chore: import upstream snapshot with attribution

docker/examples/benchmarks/benchmarks_llm_11k_prompt.txt

@@ -0,0 +1,214 @@
+A chat between a curious user and an artificial intelligence assistant, who very familiar with database related knowledge.
+The assistant gives helpful, detailed, professional and polite answers to the user's questions.  基于以下已知的信息, 专业、简要的回答用户的问题,
+            如果无法从提供的内容中获取答案, 请说: "知识库中提供的内容不足以回答此问题" 禁止胡乱编造, 回答的时候最好按照1.2.3.点进行总结。
+            已知内容:
+
+OceanBase 数据库（OceanBase Database）是一款完全自研的企业级原生分布式数据库，在普通硬件上实现金融级高可用，首创“三地五中心”城市级故障自动无损容灾新标准，刷新 TPC-C 标准测试，单集群规模超过 1500 节点，具有云原生、强一致性、高度兼容 Oracle/MySQL 等特性。
+
+核心特性
+高可用
+独创 “三地五中心” 容灾架构方案，建立金融行业无损容灾新标准。支持同城/异地容灾，可实现多地多活，满足金融行业 6 级容灾标准（RPO=0，RTO< 8s），数据零丢失。
+高兼容
+高度兼容 Oracle 和 MySQL，覆盖绝大多数常见功能，支持过程语言、触发器等高级特性，提供自动迁移工具，支持迁移评估和反向同步以保障数据迁移安全，可支撑金融、政府、运营商等关键行业核心场景替代。
+水平扩展
+实现透明水平扩展，支持业务快速的扩容缩容，同时通过准内存处理架构实现高性能。支持集群节点超过数千个，单集群最大数据量超过 3PB，最大单表行数达万亿级。
+低成本
+基于 LSM-Tree 的高压缩引擎，存储成本降低 70% - 90%；原生支持多租户架构，同集群可为多个独立业务提供服务，租户间数据隔离，降低部署和运维成本。
+实时 HTAP
+基于“同一份数据，同一个引擎”，同时支持在线实时交易及实时分析两种场景，“一份数据”的多个副本可以存储成多种形态，用于不同工作负载，从根本上保持数据一致性。
+安全可靠
+12 年完全自主研发，代码级可控，自研单机分布式一体化架构，大规模金融核心场景 9 年可靠性验证；完备的角色权限管理体系，数据存储和通信全链路透明加密，支持国密算法，通过等保三级专项合规检测。
+深入了解 OceanBase 数据库
+您可以通过以下内容更深入地了解 OceanBase 数据库：
+
+OceanBase 使用通用服务器硬件，依赖本地存储，分布式部署使用的多个服务器也是对等的，没有特殊的硬件要求。OceanBase 的分布式数据库处理采用 Shared Nothing 架构，数据库内的 SQL 执行引擎具有分布式执行能力。
+
+OceanBase 在服务器上会运行叫做 observer 的单进程程序作为数据库的运行实例，使用本地的文件存储数据和事务 Redo 日志。
+
+OceanBase 集群部署需要配置可用区（Zone），由若干个服务器组成。可用区是一个逻辑概念，表示集群内具有相似硬件可用性的一组节点，它在不同的部署模式下代表不同的含义。例如，当整个集群部署在同一个数据中心（IDC）内的时候，一个可用区的节点可以属于同一个机架，同一个交换机等。当集群分布在多个数据中心的时候，每个可用区可以对应于一个数据中心。
+
+用户存储的数据在分布式集群内部可以存储多个副本，用于故障容灾，也可以用于分散读取压力。在一个可用区内部数据只有一个副本，不同的可用区可以存储同一个数据的多个副本，副本之间由共识协议保证数据的一致性。
+
+OceanBase 内置多租户特性，每个租户对于使用者是一个独立的数据库，一个租户能够在租户级别设置租户的分布式部署方式。租户之间 CPU、内存和 IO 都是隔离的。
+
+OceanBase的数据库实例内部由不同的组件相互协作，这些组件从底层向上由存储层、复制层、均衡层、事务层、SQL 层、接入层组成。
+
+存储层
+存储层以一张表或者一个分区为粒度提供数据存储与访问，每个分区对应一个用于存储数据的Tablet（分片），用户定义的非分区表也会对应一个 Tablet。
+
+Tablet 的内部是分层存储的结构，总共有 4 层。DML 操作插入、更新、删除等首先写入 MemTable，等到 MemTable 达到一定大小时转储到磁盘成为 L0 SSTable。L0 SSTable 个数达到阈值后会将多个 L0 SSTable 合并成一个 L1 SSTable。在每天配置的业务低峰期，系统会将所有的 MemTable、L0 SSTable 和 L1 SSTable 合并成一个 Major SSTable。
+
+每个 SSTable 内部是以 2MB 定长宏块为基本单位，每个宏块内部由多个不定长微块组成。
+
+Major SSTable 的微块会在合并过程中用编码方式进行格式转换，微块内的数据会按照列维度分别进行列内的编码，编码规则包括字典/游程/常量/差值等，每一列压缩结束后，还会进一步对多列进行列间等值/子串等规则编码。编码能对数据大幅压缩，同时提炼的列内特征信息还能进一步加速后续的查询速度。
+
+在编码压缩之后，还可以根据用户指定的通用压缩算法进行无损压缩，进一步提升数据压缩率。
+
+复制层
+复制层使用日志流（LS、Log Stream）在多副本之间同步状态。每个 Tablet 都会对应一个确定的日志流，DML 操作写入 Tablet 的数据所产生的 Redo 日志会持久化在日志流中。日志流的多个副本会分布在不同的可用区中，多个副本之间维持了共识算法，选择其中一个副本作为主副本，其他的副本皆为从副本。Tablet 的 DML 和强一致性查询只在其对应的日志流的主副本上进行。
+
+通常情况下，每个租户在每台机器上只会有一个日志流的主副本，可能存在多个其他日志流的从副本。租户的总日志流个数取决于 Primary Zone 和 Locality 的配置。
+
+日志流使用自研的 Paxos 协议将 Redo 日志在本服务器持久化，同时通过网络发送给日志流的从副本，从副本在完成各自持久化后应答主副本，主副本在确认有多数派副本都持久化成功后确认对应的 Redo 日志持久化成功。从副本利用 Redo 日志的内容实时回放，保证自己的状态与主副本一致。
+
+日志流的主副本在被选举成为主后会获得租约（Lease），正常工作的主副本在租约有效期内会不停的通过选举协议延长租约期。主副本只会在租约有效时执行主的工作，租约机制保证了数据库异常处理的能力。
+
+复制层能够自动应对服务器故障，保障数据库服务的持续可用。如果出现少于半数的从副本所在服务器出现问题，因为还有多于半数的副本正常工作，数据库的服务不受影响。如果主副本所在服务器出现问题，其租约会得不到延续，待其租约失效后，其他从副本会通过选举协议选举出新的主副本并授予新的租约，之后即可恢复数据库的服务。
+
+均衡层
+新建表和新增分区时，系统会按照均衡原则选择合适的日志流创建 Tablet。当租户的属性发生变更，新增了机器资源，或者经过长时间使用后，Tablet 在各台机器上不再均衡时，均衡层通过日志流的分裂和合并操作，并在这个过程中配合日志流副本的移动，让数据和服务在多个服务器之间再次均衡。
+
+当租户有扩容操作，获得更多服务器资源时，均衡层会将租户内已有的日志流进行分裂，并选择合适数量的 Tablet 一同分裂到新的日志流中，再将新日志流迁移到新增的服务器上，以充分利用扩容后的资源。当租户有缩容操作时，均衡层会把需要缩减的服务器上的日志流迁移到其他服务器上，并和其他服务器上已有的日志流进行合并，以缩减机器的资源占用。
+
+当数据库长期使用后，随着持续创建删除表格，并且写入更多的数据，即使没有服务器资源数量变化，原本均衡的情况可能被破坏。最常见的情况是，当用户删除了一批表格后，删除的表格可能原本聚集在某一些机器上，删除后这些机器上的 Tablet 数量就变少了，应该把其他机器的 Tablet 均衡一些到这些少的机器上。均衡层会定期生成均衡计划，将 Tablet 多的服务器上日志流分裂出临时日志流并携带需要移动的 Tablet，临时日志流迁移到目的服务器后再和目的服务器上的日志流进行合并，以达成均衡的效果。
+
+事务层
+事务层保证了单个日志流和多个日志流DML操作提交的原子性，也保证了并发事务之间的多版本隔离能力。
+
+原子性
+一个日志流上事务的修改，即使涉及多个 Tablet，通过日志流的 write-ahead log 可以保证事务提交的原子性。事务的修改涉及多个日志流时，每个日志流会产生并持久化各自的write-ahead log，事务层通过优化的两阶段提交协议来保证提交的原子性。
+
+事务层会选择一个事务修改的一个日志流产生协调者状态机，协调者会与事务修改的所有日志流通信，判断 write-ahead log 是否持久化，当所有日志流都完成持久化后，事务进入提交状态，协调者会再驱动所有日志流写下这个事务的 Commit 日志，表示事务最终的提交状态。当从副本回放或者数据库重启时，已经完成提交的事务都会通过 Commit 日志确定各自日志流事务的状态。
+
+宕机重启场景下，宕机前还未完成的事务，会出现写完 write-ahead log 但是还没有Commit 日志的情况，每个日志流的 write-ahead log 都会包含事务的所有日志流列表，通过此信息可以重新确定哪个日志流是协调者并恢复协调者的状态，再次推进两阶段状态机，直到事务最终的 Commit 或 Abort 状态。
+
+隔离性
+GTS 服务是一个租户内产生连续增长的时间戳的服务，其通过多副本保证可用性，底层机制与上面复制层所描述的日志流副本同步机制是一样的。
+
+每个事务在提交时会从 GTS 获取一个时间戳作为事务的提交版本号并持久化在日志流的write-ahead log 中，事务内所有修改的数据都以此提交版本号标记。
+
+每个语句开始时（对于 Read Committed 隔离级别）或者每个事务开始时（对于Repeatable Read 和 Serializable 隔离级别）会从 GTS 获取一个时间戳作为语句或事务的读取版本号。在读取数据时，会跳过事务版本号比读取版本号大的数据，通过这种方式为读取操作提供了统一的全局数据快照。
+
+SQL 层
+SQL 层将用户的 SQL 请求转化成对一个或多个 Tablet 的数据访问。
+
+SQL 层组件
+SQL 层处理一个请求的执行流程是：Parser、Resolver、Transformer、Optimizer、Code Generator、Executor。
+
+Parser 负责词法/语法解析，Parser 会将用户的 SQL 分成一个个的 "Token"，并根据预先设定好的语法规则解析整个请求，转换成语法树（Syntax Tree）。
+
+Resolver 负责语义解析，将根据数据库元信息将 SQL 请求中的 Token 翻译成对应的对象（例如库、表、列、索引等），生成的数据结构叫做 Statement Tree。
+
+Transformer 负责逻辑改写，根据内部的规则或代价模型，将 SQL 改写为与之等价的其他形式，并将其提供给后续的优化器做进一步的优化。Transformer 的工作方式是在原Statement Tree 上做等价变换，变换的结果仍然是一棵 Statement Tree。
+
+Optimizer（优化器）为 SQL 请求生成最佳的执行计划，需要综合考虑 SQL 请求的语义、对象数据特征、对象物理分布等多方面因素，解决访问路径选择、联接顺序选择、联接算法选择、分布式计划生成等问题，最终生成执行计划。
+
+Code Generator（代码生成器）将执行计划转换为可执行的代码，但是不做任何优化选择。
+
+Executor（执行器）启动 SQL 的执行过程。
+
+在标准的 SQL 流程之外，SQL 层还有 Plan Cache 能力，将历史的执行计划缓存在内存中，后续的执行可以反复执行这个计划，避免了重复查询优化的过程。配合 Fast-parser 模块，仅使用词法分析对文本串直接参数化，获取参数化后的文本及常量参数，让 SQL 直接命中 Plan Cache，加速频繁执行的 SQL。
+
+多种计划
+SQL 层的执行计划分为本地、远程和分布式三种。本地执行计划只访问本服务器的数据。远程执行计划只访问非本地的一台服务器的数据。分布式计划会访问超过一台服务器的数据，执行计划会分成多个子计划在多个服务器上执行。
+
+SQL 层并行化执行能力可以将执行计划分解成多个部分，由多个执行线程执行，通过一定的调度的方式，实现执行计划的并行处理。并行化执行可以充分发挥服务器 CPU 和 IO 处理能力，缩短单个查询的响应时间。并行查询技术可以用于分布式执行计划，也可以用于本地执行计划。
+
+接入层
+obproxy 是 OceanBase 数据库的接入层，负责将用户的请求转发到合适的 OceanBase 实例上进行处理。
+
+obproxy 是独立的进程实例，独立于 OceanBase 的数据库实例部署。obproxy 监听网络端口，兼容 MySQL 网络协议，支持使用 MySQL 驱动的应用直接连接 OceanBase。
+
+obproxy 能够自动发现 OceanBase 集群的数据分布信息，对于代理的每一条 SQL 语句，会尽可能识别出语句将访问的数据，并将语句直接转发到数据所在服务器的 OceanBase 实例。
+
+obproxy 有两种部署方式，一种是部署在每一个需要访问数据库的应用服务器上，另一种是部署在与 OceanBase 相同的机器上。第一种部署方式下，应用程序直接连接部署在同一台服务器上的 obproxy，所有的请求会由 obproxy 发送到合适的 OceanBase 服务器。第二种部署方式下，需要使用网络负载均衡服务将多个 obproxy 聚合成同一个对应用提供服务的入口地址。
+
+OceanBase 数据库采用 Shared-Nothing 架构，各个节点之间完全对等，每个节点都有自己的 SQL 引擎、存储引擎、事务引擎，运行在普通 PC 服务器组成的集群之上，具备高可扩展性、高可用性、高性能、低成本、与主流数据库高兼容等核心特性。
+
+OceanBase 数据库的一个集群由若干个节点组成。这些节点分属于若干个可用区（Zone），每个节点属于一个可用区。可用区是一个逻辑概念，表示集群内具有相似硬件可用性的一组节点，它在不同的部署模式下代表不同的含义。例如，当整个集群部署在同一个数据中心（IDC）内的时候，一个可用区的节点可以属于同一个机架，同一个交换机等。当集群分布在多个数据中心的时候，每个可用区可以对应于一个数据中心。每个可用区具有 IDC 和地域（Region）两个属性，描述该可用区所在的 IDC 及 IDC 所属的地域。一般地，地域指 IDC 所在的城市。可用区的 IDC 和 Region 属性需要反映部署时候的实际情况，以便集群内的自动容灾处理和优化策略能更好地工作。根据业务对数据库系统不同的高可用性需求，OceanBase 集群提供了多种部署模式，参见 高可用架构概述。
+
+在 OceanBase 数据库中，一个表的数据可以按照某种划分规则水平拆分为多个分片，每个分片叫做一个表分区，简称分区（Partition）。某行数据属于且只属于一个分区。分区的规则由用户在建表的时候指定，包括hash、range、list等类型的分区，还支持二级分区。例如，交易库中的订单表，可以先按照用户 ID 划分为若干一级分区，再按照月份把每个一级分区划分为若干二级分区。对于二级分区表，第二级的每个子分区是一个物理分区，而第一级分区只是逻辑概念。一个表的若干个分区可以分布在一个可用区内的多个节点上。每个物理分区有一个用于存储数据的存储层对象，叫做 Tablet ，用于存储有序的数据记录。
+
+当用户对 Tablet 中记录进行修改的时候，为了保证数据持久化，需要记录重做日志（REDO）到 Tablet 对应的日志流（Log Stream）里。每个日志流服务了其所在节点上的多个 Tablet。为了能够保护数据，并在节点发生故障的时候不中断服务，每个日志流及其所属的 Tablet 有多个副本。一般来说，多个副本分散在多个不同的可用区里。多个副本中有且只有一个副本接受修改操作，叫做主副本（Leader），其他副本叫做从副本（Follower）。主从副本之间通过基于 Multi-Paxos 的分布式共识协议实现了副本之间数据的一致性。当主副本所在节点发生故障的时候，一个从副本会被选举为新的主副本并继续提供服务。
+
+在集群的每个节点上会运行一个叫做 observer 的服务进程，它内部包含多个操作系统线程。节点的功能都是对等的。每个服务负责自己所在节点上分区数据的存取，也负责路由到本机的 SQL 语句的解析和执行。这些服务进程之间通过 TCP/IP 协议进行通信。同时，每个服务会监听来自外部应用的连接请求，建立连接和数据库会话，并提供数据库服务。关于 observer 服务进程的更多信息，参见 线程简介。
+
+为了简化大规模部署多个业务数据库的管理并降低资源成本，OceanBase 数据库提供了独特的多租户特性。在一个 OceanBase 集群内，可以创建很多个互相之间隔离的数据库"实例"，叫做一个租户。从应用程序的视角来看，每个租户是一个独立的数据库。不仅如此，每个租户可以选择 MySQL 或 Oracle 兼容模式。应用连接到 MySQL 租户后，可以在租户下创建用户、database，与一个独立的 MySQL 库的使用体验是一样的。同样的，应用连接到 Oracle 租户后，可以在租户下创建 schema、管理角色等，与一个独立的 Oracle 库的使用体验是一样的。一个新的集群初始化之后，就会存在一个特殊的名为 sys 的租户，叫做系统租户。系统租户中保存了集群的元数据，是一个 MySQL 兼容模式的租户。
+
+为了隔离租户的资源，每个 observer 进程内可以有多个属于不同租户的虚拟容器，叫做资源单元（UNIT）。每个租户在多个节点上的资源单元组成一个资源池。资源单元包括 CPU 和内存资源。
+
+为了使 OceanBase 数据库对应用程序屏蔽内部分区和副本分布等细节，使应用访问分布式数据库像访问单机数据库一样简单，我们提供了 obproxy 代理服务。应用程序并不会直接与 OBServer 建立连接，而是连接obproxy，然后由 obproxy 转发 SQL 请求到合适的 OBServer 节点。obproxy 是无状态的服务，多个 obproxy 节点通过网络负载均衡（SLB）对应用提供统一的网络地址。
+
+
+OceanBase 数据库是随着阿里巴巴电商业务的发展孕育而生，随着蚂蚁集团移动支付业务的发展而壮大，经过十多年各类业务的使用和打磨才终于破茧成蝶，推向了外部市场。本章节简述 OceanBase 数据库发展过程中一些里程碑意义的事件。
+
+诞生
+
+2010 年，OceanBase 创始人阳振坤博士带领初创团队启动了 OceanBase 项目。第一个应用是淘宝的收藏夹业务。如今收藏夹依然是 OceanBase 的客户。收藏夹单表数据量非常大，OceanBase 用独创的方法解决了其高并发的大表连接小表的需求。
+
+关系数据库
+
+早期的版本中，应用通过定制的 API 库访问 OceanBase 数据库。2012 年，OceanBase 数据库发布了支持 SQL 的版本，初步成为一个功能完整的通用关系数据库。
+
+初试金融业务
+
+OceanBase 进入支付宝（后来的蚂蚁集团），开始应用于金融级的业务场景。2014 年"双 11"大促活动，OceanBase 开始承担交易库部分流量。此后，新成立的网商银行把所有核心交易库都运行在 OceanBase 数据库上。
+
+金融级核心库
+
+2016 年，OceanBase 数据库发布了架构重新设计后的 1.0 版本，支持了分布式事务，提升了高并发写业务中的扩展，同时实现了多租户架构，这个整体架构延续至今。同时，到 2016 年"双 11"时，支付宝全部核心库的业务流量 100% 运行在 OceanBase 数据库上，包括交易、支付、会员和最重要的账务库。
+
+走向外部市场
+
+2017 年，OceanBase 数据库开始试点外部业务，成功应用于南京银行。
+
+商业化加速
+
+2018 年，OceanBase 数据库发布 2.0 版本，开始支持 Oracle 兼容模式。这一特性降低应用改造适配成本，在外部客户中快速推广开来。
+
+勇攀高峰
+
+2019 年，OceanBase 数据库 V2.2 版本参加代表 OLTP 数据库最权威的 TPC-C 评测，以 6000 万 tpmC 的成绩登顶世界第一。随后，在 2020 年，又以 7 亿 tpmC 刷新纪录，截止目前依然稳居第一。这充分证明了 OceanBase 数据库优秀的扩展性和稳定性。OceanBase 数据库是第一个也是截止目前唯一一个上榜 TPC-C 的中国数据库产品。
+
+HTAP 混合负载
+
+2021 年，OceanBase 数据库 V3.0 基于全新的向量化执行引擎，在 TPC-H 30000GB 的评测中以 1526 万 QphH 的成绩刷新了评测榜单。这标志着 OceanBase 数据库一套引擎处理 AP 和 TP 混合负载的能力取得了基础性的突破。
+
+开源开放
+
+2021 年六一儿童节，OceanBase 数据库宣布全面开源，开放合作，共建生态。
+
+OceanBase 数据库采用了单集群多租户设计，天然支持云数据库架构，支持公有云、私有云、混合云等多种部署形式。
+
+架构 
+
+OceanBase 数据库通过租户实现资源隔离，让每个数据库服务的实例不感知其他实例的存在，并通过权限控制确保租户数据的安全性，配合 OceanBase 数据库强大的可扩展性，能够提供安全、灵活的 DBaaS 服务。
+
+租户是一个逻辑概念。在 OceanBase 数据库中，租户是资源分配的单位，是数据库对象管理和资源管理的基础，对于系统运维，尤其是对于云数据库的运维有着重要的影响。租户在一定程度上相当于传统数据库的"实例"概念。租户之间是完全隔离的。在数据安全方面，OceanBase 数据库不允许跨租户的数据访问，以确保用户的数据资产没有被其他租户窃取的风险。在资源使用方面，OceanBase 数据库表现为租户"独占"其资源配额。总体上来说，租户（tenant）既是各类数据库对象的容器，又是资源（CPU、Memory、IO 等）的容器。
+
+OceanBase 数据库在一个系统中可同时支持 MySQL 模式和 Oracle 模式两种模式的租户。用户在创建租户时，可选择创建 MySQL 兼容模式的租户或 Oracle 兼容模式的租户，租户的兼容模式一经确定就无法更改，所有数据类型、SQL 功能、视图等相应地与 MySQL 数据库或 Oracle 数据库保持一致。
+
+
+MySQL 模式
+MySQL 模式是为降低 MySQL 数据库迁移至 OceanBase 数据库所引发的业务系统改造成本，同时使业务数据库设计人员、开发人员、数据库管理员等可复用积累的 MySQL 数据库技术知识经验，并能快速上手 OceanBase 数据库而支持的一种租户类型功能。OceanBase 数据库的 MySQL 模式兼容 MySQL 5.7 的绝大部分功能和语法，兼容 MySQL 5.7 版本的全量以及 8.0 版本的部分 JSON 函数，基于 MySQL 的应用能够平滑迁移。
+
+Oracle 模式
+OceanBase 数据库从 V2.x.x 版本开始支持 Oracle 兼容模式。Oracle 模式是为降低 Oracle 数据库迁移 OceanBase 数据库的业务系统改造成本，同时使业务数据库设计开发人员、数据库管理员等可复用积累的 Oracle 数据库技术知识经验，并能快速上手 OceanBase 数据库而支持的一种租户类型功能。Oracle 模式目前能够支持绝大部分的 Oracle 语法和过程性语言功能，可以做到大部分的 Oracle 业务进行少量修改后的自动迁移。
+
+OceanBase 数据库是多租户架构。在 V4.0.0 版本之前，仅支持两种类型的租户：系统租户和用户租户。从 V4.0.0 版本开始，引入了 Meta 租户概念。因此，当前版本对用户可见的租户有三种类型：系统租户、用户租户以及 Meta 租户。
+
+系统租户
+系统租户是集群默认创建的租户，与集群的生命周期一致，负责管理集群和所有租户的生命周期。系统租户仅有一个 1 号日志流，仅支持单点写入，不具备扩展能力。
+
+系统租户可以创建用户表，所有的用户表和系统表数据均由 1 号日志流服务。系统租户的数据是集群私有的，不支持主备集群物理同步和物理备份恢复。
+
+用户租户
+用户租户是由用户创建的租户，对外提供完整的数据库功能，支持 MySQL 和 Oracle 两种兼容模式。用户租户支持服务能力水平扩展到多台机器上，支持动态扩容和缩容，内部会根据用户的配置自动创建和删除日志流。
+
+用户租户的数据有更强的数据保护和可用性要求，支持跨集群物理同步和物理备份恢复，典型数据包括：Schema 数据、用户表数据及事务数据等。
+Meta 租户
+Meta 租户是 OceanBase 数据库内部自管理的租户，每创建一个用户租户系统就会自动创建一个对应的 Meta 租户，其生命期与用户租户保持一致。
+
+Meta 租户用于存储和管理用户租户的集群私有数据，这部分数据不需要进行跨库物理同步以及物理备份恢复，这些数据包括：配置项、位置信息、副本信息、日志流状态、备份恢复相关信息、合并信息等。
+
+租户对比
+从用户角度来看，系统租户、用户租户和 Meta 租户的差异性如下表所示。
+OceanBase 数据库是多租户的数据库系统，一个集群内可包含多个相互独立的租户，每个租户提供独立的数据库服务。在 OceanBase 数据库中，使用资源配置（unit_config）、资源池（Resource Pool）和资源单元（Unit）三个概念，对各租户的可用资源进行管理。
+
+
+创建租户前，需首先确定租户的资源配置、使用资源范围等。租户创建的通用流程如下：
+
+资源配置是描述资源池的配置信息，用来描述资源池中每个资源单元可用的 CPU、内存、存储空间和 IOPS 等的规格。修改资源配置可动态调整资源单元的规格。这里需要注意，资源配置指定的是对应资源单元能够提供的服务能力，而不是资源单元的实时负载。 创建资源配置的示例语句如下：
+
+问题:
+请你基于上述内容对 OceanBase 的介绍进行总结，不少于2000字。

