【KWDB 创作者筹划】技术解读：多模架构、高效时序数据处理与分布式实现

在当今数据爆炸的期间，数据库技术的发展日新月异，尤其是对于能够适应复杂多样数据场景的数据库需求愈发猛烈。KWDB作为一款面向AIoT场景的分布式多模数据库，凭借其独特的多模架构、高效的时序数据处理能力以及强大的分布式特性，在众多数据库产物中脱颖而出。
本文基于 KWDB 的源码，剖析其核心架构设计和关键技术实现，重点探讨以下三个技术亮点：

• 多模架构设计：支持多种数据模型的机动架构。
  
• 高效的时序数据处理：针对时序特性的优化技术。
  
• 分布式实现流程：数据分片、存储和查询的分布式设计。
  

一、多模架构

1.1 架构概述

KWDB的多模架构允许在同一实例中同时创建时序库和关系库，并融合处理多模数据。这种架构设计的上风在于能够满意不同类型数据的存储和处理需求，为企业提供一站式的数据解决方案。
1.2 源码分析

固然在提供的源码中没有直接体现多模架构的核心代码，但从整体架构设计可以推测，KWDB需要在底层对不同类型的数据进行区分和管理。比方，在SQL执行层面，可能会有不同的处理逻辑来处理时序数据和关系数据。在KWDB/kwbase/pkg/sql目次下的相关代码，如buffer.go和delayed.go，可以看出对不同类型数据的处理逻辑有所不同。

1. // KWDB/kwbase/pkg/sql/buffer.go
2. // bufferNode consumes its input one row at a time, stores it in the buffer,
3. // and passes the row through. The buffered rows can be iterated over multiple
4. // times.
5. type bufferNode struct {
6.     plan planNode
8.     // TODO(yuzefovich): the buffer should probably be backed by disk. If so, the
9.     // comments about TempStorage suggest that it should be used by DistSQL
10.     // processors, but this node is local.
11.     bufferedRows       *rowcontainer.RowContainer
12.     passThruNextRowIdx int
14.     // label is a string used to describe the node in an EXPLAIN plan.
15.     label string
16. }

复制代码

从bufferNode结构体的界说可以看出，它用于存储和处理数据行，不同类型的数据可能会有不同的存储和处理方式。比方，时序数据可能需要按照时间顺序进行存储和索引，而关系数据则可能更注意表结构和关联关系。
在KWDB/kwbase/pkg/sql/opt/memo/memo.go中界说的MultimodelHelper结构体，可能与多模数据的处理设置有关。代码如下：

1. // configurations for multiple model processing.
2. type MultimodelHelper struct {
3.     AggNotPushDown []bool
4.     HashTagScan    bool
5.     HasLastAgg     bool
6.     IsUnion        bool
7.     JoinRelations  JoinRelations
8.     PlanMode       []PlanMode
9.     PreGroupInfos  []PreGroupInfo
10.     ResetReasons   map[MultiModelResetReason]struct{}
11.     TableData      sync.Map
12.     TableGroup     [][]opt.TableID
13. }

复制代码

该结构体可能用于存储和管理多模数据处理的相关设置信息，为不同类型数据的处理提供支持。
1.3 实现流程

• 数据辨认：在数据写入时，KWDB需要辨认数据的类型，是时序数据照旧关系数据。
  
• 存储分配：根据数据类型，将数据分配到不同的存储模块中，比方时序数据可能存储在专门的时序存储引擎中，而关系数据则存储在关系数据库中。
  
• 查询处理：在查询时，根据查询的类型和数据类型，选择合适的处理逻辑进行查询。
  

二、高效时序数据处理

2.1 处理能力概述

KWDB具备千万级设备接入、百万级数据秒级写入、亿级数据秒级读取等时序数据高效处理能力。这得益于其先进的时序数据存储和索引技术。
2.2 源码分析

在KWDB/qa/stress_tests/kwdbts-bench2/src/worker/statistics.h文件中，我们可以看到一些与时序数据统计相关的代码。

