数据库，我们该如何选型？

更多内容关注微信公众号：fullstack888

影响数据库选择的因素

• 数据量：是否海量数据，单表数据量太大会考验数据库的性能

• 数据结构：结构化 (每条记录的结构都一样) 还是非结构化的 (不同记录的结构可以不一样)

• 是否宽表：一条记录是 10 个域，还是成百上千个域

• 数据属性：是基本数据 (比如用户信息)、业务数据 (比如用户行为)、辅助数据 (比如日志)、缓存数据

• 是否要求事务性：一个事务由多个操作组成，必须全部成功或全部回滚，不允许部分成功

• 实时性：对写延迟，或读延迟有没有要求，比如有的业务允许写延迟高但要求读延迟低

• 查询量：比如有的业务要求查询大量记录的少数列，有的要求查询少数记录的所有列

• 排序要求：比如有的业务是针对时间序列操作的

• 可靠性要求：对数据丢失的容忍度

• 一致性要求：是否要求读到的一定是最新写入的数据

• 对增删查改的要求：有的业务要能快速的对单条数据做增删查改 (比如用户信息)，有的要求批量导入，有的不需要修改删除单条记录 (比如日志、用户行为)，有的要求检索少量数据 (比如日志)，有的要求快速读取大量数据 (比如展示报表)，有的要求大量读取并计算数据 (比如分析用户行为)

• 是否需要支持多表操作

不同的业务对数据库有不同的要求

SQL 数据库 & NoSQL 数据库

SQL 数据库就是传统的关系型数据库

• 行列式表存储

• 结构化数据

• 需要预定义数据类型

• 数据量和查询量都不大，如果数据量大要做分表

• 对数据一致性、完整性约束、事务性、可靠性要求比较高

• 支持多表 Join 操作

• 支持多表间的完整性，要删除 A 表的某条数据，可能需要先删除 B 表的某些数据

• SQL 的增删改查功能强

• 较为通用，技术比较成熟

• 大数据量性能不足

• 高并发性能不足

• 无法应用于非结构化数据

• 扩展困难

常用的 SQL 数据库比如 Oracle、MySQL、PostgreSQL、SQLite

NoSQL 泛指非关系型数据库

• 表结构较灵活，比如列存储，键值对存储，文档存储，图形存储

• 支持非结构化数据

• 有的不需要预定义数据类型，有的甚至不需要预定义表

• 支持大数据量

• 多数都支持分布式

• 扩展性好

• 基本查询能力，高并发能力比较强 (因为采用非结构化、分布式，并牺牲一致性、完整性、事务性等功能)

• 对数据一致性要求比较低

• 通常不支持事务性，或是有限支持

• 通常不支持完整性，复杂业务场景支持较差

• 通常不支持多表 Join，或是有限支持

• 非 SQL 查询语言，或类 SQL 查询语言，但功能都比较弱，有的甚至不支持修改删除数据

• 不是很通用，技术多样，市场变化比较大

常用的 NoSQL 数据库比如

• 列式：HBase、Cassandra、ClickHouse

• 键值：Redis、Memcached

• 文档：MongoDB

• 时序：InfluxDB、Prometheus

• 搜索：Elasticsearch

SQL 和 NoSQL 是一个互补的关系，应用在不同的场景中

OLTP & OLAP

OLTP (On-Line Transaction Processing)

• 主要做实时事务处理

• 比如处理用户基本信息、处理订单合同、处理银行转账业务、企业的 ERP 系统和 OA 系统，等等

• 频繁地，对少量数据，甚至是单条数据，做实时的增删改查

• 数据库经常更新

• 通常对规范化、实时性、稳定性、事务性、一致性、完整性等有要求

• 操作较为固定，比如订单业务，可能永远就那几个固定的操作

• 数据库主要模型是 3NF 或 BCNF 模型

OLAP (On-Line Analytical Processing)

• 数据仓库，主要做历史数据分析，为商业决策提供支持

• 比如对大量的用户行为做分析，对设备的状态、使用率、性能做分析

• 频率较低地，对大量数据，做读取、聚合、计算、分析，实时性要求不高，对吞吐能力要求较高

• 通常列的数量比较多，但每次分析的时候只取少部分列的数据

• 通常是批量导入数据

• 通常数据导入后不会修改，主要是读取操作，写少读多

• 通常对规范化、事务性、一致性、完整性等要求较低，甚至一个查询操作失败了也不会有什么影响

• 操作较为灵活，比如一个海量用户行为数据表，可以想出许多不同的方法，从不同的角度对用户做分析

• 数据库主要是星型、雪花模型

• 不使用高性能的 OLAP 之前，更传统的做法是通过离线业务构建 T+1 的离线数据，比较滞后

OLTP 通常用传统的关系数据库，如果数据量大要分表，对事务性、一致性、完整性等要求不高的话也可以用 NoSQL
OLAP 通常用 NoSQL，数据量不大的话也可以用传统的关系数据库

关系型数据库 Oracle、SQL Server、MySQL、PostgreSQL、SQLite

• Oracle：甲骨文开发的商业数据库，不开源，支持所有主流平台，性能好，功能强，稳定性好，安全性好，支持大数据量，比较复杂，收费昂贵

• SQL Server：微软开发的商业数据库，只能在 Windows 运行