docker/examples/dashboard/test_case_mysql_data.py

@@ -0,0 +1,219 @@
+import os
+import random
+import string
+from datetime import datetime, timedelta
+from typing import List
+
+import pymysql
+import pymysql.cursors
+
+# At first you need to create an test database which called dbgpt_test;
+# you can use next command to create.
+# CREATE DATABASE IF NOT EXISTS dbgpt_test CHARACTER SET utf8;
+
+
+def build_table(connection):
+    connection.cursor().execute(
+        """CREATE TABLE user (
+              id INT(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
+              name VARCHAR(50) NOT NULL COMMENT '用户名',
+              email VARCHAR(50) NOT NULL COMMENT '电子邮件',
+              mobile CHAR(11) NOT NULL COMMENT '手机号码',
+              gender VARCHAR(20) COMMENT '性别，可选值：Male, Female',
+              birth DATE COMMENT '出生日期',
+              country VARCHAR(20) COMMENT '国家',
+              city VARCHAR(20) COMMENT '城市',
+              create_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+              update_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+              PRIMARY KEY (id),
+              UNIQUE KEY uk_email (email)
+            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户信息表';"""
+    )
+    connection.cursor().execute(
+        """CREATE TABLE transaction_order (
+              id INT(11) NOT NULL AUTO_INCREMENT COMMENT '订单ID',
+              order_no CHAR(20) NOT NULL COMMENT '订单编号',
+              product_name VARCHAR(50) NOT NULL COMMENT '产品名称',
+              product_category VARCHAR(20) COMMENT '产品分类',
+              amount DECIMAL(10, 2) NOT NULL COMMENT '订单金额',
+              pay_status VARCHAR(20) COMMENT '付款状态，可选值：CANCEL, REFUND, SUCCESS, FAILD',
+              user_id INT(11) NOT NULL COMMENT '用户ID',
+              user_name VARCHAR(50) COMMENT '用户名',
+              create_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+              update_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+              PRIMARY KEY (id),
+              UNIQUE KEY uk_order_no (order_no),
+              KEY idx_user_id (user_id)
+            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='交易订单表';"""
+    )
+
+
+def user_build(names: List, country: str, grander: str = "Male") -> List:
+    countries = ["China", "US", "India", "Indonesia", "Pakistan"]  # 国家列表
+    cities = {
+        "China": ["Beijing", "Shanghai", "Guangzhou", "Shenzhen", "Hangzhou"],
+        "US": ["New York", "Los Angeles", "Chicago", "Houston", "Phoenix"],
+        "India": ["Mumbai", "Delhi", "Bangalore", "Hyderabad", "Chennai"],
+        "Indonesia": ["Jakarta", "Surabaya", "Medan", "Bandung", "Makassar"],
+        "Pakistan": ["Karachi", "Lahore", "Faisalabad", "Rawalpindi", "Multan"],
+    }
+
+    users = []
+    for i in range(1, len(names) + 1):
+        if grander == "Male":
+            id = int(str(countries.index(country) + 1) + "10") + i
+        else:
+            id = int(str(countries.index(country) + 1) + "20") + i
+
+        name = names[i - 1]
+        email = f"{name}@example.com"
+        mobile = "".join(random.choices(string.digits, k=10))
+        gender = grander
+        birth = f"19{random.randint(60, 99)}-{random.randint(1, 12):02d}-{random.randint(1, 28):02d}"
+        country = country
+        city = random.choice(cities[country])
+
+        now = datetime.now()
+        year = now.year
+
+        start = datetime(year, 1, 1)
+        end = datetime(year, 12, 31)
+        random_date = start + timedelta(days=random.randint(0, (end - start).days))
+        random_time = datetime.combine(random_date, datetime.min.time()) + timedelta(
+            seconds=random.randint(0, 24 * 60 * 60 - 1)
+        )
+
+        random_datetime_str = random_time.strftime("%Y-%m-%d %H:%M:%S")
+        create_time = random_datetime_str
+        users.append(
+            (
+                id,
+                name,
+                email,
+                mobile,
+                gender,
+                birth,
+                country,
+                city,
+                create_time,
+                create_time,
+            )
+        )
+    return users
+
+
+def gnerate_all_users(cursor):
+    users = []
+    users_f = ["ZhangWei", "LiQiang", "ZhangSan", "LiSi"]
+    users.extend(user_build(users_f, "China", "Male"))
+    users_m = ["Hanmeimei", "LiMeiMei", "LiNa", "ZhangLi", "ZhangMing"]
+    users.extend(user_build(users_m, "China", "Female"))
+
+    users1_f = ["James", "John", "David", "Richard"]
+    users.extend(user_build(users1_f, "US", "Male"))
+    users1_m = ["Mary", "Patricia", "Sarah"]
+    users.extend(user_build(users1_m, "US", "Female"))
+
+    users2_f = ["Ravi", "Rajesh", "Ajay", "Arjun", "Sanjay"]
+    users.extend(user_build(users2_f, "India", "Male"))
+    users2_m = ["Priya", "Sushma", "Pooja", "Swati"]
+    users.extend(user_build(users2_m, "India", "Female"))
+    for user in users:
+        cursor.execute(
+            "INSERT INTO user (id, name, email, mobile, gender, birth, country, city, create_time, update_time) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
+            user,
+        )
+
+    return users
+
+
+def gnerate_all_orders(users, cursor):
+    orders = []
+    orders_num = 200
+    categories = ["Clothing", "Food", "Home Appliance", "Mother and Baby", "Travel"]
+
+    categories_product = {
+        "Clothing": ["T-shirt", "Jeans", "Skirt", "Other"],
+        "Food": ["Snack", "Fruit"],
+        "Home Appliance": ["Refrigerator", "Television", "Air conditioner"],
+        "Mother and Baby": ["Diapers", "Milk Powder", "Stroller", "Toy"],
+        "Travel": ["Tent", "Fishing Rod", "Bike", "Rawalpindi", "Multan"],
+    }
+
+    for i in range(1, orders_num + 1):
+        id = i
+        order_no = "".join(random.choices(string.ascii_uppercase, k=3)) + "".join(
+            random.choices(string.digits, k=10)
+        )
+        product_category = random.choice(categories)
+        product_name = random.choice(categories_product[product_category])
+        amount = round(random.uniform(0, 10000), 2)
+        pay_status = random.choice(["SUCCESS", "FAILD", "CANCEL", "REFUND"])
+        user_id = random.choice(users)[0]
+        user_name = random.choice(users)[1]
+
+        now = datetime.now()
+        year = now.year
+
+        start = datetime(year, 1, 1)
+        end = datetime(year, 12, 31)
+        random_date = start + timedelta(days=random.randint(0, (end - start).days))
+        random_time = datetime.combine(random_date, datetime.min.time()) + timedelta(
+            seconds=random.randint(0, 24 * 60 * 60 - 1)
+        )
+
+        random_datetime_str = random_time.strftime("%Y-%m-%d %H:%M:%S")
+        create_time = random_datetime_str
+
+        order = (
+            id,
+            order_no,
+            product_category,
+            product_name,
+            amount,
+            pay_status,
+            user_id,
+            user_name,
+            create_time,
+        )
+        cursor.execute(
+            "INSERT INTO transaction_order (id, order_no, product_name, product_category, amount, pay_status, user_id, user_name, create_time) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)",
+            order,
+        )
+
+
+if __name__ == "__main__":
+    connection = pymysql.connect(
+        host=os.getenv("DB_HOST", "127.0.0.1"),
+        port=int(
+            os.getenv("DB_PORT", 3306),
+        ),
+        user=os.getenv("DB_USER", "root"),
+        password=os.getenv("DB_PASSWORD", "aa12345678"),
+        database=os.getenv("DB_DATABASE", "dbgpt_test"),
+        charset="utf8mb4",
+        ssl_ca=None,
+    )
+
+    build_table(connection)
+
+    connection.commit()
+
+    cursor = connection.cursor()
+
+    users = gnerate_all_users(cursor)
+    connection.commit()
+
+    gnerate_all_orders(users, cursor)
+    connection.commit()
+
+    cursor.execute("SELECT * FROM user")
+    data = cursor.fetchall()
+    print(data)
+
+    cursor.execute("SELECT count(*) FROM transaction_order")
+    data = cursor.fetchall()
+    print("orders:" + str(data))
+
+    cursor.close()
+    connection.close()