1. // KWDB/qa/stress_tests/kwdbts-bench2/src/worker/statistics.h
2. struct Statistics {
3.     // append Statistics
4.     AvgStat db_append_t;
5.     AvgStat table_append_t;
7.     // Number and time of data blocks written by the flush thread per loop
8.     AvgStat flush_time;
9.     AvgStat flush_blocks;
11.     // Size and time required to write data to a partition file
12.     AvgStat file_write_time;
13.     AvgStat file_write_size;
14.     AvgStat key_write_size;
16.     // The number and time of data blocks read each time according to [from,to]
17.     AvgStat block_find_num;
18.     AvgStat block_find_time;
20.     double WriteGB() {
21.         return file_write_size.sum() / KB / KB / KB;
22.     }
24.     double IoMB() {
25.         double sum_size = file_write_size.sum() / KB / KB; // MB
26.         double sum_time = file_write_time.sum() / Second; // second
27.         return sum_size / sum_time;
28.     }
30.     void Show() {
31.         fprintf(stdout, "*******Statistics Print******\n"
32.                         " DB Append =%.2f ns, table append=%.2f ns\n",
33.                 db_append_t.avg(), table_append_t.avg());
34.         fflush(stdout);
35.     }
37.     void Reset() {
38.         db_append_t.reset();
39.         table_append_t.reset();
40.         flush_time.reset();
41.         flush_blocks.reset();
42.         file_write_time.reset();
43.         file_write_time.reset();
44.         block_find_num.reset();
45.         block_find_time.reset();
46.     }
47. };

复制代码

从Statistics结构体可以看出，KWDB对时序数据的写入和读取进行了具体的统计，包括写入时间、写入大小、读取时间等。这些统计信息可以资助优化时序数据的处理性能。
在KWDB/kwdbts2/mmap/src/mmap/mmap_partition_table.cpp中的TsTimePartition::RedoPut函数，负责处理时序数据的写入和存储。代码如下：

1. int TsTimePartition::RedoPut(kwdbts::kwdbContext_p ctx, uint32_t entity_id, kwdbts::TS_LSN lsn,
2.                              uint64_t start_row, size_t num, kwdbts::Payload* payload,
3.                              std::vector<BlockSpan>* alloc_spans, std::vector<MetricRowID>* todo_markdel,
4.                              std::unordered_map<KTimestamp, MetricRowID>* partition_ts_map, KTimestamp p_time,
5.                              ErrorInfo& err_info) {
6.     // 代码实现部分
7. }

复制代码

该函数包含了数据写入前的查抄、数据空间分配、去重处理、数据写入等操作，体现了高效时序数据处理的流程。
2.3 实现流程

• 数据写入：采用高效的写入算法，将大量的时序数据快速写入到存储体系中。比方，可能会采用批量写入、异步写入等方式提高写入性能。
  
• 数据存储：利用专门的时序存储引擎，对时序数据进行高效的存储和索引。比方，可能会采用时间分区、压缩存储等技术减少存储空间和提高读取性能。
  
• 数据读取：根据查询条件，快速定位和读取所需的时序数据。比方，可能会采用索引加速、预取等技术提高读取速度。
  

三、分布式实现

3.1 分布式特性概述

KWDB作为分布式数据库，具备分布式存储、分布式查询等特性，能够实现数据的高可用和负载均衡。
3.2 源码分析

在KWDB/kwbase/pkg/cmd/roachtest/tpchbench.go文件中，我们可以看到一些与分布式测试相关的代码。