• MySQL：甲骨文拥有的开源数据库，支持多种操作系统，体积小，功能弱些，简单的操作性能好，复杂的操作性能差些

• PostgreSQL：使用 BSD 协议的完全开源免费的项目，支持多种操作系统，功能更强大，可以和多种开源工具配合

• SQLite：开源、轻型、无服务器、零配置，一个数据库就只是一个文件，在应用程序内执行操作，占用资源小，可用于嵌入式或小型应用

Oracle 多用于银行等高要求的领域，要求不高的比如互联网行业多用 MySQL 和 PostgreSQL，而 SQLite 用于嵌入式或作为应用程序内的数据库使用，SQL Server 用于 Window 服务器

HBase (宽表、列式存储、键值对存储、NoSQL、OLTP)

• 基于 Hadoop 的 HDFS 分布式文件系统

• 分布式数据库，需要 ZooKeeper 作为节点间的协调器

• 支持宽表，支持非结构化数据，不需要预定义列和数据类型

• 列式存储，每个 HFile 文件只存储一个列族的数据，一个列族可以有多个 HFile，而 HFile 内部按 Key-Value 格式存储，其中 Key 是 rowkey, column family, column, timestamp 的组合并且按 rowkey 在 HFile 中按序存储，而 value 就是 Column Cell 的值

• 支持海量数据 (千亿级数据表)

• 数据先写入内存，达到阀值再写入磁盘，性能好，占用内存大

• 不支持 SQL，不支持 Join，有自己专用的语句，支持增删改查

• 自动分区、负载均衡、可线性扩展

• 自动故障迁移

• 强一致性 (每个分区 Region 只由一个 Region Server 负责，容易实现强一致性)

• CP 模型 (不保证可用性，每个 Region 只由一个 Region Server 负责，Server 挂了得做迁移导致暂时不可用)

• 不支持事务、二级索引

组件比较多，比较重，适用于已有的 Hadoop 平台，适用于海量宽表数据、需要增删改查、OLTP 的场景

Phoenix (基于 HBase 的数据库引擎、关系型、OLTP)

• 嵌入到 HBase 的 Region Server 的数据库引擎

• 支持 SQL

• 支持 Join

• 支持事务 (需要在定义表的时候配置)

• 支持二级索引

• 支持撒盐

• 支持 JDBC

用于强化 HBase，主要作为 OLTP，查询性能要求不高的话也可作为 OLAP，多用于 HDP (HDP 有集成 Phoenix)

Cassandra (宽表、键值对存储、NoSQL、OLTP)

• 无单点故障：Cassandra 节点按环形排列，没有中心节点，每个节点独立互联地扮演相同角色，每个节点都可以接受读写请求，数据可以有多个副本存储在多个节点，节点之间通过 Gossip (P2P) 协议交换状态信息，集群中有若干节点配为种子节点，用于新加入的节点获取集群拓扑结构并启动 Gossip 协议

• 提供类 SQL 语言 CQL

• 适合结构化、非结构化数据

• Table 需要定义 Partition Key、Clustering Key、以及普通列，其中 Partition Key 用于分区和排序，即按照 Partition Key 的 Hash Token 决定了数据被分配到哪个节点，并且在节点内也是按该 Hash Token 按序存储的，有相同 Partition Key 的数据会存在一起，并且按照 Clustering Key 排序存储，有点类似于 HBase 的 RowKey、ColumnFamily、Column，不过 HBase 是相同 CF 存一起，内部再按 RowKey 排序存储，再取 Column 值 (Column 值不排序)，而 Cassandra 是先按 Partition Key 的 Token 排序存储，内部再按 Clustering 排序存储，再取普通 Column 的值 (Column 值不排序)

• 高度可扩展，允许添加硬件、节点以提高数据容量，同时保持快速的响应时间

• 通过 Consistency 命令可以配置一致性级别，主要是通知客户端操作前，必须确保的 replica 的成功数量

• Cassandra 采用的是最终一致性，是 CAP 理论里的 AP

• Cassandra 不支持 Join 和子查询

主要用于 OLTP，要求不高的话也可以作为 OLAP 使用，和 HBase 比需要的组件比较少，维护比较容易

Redis (基于内存的 Key-Value 的 NoSQL 数据库，OLTP)

• 由 C 语言编写

• 支持多种数据类型如 strings，hashes，lists，sets，sorted sets，bitmaps，hyperloglogs，geospatial 等

• 操作原子性，保证了两个客户端同时访问服务器将获得更新后的值

• 数据存储在内存中

• 可以配置持久化，周期性的把更新数据写入磁盘，或周期性地把修改操作写入追加记录文件，也可以关闭持久化功能，将 Redis 作为一个高效的网络缓存数据功能使用

• 支持主从同步，数据可以从主服务器向任意数量的从服务器同步，从服务器可以是关联其他从服务器的主服务器，这使得 Redis 可执行单层树复制，存盘可以有意无意的对数据进行写操作，由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录，同步对读取操作的可扩展性和数据冗余很有帮助

• 支持消息的发布/订阅（Pub/Sub）模式

• 单线程模式，即网络 IO、数据读写，都由一个线程完成，正因为如此保证了原子性、稳定性、代码容易维护，之所以单线程不影响性能，是因为数据都在内存，操作本来就高效，当然这里的单线程指网络 IO、数据读写这个主功能，实际上还有其他线程，比如周期性写入硬盘的线程