docker/examples/dashboard/test_case_sqlite_data.py

@@ -0,0 +1,156 @@
+import os
+import random
+import string
+from datetime import datetime, timedelta
+from typing import List
+import sqlite3
+
+# Change the database name to the desired SQLite file name.
+DATABASE_NAME = "dbgpt_test.db"
+
+
+def build_table(connection):
+    cursor = connection.cursor()
+    cursor.execute(
+        """CREATE TABLE IF NOT EXISTS user (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              name TEXT NOT NULL,
+              email TEXT NOT NULL UNIQUE,
+              mobile TEXT NOT NULL,
+              gender TEXT,
+              birth DATE,
+              country TEXT,
+              city TEXT,
+              create_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+              update_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+            );"""
+    )
+    cursor.execute(
+        """CREATE TABLE IF NOT EXISTS transaction_order (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              order_no TEXT NOT NULL UNIQUE,
+              product_name TEXT NOT NULL,
+              product_category TEXT,
+              amount REAL NOT NULL,
+              pay_status TEXT,
+              user_id INTEGER NOT NULL,
+              user_name TEXT,
+              create_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+            );"""
+    )
+    connection.commit()
+
+
+def user_build(names: List[str], country: str, gender: str = "Male") -> List:
+    countries = ["China", "US", "India", "Indonesia", "Pakistan"]
+    cities = {
+        "China": ["Beijing", "Shanghai", "Guangzhou", "Shenzhen", "Hangzhou"],
+        "US": ["New York", "Los Angeles", "Chicago", "Houston", "Phoenix"],
+        "India": ["Mumbai", "Delhi", "Bangalore", "Hyderabad", "Chennai"],
+        "Indonesia": ["Jakarta", "Surabaya", "Medan", "Bandung", "Makassar"],
+        "Pakistan": ["Karachi", "Lahore", "Faisalabad", "Rawalpindi", "Multan"],
+    }
+    users = []
+    for name in names:
+        email = f"{name}@example.com"
+        mobile = "".join(random.choices(string.digits, k=11))
+        birth = f"19{random.randint(60, 99)}-{random.randint(1, 12):02d}-{random.randint(1, 28):02d}"
+        city = random.choice(cities[country])
+        create_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        users.append(
+            (
+                name,
+                email,
+                mobile,
+                gender,
+                birth,
+                country,
+                city,
+                create_time,
+                create_time,
+            )
+        )
+    return users
+
+
+def generate_all_users(cursor):
+    users = []
+    users_f = ["ZhangWei", "LiQiang", "ZhangSan", "LiSi"]
+    users.extend(user_build(users_f, "China", "Male"))
+    users_m = ["Hanmeimei", "LiMeiMei", "LiNa", "ZhangLi", "ZhangMing"]
+    users.extend(user_build(users_m, "China", "Female"))
+    users1_f = ["James", "John", "David", "Richard"]
+    users.extend(user_build(users1_f, "US", "Male"))
+    users1_m = ["Mary", "Patricia", "Sarah"]
+    users.extend(user_build(users1_m, "US", "Female"))
+    users2_f = ["Ravi", "Rajesh", "Ajay", "Arjun", "Sanjay"]
+    users.extend(user_build(users2_f, "India", "Male"))
+    users2_m = ["Priya", "Sushma", "Pooja", "Swati"]
+    users.extend(user_build(users2_m, "India", "Female"))
+    for user in users:
+        cursor.execute(
+            "INSERT INTO user (name, email, mobile, gender, birth, country, city, create_time, update_time) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            user,
+        )
+    return users
+
+
+def generate_all_orders(users, cursor):
+    orders = []
+    orders_num = 200
+    categories = ["Clothing", "Food", "Home Appliance", "Mother and Baby", "Travel"]
+    categories_product = {
+        "Clothing": ["T-shirt", "Jeans", "Skirt", "Other"],
+        "Food": ["Snack", "Fruit"],
+        "Home Appliance": ["Refrigerator", "Television", "Air conditioner"],
+        "Mother and Baby": ["Diapers", "Milk Powder", "Stroller", "Toy"],
+        "Travel": ["Tent", "Fishing Rod", "Bike"],
+    }
+    for i in range(orders_num):
+        id = i + 1  # Simple incremental ID
+        order_no = "".join(random.choices(string.ascii_uppercase, k=3)) + "".join(
+            random.choices(string.digits, k=10)
+        )
+        product_category = random.choice(categories)
+        product_name = random.choice(categories_product[product_category])
+        amount = round(random.uniform(0, 10000), 2)
+        pay_status = random.choice(["SUCCESS", "FAILED", "CANCEL", "REFUND"])
+        user_id = random.choice(users)[0]
+        user_name = random.choice(users)[1]
+        create_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        order = (
+            id,
+            order_no,
+            product_name,
+            product_category,
+            amount,
+            pay_status,
+            user_id,
+            user_name,
+            create_time,
+        )
+        cursor.execute(
+            "INSERT INTO transaction_order (id, order_no, product_name, product_category, amount, pay_status, user_id, user_name, create_time) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            order,
+        )
+
+
+if __name__ == "__main__":
+    connection = sqlite3.connect(DATABASE_NAME)
+    build_table(connection)
+    cursor = connection.cursor()
+    users = generate_all_users(cursor)
+    generate_all_orders(users, cursor)
+
+    connection.commit()
+
+    cursor.execute("SELECT * FROM user")
+    data = cursor.fetchall()
+    print(data)
+
+    cursor.execute("SELECT COUNT(*) FROM transaction_order")
+    data = cursor.fetchall()
+    print("orders: " + str(data))
+
+    cursor.close()
+    connection.close()