1. // KWDB/kwbase/pkg/cmd/roachtest/tpchbench.go
2. // runTPCHBench runs sets of queries against CockroachDB clusters in different
3. // configurations.
4. //
5. // In order to run a benchmark, a TPC-H dataset must first be loaded. To reuse
6. // this data across runs, it is recommended to use a combination of
7. // `--cluster=<cluster>` and `--wipe=false` flags to limit the loading phase to
8. // the first run.
9. //
10. // This benchmark runs with a single load generator node running a single
11. // worker.
12. func runTPCHBench(ctx context.Context, t *test, c *cluster, b tpchBenchSpec) {
13.     roachNodes := c.Range(1, c.spec.NodeCount-1)
14.     loadNode := c.Node(c.spec.NodeCount)
16.     t.Status("copying binaries")
17.     c.Put(ctx, kwbase, "./kwbase", roachNodes)
18.     c.Put(ctx, workload, "./workload", loadNode)
20.     filename := b.benchType
21.     t.Status(fmt.Sprintf("downloading %s query file from %s", filename, b.url))
22.     if err := c.RunE(ctx, loadNode, fmt.Sprintf("curl %s > %s", b.url, filename)); err != nil {
23.         t.Fatal(err)
24.     }
26.     t.Status("starting nodes")
27.     c.Start(ctx, t, roachNodes)
29.     m := newMonitor(ctx, c, roachNodes)
30.     m.Go(func(ctx context.Context) error {
31.         t.Status("setting up dataset")
32.         err := loadTPCHDataset(ctx, t, c, b.ScaleFactor, m, roachNodes)
33.         if err != nil {
34.             return err
35.         }
37.         t.l.Printf("running %s benchmark on tpch scale-factor=%d", filename, b.ScaleFactor)
39.         numQueries, err := getNumQueriesInFile(filename, b.url)
40.         if err != nil {
41.             t.Fatal(err)
42.         }
43.         // maxOps flag will allow us to exit the workload once all the queries were
44.         // run b.numRunsPerQuery number of times.
45.         maxOps := b.numRunsPerQuery * numQueries
47.         // Run with only one worker to get best-case single-query performance.
48.         cmd := fmt.Sprintf(
49.             "./workload run querybench --db=tpch --concurrency=1 --query-file=%s "+
50.                 "--num-runs=%d --max-ops=%d {pgurl%s} "+
51.                 "--histograms="+perfArtifactsDir+"/stats.json --histograms-max-latency=%s",
52.             filename,
53.             b.numRunsPerQuery,
54.             maxOps,
55.             roachNodes,
56.             b.maxLatency.String(),
57.         )
58.         if err := c.RunE(ctx, loadNode, cmd); err != nil {
59.             t.Fatal(err)
60.         }
61.         return nil
62.     })
63.     m.Wait()
64. }

复制代码

从runTPCHBench函数可以看出，KWDB通过分布式集群进行测试，涉及到节点的启动、数据的加载、查询的执行等操作。这表明KWDB在分布式环境下能够和谐多个节点进行数据处理。
在KWDB/kwbase/pkg/cmd/allocsim/configs/multiple-nodes-per-locality-imbalanced-load.json文件中，界说了分布式节点的设置信息，包括节点数量、工作负载和节点之间的延迟等。代码如下：

1. {
2.     "Localities": [
3.         {
4.             "Name": "1",
5.             "NumNodes": 3,
6.             "NumWorkers": 0,
7.             "OutgoingLatencies": [
8.                 {
9.                     "Name": "2",
10.                     "Latency": "50ms"
11.                 },
12.                 {
13.                     "Name": "3",
14.                     "Latency": "50ms"
15.                 }
16.             ]
17.         },
18.         // 其他节点配置
19.     ]
20. }

复制代码

该设置文件为数据分片和节点通讯提供了基础信息，有助于实现分布式存储和查询。
3.3 实现流程

• 数据分片：将数据按照一定的规则进行分片，分布到不同的节点上存储。比方，可能会按照时间、地区等因素进行分片。
  
• 节点通讯：各个节点之间通过网络进行通讯，实现数据的同步和和谐。比方，可能会采用分布式同等性协议（如Raft）来包管数据的同等性。
  
• 查询路由：在查询时，根据查询条件将查询请求路由到合适的节点上进行处理。比方，可能会采用查询优化器来选择最优的查询路径。
  

四、总结

多模架构使得KWDB能够适应不同类型的数据需求，高效时序数据处理能力包管了在海量时序数据场景下的高性能，分布式特性则提供了数据的高可用和负载均衡。这些技术亮点使得KWDB在AIoT等范畴具有广阔的应用前景。未来，我们可以进一步关注KWDB的发展，期待它在数据库技术范畴取得更大的突破。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告