• 高版本在网络 IO 这块使用了多线程 (因为在高并发操作时，网络 IO 成为了瓶颈)，但读写操作还是单线程 (操作内存数据性能还是非常高的，能应付高并发场景)

通常作为高性能内存数据库、缓存、消息中间件等使用

memcached (基于内存的 Key-Value 的 NoSQL 数据库，OLTP)

• 开源、高性能、分布式的基于内存的 Key-Value 数据存储，作用类似于 Redis

• 存储 String/RawData，不定义数据结构 (Redis 有 hash、list、set 等多种结构)

• 数据通常由 key，flags，expire time，bytes，value 组成

• 服务端基本上只能简单的读写数据，服务端能支持的操作比较少

• 包含 Server 组件和 Client 组件，可以有多个 server 但 server 之间是独立的，没有同步广播等机制，需要选择哪个 server 由 client 的 API 决定的

• 数据只在内存，不会落到硬盘

• 没有安全机制

• 协议简单性能高效

memcached 比较简单，作为纯粹的 Key-Value 缓存性能会比 Redis 好些，但功能没有 Redis 强大

MongoDB (文档数据库，NoSQL，OLTP)

• 之所以说是文档数据库，是因为它的数据是以 JSON 文档的形式存储

• MongoDB 的概念和很多数据库不一样，它的 collection 相当于表，document 相当于行，field 相当于列

比如

db.user.insert(
    {
        "name": "Lin",
        "age": 30
        "address": {
            "street": "Zhongshan Road",
            "city": "Guangzhou",
            "zip": 510000
        },
        "hobbies": ["surfing", "coding"]
    }
)

这是一条插入语句，这里的 db 是指当前数据库，user 就是 collection 相当于表，insert 语句里面的 JSON 就是 document 相当于其他数据库的行，name，age，street 这些就是 field 相当于列

相同的文档可以插入多次而不会被覆盖，实际上 mongodb 会自动创建 _id 字段作为 primary key，并分配不同的数值，所以不会重复，也可以 insert 的时候指定 _id，但如果 _id 已经存在则会报错

• 可以看到，mongodb 是非结构化数据，不需要预定义 collection，也不需要预定义数据结构

• 提供丰富的查询表达式

• 支持二级索引，自动负载平衡，读效率比写高

• 支持分布式、支持故障恢复、数据冗余、分片、水平扩展

• 可以配置存储引擎，WiredTiger Storage Engine (默认) 会做内存到文件的映射以提高性能，但内存消耗大，In-Memory Storage Engine (企业版支持) 只存在内存，不会落盘

• 高版本支持 Join，支持事务

• 支持安全认证功能

• 提供扩展，比如实现可视化的工具，实现 BI 集成的工具

mongodb 更适用于高度非结构化，或者源数据就是 JSON，每条数据比较大，以 OLTP 为主的场景，不适合于事务要求比较高，或比较复杂的大数据量的查询的场景，另外由于 mongodb 的语法和其他数据库差异比较大，需要一定的学习成本

Hive (基于 HDFS 的数据库引擎、关系型、OLAP)

• Hive 是基于 Hadoop 的一个数据仓库工具

• 数据存储在 HDFS，创建表的时候要通过 STORED AS 命令指定存储格式比如 TEXTFILE、ORCFILE、PARQUET，也可以通过 STORED BY 命令指定为 HBase，可以创建新表也可以创建已有 HBase 表的映射

• 查询通过 MapReduce、Spark 等作业完成

• 提供了类 SQL 查询语言 HQL (HiveQL)，支持用户定义函数 (UDF)

• 高版本支持事务 (需要创建表时指定)

• 支持海量数据

• 结构化数据

• 支持增删改查

不适合于 OLTP，主要作为 OLAP 用于大数据批量查询使用，需要有 Hadoop 平台

Impala (基于 HDFS、HBase、Kudu 存储，并行计算，关系型，OLAP)

• Cloudera 开发的基于内存的分布式并行计算的数据库查询引擎

• 主要由 C++ 实现，和 Hadoop 的交互使用 JNI

• Impala 使用和 Hive 一样的 metadata、SQL、ODBC driver、UI，这样在提高了 HDFS 的 SQL 查询性能的同时，又提供了相似的用户使用体验

• 和 Hive 一样可以通过 STORED AS 指定 HDFS 的存储格式比如 TEXTFILE、ORCFILE、PARQUET

• 通过 Hive 操作的表，需要手动同步到 Impala

• Impala 不仅 SQL 和 Hive 一样，实际上元数据也存在 Hive 中

• 表数据除了 HDFS，也可以存储到 HBase，但需要在 HBase 建表，然后在 Hive 通过 STORED BY 建立映射表，由于 Impala 和 Hive 使用一样的 metadata，在 Hive 建好表后，只要在 Impala 执行刷新命令 INVALIDATE METADATA，就可以看到对应的 HBase 表

• 支持 Join、Aggregate 等功能

• 支持 JDBC、ODBC

• 和 Hive 不同，Impala 不依赖于 MapReduce，而是在每个 HDFS DataNode 上运行自己的引擎实现并行处理

• Impala 的并行处理引擎主要由 state store、catalog service、多个 impala daemon 组成