docker/examples/excel/zx.csv

@@ -0,0 +1,69 @@
+序号,大项,明细,备注,预算,实际,费用小计,超额,已支出,支出小计,其他
+1,中央空调,内外机,1拖5 140 31600,30600,30600,30600,0,30600,30600,
+2,基装,地砖,,106000,32100,107948.4,1948.4,32100,107948.4,1948.4
+3,,地板,,,,,,,,
+4,,门,颜色升级,,37450,,,37450,,
+5,,橱柜,浴柜、马桶、花洒 自选,,,,,,,
+6,,卫生间墙地,,,28149.4,,,28149.4,,
+7,,厨房,墙、地（大改小增项）、菜盆去掉自选,,,,,,,
+8,,打拆改建,,,10249,,,10249,,
+9,其他费用,物业装修管理费（物业）,405.58,26936.23,405.58,20836.23,-6100,405.58,20036.23,
+10,,建渣清运费（物业）,281.65,,281.65,,,281.65,,
+11,,打拆清运费（物业）,1300,,1300,,,1300,,
+,,预交水费,200,,200,,,200,,
+,,客卧加墙,1500,,1500,,,1500,,
+,,天然气暗改,1800,,1800,,,1800,,
+,,天然气明改,719,,719,,,719,,
+,,开槽（150）,0,,0,,,0,,
+,,防水增加,358,,358,,,358,,
+,,墙砖背胶（大砖上墙加背胶）,208,,208,,,208,,
+,,美缝3000,3100,,3100,,,2500,,
+,,淋浴隔断（18980439828）,3130,,3130,,,3130,,
+,,橱柜增加费用,4500,,,,,,,
+,,电费,200,,200,,,200,,
+,,门锁,844,,844,,,844,,
+,,空调机位封窗,1500,,1500,,,1300,,
+,,开关灯安装,1000,,,,,,,
+,,空调机位门,600,,,,,,,
+,,瓷白胶,190,,190,,,190,,
+,,瓷白胶人工,300,,300,,,300,,
+,,每逢增加(橱柜浴柜),,,,,,,,
+,,乳胶漆人工,,,,,,,,
+12,,乳胶漆自购,4800,,4800,,,4800,,
+13,水电改造,材料,16446,18636,16446,18425,-211,16446,18425,
+14,,人工,,,,,,,,
+,,开关插座补,531,,320,,,320,,
+15,,开关插座,1659,,1659,,,1659,,
+16,封窗,,15000,14500,14500,14500,0,4500,14500,
+,,,,,,,,8000,,
+17,,,,,,,,2000,,
+18,基装(自购),马桶*2,9000,8200,8200,20000,,8200,20000,
+19,,花洒*2,3000,4000,4000,,,4000,,
+20,,浴柜*2,5000,4600,4600,,,4600,,
+21,,菜盆,2500,3200,3200,,,3200,,
+22,衣柜定做,鞋柜亮面、衣柜肤质、板材克诺斯邦、侧面表层,40*730,33000,5000,31000,,5000,31000,
+23,,,,,15000,,,15000,,
+,,,,,11000,,,11000,,
+24,,,,,,,,,,
+25,基础家电,燃气热水器,计划史密斯智能4000,3798,3798,18551,,3798,18841,24期免息
+,,燃气热水器安装,,355,355,,,355,,
+26,,洗碗机,计划西门子5999,6999,6999,,,6999,,
+27,,冰箱,计划西门子,6000,,,,,,
+28,,电视,,8000,,,,,,
+,,洗衣机(安装),,290,,,,290,,
+,,抽油烟机+灶具(升级),方太型号升级,3900,3900,,,3900,,
+29,,洗衣机,计划西门子6500,3499,3499,,,3499,,
+30,软装,沙发,15000,71799.8,,10877.8,,,9777.8,
+31,,茶几,5000,,,,,,,
+32,,电视柜,6000,,,,,,,
+33,,餐桌,7000,,,,,,,
+34,,床*2,7000,,,,,,,
+,,床垫*2,13000,,,,,,,
+,,窗帘,10400,,10500,,,9400,,
+,,洞灯,399.8,,377.8,,,377.8,,
+,,书桌,2000,,,,,,,
+35,,灯具,6000,,,,,,,
+36,合计,,,354313.03,272738.43,272738.43,-4362.6,,271128.43,-83184.6
+37,,,,,,,,,,
+38,双十一,,,,,38551,,,,
+,,,,,,,,,,

docker/examples/metadata/duckdb2mysql.py

@@ -0,0 +1,54 @@
+import duckdb
+import pymysql
+
+""" migrate duckdb to mysql"""
+
+mysql_config = {
+    "host": "127.0.0.1",
+    "user": "root",
+    "password": "your_password",
+    "db": "dbgpt",
+    "charset": "utf8mb4",
+    "cursorclass": pymysql.cursors.DictCursor,
+}
+
+duckdb_files_to_tables = {
+    "pilot/message/chat_history.db": "chat_history",
+    "pilot/message/connect_config.db": "connect_config",
+}
+
+conn_mysql = pymysql.connect(**mysql_config)
+
+
+def migrate_table(duckdb_file_path, source_table, destination_table, conn_mysql):
+    conn_duckdb = duckdb.connect(duckdb_file_path)
+    try:
+        cursor = conn_duckdb.cursor()
+        cursor.execute(f"SELECT * FROM {source_table}")
+        column_names = [
+            desc[0] for desc in cursor.description if desc[0].lower() != "id"
+        ]
+        select_columns = ", ".join(column_names)
+
+        cursor.execute(f"SELECT {select_columns} FROM {source_table}")
+        results = cursor.fetchall()
+
+        with conn_mysql.cursor() as cursor_mysql:
+            for row in results:
+                placeholders = ", ".join(["%s"] * len(row))
+                insert_query = f"INSERT INTO {destination_table} ({', '.join(column_names)}) VALUES ({placeholders})"
+                cursor_mysql.execute(insert_query, row)
+        conn_mysql.commit()
+    finally:
+        conn_duckdb.close()
+
+
+try:
+    for duckdb_file, table in duckdb_files_to_tables.items():
+        print(f"Migrating table {table} from {duckdb_file}...")
+        migrate_table(duckdb_file, table, table, conn_mysql)
+        print(f"Table {table} migrated successfully.")
+finally:
+    conn_mysql.close()
+
+print("Migration completed.")

docker/examples/metadata/duckdb2sqlite.py

@@ -0,0 +1,49 @@
+import sqlite3
+
+import duckdb
+
+""" migrate duckdb to sqlite"""
+
+duckdb_files_to_tables = {
+    "pilot/message/chat_history.db": "chat_history",
+    "pilot/message/connect_config.db": "connect_config",
+}
+
+sqlite_db_path = "pilot/meta_data/dbgpt.db"
+
+conn_sqlite = sqlite3.connect(sqlite_db_path)
+
+
+def migrate_table(duckdb_file_path, source_table, destination_table, conn_sqlite):
+    conn_duckdb = duckdb.connect(duckdb_file_path)
+    try:
+        cursor_duckdb = conn_duckdb.cursor()
+        cursor_duckdb.execute(f"SELECT * FROM {source_table}")
+        column_names = [
+            desc[0] for desc in cursor_duckdb.description if desc[0].lower() != "id"
+        ]
+        select_columns = ", ".join(column_names)
+
+        cursor_duckdb.execute(f"SELECT {select_columns} FROM {source_table}")
+        results = cursor_duckdb.fetchall()
+
+        cursor_sqlite = conn_sqlite.cursor()
+        for row in results:
+            placeholders = ", ".join(["?"] * len(row))
+            insert_query = f"INSERT INTO {destination_table} ({', '.join(column_names)}) VALUES ({placeholders})"
+            cursor_sqlite.execute(insert_query, row)
+        conn_sqlite.commit()
+        cursor_sqlite.close()
+    finally:
+        conn_duckdb.close()
+
+
+try:
+    for duckdb_file, table in duckdb_files_to_tables.items():
+        print(f"Migrating table {table} from {duckdb_file} to SQLite...")
+        migrate_table(duckdb_file, table, table, conn_sqlite)
+        print(f"Table {table} migrated to SQLite successfully.")
+finally:
+    conn_sqlite.close()
+
+print("Migration to SQLite completed.")

docker/examples/my.cnf

@@ -0,0 +1,44 @@
+# For advice on how to change settings please see
+# http://dev.mysql.com/doc/refman/8.0/en/server-configuration-defaults.html
+
+[mysqld]
+#
+# Remove leading # and set to the amount of RAM for the most important data
+# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.
+# innodb_buffer_pool_size = 128M
+#
+# Remove leading # to turn on a very important data integrity option: logging
+# changes to the binary log between backups.
+# log_bin
+#
+# Remove leading # to set options mainly useful for reporting servers.
+# The server defaults are faster for transactions and fast SELECTs.
+# Adjust sizes as needed, experiment to find the optimal values.
+# join_buffer_size = 128M
+# sort_buffer_size = 2M
+# read_rnd_buffer_size = 2M
+
+# Remove leading # to revert to previous value for default_authentication_plugin,
+# this will increase compatibility with older clients. For background, see:
+# https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_default_authentication_plugin
+# default-authentication-plugin=mysql_native_password
+skip-host-cache
+skip-name-resolve
+datadir=/var/lib/mysql
+socket=/var/lib/mysql/mysql.sock
+secure-file-priv=/var/lib/mysql-files
+user=mysql
+
+pid-file=/var/run/mysqld/mysqld.pid
+
+# add example config
+
+default-authentication-plugin=mysql_native_password
+character_set_server=utf8mb4
+collation-server=utf8mb4_unicode_ci
+init_connect='SET NAMES utf8mb4'
+
+[mysql]
+default-character-set=utf8mb4
+[client]
+default-character-set=utf8mb4

docker/examples/sqls/case_1_student_manager_mysql.sql

@@ -0,0 +1,63 @@
+create database case_1_student_manager character set utf8;
+use case_1_student_manager;
+
+CREATE TABLE students (
+    student_id INT PRIMARY KEY,
+    student_name VARCHAR(100) COMMENT '学生姓名',
+    major VARCHAR(100) COMMENT '专业',
+    year_of_enrollment INT COMMENT '入学年份',
+    student_age INT COMMENT '学生年龄'
+) COMMENT '学生信息表';
+
+CREATE TABLE courses (
+    course_id INT PRIMARY KEY,
+    course_name VARCHAR(100) COMMENT '课程名称',
+    credit FLOAT COMMENT '学分'
+) COMMENT '课程信息表';
+
+CREATE TABLE scores (
+    student_id INT,
+    course_id INT,
+    score INT COMMENT '得分',
+    semester VARCHAR(50) COMMENT '学期',
+    PRIMARY KEY (student_id, course_id),
+    FOREIGN KEY (student_id) REFERENCES students(student_id),
+    FOREIGN KEY (course_id) REFERENCES courses(course_id)
+) COMMENT '学生成绩表';
+
+
+INSERT INTO students (student_id, student_name, major, year_of_enrollment, student_age) VALUES
+(1, '张三', '计算机科学', 2020, 20),
+(2, '李四', '计算机科学', 2021, 19),
+(3, '王五', '物理学', 2020, 21),
+(4, '赵六', '数学', 2021, 19),
+(5, '周七', '计算机科学', 2022, 18),
+(6, '吴八', '物理学', 2020, 21),
+(7, '郑九', '数学', 2021, 19),
+(8, '孙十', '计算机科学', 2022, 18),
+(9, '刘十一', '物理学', 2020, 21),
+(10, '陈十二', '数学', 2021, 19);
+
+INSERT INTO courses (course_id, course_name, credit) VALUES
+(1, '计算机基础', 3),
+(2, '数据结构', 4),
+(3, '高等物理', 3),
+(4, '线性代数', 4),
+(5, '微积分', 5),
+(6, '编程语言', 4),
+(7, '量子力学', 3),
+(8, '概率论', 4),
+(9, '数据库系统', 4),
+(10, '计算机网络', 4);
+
+INSERT INTO scores (student_id, course_id, score, semester) VALUES
+(1, 1, 90, '2020年秋季'),
+(1, 2, 85, '2021年春季'),
+(2, 1, 88, '2021年秋季'),
+(2, 2, 90, '2022年春季'),
+(3, 3, 92, '2020年秋季'),
+(3, 4, 85, '2021年春季'),
+(4, 3, 88, '2021年秋季'),
+(4, 4, 86, '2022年春季'),
+(5, 1, 90, '2022年秋季'),
+(5, 2, 87, '2023年春季');

docker/examples/sqls/case_1_student_manager_sqlite.sql

@@ -0,0 +1,59 @@
+CREATE TABLE students (
+    student_id INTEGER PRIMARY KEY,
+    student_name VARCHAR(100),
+    major VARCHAR(100),
+    year_of_enrollment INTEGER,
+    student_age INTEGER
+);
+
+CREATE TABLE courses (
+    course_id INTEGER PRIMARY KEY,
+    course_name VARCHAR(100),
+    credit REAL
+);
+
+CREATE TABLE scores (
+    student_id INTEGER,
+    course_id INTEGER,
+    score INTEGER,
+    semester VARCHAR(50),
+    PRIMARY KEY (student_id, course_id),
+    FOREIGN KEY (student_id) REFERENCES students(student_id),
+    FOREIGN KEY (course_id) REFERENCES courses(course_id)
+);
+
+INSERT INTO students (student_id, student_name, major, year_of_enrollment, student_age) VALUES
+(1, '张三', '计算机科学', 2020, 20),
+(2, '李四', '计算机科学', 2021, 19),
+(3, '王五', '物理学', 2020, 21),
+(4, '赵六', '数学', 2021, 19),
+(5, '周七', '计算机科学', 2022, 18),
+(6, '吴八', '物理学', 2020, 21),
+(7, '郑九', '数学', 2021, 19),
+(8, '孙十', '计算机科学', 2022, 18),
+(9, '刘十一', '物理学', 2020, 21),
+(10, '陈十二', '数学', 2021, 19);
+
+INSERT INTO courses (course_id, course_name, credit) VALUES
+(1, '计算机基础', 3),
+(2, '数据结构', 4),
+(3, '高等物理', 3),
+(4, '线性代数', 4),
+(5, '微积分', 5),
+(6, '编程语言', 4),
+(7, '量子力学', 3),
+(8, '概率论', 4),
+(9, '数据库系统', 4),
+(10, '计算机网络', 4);
+
+INSERT INTO scores (student_id, course_id, score, semester) VALUES
+(1, 1, 90, '2020年秋季'),
+(1, 2, 85, '2021年春季'),
+(2, 1, 88, '2021年秋季'),
+(2, 2, 90, '2022年春季'),
+(3, 3, 92, '2020年秋季'),
+(3, 4, 85, '2021年春季'),
+(4, 3, 88, '2021年秋季'),
+(4, 4, 86, '2022年春季'),
+(5, 1, 90, '2022年秋季'),
+(5, 2, 87, '2023年春季');

docker/examples/sqls/case_1_student_manager_vertica.sql

@@ -0,0 +1,78 @@
+CREATE SCHEMA case_1_student_manager;
+COMMENT ON SCHEMA case_1_student_manager is '学校管理系统';
+
+SET SEARCH_PATH = case_1_student_manager;
+
+CREATE TABLE students (
+    student_id INT PRIMARY KEY,
+    student_name VARCHAR(100),
+    major VARCHAR(100),
+    year_of_enrollment INT,
+    student_age INT
+);
+COMMENT ON TABLE students IS '学生信息表';
+COMMENT ON COLUMN students.student_name IS '学生姓名';
+COMMENT ON COLUMN students.major IS '专业';
+COMMENT ON COLUMN students.year_of_enrollment IS '入学年份';
+COMMENT ON COLUMN students.student_age IS '学生年龄';
+
+CREATE TABLE courses (
+    course_id INT PRIMARY KEY,
+    course_name VARCHAR(100),
+    credit FLOAT
+);
+COMMENT ON TABLE courses IS '课程信息表';
+COMMENT ON COLUMN courses.course_name IS '课程名称';
+COMMENT ON COLUMN courses.credit IS '学分';
+
+CREATE TABLE scores (
+    student_id INT,
+    course_id INT,
+    score INT,
+    semester VARCHAR(50),
+    PRIMARY KEY (student_id, course_id),
+    FOREIGN KEY (student_id) REFERENCES students(student_id),
+    FOREIGN KEY (course_id) REFERENCES courses(course_id)
+);
+COMMENT ON TABLE scores IS '学生成绩表';
+COMMENT ON COLUMN scores.score IS '得分';
+COMMENT ON COLUMN scores.semester IS '学期';
+
+
+INSERT INTO students (student_id, student_name, major, year_of_enrollment, student_age) VALUES
+(1, '张三', '计算机科学', 2020, 20),
+(2, '李四', '计算机科学', 2021, 19),
+(3, '王五', '物理学', 2020, 21),
+(4, '赵六', '数学', 2021, 19),
+(5, '周七', '计算机科学', 2022, 18),
+(6, '吴八', '物理学', 2020, 21),
+(7, '郑九', '数学', 2021, 19),
+(8, '孙十', '计算机科学', 2022, 18),
+(9, '刘十一', '物理学', 2020, 21),
+(10, '陈十二', '数学', 2021, 19);
+
+INSERT INTO courses (course_id, course_name, credit) VALUES
+(1, '计算机基础', 3),
+(2, '数据结构', 4),
+(3, '高等物理', 3),
+(4, '线性代数', 4),
+(5, '微积分', 5),
+(6, '编程语言', 4),
+(7, '量子力学', 3),
+(8, '概率论', 4),
+(9, '数据库系统', 4),
+(10, '计算机网络', 4);
+
+INSERT INTO scores (student_id, course_id, score, semester) VALUES
+(1, 1, 90, '2020年秋季'),
+(1, 2, 85, '2021年春季'),
+(2, 1, 88, '2021年秋季'),
+(2, 2, 90, '2022年春季'),
+(3, 3, 92, '2020年秋季'),
+(3, 4, 85, '2021年春季'),
+(4, 3, 88, '2021年秋季'),
+(4, 4, 86, '2022年春季'),
+(5, 1, 90, '2022年秋季'),
+(5, 2, 87, '2023年春季');
+
+COMMIT;

docker/examples/sqls/case_2_ecom_mysql.sql