• 每个 impala daemon 都可以接收 client 的请求，impala daemon 由 query planner、query coordinator、query executor 组成，planner 接收 client 的 SQL 查询，然后分解为多个子查询，由 coordinator 将子查询分发到各个 daemon 的 executor 执行，daemon 获取 HDFS、HBase 数据、计算、然后返回给 coordinator，然后由 coordinator 聚合后将最终结果返回给 client

• Impala 是无中心结构，每个 daemon 都可以接受连接查询，可以通过 HA Proxy 实现多个 daemon 的负载均衡

• state store 用于收集监控各个 daemon 的状态

• catalog service 将 SQL 做出的元数据变化通知给集群中所有的 impala daemon

• Impala 的计算都在内存进行，对内存要求比较高

• Impala 在 2.8 以后才支持 update 操作，但是只限于 Kudu 存储，需要安装 Kudu，并通过 STORED AS 指定 Kudu 作为数据库的存储，Kudu 是 Cloudera 开发的列式存储管理器，目的是做 OLAP，并且平衡 HDFS 和 HBase 的性能，Kude 的随机读写性能比 HDFS（比如 Parquet）好，但是比 HBase 差，而大数据量查询性能比 HDFS（比如 Parquet）差，但比 HBase 好，Kude 和 Impala 高度集成，也可以和 MapReduce/Spark 集成，用 Kudu 替换 HDFS/HBase 这样 Impala 就可以做 update，兼顾 OLAP 和改数据的需求，适合于以 OLAP 为主又有一定的 Update 需求的场景，Kudu 可以配置一致性，采用结构化表数据模型，需要定义主键，不使用 HDFS 而是有自己的组件存储和管理数据, 采用 c++ 没有 full gc 风险

Impala 不适合于 OLTP，主要作为 OLAP 用于大数据批量查询使用
需要有 Hadoop 平台和 Hive
性能比 Hive 好很多
作为 OLAP 的性能比 Phoenix 之类的好
主要是 CDH 在推，CDH 有集成 Impala

Presto (基于多种数据源，并行计算，关系型，OLAP)

• Facebook 推出的基于内存的分布式并行计算的数据库查询引擎

• 由 coordinator server、discovery server (通常集成在 coordinator 里，也可以独立)、多个 worker server 组成

• coordinator 负责与 client 交互，负责管理 worker，负责解析 statement、规划 query、创建一系列的 stage、再转换成一系列的 task 分发到不同 worker 并发执行

• worker 负责执行 task 和处理数据，会通过 connector 获取数据，和其他 worker 交互中间数据，最终结果会由 coordinator 返回给 client

• connector 是适配器，使得 Presto 可以访问不同的数据库

• 内建的 connector 主要是 Hive，此外有很多三方开发的 connector 比如 cassandra、es、kafka、kudu、redis、mysql、postgresql 等等

• 需要在配置文件配置 catalog，这里 catalog 维护 schema 并通过 connector 指向一个数据源，定位 presto 表都是从 catalog 开始的，比如 hive.test_data.test 指的是 hive catalog 下的 test_data schema 下面的 test 表，而 schema 的概念则依赖于具体的 connector，比如对于 mysql 而言，presto 的 schema 就是 mysql 的 schema，而对于 cassandra 而言，presto 的 schema 就是 cassandra 的 keyspace，可以建立多个 catalog 关联同一个 connector 比如环境里有多个 kafka 集群那可以有 kafka1 和 kafka2 两个 catalog

• statement 可以认为就是 presto 收到的 sql 语句，然后会解析成 query plan，然后 query 又被分为多个 stages，这些 stages 组成一个树的结构，每个 stage 会聚合计算它下面的其他 stages 的结果，每个 stage 又分为一个或多个 tasks，这些 task 会分发到不同的 worker 并行执行，每个 task 处理不同的数据分片，每个 task 又有一个或多个 driver 并发处理数据

• Presto 支持 JDBC 接口，JDBC 的 URL 格式为 jdbc:presto://host:port/catalog/schema 或 jdbc:presto://host:port/catalog 或 jdbc:presto://host:port

• 支持 Join 查询，并且支持多数据源的 join 查询 (多张大表的 join 可能会影响性能)，跨数据源查询的时候需要指定完整的表名即 [catalog].[schema].[table]，并且使用 presto://host:port 连接 JDBC，不指定 catalog 和 schema

• 有限支持子查询

• 不支持 update 操作

• 支持安全机制

• 支持标准的 ANSI SQL

• 扩展性好

• 可以和 Tableau 集成

• 支持 Spark

适合有多种数据源的大数据量的 OLAP 查询
性能和 Impala 可能差不多，但支持多种数据源，不依赖 Hadoop

Greenplum (基于多个 PostgreSQL，并行计算，关系型，OLAP)

• 基于多个 PostgreSQL 的分布式并行计算的数据库查询引擎

• 内部的 PostgreSQL 有做改动以适应并行分布式计算

• 主要由一个 master、多个 segments、一个 interconnect 组成

• master 维护元数据，接收并认证 client 的链接，接收 SQL 请求，解析 SQL，生成 query plan，并将任务分发到 segments，协调聚合 segments 的返回结果，并将最终结果返回给 client，可以设置 master 为主从配置

• 每个 segment 有个独立的 PostgreSQL 数据库，每个 segment 负责存储部分数据，并执行相应的查询计算，segment 也可以配置备份机制

• Interconnect 是 Greenplum 的网络层，负责 master 和 segment 的链接，以及各个 segment 之间的链接

• 链接和 SQL 语法都和 PostgreSQL 兼容，支持 JDBC、ODBC

• 创建表时可以指定是用列存储、行存储、外部表 (数据在其他系统比如 HDFS 而 GP 只存储元数据)

• 操作外部数据，需要安装 PXF (Platform Extension Framework)，有了 PXF 可以支持 Hive、HBase、Parquet、S3、MySQL、ORACLE 等等

• 支持安全、权限配置

• 支持分布式事务，支持 ACID，保证数据的强一致性，不是使用锁，而是使用 MVCC (Multi-Version Concurrency Control) 来保证数据一致性

• shared-nothing 架构

和 Impala、Presto 类似都是并行内存计算，但 Greenplum 性能可能稍差一点点，并且 Greenplum 还分开源版和商业版，有的功能只有商业版才支持

Kylin (基于 Hive、HBase，并行计算，关系型，多维度、预计算 OLAP)

传统 OLAP 根据数据存储方式的不同分为 ROLAP（Relational OLAP）以及 MOLAP（Multi-Dimension OLAP），ROLAP 以关系模型的方式存储数据，优点在于体积小，查询方式灵活，缺点是每次查询都需要对数据进行聚合计算，而 Kylin 属于 MOLAP

Kylin 将数据按维度的不同组合，提前计算好结果，形成 Cube (立方体) 结构，这样查询速度快，缺点是数据量不容易控制，N 个维度可以有 2**N 种组合，可能会出现维度爆炸的问题，而且数据有改动的话需要重新计算

比如有 Phone 和 Country 两张维度表，以及 Sale 事实表 (明细表)，取手机品牌、国家、日期作为三个维度，有 (null)、(品牌)、(国家)、(日期)、(品牌、国家)、(品牌、日期)、(国家、日期)、(品牌、国家、日期) 共 8 种组合，可以提前计算好这 8 种 group by 组合的 sale 的各种汇总信息 (sum、count 等)，一个维度组合的一个汇总信息称为一个 cuboid，所有的 cuboid 合起来就被称为一个 Cube

Kylin 的数据源可以是 Hive 或 Kafka (Json 格式消息，key 就是列名)

Kylin 的预计算结果存到 HBase，RowKey 就是各种维度的组合，相应的明细汇总存在 Column 中，这样 SQL 就变成对 RowKey 的扫描，并进一步的对 Column 计算 (如果需要的话)，这样查询性能自然就提升了，可以支持亚秒级查询

Kylin 支持 ODBC，JDBC，RESTful API 等接口

Kylin 可以和 Tableau、PowerBI 等 BI 工具集成

使用步骤如下

• 创建 Project

• 同步 Hive 表或 Kafka 表

• 创建 Data Model

  • 创建并命名 Model

  • 选择 Fact Table (事实表) 和 Lookup Table (查找表，主要是维度信息)，以及 Join 字段

  • 从 Fact Table 和 Lookup Table 中挑选维度列 (可以被 Cube 做 group by)

  • 从 Fact Table 选择指标列 (可以被 Cube 做 aggregation)

  • 从 Fact Table 选择用于日期分区的列，不需要就留空

  • 添加 Filter (可以被 Cube 用来做 Where 操作)

• 创建 Cube

  • 创建并命名 Cube，并选择要关联的 Data Model

  • 添加维度列 (必须从 Data Model 配置的维度列中选择)

  • 添加指标列 (必须从 Data Model 配置的指标列中选择)

  • 共有 8 种 aggregation 操作可以配置给指标列：SUM, MAX, MIN, COUNT, COUNT_DISTINCT, TOP_N, EXTENDED_COLUMN and PERCENTILE (如果要查 avg 实际上就是用 sum 除以 count 得出，所以这里不需要配置 avg 等可以通过预计算结果进一步计算出的操作)

• build Cube，实际是通过 MapReduce/Spark 计算，任务完成后结果会写入 HBase

• build 成功后即可直接用 SQL 查询了，实际是根据维度查 RowKey，然后把 Column 存的聚合结果取出，如果必要的话再做进一步计算

• 如果数据源有改动，需要重新 build Cube

可以看到 Kylin 是一个纯粹的 OLAP 工具，通过预计算提升查询性能，但无法及时反应出数据源的改变，预计算可能很耗时并且可能会占用大量空间，且需要和 Hadoop 集成

基于预计算的 OLAP 数据查询引擎还有 Druid

ClickHouse (列存储，向量化计算，并行计算，OLAP)

• 俄罗斯企业 Yandex 开发的 OLAP 数据库
  
  

• 列存储对于 OLAP 的好处

  • 由于 OLAP 经常是在大量数据列中检索少量列，如果采用行存储，意味着要逐行扫描，并且每行都很大，而采用列存储只需要扫描要检索的列，能减少 IO

  • 假设有的记录并没有存储要检索的列，行存储依然要扫描该记录才知道，而对于列存储则不存在这样的问题，因为没存储，自热而然就不会扫描到

  • 因为同一列的数据类型、大小比较一致，列存储更容易压缩，效率更高，进一步减少 IO

  • IO 的减少还意味着有更多数据可以被缓存到内存