@@ -0,0 +1,63 @@
+create database case_2_ecom character set utf8;
+use case_2_ecom;
+
+CREATE TABLE users (
+    user_id INT PRIMARY KEY,
+    user_name VARCHAR(100) COMMENT '用户名',
+    user_email VARCHAR(100) COMMENT '用户邮箱',
+    registration_date DATE COMMENT '注册日期',
+    user_country VARCHAR(100) COMMENT '用户国家'
+) COMMENT '用户信息表';
+
+CREATE TABLE products (
+    product_id INT PRIMARY KEY,
+    product_name VARCHAR(100) COMMENT '商品名称',
+    product_price FLOAT COMMENT '商品价格'
+) COMMENT '商品信息表';
+
+CREATE TABLE orders (
+    order_id INT PRIMARY KEY,
+    user_id INT,
+    product_id INT,
+    quantity INT COMMENT '数量',
+    order_date DATE COMMENT '订单日期',
+    FOREIGN KEY (user_id) REFERENCES users(user_id),
+    FOREIGN KEY (product_id) REFERENCES products(product_id)
+) COMMENT '订单信息表';
+
+
+INSERT INTO users (user_id, user_name, user_email, registration_date, user_country) VALUES
+(1, 'John', 'john@gmail.com', '2020-01-01', 'USA'),
+(2, 'Mary', 'mary@gmail.com', '2021-01-01', 'UK'),
+(3, 'Bob', 'bob@gmail.com', '2020-01-01', 'USA'),
+(4, 'Alice', 'alice@gmail.com', '2021-01-01', 'UK'),
+(5, 'Charlie', 'charlie@gmail.com', '2020-01-01', 'USA'),
+(6, 'David', 'david@gmail.com', '2021-01-01', 'UK'),
+(7, 'Eve', 'eve@gmail.com', '2020-01-01', 'USA'),
+(8, 'Frank', 'frank@gmail.com', '2021-01-01', 'UK'),
+(9, 'Grace', 'grace@gmail.com', '2020-01-01', 'USA'),
+(10, 'Helen', 'helen@gmail.com', '2021-01-01', 'UK');
+
+INSERT INTO products (product_id, product_name, product_price) VALUES
+(1, 'iPhone', 699),
+(2, 'Samsung Galaxy', 599),
+(3, 'iPad', 329),
+(4, 'Macbook', 1299),
+(5, 'Apple Watch', 399),
+(6, 'AirPods', 159),
+(7, 'Echo', 99),
+(8, 'Kindle', 89),
+(9, 'Fire TV Stick', 39),
+(10, 'Echo Dot', 49);
+
+INSERT INTO orders (order_id, user_id, product_id, quantity, order_date) VALUES
+(1, 1, 1, 1, '2022-01-01'),
+(2, 1, 2, 1, '2022-02-01'),
+(3, 2, 3, 2, '2022-03-01'),
+(4, 2, 4, 1, '2022-04-01'),
+(5, 3, 5, 2, '2022-05-01'),
+(6, 3, 6, 3, '2022-06-01'),
+(7, 4, 7, 2, '2022-07-01'),
+(8, 4, 8, 1, '2022-08-01'),
+(9, 5, 9, 2, '2022-09-01'),
+(10, 5, 10, 3, '2022-10-01');

docker/examples/sqls/case_2_ecom_sqlite.sql

@@ -0,0 +1,59 @@
+CREATE TABLE users (
+    user_id INTEGER PRIMARY KEY,
+    user_name VARCHAR(100),
+    user_email VARCHAR(100),
+    registration_date DATE,
+    user_country VARCHAR(100)
+);
+
+CREATE TABLE products (
+    product_id INTEGER PRIMARY KEY,
+    product_name VARCHAR(100),
+    product_price REAL
+);
+
+CREATE TABLE orders (
+    order_id INTEGER PRIMARY KEY,
+    user_id INTEGER,
+    product_id INTEGER,
+    quantity INTEGER,
+    order_date DATE,
+    FOREIGN KEY (user_id) REFERENCES users(user_id),
+    FOREIGN KEY (product_id) REFERENCES products(product_id)
+);
+
+INSERT INTO users (user_id, user_name, user_email, registration_date, user_country) VALUES
+(1, 'John', 'john@gmail.com', '2020-01-01', 'USA'),
+(2, 'Mary', 'mary@gmail.com', '2021-01-01', 'UK'),
+(3, 'Bob', 'bob@gmail.com', '2020-01-01', 'USA'),
+(4, 'Alice', 'alice@gmail.com', '2021-01-01', 'UK'),
+(5, 'Charlie', 'charlie@gmail.com', '2020-01-01', 'USA'),
+(6, 'David', 'david@gmail.com', '2021-01-01', 'UK'),
+(7, 'Eve', 'eve@gmail.com', '2020-01-01', 'USA'),
+(8, 'Frank', 'frank@gmail.com', '2021-01-01', 'UK'),
+(9, 'Grace', 'grace@gmail.com', '2020-01-01', 'USA'),
+(10, 'Helen', 'helen@gmail.com', '2021-01-01', 'UK');
+
+INSERT INTO products (product_id, product_name, product_price) VALUES
+(1, 'iPhone', 699),
+(2, 'Samsung Galaxy', 599),
+(3, 'iPad', 329),
+(4, 'Macbook', 1299),
+(5, 'Apple Watch', 399),
+(6, 'AirPods', 159),
+(7, 'Echo', 99),
+(8, 'Kindle', 89),
+(9, 'Fire TV Stick', 39),
+(10, 'Echo Dot', 49);
+
+INSERT INTO orders (order_id, user_id, product_id, quantity, order_date) VALUES
+(1, 1, 1, 1, '2022-01-01'),
+(2, 1, 2, 1, '2022-02-01'),
+(3, 2, 3, 2, '2022-03-01'),
+(4, 2, 4, 1, '2022-04-01'),
+(5, 3, 5, 2, '2022-05-01'),
+(6, 3, 6, 3, '2022-06-01'),
+(7, 4, 7, 2, '2022-07-01'),
+(8, 4, 8, 1, '2022-08-01'),
+(9, 5, 9, 2, '2022-09-01'),
+(10, 5, 10, 3, '2022-10-01');

docker/examples/sqls/case_2_ecom_vertica.sql

@@ -0,0 +1,78 @@
+CREATE SCHEMA case_2_ecom;
+COMMENT ON SCHEMA case_2_ecom is '电子商务系统';
+
+SET SEARCH_PATH = case_2_ecom;
+
+CREATE TABLE users (
+    user_id INT PRIMARY KEY,
+    user_name VARCHAR(100),
+    user_email VARCHAR(100),
+    registration_date DATE,
+    user_country VARCHAR(100)
+);
+COMMENT ON TABLE users IS '用户信息表';
+COMMENT ON COLUMN users.user_name IS '用户名';
+COMMENT ON COLUMN users.user_email IS '用户邮箱';
+COMMENT ON COLUMN users.registration_date IS '注册日期';
+COMMENT ON COLUMN users.user_country  IS '用户国家';
+
+CREATE TABLE products (
+    product_id INT PRIMARY KEY,
+    product_name VARCHAR(100),
+    product_price FLOAT
+);
+COMMENT ON TABLE products IS '商品信息表';
+COMMENT ON COLUMN products.product_name IS '商品名称';
+COMMENT ON COLUMN products.product_price IS '商品价格';
+
+CREATE TABLE orders (
+    order_id INT PRIMARY KEY,
+    user_id INT,
+    product_id INT,
+    quantity INT,
+    order_date DATE,
+    FOREIGN KEY (user_id) REFERENCES users(user_id),
+    FOREIGN KEY (product_id) REFERENCES products(product_id)
+);
+COMMENT ON TABLE orders IS '订单信息表';
+COMMENT ON COLUMN orders.quantity IS '数量';
+COMMENT ON COLUMN orders.order_date IS '订单日期';
+
+
+INSERT INTO users (user_id, user_name, user_email, registration_date, user_country) VALUES
+(1, 'John', 'john@gmail.com', '2020-01-01', 'USA'),
+(2, 'Mary', 'mary@gmail.com', '2021-01-01', 'UK'),
+(3, 'Bob', 'bob@gmail.com', '2020-01-01', 'USA'),
+(4, 'Alice', 'alice@gmail.com', '2021-01-01', 'UK'),
+(5, 'Charlie', 'charlie@gmail.com', '2020-01-01', 'USA'),
+(6, 'David', 'david@gmail.com', '2021-01-01', 'UK'),
+(7, 'Eve', 'eve@gmail.com', '2020-01-01', 'USA'),
+(8, 'Frank', 'frank@gmail.com', '2021-01-01', 'UK'),
+(9, 'Grace', 'grace@gmail.com', '2020-01-01', 'USA'),
+(10, 'Helen', 'helen@gmail.com', '2021-01-01', 'UK');
+
+INSERT INTO products (product_id, product_name, product_price) VALUES
+(1, 'iPhone', 699),
+(2, 'Samsung Galaxy', 599),
+(3, 'iPad', 329),
+(4, 'Macbook', 1299),
+(5, 'Apple Watch', 399),
+(6, 'AirPods', 159),
+(7, 'Echo', 99),
+(8, 'Kindle', 89),
+(9, 'Fire TV Stick', 39),
+(10, 'Echo Dot', 49);
+
+INSERT INTO orders (order_id, user_id, product_id, quantity, order_date) VALUES
+(1, 1, 1, 1, '2022-01-01'),
+(2, 1, 2, 1, '2022-02-01'),
+(3, 2, 3, 2, '2022-03-01'),
+(4, 2, 4, 1, '2022-04-01'),
+(5, 3, 5, 2, '2022-05-01'),
+(6, 3, 6, 3, '2022-06-01'),
+(7, 4, 7, 2, '2022-07-01'),
+(8, 4, 8, 1, '2022-08-01'),
+(9, 5, 9, 2, '2022-09-01'),
+(10, 5, 10, 3, '2022-10-01');
+
+COMMIT;

docker/examples/sqls/case_3_order_wide_table_sqlite_wide.sql

@@ -0,0 +1,317 @@
+CREATE TABLE order_wide_table (
+
+    -- order_base
+    order_id TEXT, -- 订单ID
+    order_no TEXT, -- 订单编号
+    parent_order_no TEXT, -- 父订单编号
+    order_type INTEGER, -- 订单类型：1实物2虚拟3混合
+    order_status INTEGER, -- 订单状态
+    order_source TEXT, -- 订单来源
+    order_source_detail TEXT, -- 订单来源详情
+    create_time DATETIME, -- 创建时间
+    pay_time DATETIME, -- 支付时间
+    finish_time DATETIME, -- 完成时间
+    close_time DATETIME, -- 关闭时间
+    cancel_time DATETIME, -- 取消时间
+    cancel_reason TEXT, -- 取消原因
+    order_remark TEXT, -- 订单备注
+    seller_remark TEXT, -- 卖家备注
+    buyer_remark TEXT, -- 买家备注
+    is_deleted INTEGER, -- 是否删除
+    delete_time DATETIME, -- 删除时间
+    order_ip TEXT, -- 下单IP
+    order_platform TEXT, -- 下单平台
+    order_device TEXT, -- 下单设备
+    order_app_version TEXT, -- APP版本号
+
+    -- order_amount
+    currency TEXT, -- 货币类型
+    exchange_rate REAL, -- 汇率
+    original_amount REAL, -- 原始金额
+    discount_amount REAL, -- 优惠金额
+    coupon_amount REAL, -- 优惠券金额
+    points_amount REAL, -- 积分抵扣金额
+    shipping_amount REAL, -- 运费
+    insurance_amount REAL, -- 保价费
+    tax_amount REAL, -- 税费
+    tariff_amount REAL, -- 关税
+    payment_amount REAL, -- 实付金额
+    commission_amount REAL, -- 佣金金额
+    platform_fee REAL, -- 平台费用
+    seller_income REAL, -- 卖家实收
+    payment_currency TEXT, -- 支付货币
+    payment_exchange_rate REAL, -- 支付汇率
+
+    -- user_info
+    user_id TEXT, -- 用户ID
+    user_name TEXT, -- 用户名
+    user_nickname TEXT, -- 用户昵称
+    user_level INTEGER, -- 用户等级
+    user_type INTEGER, -- 用户类型
+    register_time DATETIME, -- 注册时间
+    register_source TEXT, -- 注册来源
+    mobile TEXT, -- 手机号
+    mobile_area TEXT, -- 手机号区号
+    email TEXT, -- 邮箱
+    is_vip INTEGER, -- 是否VIP
+    vip_level INTEGER, -- VIP等级
+    vip_expire_time DATETIME, -- VIP过期时间
+    user_age INTEGER, -- 用户年龄
+    user_gender INTEGER, -- 用户性别
+    user_birthday DATE, -- 用户生日
+    user_avatar TEXT, -- 用户头像
+    user_province TEXT, -- 用户所在省
+    user_city TEXT, -- 用户所在市
+    user_district TEXT, -- 用户所在区
+    last_login_time DATETIME, -- 最后登录时间
+    last_login_ip TEXT, -- 最后登录IP
+    user_credit_score INTEGER, -- 用户信用分
+    total_order_count INTEGER, -- 历史订单数
+    total_order_amount REAL, -- 历史订单金额
+
+    -- product_info
+    product_id TEXT, -- 商品ID
+    product_code TEXT, -- 商品编码
+    product_name TEXT, -- 商品名称
+    product_short_name TEXT, -- 商品短名称
+    product_type INTEGER, -- 商品类型
+    product_status INTEGER, -- 商品状态
+    category_id TEXT, -- 类目ID
+    category_name TEXT, -- 类目名称
+    category_path TEXT, -- 类目路径
+    brand_id TEXT, -- 品牌ID
+    brand_name TEXT, -- 品牌名称
+    brand_english_name TEXT, -- 品牌英文名
+    seller_id TEXT, -- 卖家ID
+    seller_name TEXT, -- 卖家名称
+    seller_type INTEGER, -- 卖家类型
+    shop_id TEXT, -- 店铺ID
+    shop_name TEXT, -- 店铺名称
+    product_price REAL, -- 商品价格
+    market_price REAL, -- 市场价
+    cost_price REAL, -- 成本价
+    wholesale_price REAL, -- 批发价
+    product_quantity INTEGER, -- 商品数量
+    product_unit TEXT, -- 商品单位
+    product_weight REAL, -- 商品重量(克)
+    product_volume REAL, -- 商品体积(cm³)
+    product_spec TEXT, -- 商品规格
+    product_color TEXT, -- 商品颜色
+    product_size TEXT, -- 商品尺寸
+    product_material TEXT, -- 商品材质
+    product_origin TEXT, -- 商品产地
+    product_shelf_life INTEGER, -- 保质期(天)
+    manufacture_date DATE, -- 生产日期
+    expiry_date DATE, -- 过期日期
+    batch_number TEXT, -- 批次号
+    product_barcode TEXT, -- 商品条码
+    warehouse_id TEXT, -- 发货仓库ID
+    warehouse_name TEXT, -- 发货仓库名称
+
+    -- address_info
+    receiver_name TEXT, -- 收货人姓名
+    receiver_mobile TEXT, -- 收货人手机
+    receiver_tel TEXT, -- 收货人电话
+    receiver_email TEXT, -- 收货人邮箱
+    receiver_country TEXT, -- 国家
+    receiver_province TEXT, -- 省份
+    receiver_city TEXT, -- 城市
+    receiver_district TEXT, -- 区县
+    receiver_street TEXT, -- 街道
+    receiver_address TEXT, -- 详细地址
+    receiver_zip TEXT, -- 邮编
+    address_type INTEGER, -- 地址类型
+    is_default INTEGER, -- 是否默认地址
+    longitude REAL, -- 经度
+    latitude REAL, -- 纬度
+    address_label TEXT, -- 地址标签
+
+    -- shipping_info
+    shipping_type INTEGER, -- 配送方式
+    shipping_method TEXT, -- 配送方式名称
+    shipping_company TEXT, -- 快递公司
+    shipping_company_code TEXT, -- 快递公司编码
+    shipping_no TEXT, -- 快递单号
+    shipping_time DATETIME, -- 发货时间
+    shipping_remark TEXT, -- 发货备注
+    expect_receive_time DATETIME, -- 预计送达时间
+    receive_time DATETIME, -- 收货时间
+    sign_type INTEGER, -- 签收类型
+    shipping_status INTEGER, -- 物流状态
+    tracking_url TEXT, -- 物流跟踪URL
+    is_free_shipping INTEGER, -- 是否包邮
+    shipping_insurance REAL, -- 运费险金额
+    shipping_distance REAL, -- 配送距离
+    delivered_time DATETIME, -- 送达时间
+    delivery_staff_id TEXT, -- 配送员ID
+    delivery_staff_name TEXT, -- 配送员姓名
+    delivery_staff_mobile TEXT, -- 配送员电话
+
+    -- payment_info
+    payment_id TEXT, -- 支付ID
+    payment_no TEXT, -- 支付单号
+    payment_type INTEGER, -- 支付方式
+    payment_method TEXT, -- 支付方式名称
+    payment_status INTEGER, -- 支付状态
+    payment_platform TEXT, -- 支付平台
+    transaction_id TEXT, -- 交易流水号
+    payment_time DATETIME, -- 支付时间
+    payment_account TEXT, -- 支付账号
+    payment_bank TEXT, -- 支付银行
+    payment_card_type TEXT, -- 支付卡类型
+    payment_card_no TEXT, -- 支付卡号
+    payment_scene TEXT, -- 支付场景
+    payment_client_ip TEXT, -- 支付IP
+    payment_device TEXT, -- 支付设备
+    payment_remark TEXT, -- 支付备注
+    payment_voucher TEXT, -- 支付凭证
+
+    -- promotion_info
+    promotion_id TEXT, -- 活动ID
+    promotion_name TEXT, -- 活动名称
+    promotion_type INTEGER, -- 活动类型
+    promotion_desc TEXT, -- 活动描述
+    promotion_start_time DATETIME, -- 活动开始时间
+    promotion_end_time DATETIME, -- 活动结束时间
+    coupon_id TEXT, -- 优惠券ID
+    coupon_code TEXT, -- 优惠券码
+    coupon_type INTEGER, -- 优惠券类型
+    coupon_name TEXT, -- 优惠券名称
+    coupon_desc TEXT, -- 优惠券描述
+    points_used INTEGER, -- 使用积分
+    points_gained INTEGER, -- 获得积分
+    points_multiple REAL, -- 积分倍率
+    is_first_order INTEGER, -- 是否首单
+    is_new_customer INTEGER, -- 是否新客
+    marketing_channel TEXT, -- 营销渠道
+    marketing_source TEXT, -- 营销来源
+    referral_code TEXT, -- 推荐码
+    referral_user_id TEXT, -- 推荐人ID
+
+    -- after_sale_info
+    refund_id TEXT, -- 退款ID
+    refund_no TEXT, -- 退款单号
+    refund_type INTEGER, -- 退款类型
+    refund_status INTEGER, -- 退款状态
+    refund_reason TEXT, -- 退款原因
+    refund_desc TEXT, -- 退款描述
+    refund_time DATETIME, -- 退款时间
+    refund_amount REAL, -- 退款金额
+    return_shipping_no TEXT, -- 退货快递单号
+    return_shipping_company TEXT, -- 退货快递公司
+    return_shipping_time DATETIME, -- 退货时间
+    refund_evidence TEXT, -- 退款凭证
+    complaint_id TEXT, -- 投诉ID
+    complaint_type INTEGER, -- 投诉类型
+    complaint_status INTEGER, -- 投诉状态
+    complaint_content TEXT, -- 投诉内容
+    complaint_time DATETIME, -- 投诉时间
+    complaint_handle_time DATETIME, -- 投诉处理时间
+    complaint_handle_result TEXT, -- 投诉处理结果
+    evaluation_score INTEGER, -- 评价分数
+    evaluation_content TEXT, -- 评价内容
+    evaluation_time DATETIME, -- 评价时间
+    evaluation_reply TEXT, -- 评价回复
+    evaluation_reply_time DATETIME, -- 评价回复时间
+    evaluation_images TEXT, -- 评价图片
+    evaluation_videos TEXT, -- 评价视频
+    is_anonymous INTEGER, -- 是否匿名评价
+
+    -- invoice_info
+    invoice_type INTEGER, -- 发票类型
+    invoice_title TEXT, -- 发票抬头
+    invoice_content TEXT, -- 发票内容
+    tax_no TEXT, -- 税号
+    invoice_amount REAL, -- 发票金额
+    invoice_status INTEGER, -- 发票状态
+    invoice_time DATETIME, -- 开票时间
+    invoice_number TEXT, -- 发票号码
+    invoice_code TEXT, -- 发票代码
+    company_name TEXT, -- 单位名称
+    company_address TEXT, -- 单位地址
+    company_tel TEXT, -- 单位电话
+    company_bank TEXT, -- 开户银行
+    company_account TEXT, -- 银行账号
+
+    -- delivery_time_info
+    expect_delivery_time DATETIME, -- 期望配送时间
+    delivery_period_type INTEGER, -- 配送时段类型
+    delivery_period_start TEXT, -- 配送时段开始
+    delivery_period_end TEXT, -- 配送时段结束
+    delivery_priority INTEGER, -- 配送优先级
+
+    -- tag_info
+    order_tags TEXT, -- 订单标签
+    user_tags TEXT, -- 用户标签
+    product_tags TEXT, -- 商品标签
+    risk_level INTEGER, -- 风险等级
+    risk_tags TEXT, -- 风险标签
+    business_tags TEXT, -- 业务标签
+
+    -- commercial_info
+    gross_profit REAL, -- 毛利
+    gross_profit_rate REAL, -- 毛利率
+    settlement_amount REAL, -- 结算金额
+    settlement_time DATETIME, -- 结算时间
+    settlement_cycle INTEGER, -- 结算周期
+    settlement_status INTEGER, -- 结算状态
+    commission_rate REAL, -- 佣金比例
+    platform_service_fee REAL, -- 平台服务费
+    ad_cost REAL, -- 广告费用
+    promotion_cost REAL -- 推广费用
+);
+
+-- 插入示例数据
+INSERT INTO order_wide_table (
+    -- 基础订单信息
+    order_id, order_no, order_type, order_status, create_time, order_source,
+    -- 订单金额
+    original_amount, payment_amount, shipping_amount,
+    -- 用户信息
+    user_id, user_name, user_level, mobile,
+    -- 商品信息
+    product_id, product_name, product_quantity, product_price,
+    -- 收货信息
+    receiver_name, receiver_mobile, receiver_address,
+    -- 物流信息
+    shipping_no, shipping_status,
+    -- 支付信息
+    payment_type, payment_status,
+    -- 营销信息
+    promotion_id, coupon_amount,
+    -- 发票信息
+    invoice_type, invoice_title
+) VALUES 
+(
+    'ORD20240101001', 'NO20240101001', 1, 2, '2024-01-01 10:00:00', 'APP',
+    199.99, 188.88, 10.00,
+    'USER001', '张三', 2, '13800138000',
+    'PRD001', 'iPhone 15 手机壳', 2, 89.99,
+    '李四', '13900139000', '北京市朝阳区XX路XX号',
+    'SF123456789', 1,
+    1, 1,
+    'PROM001', 20.00,
+    1, '个人'
+),
+(
+    'ORD20240101002', 'NO20240101002', 1, 1, '2024-01-01 11:00:00', 'H5',
+    299.99, 279.99, 0.00,
+    'USER002', '王五', 3, '13700137000',
+    'PRD002', 'AirPods Pro 保护套', 1, 299.99,
+    '赵六', '13600136000', '上海市浦东新区XX路XX号',
+    'YT987654321', 2,
+    2, 2,
+    'PROM002', 10.00,
+    2, '上海科技有限公司'
+),
+(
+    'ORD20240101003', 'NO20240101003', 2, 3, '2024-01-01 12:00:00', 'WEB',
+    1999.99, 1899.99, 0.00,
+    'USER003', '陈七', 4, '13500135000',
+    'PRD003', 'MacBook Pro 电脑包', 1, 1999.99,
+    '孙八', '13400134000', '广州市天河区XX路XX号',
+    'JD123123123', 3,
+    3, 1,
+    'PROM003', 100.00,
+    1, '个人'
+);

docker/examples/sqls/test_case.md