• 向量化计算

  • SIMD (Single Instruction，Multiple Data，单指令流多数据流)，现在的 CPU 支持这样的功能，通过一条指令即可利用多核对一组数据 (也就是向量) 进行 CPU 层面的并发计算，适用于纯基础计算的场景，如果有判断、跳转、分支的场景则不合适

  • ClickHouse 有一个向量计算引擎，尽可能地使用 SMID 指令，批量并行地处理数据，大大提升了处理能力
    
    

• 主要由 C++ 实现

• 无中心化结构，由一个集群的 server 组成，并且每个 server 都可以接受客户端的链接查询，server 收到请求后会和其他 server 协调做并行计算，每个 server 都是多线程的，server 之间通过 ZooKeeper 协调同步
  
  

• 支持分片（shard），数据可以跨节点存储在不同分片中，一个分片就是一个节点，或者多个节点组成一个有副本备份的分片，由配置文件配置

• 支持分区，通过 Partition By 命令创建表

• 分片和分区有时候不好区分，分片更多指的是表的数据分布在不同节点，而且一个节点可以存储多个数据库、多个表的数据，而分区更多指的是按某列数据将一个大表分成多个小表，比如按日期列分区，每天一个分区表，既可以查分区表，也可以查大表

• 支持副本备份、支持数据完整性
  
  

• 表引擎（Table Engine）

  • 在某个 server 创建的表只是该 server 的本地表，不是分布式的，如果要创建分布式表，需要在每个 server 创建相同名字的表，再在其中一台 server 上创建分布式表（会自动在所有 server 上都创建），这个分布式表是个逻辑表，不真正存储数据，而是映射到各个 server 的本地表，会自动做并行计算

  • ENGINE = Distributed(cluster_name, database, table, [sharding_key])

  • cluster_name 是在配置文件里配置的
    
    

  • ENGINE = Memory 数据存在内存

  • ENGINE = ODBC(connection_settings, external_database, external_table)

  • ENGINE = JDBC(dbms_uri, external_database, external_table)

  • ENGINE = MySQL('host:port', 'database', 'table', 'user', 'password')

  • ENGINE = PostgreSQL('host:port', 'database', 'table', 'user', 'password')

  • ENGINE = MongoDB(host:port, database, collection, user, password)

  • ENGINE = HDFS(URI, format)

  • ENGINE = Kafka() SETTINGS kafka_broker_list = 'host:port', kafka_topic_list = 'topic1'

  • ENGINE = Log;

  • ENGINE = TinyLog;

  • ENGINE = MergeTree()

  • ENGINE = AggregatingMergeTree()

  • 创建表的时候要通过 Engine 命令指定要用的表引擎，决定如何存储数据

  • 最常用的是 MergeTree 系列引擎，比如

  • 比较轻量级的 Log 系列引擎

  • 允许从其他数据源查询，比如

  • 特殊类型，比如

  • 分布式

• 通常使用 MergeTree 存储，数据可以快速地按序 append 到一颗 MergeTree 的后面，后台会做合并和压缩操作，这样提升了数据插入的性能

• 主索引，数据按 Primary Key 排序

• 也可以在创建表时通过 Order By 指定排序的字段

• 支持二级索引，也叫跳数索引 data skipping index，比如 minmax 索引，会统计每一段数据内某列数据（或是某个表达式）的最大值和最小值，检索的时候可以依据 minmax 决定是否跳过这段数据（感觉比较怪，性能应该比重建一张索引表的做法要差吧）

• 支持 TTL，包括列级别、行级别、分区级别的 TTL
  
  

• 支持 HTTP、TCP 接口

• 支持 JDBC、ODBC

• 有三方工具支持将其他数据库如 PG 的数据导入 ClickHouse

• 有三方工具支持和一些可视化工具如 Grafana、DBeaver、Tabix 集成

• 有三方工具支持 Kafka、Flink、Spark 等
  
  

• 支持 SQL，支持 group by、order by、join、部分子查询等功能

• 支持 array、json、tuple、set 等复杂数据类型

• 支持近似计算，比如计算平均值，可以取部分数据计算，这样提升了性能，但降低了准度

• 自适应 Join 算法，比如优先使用 Hash-Join，如果有多张大表则自动改用 Merge-Join
  
  

• 安全机制、基于 Role 的权限控制

• 支持错误恢复、扩展性好

不足的地方

• 对高并发的支持不足

• 没有成熟的事务功能

• 修改、删除数据的性能比较差，并且仅提供有限支持

• Primary Key 是采用稀疏索引，即索引只能指向一段数据，具体的数据还得一条条查，所以如果是查少量数据，或者查询单条数据，性能会比较差

不依赖 Hadoop、列存储、向量化、并行、多线程、多存储引擎

单表查询性能极好，比 Impala、Presto 之类的要好很多

多表查询性能差些，比 Impala、Presto 之类的要差

Elasticsearch (倒索引、分词、搜索引擎)

• Elastic Stack 是一组组件包括 Elasticsearch、Logstash、Filebeat、Kibana 等

• Elasticsearch 是基于 Apache Lucene 开发的搜索引擎，主要由 Java 开发
  
  

• Elasticsearch 集群主要由 master、data、ingest、coordinating 节点组成