@@ -0,0 +1,87 @@
+# 测试问题
+
+## 场景一 
+
+学校管理系统，主要测试SQL助手的联合查询，条件查询和排序功能。
+
+我们的数据库有三个表：学生表、课程表和成绩表。我们要测试SQL助手能否处理复杂的SQL查询，包括连接多个表，按照一定的条件筛选数据，以及对结果进行排序。
+
+### Q1
+
+查询所有学生的姓名，专业和成绩，按成绩降序排序
+
+SQL：
+```sql
+SELECT students.student_name, students.major, scores.score
+FROM students
+JOIN scores ON students.student_id = scores.student_id
+ORDER BY scores.score DESC;
+```
+
+### Q2
+
+查询 "计算机科学" 专业的学生的平均成绩
+
+SQL：
+```sql
+SELECT AVG(scores.score) as avg_score
+FROM students
+JOIN scores ON students.student_id = scores.student_id
+WHERE students.major = '计算机科学';
+```
+
+### Q3
+
+查询哪些学生在 "2023年春季" 学期的课程学分总和超过2学分
+
+```sql
+SELECT students.student_name
+FROM students
+JOIN scores ON students.student_id = scores.student_id
+JOIN courses ON scores.course_id = courses.course_id
+WHERE scores.semester = '2023年春季'
+GROUP BY students.student_id
+HAVING SUM(courses.credit) > 2;
+```
+
+## 场景二：电商系统，主要测试SQL助手的数据聚合和分组功能。
+
+我们的数据库有三个表：用户表、商品表和订单表。我们要测试SQL助手能否处理复杂的SQL查询，包括对数据进行聚合和分组。
+
+### Q1
+
+查询每个用户的总订单数量
+
+SQL:
+
+```sql
+SELECT users.user_name, COUNT(orders.order_id) as order_count
+FROM users
+JOIN orders ON users.user_id = orders.user_id
+GROUP BY users.user_id;
+```
+
+### Q2
+
+查询每种商品的总销售额
+
+```sql
+SELECT products.product_name, SUM(products.product_price * orders.quantity) as total_sales
+FROM products
+JOIN orders ON products.product_id = orders.product_id
+GROUP BY products.product_id;
+```
+
+### Q3
+
+查询2023年最受欢迎的商品（订单数量最多的商品）
+
+```sql
+SELECT products.product_name
+FROM products
+JOIN orders ON products.product_id = orders.product_id
+WHERE YEAR(orders.order_date) = 2023
+GROUP BY products.product_id
+ORDER BY COUNT(orders.order_id) DESC
+LIMIT 1;
+```

docker/examples/sqls/test_case_info_mysql.sql

@@ -0,0 +1,19 @@
+create database test_case_info character set utf8;
+use test_case_info;
+
+CREATE TABLE test_cases (
+    case_id INT AUTO_INCREMENT PRIMARY KEY,
+    scenario_name VARCHAR(100) COMMENT '场景名称',
+    scenario_description TEXT COMMENT '场景描述',
+    test_question VARCHAR(500) COMMENT '测试问题',
+    expected_sql TEXT COMMENT '预期SQL',
+    correct_output TEXT COMMENT '正确输出'
+) COMMENT '测试用例表';
+
+INSERT INTO test_cases (scenario_name, scenario_description, test_question, expected_sql, correct_output) VALUES
+('学校管理系统', '测试SQL助手的联合查询，条件查询和排序功能', '查询所有学生的姓名，专业和成绩，按成绩降序排序', 'SELECT students.student_name, students.major, scores.score FROM students JOIN scores ON students.student_id = scores.student_id ORDER BY scores.score DESC;', '返回所有学生的姓名，专业和成绩，按成绩降序排序的结果'),
+('学校管理系统', '测试SQL助手的联合查询，条件查询和排序功能', '查询计算机科学专业的学生的平均成绩', 'SELECT AVG(scores.score) as avg_score FROM students JOIN scores ON students.student_id = scores.student_id WHERE students.major = ''计算机科学'';', '返回计算机科学专业学生的平均成绩'),
+('学校管理系统', '测试SQL助手的联合查询，条件查询和排序功能', '查询哪些学生在2023年秋季学期的课程学分总和超过15', 'SELECT students.student_name FROM students JOIN scores ON students.student_id = scores.student_id JOIN courses ON scores.course_id = courses.course_id WHERE scores.semester = ''2023年秋季'' GROUP BY students.student_id HAVING SUM(courses.credit) > 15;', '返回在2023年秋季学期的课程学分总和超过15的学生的姓名'),
+('电商系统', '测试SQL助手的数据聚合和分组功能', '查询每个用户的总订单数量', 'SELECT users.user_name, COUNT(orders.order_id) as order_count FROM users JOIN orders ON users.user_id = orders.user_id GROUP BY users.user_id;', '返回每个用户的总订单数量'),
+('电商系统', '测试SQL助手的数据聚合和分组功能', '查询每种商品的总销售额', 'SELECT products.product_name, SUM(products.product_price * orders.quantity) as total_sales FROM products JOIN orders ON products.product_id = orders.product_id GROUP BY products.product_id;', '返回每种商品的总销售额'),
+('电商系统', '测试SQL助手的数据聚合和分组功能', '查询2023年最受欢迎的商品（订单数量最多的商品）', 'SELECT products.product_name FROM products JOIN orders ON products.product_id = orders.product_id WHERE YEAR(orders.order_date) = 2023 GROUP BY products.product_id ORDER BY COUNT(orders.order_id) DESC LIMIT 1;', '返回2023年最受欢迎的商品（订单数量最多的商品）的名称');

docker/examples/sqls/test_case_info_sqlite.sql

@@ -0,0 +1,17 @@
+CREATE TABLE test_cases (
+    case_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    scenario_name VARCHAR(100),
+    scenario_description TEXT,
+    test_question VARCHAR(500),
+    expected_sql TEXT,
+    correct_output TEXT
+);
+
+
+INSERT INTO test_cases (scenario_name, scenario_description, test_question, expected_sql, correct_output) VALUES
+('学校管理系统', '测试SQL助手的联合查询，条件查询和排序功能', '查询所有学生的姓名，专业和成绩，按成绩降序排序', 'SELECT students.student_name, students.major, scores.score FROM students JOIN scores ON students.student_id = scores.student_id ORDER BY scores.score DESC;', '返回所有学生的姓名，专业和成绩，按成绩降序排序的结果'),
+('学校管理系统', '测试SQL助手的联合查询，条件查询和排序功能', '查询计算机科学专业的学生的平均成绩', 'SELECT AVG(scores.score) as avg_score FROM students JOIN scores ON students.student_id = scores.student_id WHERE students.major = ''计算机科学'';', '返回计算机科学专业学生的平均成绩'),
+('学校管理系统', '测试SQL助手的联合查询，条件查询和排序功能', '查询哪些学生在2023年秋季学期的课程学分总和超过15', 'SELECT students.student_name FROM students JOIN scores ON students.student_id = scores.student_id JOIN courses ON scores.course_id = courses.course_id WHERE scores.semester = ''2023年秋季'' GROUP BY students.student_id HAVING SUM(courses.credit) > 15;', '返回在2023年秋季学期的课程学分总和超过15的学生的姓名'),
+('电商系统', '测试SQL助手的数据聚合和分组功能', '查询每个用户的总订单数量', 'SELECT users.user_name, COUNT(orders.order_id) as order_count FROM users JOIN orders ON users.user_id = orders.user_id GROUP BY users.user_id;', '返回每个用户的总订单数量'),
+('电商系统', '测试SQL助手的数据聚合和分组功能', '查询每种商品的总销售额', 'SELECT products.product_name, SUM(products.product_price * orders.quantity) as total_sales FROM products JOIN orders ON products.product_id = orders.product_id GROUP BY products.product_id;', '返回每种商品的总销售额'),
+('电商系统', '测试SQL助手的数据聚合和分组功能', '查询2023年最受欢迎的商品（订单数量最多的商品）', 'SELECT products.product_name FROM products JOIN orders ON products.product_id = orders.product_id WHERE YEAR(orders.order_date) = 2023 GROUP BY products.product_id ORDER BY COUNT(orders.order_id) DESC LIMIT 1;', '返回2023年最受欢迎的商品（订单数量最多的商品）的名称');

docker/examples/sqls/test_case_info_vertica.sql

@@ -0,0 +1,29 @@
+CREATE SCHEMA test_case_info;
+COMMENT ON SCHEMA test_case_info is '测试用例信息';
+
+SET SEARCH_PATH = test_case_info;
+
+CREATE TABLE test_cases (
+    case_id SERIAL /*INT AUTO_INCREMENT*/ PRIMARY KEY,
+    scenario_name VARCHAR(100),
+    scenario_description VARCHAR(6500),
+    test_question VARCHAR(500),
+    expected_sql VARCHAR(6500),
+    correct_output VARCHAR(6500)
+);
+COMMENT ON TABLE test_cases IS '测试用例表';
+COMMENT ON COLUMN test_cases.scenario_name IS '场景名称';
+COMMENT ON COLUMN test_cases.scenario_description IS '场景描述';
+COMMENT ON COLUMN test_cases.test_question IS '测试问题';
+COMMENT ON COLUMN test_cases.expected_sql IS '预期SQL';
+COMMENT ON COLUMN test_cases.correct_output IS '正确输出';
+
+INSERT INTO test_cases (scenario_name, scenario_description, test_question, expected_sql, correct_output) VALUES
+('学校管理系统', '测试SQL助手的联合查询，条件查询和排序功能', '查询所有学生的姓名，专业和成绩，按成绩降序排序', 'SELECT students.student_name, students.major, scores.score FROM students JOIN scores ON students.student_id = scores.student_id ORDER BY scores.score DESC;', '返回所有学生的姓名，专业和成绩，按成绩降序排序的结果'),
+('学校管理系统', '测试SQL助手的联合查询，条件查询和排序功能', '查询计算机科学专业的学生的平均成绩', 'SELECT AVG(scores.score) as avg_score FROM students JOIN scores ON students.student_id = scores.student_id WHERE students.major = ''计算机科学'';', '返回计算机科学专业学生的平均成绩'),
+('学校管理系统', '测试SQL助手的联合查询，条件查询和排序功能', '查询哪些学生在2023年秋季学期的课程学分总和超过15', 'SELECT students.student_name FROM students JOIN scores ON students.student_id = scores.student_id JOIN courses ON scores.course_id = courses.course_id WHERE scores.semester = ''2023年秋季'' GROUP BY students.student_id HAVING SUM(courses.credit) > 15;', '返回在2023年秋季学期的课程学分总和超过15的学生的姓名'),
+('电商系统', '测试SQL助手的数据聚合和分组功能', '查询每个用户的总订单数量', 'SELECT users.user_name, COUNT(orders.order_id) as order_count FROM users JOIN orders ON users.user_id = orders.user_id GROUP BY users.user_id;', '返回每个用户的总订单数量'),
+('电商系统', '测试SQL助手的数据聚合和分组功能', '查询每种商品的总销售额', 'SELECT products.product_name, SUM(products.product_price * orders.quantity) as total_sales FROM products JOIN orders ON products.product_id = orders.product_id GROUP BY products.product_id;', '返回每种商品的总销售额'),
+('电商系统', '测试SQL助手的数据聚合和分组功能', '查询2023年最受欢迎的商品（订单数量最多的商品）', 'SELECT products.product_name FROM products JOIN orders ON products.product_id = orders.product_id WHERE YEAR(orders.order_date) = 2023 GROUP BY products.product_id ORDER BY COUNT(orders.order_id) DESC LIMIT 1;', '返回2023年最受欢迎的商品（订单数量最多的商品）的名称');
+
+COMMIT;

docker/examples/sqls/user_config_mysql.sql

@@ -0,0 +1,3 @@
+USE mysql;
+UPDATE user SET Host='%' WHERE User='root';
+FLUSH PRIVILEGES;