• 每个节点可以同时配置多种角色，比如即是 master 又是 data，但在大型集群中，通常每个节点只负担一种功能

• coordinating 是每个节点都会有的功能，不需要配置，即无论 master 还是 data 都会有 coordinating 功能，用于接收 client 的读写请求，然后将请求转发给相应节点处理，然后将处理结果合并后返回给 client，在大型集群中为了不对 master/data 等节点造成太大压力，可以配置多个专门的 coordinating，通过将 role 配置为空或是将 master、data、ingest 设置为 false (取决于不同版本) 即可，这样这些 coordinating 节点就只负责接收响应 client 请求不做其他工作，就像是一个反向代理的负载均衡一样，能提高并发性能

• master 负责管理整个集群，负责对 index 的创建删除等管理操作，决定数据要分片到哪个节点，管理其他节点的状态等等，可以配置多个 master 做 HA，需要单数个，至少要 3 个，系统实际上自动选举其中一个做 master，如果该 master 挂了，会从其他配置为 master 的节点中重新选举一个，master 的配置可以低一些

• data 负责存储、计算、处理数据，对资源要求比较高，data 还可以进一步配置，指定节点用于存储 hot data、warm data、cold data 等等

• Ingest 是可选节点，专门用于针对某些数据和操作，做流水线预处理
  
  

• Elasticsearch 的数据存储主要由 index，type，document 组成

• index 就类似于 SQL 中的一个数据库，可以直接创建 index，也可以通过 index template 作为模板创建 index，模板通常用于具有相同配置的多个 index，比如每天都建立一个 index 用于存储当天的日志

• type 就类似于 SQL 中的表 (这种说法不完全对，官方有澄清过，因为不同的 type 并不是完全独立无关的)，早期版本中，一个 index 下可以有多个 type，从 6.0 开始只能有一个 type，从 7.0 开不建议使用 type 这个概念，据说从 8.0 开始将完全不支持 type

• document 就是像是 SQL 中的一行记录，document 使用的是非结构化的数据，由 JSON 格式表示，JSON 的每个 field 就相当于一个列

• 每个 document 会一个唯一的 _id，如果不指定则由系统自动生成

• 每个 document 有严格递增的序号 _seq_no 代表文档写入/更新的先后顺序

• 每个 document 有 _version 字段，每次更改这个字段就加 1

• 可以先建立 index，也可以不提前建立 index，写入数据时自动创建

• 不需要提前设置 document 的 field，写入数据时自动创建，每个 document 的 field 可以不一样，也可以提前设置 field，使得每个 document 的 field 必须一样
  
  

• Elasticsearch 会自动对所有 field 建立索引，并且会自动做分词处理，即把一个句子比如 "hello world" 自动分成 "hello" 和 "world" 两个词做索引，没有分词的 "hello world" 是 keyword，大小限制是 256，经过分词的比如 "hello" 是一个 text

• Elasticsearch 采用倒索引 (inverted index)，主要由三部分组成：Term Index (单词索引)、Term Dictionary (单词字典)、Posting List (索引项列表)

• Term Index 存在内存中，不保存所有单词，而是保存单词的前缀，比如保存 he、wor、ad、sar 等等，指出以这些前缀作为开头的单词在 Term Dictionary 中的起始位置，这样 Term Index 的大小就比较小，可以存在内存中，并且可以帮助快速定位要读取的内容在 Term Dictionary 中的位置，可以大大减少磁盘 IO 的次数

• Term Dictionary 存在磁盘中，通常单词量会非常大，记录着 index 的每个单词到 Posting List 的关联关系，通过 B+ 树或 Hash 表方式以满足高性能的插入与查询

• Posting List 记录着：出现该单词的所有 document 的 id，该单词在该 document 中出现的次数，该单词在该 document 中的位置

• 搜索引擎通过这样的倒排序索引找到对应的 document，再做进一步处理

• 由于会对所有 field 做索引，数据量会非常大
  
  

• 数据先写入内存，然后定期将数据落盘形成一个个 segment，当 segment 多了之后会进行 merge 组成更大的 segment

• 为了防止内存中还没落盘的数据丢失，会写入 translog，类似于 HBase 的 WAL，其实这也需要磁盘 IO，会影响性能，但比落盘数据要简单

• segment 由多个文件组成，记录着元数据、field 信息、正排序的索引信息 (即从 document id 找到相应的数据)、field 数据 (相当于按列存储)、倒排序索引数据、等等

• 更多信息 https://elasticsearch.cn/article/6178
  
  

• 支持 REST API 接口操作，通过在 Body 的 JSON 格式数据提高丰富的语法，可以执行很多操作

• 支持 Event Query Language (EQL)：for event-based time series data, such as logs, metrics, and traces, 通过 REST API 的 Body 指定

• 支持 JDBC、ODBC，这里 table 指定的是 index，而 column 指定的是 field，这里的 SQL 不支持 JOIN
  
  

• 不支持事务

• 跨表查询不完全支持，而且要定义父子文档，要定义 join 类型的 field，比较复杂

• 读写有一定延时性，即写入的数据无法立刻索引到，至少要等 1 秒钟

• 和传统的数据库有一定差异，需要一定的学习成本

部分 REST API 操作的例子

curl localhost:9200                          # 查看集群基本信息
curl localhost:9200/_cluster/health?pretty   # 查看集群健康 (pretty 是 JSON 格式化输出)
curl localhost:9200/_cluster/state?pretty    # 查看集群状态
curl localhost:9200/_cluster/stats?pretty    # 查看统计信息
curl localhost:9200/_nodes?pretty            # 查看节点信息


curl localhost:9200/_cat                     # 列出可以查看的各种信息 (cat 命令列出的信息比较简化)
curl localhost:9200/_cat/health
curl localhost:9200/_cat/nodes
curl localhost:9200/_cat/indices


curl -X PUT 'http://localhost:9200/my_index/my_doc/123'  -H 'Content-Type: application/json' -d '{
  "name": "Lin", "title": "senior designer", "age": 30
}'      ## 指定 document id 为 123，会自动创建 my_index，my_doc 以及各个 fields


curl -X POST 'http://localhost:9200/my_index/my_doc'  -H 'Content-Type: application/json' -d '{
  "name": "Wang", "title": "senior designer", "age": 35
}'      ## 由系统自动创建 document id


curl -X POST 'http://localhost:9200/my_index/my_doc_2'  -H 'Content-Type: application/json' -d '{
  "name": "n_1", "type": "t_1", "value": 1
}'      ## 报错，不允许 index 下有两个 type


curl -X POST 'http://localhost:9200/my_index/_doc'  -H 'Content-Type: application/json' -d '{
  "name": "n_1", "type": "t_1", "value": 1
}'      ## 允许，_doc 就是 my_doc（可以一开始就只用 _doc 而不需要 type 名）


curl -X POST 'http://localhost:9200/my_index/_doc'  -H 'Content-Type: application/json' -d '{
  "name": "Li",
  "address": {"city": "guangzhou", "district": "tianhe"}
}'      ## 允许新的 fields，允许复杂类型，貌似不支持列表 "address": ["xxx"]


curl localhost:9200/my_index/my_doc/123?pretty        ## 查看 id 为 123 的记录
curl localhost:9200/my_index/my_doc/_search?pretty    ## 查看所有记录
curl localhost:9200/my_index/_search?pretty


curl localhost:9200/_all?pretty                   ## 列出所有 index 的设置和 mapping (就是 field 的信息)
curl localhost:9200/my_index?pretty               ## 查看 my_index 的设置和 mapping
curl localhost:9200/my_index/_mapping?pretty      ## 查看 my_index 的 mapping


curl -X GET -H "Content-Type: application/json"  localhost:9200/my_index/_search?pretty -d '{
  "query": {
     "term":{
        "name":"lin"
     }
   }
}'        ## 简单的查询，还有更多的语法和功能


curl -X GET -H "Content-Type: application/json"  localhost:9200/my_index/_search?pretty -d '{
  "query": {
     "term":{
        "title.keyword":"senior designer"
     }
   }
}'        ## 默认查询的是分词，如果要查没分词的，应该加上 keyword


curl -X GET -H "Content-Type: application/json"  localhost:9200/my_index/_search?pretty -d '{
  "query": {
     "term":{
        "address.city":"guangzhou"
     }
   }
}'        ## 查询嵌套的字段


curl localhost:9200/_search?pretty        ## 在所有 index 中查找


curl -H "Content-Type: application/json" localhost:9200/my_index/_analyze?pretty -d '{
   "analyzer" : "standard",  
   "text" : "This is the apple"
}'        ## 如何分析一段文字


curl -X PUT 'http://localhost:9200/my_index_3'    ## 创建 index


curl -X PUT -H "Content-Type: application/json" 'http://localhost:9200/my_index_6' -d  '{
    "settings": {
        "number_of_shards": 1,
        "number_of_replicas": 1
    },
    "mappings": {
        "properties": {
            "name": {
                "type": "text"
            },
            "title": {
                "type": "text"
            },
            "value": {
                "type": "long"
            }
        }
    }
}'         ## 创建 index 同时指定 field，在版本 7 以后不需要指定 type (不需要指定 my_doc 之类的)

适合于以搜索为主的业务场景，最开始 ELK (Elasticsearch + Logstash + Kibana) 就是用于日志收集和搜索

Spark/Flink

数据库虽然强大，但如果遇到复杂的逻辑计算也是无能为力，这种情况，就需要有专门的计算工具

Spark 和 Flink 都是高性能的并行计算引擎，Flink 更偏向实时流业务，Spark 更偏向批处理业务，都可以用来高效地处理数据

BI

数据通常要可视化，比较常用的 BI 工具有 Tableau (收费的) 和 PowerBI

整体系统架构

K8S (容器部署) + SpringCloud (微服务) + Keycloak (认证) + Kafka (数据流) + Spark/Flink (数据处理) + ELK (日志收集) + PG/MySQL (基本数据) + NoSQL-OLTP (大数据量业务数据) + OLAP (分析业务) + BI (数据可视化)

- END -

推荐阅读：

总结Spring事务注解@transactional无法生效的八个场景

问题定位神器 Arthas 的骚操作，定位线上BUG，超给力

（长文）Java后端从入门到放弃

如何使用PostMan进行接口测试

MySQL 索引失效的几种类型以及解决方式

Docker 容器监控系统初探

关注:fullstack888

学习架构知识

互联网后端架构