diff --git a/CMakeLists.txt b/CMakeLists.txt index 7bb36fe1b0..be97e679d1 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,6 +16,7 @@ SET(TD_GRANT FALSE) SET(TD_MQTT FALSE) SET(TD_TSDB_PLUGINS FALSE) SET(TD_STORAGE FALSE) +SET(TD_TOPIC FALSE) SET(TD_COVER FALSE) SET(TD_MEM_CHECK FALSE) diff --git a/cmake/define.inc b/cmake/define.inc index ae90410f2d..ff4583d02b 100755 --- a/cmake/define.inc +++ b/cmake/define.inc @@ -25,6 +25,10 @@ IF (TD_STORAGE) ADD_DEFINITIONS(-D_STORAGE) ENDIF () +IF (TD_TOPIC) + ADD_DEFINITIONS(-D_TOPIC) +ENDIF () + IF (TD_GODLL) ADD_DEFINITIONS(-D_TD_GO_DLL_) ENDIF () diff --git a/cmake/input.inc b/cmake/input.inc index e8324887a0..b1a993c996 100755 --- a/cmake/input.inc +++ b/cmake/input.inc @@ -9,6 +9,14 @@ ELSEIF (${ACCOUNT} MATCHES "false") MESSAGE(STATUS "Build without account plugins") ENDIF () +IF (${TOPIC} MATCHES "true") + SET(TD_TOPIC TRUE) + MESSAGE(STATUS "Build with topic plugins") +ELSEIF (${TOPIC} MATCHES "false") + SET(TD_TOPIC FALSE) + MESSAGE(STATUS "Build without topic plugins") +ENDIF () + IF (${COVER} MATCHES "true") SET(TD_COVER TRUE) MESSAGE(STATUS "Build with test coverage") diff --git a/cmake/version.inc b/cmake/version.inc index 962f1f6040..05fbef5b87 100755 --- a/cmake/version.inc +++ b/cmake/version.inc @@ -4,7 +4,7 @@ PROJECT(TDengine) IF (DEFINED VERNUMBER) SET(TD_VER_NUMBER ${VERNUMBER}) ELSE () - SET(TD_VER_NUMBER "2.0.16.0") + SET(TD_VER_NUMBER "2.0.17.0") ENDIF () IF (DEFINED VERCOMPATIBLE) diff --git a/documentation20/cn/03.architecture/docs.md b/documentation20/cn/03.architecture/docs.md index dc710704e5..26d8bc55c2 100644 --- a/documentation20/cn/03.architecture/docs.md +++ b/documentation20/cn/03.architecture/docs.md @@ -166,7 +166,7 @@ TDengine 分布式架构的逻辑结构图如下： **虚拟节点(vnode)**: 为更好的支持数据分片、负载均衡，防止数据过热或倾斜，数据节点被虚拟化成多个虚拟节点(vnode，图中V2, V3, V4等)。每个 vnode 都是一个相对独立的工作单元，是时序数据存储的基本单元，具有独立的运行线程、内存空间与持久化存储的路径。一个 vnode 包含一定数量的表（数据采集点）。当创建一张新表时，系统会检查是否需要创建新的 vnode。一个数据节点上能创建的 vnode 的数量取决于该数据节点所在物理节点的硬件资源。一个 vnode 只属于一个DB，但一个DB可以有多个 vnode。一个 vnode 除存储的时序数据外，也保存有所包含的表的schema、标签值等。一个虚拟节点由所属的数据节点的EP，以及所属的VGroup ID在系统内唯一标识，由管理节点创建并管理。 -**管理节点(mnode):** 一个虚拟的逻辑单元，负责所有数据节点运行状态的监控和维护，以及节点之间的负载均衡(图中M)。同时，管理节点也负责元数据(包括用户、数据库、表、静态标签等)的存储和管理，因此也称为 Meta Node。TDengine 集群中可配置多个(最多不超过5个) mnode，它们自动构建成为一个虚拟管理节点组(图中M0, M1, M2)。mnode 间采用 master/slave 的机制进行管理，而且采取强一致方式进行数据同步, 任何数据更新操作只能在 Master 上进行。mnode 集群的创建由系统自动完成，无需人工干预。每个dnode上至多有一个mnode，由所属的数据节点的EP来唯一标识。每个dnode通过内部消息交互自动获取整个集群中所有 mnode 所在的 dnode 的EP。 +**管理节点(mnode):** 一个虚拟的逻辑单元，负责所有数据节点运行状态的监控和维护，以及节点之间的负载均衡(图中M)。同时，管理节点也负责元数据(包括用户、数据库、表、静态标签等)的存储和管理，因此也称为 Meta Node。TDengine 集群中可配置多个(开源版最多不超过3个) mnode，它们自动构建成为一个虚拟管理节点组(图中M0, M1, M2)。mnode 间采用 master/slave 的机制进行管理，而且采取强一致方式进行数据同步, 任何数据更新操作只能在 Master 上进行。mnode 集群的创建由系统自动完成，无需人工干预。每个dnode上至多有一个mnode，由所属的数据节点的EP来唯一标识。每个dnode通过内部消息交互自动获取整个集群中所有 mnode 所在的 dnode 的EP。 **虚拟节点组(VGroup):** 不同数据节点上的 vnode 可以组成一个虚拟节点组(vnode group)来保证系统的高可靠。虚拟节点组内采取master/slave的方式进行管理。写操作只能在 master vnode 上进行，系统采用异步复制的方式将数据同步到 slave vnode，这样确保了一份数据在多个物理节点上有拷贝。一个 vgroup 里虚拟节点个数就是数据的副本数。如果一个DB的副本数为N，系统必须有至少N个数据节点。副本数在创建DB时通过参数 replica 可以指定，缺省为1。使用 TDengine 的多副本特性，可以不再需要昂贵的磁盘阵列等存储设备，就可以获得同样的数据高可靠性。虚拟节点组由管理节点创建、管理，并且由管理节点分配一个系统唯一的ID，VGroup ID。如果两个虚拟节点的vnode group ID相同，说明他们属于同一个组，数据互为备份。虚拟节点组里虚拟节点的个数是可以动态改变的，容许只有一个，也就是没有数据复制。VGroup ID是永远不变的，即使一个虚拟节点组被删除，它的ID也不会被收回重复利用。 diff --git a/documentation20/cn/10.cluster/docs.md b/documentation20/cn/10.cluster/docs.md index 6d7d68fe1b..7b4073a883 100644 --- a/documentation20/cn/10.cluster/docs.md +++ b/documentation20/cn/10.cluster/docs.md @@ -225,7 +225,13 @@ SHOW MNODES; ## Arbitrator的使用 -如果副本数为偶数，当一个vnode group里一半vnode不工作时，是无法从中选出master的。同理，一半mnode不工作时，是无法选出mnode的master的，因为存在“split brain”问题。为解决这个问题，TDengine引入了Arbitrator的概念。Arbitrator模拟一个vnode或mnode在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含Arbitrator在内，超过半数的vnode或mnode工作，那么该vnode group或mnode组就可以正常的提供数据插入或查询服务。比如对于副本数为2的情形，如果一个节点A离线，但另外一个节点B正常，而且能连接到Arbitrator，那么节点B就能正常工作。 +如果副本数为偶数，当一个 vnode group 里一半 vnode 不工作时，是无法从中选出 master 的。同理，一半 mnode 不工作时，是无法选出 mnode 的 master 的，因为存在“split brain”问题。为解决这个问题，TDengine 引入了 Arbitrator 的概念。Arbitrator 模拟一个 vnode 或 mnode 在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含 Arbitrator 在内，超过半数的 vnode 或 mnode 工作，那么该 vnode group 或 mnode 组就可以正常的提供数据插入或查询服务。比如对于副本数为 2 的情形，如果一个节点 A 离线，但另外一个节点 B 正常，而且能连接到 Arbitrator，那么节点 B 就能正常工作。 -TDengine提供一个执行程序，名为 tarbitrator，找任何一台Linux服务器运行它即可。请点击[安装包下载](https://www.taosdata.com/cn/all-downloads/)，在TDengine Arbitrator Linux一节中，选择适合的版本下载并安装。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6042。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为Arbitrator的End Point。如果该参数配置了，当副本数为偶数时，系统将自动连接配置的Arbitrator。如果副本数为奇数，即使配置了Arbitrator，系统也不会去建立连接。 +总之，在目前版本下，TDengine 建议在双副本环境要配置 Arbitrator，以提升系统的可用性。 + +Arbitrator 的执行程序名为 tarbitrator。该程序对系统资源几乎没有要求，只需要保证有网络连接，找任何一台 Linux 服务器运行它即可。以下简要描述安装配置的步骤： +1. 请点击 [安装包下载](https://www.taosdata.com/cn/all-downloads/)，在 TDengine Arbitrator Linux 一节中，选择合适的版本下载并安装。 +2. 该应用的命令行参数 `-p` 可以指定其对外服务的端口号，缺省是 6042。 +3. 修改每个 taosd 实例的配置文件，在 taos.cfg 里将参数 arbitrator 设置为 tarbitrator 程序所对应的 End Point。（如果该参数配置了，当副本数为偶数时，系统将自动连接配置的 Arbitrator。如果副本数为奇数，即使配置了 Arbitrator，系统也不会去建立连接。） +4. 在配置文件中配置了的 Arbitrator，会出现在 `SHOW DNODES;` 指令的返回结果中，对应的 role 列的值会是“arb”。 diff --git a/documentation20/cn/11.administrator/docs.md b/documentation20/cn/11.administrator/docs.md index 86ad8e5bb9..52a0da6551 100644 --- a/documentation20/cn/11.administrator/docs.md +++ b/documentation20/cn/11.administrator/docs.md @@ -2,52 +2,52 @@ ## 容量规划 -使用TDengine来搭建一个物联网大数据平台，计算资源、存储资源需要根据业务场景进行规划。下面分别讨论系统运行所需要的内存、CPU以及硬盘空间。 +使用 TDengine 来搭建一个物联网大数据平台，计算资源、存储资源需要根据业务场景进行规划。下面分别讨论系统运行所需要的内存、CPU 以及硬盘空间。 ### 内存需求 -每个DB可以创建固定数目的vgroup，默认与CPU核数相同，可通过maxVgroupsPerDb配置；vgroup中的每个副本会是一个vnode；每个vnode会占用固定大小的内存（大小与数据库的配置参数blocks和cache有关)；每个Table会占用与标签总长度有关的内存；此外，系统会有一些固定的内存开销。因此，每个DB需要的系统内存可通过如下公式计算： +每个 DB 可以创建固定数目的 vgroup，默认与 CPU 核数相同，可通过 maxVgroupsPerDb 配置；vgroup 中的每个副本会是一个 vnode；每个 vnode 会占用固定大小的内存（大小与数据库的配置参数 blocks 和 cache 有关)；每个 Table 会占用与标签总长度有关的内存；此外，系统会有一些固定的内存开销。因此，每个 DB 需要的系统内存可通过如下公式计算： ``` -Memory Size = maxVgroupsPerDb * (blocks * cache + 10Mb) + numOfTables * (tagSizePerTable + 0.5Kb) +Memory Size = maxVgroupsPerDb * (blocks * cache + 10MB) + numOfTables * (tagSizePerTable + 0.5KB) ``` -示例：假设是4核机器，cache是缺省大小16M, blocks是缺省值6，假设有10万张表，标签总长度是256字节，则总的内存需求为：4\*(16\*6+10) + 100000\*(0.25+0.5)/1000 = 499M。 +示例：假设是 4 核机器，cache 是缺省大小 16M, blocks 是缺省值 6，假设有 10 万张表，标签总长度是 256 字节，则总的内存需求为：4 \* (16 \* 6 + 10) + 100000 \* (0.25 + 0.5) / 1000 = 499M。 -实际运行的系统往往会根据数据特点的不同，将数据存放在不同的DB里。因此做规划时，也需要考虑。 +实际运行的系统往往会根据数据特点的不同，将数据存放在不同的 DB 里。因此做规划时，也需要考虑。 -如果内存充裕，可以加大Blocks的配置，这样更多数据将保存在内存里，提高查询速度。 +如果内存充裕，可以加大 Blocks 的配置，这样更多数据将保存在内存里，提高查询速度。 -### CPU需求 +### CPU 需求 -CPU的需求取决于如下两方面： +CPU 的需求取决于如下两方面： -* __数据插入__ TDengine单核每秒能至少处理一万个插入请求。每个插入请求可以带多条记录，一次插入一条记录与插入10条记录，消耗的计算资源差别很小。因此每次插入，条数越大，插入效率越高。如果一个插入请求带200条以上记录，单核就能达到每秒插入100万条记录的速度。但对前端数据采集的要求越高，因为需要缓存记录，然后一批插入。 -* __查询需求__ TDengine提供高效的查询，但是每个场景的查询差异很大，查询频次变化也很大，难以给出客观数字。需要用户针对自己的场景，写一些查询语句，才能确定。 +* __数据插入__ TDengine 单核每秒能至少处理一万个插入请求。每个插入请求可以带多条记录，一次插入一条记录与插入 10 条记录，消耗的计算资源差别很小。因此每次插入，条数越大，插入效率越高。如果一个插入请求带 200 条以上记录，单核就能达到每秒插入 100 万条记录的速度。但对前端数据采集的要求越高，因为需要缓存记录，然后一批插入。 +* __查询需求__ TDengine 提供高效的查询，但是每个场景的查询差异很大，查询频次变化也很大，难以给出客观数字。需要用户针对自己的场景，写一些查询语句，才能确定。 -因此仅对数据插入而言，CPU是可以估算出来的，但查询所耗的计算资源无法估算。在实际运营过程中，不建议CPU使用率超过50%，超过后，需要增加新的节点，以获得更多计算资源。 +因此仅对数据插入而言，CPU 是可以估算出来的，但查询所耗的计算资源无法估算。在实际运营过程中，不建议 CPU 使用率超过 50%，超过后，需要增加新的节点，以获得更多计算资源。 ### 存储需求 -TDengine相对于通用数据库，有超高的压缩比，在绝大多数场景下，TDengine的压缩比不会低于5倍，有的场合，压缩比可达到10倍以上，取决于实际场景的数据特征。压缩前的原始数据大小可通过如下方式计算： +TDengine 相对于通用数据库，有超高的压缩比，在绝大多数场景下，TDengine 的压缩比不会低于 5 倍，有的场合，压缩比可达到 10 倍以上，取决于实际场景的数据特征。压缩前的原始数据大小可通过如下方式计算： ``` Raw DataSize = numOfTables * rowSizePerTable * rowsPerTable ``` -示例：1000万台智能电表，每台电表每15分钟采集一次数据，每次采集的数据128字节，那么一年的原始数据量是：10000000\*128\*24\*60/15\*365 = 44.8512T。TDengine大概需要消耗44.851/5=8.97024T空间。 +示例：1000 万台智能电表，每台电表每 15 分钟采集一次数据，每次采集的数据 128 字节，那么一年的原始数据量是：10000000 \* 128 \* 24 \* 60 / 15 \* 365 = 44.8512T。TDengine大概需要消耗 44.851 / 5 = 8.97024T 空间。 -用户可以通过参数keep，设置数据在磁盘中的最大保存时长。为进一步减少存储成本，TDengine还提供多级存储，最冷的数据可以存放在最廉价的存储介质上，应用的访问不用做任何调整，只是读取速度降低了。 +用户可以通过参数 keep，设置数据在磁盘中的最大保存时长。为进一步减少存储成本，TDengine 还提供多级存储，最冷的数据可以存放在最廉价的存储介质上，应用的访问不用做任何调整，只是读取速度降低了。 -为提高速度，可以配置多块硬盘，这样可以并发写入或读取数据。需要提醒的是，TDengine采取多副本的方式提供数据的高可靠，因此不再需要采用昂贵的磁盘阵列。 +为提高速度，可以配置多块硬盘，这样可以并发写入或读取数据。需要提醒的是，TDengine 采取多副本的方式提供数据的高可靠，因此不再需要采用昂贵的磁盘阵列。 ### 物理机或虚拟机台数 -根据上面的内存、CPU、存储的预估，就可以知道整个系统需要多少核、多少内存、多少存储空间。如果数据副本数不为1，总需求量需要再乘以副本数。 +根据上面的内存、CPU、存储的预估，就可以知道整个系统需要多少核、多少内存、多少存储空间。如果数据副本数不为 1，总需求量需要再乘以副本数。 -因为TDengine具有很好的水平扩展能力，根据总量，再根据单个物理机或虚拟机的资源，就可以轻松决定需要购置多少台物理机或虚拟机了。 +因为 TDengine 具有很好的水平扩展能力，根据总量，再根据单个物理机或虚拟机的资源，就可以轻松决定需要购置多少台物理机或虚拟机了。 -**立即计算CPU、内存、存储，请参见：[资源估算方法](https://www.taosdata.com/config/config.html)** +**立即计算 CPU、内存、存储，请参见：[资源估算方法](https://www.taosdata.com/config/config.html)** ## 容错和灾备 @@ -432,60 +432,62 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下 ## TDengine参数限制与保留关键字 -- 数据库名：不能包含“.”以及特殊字符，不能超过32个字符 -- 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过192个字符 -- 表的列名：不能包含特殊字符，不能超过64个字符 +- 数据库名：不能包含“.”以及特殊字符，不能超过 32 个字符 +- 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过 192 个字符 +- 表的列名：不能包含特殊字符，不能超过 64 个字符 - 数据库名、表名、列名，都不能以数字开头 -- 表的列数：不能超过1024列 -- 记录的最大长度：包括时间戳8 byte，不能超过16KB -- 单条SQL语句默认最大字符串长度：65480 byte -- 数据库副本数：不能超过3 -- 用户名：不能超过23个byte -- 用户密码：不能超过15个byte -- 标签(Tags)数量：不能超过128个 -- 标签的总长度：不能超过16Kbyte +- 表的列数：不能超过 1024 列 +- 记录的最大长度：包括时间戳 8 byte，不能超过 16KB（每个 BINARY/NCHAR 类型的列还会额外占用 2 个 byte 的存储位置） +- 单条 SQL 语句默认最大字符串长度：65480 byte +- 数据库副本数：不能超过 3 +- 用户名：不能超过 23 个 byte +- 用户密码：不能超过 15 个 byte +- 标签(Tags)数量：不能超过 128 个 +- 标签的总长度：不能超过 16K byte - 记录条数：仅受存储空间限制 - 表的个数：仅受节点个数限制 - 库的个数：仅受节点个数限制 -- 单个库上虚拟节点个数：不能超过64个 +- 单个库上虚拟节点个数：不能超过 64 个 -目前TDengine有将近200个内部保留关键字，这些关键字无论大小写均不可以用作库名、表名、STable名、数据列名及标签列名等。这些关键字列表如下： +目前 TDengine 有将近 200 个内部保留关键字，这些关键字无论大小写均不可以用作库名、表名、STable 名、数据列名及标签列名等。这些关键字列表如下： | 关键字列表 | | | | | | ---------- | ----------- | ------------ | ---------- | --------- | -| ABLOCKS | CONNECTION | GROUP | MINUS | SLASH | -| ABORT | CONNECTIONS | GT | MNODES | SLIDING | -| ACCOUNT | COPY | ID | MODULES | SMALLINT | -| ACCOUNTS | COUNT | IF | NCHAR | SPREAD | -| ADD | CREATE | IGNORE | NE | STABLE | -| AFTER | CTIME | IMMEDIATE | NONE | STABLES | -| ALL | DATABASE | IMPORT | NOT | STAR | -| ALTER | DATABASES | IN | NOTNULL | STATEMENT | -| AND | DAYS | INITIALLY | NOW | STDDEV | -| AS | DEFERRED | INSERT | OF | STREAM | -| ASC | DELIMITERS | INSTEAD | OFFSET | STREAMS | -| ATTACH | DESC | INTEGER | OR | STRING | -| AVG | DESCRIBE | INTERVAL | ORDER | SUM | -| BEFORE | DETACH | INTO | PASS | TABLE | -| BEGIN | DIFF | IP | PERCENTILE | TABLES | -| BETWEEN | DISTINCT | IS | PLUS | TAG | -| BIGINT | DIVIDE | ISNULL | PRAGMA | TAGS | -| BINARY | DNODE | JOIN | PREV | TBLOCKS | -| BITAND | DNODES | KEEP | PRIVILEGE | TBNAME | -| BITNOT | DOT | KEY | QUERIES | TIMES | -| BITOR | DOUBLE | KILL | QUERY | TIMESTAMP | -| BOOL | DROP | LAST | RAISE | TINYINT | -| BOTTOM | EACH | LE | REM | TOP | -| BY | END | LEASTSQUARES | REPLACE | TRIGGER | -| CACHE | EQ | LIKE | REPLICA | UMINUS | -| CASCADE | EXISTS | LIMIT | RESET | UPLUS | -| CHANGE | EXPLAIN | LINEAR | RESTRICT | USE | -| CLOG | FAIL | LOCAL | ROW | USER | -| CLUSTER | FILL | LP | ROWS | USERS | -| COLON | FIRST | LSHIFT | RP | USING | -| COLUMN | FLOAT | LT | RSHIFT | VALUES | -| COMMA | FOR | MATCH | SCORES | VARIABLE | -| COMP | FROM | MAX | SELECT | VGROUPS | -| CONCAT | GE | METRIC | SEMI | VIEW | -| CONFIGS | GLOB | METRICS | SET | WAVG | -| CONFLICT | GRANTS | MIN | SHOW | WHERE | +| ABLOCKS | CONNECTIONS | GT | MNODES | SLIDING | +| ABORT | COPY | ID | MODULES | SLIMIT | +| ACCOUNT | COUNT | IF | NCHAR | SMALLINT | +| ACCOUNTS | CREATE | IGNORE | NE | SPREAD | +| ADD | CTIME | IMMEDIATE | NONE | STABLE | +| AFTER | DATABASE | IMPORT | NOT | STABLES | +| ALL | DATABASES | IN | NOTNULL | STAR | +| ALTER | DAYS | INITIALLY | NOW | STATEMENT | +| AND | DEFERRED | INSERT | OF | STDDEV | +| AS | DELIMITERS | INSTEAD | OFFSET | STREAM | +| ASC | DESC | INTEGER | OR | STREAMS | +| ATTACH | DESCRIBE | INTERVAL | ORDER | STRING | +| AVG | DETACH | INTO | PASS | SUM | +| BEFORE | DIFF | IP | PERCENTILE | TABLE | +| BEGIN | DISTINCT | IS | PLUS | TABLES | +| BETWEEN | DIVIDE | ISNULL | PRAGMA | TAG | +| BIGINT | DNODE | JOIN | PREV | TAGS | +| BINARY | DNODES | KEEP | PRIVILEGE | TBLOCKS | +| BITAND | DOT | KEY | QUERIES | TBNAME | +| BITNOT | DOUBLE | KILL | QUERY | TIMES | +| BITOR | DROP | LAST | RAISE | TIMESTAMP | +| BOOL | EACH | LE | REM | TINYINT | +| BOTTOM | END | LEASTSQUARES | REPLACE | TOP | +| BY | EQ | LIKE | REPLICA | TRIGGER | +| CACHE | EXISTS | LIMIT | RESET | UMINUS | +| CASCADE | EXPLAIN | LINEAR | RESTRICT | UPLUS | +| CHANGE | FAIL | LOCAL | ROW | USE | +| CLOG | FILL | LP | ROWS | USER | +| CLUSTER | FIRST | LSHIFT | RP | USERS | +| COLON | FLOAT | LT | RSHIFT | USING | +| COLUMN | FOR | MATCH | SCORES | VALUES | +| COMMA | FROM | MAX | SELECT | VARIABLE | +| COMP | GE | METRIC | SEMI | VGROUPS | +| CONCAT | GLOB | METRICS | SET | VIEW | +| CONFIGS | GRANTS | MIN | SHOW | WAVG | +| CONFLICT | GROUP | MINUS | SLASH | WHERE | +| CONNECTION | | | | | + diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md index aba8faa677..c89dbda7a0 100644 --- a/documentation20/cn/12.taos-sql/docs.md +++ b/documentation20/cn/12.taos-sql/docs.md @@ -1,17 +1,19 @@ # TAOS SQL -本文档说明TAOS SQL支持的语法规则、主要查询功能、支持的SQL查询函数，以及常用技巧等内容。阅读本文档需要读者具有基本的SQL语言的基础。 +本文档说明 TAOS SQL 支持的语法规则、主要查询功能、支持的 SQL 查询函数，以及常用技巧等内容。阅读本文档需要读者具有基本的 SQL 语言的基础。 -TAOS SQL是用户对TDengine进行数据写入和查询的主要工具。TAOS SQL为了便于用户快速上手，在一定程度上提供类似于标准SQL类似的风格和模式。严格意义上，TAOS SQL并不是也不试图提供SQL标准的语法。此外，由于TDengine针对的时序性结构化数据不提供删除功能，因此在TAO SQL中不提供数据删除的相关功能。 +TAOS SQL 是用户对 TDengine 进行数据写入和查询的主要工具。TAOS SQL 为了便于用户快速上手，在一定程度上提供类似于标准 SQL 类似的风格和模式。严格意义上，TAOS SQL 并不是也不试图提供 SQL 标准的语法。此外，由于 TDengine 针对的时序性结构化数据不提供删除功能，因此在 TAO SQL 中不提供数据删除的相关功能。 -本章节SQL语法遵循如下约定： +TAOS SQL 不支持关键字的缩写，例如 DESCRIBE 不能缩写为 DESC。 -- < > 里的内容是用户需要输入的，但不要输入<>本身 -- [ ]表示内容为可选项，但不能输入[]本身 -- | 表示多选一，选择其中一个即可，但不能输入|本身 +本章节 SQL 语法遵循如下约定： + +- < > 里的内容是用户需要输入的，但不要输入 <> 本身 +- [ ] 表示内容为可选项，但不能输入 [] 本身 +- | 表示多选一，选择其中一个即可，但不能输入 | 本身 - … 表示前面的项可重复多个 -为更好地说明SQL语法的规则及其特点，本文假设存在一个数据集。以智能电表(meters)为例，假设每个智能电表采集电流、电压、相位三个量。其建模如下： +为更好地说明 SQL 语法的规则及其特点，本文假设存在一个数据集。以智能电表(meters)为例，假设每个智能电表采集电流、电压、相位三个量。其建模如下： ```mysql taos> DESCRIBE meters; Field | Type | Length | Note | @@ -23,7 +25,7 @@ taos> DESCRIBE meters; location | BINARY | 64 | TAG | groupid | INT | 4 | TAG | ``` -数据集包含4个智能电表的数据，按照TDengine的建模规则，对应4个子表，其名称分别是 d1001, d1002, d1003, d1004。 +数据集包含 4 个智能电表的数据，按照 TDengine 的建模规则，对应 4 个子表，其名称分别是 d1001, d1002, d1003, d1004。 ## 支持的数据类型 @@ -113,7 +115,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic ```mysql ALTER DATABASE db_name QUORUM 2; ``` - QUORUM 参数是指数据写入成功所需要的确认数，取值范围 [1, 3]。对于异步复制，quorum 设为 1，具有 master 角色的虚拟节点自己确认即可。对于同步复制，需要至少大于等于 2。原则上，Quorum >= 1 并且 Quorum <= replica(副本数)，这个参数在启动一个同步模块实例时需要提供。 + QUORUM 参数是指数据写入成功所需要的确认数，取值范围 [1, 2]。对于异步复制，quorum 设为 1，具有 master 角色的虚拟节点自己确认即可。对于同步复制，需要至少大于等于 2。原则上，Quorum >= 1 并且 Quorum <= replica(副本数)，这个参数在启动一个同步模块实例时需要提供。 ```mysql ALTER DATABASE db_name BLOCKS 100; @@ -142,15 +144,15 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic ``` 说明： - 1) 表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键； + 1) 表的第一个字段必须是 TIMESTAMP，并且系统自动将其设为主键； - 2) 表名最大长度为192； + 2) 表名最大长度为 192； - 3) 表的每行长度不能超过16k个字符; + 3) 表的每行长度不能超过 16k 个字符;（注意：每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置） 4) 子表名只能由字母、数字和下划线组成，且不能以数字开头 - 5) 使用数据类型binary或nchar，需指定其最长的字节数，如binary(20)，表示20字节； + 5) 使用数据类型 binary 或 nchar，需指定其最长的字节数，如 binary(20)，表示 20 字节； - **以超级表为模板创建数据表** @@ -402,8 +404,8 @@ SELECT select_expr [, select_expr ...] FROM {tb_name_list} [WHERE where_condition] [INTERVAL (interval_val [, interval_offset])] + [SLIDING sliding_val] [FILL fill_val] - [SLIDING fill_val] [GROUP BY col_list] [ORDER BY col_list { DESC | ASC }] [SLIMIT limit_val [, SOFFSET offset_val]] @@ -619,10 +621,11 @@ taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2; Query OK, 1 row(s) in set (0.001091s) ``` -- 可以使用* 返回所有列，或指定列名。可以对数字列进行四则运算，可以给输出的列取列名 -- where语句可以使用各种逻辑判断来过滤数字值，或使用通配符来过滤字符串 -- 输出结果缺省按首列时间戳升序排序，但可以指定按降序排序(_c0指首列时间戳)。使用ORDER BY对其他字段进行排序为非法操作。 -- 参数LIMIT控制输出条数，OFFSET指定从第几条开始输出。LIMIT/OFFSET对结果集的执行顺序在ORDER BY之后。 +- 可以使用 * 返回所有列，或指定列名。可以对数字列进行四则运算，可以给输出的列取列名 +- WHERE 语句可以使用各种逻辑判断来过滤数字值，或使用通配符来过滤字符串 +- 输出结果缺省按首列时间戳升序排序，但可以指定按降序排序( _c0 指首列时间戳)。使用 ORDER BY 对其他字段进行排序为非法操作。 +- 参数 LIMIT 控制输出条数，OFFSET 指定从第几条开始输出。LIMIT/OFFSET 对结果集的执行顺序在 ORDER BY 之后。 +- 参数 SLIMIT 控制由 GROUP BY 指令划分的每个分组中的输出条数。 - 通过”>>"输出结果可以导出到指定文件 ### 支持的条件过滤操作 @@ -1162,17 +1165,20 @@ TDengine支持按时间段进行聚合，可以将表中数据按照时间段进 SELECT function_list FROM tb_name [WHERE where_condition] INTERVAL (interval [, offset]) + [SLIDING sliding] [FILL ({NONE | VALUE | PREV | NULL | LINEAR})] SELECT function_list FROM stb_name [WHERE where_condition] INTERVAL (interval [, offset]) + [SLIDING sliding] [FILL ({ VALUE | PREV | NULL | LINEAR})] [GROUP BY tags] ``` - 聚合时间段的长度由关键词INTERVAL指定，最短时间间隔10毫秒（10a），并且支持偏移（偏移必须小于间隔）。聚合查询中，能够同时执行的聚合和选择函数仅限于单个输出的函数：count、avg、sum 、stddev、leastsquares、percentile、min、max、first、last，不能使用具有多行输出结果的函数（例如：top、bottom、diff以及四则运算）。 - WHERE语句可以指定查询的起止时间和其他过滤条件 +- SLIDING语句用于指定聚合时间段的前向增量 - FILL语句指定某一时间区间数据缺失的情况下的填充模式。填充模式包括以下几种： * 不进行填充：NONE(默认填充模式)。 * VALUE填充：固定值填充，此时需要指定填充的数值。例如：fill(value, 1.23)。 @@ -1184,6 +1190,8 @@ SELECT function_list FROM stb_name 2. 在时间维度聚合中，返回的结果中时间序列严格单调递增。 3. 如果查询对象是超级表，则聚合函数会作用于该超级表下满足值过滤条件的所有表的数据。如果查询中没有使用group by语句，则返回的结果按照时间序列严格单调递增；如果查询中使用了group by语句分组，则返回结果中每个group内不按照时间序列严格单调递增。 +时间聚合也常被用于连续查询场景，可以参考文档 [连续查询(Continuous Query)](https://www.taosdata.com/cn/documentation/advanced-features#continuous-query)。 + **示例:** 智能电表的建表语句如下： ```mysql @@ -1202,11 +1210,11 @@ SELECT AVG(current), MAX(current), LEASTSQUARES(current, start_val, step_val), P ## TAOS SQL 边界限制 -- 数据库名最大长度为32 -- 表名最大长度为192，每行数据最大长度16k个字符 -- 列名最大长度为64，最多允许1024列，最少需要2列，第一列必须是时间戳 -- 标签最多允许128个，可以1个，标签总长度不超过16k个字符 -- SQL语句最大长度65480个字符，但可通过系统配置参数maxSQLLength修改，最长可配置为1M +- 数据库名最大长度为 32 +- 表名最大长度为 192，每行数据最大长度 16k 个字符（注意：数据行内每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置） +- 列名最大长度为 64，最多允许 1024 列，最少需要 2 列，第一列必须是时间戳 +- 标签最多允许 128 个，可以 1 个，标签总长度不超过 16k 个字符 +- SQL 语句最大长度 65480 个字符，但可通过系统配置参数 maxSQLLength 修改，最长可配置为 1M - 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制 ## TAOS SQL其他约定 @@ -1221,4 +1229,5 @@ TAOS SQL支持表之间按主键时间戳来join两张表的列，暂不支持 **is not null与不为空的表达式适用范围** -is not null支持所有类型的列。不为空的表达式为 <>""，仅对非数值类型的列适用。 \ No newline at end of file +is not null支持所有类型的列。不为空的表达式为 <>""，仅对非数值类型的列适用。 + diff --git a/documentation20/cn/13.faq/docs.md b/documentation20/cn/13.faq/docs.md index 727ccf653f..d3169d507a 100644 --- a/documentation20/cn/13.faq/docs.md +++ b/documentation20/cn/13.faq/docs.md @@ -92,6 +92,8 @@ TDengine 目前尚不支持删除功能，未来根据用户需求可能会支 从 2.0.8.0 开始，TDengine 支持更新已经写入数据的功能。使用更新功能需要在创建数据库时使用 UPDATE 1 参数，之后可以使用 INSERT INTO 命令更新已经写入的相同时间戳数据。UPDATE 参数不支持 ALTER DATABASE 命令修改。没有使用 UPDATE 1 参数创建的数据库，写入相同时间戳的数据不会修改之前的数据，也不会报错。 +另需注意，在 UPDATE 设置为 0 时，后发送的相同时间戳的数据会被直接丢弃，但并不会报错，而且仍然会被计入 affected rows （所以不能利用 INSERT 指令的返回信息进行时间戳查重）。这样设计的主要原因是，TDengine 把写入的数据看做一个数据流，无论时间戳是否出现冲突，TDengine 都认为产生数据的原始设备真实地产生了这样的数据。UPDATE 参数只是控制这样的流数据在进行持久化时要怎样处理——UPDATE 为 0 时，表示先写入的数据覆盖后写入的数据；而 UPDATE 为 1 时，表示后写入的数据覆盖先写入的数据。这种覆盖关系如何选择，取决于对数据的后续使用和统计中，希望以先还是后生成的数据为准。 + ## 10. 我怎么创建超过1024列的表？ 使用2.0及其以上版本，默认支持1024列；2.0之前的版本，TDengine最大允许创建250列的表。但是如果确实超过限值，建议按照数据特性，逻辑地将这个宽表分解成几个小表。 diff --git a/packaging/docker/Dockerfile b/packaging/docker/Dockerfile index 230741d036..629f8f9fd6 100644 --- a/packaging/docker/Dockerfile +++ b/packaging/docker/Dockerfile @@ -12,9 +12,13 @@ RUN tar -zxf ${pkgFile} WORKDIR /root/${dirName}/ RUN /bin/bash install.sh -e no +RUN apt-get clean && apt-get update && apt-get install -y locales +RUN locale-gen en_US.UTF-8 ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/lib" -ENV LANG=C.UTF-8 -ENV LC_ALL=C.UTF-8 +ENV LC_CTYPE=en_US.UTF-8 +ENV LANG=en_US.UTF-8 +ENV LC_ALL=en_US.UTF-8 + EXPOSE 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 CMD ["taosd"] VOLUME [ "/var/lib/taos", "/var/log/taos","/etc/taos/" ] diff --git a/packaging/docker/dockerManifest.sh b/packaging/docker/dockerManifest.sh index b52580cfa6..c846e8345d 100755 --- a/packaging/docker/dockerManifest.sh +++ b/packaging/docker/dockerManifest.sh @@ -36,10 +36,10 @@ done echo "verNumber=${verNumber}" #docker manifest create -a tdengine/tdengine:${verNumber} tdengine/tdengine-amd64:${verNumber} tdengine/tdengine-aarch64:${verNumber} tdengine/tdengine-aarch32:${verNumber} -docker manifest create -a tdengine/tdengine tdengine/tdengine-amd64:latest tdengine/tdengine-aarch64:latest tdengine/tdengine-aarch32:latest +docker manifest create -a tdengine/tdengine:latest tdengine/tdengine-amd64:latest tdengine/tdengine-aarch64:latest tdengine/tdengine-aarch32:latest docker login -u tdengine -p ${passWord} #replace the docker registry username and password -docker manifest push tdengine/tdengine +docker manifest push tdengine/tdengine:latest # how set latest version ??? diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml index 7b6bfee42b..c7ed621815 100644 --- a/snap/snapcraft.yaml +++ b/snap/snapcraft.yaml @@ -1,6 +1,6 @@ name: tdengine base: core18 -version: '2.0.16.0' +version: '2.0.17.0' icon: snap/gui/t-dengine.svg summary: an open-source big data platform designed and optimized for IoT. description: | @@ -72,7 +72,7 @@ parts: - usr/bin/taosd - usr/bin/taos - usr/bin/taosdemo - - usr/lib/libtaos.so.2.0.16.0 + - usr/lib/libtaos.so.2.0.17.0 - usr/lib/libtaos.so.1 - usr/lib/libtaos.so diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index d5f8f420bf..7219e56cb9 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -1872,6 +1872,24 @@ void setResultColName(char* name, tSqlExprItem* pItem, int32_t functionId, SStrT } } + +void setLastOrderForGoupBy(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo) { // todo refactor + SSqlGroupbyExpr* pGroupBy = &pQueryInfo->groupbyExpr; + if (pGroupBy->numOfGroupCols > 0) { + size_t idx = taosArrayGetSize(pQueryInfo->exprList); + for(int32_t k = 0; k < pGroupBy->numOfGroupCols; ++k) { + SColIndex* pIndex = taosArrayGet(pGroupBy->columnInfo, k); + if (!TSDB_COL_IS_TAG(pIndex->flag) && pIndex->colIndex < tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) { // group by normal columns + SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, idx - 1); + pExpr->numOfParams = 1; + pExpr->param->i64 = TSDB_ORDER_ASC; + + break; + } + } + } +} + int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t colIndex, tSqlExprItem* pItem, bool finalResult) { STableMetaInfo* pTableMetaInfo = NULL; int32_t optr = pItem->pNode->nSQLOptr; @@ -2152,6 +2170,10 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col if (setExprInfoForFunctions(pCmd, pQueryInfo, &pSchema[j], cvtFunc, name, colIndex++, &index, finalResult) != 0) { return TSDB_CODE_TSC_INVALID_SQL; } + + if (optr == TK_LAST) { + setLastOrderForGoupBy(pQueryInfo, pTableMetaInfo); + } } } else { @@ -2173,24 +2195,12 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col bool multiColOutput = pItem->pNode->pParam->nExpr > 1; setResultColName(name, pItem, cvtFunc.originFuncId, &pParamElem->pNode->colInfo, multiColOutput); - if (setExprInfoForFunctions(pCmd, pQueryInfo, pSchema, cvtFunc, name, colIndex + i, &index, finalResult) != 0) { + if (setExprInfoForFunctions(pCmd, pQueryInfo, pSchema, cvtFunc, name, colIndex++, &index, finalResult) != 0) { return TSDB_CODE_TSC_INVALID_SQL; } - if (optr == TK_LAST) { // todo refactor - SSqlGroupbyExpr* pGroupBy = &pQueryInfo->groupbyExpr; - if (pGroupBy->numOfGroupCols > 0) { - for(int32_t k = 0; k < pGroupBy->numOfGroupCols; ++k) { - SColIndex* pIndex = taosArrayGet(pGroupBy->columnInfo, k); - if (!TSDB_COL_IS_TAG(pIndex->flag) && pIndex->colIndex < tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) { // group by normal columns - SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, colIndex + i); - pExpr->numOfParams = 1; - pExpr->param->i64 = TSDB_ORDER_ASC; - - break; - } - } - } + if (optr == TK_LAST) { + setLastOrderForGoupBy(pQueryInfo, pTableMetaInfo); } } } @@ -2220,6 +2230,10 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col } colIndex++; + + if (optr == TK_LAST) { + setLastOrderForGoupBy(pQueryInfo, pTableMetaInfo); + } } numOfFields += tscGetNumOfColumns(pTableMetaInfo->pTableMeta); @@ -5614,6 +5628,8 @@ static void setCreateDBOption(SCreateDbMsg* pMsg, SCreateDbInfo* pCreateDb) { pMsg->ignoreExist = pCreateDb->ignoreExists; pMsg->update = pCreateDb->update; pMsg->cacheLastRow = pCreateDb->cachelast; + pMsg->dbType = pCreateDb->dbType; + pMsg->partitions = htons(pCreateDb->partitions); } int32_t parseCreateDBOptions(SSqlCmd* pCmd, SCreateDbInfo* pCreateDbSql) { @@ -6244,6 +6260,15 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg* pCreate) { return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg); } + val = (int16_t)htons(pCreate->partitions); + if (val != -1 && + (val < TSDB_MIN_DB_PARTITON_OPTION || val > TSDB_MAX_DB_PARTITON_OPTION)) { + snprintf(msg, tListLen(msg), "invalid topic option partition: %d valid range: [%d, %d]", val, + TSDB_MIN_DB_PARTITON_OPTION, TSDB_MAX_DB_PARTITON_OPTION); + return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg); + } + + return TSDB_CODE_SUCCESS; } diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c index d005eaf75c..9e43ae674d 100644 --- a/src/client/src/tscServer.c +++ b/src/client/src/tscServer.c @@ -1055,7 +1055,8 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) { int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) { SSqlCmd *pCmd = &pSql->cmd; pCmd->payloadLen = sizeof(SCreateDbMsg); - pCmd->msgType = TSDB_MSG_TYPE_CM_CREATE_DB; + + pCmd->msgType = (pInfo->pMiscInfo->dbOpt.dbType == TSDB_DB_TYPE_DEFAULT) ? TSDB_MSG_TYPE_CM_CREATE_DB : TSDB_MSG_TYPE_CM_CREATE_TP; SCreateDbMsg *pCreateDbMsg = (SCreateDbMsg *)pCmd->payload; @@ -1187,7 +1188,7 @@ int32_t tscBuildDropDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) { pDropDbMsg->ignoreNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0; - pCmd->msgType = TSDB_MSG_TYPE_CM_DROP_DB; + pCmd->msgType = (pInfo->pMiscInfo->dbType == TSDB_DB_TYPE_DEFAULT) ? TSDB_MSG_TYPE_CM_DROP_DB : TSDB_MSG_TYPE_CM_DROP_TP; return TSDB_CODE_SUCCESS; } @@ -1514,9 +1515,11 @@ int tscBuildUpdateTagMsg(SSqlObj* pSql, SSqlInfo *pInfo) { int tscAlterDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) { SSqlCmd *pCmd = &pSql->cmd; pCmd->payloadLen = sizeof(SAlterDbMsg); - pCmd->msgType = TSDB_MSG_TYPE_CM_ALTER_DB; + pCmd->msgType = (pInfo->pMiscInfo->dbOpt.dbType == TSDB_DB_TYPE_DEFAULT) ? TSDB_MSG_TYPE_CM_ALTER_DB : TSDB_MSG_TYPE_CM_ALTER_TP; SAlterDbMsg *pAlterDbMsg = (SAlterDbMsg* )pCmd->payload; + pAlterDbMsg->dbType = -1; + STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0); tNameExtractFullName(&pTableMetaInfo->name, pAlterDbMsg->db); diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c index 78e9c68290..e577291966 100644 --- a/src/client/src/tscSubquery.c +++ b/src/client/src/tscSubquery.c @@ -1941,7 +1941,11 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) { // tag or group by column if (TSDB_COL_IS_TAG(pExpr->colInfo.flag) || pExpr->functionId == TSDB_FUNC_PRJ) { - memcpy(p + offset, row[i], length[i]); + if (row[i] == NULL) { + setNull(p + offset, pExpr->resType, pExpr->resBytes); + } else { + memcpy(p + offset, row[i], length[i]); + } offset += pExpr->resBytes; } } diff --git a/src/common/inc/tglobal.h b/src/common/inc/tglobal.h index c6d0226244..df1a622101 100644 --- a/src/common/inc/tglobal.h +++ b/src/common/inc/tglobal.h @@ -95,6 +95,7 @@ extern int8_t tsCompression; extern int8_t tsWAL; extern int32_t tsFsyncPeriod; extern int32_t tsReplications; +extern int16_t tsPartitons; extern int32_t tsQuorum; extern int8_t tsUpdate; extern int8_t tsCacheLastRow; diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c index 4ed4e0473b..9e405fdfe1 100644 --- a/src/common/src/tglobal.c +++ b/src/common/src/tglobal.c @@ -126,8 +126,9 @@ int8_t tsWAL = TSDB_DEFAULT_WAL_LEVEL; int32_t tsFsyncPeriod = TSDB_DEFAULT_FSYNC_PERIOD; int32_t tsReplications = TSDB_DEFAULT_DB_REPLICA_OPTION; int32_t tsQuorum = TSDB_DEFAULT_DB_QUORUM_OPTION; +int16_t tsPartitons = TSDB_DEFAULT_DB_PARTITON_OPTION; int8_t tsUpdate = TSDB_DEFAULT_DB_UPDATE_OPTION; -int8_t tsCacheLastRow = TSDB_DEFAULT_CACHE_BLOCK_SIZE; +int8_t tsCacheLastRow = TSDB_DEFAULT_CACHE_LAST_ROW; int32_t tsMaxVgroupsPerDb = 0; int32_t tsMinTablePerVnode = TSDB_TABLES_STEP; int32_t tsMaxTablePerVnode = TSDB_DEFAULT_TABLES; @@ -853,6 +854,16 @@ static void doInitGlobalConfig(void) { cfg.unitType = TAOS_CFG_UTYPE_NONE; taosInitConfigOption(cfg); + cfg.option = "partitions"; + cfg.ptr = &tsPartitons; + cfg.valType = TAOS_CFG_VTYPE_INT16; + cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW; + cfg.minValue = TSDB_MIN_DB_PARTITON_OPTION; + cfg.maxValue = TSDB_MAX_DB_PARTITON_OPTION; + cfg.ptrLength = 0; + cfg.unitType = TAOS_CFG_UTYPE_NONE; + taosInitConfigOption(cfg); + cfg.option = "quorum"; cfg.ptr = &tsQuorum; cfg.valType = TAOS_CFG_VTYPE_INT32; diff --git a/src/connector/jdbc/pom.xml b/src/connector/jdbc/pom.xml index 7a421eff22..f1e013e864 100755 --- a/src/connector/jdbc/pom.xml +++ b/src/connector/jdbc/pom.xml @@ -102,6 +102,7 @@ **/*Test.java + **/DatetimeBefore1970Test.java **/AppMemoryLeakTest.java **/AuthenticationTest.java **/TaosInfoMonitorTest.java diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDriver.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDriver.java index 21bf8e7a93..28b7bd6a5f 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDriver.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDriver.java @@ -1,76 +1,12 @@ package com.taosdata.jdbc; -import java.io.*; import java.sql.Driver; import java.sql.DriverPropertyInfo; -import java.util.ArrayList; -import java.util.List; import java.util.Properties; import java.util.StringTokenizer; public abstract class AbstractDriver implements Driver { - private static final String TAOS_CFG_FILENAME = "taos.cfg"; - - /** - * @param cfgDirPath - * @return return the config dir - **/ - protected File loadConfigDir(String cfgDirPath) { - if (cfgDirPath == null) - return loadDefaultConfigDir(); - File cfgDir = new File(cfgDirPath); - if (!cfgDir.exists()) - return loadDefaultConfigDir(); - return cfgDir; - } - - /** - * @return search the default config dir, if the config dir is not exist will return null - */ - protected File loadDefaultConfigDir() { - File cfgDir; - File cfgDir_linux = new File("/etc/taos"); - cfgDir = cfgDir_linux.exists() ? cfgDir_linux : null; - File cfgDir_windows = new File("C:\\TDengine\\cfg"); - cfgDir = (cfgDir == null && cfgDir_windows.exists()) ? cfgDir_windows : cfgDir; - return cfgDir; - } - - protected List loadConfigEndpoints(File cfgFile) { - List endpoints = new ArrayList<>(); - try (BufferedReader reader = new BufferedReader(new FileReader(cfgFile))) { - String line = null; - while ((line = reader.readLine()) != null) { - if (line.trim().startsWith("firstEp") || line.trim().startsWith("secondEp")) { - endpoints.add(line.substring(line.indexOf('p') + 1).trim()); - } - if (endpoints.size() > 1) - break; - } - } catch (FileNotFoundException e) { - e.printStackTrace(); - } catch (IOException e) { - e.printStackTrace(); - } - return endpoints; - } - - protected void loadTaosConfig(Properties info) { - if ((info.getProperty(TSDBDriver.PROPERTY_KEY_HOST) == null || - info.getProperty(TSDBDriver.PROPERTY_KEY_HOST).isEmpty()) && ( - info.getProperty(TSDBDriver.PROPERTY_KEY_PORT) == null || - info.getProperty(TSDBDriver.PROPERTY_KEY_PORT).isEmpty())) { - File cfgDir = loadConfigDir(info.getProperty(TSDBDriver.PROPERTY_KEY_CONFIG_DIR)); - File cfgFile = cfgDir.listFiles((dir, name) -> TAOS_CFG_FILENAME.equalsIgnoreCase(name))[0]; - List endpoints = loadConfigEndpoints(cfgFile); - if (!endpoints.isEmpty()) { - info.setProperty(TSDBDriver.PROPERTY_KEY_HOST, endpoints.get(0).split(":")[0]); - info.setProperty(TSDBDriver.PROPERTY_KEY_PORT, endpoints.get(0).split(":")[1]); - } - } - } - protected DriverPropertyInfo[] getPropertyInfo(Properties info) { DriverPropertyInfo hostProp = new DriverPropertyInfo(TSDBDriver.PROPERTY_KEY_HOST, info.getProperty(TSDBDriver.PROPERTY_KEY_HOST)); hostProp.required = false; @@ -156,6 +92,4 @@ public abstract class AbstractDriver implements Driver { return urlProps; } - - } diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ColumnMetaData.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ColumnMetaData.java index fe16aa6535..14e75f0e09 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ColumnMetaData.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ColumnMetaData.java @@ -52,4 +52,14 @@ public class ColumnMetaData { public void setColIndex(int colIndex) { this.colIndex = colIndex; } + + @Override + public String toString() { + return "ColumnMetaData{" + + "colType=" + colType + + ", colName='" + colName + '\'' + + ", colSize=" + colSize + + ", colIndex=" + colIndex + + '}'; + } } diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java index 8d947b9411..a8653eb172 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java @@ -87,11 +87,10 @@ public class TSDBConnection extends AbstractConnection { } public void close() throws SQLException { - if (isClosed()) { - throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED); - } - this.isClosed = true; + if (isClosed) + return; this.connector.closeConnection(); + this.isClosed = true; } public boolean isClosed() throws SQLException { diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java index 2b87b72fef..530ece6bcb 100755 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java @@ -112,8 +112,6 @@ public class TSDBDriver extends AbstractDriver { if ((props = parseURL(url, info)) == null) { return null; } - //load taos.cfg start - loadTaosConfig(info); try { TSDBJNIConnector.init((String) props.get(PROPERTY_KEY_CONFIG_DIR), (String) props.get(PROPERTY_KEY_LOCALE), diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java index f3c4e02579..b27bc63db1 100755 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java @@ -1,4 +1,5 @@ -/*************************************************************************** +/** + * ************************************************************************* * Copyright (c) 2019 TAOS Data, Inc. * * This program is free software: you can use, redistribute, and/or modify @@ -11,7 +12,7 @@ * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . - *****************************************************************************/ + **************************************************************************** */ package com.taosdata.jdbc; import com.taosdata.jdbc.utils.TaosInfo; @@ -20,6 +21,9 @@ import java.sql.SQLException; import java.sql.SQLWarning; import java.util.List; +/** + * JNI connector + * */ public class TSDBJNIConnector { private static volatile Boolean isInitialized = false; diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java index 80ff492530..5d68ffad6c 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java @@ -20,18 +20,16 @@ import java.util.ArrayList; import java.util.List; public class TSDBResultSet extends AbstractResultSet implements ResultSet { - private TSDBJNIConnector jniConnector; - + private final TSDBJNIConnector jniConnector; private final TSDBStatement statement; - private long resultSetPointer = 0L; + private final long resultSetPointer; private List columnMetaDataList = new ArrayList<>(); - - private TSDBResultSetRowData rowData; - private TSDBResultSetBlockData blockData; + private final TSDBResultSetRowData rowData; + private final TSDBResultSetBlockData blockData; private boolean batchFetch = false; private boolean lastWasNull = false; - private final int COLUMN_INDEX_START_VALUE = 1; + private boolean isClosed; public void setBatchFetch(boolean batchFetch) { this.batchFetch = batchFetch; @@ -56,13 +54,13 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet { int code = this.jniConnector.getSchemaMetaData(this.resultSetPointer, this.columnMetaDataList); if (code == TSDBConstants.JNI_CONNECTION_NULL) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL); } if (code == TSDBConstants.JNI_RESULT_SET_NULL) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_RESULT_SET_NULL)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL); } if (code == TSDBConstants.JNI_NUM_OF_FIELDS_0) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_NUM_OF_FIELDS_0)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_NUM_OF_FIELDS_0); } this.rowData = new TSDBResultSetRowData(this.columnMetaDataList.size()); this.blockData = new TSDBResultSetBlockData(this.columnMetaDataList, this.columnMetaDataList.size()); @@ -78,16 +76,12 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet { this.blockData.reset(); if (code == TSDBConstants.JNI_CONNECTION_NULL) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL); } else if (code == TSDBConstants.JNI_RESULT_SET_NULL) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_RESULT_SET_NULL)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL); } else if (code == TSDBConstants.JNI_NUM_OF_FIELDS_0) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_NUM_OF_FIELDS_0)); - } else if (code == TSDBConstants.JNI_FETCH_END) { - return false; - } - - return true; + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_NUM_OF_FIELDS_0); + } else return code != TSDBConstants.JNI_FETCH_END; } else { if (rowData != null) { this.rowData.clear(); @@ -95,11 +89,11 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet { int code = this.jniConnector.fetchRow(this.resultSetPointer, this.rowData); if (code == TSDBConstants.JNI_CONNECTION_NULL) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL); } else if (code == TSDBConstants.JNI_RESULT_SET_NULL) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_RESULT_SET_NULL)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL); } else if (code == TSDBConstants.JNI_NUM_OF_FIELDS_0) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_NUM_OF_FIELDS_0)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_NUM_OF_FIELDS_0); } else if (code == TSDBConstants.JNI_FETCH_END) { return false; } else { @@ -109,14 +103,17 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet { } public void close() throws SQLException { + if (isClosed) + return; if (this.jniConnector != null) { int code = this.jniConnector.freeResultSet(this.resultSetPointer); if (code == TSDBConstants.JNI_CONNECTION_NULL) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL); } else if (code == TSDBConstants.JNI_RESULT_SET_NULL) { - throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_RESULT_SET_NULL)); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL); } } + isClosed = true; } public boolean wasNull() throws SQLException { @@ -415,8 +412,8 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet { } public boolean isClosed() throws SQLException { - //TODO: check if need release resources - boolean isClosed = true; + if (isClosed) + return true; if (jniConnector != null) { isClosed = jniConnector.isResultsetClosed(); } @@ -429,14 +426,12 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet { } private int getTrueColumnIndex(int columnIndex) throws SQLException { - if (columnIndex < this.COLUMN_INDEX_START_VALUE) { - throw new SQLException("Column Index out of range, " + columnIndex + " < " + this.COLUMN_INDEX_START_VALUE); - } + if (columnIndex < 1) + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE, "columnIndex(" + columnIndex + "): < 1"); int numOfCols = this.columnMetaDataList.size(); - if (columnIndex > numOfCols) { - throw new SQLException("Column Index out of range, " + columnIndex + " > " + numOfCols); - } + if (columnIndex > numOfCols) + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE, "columnIndex: " + columnIndex); return columnIndex - 1; } } diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java index 996ea4a185..29e849049e 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java @@ -73,11 +73,11 @@ public class TSDBStatement extends AbstractStatement { } public void close() throws SQLException { - if (!isClosed) { - if (this.resultSet != null) - this.resultSet.close(); - isClosed = true; - } + if (isClosed) + return; + if (this.resultSet != null && !this.resultSet.isClosed()) + this.resultSet.close(); + isClosed = true; } public boolean execute(String sql) throws SQLException { diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBJNIConnectorTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBJNIConnectorTest.java new file mode 100644 index 0000000000..aba95f65b7 --- /dev/null +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBJNIConnectorTest.java @@ -0,0 +1,89 @@ +package com.taosdata.jdbc; + +import org.junit.Test; + +import java.sql.SQLException; +import java.sql.SQLWarning; +import java.util.ArrayList; +import java.util.List; + +public class TSDBJNIConnectorTest { + + private static TSDBResultSetRowData rowData; + + @Test + public void test() { + try { + // init + TSDBJNIConnector.init(null, null, null, null); + // connect + TSDBJNIConnector connector = new TSDBJNIConnector(); + connector.connect("127.0.0.1", 6030, null, "root", "taosdata"); + // executeQuery + long pSql = connector.executeQuery("show variables"); + if (connector.isUpdateQuery(pSql)) { + connector.freeResultSet(pSql); + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_WITH_EXECUTEQUERY); + } + // get schema + List columnMetaDataList = new ArrayList<>(); + int code = connector.getSchemaMetaData(pSql, columnMetaDataList); + if (code == TSDBConstants.JNI_CONNECTION_NULL) { + throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL)); + } + if (code == TSDBConstants.JNI_RESULT_SET_NULL) { + throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_RESULT_SET_NULL)); + } + if (code == TSDBConstants.JNI_NUM_OF_FIELDS_0) { + throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_NUM_OF_FIELDS_0)); + } + int columnSize = columnMetaDataList.size(); + // print metadata + for (int i = 0; i < columnSize; i++) { + System.out.println(columnMetaDataList.get(i)); + } + rowData = new TSDBResultSetRowData(columnSize); + // iterate resultSet + for (int i = 0; next(connector, pSql); i++) { + System.out.println("col[" + i + "] size: " + rowData.getColSize()); + rowData.getData().stream().forEach(col -> System.out.print(col + "\t")); + System.out.println(); + } + // close resultSet + code = connector.freeResultSet(pSql); + if (code == TSDBConstants.JNI_CONNECTION_NULL) { + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL); + } else if (code == TSDBConstants.JNI_RESULT_SET_NULL) { + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL); + } + // close statement + + // close connection + connector.closeConnection(); + + } catch (SQLWarning throwables) { + throwables.printStackTrace(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + private static boolean next(TSDBJNIConnector connector, long pSql) throws SQLException { + if (rowData != null) + rowData.clear(); + + int code = connector.fetchRow(pSql, rowData); + if (code == TSDBConstants.JNI_CONNECTION_NULL) { + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL); + } else if (code == TSDBConstants.JNI_RESULT_SET_NULL) { + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL); + } else if (code == TSDBConstants.JNI_NUM_OF_FIELDS_0) { + throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_NUM_OF_FIELDS_0); + } else if (code == TSDBConstants.JNI_FETCH_END) { + return false; + } else { + return true; + } + } + +} \ No newline at end of file diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DatetimeBefore1970Test.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DatetimeBefore1970Test.java new file mode 100644 index 0000000000..f97e555ad1 --- /dev/null +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DatetimeBefore1970Test.java @@ -0,0 +1,68 @@ +package com.taosdata.jdbc.cases; + +import com.taosdata.jdbc.utils.TimestampUtil; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.sql.*; + +public class DatetimeBefore1970Test { + + private static Connection conn; + + @Test + public void test() { + try (Statement stmt = conn.createStatement()) { + stmt.executeUpdate("insert into weather(ts) values('1969-12-31 23:59:59.999')"); + stmt.executeUpdate("insert into weather(ts) values('1970-01-01 00:00:00.000')"); + stmt.executeUpdate("insert into weather(ts) values('1970-01-01 08:00:00.000')"); + stmt.executeUpdate("insert into weather(ts) values('1970-01-01 07:59:59.999')"); + + ResultSet rs = stmt.executeQuery("select * from weather"); + while (rs.next()) { + Timestamp ts = rs.getTimestamp("ts"); + System.out.println("long: " + ts.getTime() + ", string: " + TimestampUtil.longToDatetime(ts.getTime())); + } + } catch (SQLException e) { + e.printStackTrace(); + } + } + + public static void main(String[] args) { + System.out.println("timestamp: " + Long.MAX_VALUE + ", string: " + TimestampUtil.longToDatetime(Long.MAX_VALUE)); + System.out.println("timestamp: " + Long.MIN_VALUE + ", string: " + TimestampUtil.longToDatetime(Long.MIN_VALUE)); + System.out.println("timestamp: " + 0 + ", string: " + TimestampUtil.longToDatetime(0)); + System.out.println("timestamp: " + -1 + ", string: " + TimestampUtil.longToDatetime(-1)); + String datetime = "1970-01-01 00:00:00.000"; + System.out.println("timestamp: " + TimestampUtil.datetimeToLong(datetime) + ", string: " + datetime); + datetime = "1969-12-31 23:59:59.999"; + System.out.println("timestamp: " + TimestampUtil.datetimeToLong(datetime) + ", string: " + datetime); + } + + @BeforeClass + public static void beforeClass() { + try { + Class.forName("com.taosdata.jdbc.TSDBDriver"); + conn = DriverManager.getConnection("jdbc:TAOS://127.0.0.1:6030/?user=root&password=taosdata"); + Statement stmt = conn.createStatement(); + stmt.execute("drop database if exists test_timestamp"); + stmt.execute("create database if not exists test_timestamp keep 36500"); + stmt.execute("use test_timestamp"); + stmt.execute("create table weather(ts timestamp,f1 float)"); + stmt.close(); + } catch (ClassNotFoundException | SQLException e) { + e.printStackTrace(); + } + } + + @AfterClass + public static void afterClass() { + try { + if (conn != null) + conn.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } +} diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/FailOverTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/FailOverTest.java index 83295df527..be2ff94e02 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/FailOverTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/FailOverTest.java @@ -4,7 +4,6 @@ import org.junit.Test; import java.sql.*; import java.text.SimpleDateFormat; -import java.util.Date; import java.util.concurrent.TimeUnit; public class FailOverTest { @@ -18,13 +17,17 @@ public class FailOverTest { long end = System.currentTimeMillis() + 1000 * 60 * 5; while (System.currentTimeMillis() < end) { - try (Connection conn = DriverManager.getConnection(url)) { - Statement stmt = conn.createStatement(); - ResultSet resultSet = stmt.executeQuery("select server_status()"); - resultSet.next(); - int status = resultSet.getInt("server_status()"); - System.out.println(">>>>>>>>>" + sdf.format(new Date()) + " status : " + status); - stmt.close(); + try (Connection conn = DriverManager.getConnection(url); Statement stmt = conn.createStatement()) { + ResultSet rs = stmt.executeQuery("show dnodes"); + ResultSetMetaData meta = rs.getMetaData(); + while (rs.next()) { + for (int i = 1; i <= meta.getColumnCount(); i++) { + System.out.print(meta.getColumnLabel(i) + ": " + rs.getString(i) + "\t"); + } + System.out.println(); + } + System.out.println("======================="); + rs.close(); TimeUnit.SECONDS.sleep(5); } catch (SQLException | InterruptedException e) { e.printStackTrace(); diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/TimeStampUtil.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/TimestampUtil.java similarity index 98% rename from src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/TimeStampUtil.java rename to src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/TimestampUtil.java index 1c6af7e3d2..16f8269d24 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/TimeStampUtil.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/TimestampUtil.java @@ -4,7 +4,7 @@ import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; -public class TimeStampUtil { +public class TimestampUtil { private static final String datetimeFormat = "yyyy-MM-dd HH:mm:ss.SSS"; diff --git a/src/dnode/CMakeLists.txt b/src/dnode/CMakeLists.txt index 644a4e875d..516e5b4d1f 100644 --- a/src/dnode/CMakeLists.txt +++ b/src/dnode/CMakeLists.txt @@ -31,6 +31,10 @@ IF (TD_MQTT) TARGET_LINK_LIBRARIES(taosd mqtt) ENDIF () +IF (TD_TOPIC) + TARGET_LINK_LIBRARIES(taosd topic) +ENDIF () + SET(PREPARE_ENV_CMD "prepare_env_cmd") SET(PREPARE_ENV_TARGET "prepare_env_target") ADD_CUSTOM_COMMAND(OUTPUT ${PREPARE_ENV_CMD} diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c index 79744e153e..a409d537fa 100644 --- a/src/dnode/src/dnodeMWrite.c +++ b/src/dnode/src/dnodeMWrite.c @@ -146,10 +146,10 @@ void dnodeSendRpcMWriteRsp(void *pMsg, int32_t code) { } dTrace("msg:%p, app:%p type:%s master:%p will be responsed", pWrite, pWrite->rpcMsg.ahandle, - taosMsg[pWrite->rpcMsg.msgType], pWrite->pBatchMasterMsg); + taosMsg[pWrite->rpcMsg.msgType], pWrite->pBatchMasterMsg); if (pWrite->pBatchMasterMsg && pWrite != pWrite->pBatchMasterMsg) { dError("msg:%p, app:%p type:%s master:%p sub message should not response!", pWrite, pWrite->rpcMsg.ahandle, - taosMsg[pWrite->rpcMsg.msgType], pWrite->pBatchMasterMsg); + taosMsg[pWrite->rpcMsg.msgType], pWrite->pBatchMasterMsg); return; } diff --git a/src/dnode/src/dnodeMain.c b/src/dnode/src/dnodeMain.c index 16f97d0eea..c24eac84cf 100644 --- a/src/dnode/src/dnodeMain.c +++ b/src/dnode/src/dnodeMain.c @@ -189,6 +189,11 @@ static void dnodeCheckDataDirOpenned(char *dir) { } static int32_t dnodeInitStorage() { + if (tsDiskCfgNum == 1 && dnodeCreateDir(tsDataDir) < 0) { + dError("failed to create dir: %s, reason: %s", tsDataDir, strerror(errno)); + return -1; + } + if (tfsInit(tsDiskCfg, tsDiskCfgNum) < 0) { dError("failed to init TFS since %s", tstrerror(terrno)); return -1; diff --git a/src/dnode/src/dnodeShell.c b/src/dnode/src/dnodeShell.c index 9a226b81e8..60d9c38c05 100644 --- a/src/dnode/src/dnodeShell.c +++ b/src/dnode/src/dnodeShell.c @@ -47,8 +47,11 @@ int32_t dnodeInitShell() { dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DNODE]= dnodeDispatchToMWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE] = dnodeDispatchToMWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB] = dnodeDispatchToMWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP] = dnodeDispatchToMWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB] = dnodeDispatchToMWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_TP] = dnodeDispatchToMWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB] = dnodeDispatchToMWriteQueue; + dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP] = dnodeDispatchToMWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE]= dnodeDispatchToMWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_TABLE] = dnodeDispatchToMWriteQueue; dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TABLE] = dnodeDispatchToMWriteQueue; diff --git a/src/dnode/src/dnodeVnodes.c b/src/dnode/src/dnodeVnodes.c index 9f32541612..d00314fcbc 100644 --- a/src/dnode/src/dnodeVnodes.c +++ b/src/dnode/src/dnodeVnodes.c @@ -198,6 +198,14 @@ void dnodeCleanupVnodes() { static void dnodeProcessStatusRsp(SRpcMsg *pMsg) { if (pMsg->code != TSDB_CODE_SUCCESS) { dError("status rsp is received, error:%s", tstrerror(pMsg->code)); + if (pMsg->code == TSDB_CODE_MND_DNODE_NOT_EXIST) { + char clusterId[TSDB_CLUSTER_ID_LEN]; + dnodeGetClusterId(clusterId); + if (clusterId[0] != '\0') { + dError("exit zombie dropped dnode"); + exit(EXIT_FAILURE); + } + } taosTmrReset(dnodeSendStatusMsg, tsStatusInterval * 1000, NULL, tsDnodeTmr, &tsStatusTimer); return; } diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h index f4712198ee..d9a50e8914 100644 --- a/src/inc/taosdef.h +++ b/src/inc/taosdef.h @@ -222,6 +222,9 @@ do { \ #define TSDB_MQTT_TOPIC_LEN 64 #define TSDB_MQTT_CLIENT_ID_LEN 32 +#define TSDB_DB_TYPE_DEFAULT 0 +#define TSDB_DB_TYPE_TOPIC 1 + #define TSDB_DEFAULT_PKT_SIZE 65480 //same as RPC_MAX_UDP_SIZE #define TSDB_PAYLOAD_SIZE TSDB_DEFAULT_PKT_SIZE @@ -306,6 +309,10 @@ do { \ #define TSDB_MAX_DB_REPLICA_OPTION 3 #define TSDB_DEFAULT_DB_REPLICA_OPTION 1 +#define TSDB_MIN_DB_PARTITON_OPTION 0 +#define TSDB_MAX_DB_PARTITON_OPTION 1000 +#define TSDB_DEFAULT_DB_PARTITON_OPTION 4 + #define TSDB_MIN_DB_QUORUM_OPTION 1 #define TSDB_MAX_DB_QUORUM_OPTION 2 #define TSDB_DEFAULT_DB_QUORUM_OPTION 1 diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h index 3eb197868b..af933fa4e9 100644 --- a/src/inc/taoserror.h +++ b/src/inc/taoserror.h @@ -185,6 +185,9 @@ int32_t* taosGetErrno(); #define TSDB_CODE_MND_INVALID_DB_OPTION_DAYS TAOS_DEF_ERROR_CODE(0, 0x0390) //"Invalid database option: days out of range") #define TSDB_CODE_MND_INVALID_DB_OPTION_KEEP TAOS_DEF_ERROR_CODE(0, 0x0391) //"Invalid database option: keep >= keep1 >= keep0 >= days") +#define TSDB_CODE_MND_INVALID_TOPIC TAOS_DEF_ERROR_CODE(0, 0x0392) //"Invalid topic name) +#define TSDB_CODE_MND_INVALID_TOPIC_OPTION TAOS_DEF_ERROR_CODE(0, 0x0393) //"Invalid topic option) + // dnode #define TSDB_CODE_DND_MSG_NOT_PROCESSED TAOS_DEF_ERROR_CODE(0, 0x0400) //"Message not processed") #define TSDB_CODE_DND_OUT_OF_MEMORY TAOS_DEF_ERROR_CODE(0, 0x0401) //"Dnode out of memory") diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h index 721b9ca605..f740575b7a 100644 --- a/src/inc/taosmsg.h +++ b/src/inc/taosmsg.h @@ -107,6 +107,12 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY13, "dummy13" ) TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY14, "dummy14" ) TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_NETWORK_TEST, "nettest" ) +// message for topic +TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_TP, "create-tp" ) +TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_TP, "drop-tp" ) +TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_USE_TP, "use-tp" ) +TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_ALTER_TP, "alter-tp" ) + #ifndef TAOS_MESSAGE_C TSDB_MSG_TYPE_MAX // 105 #endif @@ -141,6 +147,7 @@ enum _mgmt_table { TSDB_MGMT_TABLE_VNODES, TSDB_MGMT_TABLE_STREAMTABLES, TSDB_MGMT_TABLE_CLUSTER, + TSDB_MGMT_TABLE_TP, TSDB_MGMT_TABLE_MAX, }; @@ -555,7 +562,9 @@ typedef struct { int8_t ignoreExist; int8_t update; int8_t cacheLastRow; - int8_t reserve[8]; + int8_t dbType; + int16_t partitions; + int8_t reserve[5]; } SCreateDbMsg, SAlterDbMsg; typedef struct { @@ -674,7 +683,8 @@ typedef struct { int8_t cacheLastRow; int32_t vgCfgVersion; int8_t dbReplica; - int8_t reserved[9]; + int8_t dbType; + int8_t reserved[8]; } SVnodeCfg; typedef struct { diff --git a/src/inc/tp.h b/src/inc/tp.h new file mode 100644 index 0000000000..b0b787bf68 --- /dev/null +++ b/src/inc/tp.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#ifndef TDENGINE_TP +#define TDENGINE_TP + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t tpInit(); +void tpCleanUp(); +void tpUpdateTs(int32_t *seq, void *pMsg); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h index 8bb9cde935..5ee0ec376a 100644 --- a/src/inc/ttokendef.h +++ b/src/inc/ttokendef.h @@ -62,170 +62,176 @@ #define TK_BITNOT 43 #define TK_SHOW 44 #define TK_DATABASES 45 -#define TK_MNODES 46 -#define TK_DNODES 47 -#define TK_ACCOUNTS 48 -#define TK_USERS 49 -#define TK_MODULES 50 -#define TK_QUERIES 51 -#define TK_CONNECTIONS 52 -#define TK_STREAMS 53 -#define TK_VARIABLES 54 -#define TK_SCORES 55 -#define TK_GRANTS 56 -#define TK_VNODES 57 -#define TK_IPTOKEN 58 -#define TK_DOT 59 -#define TK_CREATE 60 -#define TK_TABLE 61 -#define TK_DATABASE 62 -#define TK_TABLES 63 -#define TK_STABLES 64 -#define TK_VGROUPS 65 -#define TK_DROP 66 -#define TK_STABLE 67 -#define TK_DNODE 68 -#define TK_USER 69 -#define TK_ACCOUNT 70 -#define TK_USE 71 -#define TK_DESCRIBE 72 -#define TK_ALTER 73 -#define TK_PASS 74 -#define TK_PRIVILEGE 75 -#define TK_LOCAL 76 -#define TK_IF 77 -#define TK_EXISTS 78 -#define TK_PPS 79 -#define TK_TSERIES 80 -#define TK_DBS 81 -#define TK_STORAGE 82 -#define TK_QTIME 83 -#define TK_CONNS 84 -#define TK_STATE 85 -#define TK_KEEP 86 -#define TK_CACHE 87 -#define TK_REPLICA 88 -#define TK_QUORUM 89 -#define TK_DAYS 90 -#define TK_MINROWS 91 -#define TK_MAXROWS 92 -#define TK_BLOCKS 93 -#define TK_CTIME 94 -#define TK_WAL 95 -#define TK_FSYNC 96 -#define TK_COMP 97 -#define TK_PRECISION 98 -#define TK_UPDATE 99 -#define TK_CACHELAST 100 -#define TK_LP 101 -#define TK_RP 102 -#define TK_UNSIGNED 103 -#define TK_TAGS 104 -#define TK_USING 105 -#define TK_COMMA 106 -#define TK_AS 107 -#define TK_NULL 108 -#define TK_SELECT 109 -#define TK_UNION 110 -#define TK_ALL 111 -#define TK_DISTINCT 112 -#define TK_FROM 113 -#define TK_VARIABLE 114 -#define TK_INTERVAL 115 -#define TK_FILL 116 -#define TK_SLIDING 117 -#define TK_ORDER 118 -#define TK_BY 119 -#define TK_ASC 120 -#define TK_DESC 121 -#define TK_GROUP 122 -#define TK_HAVING 123 -#define TK_LIMIT 124 -#define TK_OFFSET 125 -#define TK_SLIMIT 126 -#define TK_SOFFSET 127 -#define TK_WHERE 128 -#define TK_NOW 129 -#define TK_RESET 130 -#define TK_QUERY 131 -#define TK_ADD 132 -#define TK_COLUMN 133 -#define TK_TAG 134 -#define TK_CHANGE 135 -#define TK_SET 136 -#define TK_KILL 137 -#define TK_CONNECTION 138 -#define TK_STREAM 139 -#define TK_COLON 140 -#define TK_ABORT 141 -#define TK_AFTER 142 -#define TK_ATTACH 143 -#define TK_BEFORE 144 -#define TK_BEGIN 145 -#define TK_CASCADE 146 -#define TK_CLUSTER 147 -#define TK_CONFLICT 148 -#define TK_COPY 149 -#define TK_DEFERRED 150 -#define TK_DELIMITERS 151 -#define TK_DETACH 152 -#define TK_EACH 153 -#define TK_END 154 -#define TK_EXPLAIN 155 -#define TK_FAIL 156 -#define TK_FOR 157 -#define TK_IGNORE 158 -#define TK_IMMEDIATE 159 -#define TK_INITIALLY 160 -#define TK_INSTEAD 161 -#define TK_MATCH 162 -#define TK_KEY 163 -#define TK_OF 164 -#define TK_RAISE 165 -#define TK_REPLACE 166 -#define TK_RESTRICT 167 -#define TK_ROW 168 -#define TK_STATEMENT 169 -#define TK_TRIGGER 170 -#define TK_VIEW 171 -#define TK_COUNT 172 -#define TK_SUM 173 -#define TK_AVG 174 -#define TK_MIN 175 -#define TK_MAX 176 -#define TK_FIRST 177 -#define TK_LAST 178 -#define TK_TOP 179 -#define TK_BOTTOM 180 -#define TK_STDDEV 181 -#define TK_PERCENTILE 182 -#define TK_APERCENTILE 183 -#define TK_LEASTSQUARES 184 -#define TK_HISTOGRAM 185 -#define TK_DIFF 186 -#define TK_SPREAD 187 -#define TK_TWA 188 -#define TK_INTERP 189 -#define TK_LAST_ROW 190 -#define TK_RATE 191 -#define TK_IRATE 192 -#define TK_SUM_RATE 193 -#define TK_SUM_IRATE 194 -#define TK_AVG_RATE 195 -#define TK_AVG_IRATE 196 -#define TK_TBID 197 -#define TK_SEMI 198 -#define TK_NONE 199 -#define TK_PREV 200 -#define TK_LINEAR 201 -#define TK_IMPORT 202 -#define TK_METRIC 203 -#define TK_TBNAME 204 -#define TK_JOIN 205 -#define TK_METRICS 206 -#define TK_INSERT 207 -#define TK_INTO 208 -#define TK_VALUES 209 +#define TK_TOPICS 46 +#define TK_MNODES 47 +#define TK_DNODES 48 +#define TK_ACCOUNTS 49 +#define TK_USERS 50 +#define TK_MODULES 51 +#define TK_QUERIES 52 +#define TK_CONNECTIONS 53 +#define TK_STREAMS 54 +#define TK_VARIABLES 55 +#define TK_SCORES 56 +#define TK_GRANTS 57 +#define TK_VNODES 58 +#define TK_IPTOKEN 59 +#define TK_DOT 60 +#define TK_CREATE 61 +#define TK_TABLE 62 +#define TK_DATABASE 63 +#define TK_TABLES 64 +#define TK_STABLES 65 +#define TK_VGROUPS 66 +#define TK_DROP 67 +#define TK_STABLE 68 +#define TK_TOPIC 69 +#define TK_DNODE 70 +#define TK_USER 71 +#define TK_ACCOUNT 72 +#define TK_USE 73 +#define TK_DESCRIBE 74 +#define TK_ALTER 75 +#define TK_PASS 76 +#define TK_PRIVILEGE 77 +#define TK_LOCAL 78 +#define TK_IF 79 +#define TK_EXISTS 80 +#define TK_PPS 81 +#define TK_TSERIES 82 +#define TK_DBS 83 +#define TK_STORAGE 84 +#define TK_QTIME 85 +#define TK_CONNS 86 +#define TK_STATE 87 +#define TK_KEEP 88 +#define TK_CACHE 89 +#define TK_REPLICA 90 +#define TK_QUORUM 91 +#define TK_DAYS 92 +#define TK_MINROWS 93 +#define TK_MAXROWS 94 +#define TK_BLOCKS 95 +#define TK_CTIME 96 +#define TK_WAL 97 +#define TK_FSYNC 98 +#define TK_COMP 99 +#define TK_PRECISION 100 +#define TK_UPDATE 101 +#define TK_CACHELAST 102 +#define TK_PARTITIONS 103 +#define TK_LP 104 +#define TK_RP 105 +#define TK_UNSIGNED 106 +#define TK_TAGS 107 +#define TK_USING 108 +#define TK_COMMA 109 +#define TK_AS 110 +#define TK_NULL 111 +#define TK_SELECT 112 +#define TK_UNION 113 +#define TK_ALL 114 +#define TK_DISTINCT 115 +#define TK_FROM 116 +#define TK_VARIABLE 117 +#define TK_INTERVAL 118 +#define TK_FILL 119 +#define TK_SLIDING 120 +#define TK_ORDER 121 +#define TK_BY 122 +#define TK_ASC 123 +#define TK_DESC 124 +#define TK_GROUP 125 +#define TK_HAVING 126 +#define TK_LIMIT 127 +#define TK_OFFSET 128 +#define TK_SLIMIT 129 +#define TK_SOFFSET 130 +#define TK_WHERE 131 +#define TK_NOW 132 +#define TK_RESET 133 +#define TK_QUERY 134 +#define TK_ADD 135 +#define TK_COLUMN 136 +#define TK_TAG 137 +#define TK_CHANGE 138 +#define TK_SET 139 +#define TK_KILL 140 +#define TK_CONNECTION 141 +#define TK_STREAM 142 +#define TK_COLON 143 +#define TK_ABORT 144 +#define TK_AFTER 145 +#define TK_ATTACH 146 +#define TK_BEFORE 147 +#define TK_BEGIN 148 +#define TK_CASCADE 149 +#define TK_CLUSTER 150 +#define TK_CONFLICT 151 +#define TK_COPY 152 +#define TK_DEFERRED 153 +#define TK_DELIMITERS 154 +#define TK_DETACH 155 +#define TK_EACH 156 +#define TK_END 157 +#define TK_EXPLAIN 158 +#define TK_FAIL 159 +#define TK_FOR 160 +#define TK_IGNORE 161 +#define TK_IMMEDIATE 162 +#define TK_INITIALLY 163 +#define TK_INSTEAD 164 +#define TK_MATCH 165 +#define TK_KEY 166 +#define TK_OF 167 +#define TK_RAISE 168 +#define TK_REPLACE 169 +#define TK_RESTRICT 170 +#define TK_ROW 171 +#define TK_STATEMENT 172 +#define TK_TRIGGER 173 +#define TK_VIEW 174 +#define TK_COUNT 175 +#define TK_SUM 176 +#define TK_AVG 177 +#define TK_MIN 178 +#define TK_MAX 179 +#define TK_FIRST 180 +#define TK_LAST 181 +#define TK_TOP 182 +#define TK_BOTTOM 183 +#define TK_STDDEV 184 +#define TK_PERCENTILE 185 +#define TK_APERCENTILE 186 +#define TK_LEASTSQUARES 187 +#define TK_HISTOGRAM 188 +#define TK_DIFF 189 +#define TK_SPREAD 190 +#define TK_TWA 191 +#define TK_INTERP 192 +#define TK_LAST_ROW 193 +#define TK_RATE 194 +#define TK_IRATE 195 +#define TK_SUM_RATE 196 +#define TK_SUM_IRATE 197 +#define TK_AVG_RATE 198 +#define TK_AVG_IRATE 199 +#define TK_TBID 200 +#define TK_SEMI 201 +#define TK_NONE 202 +#define TK_PREV 203 +#define TK_LINEAR 204 +#define TK_IMPORT 205 +#define TK_METRIC 206 +#define TK_TBNAME 207 +#define TK_JOIN 208 +#define TK_METRICS 209 +#define TK_INSERT 210 +#define TK_INTO 211 +#define TK_VALUES 212 + + + diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c index 0353fcabd3..8559767895 100644 --- a/src/kit/taosdemo/taosdemo.c +++ b/src/kit/taosdemo/taosdemo.c @@ -46,16 +46,18 @@ #include #include "os.h" -#ifdef TD_WINDOWS +#ifdef WINDOWS + #include + typedef unsigned __int32 uint32_t; + #pragma comment ( lib, "ws2_32.lib" ) - #pragma comment ( lib, "winmm.lib" ) - #pragma comment ( lib, "wldap32.lib" ) #endif #endif #include "cJSON.h" #include "taos.h" +#include "taoserror.h" #include "tutil.h" #define REQ_EXTRA_BUF_LEN 1024 @@ -94,6 +96,7 @@ extern char configDir[]; #define MAX_QUERY_SQL_LENGTH 256 #define MAX_DATABASE_COUNT 256 +#define INPUT_BUF_LEN 256 typedef enum CREATE_SUB_TALBE_MOD_EN { PRE_CREATE_SUBTBL, @@ -184,6 +187,7 @@ typedef struct SArguments_S { bool insert_only; bool answer_yes; bool debug_print; + bool verbose_print; char * output_file; int mode; char * datatype[MAX_NUM_DATATYPE + 1]; @@ -225,7 +229,8 @@ typedef struct SSuperTable_S { int disorderRatio; // 0: no disorder, >0: x% int disorderRange; // ms or us by database precision int maxSqlLen; // - + + int insertInterval; // insert interval, will override global insert interval int64_t insertRows; // 0: no limit int timeStampStep; char startTimestamp[MAX_TB_NAME_SIZE]; // @@ -471,8 +476,8 @@ char *aggreFunc[] = {"*", "count(*)", "avg(col0)", "sum(col0)", "max(col0)", "min(col0)", "first(col0)", "last(col0)"}; SArguments g_args = { - NULL, // metaFile - 0, // test_mode + NULL, // metaFile + 0, // test_mode "127.0.0.1", // host 6030, // port "root", // user @@ -488,6 +493,7 @@ SArguments g_args = { false, // use_metric false, // insert_only false, // debug_print + false, // verbose_print false, // answer_yes; "./output.txt", // output_file 0, // mode : sync or async @@ -525,7 +531,11 @@ static SQueryMetaInfo g_queryInfo; static FILE * g_fpOfInsertResult = NULL; #define debugPrint(fmt, ...) \ - do { if (g_args.debug_print) fprintf(stderr, fmt, __VA_ARGS__); } while(0) + do { if (g_args.debug_print || g_args.verbose_print) \ + fprintf(stderr, "DEBG: "fmt, __VA_ARGS__); } while(0) +#define verbosePrint(fmt, ...) \ + do { if (g_args.verbose_print) fprintf(stderr, "VERB: "fmt, __VA_ARGS__); } while(0) + /////////////////////////////////////////////////// void printHelp() { @@ -690,6 +700,8 @@ void parse_args(int argc, char *argv[], SArguments *arguments) { arguments->answer_yes = true; } else if (strcmp(argv[i], "-g") == 0) { arguments->debug_print = true; + } else if (strcmp(argv[i], "-gg") == 0) { + arguments->verbose_print = true; } else if (strcmp(argv[i], "-c") == 0) { strcpy(configDir, argv[++i]); } else if (strcmp(argv[i], "-O") == 0) { @@ -728,7 +740,8 @@ void parse_args(int argc, char *argv[], SArguments *arguments) { } } - if (arguments->debug_print) { + if (((arguments->debug_print) && (arguments->metaFile == NULL)) + || arguments->verbose_print) { printf("###################################################################\n"); printf("# meta file: %s\n", arguments->metaFile); printf("# Server IP: %s:%hu\n", @@ -747,7 +760,7 @@ void parse_args(int argc, char *argv[], SArguments *arguments) { printf("\n"); } printf("# Insertion interval: %d\n", arguments->insert_interval); - printf("# Number of Columns per record: %d\n", arguments->num_of_RPR); + printf("# Number of records per req: %d\n", arguments->num_of_RPR); printf("# Number of Threads: %d\n", arguments->num_of_threads); printf("# Number of Tables: %d\n", arguments->num_of_tables); printf("# Number of Data per Table: %d\n", arguments->num_of_DPT); @@ -804,7 +817,7 @@ static int queryDbExec(TAOS *taos, char *command, int type) { } if (code != 0) { - debugPrint("DEBUG %s() LN%d - command: %s\n", __func__, __LINE__, command); + debugPrint("%s() LN%d - command: %s\n", __func__, __LINE__, command); fprintf(stderr, "Failed to run %s, reason: %s\n", command, taos_errstr(res)); taos_free_result(res); //taos_close(taos); @@ -838,7 +851,8 @@ static void getResult(TAOS_RES *res, char* resultFileName) { char* databuf = (char*) calloc(1, 100*1024*1024); if (databuf == NULL) { fprintf(stderr, "failed to malloc, warning: save result to file slowly!\n"); - fclose(fp); + if (fp) + fclose(fp); return ; } @@ -996,7 +1010,7 @@ static int printfInsertMeta() { printf("database count: \033[33m%d\033[0m\n", g_Dbs.dbCount); for (int i = 0; i < g_Dbs.dbCount; i++) { printf("database[\033[33m%d\033[0m]:\n", i); - printf(" database name: \033[33m%s\033[0m\n", g_Dbs.db[i].dbName); + printf(" database[%d] name: \033[33m%s\033[0m\n", i, g_Dbs.db[i].dbName); if (0 == g_Dbs.db[i].drop) { printf(" drop: \033[33mno\033[0m\n"); }else { @@ -1145,7 +1159,7 @@ static void printfInsertMetaToFile(FILE* fp) { fprintf(fp, "database count: %d\n", g_Dbs.dbCount); for (int i = 0; i < g_Dbs.dbCount; i++) { fprintf(fp, "database[%d]:\n", i); - fprintf(fp, " database name: %s\n", g_Dbs.db[i].dbName); + fprintf(fp, " database[%d] name: %s\n", i, g_Dbs.db[i].dbName); if (0 == g_Dbs.db[i].drop) { fprintf(fp, " drop: no\n"); }else { @@ -1224,6 +1238,7 @@ static void printfInsertMetaToFile(FILE* fp) { fprintf(fp, " dataSource: %s\n", g_Dbs.db[i].superTbls[j].dataSource); fprintf(fp, " insertMode: %s\n", g_Dbs.db[i].superTbls[j].insertMode); fprintf(fp, " insertRows: %"PRId64"\n", g_Dbs.db[i].superTbls[j].insertRows); + fprintf(fp, " insert interval: %d\n", g_Dbs.db[i].superTbls[j].insertInterval); if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) { fprintf(fp, " multiThreadWriteOneTbl: no\n"); @@ -1585,18 +1600,17 @@ static void printfQuerySystemInfo(TAOS * taos) { } -void ERROR_EXIT(const char *msg) { perror(msg); exit(0); } +void ERROR_EXIT(const char *msg) { perror(msg); exit(-1); } int postProceSql(char* host, uint16_t port, char* sqlstr) { - char *req_fmt = "POST %s HTTP/1.1\r\nHost: %s:%d\r\nAccept: */*\r\n%s\r\nContent-Length: %d\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n%s"; + char *req_fmt = "POST %s HTTP/1.1\r\nHost: %s:%d\r\nAccept: */*\r\nAuthorization: Basic %s\r\nContent-Length: %d\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n%s"; char *url = "/rest/sql"; - char *auth = "Authorization: Basic cm9vdDp0YW9zZGF0YQ=="; struct hostent *server; struct sockaddr_in serv_addr; - int sockfd, bytes, sent, received, req_str_len, resp_len; + int bytes, sent, received, req_str_len, resp_len; char *request_buf; char response_buf[RESP_BUF_LEN]; uint16_t rest_port = port + TSDB_PORT_HTTP; @@ -1607,18 +1621,37 @@ int postProceSql(char* host, uint16_t port, char* sqlstr) if (NULL == request_buf) ERROR_EXIT("ERROR, cannot allocate memory."); - int r = snprintf(request_buf, - req_buf_len, - req_fmt, url, host, rest_port, - auth, strlen(sqlstr), sqlstr); - if (r >= req_buf_len) { - free(request_buf); - ERROR_EXIT("ERROR too long request"); - } - printf("Request:\n%s\n", request_buf); + char userpass_buf[INPUT_BUF_LEN]; + int mod_table[] = {0, 2, 1}; + static char base64[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', + 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', + 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', + 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', + 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', + 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', + 'w', 'x', 'y', 'z', '0', '1', '2', '3', + '4', '5', '6', '7', '8', '9', '+', '/'}; + + snprintf(userpass_buf, INPUT_BUF_LEN, "%s:%s", + g_Dbs.user, g_Dbs.password); + size_t userpass_buf_len = strlen(userpass_buf); + size_t encoded_len = 4 * ((userpass_buf_len +2) / 3); + + char base64_buf[INPUT_BUF_LEN]; +#ifdef WINDOWS + WSADATA wsaData; + WSAStartup(MAKEWORD(2, 2), &wsaData); + SOCKET sockfd; +#else + int sockfd; +#endif sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { +#ifdef WINDOWS + fprintf(stderr, "Could not create socket : %d" , WSAGetLastError()); +#endif + debugPrint("%s() LN%d sockfd=%d\n", __func__, __LINE__, sockfd); free(request_buf); ERROR_EXIT("ERROR opening socket"); } @@ -1629,20 +1662,68 @@ int postProceSql(char* host, uint16_t port, char* sqlstr) ERROR_EXIT("ERROR, no such host"); } + debugPrint("h_name: %s\nh_addretype: %s\nh_length: %d\n", + server->h_name, + (server->h_addrtype == AF_INET)?"ipv4":"ipv6", + server->h_length); + memset(&serv_addr, 0, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(rest_port); +#ifdef WINDOWS + serv_addr.sin_addr.s_addr = inet_addr(host); +#else memcpy(&serv_addr.sin_addr.s_addr,server->h_addr,server->h_length); +#endif - if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0) { + int retConn = connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)); + debugPrint("%s() LN%d connect() return %d\n", __func__, __LINE__, retConn); + if (retConn < 0) { free(request_buf); ERROR_EXIT("ERROR connecting"); } + memset(base64_buf, 0, INPUT_BUF_LEN); + + for (int n = 0, m = 0; n < userpass_buf_len;) { + uint32_t oct_a = n < userpass_buf_len ? + (unsigned char) userpass_buf[n++]:0; + uint32_t oct_b = n < userpass_buf_len ? + (unsigned char) userpass_buf[n++]:0; + uint32_t oct_c = n < userpass_buf_len ? + (unsigned char) userpass_buf[n++]:0; + uint32_t triple = (oct_a << 0x10) + (oct_b << 0x08) + oct_c; + + base64_buf[m++] = base64[(triple >> 3* 6) & 0x3f]; + base64_buf[m++] = base64[(triple >> 2* 6) & 0x3f]; + base64_buf[m++] = base64[(triple >> 1* 6) & 0x3f]; + base64_buf[m++] = base64[(triple >> 0* 6) & 0x3f]; + } + + for (int l = 0; l < mod_table[userpass_buf_len % 3]; l++) + base64_buf[encoded_len - 1 - l] = '='; + + debugPrint("%s() LN%d: auth string base64 encoded: %s\n", __func__, __LINE__, base64_buf); + char *auth = base64_buf; + + int r = snprintf(request_buf, + req_buf_len, + req_fmt, url, host, rest_port, + auth, strlen(sqlstr), sqlstr); + if (r >= req_buf_len) { + free(request_buf); + ERROR_EXIT("ERROR too long request"); + } + verbosePrint("%s() LN%d: Request:\n%s\n", __func__, __LINE__, request_buf); + req_str_len = strlen(request_buf); sent = 0; do { +#ifdef WINDOWS + bytes = send(sockfd, request_buf + sent, req_str_len - sent, 0); +#else bytes = write(sockfd, request_buf + sent, req_str_len - sent); +#endif if (bytes < 0) ERROR_EXIT("ERROR writing message to socket"); if (bytes == 0) @@ -1654,7 +1735,11 @@ int postProceSql(char* host, uint16_t port, char* sqlstr) resp_len = sizeof(response_buf) - 1; received = 0; do { +#ifdef WINDOWS + bytes = recv(sockfd, response_buf + received, resp_len - received, 0); +#else bytes = read(sockfd, response_buf + received, resp_len - received); +#endif if (bytes < 0) { free(request_buf); ERROR_EXIT("ERROR reading response from socket"); @@ -1669,10 +1754,16 @@ int postProceSql(char* host, uint16_t port, char* sqlstr) ERROR_EXIT("ERROR storing complete response from socket"); } + response_buf[RESP_BUF_LEN - 1] = '\0'; printf("Response:\n%s\n", response_buf); free(request_buf); +#ifdef WINDOWS + closesocket(sockfd); + WSACleanup(); +#else close(sockfd); +#endif return 0; } @@ -1983,7 +2074,7 @@ static int createSuperTable(TAOS * taos, char* dbName, SSuperTable* superTbls, exit(-1); } snprintf(superTbls->colsOfCreateChildTable, len+20, "(ts timestamp%s)", cols); - debugPrint("DEBUG - %s() LN%d: %s\n", __func__, __LINE__, superTbls->colsOfCreateChildTable); + verbosePrint("%s() LN%d: %s\n", __func__, __LINE__, superTbls->colsOfCreateChildTable); if (use_metric) { char tags[STRING_LEN] = "\0"; @@ -2036,13 +2127,13 @@ static int createSuperTable(TAOS * taos, char* dbName, SSuperTable* superTbls, snprintf(command, BUFFER_SIZE, "create table if not exists %s.%s (ts timestamp%s) tags %s", dbName, superTbls->sTblName, cols, tags); - debugPrint("DEBUG - %s() LN%d: %s\n", __func__, __LINE__, command); + verbosePrint("%s() LN%d: %s\n", __func__, __LINE__, command); if (0 != queryDbExec(taos, command, NO_INSERT_TYPE)) { fprintf(stderr, "create supertable %s failed!\n\n", superTbls->sTblName); return -1; } - debugPrint("DEBUG - create supertable %s success!\n\n", superTbls->sTblName); + debugPrint("create supertable %s success!\n\n", superTbls->sTblName); } return 0; } @@ -2061,7 +2152,7 @@ static int createDatabases() { for (int i = 0; i < g_Dbs.dbCount; i++) { if (g_Dbs.db[i].drop) { sprintf(command, "drop database if exists %s;", g_Dbs.db[i].dbName); - debugPrint("DEBUG %s() %d command: %s\n", __func__, __LINE__, command); + verbosePrint("%s() %d command: %s\n", __func__, __LINE__, command); if (0 != queryDbExec(taos, command, NO_INSERT_TYPE)) { taos_close(taos); return -1; @@ -2129,19 +2220,19 @@ static int createDatabases() { "precision \'%s\';", g_Dbs.db[i].dbCfg.precision); } - debugPrint("DEBUG %s() %d command: %s\n", __func__, __LINE__, command); + debugPrint("%s() %d command: %s\n", __func__, __LINE__, command); if (0 != queryDbExec(taos, command, NO_INSERT_TYPE)) { taos_close(taos); - printf("\ncreate database %s failed!\n\n", g_Dbs.db[i].dbName); + fprintf(stderr, "\ncreate database %s failed!\n\n", g_Dbs.db[i].dbName); return -1; } printf("\ncreate database %s success!\n\n", g_Dbs.db[i].dbName); - debugPrint("DEBUG %s() %d count:%d\n", __func__, __LINE__, g_Dbs.db[i].superTblCount); + debugPrint("%s() %d supertbl count:%d\n", __func__, __LINE__, g_Dbs.db[i].superTblCount); for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) { // describe super table, if exists sprintf(command, "describe %s.%s;", g_Dbs.db[i].dbName, g_Dbs.db[i].superTbls[j].sTblName); - debugPrint("DEBUG %s() %d command: %s\n", __func__, __LINE__, command); + verbosePrint("%s() %d command: %s\n", __func__, __LINE__, command); if (0 != queryDbExec(taos, command, NO_INSERT_TYPE)) { g_Dbs.db[i].superTbls[j].superTblExists = TBL_NO_EXISTS; ret = createSuperTable(taos, g_Dbs.db[i].dbName, &g_Dbs.db[i].superTbls[j], g_Dbs.use_metric); @@ -2229,8 +2320,9 @@ static void* createTable(void *sarg) } len = 0; - debugPrint("DEBUG %s() LN%d %s\n", __func__, __LINE__, buffer); + verbosePrint("%s() LN%d %s\n", __func__, __LINE__, buffer); if (0 != queryDbExec(winfo->taos, buffer, NO_INSERT_TYPE)){ + fprintf(stderr, "queryDbExec() failed. buffer:\n%s\n", buffer); free(buffer); return NULL; } @@ -2244,8 +2336,10 @@ static void* createTable(void *sarg) } if (0 != len) { - debugPrint("DEBUG %s() %d buffer: %s\n", __func__, __LINE__, buffer); - (void)queryDbExec(winfo->taos, buffer, NO_INSERT_TYPE); + verbosePrint("%s() %d buffer: %s\n", __func__, __LINE__, buffer); + if (0 != queryDbExec(winfo->taos, buffer, NO_INSERT_TYPE)) { + fprintf(stderr, "queryDbExec() failed. buffer:\n%s\n", buffer); + } } free(buffer); @@ -2282,6 +2376,7 @@ int startMultiThreadCreateChildTable( t_info->threadID = i; tstrncpy(t_info->db_name, db_name, MAX_DB_NAME_SIZE); t_info->superTblInfo = superTblInfo; + verbosePrint("%s() %d db_name: %s\n", __func__, __LINE__, db_name); t_info->taos = taos_connect( g_Dbs.host, g_Dbs.user, @@ -2290,6 +2385,8 @@ int startMultiThreadCreateChildTable( g_Dbs.port); if (t_info->taos == NULL) { fprintf(stderr, "Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL)); + free(pids); + free(infos); return -1; } t_info->start_table_id = last; @@ -2330,7 +2427,7 @@ static void createChildTables() { continue; } - debugPrint("DEBUG - %s() LN%d: %s\n", __func__, __LINE__, + verbosePrint("%s() LN%d: %s\n", __func__, __LINE__, g_Dbs.db[i].superTbls[j].colsOfCreateChildTable); startMultiThreadCreateChildTable( g_Dbs.db[i].superTbls[j].colsOfCreateChildTable, @@ -2342,27 +2439,26 @@ static void createChildTables() { } else { // normal table len = snprintf(tblColsBuf, MAX_SQL_SIZE, "(TS TIMESTAMP"); - for (int i = 0; i < MAX_COLUMN_COUNT; i++) { - if (g_args.datatype[i]) { - if ((strncasecmp(g_args.datatype[i], "BINARY", strlen("BINARY")) == 0) - || (strncasecmp(g_args.datatype[i], "NCHAR", strlen("NCHAR")) == 0)) { - len = snprintf(tblColsBuf + len, MAX_SQL_SIZE, ", COL%d %s(60)", i, g_args.datatype[i]); + int j = 0; + while (g_args.datatype[j]) { + if ((strncasecmp(g_args.datatype[j], "BINARY", strlen("BINARY")) == 0) + || (strncasecmp(g_args.datatype[j], "NCHAR", strlen("NCHAR")) == 0)) { + len = snprintf(tblColsBuf + len, MAX_SQL_SIZE, ", COL%d %s(60)", j, g_args.datatype[j]); } else { - len = snprintf(tblColsBuf + len, MAX_SQL_SIZE, ", COL%d %s", i, g_args.datatype[i]); + len = snprintf(tblColsBuf + len, MAX_SQL_SIZE, ", COL%d %s", j, g_args.datatype[j]); } len = strlen(tblColsBuf); - } else { - len = snprintf(tblColsBuf + len, MAX_SQL_SIZE, ")"); - break; + j++; } - } - debugPrint("DEBUG - %s() LN%d: %s\n", __func__, __LINE__, - tblColsBuf); - startMultiThreadCreateChildTable( + len = snprintf(tblColsBuf + len, MAX_SQL_SIZE - len, ")"); + + verbosePrint("%s() LN%d: dbName: %s num of tb: %d schema: %s\n", __func__, __LINE__, + g_Dbs.db[i].dbName, g_args.num_of_tables, tblColsBuf); + startMultiThreadCreateChildTable( tblColsBuf, g_Dbs.threadCountByCreateTbl, - g_args.num_of_DPT, + g_args.num_of_tables, g_Dbs.db[i].dbName, NULL); } @@ -2730,13 +2826,13 @@ static bool getMetaFromInsertJsonFile(cJSON* root) { goto PARSE_OVER; } - cJSON* insertInterval = cJSON_GetObjectItem(root, "insert_interval"); - if (insertInterval && insertInterval->type == cJSON_Number) { - g_args.insert_interval = insertInterval->valueint; - } else if (!insertInterval) { + cJSON* gInsertInterval = cJSON_GetObjectItem(root, "insert_interval"); + if (gInsertInterval && gInsertInterval->type == cJSON_Number) { + g_args.insert_interval = gInsertInterval->valueint; + } else if (!gInsertInterval) { g_args.insert_interval = 0; } else { - printf("failed to read json, insert_interval not found"); + printf("failed to read json, insert_interval input mistake"); goto PARSE_OVER; } @@ -3218,18 +3314,26 @@ static bool getMetaFromInsertJsonFile(cJSON* root) { printf("failed to read json, disorderRange not found"); goto PARSE_OVER; } - cJSON* insertRows = cJSON_GetObjectItem(stbInfo, "insert_rows"); if (insertRows && insertRows->type == cJSON_Number) { g_Dbs.db[i].superTbls[j].insertRows = insertRows->valueint; - //if (0 == g_Dbs.db[i].superTbls[j].insertRows) { - // g_Dbs.db[i].superTbls[j].insertRows = 0x7FFFFFFFFFFFFFFF; - //} } else if (!insertRows) { g_Dbs.db[i].superTbls[j].insertRows = 0x7FFFFFFFFFFFFFFF; } else { - printf("failed to read json, insert_rows not found"); + printf("failed to read json, insert_rows input mistake"); + goto PARSE_OVER; + } + + cJSON* insertInterval = cJSON_GetObjectItem(stbInfo, "insert_interval"); + if (insertInterval && insertInterval->type == cJSON_Number) { + g_Dbs.db[i].superTbls[j].insertInterval = insertInterval->valueint; + } else if (!insertInterval) { + debugPrint("%s() LN%d: stable insert interval be overrided by global %d.\n", + __func__, __LINE__, g_args.insert_interval); + g_Dbs.db[i].superTbls[j].insertInterval = g_args.insert_interval; + } else { + printf("failed to read json, insert_interval input mistake"); goto PARSE_OVER; } @@ -3582,7 +3686,7 @@ PARSE_OVER: } static bool getInfoFromJsonFile(char* file) { - debugPrint("DEBUG - %s %d %s\n", __func__, __LINE__, file); + debugPrint("%s %d %s\n", __func__, __LINE__, file); FILE *fp = fopen(file, "r"); if (!fp) { @@ -3741,6 +3845,7 @@ int generateRowData(char* dataBuf, int maxLen, int64_t timestamp, SSuperTable* return (-1); } } + dataLen -= 2; dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen, ")"); @@ -3771,7 +3876,6 @@ static void syncWriteForNumberOfTblInOneSql( } uint64_t time_counter = winfo->start_time; - int64_t tmp_time; int sampleUsePos; int64_t st = 0; @@ -3779,6 +3883,7 @@ static void syncWriteForNumberOfTblInOneSql( for (int i = 0; i < superTblInfo->insertRows;) { int32_t tbl_id = 0; for (int tID = winfo->start_table_id; tID <= winfo->end_table_id; ) { + int64_t tmp_time = 0; int inserted = i; for (int k = 0; k < g_args.num_of_RPR;) { @@ -3808,7 +3913,7 @@ static void syncWriteForNumberOfTblInOneSql( if (0 == len) { len += snprintf(pstr + len, superTblInfo->maxSqlLen - len, - "insert into %s.%s%d using %s.%s tags %s values ", + "insert into %s.%s%d using %s.%s tags %s values ", winfo->db_name, superTblInfo->childTblPrefix, tbl_id, @@ -3818,7 +3923,7 @@ static void syncWriteForNumberOfTblInOneSql( } else { len += snprintf(pstr + len, superTblInfo->maxSqlLen - len, - " %s.%s%d using %s.%s tags %s values ", + " %s.%s%d using %s.%s tags %s values ", winfo->db_name, superTblInfo->childTblPrefix, tbl_id, @@ -3831,13 +3936,13 @@ static void syncWriteForNumberOfTblInOneSql( if (0 == len) { len += snprintf(pstr + len, superTblInfo->maxSqlLen - len, - "insert into %s.%s values ", + "insert into %s.%s values ", winfo->db_name, superTblInfo->childTblName + tbl_id * TSDB_TABLE_NAME_LEN); } else { len += snprintf(pstr + len, superTblInfo->maxSqlLen - len, - " %s.%s values ", + " %s.%s values ", winfo->db_name, superTblInfo->childTblName + tbl_id * TSDB_TABLE_NAME_LEN); } @@ -3845,14 +3950,14 @@ static void syncWriteForNumberOfTblInOneSql( if (0 == len) { len += snprintf(pstr + len, superTblInfo->maxSqlLen - len, - "insert into %s.%s%d values ", + "insert into %s.%s%d values ", winfo->db_name, superTblInfo->childTblPrefix, tbl_id); } else { len += snprintf(pstr + len, superTblInfo->maxSqlLen - len, - " %s.%s%d values ", + " %s.%s%d values ", winfo->db_name, superTblInfo->childTblPrefix, tbl_id); @@ -3887,7 +3992,7 @@ static void syncWriteForNumberOfTblInOneSql( } else { retLen = generateRowData(pstr + len, superTblInfo->maxSqlLen - len, - tmp_time += superTblInfo->timeStampStep, + tmp_time += superTblInfo->timeStampStep, superTblInfo); } if (retLen < 0) { @@ -3915,7 +4020,7 @@ static void syncWriteForNumberOfTblInOneSql( send_to_server: if (g_args.insert_interval && (g_args.insert_interval > (et - st))) { int sleep_time = g_args.insert_interval - (et -st); - debugPrint("DEBUG sleep: %d ms\n", sleep_time); + printf("sleep: %d ms insert interval\n", sleep_time); taosMsleep(sleep_time); // ms } @@ -3932,29 +4037,30 @@ send_to_server: int64_t endTs; startTs = taosGetTimestampUs(); - debugPrint("DEBUG %s() LN%d buff: %s\n", __func__, __LINE__, buffer); + debugPrint("%s() LN%d buff: %s\n", __func__, __LINE__, buffer); int affectedRows = queryDbExec( winfo->taos, buffer, INSERT_TYPE); - if (0 > affectedRows) { - goto free_and_statistics; - } else { + if (0 < affectedRows) { endTs = taosGetTimestampUs(); int64_t delay = endTs - startTs; if (delay > winfo->maxDelay) winfo->maxDelay = delay; if (delay < winfo->minDelay) winfo->minDelay = delay; winfo->cntDelay++; winfo->totalDelay += delay; - //winfo->avgDelay = (double)winfo->totalDelay / winfo->cntDelay; + winfo->avgDelay = (double)winfo->totalDelay / winfo->cntDelay; + winfo->totalAffectedRows += affectedRows; + } else { + fprintf(stderr, "queryDbExec() buffer:\n%s\naffected rows is %d", buffer, affectedRows); + goto free_and_statistics; } - totalAffectedRows += affectedRows; int64_t currentPrintTime = taosGetTimestampMs(); if (currentPrintTime - lastPrintTime > 30*1000) { - printf("thread[%d] has currently inserted rows: %"PRId64 ", affected rows: %"PRId64 "\n", - winfo->threadID, - totalRowsInserted, - totalAffectedRows); + printf("thread[%d] has currently inserted rows: %"PRId64 ", affected rows: %"PRId64 "\n", + winfo->threadID, + winfo->totalRowsInserted, + winfo->totalAffectedRows); lastPrintTime = currentPrintTime; } //int64_t t2 = taosGetTimestampMs(); @@ -4073,11 +4179,10 @@ static void* syncWrite(void *sarg) { int len_of_binary = g_args.len_of_binary; int ncols_per_record = 1; // count first col ts - for (int i = 0; i < MAX_COLUMN_COUNT; i ++) { - if (NULL == g_args.datatype[i]) - break; - else - ncols_per_record ++; + int i = 0; + while(g_args.datatype[i]) { + i ++; + ncols_per_record ++; } srand((uint32_t)time(NULL)); @@ -4086,15 +4191,19 @@ static void* syncWrite(void *sarg) { uint64_t st = 0; uint64_t et = 0; - for (int i = 0; i < g_args.num_of_DPT;) { + winfo->totalRowsInserted = 0; + winfo->totalAffectedRows = 0; - for (int tID = winfo->start_table_id; tID <= winfo->end_table_id; tID++) { - int inserted = i; - int64_t tmp_time = time_counter; + for (int tID = winfo->start_table_id; tID <= winfo->end_table_id; tID++) { + int64_t tmp_time = time_counter; + + for (int i = 0; i < g_args.num_of_DPT;) { + + int tblInserted = i; char *pstr = buffer; pstr += sprintf(pstr, - "insert into %s.%s%d values", + "insert into %s.%s%d values ", winfo->db_name, g_args.tb_prefix, tID); int k; for (k = 0; k < g_args.num_of_RPR;) { @@ -4118,32 +4227,34 @@ static void* syncWrite(void *sarg) { } pstr += sprintf(pstr, " %s", data); - inserted++; + tblInserted++; k++; + i++; - if (inserted >= g_args.num_of_DPT) + if (tblInserted >= g_args.num_of_DPT) break; } + winfo->totalRowsInserted += k; /* puts(buffer); */ int64_t startTs; int64_t endTs; startTs = taosGetTimestampUs(); //queryDB(winfo->taos, buffer); - if (i > 0 && g_args.insert_interval + if (i > 0 && g_args.insert_interval && (g_args.insert_interval > (et - st) )) { int sleep_time = g_args.insert_interval - (et -st); - debugPrint("DEBUG sleep: %d ms\n", sleep_time); + printf("sleep: %d ms specified by insert_interval\n", sleep_time); taosMsleep(sleep_time); // ms - } + } - if (g_args.insert_interval) { + if (g_args.insert_interval) { st = taosGetTimestampMs(); - } - debugPrint("DEBUG - %s() LN%d %s\n", __func__, __LINE__, buffer); + } + verbosePrint("%s() LN%d %s\n", __func__, __LINE__, buffer); int affectedRows = queryDbExec(winfo->taos, buffer, 1); - - if (0 <= affectedRows){ + + if (0 < affectedRows){ endTs = taosGetTimestampUs(); int64_t delay = endTs - startTs; if (delay > winfo->maxDelay) @@ -4152,27 +4263,33 @@ static void* syncWrite(void *sarg) { winfo->minDelay = delay; winfo->cntDelay++; winfo->totalDelay += delay; - //winfo->avgDelay = (double)winfo->totalDelay / winfo->cntDelay; + winfo->totalAffectedRows += affectedRows; + winfo->avgDelay = (double)winfo->totalDelay / winfo->cntDelay; + } else { + fprintf(stderr, "queryDbExec() buffer:\n%s\naffected rows is %d", buffer, affectedRows); } - if (g_args.insert_interval) { + verbosePrint("%s() LN%d: totalaffectedRows:%"PRId64" tblInserted=%d\n", __func__, __LINE__, winfo->totalAffectedRows, tblInserted); + if (g_args.insert_interval) { et = taosGetTimestampMs(); - } - - if (tID == winfo->end_table_id) { - i = inserted; - time_counter = tmp_time; } - } - } + if (tblInserted >= g_args.num_of_DPT) { + break; + } + } // num_of_DPT + } // tId + + printf("====thread[%d] completed total inserted rows: %"PRId64 ", total affected rows: %"PRId64 "====\n", + winfo->threadID, + winfo->totalRowsInserted, + winfo->totalAffectedRows); + return NULL; } static void* syncWriteWithStb(void *sarg) { - uint64_t totalRowsInserted = 0; - uint64_t totalAffectedRows = 0; uint64_t lastPrintTime = taosGetTimestampMs(); threadInfo *winfo = (threadInfo *)sarg; @@ -4228,27 +4345,44 @@ static void* syncWriteWithStb(void *sarg) { return NULL; } - int64_t time_counter = winfo->start_time; uint64_t st = 0; uint64_t et = 0; - debugPrint("DEBUG - %s() LN%d insertRows=%"PRId64"\n", __func__, __LINE__, superTblInfo->insertRows); + winfo->totalRowsInserted = 0; + winfo->totalAffectedRows = 0; - for (int i = 0; i < superTblInfo->insertRows;) { + int sampleUsePos; - for (uint32_t tID = winfo->start_table_id; tID <= winfo->end_table_id; tID++) { - uint64_t inserted = i; - uint64_t tmp_time = time_counter; + verbosePrint("%s() LN%d insertRows=%"PRId64"\n", __func__, __LINE__, superTblInfo->insertRows); - int sampleUsePos = samplePos; - int k = 0; - debugPrint("DEBUG - %s() LN%d num_of_RPR=%d\n", __func__, __LINE__, g_args.num_of_RPR); - for (k = 0; k < g_args.num_of_RPR;) { - int len = 0; - memset(buffer, 0, superTblInfo->maxSqlLen); - char *pstr = buffer; + for (uint32_t tID = winfo->start_table_id; tID <= winfo->end_table_id; + tID++) { + int64_t start_time = winfo->start_time; - if (AUTO_CREATE_SUBTBL == superTblInfo->autoCreateTable) { + for (int i = 0; i < superTblInfo->insertRows;) { + + int64_t tblInserted = i; + + if (i > 0 && superTblInfo->insertInterval + && (superTblInfo->insertInterval > (et - st) )) { + int sleep_time = superTblInfo->insertInterval - (et -st); + printf("sleep: %d ms insert interval\n", sleep_time); + taosMsleep(sleep_time); // ms + } + + if (superTblInfo->insertInterval) { + st = taosGetTimestampMs(); + } + + sampleUsePos = samplePos; + verbosePrint("%s() LN%d num_of_RPR=%d\n", __func__, __LINE__, g_args.num_of_RPR); + + memset(buffer, 0, superTblInfo->maxSqlLen); + int len = 0; + + char *pstr = buffer; + + if (AUTO_CREATE_SUBTBL == superTblInfo->autoCreateTable) { char* tagsValBuf = NULL; if (0 == superTblInfo->tagSource) { tagsValBuf = generateTagVaulesForStb(superTblInfo); @@ -4271,27 +4405,29 @@ static void* syncWriteWithStb(void *sarg) { superTblInfo->sTblName, tagsValBuf); tmfree(tagsValBuf); - } else if (TBL_ALREADY_EXISTS == superTblInfo->childTblExists) { + } else if (TBL_ALREADY_EXISTS == superTblInfo->childTblExists) { len += snprintf(pstr + len, superTblInfo->maxSqlLen - len, "insert into %s.%s values", winfo->db_name, superTblInfo->childTblName + tID * TSDB_TABLE_NAME_LEN); - } else { + } else { len += snprintf(pstr + len, superTblInfo->maxSqlLen - len, "insert into %s.%s%d values", winfo->db_name, superTblInfo->childTblPrefix, tID); - } + } + int k; + for (k = 0; k < g_args.num_of_RPR;) { int retLen = 0; if (0 == strncasecmp(superTblInfo->dataSource, "sample", strlen("sample"))) { retLen = getRowDataFromSample( pstr + len, superTblInfo->maxSqlLen - len, - tmp_time += superTblInfo->timeStampStep, + start_time + superTblInfo->timeStampStep * i, superTblInfo, &sampleUsePos, fp, @@ -4303,135 +4439,104 @@ static void* syncWriteWithStb(void *sarg) { int rand_num = rand_tinyint() % 100; if (0 != superTblInfo->disorderRatio && rand_num < superTblInfo->disorderRatio) { - int64_t d = tmp_time - rand() % superTblInfo->disorderRange; + int64_t d = start_time - rand() % superTblInfo->disorderRange; retLen = generateRowData( pstr + len, - superTblInfo->maxSqlLen - len, d, + superTblInfo->maxSqlLen - len, + d, superTblInfo); //printf("disorder rows, rand_num:%d, last ts:%"PRId64" current ts:%"PRId64"\n", rand_num, tmp_time, d); } else { retLen = generateRowData( pstr + len, superTblInfo->maxSqlLen - len, - tmp_time += superTblInfo->timeStampStep, + start_time + superTblInfo->timeStampStep * i, superTblInfo); } if (retLen < 0) { goto free_and_statistics_2; } } -/* len += retLen; -*/ - inserted++; + + len += retLen; + verbosePrint("%s() LN%d retLen=%d len=%d k=%d \nbuffer=%s\n", __func__, __LINE__, retLen, len, k, buffer); + + tblInserted++; k++; - totalRowsInserted++; - - if (inserted > superTblInfo->insertRows) + i++; + + if (tblInserted >= superTblInfo->insertRows) break; -/* if (inserted >= superTblInfo->insertRows - || (superTblInfo->maxSqlLen - len) < (superTblInfo->lenOfOneRow + 128)) - break; -*/ - if (i > 0 && g_args.insert_interval - && (g_args.insert_interval > (et - st) )) { - int sleep_time = g_args.insert_interval - (et -st); - debugPrint("DEBUG sleep: %d ms\n", sleep_time); - taosMsleep(sleep_time); // ms - } + } + + winfo->totalRowsInserted += k; - if (g_args.insert_interval) { - st = taosGetTimestampMs(); - } - - if (0 == strncasecmp(superTblInfo->insertMode, "taosc", strlen("taosc"))) { - //printf("===== sql: %s \n\n", buffer); - //int64_t t1 = taosGetTimestampMs(); - int64_t startTs; - int64_t endTs; - startTs = taosGetTimestampUs(); - - debugPrint("DEBUG %s() LN%d %s\n", __func__, __LINE__, buffer); - int affectedRows = queryDbExec(winfo->taos, buffer, INSERT_TYPE); + int64_t startTs = taosGetTimestampUs(); + int64_t endTs; + int affectedRows; + if (0 == strncasecmp(superTblInfo->insertMode, "taosc", strlen("taosc"))) { + verbosePrint("%s() LN%d %s\n", __func__, __LINE__, buffer); + affectedRows = queryDbExec(winfo->taos, buffer, INSERT_TYPE); if (0 > affectedRows){ goto free_and_statistics_2; - } else { - endTs = taosGetTimestampUs(); - int64_t delay = endTs - startTs; - if (delay > winfo->maxDelay) winfo->maxDelay = delay; - if (delay < winfo->minDelay) winfo->minDelay = delay; - winfo->cntDelay++; - winfo->totalDelay += delay; - //winfo->avgDelay = (double)winfo->totalDelay / winfo->cntDelay; } - totalAffectedRows += affectedRows; - - int64_t currentPrintTime = taosGetTimestampMs(); - if (currentPrintTime - lastPrintTime > 30*1000) { - printf("thread[%d] has currently inserted rows: %"PRId64 ", affected rows: %"PRId64 "\n", - winfo->threadID, - totalRowsInserted, - totalAffectedRows); - lastPrintTime = currentPrintTime; - } - //int64_t t2 = taosGetTimestampMs(); - //printf("taosc insert sql return, Spent %.4f seconds \n", (double)(t2 - t1)/1000.0); - } else { - //int64_t t1 = taosGetTimestampMs(); + } else { + verbosePrint("%s() LN%d %s\n", __func__, __LINE__, buffer); int retCode = postProceSql(g_Dbs.host, g_Dbs.port, buffer); - //int64_t t2 = taosGetTimestampMs(); - //printf("http insert sql return, Spent %ld ms \n", t2 - t1); - + if (0 != retCode) { printf("========restful return fail, threadID[%d]\n", winfo->threadID); goto free_and_statistics_2; } - } - if (g_args.insert_interval) { - et = taosGetTimestampMs(); - } -/* - if (loop_cnt) { - loop_cnt--; - if ((1 == loop_cnt) && (0 != nrecords_last_req)) { - nrecords_cur_req = nrecords_last_req; - } else if (0 == loop_cnt){ - nrecords_cur_req = nrecords_no_last_req; - loop_cnt = loop_cnt_orig; - break; - } - } else { - break; - } - */ + + affectedRows = k; } - if (tID == winfo->end_table_id) { + endTs = taosGetTimestampUs(); + int64_t delay = endTs - startTs; + if (delay > winfo->maxDelay) winfo->maxDelay = delay; + if (delay < winfo->minDelay) winfo->minDelay = delay; + winfo->cntDelay++; + winfo->totalDelay += delay; + + winfo->totalAffectedRows += affectedRows; + + int64_t currentPrintTime = taosGetTimestampMs(); + if (currentPrintTime - lastPrintTime > 30*1000) { + printf("thread[%d] has currently inserted rows: %"PRId64 ", affected rows: %"PRId64 "\n", + winfo->threadID, + winfo->totalRowsInserted, + winfo->totalAffectedRows); + lastPrintTime = currentPrintTime; + } + + if (superTblInfo->insertInterval) { + et = taosGetTimestampMs(); + } + + if (tblInserted >= superTblInfo->insertRows) + break; + } // num_of_DPT + + if (tID == winfo->end_table_id) { if (0 == strncasecmp( superTblInfo->dataSource, "sample", strlen("sample"))) { samplePos = sampleUsePos; } - i = inserted; - time_counter = tmp_time; - } } - - //printf("========loop %d childTables duration:%"PRId64 "========inserted rows:%d\n", winfo->end_table_id - winfo->start_table_id, et - st, i); - } + } // tID free_and_statistics_2: tmfree(buffer); tmfree(sampleDataBuf); tmfclose(fp); - winfo->totalRowsInserted = totalRowsInserted; - winfo->totalAffectedRows = totalAffectedRows; - printf("====thread[%d] completed total inserted rows: %"PRId64 ", total affected rows: %"PRId64 "====\n", winfo->threadID, - totalRowsInserted, - totalAffectedRows); + winfo->totalRowsInserted, + winfo->totalAffectedRows); return NULL; } @@ -4449,7 +4554,8 @@ void callBack(void *param, TAOS_RES *res, int code) { char *data = calloc(1, MAX_DATA_SIZE); char *pstr = buffer; pstr += sprintf(pstr, "insert into %s.%s%d values", winfo->db_name, winfo->tb_prefix, winfo->start_table_id); - if (winfo->counter >= winfo->superTblInfo->insertRows) { +// if (winfo->counter >= winfo->superTblInfo->insertRows) { + if (winfo->counter >= g_args.num_of_RPR) { winfo->start_table_id++; winfo->counter = 0; } @@ -4558,11 +4664,14 @@ void startMultiThreadInsertData(int threads, char* db_name, char* precision, if (0 == strncasecmp(superTblInfo->startTimestamp, "now", 3)) { start_time = taosGetTimestamp(timePrec); } else { - taosParseTime( + if (TSDB_CODE_SUCCESS != taosParseTime( superTblInfo->startTimestamp, &start_time, strlen(superTblInfo->startTimestamp), - timePrec, 0); + timePrec, 0)) { + printf("ERROR to parse time!\n"); + exit(-1); + } } } else { start_time = 1500000000000; @@ -4637,12 +4746,12 @@ void startMultiThreadInsertData(int threads, char* db_name, char* precision, if (superTblInfo) { superTblInfo->totalAffectedRows += t_info->totalAffectedRows; superTblInfo->totalRowsInserted += t_info->totalRowsInserted; - - totalDelay += t_info->totalDelay; - cntDelay += t_info->cntDelay; - if (t_info->maxDelay > maxDelay) maxDelay = t_info->maxDelay; - if (t_info->minDelay < minDelay) minDelay = t_info->minDelay; } + + totalDelay += t_info->totalDelay; + cntDelay += t_info->cntDelay; + if (t_info->maxDelay > maxDelay) maxDelay = t_info->maxDelay; + if (t_info->minDelay < minDelay) minDelay = t_info->minDelay; } cntDelay -= 1; @@ -4691,11 +4800,12 @@ void *readTable(void *sarg) { } int num_of_DPT; - if (rinfo->superTblInfo) { +/* if (rinfo->superTblInfo) { num_of_DPT = rinfo->superTblInfo->insertRows; // nrecords_per_table; } else { + */ num_of_DPT = g_args.num_of_DPT; - } +// } int num_of_tables = rinfo->end_table_id - rinfo->start_table_id + 1; int totalData = num_of_DPT * num_of_tables; @@ -4829,7 +4939,7 @@ int insertTestProcess() { if (ret == -1) exit(EXIT_FAILURE); - debugPrint("DEBUG - %d result file: %s\n", __LINE__, g_Dbs.resultFile); + debugPrint("%d result file: %s\n", __LINE__, g_Dbs.resultFile); g_fpOfInsertResult = fopen(g_Dbs.resultFile, "a"); if (NULL == g_fpOfInsertResult) { fprintf(stderr, "Failed to open %s for save result\n", g_Dbs.resultFile); @@ -4985,7 +5095,7 @@ void *subQueryProcess(void *sarg) { int64_t st = 0; int64_t et = (int64_t)g_queryInfo.subQueryInfo.rate*1000; while (1) { - if (g_queryInfo.subQueryInfo.rate && (et - st) < g_queryInfo.subQueryInfo.rate*1000) { + if (g_queryInfo.subQueryInfo.rate && (et - st) < (int64_t)g_queryInfo.subQueryInfo.rate*1000) { taosMsleep(g_queryInfo.subQueryInfo.rate*1000 - (et - st)); // ms //printf("========sleep duration:%"PRId64 "========inserted rows:%d, table range:%d - %d\n", (1000 - (et - st)), i, winfo->start_table_id, winfo->end_table_id); } @@ -5065,7 +5175,7 @@ static int queryTestProcess() { char sqlStr[MAX_TB_NAME_SIZE*2]; sprintf(sqlStr, "use %s", g_queryInfo.dbName); - debugPrint("DEBUG %s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr); + verbosePrint("%s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr); (void)queryDbExec(t_info->taos, sqlStr, NO_INSERT_TYPE); } else { t_info->taos = NULL; @@ -5176,7 +5286,7 @@ void *subSubscribeProcess(void *sarg) { char sqlStr[MAX_TB_NAME_SIZE*2]; sprintf(sqlStr, "use %s", g_queryInfo.dbName); - debugPrint("DEBUG %s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr); + debugPrint("%s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr); if (0 != queryDbExec(winfo->taos, sqlStr, NO_INSERT_TYPE)){ return NULL; } @@ -5242,7 +5352,7 @@ void *superSubscribeProcess(void *sarg) { char sqlStr[MAX_TB_NAME_SIZE*2]; sprintf(sqlStr, "use %s", g_queryInfo.dbName); - debugPrint("DEBUG %s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr); + debugPrint("%s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr); if (0 != queryDbExec(winfo->taos, sqlStr, NO_INSERT_TYPE)) { return NULL; } @@ -5502,7 +5612,7 @@ void setParaFromArg(){ "2017-07-14 10:40:00.000", MAX_TB_NAME_SIZE); g_Dbs.db[0].superTbls[0].timeStampStep = 10; - g_Dbs.db[0].superTbls[0].insertRows = g_args.num_of_DPT; + g_Dbs.db[0].superTbls[0].insertRows = g_args.num_of_DPT; g_Dbs.db[0].superTbls[0].maxSqlLen = TSDB_PAYLOAD_SIZE; g_Dbs.db[0].superTbls[0].columnCount = 0; @@ -5607,8 +5717,15 @@ void querySqlFile(TAOS* taos, char* sqlFile) } memcpy(cmd + cmd_len, line, read_len); - debugPrint("DEBUG %s() LN%d cmd: %s\n", __func__, __LINE__, cmd); + verbosePrint("%s() LN%d cmd: %s\n", __func__, __LINE__, cmd); queryDbExec(taos, cmd, NO_INSERT_TYPE); + if (0 != queryDbExec(taos, cmd, NO_INSERT_TYPE)) { + printf("queryDbExec %s failed!\n", cmd); + tmfree(cmd); + tmfree(line); + tmfclose(fp); + return; + } memset(cmd, 0, MAX_SQL_SIZE); cmd_len = 0; } @@ -5695,7 +5812,7 @@ static void testCmdLine() { int main(int argc, char *argv[]) { parse_args(argc, argv, &g_args); - debugPrint("DEBUG - meta file: %s\n", g_args.metaFile); + debugPrint("meta file: %s\n", g_args.metaFile); if (g_args.metaFile) { initOfInsertMeta(); diff --git a/src/kit/taosdump/taosdump.c b/src/kit/taosdump/taosdump.c index e2105ad18b..3cee5f1b1d 100644 --- a/src/kit/taosdump/taosdump.c +++ b/src/kit/taosdump/taosdump.c @@ -769,6 +769,7 @@ int32_t taosSaveTableOfMetricToTempFile(TAOS *taosCon, char* metric, struct argu } sprintf(tmpBuf, ".select-tbname.tmp"); (void)remove(tmpBuf); + free(tblBuf); close(fd); return -1; } @@ -1523,6 +1524,7 @@ int taosDumpDb(SDbInfo *dbInfo, struct arguments *arguments, FILE *fp, TAOS *tao } sprintf(tmpBuf, ".show-tables.tmp"); (void)remove(tmpBuf); + free(tblBuf); close(fd); return -1; } diff --git a/src/mnode/inc/mnodeDef.h b/src/mnode/inc/mnodeDef.h index 5eeac97209..ed1de1b87a 100644 --- a/src/mnode/inc/mnodeDef.h +++ b/src/mnode/inc/mnodeDef.h @@ -175,7 +175,9 @@ typedef struct { int8_t quorum; int8_t update; int8_t cacheLastRow; - int8_t reserved[10]; + int8_t dbType; + int16_t partitions; + int8_t reserved[7]; } SDbCfg; typedef struct SDbObj { diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c index 9fdbaa7965..fcc88db740 100644 --- a/src/mnode/src/mnodeDb.c +++ b/src/mnode/src/mnodeDb.c @@ -22,6 +22,7 @@ #include "tname.h" #include "tbn.h" #include "tdataformat.h" +#include "tp.h" #include "mnode.h" #include "mnodeDef.h" #include "mnodeInt.h" @@ -38,8 +39,8 @@ #include "mnodeVgroup.h" #define VG_LIST_SIZE 8 -int64_t tsDbRid = -1; -static void * tsDbSdb = NULL; +int64_t tsDbRid = -1; +void * tsDbSdb = NULL; static int32_t tsDbUpdateSize; static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg *pMsg); @@ -48,8 +49,14 @@ static int32_t mnodeSetDbDropping(SDbObj *pDb); static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn); static int32_t mnodeRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn); static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg); -static int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg); static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg); +int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg); + +#ifndef _TOPIC +int32_t tpInit() { return 0; } +void tpCleanUp() {} +void tpUpdateTs(int32_t *seq, void *pMsg) {} +#endif static void mnodeDestroyDb(SDbObj *pDb) { pthread_mutex_destroy(&pDb->mutex); @@ -176,7 +183,7 @@ int32_t mnodeInitDbs() { mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_DB, mnodeCancelGetNextDb); mDebug("table:dbs table is created"); - return 0; + return tpInit(); } void *mnodeGetNextDb(void *pIter, SDbObj **pDb) { @@ -332,6 +339,17 @@ static int32_t mnodeCheckDbCfg(SDbCfg *pCfg) { return TSDB_CODE_MND_INVALID_DB_OPTION; } + if (pCfg->dbType < 0 || pCfg->dbType > 1) { + mError("invalid db option dbType:%d valid range: [%d, %d]", pCfg->dbType, 0, 1); + return TSDB_CODE_MND_INVALID_DB_OPTION; + } + + if (pCfg->partitions < TSDB_MIN_DB_PARTITON_OPTION || pCfg->partitions > TSDB_MAX_DB_PARTITON_OPTION) { + mError("invalid db option partitions:%d valid range: [%d, %d]", pCfg->partitions, TSDB_MIN_DB_PARTITON_OPTION, + TSDB_MAX_DB_PARTITON_OPTION); + return TSDB_CODE_MND_INVALID_DB_OPTION; + } + return TSDB_CODE_SUCCESS; } @@ -354,6 +372,8 @@ static void mnodeSetDefaultDbCfg(SDbCfg *pCfg) { if (pCfg->quorum < 0) pCfg->quorum = tsQuorum; if (pCfg->update < 0) pCfg->update = tsUpdate; if (pCfg->cacheLastRow < 0) pCfg->cacheLastRow = tsCacheLastRow; + if (pCfg->dbType < 0) pCfg->dbType = 0; + if (pCfg->partitions < 0) pCfg->partitions = tsPartitons; } static int32_t mnodeCreateDbCb(SMnodeMsg *pMsg, int32_t code) { @@ -408,7 +428,9 @@ static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg * .replications = pCreate->replications, .quorum = pCreate->quorum, .update = pCreate->update, - .cacheLastRow = pCreate->cacheLastRow + .cacheLastRow = pCreate->cacheLastRow, + .dbType = pCreate->dbType, + .partitions = pCreate->partitions }; mnodeSetDefaultDbCfg(&pDb->cfg); @@ -501,6 +523,7 @@ void mnodeRemoveVgroupFromDb(SVgObj *pVgroup) { } void mnodeCleanupDbs() { + tpCleanUp(); sdbCloseTable(tsDbRid); tsDbSdb = NULL; } @@ -660,7 +683,7 @@ static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn return 0; } -static char *mnodeGetDbStr(char *src) { +char *mnodeGetDbStr(char *src) { char *pos = strstr(src, TS_PATH_DELIMITER); if (pos != NULL) ++pos; @@ -852,6 +875,7 @@ static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg) { pCreate->daysToKeep2 = htonl(pCreate->daysToKeep2); pCreate->commitTime = htonl(pCreate->commitTime); pCreate->fsyncPeriod = htonl(pCreate->fsyncPeriod); + pCreate->partitions = htons(pCreate->partitions); pCreate->minRowsPerFileBlock = htonl(pCreate->minRowsPerFileBlock); pCreate->maxRowsPerFileBlock = htonl(pCreate->maxRowsPerFileBlock); @@ -887,6 +911,8 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SAlterDbMsg *pAlter) { int8_t precision = pAlter->precision; int8_t update = pAlter->update; int8_t cacheLastRow = pAlter->cacheLastRow; + int8_t dbType = pAlter->dbType; + int16_t partitions = htons(pAlter->partitions); terrno = TSDB_CODE_SUCCESS; @@ -1004,6 +1030,16 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SAlterDbMsg *pAlter) { newCfg.cacheLastRow = cacheLastRow; } + if (dbType >= 0 && dbType != pDb->cfg.dbType) { + mDebug("db:%s, dbType:%d change to %d", pDb->name, pDb->cfg.dbType, dbType); + newCfg.dbType = dbType; + } + + if (partitions >= 0 && partitions != pDb->cfg.partitions) { + mDebug("db:%s, partitions:%d change to %d", pDb->name, pDb->cfg.partitions, partitions); + newCfg.partitions = partitions; + } + return newCfg; } @@ -1031,6 +1067,8 @@ static int32_t mnodeAlterDbCb(SMnodeMsg *pMsg, int32_t code) { } static int32_t mnodeAlterDb(SDbObj *pDb, SAlterDbMsg *pAlter, void *pMsg) { + mDebug("db:%s, type:%d do alter operation", pDb->name, pDb->cfg.dbType); + SDbCfg newCfg = mnodeGetAlterDbOption(pDb, pAlter); if (terrno != TSDB_CODE_SUCCESS) { return terrno; @@ -1061,9 +1099,9 @@ static int32_t mnodeAlterDb(SDbObj *pDb, SAlterDbMsg *pAlter, void *pMsg) { return code; } -static int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg) { +int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg) { SAlterDbMsg *pAlter = pMsg->rpcMsg.pCont; - mDebug("db:%s, alter db msg is received from thandle:%p", pAlter->db, pMsg->rpcMsg.handle); + mDebug("db:%s, alter db msg is received from thandle:%p, dbType:%d", pAlter->db, pMsg->rpcMsg.handle, pAlter->dbType); if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pAlter->db); if (pMsg->pDb == NULL) { diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c index 4ff2a38dff..03772f2724 100644 --- a/src/mnode/src/mnodeShow.c +++ b/src/mnode/src/mnodeShow.c @@ -109,6 +109,7 @@ static char *mnodeGetShowType(int32_t showType) { case TSDB_MGMT_TABLE_VNODES: return "show vnodes"; case TSDB_MGMT_TABLE_CLUSTER: return "show clusters"; case TSDB_MGMT_TABLE_STREAMTABLES : return "show streamtables"; + case TSDB_MGMT_TABLE_TP: return "show topics"; default: return "undefined"; } } diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c index 98eab3f1ed..008a655597 100644 --- a/src/mnode/src/mnodeVgroup.c +++ b/src/mnode/src/mnodeVgroup.c @@ -367,6 +367,11 @@ static int32_t mnodeAllocVgroupIdPool(SVgObj *pInputVgroup) { maxIdPoolSize = MAX(maxIdPoolSize, idPoolSize); } + // create one table each vnode + if (pDb->cfg.dbType == TSDB_DB_TYPE_TOPIC) { + maxIdPoolSize = 1; + } + // new vgroup if (pInputVgroup->idPool == NULL) { pInputVgroup->idPool = taosInitIdPool(maxIdPoolSize); @@ -379,6 +384,11 @@ static int32_t mnodeAllocVgroupIdPool(SVgObj *pInputVgroup) { } } + // create one table each vnode + if (pDb->cfg.dbType == TSDB_DB_TYPE_TOPIC) { + return TSDB_CODE_SUCCESS; + } + // realloc all vgroups in db int32_t newIdPoolSize; if (minIdPoolSize * 4 < tsTableIncStepPerVnode) { @@ -449,6 +459,10 @@ int32_t mnodeGetAvailableVgroup(SMnodeMsg *pMsg, SVgObj **ppVgroup, int32_t *pSi maxVgroupsPerDb = MIN(maxVgroupsPerDb, TSDB_MAX_VNODES_PER_DB); } + if (pDb->cfg.dbType == TSDB_DB_TYPE_TOPIC) { + maxVgroupsPerDb = TSDB_MAX_DB_PARTITON_OPTION; + } + int32_t code = TSDB_CODE_MND_NO_ENOUGH_DNODES; if (pDb->numOfVgroups < maxVgroupsPerDb) { mDebug("msg:%p, app:%p db:%s, try to create a new vgroup, numOfVgroups:%d maxVgroupsPerDb:%d", pMsg, @@ -881,6 +895,7 @@ static SCreateVnodeMsg *mnodeBuildVnodeMsg(SVgObj *pVgroup) { pCfg->update = pDb->cfg.update; pCfg->cacheLastRow = pDb->cfg.cacheLastRow; pCfg->dbReplica = pDb->cfg.replications; + pCfg->dbType = pDb->cfg.dbType; SVnodeDesc *pNodes = pVnode->nodes; for (int32_t j = 0; j < pVgroup->numOfVnodes; ++j) { diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h index bcc876c953..33348c8565 100644 --- a/src/query/inc/qSqlparser.h +++ b/src/query/inc/qSqlparser.h @@ -125,6 +125,8 @@ typedef struct SCreateDbInfo { int8_t update; int8_t cachelast; SArray *keep; + int8_t dbType; + int16_t partitions; } SCreateDbInfo; typedef struct SCreateAcctInfo { @@ -155,6 +157,7 @@ typedef struct SUserInfo { typedef struct SMiscInfo { SArray *a; // SArray bool existsCheck; + int16_t dbType; int16_t tableType; SUserInfo user; union { @@ -265,7 +268,7 @@ void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken void SqlInfoDestroy(SSqlInfo *pInfo); void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParams, ...); -void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck,int16_t tableType); +void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck,int16_t dbType,int16_t tableType); void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken* pPatterns); void setCreateDbInfo(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDbInfo *pDB, SStrToken *pIgExists); @@ -276,6 +279,7 @@ void setKillSql(SSqlInfo *pInfo, int32_t type, SStrToken *ip); void setAlterUserSql(SSqlInfo *pInfo, int16_t type, SStrToken *pName, SStrToken* pPwd, SStrToken *pPrivilege); void setDefaultCreateDbOption(SCreateDbInfo *pDBInfo); +void setDefaultCreateTopicOption(SCreateDbInfo *pDBInfo); // prefix show db.tables; void setDbName(SStrToken *pCpxName, SStrToken *pDb); diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y index 8a01a736b7..1bafe241e3 100644 --- a/src/query/inc/sql.y +++ b/src/query/inc/sql.y @@ -64,6 +64,7 @@ program ::= cmd. {} //////////////////////////////////THE SHOW STATEMENT/////////////////////////////////////////// cmd ::= SHOW DATABASES. { setShowOptions(pInfo, TSDB_MGMT_TABLE_DB, 0, 0);} +cmd ::= SHOW TOPICS. { setShowOptions(pInfo, TSDB_MGMT_TABLE_TP, 0, 0);} cmd ::= SHOW MNODES. { setShowOptions(pInfo, TSDB_MGMT_TABLE_MNODE, 0, 0);} cmd ::= SHOW DNODES. { setShowOptions(pInfo, TSDB_MGMT_TABLE_DNODE, 0, 0);} cmd ::= SHOW ACCOUNTS. { setShowOptions(pInfo, TSDB_MGMT_TABLE_ACCT, 0, 0);} @@ -131,16 +132,18 @@ cmd ::= SHOW dbPrefix(X) VGROUPS ids(Y). { //drop configure for tables cmd ::= DROP TABLE ifexists(Y) ids(X) cpxName(Z). { X.n += Z.n; - setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &X, &Y, -1); + setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &X, &Y, -1, -1); } //drop stable cmd ::= DROP STABLE ifexists(Y) ids(X) cpxName(Z). { X.n += Z.n; - setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &X, &Y, TSDB_SUPER_TABLE); + setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &X, &Y, -1, TSDB_SUPER_TABLE); } -cmd ::= DROP DATABASE ifexists(Y) ids(X). { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y, -1); } +cmd ::= DROP DATABASE ifexists(Y) ids(X). { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y, TSDB_DB_TYPE_DEFAULT, -1); } +cmd ::= DROP TOPIC ifexists(Y) ids(X). { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y, TSDB_DB_TYPE_TOPIC, -1); } + cmd ::= DROP DNODE ids(X). { setDCLSQLElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &X); } cmd ::= DROP USER ids(X). { setDCLSQLElems(pInfo, TSDB_SQL_DROP_USER, 1, &X); } cmd ::= DROP ACCOUNT ids(X). { setDCLSQLElems(pInfo, TSDB_SQL_DROP_ACCT, 1, &X); } @@ -162,6 +165,7 @@ cmd ::= ALTER DNODE ids(X) ids(Y) ids(Z). { setDCLSQLElems(pInfo, TSDB_SQL cmd ::= ALTER LOCAL ids(X). { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &X); } cmd ::= ALTER LOCAL ids(X) ids(Y). { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &X, &Y); } cmd ::= ALTER DATABASE ids(X) alter_db_optr(Y). { SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);} +cmd ::= ALTER TOPIC ids(X) alter_topic_optr(Y). { SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);} cmd ::= ALTER ACCOUNT ids(X) acct_optr(Z). { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &X, NULL, &Z);} cmd ::= ALTER ACCOUNT ids(X) PASS ids(Y) acct_optr(Z). { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &X, &Y, &Z);} @@ -187,6 +191,7 @@ cmd ::= CREATE DNODE ids(X). { setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE cmd ::= CREATE ACCOUNT ids(X) PASS ids(Y) acct_optr(Z). { setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &X, &Y, &Z);} cmd ::= CREATE DATABASE ifnotexists(Z) ids(X) db_optr(Y). { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);} +cmd ::= CREATE TOPIC ifnotexists(Z) ids(X) topic_optr(Y). { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);} cmd ::= CREATE USER ids(X) PASS ids(Y). { setCreateUserSql(pInfo, &X, &Y);} pps(Y) ::= . { Y.n = 0; } @@ -247,9 +252,10 @@ comp(Y) ::= COMP INTEGER(X). { Y = X; } prec(Y) ::= PRECISION STRING(X). { Y = X; } update(Y) ::= UPDATE INTEGER(X). { Y = X; } cachelast(Y) ::= CACHELAST INTEGER(X). { Y = X; } +partitions(Y) ::= PARTITIONS INTEGER(X). { Y = X; } %type db_optr {SCreateDbInfo} -db_optr(Y) ::= . {setDefaultCreateDbOption(&Y);} +db_optr(Y) ::= . {setDefaultCreateDbOption(&Y); Y.dbType = TSDB_DB_TYPE_DEFAULT;} db_optr(Y) ::= db_optr(Z) cache(X). { Y = Z; Y.cacheBlockSize = strtol(X.z, NULL, 10); } db_optr(Y) ::= db_optr(Z) replica(X). { Y = Z; Y.replica = strtol(X.z, NULL, 10); } @@ -267,8 +273,13 @@ db_optr(Y) ::= db_optr(Z) keep(X). { Y = Z; Y.keep = X; } db_optr(Y) ::= db_optr(Z) update(X). { Y = Z; Y.update = strtol(X.z, NULL, 10); } db_optr(Y) ::= db_optr(Z) cachelast(X). { Y = Z; Y.cachelast = strtol(X.z, NULL, 10); } +%type topic_optr {SCreateDbInfo} + +topic_optr(Y) ::= db_optr(Z). { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; } +topic_optr(Y) ::= topic_optr(Z) partitions(X). { Y = Z; Y.partitions = strtol(X.z, NULL, 10); } + %type alter_db_optr {SCreateDbInfo} -alter_db_optr(Y) ::= . { setDefaultCreateDbOption(&Y);} +alter_db_optr(Y) ::= . { setDefaultCreateDbOption(&Y); Y.dbType = TSDB_DB_TYPE_DEFAULT;} alter_db_optr(Y) ::= alter_db_optr(Z) replica(X). { Y = Z; Y.replica = strtol(X.z, NULL, 10); } alter_db_optr(Y) ::= alter_db_optr(Z) quorum(X). { Y = Z; Y.quorum = strtol(X.z, NULL, 10); } @@ -280,6 +291,11 @@ alter_db_optr(Y) ::= alter_db_optr(Z) fsync(X). { Y = Z; Y.fsyncPeriod = s alter_db_optr(Y) ::= alter_db_optr(Z) update(X). { Y = Z; Y.update = strtol(X.z, NULL, 10); } alter_db_optr(Y) ::= alter_db_optr(Z) cachelast(X). { Y = Z; Y.cachelast = strtol(X.z, NULL, 10); } +%type alter_topic_optr {SCreateDbInfo} + +alter_topic_optr(Y) ::= alter_db_optr(Z). { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; } +alter_topic_optr(Y) ::= alter_topic_optr(Z) partitions(X). { Y = Z; Y.partitions = strtol(X.z, NULL, 10); } + %type typename {TAOS_FIELD} typename(A) ::= ids(X). { X.type = 0; @@ -821,3 +837,4 @@ cmd ::= KILL QUERY INTEGER(X) COLON(Z) INTEGER(Y). {X.n += (Z.n + Y.n); s COUNT SUM AVG MIN MAX FIRST LAST TOP BOTTOM STDDEV PERCENTILE APERCENTILE LEASTSQUARES HISTOGRAM DIFF SPREAD TWA INTERP LAST_ROW RATE IRATE SUM_RATE SUM_IRATE AVG_RATE AVG_IRATE TBID NOW IPTOKEN SEMI NONE PREV LINEAR IMPORT METRIC TBNAME JOIN METRICS STABLE NULL INSERT INTO VALUES. + \ No newline at end of file diff --git a/src/query/src/qParserImpl.c b/src/query/src/qParserImpl.c index 5937fdb68f..d18eae033b 100644 --- a/src/query/src/qParserImpl.c +++ b/src/query/src/qParserImpl.c @@ -805,7 +805,7 @@ void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParam, ...) { va_end(va); } -void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck, int16_t tableType) { +void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck, int16_t dbType, int16_t tableType) { pInfo->type = type; if (pInfo->pMiscInfo == NULL) { @@ -816,6 +816,7 @@ void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrTo taosArrayPush(pInfo->pMiscInfo->a, pToken); pInfo->pMiscInfo->existsCheck = (existsCheck->n == 1); + pInfo->pMiscInfo->dbType = dbType; pInfo->pMiscInfo->tableType = tableType; } @@ -935,6 +936,17 @@ void setDefaultCreateDbOption(SCreateDbInfo *pDBInfo) { pDBInfo->keep = NULL; pDBInfo->update = -1; - pDBInfo->cachelast = 0; + pDBInfo->cachelast = -1; + + pDBInfo->dbType = -1; + pDBInfo->partitions = -1; + memset(&pDBInfo->precision, 0, sizeof(SStrToken)); } + +void setDefaultCreateTopicOption(SCreateDbInfo *pDBInfo) { + setDefaultCreateDbOption(pDBInfo); + + pDBInfo->dbType = TSDB_DB_TYPE_TOPIC; + pDBInfo->partitions = TSDB_DEFAULT_DB_PARTITON_OPTION; +} diff --git a/src/query/src/qTokenizer.c b/src/query/src/qTokenizer.c index b55f813b5b..cb411be518 100644 --- a/src/query/src/qTokenizer.c +++ b/src/query/src/qTokenizer.c @@ -241,6 +241,9 @@ static SKeyword keywordTable[] = { {"AVG_IRATE", TK_AVG_IRATE}, {"CACHELAST", TK_CACHELAST}, {"DISTINCT", TK_DISTINCT}, + {"PARTITIONS", TK_PARTITIONS}, + {"TOPIC", TK_TOPIC}, + {"TOPICS", TK_TOPICS} }; static const char isIdChar[] = { diff --git a/src/query/src/sql.c b/src/query/src/sql.c index 2b1109688d..bed9121b04 100644 --- a/src/query/src/sql.c +++ b/src/query/src/sql.c @@ -100,27 +100,27 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 281 +#define YYNOCODE 287 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SStrToken typedef union { int yyinit; ParseTOKENTYPE yy0; - SCreatedTableInfo yy42; - SCreateAcctInfo yy47; - SQuerySQL* yy114; - TAOS_FIELD yy179; - SLimitVal yy204; - SSubclauseInfo* yy219; - int yy222; - SArray* yy247; - SCreateDbInfo yy262; - tSQLExpr* yy326; - SCreateTableSQL* yy358; - tVariant yy378; - int64_t yy403; - SIntervalVal yy430; - tSQLExprList* yy522; + SCreateDbInfo yy100; + int yy116; + SIntervalVal yy126; + tSQLExprList* yy178; + SArray* yy207; + int64_t yy208; + tVariant yy232; + SLimitVal yy314; + SCreateTableSQL* yy414; + SSubclauseInfo* yy441; + tSQLExpr* yy484; + SCreateAcctInfo yy505; + TAOS_FIELD yy517; + SQuerySQL* yy526; + SCreatedTableInfo yy542; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -136,18 +136,18 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 294 -#define YYNRULE 254 -#define YYNRULE_WITH_ACTION 254 -#define YYNTOKEN 210 -#define YY_MAX_SHIFT 293 -#define YY_MIN_SHIFTREDUCE 477 -#define YY_MAX_SHIFTREDUCE 730 -#define YY_ERROR_ACTION 731 -#define YY_ACCEPT_ACTION 732 -#define YY_NO_ACTION 733 -#define YY_MIN_REDUCE 734 -#define YY_MAX_REDUCE 987 +#define YYNSTATE 306 +#define YYNRULE 263 +#define YYNRULE_WITH_ACTION 263 +#define YYNTOKEN 213 +#define YY_MAX_SHIFT 305 +#define YY_MIN_SHIFTREDUCE 494 +#define YY_MAX_SHIFTREDUCE 756 +#define YY_ERROR_ACTION 757 +#define YY_ACCEPT_ACTION 758 +#define YY_NO_ACTION 759 +#define YY_MIN_REDUCE 760 +#define YY_MAX_REDUCE 1022 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -214,252 +214,258 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (651) +#define YY_ACTTAB_COUNT (668) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 74, 521, 732, 293, 521, 165, 186, 291, 28, 522, - /* 10 */ 190, 893, 522, 43, 44, 969, 47, 48, 15, 776, - /* 20 */ 198, 37, 152, 46, 242, 51, 49, 53, 50, 854, - /* 30 */ 855, 27, 858, 42, 41, 871, 128, 40, 39, 38, - /* 40 */ 43, 44, 882, 47, 48, 882, 188, 198, 37, 868, - /* 50 */ 46, 242, 51, 49, 53, 50, 187, 128, 203, 225, - /* 60 */ 42, 41, 979, 165, 40, 39, 38, 43, 44, 890, - /* 70 */ 47, 48, 193, 970, 198, 37, 165, 46, 242, 51, - /* 80 */ 49, 53, 50, 871, 128, 192, 970, 42, 41, 258, - /* 90 */ 521, 40, 39, 38, 290, 289, 115, 239, 522, 71, - /* 100 */ 77, 43, 45, 128, 47, 48, 205, 66, 198, 37, - /* 110 */ 28, 46, 242, 51, 49, 53, 50, 40, 39, 38, - /* 120 */ 921, 42, 41, 278, 65, 40, 39, 38, 865, 678, - /* 130 */ 287, 871, 859, 210, 478, 479, 480, 481, 482, 483, - /* 140 */ 484, 485, 486, 487, 488, 489, 292, 72, 201, 215, - /* 150 */ 44, 868, 47, 48, 856, 871, 198, 37, 209, 46, - /* 160 */ 242, 51, 49, 53, 50, 869, 922, 204, 237, 42, - /* 170 */ 41, 96, 163, 40, 39, 38, 278, 21, 256, 286, - /* 180 */ 285, 255, 254, 253, 284, 252, 283, 282, 281, 251, - /* 190 */ 280, 279, 835, 594, 823, 824, 825, 826, 827, 828, - /* 200 */ 829, 830, 831, 832, 833, 834, 836, 837, 47, 48, - /* 210 */ 87, 86, 198, 37, 28, 46, 242, 51, 49, 53, - /* 220 */ 50, 268, 267, 16, 211, 42, 41, 265, 264, 40, - /* 230 */ 39, 38, 197, 691, 28, 634, 682, 207, 685, 174, - /* 240 */ 688, 22, 42, 41, 73, 175, 40, 39, 38, 34, - /* 250 */ 108, 107, 173, 197, 691, 867, 67, 682, 28, 685, - /* 260 */ 21, 688, 286, 285, 194, 195, 169, 284, 241, 283, - /* 270 */ 282, 281, 202, 280, 279, 868, 618, 28, 60, 615, - /* 280 */ 22, 616, 631, 617, 218, 194, 195, 123, 34, 23, - /* 290 */ 841, 222, 221, 839, 840, 857, 261, 61, 842, 868, - /* 300 */ 844, 845, 843, 208, 846, 847, 260, 212, 213, 224, - /* 310 */ 638, 51, 49, 53, 50, 262, 181, 28, 868, 42, - /* 320 */ 41, 94, 98, 40, 39, 38, 28, 88, 103, 106, - /* 330 */ 97, 10, 52, 3, 142, 76, 100, 138, 680, 31, - /* 340 */ 83, 79, 82, 158, 154, 690, 230, 659, 660, 156, - /* 350 */ 111, 110, 109, 52, 785, 266, 777, 152, 868, 152, - /* 360 */ 689, 626, 121, 684, 270, 687, 690, 868, 196, 227, - /* 370 */ 34, 228, 258, 646, 681, 29, 683, 125, 686, 650, - /* 380 */ 651, 689, 619, 56, 18, 711, 692, 243, 966, 17, - /* 390 */ 17, 57, 604, 245, 606, 247, 29, 29, 56, 75, - /* 400 */ 605, 63, 26, 593, 56, 248, 12, 11, 93, 92, - /* 410 */ 4, 965, 58, 14, 13, 622, 620, 623, 621, 105, - /* 420 */ 104, 120, 118, 932, 964, 182, 183, 167, 168, 170, - /* 430 */ 164, 171, 172, 178, 179, 177, 162, 176, 166, 870, - /* 440 */ 931, 199, 928, 927, 884, 200, 269, 122, 892, 35, - /* 450 */ 899, 901, 124, 139, 864, 914, 140, 141, 913, 137, - /* 460 */ 787, 250, 160, 32, 259, 34, 784, 984, 84, 983, - /* 470 */ 981, 143, 226, 119, 231, 263, 978, 90, 977, 975, - /* 480 */ 694, 144, 645, 805, 189, 235, 62, 881, 129, 33, - /* 490 */ 59, 240, 30, 54, 161, 132, 130, 238, 236, 131, - /* 500 */ 774, 99, 772, 133, 234, 134, 232, 101, 36, 102, - /* 510 */ 770, 95, 769, 271, 272, 214, 153, 767, 766, 765, - /* 520 */ 764, 763, 273, 155, 157, 760, 758, 756, 754, 752, - /* 530 */ 159, 274, 229, 68, 69, 915, 275, 276, 277, 184, - /* 540 */ 206, 249, 730, 185, 180, 288, 80, 216, 217, 768, - /* 550 */ 729, 220, 219, 112, 728, 762, 147, 761, 146, 806, - /* 560 */ 145, 148, 149, 151, 150, 113, 114, 753, 1, 716, - /* 570 */ 2, 223, 227, 628, 64, 6, 866, 244, 70, 647, - /* 580 */ 126, 135, 136, 191, 24, 233, 7, 652, 127, 8, - /* 590 */ 693, 5, 25, 9, 19, 246, 20, 695, 78, 76, - /* 600 */ 562, 558, 556, 555, 554, 551, 525, 257, 81, 85, - /* 610 */ 29, 55, 596, 595, 89, 91, 592, 546, 544, 536, - /* 620 */ 542, 538, 540, 534, 532, 564, 563, 561, 560, 559, - /* 630 */ 557, 553, 552, 56, 523, 493, 491, 734, 733, 733, - /* 640 */ 733, 733, 733, 733, 733, 733, 733, 733, 733, 116, - /* 650 */ 117, + /* 0 */ 176, 541, 176, 197, 303, 17, 135, 620, 174, 542, + /* 10 */ 1004, 204, 1005, 47, 48, 30, 51, 52, 135, 201, + /* 20 */ 209, 41, 176, 50, 253, 55, 53, 57, 54, 758, + /* 30 */ 305, 203, 1005, 46, 45, 279, 278, 44, 43, 42, + /* 40 */ 47, 48, 214, 51, 52, 906, 928, 209, 41, 541, + /* 50 */ 50, 253, 55, 53, 57, 54, 199, 542, 660, 903, + /* 60 */ 46, 45, 216, 135, 44, 43, 42, 48, 906, 51, + /* 70 */ 52, 30, 956, 209, 41, 917, 50, 253, 55, 53, + /* 80 */ 57, 54, 250, 130, 75, 289, 46, 45, 906, 236, + /* 90 */ 44, 43, 42, 495, 496, 497, 498, 499, 500, 501, + /* 100 */ 502, 503, 504, 505, 506, 507, 304, 925, 81, 226, + /* 110 */ 70, 541, 212, 47, 48, 903, 51, 52, 30, 542, + /* 120 */ 209, 41, 24, 50, 253, 55, 53, 57, 54, 957, + /* 130 */ 36, 248, 704, 46, 45, 135, 664, 44, 43, 42, + /* 140 */ 47, 49, 894, 51, 52, 241, 892, 209, 41, 229, + /* 150 */ 50, 253, 55, 53, 57, 54, 233, 232, 101, 213, + /* 160 */ 46, 45, 903, 289, 44, 43, 42, 23, 267, 298, + /* 170 */ 297, 266, 265, 264, 296, 263, 295, 294, 293, 262, + /* 180 */ 292, 291, 866, 30, 854, 855, 856, 857, 858, 859, + /* 190 */ 860, 861, 862, 863, 864, 865, 867, 868, 51, 52, + /* 200 */ 917, 76, 209, 41, 900, 50, 253, 55, 53, 57, + /* 210 */ 54, 299, 18, 180, 198, 46, 45, 30, 269, 44, + /* 220 */ 43, 42, 208, 717, 272, 269, 708, 903, 711, 185, + /* 230 */ 714, 1001, 208, 717, 69, 186, 708, 906, 711, 77, + /* 240 */ 714, 114, 113, 184, 1000, 644, 215, 221, 641, 657, + /* 250 */ 642, 71, 643, 12, 205, 206, 25, 80, 252, 145, + /* 260 */ 23, 902, 298, 297, 205, 206, 891, 296, 999, 295, + /* 270 */ 294, 293, 24, 292, 291, 874, 223, 224, 872, 873, + /* 280 */ 36, 193, 904, 875, 805, 877, 878, 876, 161, 879, + /* 290 */ 880, 55, 53, 57, 54, 67, 220, 619, 814, 46, + /* 300 */ 45, 235, 161, 44, 43, 42, 99, 104, 192, 44, + /* 310 */ 43, 42, 93, 103, 109, 112, 102, 239, 78, 254, + /* 320 */ 218, 31, 106, 5, 151, 56, 1, 149, 194, 33, + /* 330 */ 150, 88, 83, 87, 30, 56, 169, 165, 716, 128, + /* 340 */ 30, 30, 167, 164, 117, 116, 115, 36, 716, 889, + /* 350 */ 890, 29, 893, 715, 645, 806, 46, 45, 1014, 161, + /* 360 */ 44, 43, 42, 715, 222, 685, 686, 276, 275, 302, + /* 370 */ 301, 122, 3, 162, 706, 273, 672, 710, 903, 713, + /* 380 */ 132, 277, 281, 676, 903, 903, 652, 60, 219, 677, + /* 390 */ 207, 271, 737, 20, 238, 718, 19, 61, 709, 19, + /* 400 */ 712, 64, 630, 905, 256, 632, 31, 258, 31, 60, + /* 410 */ 707, 79, 631, 178, 28, 720, 60, 259, 62, 179, + /* 420 */ 65, 92, 91, 111, 110, 14, 13, 98, 97, 16, + /* 430 */ 15, 648, 181, 649, 6, 646, 175, 647, 127, 125, + /* 440 */ 182, 183, 189, 190, 967, 188, 173, 187, 966, 177, + /* 450 */ 210, 963, 962, 211, 280, 129, 919, 927, 39, 949, + /* 460 */ 948, 934, 936, 131, 146, 899, 144, 147, 148, 36, + /* 470 */ 817, 261, 37, 171, 34, 270, 813, 237, 1019, 89, + /* 480 */ 1018, 1016, 126, 152, 274, 1013, 95, 671, 242, 1012, + /* 490 */ 200, 1010, 153, 835, 246, 35, 32, 916, 38, 172, + /* 500 */ 63, 66, 802, 136, 58, 251, 137, 138, 249, 247, + /* 510 */ 105, 800, 107, 245, 108, 243, 40, 798, 139, 797, + /* 520 */ 290, 100, 225, 282, 163, 795, 283, 794, 793, 792, + /* 530 */ 791, 790, 166, 168, 787, 785, 783, 781, 779, 284, + /* 540 */ 170, 286, 240, 72, 73, 950, 285, 287, 288, 300, + /* 550 */ 756, 195, 227, 217, 260, 228, 755, 230, 196, 191, + /* 560 */ 231, 84, 85, 754, 742, 234, 796, 238, 74, 654, + /* 570 */ 673, 118, 789, 156, 119, 155, 836, 154, 157, 158, + /* 580 */ 160, 159, 120, 788, 2, 121, 780, 4, 870, 255, + /* 590 */ 8, 901, 68, 133, 202, 244, 140, 141, 142, 143, + /* 600 */ 882, 678, 134, 26, 27, 9, 10, 719, 7, 11, + /* 610 */ 721, 21, 22, 257, 82, 583, 579, 80, 577, 576, + /* 620 */ 575, 572, 545, 268, 86, 90, 31, 94, 59, 96, + /* 630 */ 622, 621, 618, 567, 565, 557, 563, 559, 561, 555, + /* 640 */ 553, 586, 585, 584, 582, 581, 580, 578, 574, 573, + /* 650 */ 60, 543, 511, 509, 760, 759, 759, 759, 759, 759, + /* 660 */ 759, 759, 759, 759, 759, 759, 123, 124, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 218, 1, 210, 211, 1, 270, 212, 213, 213, 9, - /* 10 */ 230, 213, 9, 13, 14, 280, 16, 17, 270, 217, - /* 20 */ 20, 21, 220, 23, 24, 25, 26, 27, 28, 247, - /* 30 */ 248, 249, 250, 33, 34, 255, 213, 37, 38, 39, - /* 40 */ 13, 14, 253, 16, 17, 253, 251, 20, 21, 254, - /* 50 */ 23, 24, 25, 26, 27, 28, 267, 213, 230, 267, - /* 60 */ 33, 34, 255, 270, 37, 38, 39, 13, 14, 271, - /* 70 */ 16, 17, 279, 280, 20, 21, 270, 23, 24, 25, - /* 80 */ 26, 27, 28, 255, 213, 279, 280, 33, 34, 77, - /* 90 */ 1, 37, 38, 39, 63, 64, 65, 274, 9, 276, - /* 100 */ 218, 13, 14, 213, 16, 17, 230, 107, 20, 21, - /* 110 */ 213, 23, 24, 25, 26, 27, 28, 37, 38, 39, - /* 120 */ 276, 33, 34, 79, 218, 37, 38, 39, 213, 102, - /* 130 */ 230, 255, 250, 213, 45, 46, 47, 48, 49, 50, - /* 140 */ 51, 52, 53, 54, 55, 56, 57, 276, 251, 60, - /* 150 */ 14, 254, 16, 17, 248, 255, 20, 21, 66, 23, - /* 160 */ 24, 25, 26, 27, 28, 245, 276, 252, 278, 33, - /* 170 */ 34, 74, 270, 37, 38, 39, 79, 86, 87, 88, - /* 180 */ 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, - /* 190 */ 99, 100, 229, 5, 231, 232, 233, 234, 235, 236, - /* 200 */ 237, 238, 239, 240, 241, 242, 243, 244, 16, 17, - /* 210 */ 133, 134, 20, 21, 213, 23, 24, 25, 26, 27, - /* 220 */ 28, 33, 34, 44, 132, 33, 34, 135, 136, 37, - /* 230 */ 38, 39, 1, 2, 213, 37, 5, 66, 7, 60, - /* 240 */ 9, 101, 33, 34, 256, 66, 37, 38, 39, 109, - /* 250 */ 71, 72, 73, 1, 2, 254, 268, 5, 213, 7, - /* 260 */ 86, 9, 88, 89, 33, 34, 270, 93, 37, 95, - /* 270 */ 96, 97, 251, 99, 100, 254, 2, 213, 106, 5, - /* 280 */ 101, 7, 106, 9, 131, 33, 34, 213, 109, 113, - /* 290 */ 229, 138, 139, 232, 233, 0, 251, 125, 237, 254, - /* 300 */ 239, 240, 241, 132, 243, 244, 135, 33, 34, 130, - /* 310 */ 112, 25, 26, 27, 28, 251, 137, 213, 254, 33, - /* 320 */ 34, 61, 62, 37, 38, 39, 213, 67, 68, 69, - /* 330 */ 70, 101, 101, 61, 62, 105, 76, 107, 1, 67, - /* 340 */ 68, 69, 70, 61, 62, 114, 272, 120, 121, 67, - /* 350 */ 68, 69, 70, 101, 217, 251, 217, 220, 254, 220, - /* 360 */ 129, 102, 101, 5, 251, 7, 114, 254, 59, 110, - /* 370 */ 109, 102, 77, 102, 37, 106, 5, 106, 7, 102, - /* 380 */ 102, 129, 108, 106, 106, 102, 102, 15, 270, 106, - /* 390 */ 106, 106, 102, 102, 102, 102, 106, 106, 106, 106, - /* 400 */ 102, 101, 101, 103, 106, 104, 133, 134, 133, 134, - /* 410 */ 101, 270, 127, 133, 134, 5, 5, 7, 7, 74, - /* 420 */ 75, 61, 62, 246, 270, 270, 270, 270, 270, 270, - /* 430 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 255, - /* 440 */ 246, 246, 246, 246, 253, 246, 246, 213, 213, 269, - /* 450 */ 213, 213, 213, 213, 213, 277, 213, 213, 277, 257, - /* 460 */ 213, 213, 213, 213, 213, 109, 213, 213, 213, 213, - /* 470 */ 213, 213, 253, 59, 273, 213, 213, 213, 213, 213, - /* 480 */ 108, 213, 114, 213, 273, 273, 124, 266, 265, 213, - /* 490 */ 126, 118, 213, 123, 213, 262, 264, 122, 117, 263, - /* 500 */ 213, 213, 213, 261, 116, 260, 115, 213, 128, 213, - /* 510 */ 213, 85, 213, 84, 49, 213, 213, 213, 213, 213, - /* 520 */ 213, 213, 81, 213, 213, 213, 213, 213, 213, 213, - /* 530 */ 213, 83, 214, 214, 214, 214, 53, 82, 80, 214, - /* 540 */ 214, 214, 5, 214, 214, 77, 218, 140, 5, 214, - /* 550 */ 5, 5, 140, 215, 5, 214, 222, 214, 226, 228, - /* 560 */ 227, 225, 223, 221, 224, 215, 215, 214, 219, 87, - /* 570 */ 216, 131, 110, 102, 111, 101, 253, 104, 106, 102, - /* 580 */ 101, 259, 258, 1, 106, 101, 119, 102, 101, 119, - /* 590 */ 102, 101, 106, 101, 101, 104, 101, 108, 74, 105, - /* 600 */ 9, 5, 5, 5, 5, 5, 78, 15, 74, 134, - /* 610 */ 106, 16, 5, 5, 134, 134, 102, 5, 5, 5, - /* 620 */ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - /* 630 */ 5, 5, 5, 106, 78, 59, 58, 0, 281, 281, - /* 640 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 21, - /* 650 */ 21, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 660 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 670 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 680 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 690 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 700 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 710 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 720 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 730 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 740 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 750 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 760 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 770 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 780 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 790 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 800 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 810 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 820 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 830 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 840 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 850 */ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, - /* 860 */ 281, + /* 0 */ 276, 1, 276, 215, 216, 276, 216, 5, 276, 9, + /* 10 */ 286, 285, 286, 13, 14, 216, 16, 17, 216, 235, + /* 20 */ 20, 21, 276, 23, 24, 25, 26, 27, 28, 213, + /* 30 */ 214, 285, 286, 33, 34, 33, 34, 37, 38, 39, + /* 40 */ 13, 14, 235, 16, 17, 261, 216, 20, 21, 1, + /* 50 */ 23, 24, 25, 26, 27, 28, 257, 9, 37, 260, + /* 60 */ 33, 34, 235, 216, 37, 38, 39, 14, 261, 16, + /* 70 */ 17, 216, 282, 20, 21, 259, 23, 24, 25, 26, + /* 80 */ 27, 28, 280, 216, 282, 81, 33, 34, 261, 273, + /* 90 */ 37, 38, 39, 45, 46, 47, 48, 49, 50, 51, + /* 100 */ 52, 53, 54, 55, 56, 57, 58, 277, 222, 61, + /* 110 */ 110, 1, 257, 13, 14, 260, 16, 17, 216, 9, + /* 120 */ 20, 21, 104, 23, 24, 25, 26, 27, 28, 282, + /* 130 */ 112, 284, 105, 33, 34, 216, 115, 37, 38, 39, + /* 140 */ 13, 14, 256, 16, 17, 278, 0, 20, 21, 134, + /* 150 */ 23, 24, 25, 26, 27, 28, 141, 142, 76, 257, + /* 160 */ 33, 34, 260, 81, 37, 38, 39, 88, 89, 90, + /* 170 */ 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + /* 180 */ 101, 102, 234, 216, 236, 237, 238, 239, 240, 241, + /* 190 */ 242, 243, 244, 245, 246, 247, 248, 249, 16, 17, + /* 200 */ 259, 282, 20, 21, 216, 23, 24, 25, 26, 27, + /* 210 */ 28, 235, 44, 276, 273, 33, 34, 216, 79, 37, + /* 220 */ 38, 39, 1, 2, 257, 79, 5, 260, 7, 61, + /* 230 */ 9, 276, 1, 2, 222, 67, 5, 261, 7, 262, + /* 240 */ 9, 73, 74, 75, 276, 2, 258, 216, 5, 109, + /* 250 */ 7, 274, 9, 104, 33, 34, 116, 108, 37, 110, + /* 260 */ 88, 260, 90, 91, 33, 34, 254, 95, 276, 97, + /* 270 */ 98, 99, 104, 101, 102, 234, 33, 34, 237, 238, + /* 280 */ 112, 276, 251, 242, 221, 244, 245, 246, 225, 248, + /* 290 */ 249, 25, 26, 27, 28, 104, 67, 106, 221, 33, + /* 300 */ 34, 133, 225, 37, 38, 39, 62, 63, 140, 37, + /* 310 */ 38, 39, 68, 69, 70, 71, 72, 105, 222, 15, + /* 320 */ 67, 109, 78, 62, 63, 104, 223, 224, 276, 68, + /* 330 */ 69, 70, 71, 72, 216, 104, 62, 63, 117, 104, + /* 340 */ 216, 216, 68, 69, 70, 71, 72, 112, 117, 253, + /* 350 */ 254, 255, 256, 132, 111, 221, 33, 34, 261, 225, + /* 360 */ 37, 38, 39, 132, 135, 123, 124, 138, 139, 64, + /* 370 */ 65, 66, 219, 220, 1, 257, 105, 5, 260, 7, + /* 380 */ 109, 257, 257, 105, 260, 260, 105, 109, 135, 105, + /* 390 */ 60, 138, 105, 109, 113, 105, 109, 109, 5, 109, + /* 400 */ 7, 109, 105, 261, 105, 105, 109, 105, 109, 109, + /* 410 */ 37, 109, 105, 276, 104, 111, 109, 107, 130, 276, + /* 420 */ 128, 136, 137, 76, 77, 136, 137, 136, 137, 136, + /* 430 */ 137, 5, 276, 7, 104, 5, 276, 7, 62, 63, + /* 440 */ 276, 276, 276, 276, 252, 276, 276, 276, 252, 276, + /* 450 */ 252, 252, 252, 252, 252, 216, 259, 216, 275, 283, + /* 460 */ 283, 216, 216, 216, 216, 216, 263, 216, 216, 112, + /* 470 */ 216, 216, 216, 216, 216, 216, 216, 259, 216, 216, + /* 480 */ 216, 216, 60, 216, 216, 216, 216, 117, 279, 216, + /* 490 */ 279, 216, 216, 216, 279, 216, 216, 272, 216, 216, + /* 500 */ 129, 127, 216, 271, 126, 121, 270, 269, 125, 120, + /* 510 */ 216, 216, 216, 119, 216, 118, 131, 216, 268, 216, + /* 520 */ 103, 87, 216, 86, 216, 216, 50, 216, 216, 216, + /* 530 */ 216, 216, 216, 216, 216, 216, 216, 216, 216, 83, + /* 540 */ 216, 54, 217, 217, 217, 217, 85, 84, 82, 79, + /* 550 */ 5, 217, 143, 217, 217, 5, 5, 143, 217, 217, + /* 560 */ 5, 222, 222, 5, 89, 134, 217, 113, 109, 105, + /* 570 */ 105, 218, 217, 227, 218, 231, 233, 232, 230, 228, + /* 580 */ 226, 229, 218, 217, 223, 218, 217, 219, 250, 107, + /* 590 */ 104, 259, 114, 104, 1, 104, 267, 266, 265, 264, + /* 600 */ 250, 105, 104, 109, 109, 122, 122, 105, 104, 104, + /* 610 */ 111, 104, 104, 107, 76, 9, 5, 108, 5, 5, + /* 620 */ 5, 5, 80, 15, 76, 137, 109, 137, 16, 137, + /* 630 */ 5, 5, 105, 5, 5, 5, 5, 5, 5, 5, + /* 640 */ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + /* 650 */ 109, 80, 60, 59, 0, 287, 287, 287, 287, 287, + /* 660 */ 287, 287, 287, 287, 287, 287, 21, 21, 287, 287, + /* 670 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 680 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 690 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 700 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 710 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 720 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 730 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 740 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 750 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 760 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 770 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 780 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 790 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 800 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 810 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 820 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 830 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 840 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 850 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 860 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 870 */ 287, 287, 287, 287, 287, 287, 287, 287, 287, 287, + /* 880 */ 287, }; -#define YY_SHIFT_COUNT (293) +#define YY_SHIFT_COUNT (305) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (637) +#define YY_SHIFT_MAX (654) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 179, 91, 174, 12, 231, 252, 3, 3, 3, 3, - /* 10 */ 3, 3, 3, 3, 3, 0, 89, 252, 274, 274, - /* 20 */ 274, 274, 140, 3, 3, 3, 3, 295, 3, 3, - /* 30 */ 97, 12, 44, 44, 651, 252, 252, 252, 252, 252, - /* 40 */ 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, - /* 50 */ 252, 252, 252, 252, 252, 274, 274, 188, 188, 188, - /* 60 */ 188, 188, 188, 188, 261, 3, 3, 198, 3, 3, - /* 70 */ 3, 227, 227, 176, 3, 3, 3, 3, 3, 3, - /* 80 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - /* 90 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - /* 100 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - /* 110 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - /* 120 */ 3, 356, 414, 414, 414, 368, 368, 368, 414, 362, - /* 130 */ 364, 370, 373, 375, 381, 388, 391, 380, 356, 414, - /* 140 */ 414, 414, 12, 414, 414, 426, 429, 465, 441, 448, - /* 150 */ 483, 455, 458, 414, 468, 414, 468, 414, 468, 414, - /* 160 */ 651, 651, 27, 54, 88, 54, 54, 136, 192, 286, - /* 170 */ 286, 286, 286, 260, 272, 282, 209, 209, 209, 209, - /* 180 */ 92, 153, 80, 80, 230, 171, 31, 259, 269, 271, - /* 190 */ 277, 278, 283, 284, 358, 371, 337, 309, 372, 285, - /* 200 */ 172, 290, 291, 292, 293, 298, 301, 77, 273, 275, - /* 210 */ 300, 280, 410, 411, 345, 360, 537, 407, 543, 545, - /* 220 */ 412, 546, 549, 482, 440, 462, 471, 463, 473, 474, - /* 230 */ 472, 477, 479, 582, 484, 485, 487, 478, 467, 486, - /* 240 */ 470, 488, 490, 489, 492, 473, 493, 491, 495, 494, - /* 250 */ 524, 591, 596, 597, 598, 599, 600, 528, 592, 534, - /* 260 */ 475, 504, 504, 595, 480, 481, 504, 607, 608, 514, - /* 270 */ 504, 612, 613, 614, 615, 616, 617, 618, 619, 620, - /* 280 */ 621, 622, 623, 624, 625, 626, 627, 527, 556, 628, - /* 290 */ 629, 576, 578, 637, + /* 0 */ 168, 79, 79, 172, 172, 139, 221, 231, 110, 110, + /* 10 */ 110, 110, 110, 110, 110, 110, 110, 0, 48, 231, + /* 20 */ 243, 243, 243, 243, 18, 110, 110, 110, 110, 146, + /* 30 */ 110, 110, 82, 139, 4, 4, 668, 668, 668, 231, + /* 40 */ 231, 231, 231, 231, 231, 231, 231, 231, 231, 231, + /* 50 */ 231, 231, 231, 231, 231, 231, 231, 231, 231, 243, + /* 60 */ 243, 2, 2, 2, 2, 2, 2, 2, 235, 110, + /* 70 */ 110, 21, 110, 110, 110, 242, 242, 140, 110, 110, + /* 80 */ 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, + /* 90 */ 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, + /* 100 */ 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, + /* 110 */ 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, + /* 120 */ 110, 110, 110, 110, 110, 110, 110, 110, 357, 422, + /* 130 */ 422, 422, 370, 370, 370, 422, 374, 371, 378, 384, + /* 140 */ 383, 389, 394, 397, 385, 357, 422, 422, 422, 417, + /* 150 */ 139, 139, 422, 422, 434, 437, 476, 456, 461, 487, + /* 160 */ 463, 466, 417, 422, 470, 470, 422, 470, 422, 470, + /* 170 */ 422, 668, 668, 27, 100, 127, 100, 100, 53, 182, + /* 180 */ 266, 266, 266, 266, 244, 261, 274, 323, 323, 323, + /* 190 */ 323, 229, 15, 272, 272, 149, 253, 305, 281, 212, + /* 200 */ 271, 278, 284, 287, 290, 372, 393, 373, 330, 304, + /* 210 */ 288, 292, 297, 299, 300, 302, 307, 310, 285, 289, + /* 220 */ 291, 191, 293, 426, 430, 347, 376, 545, 409, 550, + /* 230 */ 551, 414, 555, 558, 475, 431, 454, 464, 478, 482, + /* 240 */ 486, 459, 465, 489, 593, 491, 496, 498, 494, 483, + /* 250 */ 495, 484, 502, 504, 499, 505, 482, 507, 506, 508, + /* 260 */ 509, 538, 606, 611, 613, 614, 615, 616, 542, 608, + /* 270 */ 548, 488, 517, 517, 612, 490, 492, 517, 625, 626, + /* 280 */ 527, 517, 628, 629, 630, 631, 632, 633, 634, 635, + /* 290 */ 636, 637, 638, 639, 640, 641, 642, 643, 644, 541, + /* 300 */ 571, 645, 646, 592, 594, 654, }; -#define YY_REDUCE_COUNT (161) -#define YY_REDUCE_MIN (-265) -#define YY_REDUCE_MAX (354) +#define YY_REDUCE_COUNT (172) +#define YY_REDUCE_MIN (-276) +#define YY_REDUCE_MAX (369) static const short yy_reduce_ofst[] = { - /* 0 */ -208, -37, 61, -218, -207, -194, -205, -110, -177, -103, - /* 10 */ 21, 45, 64, 104, 113, -202, -206, -265, -220, -172, - /* 20 */ -124, -100, -211, 74, -156, -129, -85, -118, -80, 1, - /* 30 */ -198, -94, 137, 139, -12, -252, -98, -4, 118, 141, - /* 40 */ 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - /* 50 */ 164, 165, 166, 167, 168, -193, 184, 177, 194, 195, - /* 60 */ 196, 197, 199, 200, 191, 234, 235, 180, 237, 238, - /* 70 */ 239, 178, 181, 202, 240, 241, 243, 244, 247, 248, - /* 80 */ 249, 250, 251, 253, 254, 255, 256, 257, 258, 262, - /* 90 */ 263, 264, 265, 266, 268, 270, 276, 279, 281, 287, - /* 100 */ 288, 289, 294, 296, 297, 299, 302, 303, 304, 305, - /* 110 */ 306, 307, 308, 310, 311, 312, 313, 314, 315, 316, - /* 120 */ 317, 219, 318, 319, 320, 201, 211, 212, 321, 221, - /* 130 */ 223, 232, 236, 233, 242, 245, 322, 324, 323, 325, - /* 140 */ 326, 327, 328, 329, 330, 331, 333, 332, 334, 336, - /* 150 */ 339, 340, 342, 335, 338, 341, 350, 343, 351, 353, - /* 160 */ 349, 354, + /* 0 */ -184, -52, -52, 41, 41, 96, -274, -254, -201, -153, + /* 10 */ -198, -145, -98, -33, 118, 124, 125, -170, -212, -276, + /* 20 */ -216, -193, -173, -24, -59, -133, -210, -81, -12, -114, + /* 30 */ 31, 1, 63, 12, 77, 134, -23, 103, 153, -271, + /* 40 */ -268, -63, -45, -32, -8, 5, 52, 137, 143, 156, + /* 50 */ 160, 164, 165, 166, 167, 169, 170, 171, 173, 97, + /* 60 */ 142, 192, 196, 198, 199, 200, 201, 202, 197, 239, + /* 70 */ 241, 183, 245, 246, 247, 176, 177, 203, 248, 249, + /* 80 */ 251, 252, 254, 255, 256, 257, 258, 259, 260, 262, + /* 90 */ 263, 264, 265, 267, 268, 269, 270, 273, 275, 276, + /* 100 */ 277, 279, 280, 282, 283, 286, 294, 295, 296, 298, + /* 110 */ 301, 303, 306, 308, 309, 311, 312, 313, 314, 315, + /* 120 */ 316, 317, 318, 319, 320, 321, 322, 324, 218, 325, + /* 130 */ 326, 327, 209, 211, 215, 328, 225, 232, 236, 238, + /* 140 */ 250, 329, 331, 333, 335, 332, 334, 336, 337, 338, + /* 150 */ 339, 340, 341, 342, 343, 345, 344, 346, 348, 351, + /* 160 */ 352, 354, 350, 349, 353, 356, 355, 364, 366, 367, + /* 170 */ 369, 361, 368, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 731, 786, 775, 783, 972, 972, 731, 731, 731, 731, - /* 10 */ 731, 731, 731, 731, 731, 894, 749, 972, 731, 731, - /* 20 */ 731, 731, 731, 731, 731, 731, 731, 783, 731, 731, - /* 30 */ 788, 783, 788, 788, 889, 731, 731, 731, 731, 731, - /* 40 */ 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, - /* 50 */ 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, - /* 60 */ 731, 731, 731, 731, 731, 731, 731, 896, 898, 900, - /* 70 */ 731, 918, 918, 887, 731, 731, 731, 731, 731, 731, - /* 80 */ 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, - /* 90 */ 731, 731, 731, 731, 731, 731, 731, 731, 731, 773, - /* 100 */ 731, 771, 731, 731, 731, 731, 731, 731, 731, 731, - /* 110 */ 731, 731, 731, 731, 731, 759, 731, 731, 731, 731, - /* 120 */ 731, 731, 751, 751, 751, 731, 731, 731, 751, 925, - /* 130 */ 929, 923, 911, 919, 910, 906, 905, 933, 731, 751, - /* 140 */ 751, 751, 783, 751, 751, 804, 802, 800, 792, 798, - /* 150 */ 794, 796, 790, 751, 781, 751, 781, 751, 781, 751, - /* 160 */ 822, 838, 731, 934, 731, 971, 924, 961, 960, 967, - /* 170 */ 959, 958, 957, 731, 731, 731, 953, 954, 956, 955, - /* 180 */ 731, 731, 963, 962, 731, 731, 731, 731, 731, 731, - /* 190 */ 731, 731, 731, 731, 731, 731, 731, 936, 731, 930, - /* 200 */ 926, 731, 731, 731, 731, 731, 731, 731, 731, 731, - /* 210 */ 848, 731, 731, 731, 731, 731, 731, 731, 731, 731, - /* 220 */ 731, 731, 731, 731, 731, 886, 731, 731, 731, 731, - /* 230 */ 897, 731, 731, 731, 731, 731, 731, 920, 731, 912, - /* 240 */ 731, 731, 731, 731, 731, 860, 731, 731, 731, 731, - /* 250 */ 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, - /* 260 */ 731, 982, 980, 731, 731, 731, 976, 731, 731, 731, - /* 270 */ 974, 731, 731, 731, 731, 731, 731, 731, 731, 731, - /* 280 */ 731, 731, 731, 731, 731, 731, 731, 807, 731, 757, - /* 290 */ 755, 731, 747, 731, + /* 0 */ 757, 869, 815, 881, 803, 812, 1007, 1007, 757, 757, + /* 10 */ 757, 757, 757, 757, 757, 757, 757, 929, 776, 1007, + /* 20 */ 757, 757, 757, 757, 757, 757, 757, 757, 757, 812, + /* 30 */ 757, 757, 818, 812, 818, 818, 924, 853, 871, 757, + /* 40 */ 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + /* 50 */ 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + /* 60 */ 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + /* 70 */ 757, 931, 933, 935, 757, 953, 953, 922, 757, 757, + /* 80 */ 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + /* 90 */ 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + /* 100 */ 757, 757, 757, 757, 757, 801, 757, 799, 757, 757, + /* 110 */ 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + /* 120 */ 757, 757, 786, 757, 757, 757, 757, 757, 757, 778, + /* 130 */ 778, 778, 757, 757, 757, 778, 960, 964, 958, 946, + /* 140 */ 954, 945, 941, 940, 968, 757, 778, 778, 778, 816, + /* 150 */ 812, 812, 778, 778, 834, 832, 830, 822, 828, 824, + /* 160 */ 826, 820, 804, 778, 810, 810, 778, 810, 778, 810, + /* 170 */ 778, 853, 871, 757, 969, 757, 1006, 959, 996, 995, + /* 180 */ 1002, 994, 993, 992, 757, 757, 757, 988, 989, 991, + /* 190 */ 990, 757, 757, 998, 997, 757, 757, 757, 757, 757, + /* 200 */ 757, 757, 757, 757, 757, 757, 757, 757, 971, 757, + /* 210 */ 965, 961, 757, 757, 757, 757, 757, 757, 757, 757, + /* 220 */ 757, 883, 757, 757, 757, 757, 757, 757, 757, 757, + /* 230 */ 757, 757, 757, 757, 757, 757, 921, 757, 757, 757, + /* 240 */ 757, 932, 757, 757, 757, 757, 757, 757, 955, 757, + /* 250 */ 947, 757, 757, 757, 757, 757, 895, 757, 757, 757, + /* 260 */ 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + /* 270 */ 757, 757, 1017, 1015, 757, 757, 757, 1011, 757, 757, + /* 280 */ 757, 1009, 757, 757, 757, 757, 757, 757, 757, 757, + /* 290 */ 757, 757, 757, 757, 757, 757, 757, 757, 757, 837, + /* 300 */ 757, 784, 782, 757, 774, 757, }; /********** End of lemon-generated parsing tables *****************************/ @@ -525,6 +531,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* BITNOT => nothing */ 0, /* SHOW => nothing */ 0, /* DATABASES => nothing */ + 0, /* TOPICS => nothing */ 0, /* MNODES => nothing */ 0, /* DNODES => nothing */ 0, /* ACCOUNTS => nothing */ @@ -547,6 +554,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* VGROUPS => nothing */ 0, /* DROP => nothing */ 1, /* STABLE => ID */ + 0, /* TOPIC => nothing */ 0, /* DNODE => nothing */ 0, /* USER => nothing */ 0, /* ACCOUNT => nothing */ @@ -580,6 +588,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* PRECISION => nothing */ 0, /* UPDATE => nothing */ 0, /* CACHELAST => nothing */ + 0, /* PARTITIONS => nothing */ 0, /* LP => nothing */ 0, /* RP => nothing */ 0, /* UNSIGNED => nothing */ @@ -822,241 +831,247 @@ static const char *const yyTokenName[] = { /* 43 */ "BITNOT", /* 44 */ "SHOW", /* 45 */ "DATABASES", - /* 46 */ "MNODES", - /* 47 */ "DNODES", - /* 48 */ "ACCOUNTS", - /* 49 */ "USERS", - /* 50 */ "MODULES", - /* 51 */ "QUERIES", - /* 52 */ "CONNECTIONS", - /* 53 */ "STREAMS", - /* 54 */ "VARIABLES", - /* 55 */ "SCORES", - /* 56 */ "GRANTS", - /* 57 */ "VNODES", - /* 58 */ "IPTOKEN", - /* 59 */ "DOT", - /* 60 */ "CREATE", - /* 61 */ "TABLE", - /* 62 */ "DATABASE", - /* 63 */ "TABLES", - /* 64 */ "STABLES", - /* 65 */ "VGROUPS", - /* 66 */ "DROP", - /* 67 */ "STABLE", - /* 68 */ "DNODE", - /* 69 */ "USER", - /* 70 */ "ACCOUNT", - /* 71 */ "USE", - /* 72 */ "DESCRIBE", - /* 73 */ "ALTER", - /* 74 */ "PASS", - /* 75 */ "PRIVILEGE", - /* 76 */ "LOCAL", - /* 77 */ "IF", - /* 78 */ "EXISTS", - /* 79 */ "PPS", - /* 80 */ "TSERIES", - /* 81 */ "DBS", - /* 82 */ "STORAGE", - /* 83 */ "QTIME", - /* 84 */ "CONNS", - /* 85 */ "STATE", - /* 86 */ "KEEP", - /* 87 */ "CACHE", - /* 88 */ "REPLICA", - /* 89 */ "QUORUM", - /* 90 */ "DAYS", - /* 91 */ "MINROWS", - /* 92 */ "MAXROWS", - /* 93 */ "BLOCKS", - /* 94 */ "CTIME", - /* 95 */ "WAL", - /* 96 */ "FSYNC", - /* 97 */ "COMP", - /* 98 */ "PRECISION", - /* 99 */ "UPDATE", - /* 100 */ "CACHELAST", - /* 101 */ "LP", - /* 102 */ "RP", - /* 103 */ "UNSIGNED", - /* 104 */ "TAGS", - /* 105 */ "USING", - /* 106 */ "COMMA", - /* 107 */ "AS", - /* 108 */ "NULL", - /* 109 */ "SELECT", - /* 110 */ "UNION", - /* 111 */ "ALL", - /* 112 */ "DISTINCT", - /* 113 */ "FROM", - /* 114 */ "VARIABLE", - /* 115 */ "INTERVAL", - /* 116 */ "FILL", - /* 117 */ "SLIDING", - /* 118 */ "ORDER", - /* 119 */ "BY", - /* 120 */ "ASC", - /* 121 */ "DESC", - /* 122 */ "GROUP", - /* 123 */ "HAVING", - /* 124 */ "LIMIT", - /* 125 */ "OFFSET", - /* 126 */ "SLIMIT", - /* 127 */ "SOFFSET", - /* 128 */ "WHERE", - /* 129 */ "NOW", - /* 130 */ "RESET", - /* 131 */ "QUERY", - /* 132 */ "ADD", - /* 133 */ "COLUMN", - /* 134 */ "TAG", - /* 135 */ "CHANGE", - /* 136 */ "SET", - /* 137 */ "KILL", - /* 138 */ "CONNECTION", - /* 139 */ "STREAM", - /* 140 */ "COLON", - /* 141 */ "ABORT", - /* 142 */ "AFTER", - /* 143 */ "ATTACH", - /* 144 */ "BEFORE", - /* 145 */ "BEGIN", - /* 146 */ "CASCADE", - /* 147 */ "CLUSTER", - /* 148 */ "CONFLICT", - /* 149 */ "COPY", - /* 150 */ "DEFERRED", - /* 151 */ "DELIMITERS", - /* 152 */ "DETACH", - /* 153 */ "EACH", - /* 154 */ "END", - /* 155 */ "EXPLAIN", - /* 156 */ "FAIL", - /* 157 */ "FOR", - /* 158 */ "IGNORE", - /* 159 */ "IMMEDIATE", - /* 160 */ "INITIALLY", - /* 161 */ "INSTEAD", - /* 162 */ "MATCH", - /* 163 */ "KEY", - /* 164 */ "OF", - /* 165 */ "RAISE", - /* 166 */ "REPLACE", - /* 167 */ "RESTRICT", - /* 168 */ "ROW", - /* 169 */ "STATEMENT", - /* 170 */ "TRIGGER", - /* 171 */ "VIEW", - /* 172 */ "COUNT", - /* 173 */ "SUM", - /* 174 */ "AVG", - /* 175 */ "MIN", - /* 176 */ "MAX", - /* 177 */ "FIRST", - /* 178 */ "LAST", - /* 179 */ "TOP", - /* 180 */ "BOTTOM", - /* 181 */ "STDDEV", - /* 182 */ "PERCENTILE", - /* 183 */ "APERCENTILE", - /* 184 */ "LEASTSQUARES", - /* 185 */ "HISTOGRAM", - /* 186 */ "DIFF", - /* 187 */ "SPREAD", - /* 188 */ "TWA", - /* 189 */ "INTERP", - /* 190 */ "LAST_ROW", - /* 191 */ "RATE", - /* 192 */ "IRATE", - /* 193 */ "SUM_RATE", - /* 194 */ "SUM_IRATE", - /* 195 */ "AVG_RATE", - /* 196 */ "AVG_IRATE", - /* 197 */ "TBID", - /* 198 */ "SEMI", - /* 199 */ "NONE", - /* 200 */ "PREV", - /* 201 */ "LINEAR", - /* 202 */ "IMPORT", - /* 203 */ "METRIC", - /* 204 */ "TBNAME", - /* 205 */ "JOIN", - /* 206 */ "METRICS", - /* 207 */ "INSERT", - /* 208 */ "INTO", - /* 209 */ "VALUES", - /* 210 */ "program", - /* 211 */ "cmd", - /* 212 */ "dbPrefix", - /* 213 */ "ids", - /* 214 */ "cpxName", - /* 215 */ "ifexists", - /* 216 */ "alter_db_optr", - /* 217 */ "acct_optr", - /* 218 */ "ifnotexists", - /* 219 */ "db_optr", - /* 220 */ "pps", - /* 221 */ "tseries", - /* 222 */ "dbs", - /* 223 */ "streams", - /* 224 */ "storage", - /* 225 */ "qtime", - /* 226 */ "users", - /* 227 */ "conns", - /* 228 */ "state", - /* 229 */ "keep", - /* 230 */ "tagitemlist", - /* 231 */ "cache", - /* 232 */ "replica", - /* 233 */ "quorum", - /* 234 */ "days", - /* 235 */ "minrows", - /* 236 */ "maxrows", - /* 237 */ "blocks", - /* 238 */ "ctime", - /* 239 */ "wal", - /* 240 */ "fsync", - /* 241 */ "comp", - /* 242 */ "prec", - /* 243 */ "update", - /* 244 */ "cachelast", - /* 245 */ "typename", - /* 246 */ "signed", - /* 247 */ "create_table_args", - /* 248 */ "create_stable_args", - /* 249 */ "create_table_list", - /* 250 */ "create_from_stable", - /* 251 */ "columnlist", - /* 252 */ "tagNamelist", - /* 253 */ "select", - /* 254 */ "column", - /* 255 */ "tagitem", - /* 256 */ "selcollist", - /* 257 */ "from", - /* 258 */ "where_opt", - /* 259 */ "interval_opt", - /* 260 */ "fill_opt", - /* 261 */ "sliding_opt", - /* 262 */ "groupby_opt", - /* 263 */ "orderby_opt", - /* 264 */ "having_opt", - /* 265 */ "slimit_opt", - /* 266 */ "limit_opt", - /* 267 */ "union", - /* 268 */ "sclp", - /* 269 */ "distinct", - /* 270 */ "expr", - /* 271 */ "as", - /* 272 */ "tablelist", - /* 273 */ "tmvar", - /* 274 */ "sortlist", - /* 275 */ "sortitem", - /* 276 */ "item", - /* 277 */ "sortorder", - /* 278 */ "grouplist", - /* 279 */ "exprlist", - /* 280 */ "expritem", + /* 46 */ "TOPICS", + /* 47 */ "MNODES", + /* 48 */ "DNODES", + /* 49 */ "ACCOUNTS", + /* 50 */ "USERS", + /* 51 */ "MODULES", + /* 52 */ "QUERIES", + /* 53 */ "CONNECTIONS", + /* 54 */ "STREAMS", + /* 55 */ "VARIABLES", + /* 56 */ "SCORES", + /* 57 */ "GRANTS", + /* 58 */ "VNODES", + /* 59 */ "IPTOKEN", + /* 60 */ "DOT", + /* 61 */ "CREATE", + /* 62 */ "TABLE", + /* 63 */ "DATABASE", + /* 64 */ "TABLES", + /* 65 */ "STABLES", + /* 66 */ "VGROUPS", + /* 67 */ "DROP", + /* 68 */ "STABLE", + /* 69 */ "TOPIC", + /* 70 */ "DNODE", + /* 71 */ "USER", + /* 72 */ "ACCOUNT", + /* 73 */ "USE", + /* 74 */ "DESCRIBE", + /* 75 */ "ALTER", + /* 76 */ "PASS", + /* 77 */ "PRIVILEGE", + /* 78 */ "LOCAL", + /* 79 */ "IF", + /* 80 */ "EXISTS", + /* 81 */ "PPS", + /* 82 */ "TSERIES", + /* 83 */ "DBS", + /* 84 */ "STORAGE", + /* 85 */ "QTIME", + /* 86 */ "CONNS", + /* 87 */ "STATE", + /* 88 */ "KEEP", + /* 89 */ "CACHE", + /* 90 */ "REPLICA", + /* 91 */ "QUORUM", + /* 92 */ "DAYS", + /* 93 */ "MINROWS", + /* 94 */ "MAXROWS", + /* 95 */ "BLOCKS", + /* 96 */ "CTIME", + /* 97 */ "WAL", + /* 98 */ "FSYNC", + /* 99 */ "COMP", + /* 100 */ "PRECISION", + /* 101 */ "UPDATE", + /* 102 */ "CACHELAST", + /* 103 */ "PARTITIONS", + /* 104 */ "LP", + /* 105 */ "RP", + /* 106 */ "UNSIGNED", + /* 107 */ "TAGS", + /* 108 */ "USING", + /* 109 */ "COMMA", + /* 110 */ "AS", + /* 111 */ "NULL", + /* 112 */ "SELECT", + /* 113 */ "UNION", + /* 114 */ "ALL", + /* 115 */ "DISTINCT", + /* 116 */ "FROM", + /* 117 */ "VARIABLE", + /* 118 */ "INTERVAL", + /* 119 */ "FILL", + /* 120 */ "SLIDING", + /* 121 */ "ORDER", + /* 122 */ "BY", + /* 123 */ "ASC", + /* 124 */ "DESC", + /* 125 */ "GROUP", + /* 126 */ "HAVING", + /* 127 */ "LIMIT", + /* 128 */ "OFFSET", + /* 129 */ "SLIMIT", + /* 130 */ "SOFFSET", + /* 131 */ "WHERE", + /* 132 */ "NOW", + /* 133 */ "RESET", + /* 134 */ "QUERY", + /* 135 */ "ADD", + /* 136 */ "COLUMN", + /* 137 */ "TAG", + /* 138 */ "CHANGE", + /* 139 */ "SET", + /* 140 */ "KILL", + /* 141 */ "CONNECTION", + /* 142 */ "STREAM", + /* 143 */ "COLON", + /* 144 */ "ABORT", + /* 145 */ "AFTER", + /* 146 */ "ATTACH", + /* 147 */ "BEFORE", + /* 148 */ "BEGIN", + /* 149 */ "CASCADE", + /* 150 */ "CLUSTER", + /* 151 */ "CONFLICT", + /* 152 */ "COPY", + /* 153 */ "DEFERRED", + /* 154 */ "DELIMITERS", + /* 155 */ "DETACH", + /* 156 */ "EACH", + /* 157 */ "END", + /* 158 */ "EXPLAIN", + /* 159 */ "FAIL", + /* 160 */ "FOR", + /* 161 */ "IGNORE", + /* 162 */ "IMMEDIATE", + /* 163 */ "INITIALLY", + /* 164 */ "INSTEAD", + /* 165 */ "MATCH", + /* 166 */ "KEY", + /* 167 */ "OF", + /* 168 */ "RAISE", + /* 169 */ "REPLACE", + /* 170 */ "RESTRICT", + /* 171 */ "ROW", + /* 172 */ "STATEMENT", + /* 173 */ "TRIGGER", + /* 174 */ "VIEW", + /* 175 */ "COUNT", + /* 176 */ "SUM", + /* 177 */ "AVG", + /* 178 */ "MIN", + /* 179 */ "MAX", + /* 180 */ "FIRST", + /* 181 */ "LAST", + /* 182 */ "TOP", + /* 183 */ "BOTTOM", + /* 184 */ "STDDEV", + /* 185 */ "PERCENTILE", + /* 186 */ "APERCENTILE", + /* 187 */ "LEASTSQUARES", + /* 188 */ "HISTOGRAM", + /* 189 */ "DIFF", + /* 190 */ "SPREAD", + /* 191 */ "TWA", + /* 192 */ "INTERP", + /* 193 */ "LAST_ROW", + /* 194 */ "RATE", + /* 195 */ "IRATE", + /* 196 */ "SUM_RATE", + /* 197 */ "SUM_IRATE", + /* 198 */ "AVG_RATE", + /* 199 */ "AVG_IRATE", + /* 200 */ "TBID", + /* 201 */ "SEMI", + /* 202 */ "NONE", + /* 203 */ "PREV", + /* 204 */ "LINEAR", + /* 205 */ "IMPORT", + /* 206 */ "METRIC", + /* 207 */ "TBNAME", + /* 208 */ "JOIN", + /* 209 */ "METRICS", + /* 210 */ "INSERT", + /* 211 */ "INTO", + /* 212 */ "VALUES", + /* 213 */ "program", + /* 214 */ "cmd", + /* 215 */ "dbPrefix", + /* 216 */ "ids", + /* 217 */ "cpxName", + /* 218 */ "ifexists", + /* 219 */ "alter_db_optr", + /* 220 */ "alter_topic_optr", + /* 221 */ "acct_optr", + /* 222 */ "ifnotexists", + /* 223 */ "db_optr", + /* 224 */ "topic_optr", + /* 225 */ "pps", + /* 226 */ "tseries", + /* 227 */ "dbs", + /* 228 */ "streams", + /* 229 */ "storage", + /* 230 */ "qtime", + /* 231 */ "users", + /* 232 */ "conns", + /* 233 */ "state", + /* 234 */ "keep", + /* 235 */ "tagitemlist", + /* 236 */ "cache", + /* 237 */ "replica", + /* 238 */ "quorum", + /* 239 */ "days", + /* 240 */ "minrows", + /* 241 */ "maxrows", + /* 242 */ "blocks", + /* 243 */ "ctime", + /* 244 */ "wal", + /* 245 */ "fsync", + /* 246 */ "comp", + /* 247 */ "prec", + /* 248 */ "update", + /* 249 */ "cachelast", + /* 250 */ "partitions", + /* 251 */ "typename", + /* 252 */ "signed", + /* 253 */ "create_table_args", + /* 254 */ "create_stable_args", + /* 255 */ "create_table_list", + /* 256 */ "create_from_stable", + /* 257 */ "columnlist", + /* 258 */ "tagNamelist", + /* 259 */ "select", + /* 260 */ "column", + /* 261 */ "tagitem", + /* 262 */ "selcollist", + /* 263 */ "from", + /* 264 */ "where_opt", + /* 265 */ "interval_opt", + /* 266 */ "fill_opt", + /* 267 */ "sliding_opt", + /* 268 */ "groupby_opt", + /* 269 */ "orderby_opt", + /* 270 */ "having_opt", + /* 271 */ "slimit_opt", + /* 272 */ "limit_opt", + /* 273 */ "union", + /* 274 */ "sclp", + /* 275 */ "distinct", + /* 276 */ "expr", + /* 277 */ "as", + /* 278 */ "tablelist", + /* 279 */ "tmvar", + /* 280 */ "sortlist", + /* 281 */ "sortitem", + /* 282 */ "item", + /* 283 */ "sortorder", + /* 284 */ "grouplist", + /* 285 */ "exprlist", + /* 286 */ "expritem", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -1066,258 +1081,267 @@ static const char *const yyTokenName[] = { static const char *const yyRuleName[] = { /* 0 */ "program ::= cmd", /* 1 */ "cmd ::= SHOW DATABASES", - /* 2 */ "cmd ::= SHOW MNODES", - /* 3 */ "cmd ::= SHOW DNODES", - /* 4 */ "cmd ::= SHOW ACCOUNTS", - /* 5 */ "cmd ::= SHOW USERS", - /* 6 */ "cmd ::= SHOW MODULES", - /* 7 */ "cmd ::= SHOW QUERIES", - /* 8 */ "cmd ::= SHOW CONNECTIONS", - /* 9 */ "cmd ::= SHOW STREAMS", - /* 10 */ "cmd ::= SHOW VARIABLES", - /* 11 */ "cmd ::= SHOW SCORES", - /* 12 */ "cmd ::= SHOW GRANTS", - /* 13 */ "cmd ::= SHOW VNODES", - /* 14 */ "cmd ::= SHOW VNODES IPTOKEN", - /* 15 */ "dbPrefix ::=", - /* 16 */ "dbPrefix ::= ids DOT", - /* 17 */ "cpxName ::=", - /* 18 */ "cpxName ::= DOT ids", - /* 19 */ "cmd ::= SHOW CREATE TABLE ids cpxName", - /* 20 */ "cmd ::= SHOW CREATE DATABASE ids", - /* 21 */ "cmd ::= SHOW dbPrefix TABLES", - /* 22 */ "cmd ::= SHOW dbPrefix TABLES LIKE ids", - /* 23 */ "cmd ::= SHOW dbPrefix STABLES", - /* 24 */ "cmd ::= SHOW dbPrefix STABLES LIKE ids", - /* 25 */ "cmd ::= SHOW dbPrefix VGROUPS", - /* 26 */ "cmd ::= SHOW dbPrefix VGROUPS ids", - /* 27 */ "cmd ::= DROP TABLE ifexists ids cpxName", - /* 28 */ "cmd ::= DROP STABLE ifexists ids cpxName", - /* 29 */ "cmd ::= DROP DATABASE ifexists ids", - /* 30 */ "cmd ::= DROP DNODE ids", - /* 31 */ "cmd ::= DROP USER ids", - /* 32 */ "cmd ::= DROP ACCOUNT ids", - /* 33 */ "cmd ::= USE ids", - /* 34 */ "cmd ::= DESCRIBE ids cpxName", - /* 35 */ "cmd ::= ALTER USER ids PASS ids", - /* 36 */ "cmd ::= ALTER USER ids PRIVILEGE ids", - /* 37 */ "cmd ::= ALTER DNODE ids ids", - /* 38 */ "cmd ::= ALTER DNODE ids ids ids", - /* 39 */ "cmd ::= ALTER LOCAL ids", - /* 40 */ "cmd ::= ALTER LOCAL ids ids", - /* 41 */ "cmd ::= ALTER DATABASE ids alter_db_optr", - /* 42 */ "cmd ::= ALTER ACCOUNT ids acct_optr", - /* 43 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr", - /* 44 */ "ids ::= ID", - /* 45 */ "ids ::= STRING", - /* 46 */ "ifexists ::= IF EXISTS", - /* 47 */ "ifexists ::=", - /* 48 */ "ifnotexists ::= IF NOT EXISTS", - /* 49 */ "ifnotexists ::=", - /* 50 */ "cmd ::= CREATE DNODE ids", - /* 51 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr", - /* 52 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr", - /* 53 */ "cmd ::= CREATE USER ids PASS ids", - /* 54 */ "pps ::=", - /* 55 */ "pps ::= PPS INTEGER", - /* 56 */ "tseries ::=", - /* 57 */ "tseries ::= TSERIES INTEGER", - /* 58 */ "dbs ::=", - /* 59 */ "dbs ::= DBS INTEGER", - /* 60 */ "streams ::=", - /* 61 */ "streams ::= STREAMS INTEGER", - /* 62 */ "storage ::=", - /* 63 */ "storage ::= STORAGE INTEGER", - /* 64 */ "qtime ::=", - /* 65 */ "qtime ::= QTIME INTEGER", - /* 66 */ "users ::=", - /* 67 */ "users ::= USERS INTEGER", - /* 68 */ "conns ::=", - /* 69 */ "conns ::= CONNS INTEGER", - /* 70 */ "state ::=", - /* 71 */ "state ::= STATE ids", - /* 72 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state", - /* 73 */ "keep ::= KEEP tagitemlist", - /* 74 */ "cache ::= CACHE INTEGER", - /* 75 */ "replica ::= REPLICA INTEGER", - /* 76 */ "quorum ::= QUORUM INTEGER", - /* 77 */ "days ::= DAYS INTEGER", - /* 78 */ "minrows ::= MINROWS INTEGER", - /* 79 */ "maxrows ::= MAXROWS INTEGER", - /* 80 */ "blocks ::= BLOCKS INTEGER", - /* 81 */ "ctime ::= CTIME INTEGER", - /* 82 */ "wal ::= WAL INTEGER", - /* 83 */ "fsync ::= FSYNC INTEGER", - /* 84 */ "comp ::= COMP INTEGER", - /* 85 */ "prec ::= PRECISION STRING", - /* 86 */ "update ::= UPDATE INTEGER", - /* 87 */ "cachelast ::= CACHELAST INTEGER", - /* 88 */ "db_optr ::=", - /* 89 */ "db_optr ::= db_optr cache", - /* 90 */ "db_optr ::= db_optr replica", - /* 91 */ "db_optr ::= db_optr quorum", - /* 92 */ "db_optr ::= db_optr days", - /* 93 */ "db_optr ::= db_optr minrows", - /* 94 */ "db_optr ::= db_optr maxrows", - /* 95 */ "db_optr ::= db_optr blocks", - /* 96 */ "db_optr ::= db_optr ctime", - /* 97 */ "db_optr ::= db_optr wal", - /* 98 */ "db_optr ::= db_optr fsync", - /* 99 */ "db_optr ::= db_optr comp", - /* 100 */ "db_optr ::= db_optr prec", - /* 101 */ "db_optr ::= db_optr keep", - /* 102 */ "db_optr ::= db_optr update", - /* 103 */ "db_optr ::= db_optr cachelast", - /* 104 */ "alter_db_optr ::=", - /* 105 */ "alter_db_optr ::= alter_db_optr replica", - /* 106 */ "alter_db_optr ::= alter_db_optr quorum", - /* 107 */ "alter_db_optr ::= alter_db_optr keep", - /* 108 */ "alter_db_optr ::= alter_db_optr blocks", - /* 109 */ "alter_db_optr ::= alter_db_optr comp", - /* 110 */ "alter_db_optr ::= alter_db_optr wal", - /* 111 */ "alter_db_optr ::= alter_db_optr fsync", - /* 112 */ "alter_db_optr ::= alter_db_optr update", - /* 113 */ "alter_db_optr ::= alter_db_optr cachelast", - /* 114 */ "typename ::= ids", - /* 115 */ "typename ::= ids LP signed RP", - /* 116 */ "typename ::= ids UNSIGNED", - /* 117 */ "signed ::= INTEGER", - /* 118 */ "signed ::= PLUS INTEGER", - /* 119 */ "signed ::= MINUS INTEGER", - /* 120 */ "cmd ::= CREATE TABLE create_table_args", - /* 121 */ "cmd ::= CREATE TABLE create_stable_args", - /* 122 */ "cmd ::= CREATE STABLE create_stable_args", - /* 123 */ "cmd ::= CREATE TABLE create_table_list", - /* 124 */ "create_table_list ::= create_from_stable", - /* 125 */ "create_table_list ::= create_table_list create_from_stable", - /* 126 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP", - /* 127 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP", - /* 128 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP", - /* 129 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP", - /* 130 */ "tagNamelist ::= tagNamelist COMMA ids", - /* 131 */ "tagNamelist ::= ids", - /* 132 */ "create_table_args ::= ifnotexists ids cpxName AS select", - /* 133 */ "columnlist ::= columnlist COMMA column", - /* 134 */ "columnlist ::= column", - /* 135 */ "column ::= ids typename", - /* 136 */ "tagitemlist ::= tagitemlist COMMA tagitem", - /* 137 */ "tagitemlist ::= tagitem", - /* 138 */ "tagitem ::= INTEGER", - /* 139 */ "tagitem ::= FLOAT", - /* 140 */ "tagitem ::= STRING", - /* 141 */ "tagitem ::= BOOL", - /* 142 */ "tagitem ::= NULL", - /* 143 */ "tagitem ::= MINUS INTEGER", - /* 144 */ "tagitem ::= MINUS FLOAT", - /* 145 */ "tagitem ::= PLUS INTEGER", - /* 146 */ "tagitem ::= PLUS FLOAT", - /* 147 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt", - /* 148 */ "union ::= select", - /* 149 */ "union ::= LP union RP", - /* 150 */ "union ::= union UNION ALL select", - /* 151 */ "union ::= union UNION ALL LP select RP", - /* 152 */ "cmd ::= union", - /* 153 */ "select ::= SELECT selcollist", - /* 154 */ "sclp ::= selcollist COMMA", - /* 155 */ "sclp ::=", - /* 156 */ "selcollist ::= sclp distinct expr as", - /* 157 */ "selcollist ::= sclp STAR", - /* 158 */ "as ::= AS ids", - /* 159 */ "as ::= ids", - /* 160 */ "as ::=", - /* 161 */ "distinct ::= DISTINCT", - /* 162 */ "distinct ::=", - /* 163 */ "from ::= FROM tablelist", - /* 164 */ "tablelist ::= ids cpxName", - /* 165 */ "tablelist ::= ids cpxName ids", - /* 166 */ "tablelist ::= tablelist COMMA ids cpxName", - /* 167 */ "tablelist ::= tablelist COMMA ids cpxName ids", - /* 168 */ "tmvar ::= VARIABLE", - /* 169 */ "interval_opt ::= INTERVAL LP tmvar RP", - /* 170 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP", - /* 171 */ "interval_opt ::=", - /* 172 */ "fill_opt ::=", - /* 173 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP", - /* 174 */ "fill_opt ::= FILL LP ID RP", - /* 175 */ "sliding_opt ::= SLIDING LP tmvar RP", - /* 176 */ "sliding_opt ::=", - /* 177 */ "orderby_opt ::=", - /* 178 */ "orderby_opt ::= ORDER BY sortlist", - /* 179 */ "sortlist ::= sortlist COMMA item sortorder", - /* 180 */ "sortlist ::= item sortorder", - /* 181 */ "item ::= ids cpxName", - /* 182 */ "sortorder ::= ASC", - /* 183 */ "sortorder ::= DESC", - /* 184 */ "sortorder ::=", - /* 185 */ "groupby_opt ::=", - /* 186 */ "groupby_opt ::= GROUP BY grouplist", - /* 187 */ "grouplist ::= grouplist COMMA item", - /* 188 */ "grouplist ::= item", - /* 189 */ "having_opt ::=", - /* 190 */ "having_opt ::= HAVING expr", - /* 191 */ "limit_opt ::=", - /* 192 */ "limit_opt ::= LIMIT signed", - /* 193 */ "limit_opt ::= LIMIT signed OFFSET signed", - /* 194 */ "limit_opt ::= LIMIT signed COMMA signed", - /* 195 */ "slimit_opt ::=", - /* 196 */ "slimit_opt ::= SLIMIT signed", - /* 197 */ "slimit_opt ::= SLIMIT signed SOFFSET signed", - /* 198 */ "slimit_opt ::= SLIMIT signed COMMA signed", - /* 199 */ "where_opt ::=", - /* 200 */ "where_opt ::= WHERE expr", - /* 201 */ "expr ::= LP expr RP", - /* 202 */ "expr ::= ID", - /* 203 */ "expr ::= ID DOT ID", - /* 204 */ "expr ::= ID DOT STAR", - /* 205 */ "expr ::= INTEGER", - /* 206 */ "expr ::= MINUS INTEGER", - /* 207 */ "expr ::= PLUS INTEGER", - /* 208 */ "expr ::= FLOAT", - /* 209 */ "expr ::= MINUS FLOAT", - /* 210 */ "expr ::= PLUS FLOAT", - /* 211 */ "expr ::= STRING", - /* 212 */ "expr ::= NOW", - /* 213 */ "expr ::= VARIABLE", - /* 214 */ "expr ::= BOOL", - /* 215 */ "expr ::= ID LP exprlist RP", - /* 216 */ "expr ::= ID LP STAR RP", - /* 217 */ "expr ::= expr IS NULL", - /* 218 */ "expr ::= expr IS NOT NULL", - /* 219 */ "expr ::= expr LT expr", - /* 220 */ "expr ::= expr GT expr", - /* 221 */ "expr ::= expr LE expr", - /* 222 */ "expr ::= expr GE expr", - /* 223 */ "expr ::= expr NE expr", - /* 224 */ "expr ::= expr EQ expr", - /* 225 */ "expr ::= expr BETWEEN expr AND expr", - /* 226 */ "expr ::= expr AND expr", - /* 227 */ "expr ::= expr OR expr", - /* 228 */ "expr ::= expr PLUS expr", - /* 229 */ "expr ::= expr MINUS expr", - /* 230 */ "expr ::= expr STAR expr", - /* 231 */ "expr ::= expr SLASH expr", - /* 232 */ "expr ::= expr REM expr", - /* 233 */ "expr ::= expr LIKE expr", - /* 234 */ "expr ::= expr IN LP exprlist RP", - /* 235 */ "exprlist ::= exprlist COMMA expritem", - /* 236 */ "exprlist ::= expritem", - /* 237 */ "expritem ::= expr", - /* 238 */ "expritem ::=", - /* 239 */ "cmd ::= RESET QUERY CACHE", - /* 240 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist", - /* 241 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids", - /* 242 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", - /* 243 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", - /* 244 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", - /* 245 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", - /* 246 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", - /* 247 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", - /* 248 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", - /* 249 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", - /* 250 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", - /* 251 */ "cmd ::= KILL CONNECTION INTEGER", - /* 252 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", - /* 253 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", + /* 2 */ "cmd ::= SHOW TOPICS", + /* 3 */ "cmd ::= SHOW MNODES", + /* 4 */ "cmd ::= SHOW DNODES", + /* 5 */ "cmd ::= SHOW ACCOUNTS", + /* 6 */ "cmd ::= SHOW USERS", + /* 7 */ "cmd ::= SHOW MODULES", + /* 8 */ "cmd ::= SHOW QUERIES", + /* 9 */ "cmd ::= SHOW CONNECTIONS", + /* 10 */ "cmd ::= SHOW STREAMS", + /* 11 */ "cmd ::= SHOW VARIABLES", + /* 12 */ "cmd ::= SHOW SCORES", + /* 13 */ "cmd ::= SHOW GRANTS", + /* 14 */ "cmd ::= SHOW VNODES", + /* 15 */ "cmd ::= SHOW VNODES IPTOKEN", + /* 16 */ "dbPrefix ::=", + /* 17 */ "dbPrefix ::= ids DOT", + /* 18 */ "cpxName ::=", + /* 19 */ "cpxName ::= DOT ids", + /* 20 */ "cmd ::= SHOW CREATE TABLE ids cpxName", + /* 21 */ "cmd ::= SHOW CREATE DATABASE ids", + /* 22 */ "cmd ::= SHOW dbPrefix TABLES", + /* 23 */ "cmd ::= SHOW dbPrefix TABLES LIKE ids", + /* 24 */ "cmd ::= SHOW dbPrefix STABLES", + /* 25 */ "cmd ::= SHOW dbPrefix STABLES LIKE ids", + /* 26 */ "cmd ::= SHOW dbPrefix VGROUPS", + /* 27 */ "cmd ::= SHOW dbPrefix VGROUPS ids", + /* 28 */ "cmd ::= DROP TABLE ifexists ids cpxName", + /* 29 */ "cmd ::= DROP STABLE ifexists ids cpxName", + /* 30 */ "cmd ::= DROP DATABASE ifexists ids", + /* 31 */ "cmd ::= DROP TOPIC ifexists ids", + /* 32 */ "cmd ::= DROP DNODE ids", + /* 33 */ "cmd ::= DROP USER ids", + /* 34 */ "cmd ::= DROP ACCOUNT ids", + /* 35 */ "cmd ::= USE ids", + /* 36 */ "cmd ::= DESCRIBE ids cpxName", + /* 37 */ "cmd ::= ALTER USER ids PASS ids", + /* 38 */ "cmd ::= ALTER USER ids PRIVILEGE ids", + /* 39 */ "cmd ::= ALTER DNODE ids ids", + /* 40 */ "cmd ::= ALTER DNODE ids ids ids", + /* 41 */ "cmd ::= ALTER LOCAL ids", + /* 42 */ "cmd ::= ALTER LOCAL ids ids", + /* 43 */ "cmd ::= ALTER DATABASE ids alter_db_optr", + /* 44 */ "cmd ::= ALTER TOPIC ids alter_topic_optr", + /* 45 */ "cmd ::= ALTER ACCOUNT ids acct_optr", + /* 46 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr", + /* 47 */ "ids ::= ID", + /* 48 */ "ids ::= STRING", + /* 49 */ "ifexists ::= IF EXISTS", + /* 50 */ "ifexists ::=", + /* 51 */ "ifnotexists ::= IF NOT EXISTS", + /* 52 */ "ifnotexists ::=", + /* 53 */ "cmd ::= CREATE DNODE ids", + /* 54 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr", + /* 55 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr", + /* 56 */ "cmd ::= CREATE TOPIC ifnotexists ids topic_optr", + /* 57 */ "cmd ::= CREATE USER ids PASS ids", + /* 58 */ "pps ::=", + /* 59 */ "pps ::= PPS INTEGER", + /* 60 */ "tseries ::=", + /* 61 */ "tseries ::= TSERIES INTEGER", + /* 62 */ "dbs ::=", + /* 63 */ "dbs ::= DBS INTEGER", + /* 64 */ "streams ::=", + /* 65 */ "streams ::= STREAMS INTEGER", + /* 66 */ "storage ::=", + /* 67 */ "storage ::= STORAGE INTEGER", + /* 68 */ "qtime ::=", + /* 69 */ "qtime ::= QTIME INTEGER", + /* 70 */ "users ::=", + /* 71 */ "users ::= USERS INTEGER", + /* 72 */ "conns ::=", + /* 73 */ "conns ::= CONNS INTEGER", + /* 74 */ "state ::=", + /* 75 */ "state ::= STATE ids", + /* 76 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state", + /* 77 */ "keep ::= KEEP tagitemlist", + /* 78 */ "cache ::= CACHE INTEGER", + /* 79 */ "replica ::= REPLICA INTEGER", + /* 80 */ "quorum ::= QUORUM INTEGER", + /* 81 */ "days ::= DAYS INTEGER", + /* 82 */ "minrows ::= MINROWS INTEGER", + /* 83 */ "maxrows ::= MAXROWS INTEGER", + /* 84 */ "blocks ::= BLOCKS INTEGER", + /* 85 */ "ctime ::= CTIME INTEGER", + /* 86 */ "wal ::= WAL INTEGER", + /* 87 */ "fsync ::= FSYNC INTEGER", + /* 88 */ "comp ::= COMP INTEGER", + /* 89 */ "prec ::= PRECISION STRING", + /* 90 */ "update ::= UPDATE INTEGER", + /* 91 */ "cachelast ::= CACHELAST INTEGER", + /* 92 */ "partitions ::= PARTITIONS INTEGER", + /* 93 */ "db_optr ::=", + /* 94 */ "db_optr ::= db_optr cache", + /* 95 */ "db_optr ::= db_optr replica", + /* 96 */ "db_optr ::= db_optr quorum", + /* 97 */ "db_optr ::= db_optr days", + /* 98 */ "db_optr ::= db_optr minrows", + /* 99 */ "db_optr ::= db_optr maxrows", + /* 100 */ "db_optr ::= db_optr blocks", + /* 101 */ "db_optr ::= db_optr ctime", + /* 102 */ "db_optr ::= db_optr wal", + /* 103 */ "db_optr ::= db_optr fsync", + /* 104 */ "db_optr ::= db_optr comp", + /* 105 */ "db_optr ::= db_optr prec", + /* 106 */ "db_optr ::= db_optr keep", + /* 107 */ "db_optr ::= db_optr update", + /* 108 */ "db_optr ::= db_optr cachelast", + /* 109 */ "topic_optr ::= db_optr", + /* 110 */ "topic_optr ::= topic_optr partitions", + /* 111 */ "alter_db_optr ::=", + /* 112 */ "alter_db_optr ::= alter_db_optr replica", + /* 113 */ "alter_db_optr ::= alter_db_optr quorum", + /* 114 */ "alter_db_optr ::= alter_db_optr keep", + /* 115 */ "alter_db_optr ::= alter_db_optr blocks", + /* 116 */ "alter_db_optr ::= alter_db_optr comp", + /* 117 */ "alter_db_optr ::= alter_db_optr wal", + /* 118 */ "alter_db_optr ::= alter_db_optr fsync", + /* 119 */ "alter_db_optr ::= alter_db_optr update", + /* 120 */ "alter_db_optr ::= alter_db_optr cachelast", + /* 121 */ "alter_topic_optr ::= alter_db_optr", + /* 122 */ "alter_topic_optr ::= alter_topic_optr partitions", + /* 123 */ "typename ::= ids", + /* 124 */ "typename ::= ids LP signed RP", + /* 125 */ "typename ::= ids UNSIGNED", + /* 126 */ "signed ::= INTEGER", + /* 127 */ "signed ::= PLUS INTEGER", + /* 128 */ "signed ::= MINUS INTEGER", + /* 129 */ "cmd ::= CREATE TABLE create_table_args", + /* 130 */ "cmd ::= CREATE TABLE create_stable_args", + /* 131 */ "cmd ::= CREATE STABLE create_stable_args", + /* 132 */ "cmd ::= CREATE TABLE create_table_list", + /* 133 */ "create_table_list ::= create_from_stable", + /* 134 */ "create_table_list ::= create_table_list create_from_stable", + /* 135 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP", + /* 136 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP", + /* 137 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP", + /* 138 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP", + /* 139 */ "tagNamelist ::= tagNamelist COMMA ids", + /* 140 */ "tagNamelist ::= ids", + /* 141 */ "create_table_args ::= ifnotexists ids cpxName AS select", + /* 142 */ "columnlist ::= columnlist COMMA column", + /* 143 */ "columnlist ::= column", + /* 144 */ "column ::= ids typename", + /* 145 */ "tagitemlist ::= tagitemlist COMMA tagitem", + /* 146 */ "tagitemlist ::= tagitem", + /* 147 */ "tagitem ::= INTEGER", + /* 148 */ "tagitem ::= FLOAT", + /* 149 */ "tagitem ::= STRING", + /* 150 */ "tagitem ::= BOOL", + /* 151 */ "tagitem ::= NULL", + /* 152 */ "tagitem ::= MINUS INTEGER", + /* 153 */ "tagitem ::= MINUS FLOAT", + /* 154 */ "tagitem ::= PLUS INTEGER", + /* 155 */ "tagitem ::= PLUS FLOAT", + /* 156 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt", + /* 157 */ "union ::= select", + /* 158 */ "union ::= LP union RP", + /* 159 */ "union ::= union UNION ALL select", + /* 160 */ "union ::= union UNION ALL LP select RP", + /* 161 */ "cmd ::= union", + /* 162 */ "select ::= SELECT selcollist", + /* 163 */ "sclp ::= selcollist COMMA", + /* 164 */ "sclp ::=", + /* 165 */ "selcollist ::= sclp distinct expr as", + /* 166 */ "selcollist ::= sclp STAR", + /* 167 */ "as ::= AS ids", + /* 168 */ "as ::= ids", + /* 169 */ "as ::=", + /* 170 */ "distinct ::= DISTINCT", + /* 171 */ "distinct ::=", + /* 172 */ "from ::= FROM tablelist", + /* 173 */ "tablelist ::= ids cpxName", + /* 174 */ "tablelist ::= ids cpxName ids", + /* 175 */ "tablelist ::= tablelist COMMA ids cpxName", + /* 176 */ "tablelist ::= tablelist COMMA ids cpxName ids", + /* 177 */ "tmvar ::= VARIABLE", + /* 178 */ "interval_opt ::= INTERVAL LP tmvar RP", + /* 179 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP", + /* 180 */ "interval_opt ::=", + /* 181 */ "fill_opt ::=", + /* 182 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP", + /* 183 */ "fill_opt ::= FILL LP ID RP", + /* 184 */ "sliding_opt ::= SLIDING LP tmvar RP", + /* 185 */ "sliding_opt ::=", + /* 186 */ "orderby_opt ::=", + /* 187 */ "orderby_opt ::= ORDER BY sortlist", + /* 188 */ "sortlist ::= sortlist COMMA item sortorder", + /* 189 */ "sortlist ::= item sortorder", + /* 190 */ "item ::= ids cpxName", + /* 191 */ "sortorder ::= ASC", + /* 192 */ "sortorder ::= DESC", + /* 193 */ "sortorder ::=", + /* 194 */ "groupby_opt ::=", + /* 195 */ "groupby_opt ::= GROUP BY grouplist", + /* 196 */ "grouplist ::= grouplist COMMA item", + /* 197 */ "grouplist ::= item", + /* 198 */ "having_opt ::=", + /* 199 */ "having_opt ::= HAVING expr", + /* 200 */ "limit_opt ::=", + /* 201 */ "limit_opt ::= LIMIT signed", + /* 202 */ "limit_opt ::= LIMIT signed OFFSET signed", + /* 203 */ "limit_opt ::= LIMIT signed COMMA signed", + /* 204 */ "slimit_opt ::=", + /* 205 */ "slimit_opt ::= SLIMIT signed", + /* 206 */ "slimit_opt ::= SLIMIT signed SOFFSET signed", + /* 207 */ "slimit_opt ::= SLIMIT signed COMMA signed", + /* 208 */ "where_opt ::=", + /* 209 */ "where_opt ::= WHERE expr", + /* 210 */ "expr ::= LP expr RP", + /* 211 */ "expr ::= ID", + /* 212 */ "expr ::= ID DOT ID", + /* 213 */ "expr ::= ID DOT STAR", + /* 214 */ "expr ::= INTEGER", + /* 215 */ "expr ::= MINUS INTEGER", + /* 216 */ "expr ::= PLUS INTEGER", + /* 217 */ "expr ::= FLOAT", + /* 218 */ "expr ::= MINUS FLOAT", + /* 219 */ "expr ::= PLUS FLOAT", + /* 220 */ "expr ::= STRING", + /* 221 */ "expr ::= NOW", + /* 222 */ "expr ::= VARIABLE", + /* 223 */ "expr ::= BOOL", + /* 224 */ "expr ::= ID LP exprlist RP", + /* 225 */ "expr ::= ID LP STAR RP", + /* 226 */ "expr ::= expr IS NULL", + /* 227 */ "expr ::= expr IS NOT NULL", + /* 228 */ "expr ::= expr LT expr", + /* 229 */ "expr ::= expr GT expr", + /* 230 */ "expr ::= expr LE expr", + /* 231 */ "expr ::= expr GE expr", + /* 232 */ "expr ::= expr NE expr", + /* 233 */ "expr ::= expr EQ expr", + /* 234 */ "expr ::= expr BETWEEN expr AND expr", + /* 235 */ "expr ::= expr AND expr", + /* 236 */ "expr ::= expr OR expr", + /* 237 */ "expr ::= expr PLUS expr", + /* 238 */ "expr ::= expr MINUS expr", + /* 239 */ "expr ::= expr STAR expr", + /* 240 */ "expr ::= expr SLASH expr", + /* 241 */ "expr ::= expr REM expr", + /* 242 */ "expr ::= expr LIKE expr", + /* 243 */ "expr ::= expr IN LP exprlist RP", + /* 244 */ "exprlist ::= exprlist COMMA expritem", + /* 245 */ "exprlist ::= expritem", + /* 246 */ "expritem ::= expr", + /* 247 */ "expritem ::=", + /* 248 */ "cmd ::= RESET QUERY CACHE", + /* 249 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist", + /* 250 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids", + /* 251 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", + /* 252 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", + /* 253 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", + /* 254 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", + /* 255 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", + /* 256 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", + /* 257 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", + /* 258 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", + /* 259 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", + /* 260 */ "cmd ::= KILL CONNECTION INTEGER", + /* 261 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", + /* 262 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", }; #endif /* NDEBUG */ @@ -1443,52 +1467,52 @@ static void yy_destructor( ** inside the C code. */ /********* Begin destructor definitions ***************************************/ - case 229: /* keep */ - case 230: /* tagitemlist */ - case 251: /* columnlist */ - case 252: /* tagNamelist */ - case 260: /* fill_opt */ - case 262: /* groupby_opt */ - case 263: /* orderby_opt */ - case 274: /* sortlist */ - case 278: /* grouplist */ + case 234: /* keep */ + case 235: /* tagitemlist */ + case 257: /* columnlist */ + case 258: /* tagNamelist */ + case 266: /* fill_opt */ + case 268: /* groupby_opt */ + case 269: /* orderby_opt */ + case 280: /* sortlist */ + case 284: /* grouplist */ { -taosArrayDestroy((yypminor->yy247)); +taosArrayDestroy((yypminor->yy207)); } break; - case 249: /* create_table_list */ + case 255: /* create_table_list */ { -destroyCreateTableSql((yypminor->yy358)); +destroyCreateTableSql((yypminor->yy414)); } break; - case 253: /* select */ + case 259: /* select */ { -doDestroyQuerySql((yypminor->yy114)); +doDestroyQuerySql((yypminor->yy526)); } break; - case 256: /* selcollist */ - case 268: /* sclp */ - case 279: /* exprlist */ + case 262: /* selcollist */ + case 274: /* sclp */ + case 285: /* exprlist */ { -tSqlExprListDestroy((yypminor->yy522)); +tSqlExprListDestroy((yypminor->yy178)); } break; - case 258: /* where_opt */ - case 264: /* having_opt */ - case 270: /* expr */ - case 280: /* expritem */ + case 264: /* where_opt */ + case 270: /* having_opt */ + case 276: /* expr */ + case 286: /* expritem */ { -tSqlExprDestroy((yypminor->yy326)); +tSqlExprDestroy((yypminor->yy484)); } break; - case 267: /* union */ + case 273: /* union */ { -destroyAllSelectClause((yypminor->yy219)); +destroyAllSelectClause((yypminor->yy441)); } break; - case 275: /* sortitem */ + case 281: /* sortitem */ { -tVariantDestroy(&(yypminor->yy378)); +tVariantDestroy(&(yypminor->yy232)); } break; /********* End destructor definitions *****************************************/ @@ -1777,260 +1801,269 @@ static void yy_shift( /* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side ** of that rule */ static const YYCODETYPE yyRuleInfoLhs[] = { - 210, /* (0) program ::= cmd */ - 211, /* (1) cmd ::= SHOW DATABASES */ - 211, /* (2) cmd ::= SHOW MNODES */ - 211, /* (3) cmd ::= SHOW DNODES */ - 211, /* (4) cmd ::= SHOW ACCOUNTS */ - 211, /* (5) cmd ::= SHOW USERS */ - 211, /* (6) cmd ::= SHOW MODULES */ - 211, /* (7) cmd ::= SHOW QUERIES */ - 211, /* (8) cmd ::= SHOW CONNECTIONS */ - 211, /* (9) cmd ::= SHOW STREAMS */ - 211, /* (10) cmd ::= SHOW VARIABLES */ - 211, /* (11) cmd ::= SHOW SCORES */ - 211, /* (12) cmd ::= SHOW GRANTS */ - 211, /* (13) cmd ::= SHOW VNODES */ - 211, /* (14) cmd ::= SHOW VNODES IPTOKEN */ - 212, /* (15) dbPrefix ::= */ - 212, /* (16) dbPrefix ::= ids DOT */ - 214, /* (17) cpxName ::= */ - 214, /* (18) cpxName ::= DOT ids */ - 211, /* (19) cmd ::= SHOW CREATE TABLE ids cpxName */ - 211, /* (20) cmd ::= SHOW CREATE DATABASE ids */ - 211, /* (21) cmd ::= SHOW dbPrefix TABLES */ - 211, /* (22) cmd ::= SHOW dbPrefix TABLES LIKE ids */ - 211, /* (23) cmd ::= SHOW dbPrefix STABLES */ - 211, /* (24) cmd ::= SHOW dbPrefix STABLES LIKE ids */ - 211, /* (25) cmd ::= SHOW dbPrefix VGROUPS */ - 211, /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */ - 211, /* (27) cmd ::= DROP TABLE ifexists ids cpxName */ - 211, /* (28) cmd ::= DROP STABLE ifexists ids cpxName */ - 211, /* (29) cmd ::= DROP DATABASE ifexists ids */ - 211, /* (30) cmd ::= DROP DNODE ids */ - 211, /* (31) cmd ::= DROP USER ids */ - 211, /* (32) cmd ::= DROP ACCOUNT ids */ - 211, /* (33) cmd ::= USE ids */ - 211, /* (34) cmd ::= DESCRIBE ids cpxName */ - 211, /* (35) cmd ::= ALTER USER ids PASS ids */ - 211, /* (36) cmd ::= ALTER USER ids PRIVILEGE ids */ - 211, /* (37) cmd ::= ALTER DNODE ids ids */ - 211, /* (38) cmd ::= ALTER DNODE ids ids ids */ - 211, /* (39) cmd ::= ALTER LOCAL ids */ - 211, /* (40) cmd ::= ALTER LOCAL ids ids */ - 211, /* (41) cmd ::= ALTER DATABASE ids alter_db_optr */ - 211, /* (42) cmd ::= ALTER ACCOUNT ids acct_optr */ - 211, /* (43) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ - 213, /* (44) ids ::= ID */ - 213, /* (45) ids ::= STRING */ - 215, /* (46) ifexists ::= IF EXISTS */ - 215, /* (47) ifexists ::= */ - 218, /* (48) ifnotexists ::= IF NOT EXISTS */ - 218, /* (49) ifnotexists ::= */ - 211, /* (50) cmd ::= CREATE DNODE ids */ - 211, /* (51) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ - 211, /* (52) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ - 211, /* (53) cmd ::= CREATE USER ids PASS ids */ - 220, /* (54) pps ::= */ - 220, /* (55) pps ::= PPS INTEGER */ - 221, /* (56) tseries ::= */ - 221, /* (57) tseries ::= TSERIES INTEGER */ - 222, /* (58) dbs ::= */ - 222, /* (59) dbs ::= DBS INTEGER */ - 223, /* (60) streams ::= */ - 223, /* (61) streams ::= STREAMS INTEGER */ - 224, /* (62) storage ::= */ - 224, /* (63) storage ::= STORAGE INTEGER */ - 225, /* (64) qtime ::= */ - 225, /* (65) qtime ::= QTIME INTEGER */ - 226, /* (66) users ::= */ - 226, /* (67) users ::= USERS INTEGER */ - 227, /* (68) conns ::= */ - 227, /* (69) conns ::= CONNS INTEGER */ - 228, /* (70) state ::= */ - 228, /* (71) state ::= STATE ids */ - 217, /* (72) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ - 229, /* (73) keep ::= KEEP tagitemlist */ - 231, /* (74) cache ::= CACHE INTEGER */ - 232, /* (75) replica ::= REPLICA INTEGER */ - 233, /* (76) quorum ::= QUORUM INTEGER */ - 234, /* (77) days ::= DAYS INTEGER */ - 235, /* (78) minrows ::= MINROWS INTEGER */ - 236, /* (79) maxrows ::= MAXROWS INTEGER */ - 237, /* (80) blocks ::= BLOCKS INTEGER */ - 238, /* (81) ctime ::= CTIME INTEGER */ - 239, /* (82) wal ::= WAL INTEGER */ - 240, /* (83) fsync ::= FSYNC INTEGER */ - 241, /* (84) comp ::= COMP INTEGER */ - 242, /* (85) prec ::= PRECISION STRING */ - 243, /* (86) update ::= UPDATE INTEGER */ - 244, /* (87) cachelast ::= CACHELAST INTEGER */ - 219, /* (88) db_optr ::= */ - 219, /* (89) db_optr ::= db_optr cache */ - 219, /* (90) db_optr ::= db_optr replica */ - 219, /* (91) db_optr ::= db_optr quorum */ - 219, /* (92) db_optr ::= db_optr days */ - 219, /* (93) db_optr ::= db_optr minrows */ - 219, /* (94) db_optr ::= db_optr maxrows */ - 219, /* (95) db_optr ::= db_optr blocks */ - 219, /* (96) db_optr ::= db_optr ctime */ - 219, /* (97) db_optr ::= db_optr wal */ - 219, /* (98) db_optr ::= db_optr fsync */ - 219, /* (99) db_optr ::= db_optr comp */ - 219, /* (100) db_optr ::= db_optr prec */ - 219, /* (101) db_optr ::= db_optr keep */ - 219, /* (102) db_optr ::= db_optr update */ - 219, /* (103) db_optr ::= db_optr cachelast */ - 216, /* (104) alter_db_optr ::= */ - 216, /* (105) alter_db_optr ::= alter_db_optr replica */ - 216, /* (106) alter_db_optr ::= alter_db_optr quorum */ - 216, /* (107) alter_db_optr ::= alter_db_optr keep */ - 216, /* (108) alter_db_optr ::= alter_db_optr blocks */ - 216, /* (109) alter_db_optr ::= alter_db_optr comp */ - 216, /* (110) alter_db_optr ::= alter_db_optr wal */ - 216, /* (111) alter_db_optr ::= alter_db_optr fsync */ - 216, /* (112) alter_db_optr ::= alter_db_optr update */ - 216, /* (113) alter_db_optr ::= alter_db_optr cachelast */ - 245, /* (114) typename ::= ids */ - 245, /* (115) typename ::= ids LP signed RP */ - 245, /* (116) typename ::= ids UNSIGNED */ - 246, /* (117) signed ::= INTEGER */ - 246, /* (118) signed ::= PLUS INTEGER */ - 246, /* (119) signed ::= MINUS INTEGER */ - 211, /* (120) cmd ::= CREATE TABLE create_table_args */ - 211, /* (121) cmd ::= CREATE TABLE create_stable_args */ - 211, /* (122) cmd ::= CREATE STABLE create_stable_args */ - 211, /* (123) cmd ::= CREATE TABLE create_table_list */ - 249, /* (124) create_table_list ::= create_from_stable */ - 249, /* (125) create_table_list ::= create_table_list create_from_stable */ - 247, /* (126) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ - 248, /* (127) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ - 250, /* (128) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ - 250, /* (129) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ - 252, /* (130) tagNamelist ::= tagNamelist COMMA ids */ - 252, /* (131) tagNamelist ::= ids */ - 247, /* (132) create_table_args ::= ifnotexists ids cpxName AS select */ - 251, /* (133) columnlist ::= columnlist COMMA column */ - 251, /* (134) columnlist ::= column */ - 254, /* (135) column ::= ids typename */ - 230, /* (136) tagitemlist ::= tagitemlist COMMA tagitem */ - 230, /* (137) tagitemlist ::= tagitem */ - 255, /* (138) tagitem ::= INTEGER */ - 255, /* (139) tagitem ::= FLOAT */ - 255, /* (140) tagitem ::= STRING */ - 255, /* (141) tagitem ::= BOOL */ - 255, /* (142) tagitem ::= NULL */ - 255, /* (143) tagitem ::= MINUS INTEGER */ - 255, /* (144) tagitem ::= MINUS FLOAT */ - 255, /* (145) tagitem ::= PLUS INTEGER */ - 255, /* (146) tagitem ::= PLUS FLOAT */ - 253, /* (147) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */ - 267, /* (148) union ::= select */ - 267, /* (149) union ::= LP union RP */ - 267, /* (150) union ::= union UNION ALL select */ - 267, /* (151) union ::= union UNION ALL LP select RP */ - 211, /* (152) cmd ::= union */ - 253, /* (153) select ::= SELECT selcollist */ - 268, /* (154) sclp ::= selcollist COMMA */ - 268, /* (155) sclp ::= */ - 256, /* (156) selcollist ::= sclp distinct expr as */ - 256, /* (157) selcollist ::= sclp STAR */ - 271, /* (158) as ::= AS ids */ - 271, /* (159) as ::= ids */ - 271, /* (160) as ::= */ - 269, /* (161) distinct ::= DISTINCT */ - 269, /* (162) distinct ::= */ - 257, /* (163) from ::= FROM tablelist */ - 272, /* (164) tablelist ::= ids cpxName */ - 272, /* (165) tablelist ::= ids cpxName ids */ - 272, /* (166) tablelist ::= tablelist COMMA ids cpxName */ - 272, /* (167) tablelist ::= tablelist COMMA ids cpxName ids */ - 273, /* (168) tmvar ::= VARIABLE */ - 259, /* (169) interval_opt ::= INTERVAL LP tmvar RP */ - 259, /* (170) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */ - 259, /* (171) interval_opt ::= */ - 260, /* (172) fill_opt ::= */ - 260, /* (173) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ - 260, /* (174) fill_opt ::= FILL LP ID RP */ - 261, /* (175) sliding_opt ::= SLIDING LP tmvar RP */ - 261, /* (176) sliding_opt ::= */ - 263, /* (177) orderby_opt ::= */ - 263, /* (178) orderby_opt ::= ORDER BY sortlist */ - 274, /* (179) sortlist ::= sortlist COMMA item sortorder */ - 274, /* (180) sortlist ::= item sortorder */ - 276, /* (181) item ::= ids cpxName */ - 277, /* (182) sortorder ::= ASC */ - 277, /* (183) sortorder ::= DESC */ - 277, /* (184) sortorder ::= */ - 262, /* (185) groupby_opt ::= */ - 262, /* (186) groupby_opt ::= GROUP BY grouplist */ - 278, /* (187) grouplist ::= grouplist COMMA item */ - 278, /* (188) grouplist ::= item */ - 264, /* (189) having_opt ::= */ - 264, /* (190) having_opt ::= HAVING expr */ - 266, /* (191) limit_opt ::= */ - 266, /* (192) limit_opt ::= LIMIT signed */ - 266, /* (193) limit_opt ::= LIMIT signed OFFSET signed */ - 266, /* (194) limit_opt ::= LIMIT signed COMMA signed */ - 265, /* (195) slimit_opt ::= */ - 265, /* (196) slimit_opt ::= SLIMIT signed */ - 265, /* (197) slimit_opt ::= SLIMIT signed SOFFSET signed */ - 265, /* (198) slimit_opt ::= SLIMIT signed COMMA signed */ - 258, /* (199) where_opt ::= */ - 258, /* (200) where_opt ::= WHERE expr */ - 270, /* (201) expr ::= LP expr RP */ - 270, /* (202) expr ::= ID */ - 270, /* (203) expr ::= ID DOT ID */ - 270, /* (204) expr ::= ID DOT STAR */ - 270, /* (205) expr ::= INTEGER */ - 270, /* (206) expr ::= MINUS INTEGER */ - 270, /* (207) expr ::= PLUS INTEGER */ - 270, /* (208) expr ::= FLOAT */ - 270, /* (209) expr ::= MINUS FLOAT */ - 270, /* (210) expr ::= PLUS FLOAT */ - 270, /* (211) expr ::= STRING */ - 270, /* (212) expr ::= NOW */ - 270, /* (213) expr ::= VARIABLE */ - 270, /* (214) expr ::= BOOL */ - 270, /* (215) expr ::= ID LP exprlist RP */ - 270, /* (216) expr ::= ID LP STAR RP */ - 270, /* (217) expr ::= expr IS NULL */ - 270, /* (218) expr ::= expr IS NOT NULL */ - 270, /* (219) expr ::= expr LT expr */ - 270, /* (220) expr ::= expr GT expr */ - 270, /* (221) expr ::= expr LE expr */ - 270, /* (222) expr ::= expr GE expr */ - 270, /* (223) expr ::= expr NE expr */ - 270, /* (224) expr ::= expr EQ expr */ - 270, /* (225) expr ::= expr BETWEEN expr AND expr */ - 270, /* (226) expr ::= expr AND expr */ - 270, /* (227) expr ::= expr OR expr */ - 270, /* (228) expr ::= expr PLUS expr */ - 270, /* (229) expr ::= expr MINUS expr */ - 270, /* (230) expr ::= expr STAR expr */ - 270, /* (231) expr ::= expr SLASH expr */ - 270, /* (232) expr ::= expr REM expr */ - 270, /* (233) expr ::= expr LIKE expr */ - 270, /* (234) expr ::= expr IN LP exprlist RP */ - 279, /* (235) exprlist ::= exprlist COMMA expritem */ - 279, /* (236) exprlist ::= expritem */ - 280, /* (237) expritem ::= expr */ - 280, /* (238) expritem ::= */ - 211, /* (239) cmd ::= RESET QUERY CACHE */ - 211, /* (240) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ - 211, /* (241) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ - 211, /* (242) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ - 211, /* (243) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ - 211, /* (244) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ - 211, /* (245) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ - 211, /* (246) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ - 211, /* (247) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ - 211, /* (248) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ - 211, /* (249) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ - 211, /* (250) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ - 211, /* (251) cmd ::= KILL CONNECTION INTEGER */ - 211, /* (252) cmd ::= KILL STREAM INTEGER COLON INTEGER */ - 211, /* (253) cmd ::= KILL QUERY INTEGER COLON INTEGER */ + 213, /* (0) program ::= cmd */ + 214, /* (1) cmd ::= SHOW DATABASES */ + 214, /* (2) cmd ::= SHOW TOPICS */ + 214, /* (3) cmd ::= SHOW MNODES */ + 214, /* (4) cmd ::= SHOW DNODES */ + 214, /* (5) cmd ::= SHOW ACCOUNTS */ + 214, /* (6) cmd ::= SHOW USERS */ + 214, /* (7) cmd ::= SHOW MODULES */ + 214, /* (8) cmd ::= SHOW QUERIES */ + 214, /* (9) cmd ::= SHOW CONNECTIONS */ + 214, /* (10) cmd ::= SHOW STREAMS */ + 214, /* (11) cmd ::= SHOW VARIABLES */ + 214, /* (12) cmd ::= SHOW SCORES */ + 214, /* (13) cmd ::= SHOW GRANTS */ + 214, /* (14) cmd ::= SHOW VNODES */ + 214, /* (15) cmd ::= SHOW VNODES IPTOKEN */ + 215, /* (16) dbPrefix ::= */ + 215, /* (17) dbPrefix ::= ids DOT */ + 217, /* (18) cpxName ::= */ + 217, /* (19) cpxName ::= DOT ids */ + 214, /* (20) cmd ::= SHOW CREATE TABLE ids cpxName */ + 214, /* (21) cmd ::= SHOW CREATE DATABASE ids */ + 214, /* (22) cmd ::= SHOW dbPrefix TABLES */ + 214, /* (23) cmd ::= SHOW dbPrefix TABLES LIKE ids */ + 214, /* (24) cmd ::= SHOW dbPrefix STABLES */ + 214, /* (25) cmd ::= SHOW dbPrefix STABLES LIKE ids */ + 214, /* (26) cmd ::= SHOW dbPrefix VGROUPS */ + 214, /* (27) cmd ::= SHOW dbPrefix VGROUPS ids */ + 214, /* (28) cmd ::= DROP TABLE ifexists ids cpxName */ + 214, /* (29) cmd ::= DROP STABLE ifexists ids cpxName */ + 214, /* (30) cmd ::= DROP DATABASE ifexists ids */ + 214, /* (31) cmd ::= DROP TOPIC ifexists ids */ + 214, /* (32) cmd ::= DROP DNODE ids */ + 214, /* (33) cmd ::= DROP USER ids */ + 214, /* (34) cmd ::= DROP ACCOUNT ids */ + 214, /* (35) cmd ::= USE ids */ + 214, /* (36) cmd ::= DESCRIBE ids cpxName */ + 214, /* (37) cmd ::= ALTER USER ids PASS ids */ + 214, /* (38) cmd ::= ALTER USER ids PRIVILEGE ids */ + 214, /* (39) cmd ::= ALTER DNODE ids ids */ + 214, /* (40) cmd ::= ALTER DNODE ids ids ids */ + 214, /* (41) cmd ::= ALTER LOCAL ids */ + 214, /* (42) cmd ::= ALTER LOCAL ids ids */ + 214, /* (43) cmd ::= ALTER DATABASE ids alter_db_optr */ + 214, /* (44) cmd ::= ALTER TOPIC ids alter_topic_optr */ + 214, /* (45) cmd ::= ALTER ACCOUNT ids acct_optr */ + 214, /* (46) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ + 216, /* (47) ids ::= ID */ + 216, /* (48) ids ::= STRING */ + 218, /* (49) ifexists ::= IF EXISTS */ + 218, /* (50) ifexists ::= */ + 222, /* (51) ifnotexists ::= IF NOT EXISTS */ + 222, /* (52) ifnotexists ::= */ + 214, /* (53) cmd ::= CREATE DNODE ids */ + 214, /* (54) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ + 214, /* (55) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ + 214, /* (56) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ + 214, /* (57) cmd ::= CREATE USER ids PASS ids */ + 225, /* (58) pps ::= */ + 225, /* (59) pps ::= PPS INTEGER */ + 226, /* (60) tseries ::= */ + 226, /* (61) tseries ::= TSERIES INTEGER */ + 227, /* (62) dbs ::= */ + 227, /* (63) dbs ::= DBS INTEGER */ + 228, /* (64) streams ::= */ + 228, /* (65) streams ::= STREAMS INTEGER */ + 229, /* (66) storage ::= */ + 229, /* (67) storage ::= STORAGE INTEGER */ + 230, /* (68) qtime ::= */ + 230, /* (69) qtime ::= QTIME INTEGER */ + 231, /* (70) users ::= */ + 231, /* (71) users ::= USERS INTEGER */ + 232, /* (72) conns ::= */ + 232, /* (73) conns ::= CONNS INTEGER */ + 233, /* (74) state ::= */ + 233, /* (75) state ::= STATE ids */ + 221, /* (76) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ + 234, /* (77) keep ::= KEEP tagitemlist */ + 236, /* (78) cache ::= CACHE INTEGER */ + 237, /* (79) replica ::= REPLICA INTEGER */ + 238, /* (80) quorum ::= QUORUM INTEGER */ + 239, /* (81) days ::= DAYS INTEGER */ + 240, /* (82) minrows ::= MINROWS INTEGER */ + 241, /* (83) maxrows ::= MAXROWS INTEGER */ + 242, /* (84) blocks ::= BLOCKS INTEGER */ + 243, /* (85) ctime ::= CTIME INTEGER */ + 244, /* (86) wal ::= WAL INTEGER */ + 245, /* (87) fsync ::= FSYNC INTEGER */ + 246, /* (88) comp ::= COMP INTEGER */ + 247, /* (89) prec ::= PRECISION STRING */ + 248, /* (90) update ::= UPDATE INTEGER */ + 249, /* (91) cachelast ::= CACHELAST INTEGER */ + 250, /* (92) partitions ::= PARTITIONS INTEGER */ + 223, /* (93) db_optr ::= */ + 223, /* (94) db_optr ::= db_optr cache */ + 223, /* (95) db_optr ::= db_optr replica */ + 223, /* (96) db_optr ::= db_optr quorum */ + 223, /* (97) db_optr ::= db_optr days */ + 223, /* (98) db_optr ::= db_optr minrows */ + 223, /* (99) db_optr ::= db_optr maxrows */ + 223, /* (100) db_optr ::= db_optr blocks */ + 223, /* (101) db_optr ::= db_optr ctime */ + 223, /* (102) db_optr ::= db_optr wal */ + 223, /* (103) db_optr ::= db_optr fsync */ + 223, /* (104) db_optr ::= db_optr comp */ + 223, /* (105) db_optr ::= db_optr prec */ + 223, /* (106) db_optr ::= db_optr keep */ + 223, /* (107) db_optr ::= db_optr update */ + 223, /* (108) db_optr ::= db_optr cachelast */ + 224, /* (109) topic_optr ::= db_optr */ + 224, /* (110) topic_optr ::= topic_optr partitions */ + 219, /* (111) alter_db_optr ::= */ + 219, /* (112) alter_db_optr ::= alter_db_optr replica */ + 219, /* (113) alter_db_optr ::= alter_db_optr quorum */ + 219, /* (114) alter_db_optr ::= alter_db_optr keep */ + 219, /* (115) alter_db_optr ::= alter_db_optr blocks */ + 219, /* (116) alter_db_optr ::= alter_db_optr comp */ + 219, /* (117) alter_db_optr ::= alter_db_optr wal */ + 219, /* (118) alter_db_optr ::= alter_db_optr fsync */ + 219, /* (119) alter_db_optr ::= alter_db_optr update */ + 219, /* (120) alter_db_optr ::= alter_db_optr cachelast */ + 220, /* (121) alter_topic_optr ::= alter_db_optr */ + 220, /* (122) alter_topic_optr ::= alter_topic_optr partitions */ + 251, /* (123) typename ::= ids */ + 251, /* (124) typename ::= ids LP signed RP */ + 251, /* (125) typename ::= ids UNSIGNED */ + 252, /* (126) signed ::= INTEGER */ + 252, /* (127) signed ::= PLUS INTEGER */ + 252, /* (128) signed ::= MINUS INTEGER */ + 214, /* (129) cmd ::= CREATE TABLE create_table_args */ + 214, /* (130) cmd ::= CREATE TABLE create_stable_args */ + 214, /* (131) cmd ::= CREATE STABLE create_stable_args */ + 214, /* (132) cmd ::= CREATE TABLE create_table_list */ + 255, /* (133) create_table_list ::= create_from_stable */ + 255, /* (134) create_table_list ::= create_table_list create_from_stable */ + 253, /* (135) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ + 254, /* (136) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ + 256, /* (137) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ + 256, /* (138) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ + 258, /* (139) tagNamelist ::= tagNamelist COMMA ids */ + 258, /* (140) tagNamelist ::= ids */ + 253, /* (141) create_table_args ::= ifnotexists ids cpxName AS select */ + 257, /* (142) columnlist ::= columnlist COMMA column */ + 257, /* (143) columnlist ::= column */ + 260, /* (144) column ::= ids typename */ + 235, /* (145) tagitemlist ::= tagitemlist COMMA tagitem */ + 235, /* (146) tagitemlist ::= tagitem */ + 261, /* (147) tagitem ::= INTEGER */ + 261, /* (148) tagitem ::= FLOAT */ + 261, /* (149) tagitem ::= STRING */ + 261, /* (150) tagitem ::= BOOL */ + 261, /* (151) tagitem ::= NULL */ + 261, /* (152) tagitem ::= MINUS INTEGER */ + 261, /* (153) tagitem ::= MINUS FLOAT */ + 261, /* (154) tagitem ::= PLUS INTEGER */ + 261, /* (155) tagitem ::= PLUS FLOAT */ + 259, /* (156) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */ + 273, /* (157) union ::= select */ + 273, /* (158) union ::= LP union RP */ + 273, /* (159) union ::= union UNION ALL select */ + 273, /* (160) union ::= union UNION ALL LP select RP */ + 214, /* (161) cmd ::= union */ + 259, /* (162) select ::= SELECT selcollist */ + 274, /* (163) sclp ::= selcollist COMMA */ + 274, /* (164) sclp ::= */ + 262, /* (165) selcollist ::= sclp distinct expr as */ + 262, /* (166) selcollist ::= sclp STAR */ + 277, /* (167) as ::= AS ids */ + 277, /* (168) as ::= ids */ + 277, /* (169) as ::= */ + 275, /* (170) distinct ::= DISTINCT */ + 275, /* (171) distinct ::= */ + 263, /* (172) from ::= FROM tablelist */ + 278, /* (173) tablelist ::= ids cpxName */ + 278, /* (174) tablelist ::= ids cpxName ids */ + 278, /* (175) tablelist ::= tablelist COMMA ids cpxName */ + 278, /* (176) tablelist ::= tablelist COMMA ids cpxName ids */ + 279, /* (177) tmvar ::= VARIABLE */ + 265, /* (178) interval_opt ::= INTERVAL LP tmvar RP */ + 265, /* (179) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */ + 265, /* (180) interval_opt ::= */ + 266, /* (181) fill_opt ::= */ + 266, /* (182) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ + 266, /* (183) fill_opt ::= FILL LP ID RP */ + 267, /* (184) sliding_opt ::= SLIDING LP tmvar RP */ + 267, /* (185) sliding_opt ::= */ + 269, /* (186) orderby_opt ::= */ + 269, /* (187) orderby_opt ::= ORDER BY sortlist */ + 280, /* (188) sortlist ::= sortlist COMMA item sortorder */ + 280, /* (189) sortlist ::= item sortorder */ + 282, /* (190) item ::= ids cpxName */ + 283, /* (191) sortorder ::= ASC */ + 283, /* (192) sortorder ::= DESC */ + 283, /* (193) sortorder ::= */ + 268, /* (194) groupby_opt ::= */ + 268, /* (195) groupby_opt ::= GROUP BY grouplist */ + 284, /* (196) grouplist ::= grouplist COMMA item */ + 284, /* (197) grouplist ::= item */ + 270, /* (198) having_opt ::= */ + 270, /* (199) having_opt ::= HAVING expr */ + 272, /* (200) limit_opt ::= */ + 272, /* (201) limit_opt ::= LIMIT signed */ + 272, /* (202) limit_opt ::= LIMIT signed OFFSET signed */ + 272, /* (203) limit_opt ::= LIMIT signed COMMA signed */ + 271, /* (204) slimit_opt ::= */ + 271, /* (205) slimit_opt ::= SLIMIT signed */ + 271, /* (206) slimit_opt ::= SLIMIT signed SOFFSET signed */ + 271, /* (207) slimit_opt ::= SLIMIT signed COMMA signed */ + 264, /* (208) where_opt ::= */ + 264, /* (209) where_opt ::= WHERE expr */ + 276, /* (210) expr ::= LP expr RP */ + 276, /* (211) expr ::= ID */ + 276, /* (212) expr ::= ID DOT ID */ + 276, /* (213) expr ::= ID DOT STAR */ + 276, /* (214) expr ::= INTEGER */ + 276, /* (215) expr ::= MINUS INTEGER */ + 276, /* (216) expr ::= PLUS INTEGER */ + 276, /* (217) expr ::= FLOAT */ + 276, /* (218) expr ::= MINUS FLOAT */ + 276, /* (219) expr ::= PLUS FLOAT */ + 276, /* (220) expr ::= STRING */ + 276, /* (221) expr ::= NOW */ + 276, /* (222) expr ::= VARIABLE */ + 276, /* (223) expr ::= BOOL */ + 276, /* (224) expr ::= ID LP exprlist RP */ + 276, /* (225) expr ::= ID LP STAR RP */ + 276, /* (226) expr ::= expr IS NULL */ + 276, /* (227) expr ::= expr IS NOT NULL */ + 276, /* (228) expr ::= expr LT expr */ + 276, /* (229) expr ::= expr GT expr */ + 276, /* (230) expr ::= expr LE expr */ + 276, /* (231) expr ::= expr GE expr */ + 276, /* (232) expr ::= expr NE expr */ + 276, /* (233) expr ::= expr EQ expr */ + 276, /* (234) expr ::= expr BETWEEN expr AND expr */ + 276, /* (235) expr ::= expr AND expr */ + 276, /* (236) expr ::= expr OR expr */ + 276, /* (237) expr ::= expr PLUS expr */ + 276, /* (238) expr ::= expr MINUS expr */ + 276, /* (239) expr ::= expr STAR expr */ + 276, /* (240) expr ::= expr SLASH expr */ + 276, /* (241) expr ::= expr REM expr */ + 276, /* (242) expr ::= expr LIKE expr */ + 276, /* (243) expr ::= expr IN LP exprlist RP */ + 285, /* (244) exprlist ::= exprlist COMMA expritem */ + 285, /* (245) exprlist ::= expritem */ + 286, /* (246) expritem ::= expr */ + 286, /* (247) expritem ::= */ + 214, /* (248) cmd ::= RESET QUERY CACHE */ + 214, /* (249) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ + 214, /* (250) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ + 214, /* (251) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + 214, /* (252) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + 214, /* (253) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + 214, /* (254) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + 214, /* (255) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + 214, /* (256) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + 214, /* (257) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + 214, /* (258) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + 214, /* (259) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + 214, /* (260) cmd ::= KILL CONNECTION INTEGER */ + 214, /* (261) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + 214, /* (262) cmd ::= KILL QUERY INTEGER COLON INTEGER */ }; /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number @@ -2038,258 +2071,267 @@ static const YYCODETYPE yyRuleInfoLhs[] = { static const signed char yyRuleInfoNRhs[] = { -1, /* (0) program ::= cmd */ -2, /* (1) cmd ::= SHOW DATABASES */ - -2, /* (2) cmd ::= SHOW MNODES */ - -2, /* (3) cmd ::= SHOW DNODES */ - -2, /* (4) cmd ::= SHOW ACCOUNTS */ - -2, /* (5) cmd ::= SHOW USERS */ - -2, /* (6) cmd ::= SHOW MODULES */ - -2, /* (7) cmd ::= SHOW QUERIES */ - -2, /* (8) cmd ::= SHOW CONNECTIONS */ - -2, /* (9) cmd ::= SHOW STREAMS */ - -2, /* (10) cmd ::= SHOW VARIABLES */ - -2, /* (11) cmd ::= SHOW SCORES */ - -2, /* (12) cmd ::= SHOW GRANTS */ - -2, /* (13) cmd ::= SHOW VNODES */ - -3, /* (14) cmd ::= SHOW VNODES IPTOKEN */ - 0, /* (15) dbPrefix ::= */ - -2, /* (16) dbPrefix ::= ids DOT */ - 0, /* (17) cpxName ::= */ - -2, /* (18) cpxName ::= DOT ids */ - -5, /* (19) cmd ::= SHOW CREATE TABLE ids cpxName */ - -4, /* (20) cmd ::= SHOW CREATE DATABASE ids */ - -3, /* (21) cmd ::= SHOW dbPrefix TABLES */ - -5, /* (22) cmd ::= SHOW dbPrefix TABLES LIKE ids */ - -3, /* (23) cmd ::= SHOW dbPrefix STABLES */ - -5, /* (24) cmd ::= SHOW dbPrefix STABLES LIKE ids */ - -3, /* (25) cmd ::= SHOW dbPrefix VGROUPS */ - -4, /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */ - -5, /* (27) cmd ::= DROP TABLE ifexists ids cpxName */ - -5, /* (28) cmd ::= DROP STABLE ifexists ids cpxName */ - -4, /* (29) cmd ::= DROP DATABASE ifexists ids */ - -3, /* (30) cmd ::= DROP DNODE ids */ - -3, /* (31) cmd ::= DROP USER ids */ - -3, /* (32) cmd ::= DROP ACCOUNT ids */ - -2, /* (33) cmd ::= USE ids */ - -3, /* (34) cmd ::= DESCRIBE ids cpxName */ - -5, /* (35) cmd ::= ALTER USER ids PASS ids */ - -5, /* (36) cmd ::= ALTER USER ids PRIVILEGE ids */ - -4, /* (37) cmd ::= ALTER DNODE ids ids */ - -5, /* (38) cmd ::= ALTER DNODE ids ids ids */ - -3, /* (39) cmd ::= ALTER LOCAL ids */ - -4, /* (40) cmd ::= ALTER LOCAL ids ids */ - -4, /* (41) cmd ::= ALTER DATABASE ids alter_db_optr */ - -4, /* (42) cmd ::= ALTER ACCOUNT ids acct_optr */ - -6, /* (43) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ - -1, /* (44) ids ::= ID */ - -1, /* (45) ids ::= STRING */ - -2, /* (46) ifexists ::= IF EXISTS */ - 0, /* (47) ifexists ::= */ - -3, /* (48) ifnotexists ::= IF NOT EXISTS */ - 0, /* (49) ifnotexists ::= */ - -3, /* (50) cmd ::= CREATE DNODE ids */ - -6, /* (51) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ - -5, /* (52) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ - -5, /* (53) cmd ::= CREATE USER ids PASS ids */ - 0, /* (54) pps ::= */ - -2, /* (55) pps ::= PPS INTEGER */ - 0, /* (56) tseries ::= */ - -2, /* (57) tseries ::= TSERIES INTEGER */ - 0, /* (58) dbs ::= */ - -2, /* (59) dbs ::= DBS INTEGER */ - 0, /* (60) streams ::= */ - -2, /* (61) streams ::= STREAMS INTEGER */ - 0, /* (62) storage ::= */ - -2, /* (63) storage ::= STORAGE INTEGER */ - 0, /* (64) qtime ::= */ - -2, /* (65) qtime ::= QTIME INTEGER */ - 0, /* (66) users ::= */ - -2, /* (67) users ::= USERS INTEGER */ - 0, /* (68) conns ::= */ - -2, /* (69) conns ::= CONNS INTEGER */ - 0, /* (70) state ::= */ - -2, /* (71) state ::= STATE ids */ - -9, /* (72) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ - -2, /* (73) keep ::= KEEP tagitemlist */ - -2, /* (74) cache ::= CACHE INTEGER */ - -2, /* (75) replica ::= REPLICA INTEGER */ - -2, /* (76) quorum ::= QUORUM INTEGER */ - -2, /* (77) days ::= DAYS INTEGER */ - -2, /* (78) minrows ::= MINROWS INTEGER */ - -2, /* (79) maxrows ::= MAXROWS INTEGER */ - -2, /* (80) blocks ::= BLOCKS INTEGER */ - -2, /* (81) ctime ::= CTIME INTEGER */ - -2, /* (82) wal ::= WAL INTEGER */ - -2, /* (83) fsync ::= FSYNC INTEGER */ - -2, /* (84) comp ::= COMP INTEGER */ - -2, /* (85) prec ::= PRECISION STRING */ - -2, /* (86) update ::= UPDATE INTEGER */ - -2, /* (87) cachelast ::= CACHELAST INTEGER */ - 0, /* (88) db_optr ::= */ - -2, /* (89) db_optr ::= db_optr cache */ - -2, /* (90) db_optr ::= db_optr replica */ - -2, /* (91) db_optr ::= db_optr quorum */ - -2, /* (92) db_optr ::= db_optr days */ - -2, /* (93) db_optr ::= db_optr minrows */ - -2, /* (94) db_optr ::= db_optr maxrows */ - -2, /* (95) db_optr ::= db_optr blocks */ - -2, /* (96) db_optr ::= db_optr ctime */ - -2, /* (97) db_optr ::= db_optr wal */ - -2, /* (98) db_optr ::= db_optr fsync */ - -2, /* (99) db_optr ::= db_optr comp */ - -2, /* (100) db_optr ::= db_optr prec */ - -2, /* (101) db_optr ::= db_optr keep */ - -2, /* (102) db_optr ::= db_optr update */ - -2, /* (103) db_optr ::= db_optr cachelast */ - 0, /* (104) alter_db_optr ::= */ - -2, /* (105) alter_db_optr ::= alter_db_optr replica */ - -2, /* (106) alter_db_optr ::= alter_db_optr quorum */ - -2, /* (107) alter_db_optr ::= alter_db_optr keep */ - -2, /* (108) alter_db_optr ::= alter_db_optr blocks */ - -2, /* (109) alter_db_optr ::= alter_db_optr comp */ - -2, /* (110) alter_db_optr ::= alter_db_optr wal */ - -2, /* (111) alter_db_optr ::= alter_db_optr fsync */ - -2, /* (112) alter_db_optr ::= alter_db_optr update */ - -2, /* (113) alter_db_optr ::= alter_db_optr cachelast */ - -1, /* (114) typename ::= ids */ - -4, /* (115) typename ::= ids LP signed RP */ - -2, /* (116) typename ::= ids UNSIGNED */ - -1, /* (117) signed ::= INTEGER */ - -2, /* (118) signed ::= PLUS INTEGER */ - -2, /* (119) signed ::= MINUS INTEGER */ - -3, /* (120) cmd ::= CREATE TABLE create_table_args */ - -3, /* (121) cmd ::= CREATE TABLE create_stable_args */ - -3, /* (122) cmd ::= CREATE STABLE create_stable_args */ - -3, /* (123) cmd ::= CREATE TABLE create_table_list */ - -1, /* (124) create_table_list ::= create_from_stable */ - -2, /* (125) create_table_list ::= create_table_list create_from_stable */ - -6, /* (126) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ - -10, /* (127) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ - -10, /* (128) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ - -13, /* (129) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ - -3, /* (130) tagNamelist ::= tagNamelist COMMA ids */ - -1, /* (131) tagNamelist ::= ids */ - -5, /* (132) create_table_args ::= ifnotexists ids cpxName AS select */ - -3, /* (133) columnlist ::= columnlist COMMA column */ - -1, /* (134) columnlist ::= column */ - -2, /* (135) column ::= ids typename */ - -3, /* (136) tagitemlist ::= tagitemlist COMMA tagitem */ - -1, /* (137) tagitemlist ::= tagitem */ - -1, /* (138) tagitem ::= INTEGER */ - -1, /* (139) tagitem ::= FLOAT */ - -1, /* (140) tagitem ::= STRING */ - -1, /* (141) tagitem ::= BOOL */ - -1, /* (142) tagitem ::= NULL */ - -2, /* (143) tagitem ::= MINUS INTEGER */ - -2, /* (144) tagitem ::= MINUS FLOAT */ - -2, /* (145) tagitem ::= PLUS INTEGER */ - -2, /* (146) tagitem ::= PLUS FLOAT */ - -12, /* (147) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */ - -1, /* (148) union ::= select */ - -3, /* (149) union ::= LP union RP */ - -4, /* (150) union ::= union UNION ALL select */ - -6, /* (151) union ::= union UNION ALL LP select RP */ - -1, /* (152) cmd ::= union */ - -2, /* (153) select ::= SELECT selcollist */ - -2, /* (154) sclp ::= selcollist COMMA */ - 0, /* (155) sclp ::= */ - -4, /* (156) selcollist ::= sclp distinct expr as */ - -2, /* (157) selcollist ::= sclp STAR */ - -2, /* (158) as ::= AS ids */ - -1, /* (159) as ::= ids */ - 0, /* (160) as ::= */ - -1, /* (161) distinct ::= DISTINCT */ - 0, /* (162) distinct ::= */ - -2, /* (163) from ::= FROM tablelist */ - -2, /* (164) tablelist ::= ids cpxName */ - -3, /* (165) tablelist ::= ids cpxName ids */ - -4, /* (166) tablelist ::= tablelist COMMA ids cpxName */ - -5, /* (167) tablelist ::= tablelist COMMA ids cpxName ids */ - -1, /* (168) tmvar ::= VARIABLE */ - -4, /* (169) interval_opt ::= INTERVAL LP tmvar RP */ - -6, /* (170) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */ - 0, /* (171) interval_opt ::= */ - 0, /* (172) fill_opt ::= */ - -6, /* (173) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ - -4, /* (174) fill_opt ::= FILL LP ID RP */ - -4, /* (175) sliding_opt ::= SLIDING LP tmvar RP */ - 0, /* (176) sliding_opt ::= */ - 0, /* (177) orderby_opt ::= */ - -3, /* (178) orderby_opt ::= ORDER BY sortlist */ - -4, /* (179) sortlist ::= sortlist COMMA item sortorder */ - -2, /* (180) sortlist ::= item sortorder */ - -2, /* (181) item ::= ids cpxName */ - -1, /* (182) sortorder ::= ASC */ - -1, /* (183) sortorder ::= DESC */ - 0, /* (184) sortorder ::= */ - 0, /* (185) groupby_opt ::= */ - -3, /* (186) groupby_opt ::= GROUP BY grouplist */ - -3, /* (187) grouplist ::= grouplist COMMA item */ - -1, /* (188) grouplist ::= item */ - 0, /* (189) having_opt ::= */ - -2, /* (190) having_opt ::= HAVING expr */ - 0, /* (191) limit_opt ::= */ - -2, /* (192) limit_opt ::= LIMIT signed */ - -4, /* (193) limit_opt ::= LIMIT signed OFFSET signed */ - -4, /* (194) limit_opt ::= LIMIT signed COMMA signed */ - 0, /* (195) slimit_opt ::= */ - -2, /* (196) slimit_opt ::= SLIMIT signed */ - -4, /* (197) slimit_opt ::= SLIMIT signed SOFFSET signed */ - -4, /* (198) slimit_opt ::= SLIMIT signed COMMA signed */ - 0, /* (199) where_opt ::= */ - -2, /* (200) where_opt ::= WHERE expr */ - -3, /* (201) expr ::= LP expr RP */ - -1, /* (202) expr ::= ID */ - -3, /* (203) expr ::= ID DOT ID */ - -3, /* (204) expr ::= ID DOT STAR */ - -1, /* (205) expr ::= INTEGER */ - -2, /* (206) expr ::= MINUS INTEGER */ - -2, /* (207) expr ::= PLUS INTEGER */ - -1, /* (208) expr ::= FLOAT */ - -2, /* (209) expr ::= MINUS FLOAT */ - -2, /* (210) expr ::= PLUS FLOAT */ - -1, /* (211) expr ::= STRING */ - -1, /* (212) expr ::= NOW */ - -1, /* (213) expr ::= VARIABLE */ - -1, /* (214) expr ::= BOOL */ - -4, /* (215) expr ::= ID LP exprlist RP */ - -4, /* (216) expr ::= ID LP STAR RP */ - -3, /* (217) expr ::= expr IS NULL */ - -4, /* (218) expr ::= expr IS NOT NULL */ - -3, /* (219) expr ::= expr LT expr */ - -3, /* (220) expr ::= expr GT expr */ - -3, /* (221) expr ::= expr LE expr */ - -3, /* (222) expr ::= expr GE expr */ - -3, /* (223) expr ::= expr NE expr */ - -3, /* (224) expr ::= expr EQ expr */ - -5, /* (225) expr ::= expr BETWEEN expr AND expr */ - -3, /* (226) expr ::= expr AND expr */ - -3, /* (227) expr ::= expr OR expr */ - -3, /* (228) expr ::= expr PLUS expr */ - -3, /* (229) expr ::= expr MINUS expr */ - -3, /* (230) expr ::= expr STAR expr */ - -3, /* (231) expr ::= expr SLASH expr */ - -3, /* (232) expr ::= expr REM expr */ - -3, /* (233) expr ::= expr LIKE expr */ - -5, /* (234) expr ::= expr IN LP exprlist RP */ - -3, /* (235) exprlist ::= exprlist COMMA expritem */ - -1, /* (236) exprlist ::= expritem */ - -1, /* (237) expritem ::= expr */ - 0, /* (238) expritem ::= */ - -3, /* (239) cmd ::= RESET QUERY CACHE */ - -7, /* (240) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ - -7, /* (241) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ - -7, /* (242) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ - -7, /* (243) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ - -8, /* (244) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ - -9, /* (245) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ - -7, /* (246) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ - -7, /* (247) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ - -7, /* (248) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ - -7, /* (249) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ - -8, /* (250) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ - -3, /* (251) cmd ::= KILL CONNECTION INTEGER */ - -5, /* (252) cmd ::= KILL STREAM INTEGER COLON INTEGER */ - -5, /* (253) cmd ::= KILL QUERY INTEGER COLON INTEGER */ + -2, /* (2) cmd ::= SHOW TOPICS */ + -2, /* (3) cmd ::= SHOW MNODES */ + -2, /* (4) cmd ::= SHOW DNODES */ + -2, /* (5) cmd ::= SHOW ACCOUNTS */ + -2, /* (6) cmd ::= SHOW USERS */ + -2, /* (7) cmd ::= SHOW MODULES */ + -2, /* (8) cmd ::= SHOW QUERIES */ + -2, /* (9) cmd ::= SHOW CONNECTIONS */ + -2, /* (10) cmd ::= SHOW STREAMS */ + -2, /* (11) cmd ::= SHOW VARIABLES */ + -2, /* (12) cmd ::= SHOW SCORES */ + -2, /* (13) cmd ::= SHOW GRANTS */ + -2, /* (14) cmd ::= SHOW VNODES */ + -3, /* (15) cmd ::= SHOW VNODES IPTOKEN */ + 0, /* (16) dbPrefix ::= */ + -2, /* (17) dbPrefix ::= ids DOT */ + 0, /* (18) cpxName ::= */ + -2, /* (19) cpxName ::= DOT ids */ + -5, /* (20) cmd ::= SHOW CREATE TABLE ids cpxName */ + -4, /* (21) cmd ::= SHOW CREATE DATABASE ids */ + -3, /* (22) cmd ::= SHOW dbPrefix TABLES */ + -5, /* (23) cmd ::= SHOW dbPrefix TABLES LIKE ids */ + -3, /* (24) cmd ::= SHOW dbPrefix STABLES */ + -5, /* (25) cmd ::= SHOW dbPrefix STABLES LIKE ids */ + -3, /* (26) cmd ::= SHOW dbPrefix VGROUPS */ + -4, /* (27) cmd ::= SHOW dbPrefix VGROUPS ids */ + -5, /* (28) cmd ::= DROP TABLE ifexists ids cpxName */ + -5, /* (29) cmd ::= DROP STABLE ifexists ids cpxName */ + -4, /* (30) cmd ::= DROP DATABASE ifexists ids */ + -4, /* (31) cmd ::= DROP TOPIC ifexists ids */ + -3, /* (32) cmd ::= DROP DNODE ids */ + -3, /* (33) cmd ::= DROP USER ids */ + -3, /* (34) cmd ::= DROP ACCOUNT ids */ + -2, /* (35) cmd ::= USE ids */ + -3, /* (36) cmd ::= DESCRIBE ids cpxName */ + -5, /* (37) cmd ::= ALTER USER ids PASS ids */ + -5, /* (38) cmd ::= ALTER USER ids PRIVILEGE ids */ + -4, /* (39) cmd ::= ALTER DNODE ids ids */ + -5, /* (40) cmd ::= ALTER DNODE ids ids ids */ + -3, /* (41) cmd ::= ALTER LOCAL ids */ + -4, /* (42) cmd ::= ALTER LOCAL ids ids */ + -4, /* (43) cmd ::= ALTER DATABASE ids alter_db_optr */ + -4, /* (44) cmd ::= ALTER TOPIC ids alter_topic_optr */ + -4, /* (45) cmd ::= ALTER ACCOUNT ids acct_optr */ + -6, /* (46) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ + -1, /* (47) ids ::= ID */ + -1, /* (48) ids ::= STRING */ + -2, /* (49) ifexists ::= IF EXISTS */ + 0, /* (50) ifexists ::= */ + -3, /* (51) ifnotexists ::= IF NOT EXISTS */ + 0, /* (52) ifnotexists ::= */ + -3, /* (53) cmd ::= CREATE DNODE ids */ + -6, /* (54) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ + -5, /* (55) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ + -5, /* (56) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ + -5, /* (57) cmd ::= CREATE USER ids PASS ids */ + 0, /* (58) pps ::= */ + -2, /* (59) pps ::= PPS INTEGER */ + 0, /* (60) tseries ::= */ + -2, /* (61) tseries ::= TSERIES INTEGER */ + 0, /* (62) dbs ::= */ + -2, /* (63) dbs ::= DBS INTEGER */ + 0, /* (64) streams ::= */ + -2, /* (65) streams ::= STREAMS INTEGER */ + 0, /* (66) storage ::= */ + -2, /* (67) storage ::= STORAGE INTEGER */ + 0, /* (68) qtime ::= */ + -2, /* (69) qtime ::= QTIME INTEGER */ + 0, /* (70) users ::= */ + -2, /* (71) users ::= USERS INTEGER */ + 0, /* (72) conns ::= */ + -2, /* (73) conns ::= CONNS INTEGER */ + 0, /* (74) state ::= */ + -2, /* (75) state ::= STATE ids */ + -9, /* (76) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ + -2, /* (77) keep ::= KEEP tagitemlist */ + -2, /* (78) cache ::= CACHE INTEGER */ + -2, /* (79) replica ::= REPLICA INTEGER */ + -2, /* (80) quorum ::= QUORUM INTEGER */ + -2, /* (81) days ::= DAYS INTEGER */ + -2, /* (82) minrows ::= MINROWS INTEGER */ + -2, /* (83) maxrows ::= MAXROWS INTEGER */ + -2, /* (84) blocks ::= BLOCKS INTEGER */ + -2, /* (85) ctime ::= CTIME INTEGER */ + -2, /* (86) wal ::= WAL INTEGER */ + -2, /* (87) fsync ::= FSYNC INTEGER */ + -2, /* (88) comp ::= COMP INTEGER */ + -2, /* (89) prec ::= PRECISION STRING */ + -2, /* (90) update ::= UPDATE INTEGER */ + -2, /* (91) cachelast ::= CACHELAST INTEGER */ + -2, /* (92) partitions ::= PARTITIONS INTEGER */ + 0, /* (93) db_optr ::= */ + -2, /* (94) db_optr ::= db_optr cache */ + -2, /* (95) db_optr ::= db_optr replica */ + -2, /* (96) db_optr ::= db_optr quorum */ + -2, /* (97) db_optr ::= db_optr days */ + -2, /* (98) db_optr ::= db_optr minrows */ + -2, /* (99) db_optr ::= db_optr maxrows */ + -2, /* (100) db_optr ::= db_optr blocks */ + -2, /* (101) db_optr ::= db_optr ctime */ + -2, /* (102) db_optr ::= db_optr wal */ + -2, /* (103) db_optr ::= db_optr fsync */ + -2, /* (104) db_optr ::= db_optr comp */ + -2, /* (105) db_optr ::= db_optr prec */ + -2, /* (106) db_optr ::= db_optr keep */ + -2, /* (107) db_optr ::= db_optr update */ + -2, /* (108) db_optr ::= db_optr cachelast */ + -1, /* (109) topic_optr ::= db_optr */ + -2, /* (110) topic_optr ::= topic_optr partitions */ + 0, /* (111) alter_db_optr ::= */ + -2, /* (112) alter_db_optr ::= alter_db_optr replica */ + -2, /* (113) alter_db_optr ::= alter_db_optr quorum */ + -2, /* (114) alter_db_optr ::= alter_db_optr keep */ + -2, /* (115) alter_db_optr ::= alter_db_optr blocks */ + -2, /* (116) alter_db_optr ::= alter_db_optr comp */ + -2, /* (117) alter_db_optr ::= alter_db_optr wal */ + -2, /* (118) alter_db_optr ::= alter_db_optr fsync */ + -2, /* (119) alter_db_optr ::= alter_db_optr update */ + -2, /* (120) alter_db_optr ::= alter_db_optr cachelast */ + -1, /* (121) alter_topic_optr ::= alter_db_optr */ + -2, /* (122) alter_topic_optr ::= alter_topic_optr partitions */ + -1, /* (123) typename ::= ids */ + -4, /* (124) typename ::= ids LP signed RP */ + -2, /* (125) typename ::= ids UNSIGNED */ + -1, /* (126) signed ::= INTEGER */ + -2, /* (127) signed ::= PLUS INTEGER */ + -2, /* (128) signed ::= MINUS INTEGER */ + -3, /* (129) cmd ::= CREATE TABLE create_table_args */ + -3, /* (130) cmd ::= CREATE TABLE create_stable_args */ + -3, /* (131) cmd ::= CREATE STABLE create_stable_args */ + -3, /* (132) cmd ::= CREATE TABLE create_table_list */ + -1, /* (133) create_table_list ::= create_from_stable */ + -2, /* (134) create_table_list ::= create_table_list create_from_stable */ + -6, /* (135) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ + -10, /* (136) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ + -10, /* (137) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ + -13, /* (138) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ + -3, /* (139) tagNamelist ::= tagNamelist COMMA ids */ + -1, /* (140) tagNamelist ::= ids */ + -5, /* (141) create_table_args ::= ifnotexists ids cpxName AS select */ + -3, /* (142) columnlist ::= columnlist COMMA column */ + -1, /* (143) columnlist ::= column */ + -2, /* (144) column ::= ids typename */ + -3, /* (145) tagitemlist ::= tagitemlist COMMA tagitem */ + -1, /* (146) tagitemlist ::= tagitem */ + -1, /* (147) tagitem ::= INTEGER */ + -1, /* (148) tagitem ::= FLOAT */ + -1, /* (149) tagitem ::= STRING */ + -1, /* (150) tagitem ::= BOOL */ + -1, /* (151) tagitem ::= NULL */ + -2, /* (152) tagitem ::= MINUS INTEGER */ + -2, /* (153) tagitem ::= MINUS FLOAT */ + -2, /* (154) tagitem ::= PLUS INTEGER */ + -2, /* (155) tagitem ::= PLUS FLOAT */ + -12, /* (156) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */ + -1, /* (157) union ::= select */ + -3, /* (158) union ::= LP union RP */ + -4, /* (159) union ::= union UNION ALL select */ + -6, /* (160) union ::= union UNION ALL LP select RP */ + -1, /* (161) cmd ::= union */ + -2, /* (162) select ::= SELECT selcollist */ + -2, /* (163) sclp ::= selcollist COMMA */ + 0, /* (164) sclp ::= */ + -4, /* (165) selcollist ::= sclp distinct expr as */ + -2, /* (166) selcollist ::= sclp STAR */ + -2, /* (167) as ::= AS ids */ + -1, /* (168) as ::= ids */ + 0, /* (169) as ::= */ + -1, /* (170) distinct ::= DISTINCT */ + 0, /* (171) distinct ::= */ + -2, /* (172) from ::= FROM tablelist */ + -2, /* (173) tablelist ::= ids cpxName */ + -3, /* (174) tablelist ::= ids cpxName ids */ + -4, /* (175) tablelist ::= tablelist COMMA ids cpxName */ + -5, /* (176) tablelist ::= tablelist COMMA ids cpxName ids */ + -1, /* (177) tmvar ::= VARIABLE */ + -4, /* (178) interval_opt ::= INTERVAL LP tmvar RP */ + -6, /* (179) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */ + 0, /* (180) interval_opt ::= */ + 0, /* (181) fill_opt ::= */ + -6, /* (182) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ + -4, /* (183) fill_opt ::= FILL LP ID RP */ + -4, /* (184) sliding_opt ::= SLIDING LP tmvar RP */ + 0, /* (185) sliding_opt ::= */ + 0, /* (186) orderby_opt ::= */ + -3, /* (187) orderby_opt ::= ORDER BY sortlist */ + -4, /* (188) sortlist ::= sortlist COMMA item sortorder */ + -2, /* (189) sortlist ::= item sortorder */ + -2, /* (190) item ::= ids cpxName */ + -1, /* (191) sortorder ::= ASC */ + -1, /* (192) sortorder ::= DESC */ + 0, /* (193) sortorder ::= */ + 0, /* (194) groupby_opt ::= */ + -3, /* (195) groupby_opt ::= GROUP BY grouplist */ + -3, /* (196) grouplist ::= grouplist COMMA item */ + -1, /* (197) grouplist ::= item */ + 0, /* (198) having_opt ::= */ + -2, /* (199) having_opt ::= HAVING expr */ + 0, /* (200) limit_opt ::= */ + -2, /* (201) limit_opt ::= LIMIT signed */ + -4, /* (202) limit_opt ::= LIMIT signed OFFSET signed */ + -4, /* (203) limit_opt ::= LIMIT signed COMMA signed */ + 0, /* (204) slimit_opt ::= */ + -2, /* (205) slimit_opt ::= SLIMIT signed */ + -4, /* (206) slimit_opt ::= SLIMIT signed SOFFSET signed */ + -4, /* (207) slimit_opt ::= SLIMIT signed COMMA signed */ + 0, /* (208) where_opt ::= */ + -2, /* (209) where_opt ::= WHERE expr */ + -3, /* (210) expr ::= LP expr RP */ + -1, /* (211) expr ::= ID */ + -3, /* (212) expr ::= ID DOT ID */ + -3, /* (213) expr ::= ID DOT STAR */ + -1, /* (214) expr ::= INTEGER */ + -2, /* (215) expr ::= MINUS INTEGER */ + -2, /* (216) expr ::= PLUS INTEGER */ + -1, /* (217) expr ::= FLOAT */ + -2, /* (218) expr ::= MINUS FLOAT */ + -2, /* (219) expr ::= PLUS FLOAT */ + -1, /* (220) expr ::= STRING */ + -1, /* (221) expr ::= NOW */ + -1, /* (222) expr ::= VARIABLE */ + -1, /* (223) expr ::= BOOL */ + -4, /* (224) expr ::= ID LP exprlist RP */ + -4, /* (225) expr ::= ID LP STAR RP */ + -3, /* (226) expr ::= expr IS NULL */ + -4, /* (227) expr ::= expr IS NOT NULL */ + -3, /* (228) expr ::= expr LT expr */ + -3, /* (229) expr ::= expr GT expr */ + -3, /* (230) expr ::= expr LE expr */ + -3, /* (231) expr ::= expr GE expr */ + -3, /* (232) expr ::= expr NE expr */ + -3, /* (233) expr ::= expr EQ expr */ + -5, /* (234) expr ::= expr BETWEEN expr AND expr */ + -3, /* (235) expr ::= expr AND expr */ + -3, /* (236) expr ::= expr OR expr */ + -3, /* (237) expr ::= expr PLUS expr */ + -3, /* (238) expr ::= expr MINUS expr */ + -3, /* (239) expr ::= expr STAR expr */ + -3, /* (240) expr ::= expr SLASH expr */ + -3, /* (241) expr ::= expr REM expr */ + -3, /* (242) expr ::= expr LIKE expr */ + -5, /* (243) expr ::= expr IN LP exprlist RP */ + -3, /* (244) exprlist ::= exprlist COMMA expritem */ + -1, /* (245) exprlist ::= expritem */ + -1, /* (246) expritem ::= expr */ + 0, /* (247) expritem ::= */ + -3, /* (248) cmd ::= RESET QUERY CACHE */ + -7, /* (249) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ + -7, /* (250) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ + -7, /* (251) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + -7, /* (252) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + -8, /* (253) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + -9, /* (254) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + -7, /* (255) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + -7, /* (256) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + -7, /* (257) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + -7, /* (258) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + -8, /* (259) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + -3, /* (260) cmd ::= KILL CONNECTION INTEGER */ + -5, /* (261) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + -5, /* (262) cmd ::= KILL QUERY INTEGER COLON INTEGER */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -2380,867 +2422,886 @@ static YYACTIONTYPE yy_reduce( /********** Begin reduce actions **********************************************/ YYMINORTYPE yylhsminor; case 0: /* program ::= cmd */ - case 120: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==120); - case 121: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==121); - case 122: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==122); + case 129: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==129); + case 130: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==130); + case 131: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==131); {} break; case 1: /* cmd ::= SHOW DATABASES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_DB, 0, 0);} break; - case 2: /* cmd ::= SHOW MNODES */ + case 2: /* cmd ::= SHOW TOPICS */ +{ setShowOptions(pInfo, TSDB_MGMT_TABLE_TP, 0, 0);} + break; + case 3: /* cmd ::= SHOW MNODES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_MNODE, 0, 0);} break; - case 3: /* cmd ::= SHOW DNODES */ + case 4: /* cmd ::= SHOW DNODES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_DNODE, 0, 0);} break; - case 4: /* cmd ::= SHOW ACCOUNTS */ + case 5: /* cmd ::= SHOW ACCOUNTS */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_ACCT, 0, 0);} break; - case 5: /* cmd ::= SHOW USERS */ + case 6: /* cmd ::= SHOW USERS */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_USER, 0, 0);} break; - case 6: /* cmd ::= SHOW MODULES */ + case 7: /* cmd ::= SHOW MODULES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_MODULE, 0, 0); } break; - case 7: /* cmd ::= SHOW QUERIES */ + case 8: /* cmd ::= SHOW QUERIES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_QUERIES, 0, 0); } break; - case 8: /* cmd ::= SHOW CONNECTIONS */ + case 9: /* cmd ::= SHOW CONNECTIONS */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_CONNS, 0, 0);} break; - case 9: /* cmd ::= SHOW STREAMS */ + case 10: /* cmd ::= SHOW STREAMS */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_STREAMS, 0, 0); } break; - case 10: /* cmd ::= SHOW VARIABLES */ + case 11: /* cmd ::= SHOW VARIABLES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_VARIABLES, 0, 0); } break; - case 11: /* cmd ::= SHOW SCORES */ + case 12: /* cmd ::= SHOW SCORES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_SCORES, 0, 0); } break; - case 12: /* cmd ::= SHOW GRANTS */ + case 13: /* cmd ::= SHOW GRANTS */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_GRANTS, 0, 0); } break; - case 13: /* cmd ::= SHOW VNODES */ + case 14: /* cmd ::= SHOW VNODES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, 0, 0); } break; - case 14: /* cmd ::= SHOW VNODES IPTOKEN */ + case 15: /* cmd ::= SHOW VNODES IPTOKEN */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, &yymsp[0].minor.yy0, 0); } break; - case 15: /* dbPrefix ::= */ + case 16: /* dbPrefix ::= */ {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.type = 0;} break; - case 16: /* dbPrefix ::= ids DOT */ + case 17: /* dbPrefix ::= ids DOT */ {yylhsminor.yy0 = yymsp[-1].minor.yy0; } yymsp[-1].minor.yy0 = yylhsminor.yy0; break; - case 17: /* cpxName ::= */ + case 18: /* cpxName ::= */ {yymsp[1].minor.yy0.n = 0; } break; - case 18: /* cpxName ::= DOT ids */ + case 19: /* cpxName ::= DOT ids */ {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n += 1; } break; - case 19: /* cmd ::= SHOW CREATE TABLE ids cpxName */ + case 20: /* cmd ::= SHOW CREATE TABLE ids cpxName */ { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; setDCLSQLElems(pInfo, TSDB_SQL_SHOW_CREATE_TABLE, 1, &yymsp[-1].minor.yy0); } break; - case 20: /* cmd ::= SHOW CREATE DATABASE ids */ + case 21: /* cmd ::= SHOW CREATE DATABASE ids */ { setDCLSQLElems(pInfo, TSDB_SQL_SHOW_CREATE_DATABASE, 1, &yymsp[0].minor.yy0); } break; - case 21: /* cmd ::= SHOW dbPrefix TABLES */ + case 22: /* cmd ::= SHOW dbPrefix TABLES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-1].minor.yy0, 0); } break; - case 22: /* cmd ::= SHOW dbPrefix TABLES LIKE ids */ + case 23: /* cmd ::= SHOW dbPrefix TABLES LIKE ids */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0); } break; - case 23: /* cmd ::= SHOW dbPrefix STABLES */ + case 24: /* cmd ::= SHOW dbPrefix STABLES */ { setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &yymsp[-1].minor.yy0, 0); } break; - case 24: /* cmd ::= SHOW dbPrefix STABLES LIKE ids */ + case 25: /* cmd ::= SHOW dbPrefix STABLES LIKE ids */ { SStrToken token; setDbName(&token, &yymsp[-3].minor.yy0); setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &token, &yymsp[0].minor.yy0); } break; - case 25: /* cmd ::= SHOW dbPrefix VGROUPS */ + case 26: /* cmd ::= SHOW dbPrefix VGROUPS */ { SStrToken token; setDbName(&token, &yymsp[-1].minor.yy0); setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, 0); } break; - case 26: /* cmd ::= SHOW dbPrefix VGROUPS ids */ + case 27: /* cmd ::= SHOW dbPrefix VGROUPS ids */ { SStrToken token; setDbName(&token, &yymsp[-2].minor.yy0); setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, &yymsp[0].minor.yy0); } break; - case 27: /* cmd ::= DROP TABLE ifexists ids cpxName */ + case 28: /* cmd ::= DROP TABLE ifexists ids cpxName */ { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, -1); + setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, -1, -1); } break; - case 28: /* cmd ::= DROP STABLE ifexists ids cpxName */ + case 29: /* cmd ::= DROP STABLE ifexists ids cpxName */ { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, TSDB_SUPER_TABLE); + setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, -1, TSDB_SUPER_TABLE); } break; - case 29: /* cmd ::= DROP DATABASE ifexists ids */ -{ setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0, -1); } + case 30: /* cmd ::= DROP DATABASE ifexists ids */ +{ setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0, TSDB_DB_TYPE_DEFAULT, -1); } break; - case 30: /* cmd ::= DROP DNODE ids */ + case 31: /* cmd ::= DROP TOPIC ifexists ids */ +{ setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0, TSDB_DB_TYPE_TOPIC, -1); } + break; + case 32: /* cmd ::= DROP DNODE ids */ { setDCLSQLElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &yymsp[0].minor.yy0); } break; - case 31: /* cmd ::= DROP USER ids */ + case 33: /* cmd ::= DROP USER ids */ { setDCLSQLElems(pInfo, TSDB_SQL_DROP_USER, 1, &yymsp[0].minor.yy0); } break; - case 32: /* cmd ::= DROP ACCOUNT ids */ + case 34: /* cmd ::= DROP ACCOUNT ids */ { setDCLSQLElems(pInfo, TSDB_SQL_DROP_ACCT, 1, &yymsp[0].minor.yy0); } break; - case 33: /* cmd ::= USE ids */ + case 35: /* cmd ::= USE ids */ { setDCLSQLElems(pInfo, TSDB_SQL_USE_DB, 1, &yymsp[0].minor.yy0);} break; - case 34: /* cmd ::= DESCRIBE ids cpxName */ + case 36: /* cmd ::= DESCRIBE ids cpxName */ { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; setDCLSQLElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &yymsp[-1].minor.yy0); } break; - case 35: /* cmd ::= ALTER USER ids PASS ids */ + case 37: /* cmd ::= ALTER USER ids PASS ids */ { setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, NULL); } break; - case 36: /* cmd ::= ALTER USER ids PRIVILEGE ids */ + case 38: /* cmd ::= ALTER USER ids PRIVILEGE ids */ { setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &yymsp[-2].minor.yy0, NULL, &yymsp[0].minor.yy0);} break; - case 37: /* cmd ::= ALTER DNODE ids ids */ + case 39: /* cmd ::= ALTER DNODE ids ids */ { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; - case 38: /* cmd ::= ALTER DNODE ids ids ids */ + case 40: /* cmd ::= ALTER DNODE ids ids ids */ { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 3, &yymsp[-2].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; - case 39: /* cmd ::= ALTER LOCAL ids */ + case 41: /* cmd ::= ALTER LOCAL ids */ { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &yymsp[0].minor.yy0); } break; - case 40: /* cmd ::= ALTER LOCAL ids ids */ + case 42: /* cmd ::= ALTER LOCAL ids ids */ { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; - case 41: /* cmd ::= ALTER DATABASE ids alter_db_optr */ -{ SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy262, &t);} + case 43: /* cmd ::= ALTER DATABASE ids alter_db_optr */ + case 44: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==44); +{ SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy100, &t);} break; - case 42: /* cmd ::= ALTER ACCOUNT ids acct_optr */ -{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy47);} + case 45: /* cmd ::= ALTER ACCOUNT ids acct_optr */ +{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy505);} break; - case 43: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ -{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy47);} + case 46: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ +{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy505);} break; - case 44: /* ids ::= ID */ - case 45: /* ids ::= STRING */ yytestcase(yyruleno==45); + case 47: /* ids ::= ID */ + case 48: /* ids ::= STRING */ yytestcase(yyruleno==48); {yylhsminor.yy0 = yymsp[0].minor.yy0; } yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 46: /* ifexists ::= IF EXISTS */ + case 49: /* ifexists ::= IF EXISTS */ { yymsp[-1].minor.yy0.n = 1;} break; - case 47: /* ifexists ::= */ - case 49: /* ifnotexists ::= */ yytestcase(yyruleno==49); - case 162: /* distinct ::= */ yytestcase(yyruleno==162); + case 50: /* ifexists ::= */ + case 52: /* ifnotexists ::= */ yytestcase(yyruleno==52); + case 171: /* distinct ::= */ yytestcase(yyruleno==171); { yymsp[1].minor.yy0.n = 0;} break; - case 48: /* ifnotexists ::= IF NOT EXISTS */ + case 51: /* ifnotexists ::= IF NOT EXISTS */ { yymsp[-2].minor.yy0.n = 1;} break; - case 50: /* cmd ::= CREATE DNODE ids */ + case 53: /* cmd ::= CREATE DNODE ids */ { setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);} break; - case 51: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ -{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy47);} + case 54: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ +{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy505);} break; - case 52: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */ -{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy262, &yymsp[-2].minor.yy0);} + case 55: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */ + case 56: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==56); +{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy100, &yymsp[-2].minor.yy0);} break; - case 53: /* cmd ::= CREATE USER ids PASS ids */ + case 57: /* cmd ::= CREATE USER ids PASS ids */ { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);} break; - case 54: /* pps ::= */ - case 56: /* tseries ::= */ yytestcase(yyruleno==56); - case 58: /* dbs ::= */ yytestcase(yyruleno==58); - case 60: /* streams ::= */ yytestcase(yyruleno==60); - case 62: /* storage ::= */ yytestcase(yyruleno==62); - case 64: /* qtime ::= */ yytestcase(yyruleno==64); - case 66: /* users ::= */ yytestcase(yyruleno==66); - case 68: /* conns ::= */ yytestcase(yyruleno==68); - case 70: /* state ::= */ yytestcase(yyruleno==70); + case 58: /* pps ::= */ + case 60: /* tseries ::= */ yytestcase(yyruleno==60); + case 62: /* dbs ::= */ yytestcase(yyruleno==62); + case 64: /* streams ::= */ yytestcase(yyruleno==64); + case 66: /* storage ::= */ yytestcase(yyruleno==66); + case 68: /* qtime ::= */ yytestcase(yyruleno==68); + case 70: /* users ::= */ yytestcase(yyruleno==70); + case 72: /* conns ::= */ yytestcase(yyruleno==72); + case 74: /* state ::= */ yytestcase(yyruleno==74); { yymsp[1].minor.yy0.n = 0; } break; - case 55: /* pps ::= PPS INTEGER */ - case 57: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==57); - case 59: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==59); - case 61: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==61); - case 63: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==63); - case 65: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==65); - case 67: /* users ::= USERS INTEGER */ yytestcase(yyruleno==67); - case 69: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==69); - case 71: /* state ::= STATE ids */ yytestcase(yyruleno==71); + case 59: /* pps ::= PPS INTEGER */ + case 61: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==61); + case 63: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==63); + case 65: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==65); + case 67: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==67); + case 69: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==69); + case 71: /* users ::= USERS INTEGER */ yytestcase(yyruleno==71); + case 73: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==73); + case 75: /* state ::= STATE ids */ yytestcase(yyruleno==75); { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } break; - case 72: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */ + case 76: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */ { - yylhsminor.yy47.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1; - yylhsminor.yy47.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1; - yylhsminor.yy47.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1; - yylhsminor.yy47.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1; - yylhsminor.yy47.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1; - yylhsminor.yy47.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1; - yylhsminor.yy47.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1; - yylhsminor.yy47.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1; - yylhsminor.yy47.stat = yymsp[0].minor.yy0; + yylhsminor.yy505.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1; + yylhsminor.yy505.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1; + yylhsminor.yy505.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1; + yylhsminor.yy505.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1; + yylhsminor.yy505.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1; + yylhsminor.yy505.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1; + yylhsminor.yy505.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1; + yylhsminor.yy505.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1; + yylhsminor.yy505.stat = yymsp[0].minor.yy0; } - yymsp[-8].minor.yy47 = yylhsminor.yy47; + yymsp[-8].minor.yy505 = yylhsminor.yy505; break; - case 73: /* keep ::= KEEP tagitemlist */ -{ yymsp[-1].minor.yy247 = yymsp[0].minor.yy247; } + case 77: /* keep ::= KEEP tagitemlist */ +{ yymsp[-1].minor.yy207 = yymsp[0].minor.yy207; } break; - case 74: /* cache ::= CACHE INTEGER */ - case 75: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==75); - case 76: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==76); - case 77: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==77); - case 78: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==78); - case 79: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==79); - case 80: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==80); - case 81: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==81); - case 82: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==82); - case 83: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==83); - case 84: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==84); - case 85: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==85); - case 86: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==86); - case 87: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==87); + case 78: /* cache ::= CACHE INTEGER */ + case 79: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==79); + case 80: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==80); + case 81: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==81); + case 82: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==82); + case 83: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==83); + case 84: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==84); + case 85: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==85); + case 86: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==86); + case 87: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==87); + case 88: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==88); + case 89: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==89); + case 90: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==90); + case 91: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==91); + case 92: /* partitions ::= PARTITIONS INTEGER */ yytestcase(yyruleno==92); { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } break; - case 88: /* db_optr ::= */ -{setDefaultCreateDbOption(&yymsp[1].minor.yy262);} + case 93: /* db_optr ::= */ +{setDefaultCreateDbOption(&yymsp[1].minor.yy100); yymsp[1].minor.yy100.dbType = TSDB_DB_TYPE_DEFAULT;} break; - case 89: /* db_optr ::= db_optr cache */ -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 94: /* db_optr ::= db_optr cache */ +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 90: /* db_optr ::= db_optr replica */ - case 105: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==105); -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 95: /* db_optr ::= db_optr replica */ + case 112: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==112); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 91: /* db_optr ::= db_optr quorum */ - case 106: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==106); -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 96: /* db_optr ::= db_optr quorum */ + case 113: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==113); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 92: /* db_optr ::= db_optr days */ -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 97: /* db_optr ::= db_optr days */ +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 93: /* db_optr ::= db_optr minrows */ -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 98: /* db_optr ::= db_optr minrows */ +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 94: /* db_optr ::= db_optr maxrows */ -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 99: /* db_optr ::= db_optr maxrows */ +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 95: /* db_optr ::= db_optr blocks */ - case 108: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==108); -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 100: /* db_optr ::= db_optr blocks */ + case 115: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==115); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 96: /* db_optr ::= db_optr ctime */ -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 101: /* db_optr ::= db_optr ctime */ +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 97: /* db_optr ::= db_optr wal */ - case 110: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==110); -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 102: /* db_optr ::= db_optr wal */ + case 117: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==117); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 98: /* db_optr ::= db_optr fsync */ - case 111: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==111); -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 103: /* db_optr ::= db_optr fsync */ + case 118: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==118); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 99: /* db_optr ::= db_optr comp */ - case 109: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==109); -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 104: /* db_optr ::= db_optr comp */ + case 116: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==116); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 100: /* db_optr ::= db_optr prec */ -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.precision = yymsp[0].minor.yy0; } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 105: /* db_optr ::= db_optr prec */ +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.precision = yymsp[0].minor.yy0; } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 101: /* db_optr ::= db_optr keep */ - case 107: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==107); -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.keep = yymsp[0].minor.yy247; } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 106: /* db_optr ::= db_optr keep */ + case 114: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==114); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.keep = yymsp[0].minor.yy207; } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 102: /* db_optr ::= db_optr update */ - case 112: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==112); -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 107: /* db_optr ::= db_optr update */ + case 119: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==119); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 103: /* db_optr ::= db_optr cachelast */ - case 113: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==113); -{ yylhsminor.yy262 = yymsp[-1].minor.yy262; yylhsminor.yy262.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy262 = yylhsminor.yy262; + case 108: /* db_optr ::= db_optr cachelast */ + case 120: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==120); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; break; - case 104: /* alter_db_optr ::= */ -{ setDefaultCreateDbOption(&yymsp[1].minor.yy262);} + case 109: /* topic_optr ::= db_optr */ + case 121: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==121); +{ yylhsminor.yy100 = yymsp[0].minor.yy100; yylhsminor.yy100.dbType = TSDB_DB_TYPE_TOPIC; } + yymsp[0].minor.yy100 = yylhsminor.yy100; break; - case 114: /* typename ::= ids */ + case 110: /* topic_optr ::= topic_optr partitions */ + case 122: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==122); +{ yylhsminor.yy100 = yymsp[-1].minor.yy100; yylhsminor.yy100.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy100 = yylhsminor.yy100; + break; + case 111: /* alter_db_optr ::= */ +{ setDefaultCreateDbOption(&yymsp[1].minor.yy100); yymsp[1].minor.yy100.dbType = TSDB_DB_TYPE_DEFAULT;} + break; + case 123: /* typename ::= ids */ { yymsp[0].minor.yy0.type = 0; - tSqlSetColumnType (&yylhsminor.yy179, &yymsp[0].minor.yy0); + tSqlSetColumnType (&yylhsminor.yy517, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy179 = yylhsminor.yy179; + yymsp[0].minor.yy517 = yylhsminor.yy517; break; - case 115: /* typename ::= ids LP signed RP */ + case 124: /* typename ::= ids LP signed RP */ { - if (yymsp[-1].minor.yy403 <= 0) { + if (yymsp[-1].minor.yy208 <= 0) { yymsp[-3].minor.yy0.type = 0; - tSqlSetColumnType(&yylhsminor.yy179, &yymsp[-3].minor.yy0); + tSqlSetColumnType(&yylhsminor.yy517, &yymsp[-3].minor.yy0); } else { - yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy403; // negative value of name length - tSqlSetColumnType(&yylhsminor.yy179, &yymsp[-3].minor.yy0); + yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy208; // negative value of name length + tSqlSetColumnType(&yylhsminor.yy517, &yymsp[-3].minor.yy0); } } - yymsp[-3].minor.yy179 = yylhsminor.yy179; + yymsp[-3].minor.yy517 = yylhsminor.yy517; break; - case 116: /* typename ::= ids UNSIGNED */ + case 125: /* typename ::= ids UNSIGNED */ { yymsp[-1].minor.yy0.type = 0; yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z); - tSqlSetColumnType (&yylhsminor.yy179, &yymsp[-1].minor.yy0); + tSqlSetColumnType (&yylhsminor.yy517, &yymsp[-1].minor.yy0); } - yymsp[-1].minor.yy179 = yylhsminor.yy179; + yymsp[-1].minor.yy517 = yylhsminor.yy517; break; - case 117: /* signed ::= INTEGER */ -{ yylhsminor.yy403 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[0].minor.yy403 = yylhsminor.yy403; + case 126: /* signed ::= INTEGER */ +{ yylhsminor.yy208 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[0].minor.yy208 = yylhsminor.yy208; break; - case 118: /* signed ::= PLUS INTEGER */ -{ yymsp[-1].minor.yy403 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + case 127: /* signed ::= PLUS INTEGER */ +{ yymsp[-1].minor.yy208 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } break; - case 119: /* signed ::= MINUS INTEGER */ -{ yymsp[-1].minor.yy403 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);} + case 128: /* signed ::= MINUS INTEGER */ +{ yymsp[-1].minor.yy208 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);} break; - case 123: /* cmd ::= CREATE TABLE create_table_list */ -{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy358;} + case 132: /* cmd ::= CREATE TABLE create_table_list */ +{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy414;} break; - case 124: /* create_table_list ::= create_from_stable */ + case 133: /* create_table_list ::= create_from_stable */ { SCreateTableSQL* pCreateTable = calloc(1, sizeof(SCreateTableSQL)); pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo)); - taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy42); + taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy542); pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE; - yylhsminor.yy358 = pCreateTable; + yylhsminor.yy414 = pCreateTable; } - yymsp[0].minor.yy358 = yylhsminor.yy358; + yymsp[0].minor.yy414 = yylhsminor.yy414; break; - case 125: /* create_table_list ::= create_table_list create_from_stable */ + case 134: /* create_table_list ::= create_table_list create_from_stable */ { - taosArrayPush(yymsp[-1].minor.yy358->childTableInfo, &yymsp[0].minor.yy42); - yylhsminor.yy358 = yymsp[-1].minor.yy358; + taosArrayPush(yymsp[-1].minor.yy414->childTableInfo, &yymsp[0].minor.yy542); + yylhsminor.yy414 = yymsp[-1].minor.yy414; } - yymsp[-1].minor.yy358 = yylhsminor.yy358; + yymsp[-1].minor.yy414 = yylhsminor.yy414; break; - case 126: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ + case 135: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ { - yylhsminor.yy358 = tSetCreateSqlElems(yymsp[-1].minor.yy247, NULL, NULL, TSQL_CREATE_TABLE); - setSqlInfo(pInfo, yylhsminor.yy358, NULL, TSDB_SQL_CREATE_TABLE); + yylhsminor.yy414 = tSetCreateSqlElems(yymsp[-1].minor.yy207, NULL, NULL, TSQL_CREATE_TABLE); + setSqlInfo(pInfo, yylhsminor.yy414, NULL, TSDB_SQL_CREATE_TABLE); yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0); } - yymsp[-5].minor.yy358 = yylhsminor.yy358; + yymsp[-5].minor.yy414 = yylhsminor.yy414; break; - case 127: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ + case 136: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ { - yylhsminor.yy358 = tSetCreateSqlElems(yymsp[-5].minor.yy247, yymsp[-1].minor.yy247, NULL, TSQL_CREATE_STABLE); - setSqlInfo(pInfo, yylhsminor.yy358, NULL, TSDB_SQL_CREATE_TABLE); + yylhsminor.yy414 = tSetCreateSqlElems(yymsp[-5].minor.yy207, yymsp[-1].minor.yy207, NULL, TSQL_CREATE_STABLE); + setSqlInfo(pInfo, yylhsminor.yy414, NULL, TSDB_SQL_CREATE_TABLE); yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); } - yymsp[-9].minor.yy358 = yylhsminor.yy358; + yymsp[-9].minor.yy414 = yylhsminor.yy414; break; - case 128: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ + case 137: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; - yylhsminor.yy42 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy247, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); + yylhsminor.yy542 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy207, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); } - yymsp[-9].minor.yy42 = yylhsminor.yy42; + yymsp[-9].minor.yy542 = yylhsminor.yy542; break; - case 129: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ + case 138: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ { yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n; - yylhsminor.yy42 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy247, yymsp[-1].minor.yy247, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0); + yylhsminor.yy542 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy207, yymsp[-1].minor.yy207, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0); } - yymsp[-12].minor.yy42 = yylhsminor.yy42; + yymsp[-12].minor.yy542 = yylhsminor.yy542; break; - case 130: /* tagNamelist ::= tagNamelist COMMA ids */ -{taosArrayPush(yymsp[-2].minor.yy247, &yymsp[0].minor.yy0); yylhsminor.yy247 = yymsp[-2].minor.yy247; } - yymsp[-2].minor.yy247 = yylhsminor.yy247; + case 139: /* tagNamelist ::= tagNamelist COMMA ids */ +{taosArrayPush(yymsp[-2].minor.yy207, &yymsp[0].minor.yy0); yylhsminor.yy207 = yymsp[-2].minor.yy207; } + yymsp[-2].minor.yy207 = yylhsminor.yy207; break; - case 131: /* tagNamelist ::= ids */ -{yylhsminor.yy247 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy247, &yymsp[0].minor.yy0);} - yymsp[0].minor.yy247 = yylhsminor.yy247; + case 140: /* tagNamelist ::= ids */ +{yylhsminor.yy207 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy207, &yymsp[0].minor.yy0);} + yymsp[0].minor.yy207 = yylhsminor.yy207; break; - case 132: /* create_table_args ::= ifnotexists ids cpxName AS select */ + case 141: /* create_table_args ::= ifnotexists ids cpxName AS select */ { - yylhsminor.yy358 = tSetCreateSqlElems(NULL, NULL, yymsp[0].minor.yy114, TSQL_CREATE_STREAM); - setSqlInfo(pInfo, yylhsminor.yy358, NULL, TSDB_SQL_CREATE_TABLE); + yylhsminor.yy414 = tSetCreateSqlElems(NULL, NULL, yymsp[0].minor.yy526, TSQL_CREATE_STREAM); + setSqlInfo(pInfo, yylhsminor.yy414, NULL, TSDB_SQL_CREATE_TABLE); yymsp[-3].minor.yy0.n += yymsp[-2].minor.yy0.n; setCreatedTableName(pInfo, &yymsp[-3].minor.yy0, &yymsp[-4].minor.yy0); } - yymsp[-4].minor.yy358 = yylhsminor.yy358; + yymsp[-4].minor.yy414 = yylhsminor.yy414; break; - case 133: /* columnlist ::= columnlist COMMA column */ -{taosArrayPush(yymsp[-2].minor.yy247, &yymsp[0].minor.yy179); yylhsminor.yy247 = yymsp[-2].minor.yy247; } - yymsp[-2].minor.yy247 = yylhsminor.yy247; + case 142: /* columnlist ::= columnlist COMMA column */ +{taosArrayPush(yymsp[-2].minor.yy207, &yymsp[0].minor.yy517); yylhsminor.yy207 = yymsp[-2].minor.yy207; } + yymsp[-2].minor.yy207 = yylhsminor.yy207; break; - case 134: /* columnlist ::= column */ -{yylhsminor.yy247 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy247, &yymsp[0].minor.yy179);} - yymsp[0].minor.yy247 = yylhsminor.yy247; + case 143: /* columnlist ::= column */ +{yylhsminor.yy207 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy207, &yymsp[0].minor.yy517);} + yymsp[0].minor.yy207 = yylhsminor.yy207; break; - case 135: /* column ::= ids typename */ + case 144: /* column ::= ids typename */ { - tSqlSetColumnInfo(&yylhsminor.yy179, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy179); + tSqlSetColumnInfo(&yylhsminor.yy517, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy517); } - yymsp[-1].minor.yy179 = yylhsminor.yy179; + yymsp[-1].minor.yy517 = yylhsminor.yy517; break; - case 136: /* tagitemlist ::= tagitemlist COMMA tagitem */ -{ yylhsminor.yy247 = tVariantListAppend(yymsp[-2].minor.yy247, &yymsp[0].minor.yy378, -1); } - yymsp[-2].minor.yy247 = yylhsminor.yy247; + case 145: /* tagitemlist ::= tagitemlist COMMA tagitem */ +{ yylhsminor.yy207 = tVariantListAppend(yymsp[-2].minor.yy207, &yymsp[0].minor.yy232, -1); } + yymsp[-2].minor.yy207 = yylhsminor.yy207; break; - case 137: /* tagitemlist ::= tagitem */ -{ yylhsminor.yy247 = tVariantListAppend(NULL, &yymsp[0].minor.yy378, -1); } - yymsp[0].minor.yy247 = yylhsminor.yy247; + case 146: /* tagitemlist ::= tagitem */ +{ yylhsminor.yy207 = tVariantListAppend(NULL, &yymsp[0].minor.yy232, -1); } + yymsp[0].minor.yy207 = yylhsminor.yy207; break; - case 138: /* tagitem ::= INTEGER */ - case 139: /* tagitem ::= FLOAT */ yytestcase(yyruleno==139); - case 140: /* tagitem ::= STRING */ yytestcase(yyruleno==140); - case 141: /* tagitem ::= BOOL */ yytestcase(yyruleno==141); -{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy378, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy378 = yylhsminor.yy378; + case 147: /* tagitem ::= INTEGER */ + case 148: /* tagitem ::= FLOAT */ yytestcase(yyruleno==148); + case 149: /* tagitem ::= STRING */ yytestcase(yyruleno==149); + case 150: /* tagitem ::= BOOL */ yytestcase(yyruleno==150); +{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy232, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy232 = yylhsminor.yy232; break; - case 142: /* tagitem ::= NULL */ -{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy378, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy378 = yylhsminor.yy378; + case 151: /* tagitem ::= NULL */ +{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy232, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy232 = yylhsminor.yy232; break; - case 143: /* tagitem ::= MINUS INTEGER */ - case 144: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==144); - case 145: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==145); - case 146: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==146); + case 152: /* tagitem ::= MINUS INTEGER */ + case 153: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==153); + case 154: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==154); + case 155: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==155); { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type; toTSDBType(yymsp[-1].minor.yy0.type); - tVariantCreate(&yylhsminor.yy378, &yymsp[-1].minor.yy0); + tVariantCreate(&yylhsminor.yy232, &yymsp[-1].minor.yy0); } - yymsp[-1].minor.yy378 = yylhsminor.yy378; + yymsp[-1].minor.yy232 = yylhsminor.yy232; break; - case 147: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */ + case 156: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */ { - yylhsminor.yy114 = tSetQuerySqlElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy522, yymsp[-9].minor.yy247, yymsp[-8].minor.yy326, yymsp[-4].minor.yy247, yymsp[-3].minor.yy247, &yymsp[-7].minor.yy430, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy247, &yymsp[0].minor.yy204, &yymsp[-1].minor.yy204); + yylhsminor.yy526 = tSetQuerySqlElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy178, yymsp[-9].minor.yy207, yymsp[-8].minor.yy484, yymsp[-4].minor.yy207, yymsp[-3].minor.yy207, &yymsp[-7].minor.yy126, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy207, &yymsp[0].minor.yy314, &yymsp[-1].minor.yy314); } - yymsp[-11].minor.yy114 = yylhsminor.yy114; + yymsp[-11].minor.yy526 = yylhsminor.yy526; break; - case 148: /* union ::= select */ -{ yylhsminor.yy219 = setSubclause(NULL, yymsp[0].minor.yy114); } - yymsp[0].minor.yy219 = yylhsminor.yy219; + case 157: /* union ::= select */ +{ yylhsminor.yy441 = setSubclause(NULL, yymsp[0].minor.yy526); } + yymsp[0].minor.yy441 = yylhsminor.yy441; break; - case 149: /* union ::= LP union RP */ -{ yymsp[-2].minor.yy219 = yymsp[-1].minor.yy219; } + case 158: /* union ::= LP union RP */ +{ yymsp[-2].minor.yy441 = yymsp[-1].minor.yy441; } break; - case 150: /* union ::= union UNION ALL select */ -{ yylhsminor.yy219 = appendSelectClause(yymsp[-3].minor.yy219, yymsp[0].minor.yy114); } - yymsp[-3].minor.yy219 = yylhsminor.yy219; + case 159: /* union ::= union UNION ALL select */ +{ yylhsminor.yy441 = appendSelectClause(yymsp[-3].minor.yy441, yymsp[0].minor.yy526); } + yymsp[-3].minor.yy441 = yylhsminor.yy441; break; - case 151: /* union ::= union UNION ALL LP select RP */ -{ yylhsminor.yy219 = appendSelectClause(yymsp[-5].minor.yy219, yymsp[-1].minor.yy114); } - yymsp[-5].minor.yy219 = yylhsminor.yy219; + case 160: /* union ::= union UNION ALL LP select RP */ +{ yylhsminor.yy441 = appendSelectClause(yymsp[-5].minor.yy441, yymsp[-1].minor.yy526); } + yymsp[-5].minor.yy441 = yylhsminor.yy441; break; - case 152: /* cmd ::= union */ -{ setSqlInfo(pInfo, yymsp[0].minor.yy219, NULL, TSDB_SQL_SELECT); } + case 161: /* cmd ::= union */ +{ setSqlInfo(pInfo, yymsp[0].minor.yy441, NULL, TSDB_SQL_SELECT); } break; - case 153: /* select ::= SELECT selcollist */ + case 162: /* select ::= SELECT selcollist */ { - yylhsminor.yy114 = tSetQuerySqlElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy522, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); + yylhsminor.yy526 = tSetQuerySqlElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy178, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); } - yymsp[-1].minor.yy114 = yylhsminor.yy114; + yymsp[-1].minor.yy526 = yylhsminor.yy526; break; - case 154: /* sclp ::= selcollist COMMA */ -{yylhsminor.yy522 = yymsp[-1].minor.yy522;} - yymsp[-1].minor.yy522 = yylhsminor.yy522; + case 163: /* sclp ::= selcollist COMMA */ +{yylhsminor.yy178 = yymsp[-1].minor.yy178;} + yymsp[-1].minor.yy178 = yylhsminor.yy178; break; - case 155: /* sclp ::= */ -{yymsp[1].minor.yy522 = 0;} + case 164: /* sclp ::= */ +{yymsp[1].minor.yy178 = 0;} break; - case 156: /* selcollist ::= sclp distinct expr as */ + case 165: /* selcollist ::= sclp distinct expr as */ { - yylhsminor.yy522 = tSqlExprListAppend(yymsp[-3].minor.yy522, yymsp[-1].minor.yy326, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0); + yylhsminor.yy178 = tSqlExprListAppend(yymsp[-3].minor.yy178, yymsp[-1].minor.yy484, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0); } - yymsp[-3].minor.yy522 = yylhsminor.yy522; + yymsp[-3].minor.yy178 = yylhsminor.yy178; break; - case 157: /* selcollist ::= sclp STAR */ + case 166: /* selcollist ::= sclp STAR */ { tSQLExpr *pNode = tSqlExprIdValueCreate(NULL, TK_ALL); - yylhsminor.yy522 = tSqlExprListAppend(yymsp[-1].minor.yy522, pNode, 0, 0); + yylhsminor.yy178 = tSqlExprListAppend(yymsp[-1].minor.yy178, pNode, 0, 0); } - yymsp[-1].minor.yy522 = yylhsminor.yy522; + yymsp[-1].minor.yy178 = yylhsminor.yy178; break; - case 158: /* as ::= AS ids */ + case 167: /* as ::= AS ids */ { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } break; - case 159: /* as ::= ids */ + case 168: /* as ::= ids */ { yylhsminor.yy0 = yymsp[0].minor.yy0; } yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 160: /* as ::= */ + case 169: /* as ::= */ { yymsp[1].minor.yy0.n = 0; } break; - case 161: /* distinct ::= DISTINCT */ + case 170: /* distinct ::= DISTINCT */ { yylhsminor.yy0 = yymsp[0].minor.yy0; } yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 163: /* from ::= FROM tablelist */ -{yymsp[-1].minor.yy247 = yymsp[0].minor.yy247;} + case 172: /* from ::= FROM tablelist */ +{yymsp[-1].minor.yy207 = yymsp[0].minor.yy207;} break; - case 164: /* tablelist ::= ids cpxName */ + case 173: /* tablelist ::= ids cpxName */ { toTSDBType(yymsp[-1].minor.yy0.type); yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - yylhsminor.yy247 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); - yylhsminor.yy247 = tVariantListAppendToken(yylhsminor.yy247, &yymsp[-1].minor.yy0, -1); // table alias name + yylhsminor.yy207 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); + yylhsminor.yy207 = tVariantListAppendToken(yylhsminor.yy207, &yymsp[-1].minor.yy0, -1); // table alias name } - yymsp[-1].minor.yy247 = yylhsminor.yy247; + yymsp[-1].minor.yy207 = yylhsminor.yy207; break; - case 165: /* tablelist ::= ids cpxName ids */ + case 174: /* tablelist ::= ids cpxName ids */ { toTSDBType(yymsp[-2].minor.yy0.type); toTSDBType(yymsp[0].minor.yy0.type); yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; - yylhsminor.yy247 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1); - yylhsminor.yy247 = tVariantListAppendToken(yylhsminor.yy247, &yymsp[0].minor.yy0, -1); + yylhsminor.yy207 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1); + yylhsminor.yy207 = tVariantListAppendToken(yylhsminor.yy207, &yymsp[0].minor.yy0, -1); } - yymsp[-2].minor.yy247 = yylhsminor.yy247; + yymsp[-2].minor.yy207 = yylhsminor.yy207; break; - case 166: /* tablelist ::= tablelist COMMA ids cpxName */ + case 175: /* tablelist ::= tablelist COMMA ids cpxName */ { toTSDBType(yymsp[-1].minor.yy0.type); yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - yylhsminor.yy247 = tVariantListAppendToken(yymsp[-3].minor.yy247, &yymsp[-1].minor.yy0, -1); - yylhsminor.yy247 = tVariantListAppendToken(yylhsminor.yy247, &yymsp[-1].minor.yy0, -1); + yylhsminor.yy207 = tVariantListAppendToken(yymsp[-3].minor.yy207, &yymsp[-1].minor.yy0, -1); + yylhsminor.yy207 = tVariantListAppendToken(yylhsminor.yy207, &yymsp[-1].minor.yy0, -1); } - yymsp[-3].minor.yy247 = yylhsminor.yy247; + yymsp[-3].minor.yy207 = yylhsminor.yy207; break; - case 167: /* tablelist ::= tablelist COMMA ids cpxName ids */ + case 176: /* tablelist ::= tablelist COMMA ids cpxName ids */ { toTSDBType(yymsp[-2].minor.yy0.type); toTSDBType(yymsp[0].minor.yy0.type); yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; - yylhsminor.yy247 = tVariantListAppendToken(yymsp[-4].minor.yy247, &yymsp[-2].minor.yy0, -1); - yylhsminor.yy247 = tVariantListAppendToken(yylhsminor.yy247, &yymsp[0].minor.yy0, -1); + yylhsminor.yy207 = tVariantListAppendToken(yymsp[-4].minor.yy207, &yymsp[-2].minor.yy0, -1); + yylhsminor.yy207 = tVariantListAppendToken(yylhsminor.yy207, &yymsp[0].minor.yy0, -1); } - yymsp[-4].minor.yy247 = yylhsminor.yy247; + yymsp[-4].minor.yy207 = yylhsminor.yy207; break; - case 168: /* tmvar ::= VARIABLE */ + case 177: /* tmvar ::= VARIABLE */ {yylhsminor.yy0 = yymsp[0].minor.yy0;} yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 169: /* interval_opt ::= INTERVAL LP tmvar RP */ -{yymsp[-3].minor.yy430.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy430.offset.n = 0; yymsp[-3].minor.yy430.offset.z = NULL; yymsp[-3].minor.yy430.offset.type = 0;} + case 178: /* interval_opt ::= INTERVAL LP tmvar RP */ +{yymsp[-3].minor.yy126.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy126.offset.n = 0; yymsp[-3].minor.yy126.offset.z = NULL; yymsp[-3].minor.yy126.offset.type = 0;} break; - case 170: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */ -{yymsp[-5].minor.yy430.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy430.offset = yymsp[-1].minor.yy0;} + case 179: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */ +{yymsp[-5].minor.yy126.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy126.offset = yymsp[-1].minor.yy0;} break; - case 171: /* interval_opt ::= */ -{memset(&yymsp[1].minor.yy430, 0, sizeof(yymsp[1].minor.yy430));} + case 180: /* interval_opt ::= */ +{memset(&yymsp[1].minor.yy126, 0, sizeof(yymsp[1].minor.yy126));} break; - case 172: /* fill_opt ::= */ -{yymsp[1].minor.yy247 = 0; } + case 181: /* fill_opt ::= */ +{yymsp[1].minor.yy207 = 0; } break; - case 173: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */ + case 182: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */ { tVariant A = {0}; toTSDBType(yymsp[-3].minor.yy0.type); tVariantCreate(&A, &yymsp[-3].minor.yy0); - tVariantListInsert(yymsp[-1].minor.yy247, &A, -1, 0); - yymsp[-5].minor.yy247 = yymsp[-1].minor.yy247; + tVariantListInsert(yymsp[-1].minor.yy207, &A, -1, 0); + yymsp[-5].minor.yy207 = yymsp[-1].minor.yy207; } break; - case 174: /* fill_opt ::= FILL LP ID RP */ + case 183: /* fill_opt ::= FILL LP ID RP */ { toTSDBType(yymsp[-1].minor.yy0.type); - yymsp[-3].minor.yy247 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); + yymsp[-3].minor.yy207 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); } break; - case 175: /* sliding_opt ::= SLIDING LP tmvar RP */ + case 184: /* sliding_opt ::= SLIDING LP tmvar RP */ {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0; } break; - case 176: /* sliding_opt ::= */ + case 185: /* sliding_opt ::= */ {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0; } break; - case 177: /* orderby_opt ::= */ -{yymsp[1].minor.yy247 = 0;} + case 186: /* orderby_opt ::= */ +{yymsp[1].minor.yy207 = 0;} break; - case 178: /* orderby_opt ::= ORDER BY sortlist */ -{yymsp[-2].minor.yy247 = yymsp[0].minor.yy247;} + case 187: /* orderby_opt ::= ORDER BY sortlist */ +{yymsp[-2].minor.yy207 = yymsp[0].minor.yy207;} break; - case 179: /* sortlist ::= sortlist COMMA item sortorder */ + case 188: /* sortlist ::= sortlist COMMA item sortorder */ { - yylhsminor.yy247 = tVariantListAppend(yymsp[-3].minor.yy247, &yymsp[-1].minor.yy378, yymsp[0].minor.yy222); + yylhsminor.yy207 = tVariantListAppend(yymsp[-3].minor.yy207, &yymsp[-1].minor.yy232, yymsp[0].minor.yy116); } - yymsp[-3].minor.yy247 = yylhsminor.yy247; + yymsp[-3].minor.yy207 = yylhsminor.yy207; break; - case 180: /* sortlist ::= item sortorder */ + case 189: /* sortlist ::= item sortorder */ { - yylhsminor.yy247 = tVariantListAppend(NULL, &yymsp[-1].minor.yy378, yymsp[0].minor.yy222); + yylhsminor.yy207 = tVariantListAppend(NULL, &yymsp[-1].minor.yy232, yymsp[0].minor.yy116); } - yymsp[-1].minor.yy247 = yylhsminor.yy247; + yymsp[-1].minor.yy207 = yylhsminor.yy207; break; - case 181: /* item ::= ids cpxName */ + case 190: /* item ::= ids cpxName */ { toTSDBType(yymsp[-1].minor.yy0.type); yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - tVariantCreate(&yylhsminor.yy378, &yymsp[-1].minor.yy0); + tVariantCreate(&yylhsminor.yy232, &yymsp[-1].minor.yy0); } - yymsp[-1].minor.yy378 = yylhsminor.yy378; + yymsp[-1].minor.yy232 = yylhsminor.yy232; break; - case 182: /* sortorder ::= ASC */ -{ yymsp[0].minor.yy222 = TSDB_ORDER_ASC; } + case 191: /* sortorder ::= ASC */ +{ yymsp[0].minor.yy116 = TSDB_ORDER_ASC; } break; - case 183: /* sortorder ::= DESC */ -{ yymsp[0].minor.yy222 = TSDB_ORDER_DESC;} + case 192: /* sortorder ::= DESC */ +{ yymsp[0].minor.yy116 = TSDB_ORDER_DESC;} break; - case 184: /* sortorder ::= */ -{ yymsp[1].minor.yy222 = TSDB_ORDER_ASC; } + case 193: /* sortorder ::= */ +{ yymsp[1].minor.yy116 = TSDB_ORDER_ASC; } break; - case 185: /* groupby_opt ::= */ -{ yymsp[1].minor.yy247 = 0;} + case 194: /* groupby_opt ::= */ +{ yymsp[1].minor.yy207 = 0;} break; - case 186: /* groupby_opt ::= GROUP BY grouplist */ -{ yymsp[-2].minor.yy247 = yymsp[0].minor.yy247;} + case 195: /* groupby_opt ::= GROUP BY grouplist */ +{ yymsp[-2].minor.yy207 = yymsp[0].minor.yy207;} break; - case 187: /* grouplist ::= grouplist COMMA item */ + case 196: /* grouplist ::= grouplist COMMA item */ { - yylhsminor.yy247 = tVariantListAppend(yymsp[-2].minor.yy247, &yymsp[0].minor.yy378, -1); + yylhsminor.yy207 = tVariantListAppend(yymsp[-2].minor.yy207, &yymsp[0].minor.yy232, -1); } - yymsp[-2].minor.yy247 = yylhsminor.yy247; + yymsp[-2].minor.yy207 = yylhsminor.yy207; break; - case 188: /* grouplist ::= item */ + case 197: /* grouplist ::= item */ { - yylhsminor.yy247 = tVariantListAppend(NULL, &yymsp[0].minor.yy378, -1); + yylhsminor.yy207 = tVariantListAppend(NULL, &yymsp[0].minor.yy232, -1); } - yymsp[0].minor.yy247 = yylhsminor.yy247; + yymsp[0].minor.yy207 = yylhsminor.yy207; break; - case 189: /* having_opt ::= */ - case 199: /* where_opt ::= */ yytestcase(yyruleno==199); - case 238: /* expritem ::= */ yytestcase(yyruleno==238); -{yymsp[1].minor.yy326 = 0;} + case 198: /* having_opt ::= */ + case 208: /* where_opt ::= */ yytestcase(yyruleno==208); + case 247: /* expritem ::= */ yytestcase(yyruleno==247); +{yymsp[1].minor.yy484 = 0;} break; - case 190: /* having_opt ::= HAVING expr */ - case 200: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==200); -{yymsp[-1].minor.yy326 = yymsp[0].minor.yy326;} + case 199: /* having_opt ::= HAVING expr */ + case 209: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==209); +{yymsp[-1].minor.yy484 = yymsp[0].minor.yy484;} break; - case 191: /* limit_opt ::= */ - case 195: /* slimit_opt ::= */ yytestcase(yyruleno==195); -{yymsp[1].minor.yy204.limit = -1; yymsp[1].minor.yy204.offset = 0;} + case 200: /* limit_opt ::= */ + case 204: /* slimit_opt ::= */ yytestcase(yyruleno==204); +{yymsp[1].minor.yy314.limit = -1; yymsp[1].minor.yy314.offset = 0;} break; - case 192: /* limit_opt ::= LIMIT signed */ - case 196: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==196); -{yymsp[-1].minor.yy204.limit = yymsp[0].minor.yy403; yymsp[-1].minor.yy204.offset = 0;} + case 201: /* limit_opt ::= LIMIT signed */ + case 205: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==205); +{yymsp[-1].minor.yy314.limit = yymsp[0].minor.yy208; yymsp[-1].minor.yy314.offset = 0;} break; - case 193: /* limit_opt ::= LIMIT signed OFFSET signed */ -{ yymsp[-3].minor.yy204.limit = yymsp[-2].minor.yy403; yymsp[-3].minor.yy204.offset = yymsp[0].minor.yy403;} + case 202: /* limit_opt ::= LIMIT signed OFFSET signed */ +{ yymsp[-3].minor.yy314.limit = yymsp[-2].minor.yy208; yymsp[-3].minor.yy314.offset = yymsp[0].minor.yy208;} break; - case 194: /* limit_opt ::= LIMIT signed COMMA signed */ -{ yymsp[-3].minor.yy204.limit = yymsp[0].minor.yy403; yymsp[-3].minor.yy204.offset = yymsp[-2].minor.yy403;} + case 203: /* limit_opt ::= LIMIT signed COMMA signed */ +{ yymsp[-3].minor.yy314.limit = yymsp[0].minor.yy208; yymsp[-3].minor.yy314.offset = yymsp[-2].minor.yy208;} break; - case 197: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ -{yymsp[-3].minor.yy204.limit = yymsp[-2].minor.yy403; yymsp[-3].minor.yy204.offset = yymsp[0].minor.yy403;} + case 206: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ +{yymsp[-3].minor.yy314.limit = yymsp[-2].minor.yy208; yymsp[-3].minor.yy314.offset = yymsp[0].minor.yy208;} break; - case 198: /* slimit_opt ::= SLIMIT signed COMMA signed */ -{yymsp[-3].minor.yy204.limit = yymsp[0].minor.yy403; yymsp[-3].minor.yy204.offset = yymsp[-2].minor.yy403;} + case 207: /* slimit_opt ::= SLIMIT signed COMMA signed */ +{yymsp[-3].minor.yy314.limit = yymsp[0].minor.yy208; yymsp[-3].minor.yy314.offset = yymsp[-2].minor.yy208;} break; - case 201: /* expr ::= LP expr RP */ -{yylhsminor.yy326 = yymsp[-1].minor.yy326; yylhsminor.yy326->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy326->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 210: /* expr ::= LP expr RP */ +{yylhsminor.yy484 = yymsp[-1].minor.yy484; yylhsminor.yy484->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy484->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 202: /* expr ::= ID */ -{ yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);} - yymsp[0].minor.yy326 = yylhsminor.yy326; + case 211: /* expr ::= ID */ +{ yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);} + yymsp[0].minor.yy484 = yylhsminor.yy484; break; - case 203: /* expr ::= ID DOT ID */ -{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 212: /* expr ::= ID DOT ID */ +{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 204: /* expr ::= ID DOT STAR */ -{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 213: /* expr ::= ID DOT STAR */ +{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 205: /* expr ::= INTEGER */ -{ yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);} - yymsp[0].minor.yy326 = yylhsminor.yy326; + case 214: /* expr ::= INTEGER */ +{ yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);} + yymsp[0].minor.yy484 = yylhsminor.yy484; break; - case 206: /* expr ::= MINUS INTEGER */ - case 207: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==207); -{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);} - yymsp[-1].minor.yy326 = yylhsminor.yy326; + case 215: /* expr ::= MINUS INTEGER */ + case 216: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==216); +{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);} + yymsp[-1].minor.yy484 = yylhsminor.yy484; break; - case 208: /* expr ::= FLOAT */ -{ yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);} - yymsp[0].minor.yy326 = yylhsminor.yy326; + case 217: /* expr ::= FLOAT */ +{ yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);} + yymsp[0].minor.yy484 = yylhsminor.yy484; break; - case 209: /* expr ::= MINUS FLOAT */ - case 210: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==210); -{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);} - yymsp[-1].minor.yy326 = yylhsminor.yy326; + case 218: /* expr ::= MINUS FLOAT */ + case 219: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==219); +{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);} + yymsp[-1].minor.yy484 = yylhsminor.yy484; break; - case 211: /* expr ::= STRING */ -{ yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);} - yymsp[0].minor.yy326 = yylhsminor.yy326; + case 220: /* expr ::= STRING */ +{ yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);} + yymsp[0].minor.yy484 = yylhsminor.yy484; break; - case 212: /* expr ::= NOW */ -{ yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); } - yymsp[0].minor.yy326 = yylhsminor.yy326; + case 221: /* expr ::= NOW */ +{ yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); } + yymsp[0].minor.yy484 = yylhsminor.yy484; break; - case 213: /* expr ::= VARIABLE */ -{ yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);} - yymsp[0].minor.yy326 = yylhsminor.yy326; + case 222: /* expr ::= VARIABLE */ +{ yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);} + yymsp[0].minor.yy484 = yylhsminor.yy484; break; - case 214: /* expr ::= BOOL */ -{ yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);} - yymsp[0].minor.yy326 = yylhsminor.yy326; + case 223: /* expr ::= BOOL */ +{ yylhsminor.yy484 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);} + yymsp[0].minor.yy484 = yylhsminor.yy484; break; - case 215: /* expr ::= ID LP exprlist RP */ -{ yylhsminor.yy326 = tSqlExprCreateFunction(yymsp[-1].minor.yy522, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } - yymsp[-3].minor.yy326 = yylhsminor.yy326; + case 224: /* expr ::= ID LP exprlist RP */ +{ yylhsminor.yy484 = tSqlExprCreateFunction(yymsp[-1].minor.yy178, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } + yymsp[-3].minor.yy484 = yylhsminor.yy484; break; - case 216: /* expr ::= ID LP STAR RP */ -{ yylhsminor.yy326 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } - yymsp[-3].minor.yy326 = yylhsminor.yy326; + case 225: /* expr ::= ID LP STAR RP */ +{ yylhsminor.yy484 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } + yymsp[-3].minor.yy484 = yylhsminor.yy484; break; - case 217: /* expr ::= expr IS NULL */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, NULL, TK_ISNULL);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 226: /* expr ::= expr IS NULL */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, NULL, TK_ISNULL);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 218: /* expr ::= expr IS NOT NULL */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-3].minor.yy326, NULL, TK_NOTNULL);} - yymsp[-3].minor.yy326 = yylhsminor.yy326; + case 227: /* expr ::= expr IS NOT NULL */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-3].minor.yy484, NULL, TK_NOTNULL);} + yymsp[-3].minor.yy484 = yylhsminor.yy484; break; - case 219: /* expr ::= expr LT expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_LT);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 228: /* expr ::= expr LT expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_LT);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 220: /* expr ::= expr GT expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_GT);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 229: /* expr ::= expr GT expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_GT);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 221: /* expr ::= expr LE expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_LE);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 230: /* expr ::= expr LE expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_LE);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 222: /* expr ::= expr GE expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_GE);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 231: /* expr ::= expr GE expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_GE);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 223: /* expr ::= expr NE expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_NE);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 232: /* expr ::= expr NE expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_NE);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 224: /* expr ::= expr EQ expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_EQ);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 233: /* expr ::= expr EQ expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_EQ);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 225: /* expr ::= expr BETWEEN expr AND expr */ -{ tSQLExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy326); yylhsminor.yy326 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy326, yymsp[-2].minor.yy326, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy326, TK_LE), TK_AND);} - yymsp[-4].minor.yy326 = yylhsminor.yy326; + case 234: /* expr ::= expr BETWEEN expr AND expr */ +{ tSQLExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy484); yylhsminor.yy484 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy484, yymsp[-2].minor.yy484, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy484, TK_LE), TK_AND);} + yymsp[-4].minor.yy484 = yylhsminor.yy484; break; - case 226: /* expr ::= expr AND expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_AND);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 235: /* expr ::= expr AND expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_AND);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 227: /* expr ::= expr OR expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_OR); } - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 236: /* expr ::= expr OR expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_OR); } + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 228: /* expr ::= expr PLUS expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_PLUS); } - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 237: /* expr ::= expr PLUS expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_PLUS); } + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 229: /* expr ::= expr MINUS expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_MINUS); } - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 238: /* expr ::= expr MINUS expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_MINUS); } + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 230: /* expr ::= expr STAR expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_STAR); } - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 239: /* expr ::= expr STAR expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_STAR); } + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 231: /* expr ::= expr SLASH expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_DIVIDE);} - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 240: /* expr ::= expr SLASH expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_DIVIDE);} + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 232: /* expr ::= expr REM expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_REM); } - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 241: /* expr ::= expr REM expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_REM); } + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 233: /* expr ::= expr LIKE expr */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_LIKE); } - yymsp[-2].minor.yy326 = yylhsminor.yy326; + case 242: /* expr ::= expr LIKE expr */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-2].minor.yy484, yymsp[0].minor.yy484, TK_LIKE); } + yymsp[-2].minor.yy484 = yylhsminor.yy484; break; - case 234: /* expr ::= expr IN LP exprlist RP */ -{yylhsminor.yy326 = tSqlExprCreate(yymsp[-4].minor.yy326, (tSQLExpr*)yymsp[-1].minor.yy522, TK_IN); } - yymsp[-4].minor.yy326 = yylhsminor.yy326; + case 243: /* expr ::= expr IN LP exprlist RP */ +{yylhsminor.yy484 = tSqlExprCreate(yymsp[-4].minor.yy484, (tSQLExpr*)yymsp[-1].minor.yy178, TK_IN); } + yymsp[-4].minor.yy484 = yylhsminor.yy484; break; - case 235: /* exprlist ::= exprlist COMMA expritem */ -{yylhsminor.yy522 = tSqlExprListAppend(yymsp[-2].minor.yy522,yymsp[0].minor.yy326,0, 0);} - yymsp[-2].minor.yy522 = yylhsminor.yy522; + case 244: /* exprlist ::= exprlist COMMA expritem */ +{yylhsminor.yy178 = tSqlExprListAppend(yymsp[-2].minor.yy178,yymsp[0].minor.yy484,0, 0);} + yymsp[-2].minor.yy178 = yylhsminor.yy178; break; - case 236: /* exprlist ::= expritem */ -{yylhsminor.yy522 = tSqlExprListAppend(0,yymsp[0].minor.yy326,0, 0);} - yymsp[0].minor.yy522 = yylhsminor.yy522; + case 245: /* exprlist ::= expritem */ +{yylhsminor.yy178 = tSqlExprListAppend(0,yymsp[0].minor.yy484,0, 0);} + yymsp[0].minor.yy178 = yylhsminor.yy178; break; - case 237: /* expritem ::= expr */ -{yylhsminor.yy326 = yymsp[0].minor.yy326;} - yymsp[0].minor.yy326 = yylhsminor.yy326; + case 246: /* expritem ::= expr */ +{yylhsminor.yy484 = yymsp[0].minor.yy484;} + yymsp[0].minor.yy484 = yylhsminor.yy484; break; - case 239: /* cmd ::= RESET QUERY CACHE */ + case 248: /* cmd ::= RESET QUERY CACHE */ { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);} break; - case 240: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ + case 249: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy247, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1); + SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy207, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 241: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ + case 250: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3251,14 +3312,14 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 242: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + case 251: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy247, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1); + SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy207, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 243: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + case 252: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3269,7 +3330,7 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 244: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + case 253: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3283,26 +3344,26 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 245: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + case 254: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ { yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; toTSDBType(yymsp[-2].minor.yy0.type); SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1); - A = tVariantListAppend(A, &yymsp[0].minor.yy378, -1); + A = tVariantListAppend(A, &yymsp[0].minor.yy232, -1); SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 246: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + case 255: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy247, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy207, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 247: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + case 256: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3313,14 +3374,14 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 248: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + case 257: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy247, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy207, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 249: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + case 258: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3331,7 +3392,7 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 250: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + case 259: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3345,13 +3406,13 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 251: /* cmd ::= KILL CONNECTION INTEGER */ + case 260: /* cmd ::= KILL CONNECTION INTEGER */ {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);} break; - case 252: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */ + case 261: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */ {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);} break; - case 253: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ + case 262: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);} break; default: diff --git a/src/util/src/terror.c b/src/util/src/terror.c index 4a011b7cc7..221e618390 100644 --- a/src/util/src/terror.c +++ b/src/util/src/terror.c @@ -197,6 +197,9 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_NOT_READY, "Database unsynced") TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION_DAYS, "Invalid database option: days out of range") TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION_KEEP, "Invalid database option: keep >= keep1 >= keep0 >= days") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TOPIC, "Invalid topic name") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TOPIC_OPTION, "Invalid topic option") + // dnode TAOS_DEFINE_ERROR(TSDB_CODE_DND_MSG_NOT_PROCESSED, "Message not processed") TAOS_DEFINE_ERROR(TSDB_CODE_DND_OUT_OF_MEMORY, "Dnode out of memory") diff --git a/src/vnode/inc/vnodeInt.h b/src/vnode/inc/vnodeInt.h index 3ec77bbc12..91ddf5076b 100644 --- a/src/vnode/inc/vnodeInt.h +++ b/src/vnode/inc/vnodeInt.h @@ -40,6 +40,7 @@ typedef struct { int32_t queuedWMsg; int32_t queuedRMsg; int32_t flowctrlLevel; + int32_t sequence; // for topic int8_t status; int8_t role; int8_t accessState; @@ -47,7 +48,7 @@ typedef struct { int8_t isCommiting; int8_t dbReplica; int8_t dropped; - int8_t reserved; + int8_t dbType; uint64_t version; // current version uint64_t cversion; // version while commit start uint64_t fversion; // version on saved data file diff --git a/src/vnode/src/vnodeCfg.c b/src/vnode/src/vnodeCfg.c index 03f2b11eec..c9cd366c64 100644 --- a/src/vnode/src/vnodeCfg.c +++ b/src/vnode/src/vnodeCfg.c @@ -42,6 +42,7 @@ static void vnodeLoadCfg(SVnodeObj *pVnode, SCreateVnodeMsg* vnodeMsg) { pVnode->syncCfg.replica = vnodeMsg->cfg.vgReplica; pVnode->syncCfg.quorum = vnodeMsg->cfg.quorum; pVnode->dbReplica = vnodeMsg->cfg.dbReplica; + pVnode->dbType = vnodeMsg->cfg.dbType; for (int i = 0; i < pVnode->syncCfg.replica; ++i) { SVnodeDesc *node = &vnodeMsg->nodes[i]; @@ -214,7 +215,7 @@ int32_t vnodeReadCfg(SVnodeObj *pVnode) { cJSON *dbReplica = cJSON_GetObjectItem(root, "dbReplica"); if (!dbReplica || dbReplica->type != cJSON_Number) { - vError("vgId:%d, failed to read %s, dbReplica not found", pVnode->vgId, file); + vWarn("vgId:%d, failed to read %s, dbReplica not found", pVnode->vgId, file); vnodeMsg.cfg.dbReplica = vnodeMsg.cfg.vgReplica; vnodeMsg.cfg.vgCfgVersion = 0; } else { @@ -230,7 +231,7 @@ int32_t vnodeReadCfg(SVnodeObj *pVnode) { cJSON *update = cJSON_GetObjectItem(root, "update"); if (!update || update->type != cJSON_Number) { - vError("vgId: %d, failed to read %s, update not found", pVnode->vgId, file); + vWarn("vgId: %d, failed to read %s, update not found", pVnode->vgId, file); vnodeMsg.cfg.update = 0; vnodeMsg.cfg.vgCfgVersion = 0; } else { @@ -239,13 +240,21 @@ int32_t vnodeReadCfg(SVnodeObj *pVnode) { cJSON *cacheLastRow = cJSON_GetObjectItem(root, "cacheLastRow"); if (!cacheLastRow || cacheLastRow->type != cJSON_Number) { - vError("vgId: %d, failed to read %s, cacheLastRow not found", pVnode->vgId, file); + vWarn("vgId: %d, failed to read %s, cacheLastRow not found", pVnode->vgId, file); vnodeMsg.cfg.cacheLastRow = 0; vnodeMsg.cfg.vgCfgVersion = 0; } else { vnodeMsg.cfg.cacheLastRow = (int8_t)cacheLastRow->valueint; } + cJSON *dbType = cJSON_GetObjectItem(root, "dbType"); + if (!dbType || dbType->type != cJSON_Number) { + vWarn("vgId: %d, failed to read %s, dbType not found", pVnode->vgId, file); + vnodeMsg.cfg.dbType = 0; + } else { + vnodeMsg.cfg.dbType = (int8_t)dbType->valueint; + } + cJSON *nodeInfos = cJSON_GetObjectItem(root, "nodeInfos"); if (!nodeInfos || nodeInfos->type != cJSON_Array) { vError("vgId:%d, failed to read %s, nodeInfos not found", pVnode->vgId, file); @@ -337,6 +346,7 @@ int32_t vnodeWriteCfg(SCreateVnodeMsg *pMsg) { len += snprintf(content + len, maxLen - len, " \"quorum\": %d,\n", pMsg->cfg.quorum); len += snprintf(content + len, maxLen - len, " \"update\": %d,\n", pMsg->cfg.update); len += snprintf(content + len, maxLen - len, " \"cacheLastRow\": %d,\n", pMsg->cfg.cacheLastRow); + len += snprintf(content + len, maxLen - len, " \"dbType\": %d,\n", pMsg->cfg.dbType); len += snprintf(content + len, maxLen - len, " \"nodeInfos\": [{\n"); for (int32_t i = 0; i < pMsg->cfg.vgReplica; i++) { SVnodeDesc *node = &pMsg->nodes[i]; diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c index 99b7e7b628..a1d4f50010 100644 --- a/src/vnode/src/vnodeWrite.c +++ b/src/vnode/src/vnodeWrite.c @@ -15,6 +15,7 @@ #define _DEFAULT_SOURCE #include "os.h" +#include "tp.h" #include "taosmsg.h" #include "taoserror.h" #include "tglobal.h" @@ -139,6 +140,10 @@ static int32_t vnodeProcessSubmitMsg(SVnodeObj *pVnode, void *pCont, SRspRet *pR vTrace("vgId:%d, submit msg is processed", pVnode->vgId); + if (pVnode->dbType == TSDB_DB_TYPE_TOPIC && pVnode->role == TAOS_SYNC_ROLE_MASTER) { + tpUpdateTs(&pVnode->sequence, pCont); + } + // save insert result into item SShellSubmitRspMsg *pRsp = NULL; if (pRet) { diff --git a/tests/pytest/crash_gen/crash_gen_main.py b/tests/pytest/crash_gen/crash_gen_main.py index 309c0df910..43506c68d5 100755 --- a/tests/pytest/crash_gen/crash_gen_main.py +++ b/tests/pytest/crash_gen/crash_gen_main.py @@ -35,16 +35,19 @@ import os import signal import traceback import resource -from guppy import hpy +# from guppy import hpy import gc from crash_gen.service_manager import ServiceManager, TdeInstance from crash_gen.misc import Logging, Status, CrashGenError, Dice, Helper, Progress from crash_gen.db import DbConn, MyTDSql, DbConnNative, DbManager +import crash_gen.settings import taos import requests +crash_gen.settings.init() + # Require Python 3 if sys.version_info[0] < 3: raise Exception("Must be using Python 3") @@ -259,6 +262,7 @@ class ThreadCoordinator: self._execStats = ExecutionStats() self._runStatus = Status.STATUS_RUNNING self._initDbs() + self._stepStartTime = None # Track how long it takes to execute each step def getTaskExecutor(self): return self._te @@ -394,6 +398,10 @@ class ThreadCoordinator: try: self._syncAtBarrier() # For now just cross the barrier Progress.emit(Progress.END_THREAD_STEP) + if self._stepStartTime : + stepExecTime = time.time() - self._stepStartTime + Progress.emitStr('{:.3f}s/{}'.format(stepExecTime, DbConnNative.totalRequests)) + DbConnNative.resetTotalRequests() # reset to zero except threading.BrokenBarrierError as err: self._execStats.registerFailure("Aborted due to worker thread timeout") Logging.error("\n") @@ -433,6 +441,7 @@ class ThreadCoordinator: # Then we move on to the next step Progress.emit(Progress.BEGIN_THREAD_STEP) + self._stepStartTime = time.time() self._releaseAllWorkerThreads(transitionFailed) if hasAbortedTask or transitionFailed : # abnormal ending, workers waiting at "gate" @@ -691,7 +700,7 @@ class AnyState: def canDropDb(self): # If user requests to run up to a number of DBs, # we'd then not do drop_db operations any more - if gConfig.max_dbs > 0 : + if gConfig.max_dbs > 0 or gConfig.use_shadow_db : return False return self._info[self.CAN_DROP_DB] @@ -699,6 +708,8 @@ class AnyState: return self._info[self.CAN_CREATE_FIXED_SUPER_TABLE] def canDropFixedSuperTable(self): + if gConfig.use_shadow_db: # duplicate writes to shaddow DB, in which case let's disable dropping s-table + return False return self._info[self.CAN_DROP_FIXED_SUPER_TABLE] def canAddData(self): @@ -1037,7 +1048,7 @@ class Database: _clsLock = threading.Lock() # class wide lock _lastInt = 101 # next one is initial integer _lastTick = 0 - _lastLaggingTick = 0 # lagging tick, for unsequenced insersions + _lastLaggingTick = 0 # lagging tick, for out-of-sequence (oos) data insertions def __init__(self, dbNum: int, dbc: DbConn): # TODO: remove dbc self._dbNum = dbNum # we assign a number to databases, for our testing purpose @@ -1093,21 +1104,24 @@ class Database: t3 = datetime.datetime(2012, 1, 1) # default "keep" is 10 years t4 = datetime.datetime.fromtimestamp( t3.timestamp() + elSec2) # see explanation above - Logging.debug("Setting up TICKS to start from: {}".format(t4)) + Logging.info("Setting up TICKS to start from: {}".format(t4)) return t4 @classmethod - def getNextTick(cls): + def getNextTick(cls): + ''' + Fetch a timestamp tick, with some random factor, may not be unique. + ''' with cls._clsLock: # prevent duplicate tick if cls._lastLaggingTick==0 or cls._lastTick==0 : # not initialized # 10k at 1/20 chance, should be enough to avoid overlaps tick = cls.setupLastTick() cls._lastTick = tick - cls._lastLaggingTick = tick + datetime.timedelta(0, -10000) + cls._lastLaggingTick = tick + datetime.timedelta(0, -60*2) # lagging behind 2 minutes, should catch up fast # if : # should be quite a bit into the future - if Dice.throw(20) == 0: # 1 in 20 chance, return lagging tick - cls._lastLaggingTick += datetime.timedelta(0, 1) # Go back in time 100 seconds + if gConfig.mix_oos_data and Dice.throw(20) == 0: # if asked to do so, and 1 in 20 chance, return lagging tick + cls._lastLaggingTick += datetime.timedelta(0, 1) # pick the next sequence from the lagging tick sequence return cls._lastLaggingTick else: # regular # add one second to it @@ -1334,7 +1348,8 @@ class Task(): elif self._isErrAcceptable(errno2, err.__str__()): self.logDebug("[=] Acceptable Taos library exception: errno=0x{:X}, msg: {}, SQL: {}".format( errno2, err, wt.getDbConn().getLastSql())) - print("_", end="", flush=True) + # print("_", end="", flush=True) + Progress.emit(Progress.ACCEPTABLE_ERROR) self._err = err else: # not an acceptable error errMsg = "[=] Unexpected Taos library exception ({}): errno=0x{:X}, msg: {}, SQL: {}".format( @@ -1563,8 +1578,11 @@ class TaskCreateDb(StateTransitionTask): # numReplica = Dice.throw(gConfig.max_replicas) + 1 # 1,2 ... N numReplica = gConfig.max_replicas # fixed, always repStr = "replica {}".format(numReplica) - self.execWtSql(wt, "create database {} {}" - .format(self._db.getName(), repStr) ) + updatePostfix = "update 1" if gConfig.verify_data else "" # allow update only when "verify data" is active + dbName = self._db.getName() + self.execWtSql(wt, "create database {} {} {} ".format(dbName, repStr, updatePostfix ) ) + if dbName == "db_0" and gConfig.use_shadow_db: + self.execWtSql(wt, "create database {} {} {} ".format("db_s", repStr, updatePostfix ) ) class TaskDropDb(StateTransitionTask): @classmethod @@ -1774,13 +1792,13 @@ class TdSuperTable: ]) # TODO: add more from 'top' - if aggExpr not in ['stddev(speed)']: #TODO: STDDEV not valid for super tables?! - sql = "select {} from {}.{}".format(aggExpr, self._dbName, self.getName()) - if Dice.throw(3) == 0: # 1 in X chance - sql = sql + ' GROUP BY color' - Progress.emit(Progress.QUERY_GROUP_BY) - # Logging.info("Executing GROUP-BY query: " + sql) - ret.append(SqlQuery(sql)) + # if aggExpr not in ['stddev(speed)']: # STDDEV not valid for super tables?! (Done in TD-1049) + sql = "select {} from {}.{}".format(aggExpr, self._dbName, self.getName()) + if Dice.throw(3) == 0: # 1 in X chance + sql = sql + ' GROUP BY color' + Progress.emit(Progress.QUERY_GROUP_BY) + # Logging.info("Executing GROUP-BY query: " + sql) + ret.append(SqlQuery(sql)) return ret @@ -1988,7 +2006,7 @@ class TaskAddData(StateTransitionTask): numRecords = self.LARGE_NUMBER_OF_RECORDS if gConfig.larger_data else self.SMALL_NUMBER_OF_RECORDS fullTableName = db.getName() + '.' + regTableName - sql = "insert into {} values ".format(fullTableName) + sql = "INSERT INTO {} VALUES ".format(fullTableName) for j in range(numRecords): # number of records per table nextInt = db.getNextInt() nextTick = db.getNextTick() @@ -2016,12 +2034,24 @@ class TaskAddData(StateTransitionTask): # print("_w" + str(nextInt % 100), end="", flush=True) # Trace what was written try: - sql = "insert into {} values ('{}', {}, '{}');".format( # removed: tags ('{}', {}) + sql = "INSERT INTO {} VALUES ('{}', {}, '{}');".format( # removed: tags ('{}', {}) fullTableName, # ds.getFixedSuperTableName(), # ds.getNextBinary(), ds.getNextFloat(), nextTick, nextInt, nextColor) dbc.execute(sql) + + # Quick hack, attach an update statement here. TODO: create an "update" task + if (not gConfig.use_shadow_db) and Dice.throw(5) == 0: # 1 in N chance, plus not using shaddow DB + nextInt = db.getNextInt() + nextColor = db.getNextColor() + sql = "INSERt INTO {} VALUES ('{}', {}, '{}');".format( # "INSERt" means "update" here + fullTableName, + nextTick, nextInt, nextColor) + # sql = "UPDATE {} set speed={}, color='{}' WHERE ts='{}'".format( + # fullTableName, db.getNextInt(), db.getNextColor(), nextTick) + dbc.execute(sql) + except: # Any exception at all if gConfig.verify_data: self.unlockTable(fullTableName) @@ -2070,7 +2100,8 @@ class TaskAddData(StateTransitionTask): random.shuffle(tblSeq) # now we have random sequence for i in tblSeq: if (i in self.activeTable): # wow already active - print("x", end="", flush=True) # concurrent insertion + # print("x", end="", flush=True) # concurrent insertion + Progress.emit(Progress.CONCURRENT_INSERTION) else: self.activeTable.add(i) # marking it active @@ -2373,6 +2404,11 @@ class MainExec: '--larger-data', action='store_true', help='Write larger amount of data during write operations (default: false)') + parser.add_argument( + '-m', + '--mix-oos-data', + action='store_false', + help='Mix out-of-sequence data into the test data stream (default: true)') parser.add_argument( '-n', '--dynamic-db-table-names', @@ -2414,6 +2450,11 @@ class MainExec: '--verify-data', action='store_true', help='Verify data written in a number of places by reading back (default: false)') + parser.add_argument( + '-w', + '--use-shadow-db', + action='store_true', + help='Use a shaddow database to verify data integrity (default: false)') parser.add_argument( '-x', '--continue-on-exception', @@ -2422,6 +2463,11 @@ class MainExec: global gConfig gConfig = parser.parse_args() + crash_gen.settings.gConfig = gConfig # TODO: fix this hack, consolidate this global var + + # Sanity check for arguments + if gConfig.use_shadow_db and gConfig.max_dbs>1 : + raise CrashGenError("Cannot combine use-shadow-db with max-dbs of more than 1") Logging.clsInit(gConfig) diff --git a/tests/pytest/crash_gen/db.py b/tests/pytest/crash_gen/db.py index e38692dbe1..62a369c41a 100644 --- a/tests/pytest/crash_gen/db.py +++ b/tests/pytest/crash_gen/db.py @@ -18,6 +18,8 @@ import datetime import traceback # from .service_manager import TdeInstance +import crash_gen.settings + class DbConn: TYPE_NATIVE = "native-c" TYPE_REST = "rest-api" @@ -244,7 +246,7 @@ class MyTDSql: self._conn.close() # TODO: very important, cursor close does NOT close DB connection! self._cursor.close() - def _execInternal(self, sql): + def _execInternal(self, sql): startTime = time.time() # Logging.debug("Executing SQL: " + sql) ret = self._cursor.execute(sql) @@ -257,6 +259,27 @@ class MyTDSql: cls.longestQuery = sql cls.longestQueryTime = queryTime cls.lqStartTime = startTime + + # Now write to the shadow database + if crash_gen.settings.gConfig.use_shadow_db: + if sql[:11] == "INSERT INTO": + if sql[:16] == "INSERT INTO db_0": + sql2 = "INSERT INTO db_s" + sql[16:] + self._cursor.execute(sql2) + else: + raise CrashGenError("Did not find db_0 in INSERT statement: {}".format(sql)) + else: # not an insert statement + pass + + if sql[:12] == "CREATE TABLE": + if sql[:17] == "CREATE TABLE db_0": + sql2 = sql.replace('db_0', 'db_s') + self._cursor.execute(sql2) + else: + raise CrashGenError("Did not find db_0 in CREATE TABLE statement: {}".format(sql)) + else: # not an insert statement + pass + return ret def query(self, sql): @@ -302,12 +325,18 @@ class DbConnNative(DbConn): _lock = threading.Lock() # _connInfoDisplayed = False # TODO: find another way to display this totalConnections = 0 # Not private + totalRequests = 0 def __init__(self, dbTarget): super().__init__(dbTarget) self._type = self.TYPE_NATIVE self._conn = None - # self._cursor = None + # self._cursor = None + + @classmethod + def resetTotalRequests(cls): + with cls._lock: # force single threading for opening DB connections. # TODO: whaaat??!!! + cls.totalRequests = 0 def openByType(self): # Open connection # global gContainer @@ -356,6 +385,8 @@ class DbConnNative(DbConn): Logging.debug("[SQL] Executing SQL: {}".format(sql)) self._lastSql = sql nRows = self._tdSql.execute(sql) + cls = self.__class__ + cls.totalRequests += 1 Logging.debug( "[SQL] Execution Result, nRows = {}, SQL = {}".format( nRows, sql)) @@ -369,6 +400,8 @@ class DbConnNative(DbConn): Logging.debug("[SQL] Executing SQL: {}".format(sql)) self._lastSql = sql nRows = self._tdSql.query(sql) + cls = self.__class__ + cls.totalRequests += 1 Logging.debug( "[SQL] Query Result, nRows = {}, SQL = {}".format( nRows, sql)) diff --git a/tests/pytest/crash_gen/misc.py b/tests/pytest/crash_gen/misc.py index 6ea5691ce2..9774ec5455 100644 --- a/tests/pytest/crash_gen/misc.py +++ b/tests/pytest/crash_gen/misc.py @@ -176,11 +176,13 @@ class Progress: SERVICE_START_NAP = 7 CREATE_TABLE_ATTEMPT = 8 QUERY_GROUP_BY = 9 + CONCURRENT_INSERTION = 10 + ACCEPTABLE_ERROR = 11 tokens = { STEP_BOUNDARY: '.', - BEGIN_THREAD_STEP: '[', - END_THREAD_STEP: '] ', + BEGIN_THREAD_STEP: ' [', + END_THREAD_STEP: ']', SERVICE_HEART_BEAT: '.Y.', SERVICE_RECONNECT_START: '', @@ -188,8 +190,14 @@ class Progress: SERVICE_START_NAP: '_zz', CREATE_TABLE_ATTEMPT: 'c', QUERY_GROUP_BY: 'g', + CONCURRENT_INSERTION: 'x', + ACCEPTABLE_ERROR: '_', } @classmethod def emit(cls, token): print(cls.tokens[token], end="", flush=True) + + @classmethod + def emitStr(cls, str): + print('({})'.format(str), end="", flush=True) diff --git a/tests/pytest/crash_gen/settings.py b/tests/pytest/crash_gen/settings.py new file mode 100644 index 0000000000..3c4c91e6e0 --- /dev/null +++ b/tests/pytest/crash_gen/settings.py @@ -0,0 +1,8 @@ +from __future__ import annotations +import argparse + +gConfig: argparse.Namespace + +def init(): + global gConfig + gConfig = [] \ No newline at end of file diff --git a/tests/pytest/functions/function_operations.py b/tests/pytest/functions/function_operations.py index 4bcb9a58a3..e703147b67 100644 --- a/tests/pytest/functions/function_operations.py +++ b/tests/pytest/functions/function_operations.py @@ -95,12 +95,11 @@ class TDTestCase: for i in col_list : for j in col_list : for k in op_list : - for l in [' order by ts' , ' order by ts desc' ]: - sql = " select %s %s %s from test1 %s" % ( i , k , j , l ) - if i in err_list or j in err_list: - tdSql.error(sql) - else: - tdSql.query(sql) + sql = " select %s %s %s from test1 " % ( i , k , j ) + if i in err_list or j in err_list: + tdSql.error(sql) + else: + tdSql.query(sql) def stop(self): tdSql.close() tdLog.success("%s successfully executed" % __file__) diff --git a/tests/script/general/cache/new_metrics.sim b/tests/script/general/cache/new_metrics.sim index a13dd23bb6..00cbe843f9 100644 --- a/tests/script/general/cache/new_metrics.sim +++ b/tests/script/general/cache/new_metrics.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/cache/restart_metrics.sim b/tests/script/general/cache/restart_metrics.sim index f5035e1251..4f2dae5fd9 100644 --- a/tests/script/general/cache/restart_metrics.sim +++ b/tests/script/general/cache/restart_metrics.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 @@ -51,7 +51,7 @@ print =============== step2 system sh/exec.sh -n dnode1 -s stop sleep 3000 system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start print =============== step3 diff --git a/tests/script/general/cache/restart_table.sim b/tests/script/general/cache/restart_table.sim index fcdb2fb593..9b0d8f9c5b 100644 --- a/tests/script/general/cache/restart_table.sim +++ b/tests/script/general/cache/restart_table.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 @@ -35,7 +35,7 @@ print =============== step2 system sh/exec.sh -n dnode1 -s stop sleep 3000 system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start print =============== step3 diff --git a/tests/script/general/column/commit.sim b/tests/script/general/column/commit.sim index e1b98d3814..008bec3bf9 100644 --- a/tests/script/general/column/commit.sim +++ b/tests/script/general/column/commit.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/column/metrics.sim b/tests/script/general/column/metrics.sim index a46ab6560a..580e2320cd 100644 --- a/tests/script/general/column/metrics.sim +++ b/tests/script/general/column/metrics.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/column/table.sim b/tests/script/general/column/table.sim index 7c9302aa08..46d5de1e82 100644 --- a/tests/script/general/column/table.sim +++ b/tests/script/general/column/table.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/compress/compress.sim b/tests/script/general/compress/compress.sim index 0df2a0d4cb..cecfe61229 100644 --- a/tests/script/general/compress/compress.sim +++ b/tests/script/general/compress/compress.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c comp -v 1 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/compress/compress2.sim b/tests/script/general/compress/compress2.sim index 007d1ec339..1e6868eaa6 100644 --- a/tests/script/general/compress/compress2.sim +++ b/tests/script/general/compress/compress2.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c comp -v 2 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/compress/uncompress.sim b/tests/script/general/compress/uncompress.sim index 9c71c8c1cc..49945dcb79 100644 --- a/tests/script/general/compress/uncompress.sim +++ b/tests/script/general/compress/uncompress.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c comp -v 1 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/compute/avg.sim b/tests/script/general/compute/avg.sim index 027cfbe61d..db452b0344 100644 --- a/tests/script/general/compute/avg.sim +++ b/tests/script/general/compute/avg.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/bottom.sim b/tests/script/general/compute/bottom.sim index 5c76d5d171..7af67ecbf0 100644 --- a/tests/script/general/compute/bottom.sim +++ b/tests/script/general/compute/bottom.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/count.sim b/tests/script/general/compute/count.sim index fc481088a5..cf84918f5b 100644 --- a/tests/script/general/compute/count.sim +++ b/tests/script/general/compute/count.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/diff.sim b/tests/script/general/compute/diff.sim index 433a935609..bc303a9ca5 100644 --- a/tests/script/general/compute/diff.sim +++ b/tests/script/general/compute/diff.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/diff2.sim b/tests/script/general/compute/diff2.sim index 7406771ac6..55fa1daa95 100644 --- a/tests/script/general/compute/diff2.sim +++ b/tests/script/general/compute/diff2.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/first.sim b/tests/script/general/compute/first.sim index f12ed2b73a..fce334167b 100644 --- a/tests/script/general/compute/first.sim +++ b/tests/script/general/compute/first.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/interval.sim b/tests/script/general/compute/interval.sim index 79f3475222..c21003a646 100644 --- a/tests/script/general/compute/interval.sim +++ b/tests/script/general/compute/interval.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/last.sim b/tests/script/general/compute/last.sim index 7b7c45044f..9f20f8c5aa 100644 --- a/tests/script/general/compute/last.sim +++ b/tests/script/general/compute/last.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/last_row.sim b/tests/script/general/compute/last_row.sim index 03fa9bc4af..3b28b0baa5 100644 --- a/tests/script/general/compute/last_row.sim +++ b/tests/script/general/compute/last_row.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/leastsquare.sim b/tests/script/general/compute/leastsquare.sim index 20e2cc9d17..1c8af7fe7f 100644 --- a/tests/script/general/compute/leastsquare.sim +++ b/tests/script/general/compute/leastsquare.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/max.sim b/tests/script/general/compute/max.sim index ba87416292..f9665a823d 100644 --- a/tests/script/general/compute/max.sim +++ b/tests/script/general/compute/max.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/min.sim b/tests/script/general/compute/min.sim index e981f8335f..4a9904e065 100644 --- a/tests/script/general/compute/min.sim +++ b/tests/script/general/compute/min.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/compute/null.sim b/tests/script/general/compute/null.sim index de2a834684..cd00b7a69d 100644 --- a/tests/script/general/compute/null.sim +++ b/tests/script/general/compute/null.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/percentile.sim b/tests/script/general/compute/percentile.sim index 9798aa2f5c..b0f4fff8d7 100644 --- a/tests/script/general/compute/percentile.sim +++ b/tests/script/general/compute/percentile.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/stddev.sim b/tests/script/general/compute/stddev.sim index 2f6ffb097a..772ec8386a 100644 --- a/tests/script/general/compute/stddev.sim +++ b/tests/script/general/compute/stddev.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/sum.sim b/tests/script/general/compute/sum.sim index 230248a370..8fad992750 100644 --- a/tests/script/general/compute/sum.sim +++ b/tests/script/general/compute/sum.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/compute/top.sim b/tests/script/general/compute/top.sim index a4f482b127..1e9d302b7c 100644 --- a/tests/script/general/compute/top.sim +++ b/tests/script/general/compute/top.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 sql connect diff --git a/tests/script/general/db/backup/keep.sim b/tests/script/general/db/backup/keep.sim index 943022deba..4d157b3985 100644 --- a/tests/script/general/db/backup/keep.sim +++ b/tests/script/general/db/backup/keep.sim @@ -6,9 +6,9 @@ system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1 system sh/cfg.sh -n dnode3 -c numOfMnodes -v 1 diff --git a/tests/script/general/db/delete_reuse1.sim b/tests/script/general/db/delete_reuse1.sim index b18bb285d1..9d02e041c4 100644 --- a/tests/script/general/db/delete_reuse1.sim +++ b/tests/script/general/db/delete_reuse1.sim @@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1 diff --git a/tests/script/general/db/delete_reuse2.sim b/tests/script/general/db/delete_reuse2.sim index c82457ec42..889c8f46f7 100644 --- a/tests/script/general/db/delete_reuse2.sim +++ b/tests/script/general/db/delete_reuse2.sim @@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1 diff --git a/tests/script/general/db/delete_writing1.sim b/tests/script/general/db/delete_writing1.sim index 98e9a3d66f..010bd70743 100644 --- a/tests/script/general/db/delete_writing1.sim +++ b/tests/script/general/db/delete_writing1.sim @@ -5,10 +5,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1 diff --git a/tests/script/general/db/len.sim b/tests/script/general/db/len.sim index 561245e666..8c08d2b09a 100644 --- a/tests/script/general/db/len.sim +++ b/tests/script/general/db/len.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2000 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/db/show_create_db.sim b/tests/script/general/db/show_create_db.sim index edaa971c5c..f2e8011a0e 100644 --- a/tests/script/general/db/show_create_db.sim +++ b/tests/script/general/db/show_create_db.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/db/show_create_table.sim b/tests/script/general/db/show_create_table.sim index 0d7408748a..5f2ae61343 100644 --- a/tests/script/general/db/show_create_table.sim +++ b/tests/script/general/db/show_create_table.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/db/tables.sim b/tests/script/general/db/tables.sim index 50b6805eca..b32fae25e0 100644 --- a/tests/script/general/db/tables.sim +++ b/tests/script/general/db/tables.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode2 -c maxVgroupsPerDb -v 4 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 4 diff --git a/tests/script/general/db/topic1.sim b/tests/script/general/db/topic1.sim new file mode 100644 index 0000000000..e9e0bb5567 --- /dev/null +++ b/tests/script/general/db/topic1.sim @@ -0,0 +1,856 @@ +system sh/stop_dnodes.sh +system sh/deploy.sh -n dnode1 -i 1 + +system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 100 +system sh/cfg.sh -n dnode1 -c partitions -v 4 +system sh/exec.sh -n dnode1 -s start + +sleep 2000 +sql connect + +print ====step1 create with default para +sql create topic t1; +sql use t1; + +sql show topics; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +if $data02 != 4 then + return -1 +endi + +sql show databases; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +#tables +if $data02 < 1 then + return -1 +endi +#numofvgroups +if $data03 < 1 then + return -1 +endi + +sql show t1.vgroups; +if $rows < 1 then + return -1 +endi + +sql show t1.stables; +if $rows != 1 then + return -1 +endi +if $data04 < 1 then + return -1 +endi + +sql show t1.tables; +if $rows < 1 then + return -1 +endi + +sql drop topic t1 +sql show topics; +if $rows != 0 then + return -1 +endi +sql show databases; +if $rows != 0 then + return -1 +endi + +sql_error use t1; +sql_error show t1.vgroups; +sql_error show t1.stables; +sql_error show t1.tables; + +print ====step2 create with giving para +sql create topic t1 partitions 6; + +sql show topics; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +if $data02 != 6 then + return -1 +endi + +sql show databases; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +#tables +if $data02 != 6 then + return -1 +endi +#numofvgroups +if $data03 != 6 then + return -1 +endi + +sql show t1.vgroups; +if $rows != 6 then + return -1 +endi + +sql show t1.stables; +if $rows != 1 then + return -1 +endi +if $data00 != ps then + return -1 +endi +if $data04 != 6 then + return -1 +endi + +sql show t1.tables; +if $rows != 6 then + return -1 +endi + +sql describe t1.ps; +if $data00 != off then + return -1 +endi +if $data10 != ts then + return -1 +endi +if $data20 != content then + return -1 +endi +if $data30 != pid then + return -1 +endi + +sql describe t1.p1; +if $data00 != off then + return -1 +endi +if $data10 != ts then + return -1 +endi +if $data20 != content then + return -1 +endi +if $data30 != pid then + return -1 +endi + +sql drop topic t1 +sql show topics; +if $rows != 0 then + return -1 +endi + +sql show databases; +if $rows != 0 then + return -1 +endi + +sql_error show t1.vgroups; +sql_error show t1.stables; +sql_error show t1.tables; + +sql_error create topic t1 partitions -1; +sql_error create topic t1 partitions 0; +sql_error create topic t1 partitions 10001; + +print =============step3 create with db para +sql create topic db cache 2 blocks 4 days 10 keep 20 minRows 300 maxRows 400 ctime 120 precision 'ms' comp 2 wal 1 replica 1 +sql show databases +if $data00 != db then + return -1 +endi +if $data02 != 4 then + return -1 +endi +if $data03 != 4 then + return -1 +endi +if $data04 != 1 then + return -1 +endi +if $data06 != 10 then + return -1 +endi +if $data07 != 20,20,20 then + return -1 +endi +if $data08 != 2 then + return -1 +endi +if $data09 != 4 then + return -1 +endi +sql drop topic db; + +sql create topic db cache 2 blocks 4 days 10 keep 20 minRows 300 maxRows 400 ctime 120 precision 'ms' comp 2 wal 1 replica 1 partitions 7 +sql show databases +if $data00 != db then + return -1 +endi +if $data02 != 7 then + return -1 +endi +if $data03 != 7 then + return -1 +endi +if $data04 != 1 then + return -1 +endi +if $data06 != 10 then + return -1 +endi +if $data07 != 20,20,20 then + return -1 +endi +if $data08 != 2 then + return -1 +endi +if $data09 != 4 then + return -1 +endi + +sql show topics; +if $rows != 1 then + return -1 +endi +if $data00 != db then + return -1 +endi + +sql show databases; +if $rows != 1 then + return -1 +endi +if $data00 != db then + return -1 +endi +#tables +if $data02 != 7 then + return -1 +endi +#numofvgroups +sql show db.vgroups; +if $rows != 7 then + return -1 +endi +sql show db.stables; +if $rows != 1 then + return -1 +endi +sql show db.tables; +if $rows != 7 then + return -1 +endi + +print ============== step name +sql_error alter database db name d1 +sql_error alter database db name d2 +sql_error alter topic db name d1 +sql_error alter topic db name d2 + +print ============== step ntables +sql_error alter database db ntables -1 +sql_error alter database db ntables 0 +sql_error alter database db ntables 1 +sql_error alter database db ntables 10 +sql_error alter topic db ntables -1 +sql_error alter topic db ntables 0 +sql_error alter topic db ntables 1 +sql_error alter topic db ntables 10 + +print ============== step vgroups +sql_error alter database db vgroups -1 +sql_error alter database db vgroups 0 +sql_error alter database db vgroups 1 +sql_error alter database db vgroups 10 +sql_error alter topic db vgroups -1 +sql_error alter topic db vgroups 0 +sql_error alter topic db vgroups 1 +sql_error alter topic db vgroups 10 + +print ============== step replica +sql_error alter database db replica 2 +sql_error alter database db replica 3 +sql_error alter database db replica 0 +sql_error alter topic db replica 2 +sql_error alter topic db replica 3 +sql_error alter topic db replica 0 + +sql alter database db replica 1 +sql show databases +print replica $data4_db +if $data4_db != 1 then + return -1 +endi + +sql show topics +if $rows != 1 then + return -1 +endi + +print ============== step quorum +sql show databases +print quorum $data5_db +if $data5_db != 1 then + return -1 +endi + +sql_error alter topic db quorum 1 +sql alter database db quorum 1 +sql show databases +print quorum $data5_db +if $data5_db != 1 then + return -1 +endi + +sql_error alter database db quorum 2 +sql_error alter database db quorum 3 +sql_error alter topic db quorum 2 +sql_error alter topic db quorum 3 + +sql_error alter database db quorum 0 +sql_error alter database db quorum 4 +sql_error alter database db quorum 5 +sql_error alter database db quorum -1 +sql_error alter topic db quorum 0 +sql_error alter topic db quorum 4 +sql_error alter topic db quorum 5 +sql_error alter topic db quorum -1 + +print ============== step days +sql_error alter database db days 0 +sql_error alter database db days 1 +sql_error alter database db days 2 +sql_error alter database db days 10 +sql_error alter database db days 50 +sql_error alter database db days 100 +sql_error alter topic db days 0 +sql_error alter topic db days 1 +sql_error alter topic db days 2 +sql_error alter topic db days 10 +sql_error alter topic db days 50 +sql_error alter topic db days 100 + +print ============== step keep +sql show databases +print keep $data7_db +if $data7_db != 20,20,20 then + return -1 +endi + +sql_error topic db keep 20 +sql alter database db keep 20 +sql show databases +print keep $data7_db +if $data7_db != 20,20,20 then + return -1 +endi + +sql_error topic db keep 30 +sql alter database db keep 30 +sql show databases +print keep $data7_db +if $data7_db != 20,20,30 then + return -1 +endi + +sql_error alter topic db keep 40 +sql alter database db keep 40 +sql show databases +print keep $data7_db +if $data7_db != 20,20,40 then + return -1 +endi + +sql alter database db keep 40 +sql alter database db keep 30 +sql alter database db keep 20 +sql_error alter database db keep 10 +sql_error alter database db keep 9 +sql_error alter database db keep 1 +sql alter database db keep 0 +sql alter database db keep -1 +sql_error alter database db keep 365001 + +sql_error alter topic db keep 40 +sql_error alter topic db keep 30 +sql_error alter topic db keep 20 +sql_error alter topic db keep 10 +sql_error alter topic db keep 9 +sql_error alter topic db keep 1 +sql_error alter topic db keep 0 +sql_error alter topic db keep -1 +sql_error alter topic db keep 365001 + +print ============== step cache +sql_error alter database db cache 60 +sql_error alter database db cache 50 +sql_error alter database db cache 20 +sql_error alter database db cache 3 +sql_error alter database db cache 129 +sql_error alter database db cache 300 +sql_error alter database db cache 0 +sql_error alter database db cache -1 + +sql_error alter topic db cache 60 +sql_error alter topic db cache 50 +sql_error alter topic db cache 20 +sql_error alter topic db cache 3 +sql_error alter topic db cache 129 +sql_error alter topic db cache 300 +sql_error alter topic db cache 0 +sql_error alter topic db cache -1 + +print ============== step blocks +sql show databases +print blocks $data9_db +if $data9_db != 4 then + return -1 +endi + +sql_error alter topic db blocks 10 +sql alter database db blocks 10 +sql show databases +print blocks $data9_db +if $data9_db != 10 then + return -1 +endi + +sql_error alter topic db blocks 20 +sql alter database db blocks 20 +sql show databases +print blocks $data9_db +if $data9_db != 20 then + return -1 +endi + +sql_error alter topic db blocks 20 +sql alter database db blocks 30 +sql show databases +print blocks $data9_db +if $data9_db != 30 then + return -1 +endi + +sql alter database db blocks 40 +sql alter database db blocks 30 +sql alter database db blocks 20 +sql alter database db blocks 10 +sql_error alter database db blocks 2 +sql_error alter database db blocks 1 +sql alter database db blocks 0 +sql_error alter database db blocks -1 +sql_error alter database db blocks 10001 + +sql_error alter topic db blocks 40 +sql_error alter topic db blocks 30 +sql_error alter topic db blocks 20 +sql_error alter topic db blocks 10 +sql_error alter topic db blocks 2 +sql_error alter topic db blocks 1 +sql_error alter topic db blocks 0 +sql_error alter topic db blocks -1 +sql_error alter topic db blocks 10001 + +print ============== step minrows +sql_error alter database db minrows 1 +sql_error alter database db minrows 100 +sql_error alter database db minrows 1000 + +sql_error alter topic db minrows 1 +sql_error alter topic db minrows 100 +sql_error alter topic db minrows 1000 + +print ============== step maxrows +sql_error alter database db maxrows 1 +sql_error alter database db maxrows 100 +sql_error alter database db maxrows 1000 + +sql_error alter topic db maxrows 1 +sql_error alter topic db maxrows 100 +sql_error alter topic db maxrows 1000 + +print ============== step wallevel +sql show databases +print wallevel $data12_db +if $data12_db != 1 then + return -1 +endi + +sql_error alter topic db wal 1 +sql alter database db wal 1 +sql show databases +print wal $data12_db +if $data12_db != 1 then + return -1 +endi + +sql alter database db wal 1 +sql alter database db wal 2 +sql alter database db wal 1 +sql alter database db wal 2 +sql alter database db wal 0 +sql_error alter database db wal 3 +sql_error alter database db wal 4 +sql_error alter database db wal -1 +sql_error alter database db wal 1000 + +sql_error alter topic db wal 1 +sql_error alter topic db wal 2 +sql_error alter topic db wal 1 +sql_error alter topic db wal 2 +sql_error alter topic db wal 0 +sql_error alter topic db wal 3 +sql_error alter topic db wal 4 +sql_error alter topic db wal -1 +sql_error alter topic db wal 1000 + +print ============== step fsync +sql alter database db fsync 0 +sql alter database db fsync 1 +sql alter database db fsync 3600 +sql alter database db fsync 18000 +sql alter database db fsync 180000 +sql_error alter database db fsync 180001 +sql_error alter database db fsync -1 + +sql_error alter topic db fsync 0 +sql_error alter topic db fsync 1 +sql_error alter topic db fsync 3600 +sql_error alter topic db fsync 18000 +sql_error alter topic db fsync 180000 +sql_error alter topic db fsync 180001 +sql_error alter topic db fsync -1 + +print ============== step comp +sql show databases +print comp $data14_db +if $data14_db != 2 then + return -1 +endi + +sql_error alter topic db comp 1 +sql alter database db comp 1 +sql show databases +print comp $data14_db +if $data14_db != 1 then + return -1 +endi + +sql_error alter topic db comp 2 +sql alter database db comp 2 +sql show databases +print comp $data14_db +if $data14_db != 2 then + return -1 +endi + +sql_error alter topic db comp 0 +sql alter database db comp 0 +sql show databases +print comp $data14_db +if $data14_db != 0 then + return -1 +endi + +sql_error alter database db comp 3 +sql_error alter database db comp 4 +sql_error alter database db comp 5 +sql_error alter database db comp -1 + +sql_error alter topic db comp 3 +sql_error alter topic db comp 4 +sql_error alter topic db comp 5 +sql_error alter topic db comp -1 + +print ============== step precision +sql_error alter database db prec 'us' +sql_error alter topic db prec 'us' + +print ============== step status +sql_error alter database db status 'delete' +sql_error alter topic db status 'delete' + +print ============== step drop +sql drop database db +sql show topics; +if $rows != 0 then + return -1 +endi + +sql show databases; +if $rows != 0 then + return -1 +endi + +print ============== step db1 +sql create database d1 +sql_error alter database d1 partitions 2 +sql_error alter topic d1 partitions 2 + +sql show topics; +if $rows != 0 then + return -1 +endi + +sql show databases; +if $rows != 1 then + return -1 +endi + +sql alter database d1 fsync 0 +sql show topics; +if $rows != 0 then + return -1 +endi + +sql show databases; +if $rows != 1 then + return -1 +endi + +sql drop database d1 +sql show topics; +if $rows != 0 then + return -1 +endi + +sql show databases; +if $rows != 0 then + return -1 +endi + +print ============== step db2 +sql create topic d1 +sql show topics; +if $rows != 1 then + return -1 +endi + +sql show databases; +if $rows != 1 then + return -1 +endi + +sql alter database d1 fsync 0 +sql show topics; +if $rows != 1 then + return -1 +endi + +sql show databases; +if $rows != 1 then + return -1 +endi + +sql drop database d1 +sql show topics; +if $rows != 0 then + return -1 +endi + +sql show databases; +if $rows != 0 then + return -1 +endi + +print ============== step db3 +sql create topic d1 +sql show topics; +if $rows != 1 then + return -1 +endi + +sql show databases; +if $rows != 1 then + return -1 +endi + +sql alter topic d1 partitions 2 +sql show topics; +if $rows != 1 then + return -1 +endi + +sql show databases; +if $rows != 1 then + return -1 +endi + +sql drop database d1 +sql show topics; +if $rows != 0 then + return -1 +endi + +sql show databases; +if $rows != 0 then + return -1 +endi + +print ============== step partitions +sql create topic t1 partitions 5 + +sql_error alter database t1 partitions -1 +sql_error alter database t1 partitions 0 +sql_error alter database t1 partitions 1 +sql_error alter database t1 partitions 2 +sql_error alter database t1 partitions 3 +sql_error alter database t1 partitions 100 +sql_error alter database t1 partitions 1000 +sql_error alter database t1 partitions 10000 + +sql_error alter topic t1 partitions -1 +sql_error alter topic t1 partitions 0 +sql_error alter database t1 partitions 10000 + +sql alter topic t1 partitions 1 +sql show topics; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +sql show databases; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +#tables +if $data02 != 1 then + return -1 +endi +#numofvgroups +sql show t1.vgroups; +if $rows != 1 then + return -1 +endi +sql show t1.stables; +if $rows != 1 then + return -1 +endi +sql show t1.tables; +if $rows != 1 then + return -1 +endi + +sql alter topic t1 partitions 2 +sql show topics; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +sql show databases; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +#tables +if $data02 != 2 then + return -1 +endi +#numofvgroups +sql show t1.vgroups; +if $rows != 2 then + return -1 +endi +sql show t1.stables; +if $rows != 1 then + return -1 +endi +sql show t1.tables; +if $rows != 2 then + return -1 +endi + +sql alter topic t1 partitions 3 +sql show topics; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +sql show databases; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +#tables +if $data02 != 3 then + return -1 +endi +#numofvgroups +sql show t1.vgroups; +if $rows != 3 then + return -1 +endi +sql show t1.stables; +if $rows != 1 then + return -1 +endi +sql show t1.tables; +if $rows != 3 then + return -1 +endi + +sql alter topic t1 partitions 10 +sql show topics; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +sql show databases; +if $rows != 1 then + return -1 +endi +if $data00 != t1 then + return -1 +endi +#tables +if $data02 != 10 then + return -1 +endi +#numofvgroups +sql show t1.vgroups; +if $rows != 10 then + return -1 +endi +sql show t1.stables; +if $rows != 1 then + return -1 +endi +sql show t1.tables; +if $rows != 10 then + return -1 +endi + +system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/general/db/topic2.sim b/tests/script/general/db/topic2.sim new file mode 100644 index 0000000000..f933f5eee4 --- /dev/null +++ b/tests/script/general/db/topic2.sim @@ -0,0 +1,321 @@ +system sh/stop_dnodes.sh +system sh/deploy.sh -n dnode1 -i 1 + +system sh/exec.sh -n dnode1 -s start + +sleep 2000 +sql connect + +print ==== step1 +sql create topic t1 partitions 2; +sql show t1.tables +if $rows != 2 then + return -1 +endi +sql show t1.vgroups +if $rows != 2 then + return -1 +endi + +sql insert into t1.p1 values(1, now, '1'); +sql insert into t1.p1 values(1, now, '2'); +sql insert into t1.p1 values(1, now, '3'); +sql insert into t1.p1 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p1 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p1 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql insert into t1.p2 values(1, now, '1'); +sql insert into t1.p2 values(1, now, '2'); +sql insert into t1.p2 values(1, now, '3'); +sql insert into t1.p2 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p2 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p2 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql_error insert into t1.p3 values(1, now, '1'); +sql_error insert into t1.p3 values(1, now, '2'); +sql_error insert into t1.p3 values(1, now, '3'); +sql_error insert into t1.p3 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql_error insert into t1.p3 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql_error insert into t1.p3 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql select * from t1.p1 order by off asc +if $rows != 33 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +sql select * from t1.p2 order by off asc +if $rows != 33 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +print ==== step2 +sql alter topic t1 partitions 4; +sql show t1.tables +if $rows != 4 then + return -1 +endi +sql show t1.vgroups +if $rows != 4 then + return -1 +endi + +sql insert into t1.p1 values(1, now, '1'); +sql insert into t1.p1 values(1, now, '2'); +sql insert into t1.p1 values(1, now, '3'); +sql insert into t1.p1 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p1 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p1 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql insert into t1.p2 values(1, now, '1'); +sql insert into t1.p2 values(1, now, '2'); +sql insert into t1.p2 values(1, now, '3'); +sql insert into t1.p2 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p2 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p2 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql insert into t1.p3 values(1, now, '1'); +sql insert into t1.p3 values(1, now, '2'); +sql insert into t1.p3 values(1, now, '3'); +sql insert into t1.p3 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p3 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p3 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql insert into t1.p4 values(1, now, '1'); +sql insert into t1.p4 values(1, now, '2'); +sql insert into t1.p4 values(1, now, '3'); +sql insert into t1.p4 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p4 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p4 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql_error insert into t1.p5 values(1, now, '1'); +sql_error insert into t1.p5 values(1, now, '2'); +sql_error insert into t1.p5 values(1, now, '3'); +sql_error insert into t1.p5 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql_error insert into t1.p5 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql_error insert into t1.p5 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql select * from t1.p1 order by off asc +if $rows != 66 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +sql select * from t1.p2 order by off asc +if $rows != 66 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +sql select * from t1.p3 order by off asc +if $rows != 33 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +sql select * from t1.p4 order by off asc +if $rows != 33 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +print ==== step3 +sql alter topic t1 partitions 1; +sql show t1.tables +if $rows != 1 then + return -1 +endi +sql show t1.vgroups +if $rows != 1 then + return -1 +endi + +sql insert into t1.p1 values(1, now, '1'); +sql insert into t1.p1 values(1, now, '2'); +sql insert into t1.p1 values(1, now, '3'); +sql insert into t1.p1 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p1 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p1 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql_error insert into t1.p2 values(1, now, '1'); +sql_error insert into t1.p2 values(1, now, '2'); +sql_error insert into t1.p2 values(1, now, '3'); +sql_error insert into t1.p2 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql_error insert into t1.p2 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql_error insert into t1.p2 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql_error insert into t1.p3 values(1, now, '1'); +sql_error insert into t1.p3 values(1, now, '2'); +sql_error insert into t1.p3 values(1, now, '3'); +sql_error insert into t1.p3 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql_error insert into t1.p3 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql_error insert into t1.p3 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql_error insert into t1.p4 values(1, now, '1'); +sql_error insert into t1.p4 values(1, now, '2'); +sql_error insert into t1.p4 values(1, now, '3'); +sql_error insert into t1.p4 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql_error insert into t1.p4 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql_error insert into t1.p4 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql_error insert into t1.p5 values(1, now, '1'); +sql_error insert into t1.p5 values(1, now, '2'); +sql_error insert into t1.p5 values(1, now, '3'); +sql_error insert into t1.p5 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql_error insert into t1.p5 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql_error insert into t1.p5 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql select * from t1.p1 order by off asc +if $rows != 99 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +sql_error select * from t1.p2 order by off asc +sql_error select * from t1.p3 order by off asc +sql_error select * from t1.p4 order by off asc + +print ==== step4 +sql alter topic t1 partitions 3; +sql show t1.tables +if $rows != 3 then + return -1 +endi +sql show t1.vgroups +if $rows != 3 then + return -1 +endi + +sql insert into t1.p1 values(1, now, '1'); +sql insert into t1.p1 values(1, now, '2'); +sql insert into t1.p1 values(1, now, '3'); +sql insert into t1.p1 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p1 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p1 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql insert into t1.p2 values(1, now, '1'); +sql insert into t1.p2 values(1, now, '2'); +sql insert into t1.p2 values(1, now, '3'); +sql insert into t1.p2 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p2 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p2 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql insert into t1.p3 values(1, now, '1'); +sql insert into t1.p3 values(1, now, '2'); +sql insert into t1.p3 values(1, now, '3'); +sql insert into t1.p3 values(1, now, '4')(2, now, '5')(3, now, '6')(4, now, '7')(5, now, '8')(6, now, '9'); +sql insert into t1.p3 values(1, now, '10')(2, now, '11')(3, now, '12')(4, now, '13')(5, now, '14')(6, now, '15'); +sql insert into t1.p3 values(1, now, '16')(2, now,'17')(3, now,'18')(4, now,'19')(5, now,'20')(6, now,'21')(7, now,'22')(8, now,'23')(9, now,'24')(10, now,'25')(11, now,'26')(12, now,'27')(13, now,'28')(14, now,'29')(15, now,'30')(16, now,'31')(17, now,'32')(18, now,'33'); + +sql_error insert into t1.p4 values(1, now, '1'); +sql_error insert into t1.p5 values(1, now, '1'); +sql_error insert into t1.p6 values(1, now, '1'); +sql_error select * from t1.p4 order by off asc +sql_error select * from t1.p5 order by off asc +sql_error select * from t1.p6 order by off asc + +sql select * from t1.p1 order by off asc +if $rows != 132 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +sql select * from t1.p2 order by off asc +if $rows != 33 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +sql select * from t1.p3 order by off asc +if $rows != 33 then + return -1 +endi +if $data02 != 1 then + return -1 +endi +if $data12 != 2 then + return -1 +endi +if $data22 != 3 then + return -1 +endi + +sql select * from t1.ps order by off asc +if $rows != 198 then + return -1 +endi + +system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/general/db/vnodes.sim b/tests/script/general/db/vnodes.sim index b123e91ad1..96f68f1632 100644 --- a/tests/script/general/db/vnodes.sim +++ b/tests/script/general/db/vnodes.sim @@ -5,7 +5,7 @@ $maxTables = 4 $totalRows = $totalVnodes * $maxTables system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v $maxTables system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v $totalVnodes system sh/cfg.sh -n dnode1 -c maxVnodeConnections -v 100000 @@ -44,4 +44,4 @@ if $data00 != $totalRows then return -1 endi -system sh/exec.sh -n dnode1 -s stop -x SIGINT \ No newline at end of file +system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/general/field/2.sim b/tests/script/general/field/2.sim index 812301dfbd..dc39e5ad60 100644 --- a/tests/script/general/field/2.sim +++ b/tests/script/general/field/2.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/3.sim b/tests/script/general/field/3.sim index a531caaca0..b45e3a005b 100644 --- a/tests/script/general/field/3.sim +++ b/tests/script/general/field/3.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/4.sim b/tests/script/general/field/4.sim index c530ff62d1..e219be8778 100644 --- a/tests/script/general/field/4.sim +++ b/tests/script/general/field/4.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/5.sim b/tests/script/general/field/5.sim index a676281313..e02bbd122f 100644 --- a/tests/script/general/field/5.sim +++ b/tests/script/general/field/5.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/6.sim b/tests/script/general/field/6.sim index f187d7db10..a852230cea 100644 --- a/tests/script/general/field/6.sim +++ b/tests/script/general/field/6.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/bigint.sim b/tests/script/general/field/bigint.sim index c9bda687e1..3bb120c641 100644 --- a/tests/script/general/field/bigint.sim +++ b/tests/script/general/field/bigint.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/binary.sim b/tests/script/general/field/binary.sim index 36a43272ca..d601750b0d 100644 --- a/tests/script/general/field/binary.sim +++ b/tests/script/general/field/binary.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/bool.sim b/tests/script/general/field/bool.sim index d8e613572a..796ed4e0aa 100644 --- a/tests/script/general/field/bool.sim +++ b/tests/script/general/field/bool.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/double.sim b/tests/script/general/field/double.sim index f7dac3192a..ef86585e5f 100644 --- a/tests/script/general/field/double.sim +++ b/tests/script/general/field/double.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/float.sim b/tests/script/general/field/float.sim index 3ab5602c55..a01bcbdd4c 100644 --- a/tests/script/general/field/float.sim +++ b/tests/script/general/field/float.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/int.sim b/tests/script/general/field/int.sim index 5c3cec99cf..c04fe5d2b1 100644 --- a/tests/script/general/field/int.sim +++ b/tests/script/general/field/int.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/single.sim b/tests/script/general/field/single.sim index d572f6df2a..0cfb92aad5 100644 --- a/tests/script/general/field/single.sim +++ b/tests/script/general/field/single.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/smallint.sim b/tests/script/general/field/smallint.sim index 8bd9972321..1d5566812e 100644 --- a/tests/script/general/field/smallint.sim +++ b/tests/script/general/field/smallint.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/field/tinyint.sim b/tests/script/general/field/tinyint.sim index 3a2d7bc44e..f10e3d293a 100644 --- a/tests/script/general/field/tinyint.sim +++ b/tests/script/general/field/tinyint.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/http/grafana.sim b/tests/script/general/http/grafana.sim index ca2f62a368..414b859bd3 100644 --- a/tests/script/general/http/grafana.sim +++ b/tests/script/general/http/grafana.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh sleep 2000 system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c http -v 1 #system sh/cfg.sh -n dnode1 -c adminRowLimit -v 10 system sh/cfg.sh -n dnode1 -c httpDebugFlag -v 135 diff --git a/tests/script/general/http/grafana_bug.sim b/tests/script/general/http/grafana_bug.sim index ce039af44c..e66cd29dea 100644 --- a/tests/script/general/http/grafana_bug.sim +++ b/tests/script/general/http/grafana_bug.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh sleep 2000 system sh/deploy.sh -n dnode1 -i 1 system sh/cfg.sh -n dnode1 -c http -v 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 #system sh/cfg.sh -n dnode1 -c adminRowLimit -v 10 system sh/cfg.sh -n dnode1 -c httpDebugFlag -v 135 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/http/prepare.sim b/tests/script/general/http/prepare.sim index 6803643caf..4bf6b61198 100644 --- a/tests/script/general/http/prepare.sim +++ b/tests/script/general/http/prepare.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh sleep 2000 system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c http -v 1 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/http/restful_insert.sim b/tests/script/general/http/restful_insert.sim index 90bf7e1b15..b77a1dd497 100644 --- a/tests/script/general/http/restful_insert.sim +++ b/tests/script/general/http/restful_insert.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh sleep 2000 system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c http -v 1 system sh/cfg.sh -n dnode1 -c httpEnableRecordSql -v 1 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/http/restful_limit.sim b/tests/script/general/http/restful_limit.sim index c925656b36..48a4fdf7d3 100644 --- a/tests/script/general/http/restful_limit.sim +++ b/tests/script/general/http/restful_limit.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh sleep 2000 system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/http/telegraf.sim b/tests/script/general/http/telegraf.sim index f342697186..9fc153b232 100644 --- a/tests/script/general/http/telegraf.sim +++ b/tests/script/general/http/telegraf.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh sleep 2000 system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c http -v 1 system sh/cfg.sh -n dnode1 -c httpEnableRecordSql -v 1 system sh/cfg.sh -n dnode1 -c telegrafUseFieldNum -v 0 diff --git a/tests/script/general/import/basic.sim b/tests/script/general/import/basic.sim index 50c4059c52..f72d132ca3 100644 --- a/tests/script/general/import/basic.sim +++ b/tests/script/general/import/basic.sim @@ -19,10 +19,10 @@ system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode4 -c maxtablesPerVnode -v 2000 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 print ========= start dnode1 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/import/commit.sim b/tests/script/general/import/commit.sim index 0aa63b14ff..3b4055d712 100644 --- a/tests/script/general/import/commit.sim +++ b/tests/script/general/import/commit.sim @@ -19,10 +19,10 @@ system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode4 -c maxtablesPerVnode -v 2000 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 print ========= start dnode1 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/import/large.sim b/tests/script/general/import/large.sim index 3b82c0355a..23fbcc75ea 100644 --- a/tests/script/general/import/large.sim +++ b/tests/script/general/import/large.sim @@ -19,10 +19,10 @@ system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 2000 system sh/cfg.sh -n dnode4 -c maxtablesPerVnode -v 2000 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 print ========= start dnode1 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/insert/basic.sim b/tests/script/general/insert/basic.sim index c688342fc5..88eb30a1ad 100644 --- a/tests/script/general/insert/basic.sim +++ b/tests/script/general/insert/basic.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/insert/query_block1_file.sim b/tests/script/general/insert/query_block1_file.sim index 63f46d84f1..636b9530f9 100644 --- a/tests/script/general/insert/query_block1_file.sim +++ b/tests/script/general/insert/query_block1_file.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/insert/query_block1_memory.sim b/tests/script/general/insert/query_block1_memory.sim index 516085f93f..823e466ee9 100644 --- a/tests/script/general/insert/query_block1_memory.sim +++ b/tests/script/general/insert/query_block1_memory.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/insert/query_block2_file.sim b/tests/script/general/insert/query_block2_file.sim index a1fa920c0f..5b7438875e 100644 --- a/tests/script/general/insert/query_block2_file.sim +++ b/tests/script/general/insert/query_block2_file.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/insert/query_block2_memory.sim b/tests/script/general/insert/query_block2_memory.sim index 9ce0b942d4..fb41981c89 100644 --- a/tests/script/general/insert/query_block2_memory.sim +++ b/tests/script/general/insert/query_block2_memory.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/insert/query_file_memory.sim b/tests/script/general/insert/query_file_memory.sim index d43328a65a..f920c215c0 100644 --- a/tests/script/general/insert/query_file_memory.sim +++ b/tests/script/general/insert/query_file_memory.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/insert/query_multi_file.sim b/tests/script/general/insert/query_multi_file.sim index 3b70dd6214..bbca53d309 100644 --- a/tests/script/general/insert/query_multi_file.sim +++ b/tests/script/general/insert/query_multi_file.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/insert/tcp.sim b/tests/script/general/insert/tcp.sim index 50383efb49..002d84dcae 100644 --- a/tests/script/general/insert/tcp.sim +++ b/tests/script/general/insert/tcp.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/parser/alter.sim b/tests/script/general/parser/alter.sim index e604d2122e..31d255115e 100644 --- a/tests/script/general/parser/alter.sim +++ b/tests/script/general/parser/alter.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/alter1.sim b/tests/script/general/parser/alter1.sim index 26ed029050..a52202fc1a 100644 --- a/tests/script/general/parser/alter1.sim +++ b/tests/script/general/parser/alter1.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/alter_stable.sim b/tests/script/general/parser/alter_stable.sim index 17fc8d984a..8a7f4fa924 100644 --- a/tests/script/general/parser/alter_stable.sim +++ b/tests/script/general/parser/alter_stable.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/auto_create_tb.sim b/tests/script/general/parser/auto_create_tb.sim index 926eb75476..a902469fde 100644 --- a/tests/script/general/parser/auto_create_tb.sim +++ b/tests/script/general/parser/auto_create_tb.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/parser/between_and.sim b/tests/script/general/parser/between_and.sim index 2e031c4917..cdced47cb6 100644 --- a/tests/script/general/parser/between_and.sim +++ b/tests/script/general/parser/between_and.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/parser/binary_escapeCharacter.sim b/tests/script/general/parser/binary_escapeCharacter.sim index dc54add763..f0589d154f 100644 --- a/tests/script/general/parser/binary_escapeCharacter.sim +++ b/tests/script/general/parser/binary_escapeCharacter.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/col_arithmetic_operation.sim b/tests/script/general/parser/col_arithmetic_operation.sim index 3911c2dca6..7611bd582f 100644 --- a/tests/script/general/parser/col_arithmetic_operation.sim +++ b/tests/script/general/parser/col_arithmetic_operation.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/columnValue.sim b/tests/script/general/parser/columnValue.sim index 4e6c664004..c98542fbf2 100644 --- a/tests/script/general/parser/columnValue.sim +++ b/tests/script/general/parser/columnValue.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/commit.sim b/tests/script/general/parser/commit.sim index 4085ef620d..dfe521b92b 100644 --- a/tests/script/general/parser/commit.sim +++ b/tests/script/general/parser/commit.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxTablesperVnode -v 100 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/constCol.sim b/tests/script/general/parser/constCol.sim index 4a8e443281..716d36e82b 100644 --- a/tests/script/general/parser/constCol.sim +++ b/tests/script/general/parser/constCol.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c dDebugFlag -v 135 system sh/cfg.sh -n dnode1 -c mDebugFlag -v 135 diff --git a/tests/script/general/parser/create_db.sim b/tests/script/general/parser/create_db.sim index ea1cc17a6a..9ca84af136 100644 --- a/tests/script/general/parser/create_db.sim +++ b/tests/script/general/parser/create_db.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/create_mt.sim b/tests/script/general/parser/create_mt.sim index 9278fbfba4..830b72f93f 100644 --- a/tests/script/general/parser/create_mt.sim +++ b/tests/script/general/parser/create_mt.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/create_tb.sim b/tests/script/general/parser/create_tb.sim index 48b7a0fb19..d30a1392ef 100644 --- a/tests/script/general/parser/create_tb.sim +++ b/tests/script/general/parser/create_tb.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/create_tb_with_tag_name.sim b/tests/script/general/parser/create_tb_with_tag_name.sim index bbd5fc11e1..130f4097f6 100644 --- a/tests/script/general/parser/create_tb_with_tag_name.sim +++ b/tests/script/general/parser/create_tb_with_tag_name.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/parser/dbtbnameValidate.sim b/tests/script/general/parser/dbtbnameValidate.sim index 5fc67334c4..f2e6de81f1 100644 --- a/tests/script/general/parser/dbtbnameValidate.sim +++ b/tests/script/general/parser/dbtbnameValidate.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/fill.sim b/tests/script/general/parser/fill.sim index aac79e1a3c..7bf00145d6 100644 --- a/tests/script/general/parser/fill.sim +++ b/tests/script/general/parser/fill.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/fill_stb.sim b/tests/script/general/parser/fill_stb.sim index a9547b8a94..ba8ddbdf6a 100644 --- a/tests/script/general/parser/fill_stb.sim +++ b/tests/script/general/parser/fill_stb.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/fill_us.sim b/tests/script/general/parser/fill_us.sim index a429df059b..8cd2c33347 100644 --- a/tests/script/general/parser/fill_us.sim +++ b/tests/script/general/parser/fill_us.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/first_last.sim b/tests/script/general/parser/first_last.sim index aeff740a5f..f47f67ddc6 100644 --- a/tests/script/general/parser/first_last.sim +++ b/tests/script/general/parser/first_last.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxTablespervnode -v 4 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/function.sim b/tests/script/general/parser/function.sim index af16bfd4f1..8eb6aa55f2 100644 --- a/tests/script/general/parser/function.sim +++ b/tests/script/general/parser/function.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/groupby.sim b/tests/script/general/parser/groupby.sim index 19b14e327c..a83c975be2 100644 --- a/tests/script/general/parser/groupby.sim +++ b/tests/script/general/parser/groupby.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/import.sim b/tests/script/general/parser/import.sim index d626f4fa74..4468ab87a9 100644 --- a/tests/script/general/parser/import.sim +++ b/tests/script/general/parser/import.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/import_file.sim b/tests/script/general/parser/import_file.sim index e50fc92e28..217679047a 100644 --- a/tests/script/general/parser/import_file.sim +++ b/tests/script/general/parser/import_file.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 500 sql connect diff --git a/tests/script/general/parser/insert_multiTbl.sim b/tests/script/general/parser/insert_multiTbl.sim index e9ee4fcf98..b17323280e 100644 --- a/tests/script/general/parser/insert_multiTbl.sim +++ b/tests/script/general/parser/insert_multiTbl.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 500 sql connect diff --git a/tests/script/general/parser/insert_tb.sim b/tests/script/general/parser/insert_tb.sim index f212325f26..1e431aef3d 100644 --- a/tests/script/general/parser/insert_tb.sim +++ b/tests/script/general/parser/insert_tb.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/interp.sim b/tests/script/general/parser/interp.sim index 13b6a08024..3fb91e36c6 100644 --- a/tests/script/general/parser/interp.sim +++ b/tests/script/general/parser/interp.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/join.sim b/tests/script/general/parser/join.sim index 56f115051c..392228e121 100644 --- a/tests/script/general/parser/join.sim +++ b/tests/script/general/parser/join.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c debugFlag -v 135 system sh/cfg.sh -n dnode1 -c rpcDebugFlag -v 135 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 diff --git a/tests/script/general/parser/join_multivnode.sim b/tests/script/general/parser/join_multivnode.sim index 9d7cdfe3d7..2322496a94 100644 --- a/tests/script/general/parser/join_multivnode.sim +++ b/tests/script/general/parser/join_multivnode.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/parser/last_groupby.sim b/tests/script/general/parser/last_groupby.sim new file mode 100644 index 0000000000..f993324cd1 --- /dev/null +++ b/tests/script/general/parser/last_groupby.sim @@ -0,0 +1,99 @@ +system sh/stop_dnodes.sh +system sh/deploy.sh -n dnode1 -i 1 +system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2 +system sh/exec.sh -n dnode1 -s start + +sleep 100 +sql connect +print ======================== dnode1 start + +$db = testdb + +sql create database $db +sql use $db + +sql create stable st2 (ts timestamp, f1 int, f2 float, f3 double, f4 bigint, f5 smallint, f6 tinyint, f7 bool, f8 binary(10), f9 nchar(10)) tags (id1 int, id2 float, id3 nchar(10), id4 double, id5 smallint, id6 bigint, id7 binary(10)) + +sql create table tb1 using st2 tags (1,1.0,"1",1.0,1,1,"1"); + +sql insert into tb1 values (now-200s,1,1.0,1.0,1,1,1,true,"1","1") +sql insert into tb1 values (now-100s,2,2.0,2.0,2,2,2,true,"2","2") +sql insert into tb1 values (now,3,3.0,3.0,3,3,3,true,"3","3") +sql insert into tb1 values (now+100s,4,4.0,4.0,4,4,4,true,"4","4") +sql insert into tb1 values (now+200s,4,4.0,4.0,4,4,4,true,"4","4") +sql insert into tb1 values (now+300s,4,4.0,4.0,4,4,4,true,"4","4") +sql insert into tb1 values (now+400s,4,4.0,4.0,4,4,4,true,"4","4") +sql insert into tb1 values (now+500s,4,4.0,4.0,4,4,4,true,"4","4") + +sql select f1,last(*) from st2 group by f1; + +if $rows != 4 then + return -1 +endi + +if $data00 != 1 then + return -1 +endi + +if $data02 != 1 then + print $data02 + return -1 +endi +if $data03 != 1.00000 then + return -1 +endi +if $data04 != 1.000000000 then + return -1 +endi +if $data05 != 1 then + return -1 +endi +if $data06 != 1 then + return -1 +endi +if $data07 != 1 then + return -1 +endi +if $data08 != 1 then + return -1 +endi +if $data09 != 1 then + return -1 +endi + +sql select f1,last(f1,st2.*) from st2 group by f1; +if $rows != 4 then + return -1 +endi + +if $data00 != 1 then + return -1 +endi + +if $data01 != 1 then + return -1 +endi +if $data03 != 1 then + return -1 +endi +if $data04 != 1.00000 then + return -1 +endi +if $data05 != 1.000000000 then + return -1 +endi +if $data06 != 1 then + return -1 +endi +if $data07 != 1 then + return -1 +endi +if $data08 != 1 then + return -1 +endi +if $data09 != 1 then + return -1 +endi + +system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/general/parser/lastrow.sim b/tests/script/general/parser/lastrow.sim index d1eadfb67a..2b8f294d5d 100644 --- a/tests/script/general/parser/lastrow.sim +++ b/tests/script/general/parser/lastrow.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/limit.sim b/tests/script/general/parser/limit.sim index 17636dfb74..23b85095c5 100644 --- a/tests/script/general/parser/limit.sim +++ b/tests/script/general/parser/limit.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/limit1.sim b/tests/script/general/parser/limit1.sim index 2c40f0af2b..e37bea9220 100644 --- a/tests/script/general/parser/limit1.sim +++ b/tests/script/general/parser/limit1.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/limit1_tblocks100.sim b/tests/script/general/parser/limit1_tblocks100.sim index 45ead58ba0..4546ffdb79 100644 --- a/tests/script/general/parser/limit1_tblocks100.sim +++ b/tests/script/general/parser/limit1_tblocks100.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/limit2.sim b/tests/script/general/parser/limit2.sim index 0e7e13b6de..336f9234c8 100644 --- a/tests/script/general/parser/limit2.sim +++ b/tests/script/general/parser/limit2.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c rowsInFileBlock -v 255 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/limit2_tblocks100.sim b/tests/script/general/parser/limit2_tblocks100.sim index 19cea74e70..11f7a15eb0 100644 --- a/tests/script/general/parser/limit2_tblocks100.sim +++ b/tests/script/general/parser/limit2_tblocks100.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c rowsInFileBlock -v 255 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/mixed_blocks.sim b/tests/script/general/parser/mixed_blocks.sim index 8208963858..c20cf9a915 100644 --- a/tests/script/general/parser/mixed_blocks.sim +++ b/tests/script/general/parser/mixed_blocks.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/parser/nchar.sim b/tests/script/general/parser/nchar.sim index 3dcfca7503..786cee651b 100644 --- a/tests/script/general/parser/nchar.sim +++ b/tests/script/general/parser/nchar.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/null_char.sim b/tests/script/general/parser/null_char.sim index 4e7c8ab354..cb65290d25 100644 --- a/tests/script/general/parser/null_char.sim +++ b/tests/script/general/parser/null_char.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/projection_limit_offset.sim b/tests/script/general/parser/projection_limit_offset.sim index a92493b7f4..ffbcb28ffd 100644 --- a/tests/script/general/parser/projection_limit_offset.sim +++ b/tests/script/general/parser/projection_limit_offset.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/selectResNum.sim b/tests/script/general/parser/selectResNum.sim index 20b5024478..dfd204e152 100644 --- a/tests/script/general/parser/selectResNum.sim +++ b/tests/script/general/parser/selectResNum.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 200 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/select_across_vnodes.sim b/tests/script/general/parser/select_across_vnodes.sim index 6c473a35d1..9bf61ee61d 100644 --- a/tests/script/general/parser/select_across_vnodes.sim +++ b/tests/script/general/parser/select_across_vnodes.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 5 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/select_distinct_tag.sim b/tests/script/general/parser/select_distinct_tag.sim index 7ea9dc444f..d8e92d4bc5 100644 --- a/tests/script/general/parser/select_distinct_tag.sim +++ b/tests/script/general/parser/select_distinct_tag.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 5 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/select_from_cache_disk.sim b/tests/script/general/parser/select_from_cache_disk.sim index 3d2cc0b700..7f8af52c6b 100644 --- a/tests/script/general/parser/select_from_cache_disk.sim +++ b/tests/script/general/parser/select_from_cache_disk.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/select_with_tags.sim b/tests/script/general/parser/select_with_tags.sim index 5428f98593..38a514a51b 100644 --- a/tests/script/general/parser/select_with_tags.sim +++ b/tests/script/general/parser/select_with_tags.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/set_tag_vals.sim b/tests/script/general/parser/set_tag_vals.sim index 92380ace84..74184f94d4 100644 --- a/tests/script/general/parser/set_tag_vals.sim +++ b/tests/script/general/parser/set_tag_vals.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/single_row_in_tb.sim b/tests/script/general/parser/single_row_in_tb.sim index bc93629041..5de2a51f0f 100644 --- a/tests/script/general/parser/single_row_in_tb.sim +++ b/tests/script/general/parser/single_row_in_tb.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/slimit.sim b/tests/script/general/parser/slimit.sim index bfb97b5261..0af31f9826 100644 --- a/tests/script/general/parser/slimit.sim +++ b/tests/script/general/parser/slimit.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/slimit1.sim b/tests/script/general/parser/slimit1.sim index 901da4cab2..2dede439ec 100644 --- a/tests/script/general/parser/slimit1.sim +++ b/tests/script/general/parser/slimit1.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/slimit_alter_tags.sim b/tests/script/general/parser/slimit_alter_tags.sim index ad557e891b..53af0f3e84 100644 --- a/tests/script/general/parser/slimit_alter_tags.sim +++ b/tests/script/general/parser/slimit_alter_tags.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/stableOp.sim b/tests/script/general/parser/stableOp.sim index f4b1bd4b8a..8647657e7b 100644 --- a/tests/script/general/parser/stableOp.sim +++ b/tests/script/general/parser/stableOp.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 diff --git a/tests/script/general/parser/tags_dynamically_specifiy.sim b/tests/script/general/parser/tags_dynamically_specifiy.sim index 87b278da09..f6b3dabf15 100644 --- a/tests/script/general/parser/tags_dynamically_specifiy.sim +++ b/tests/script/general/parser/tags_dynamically_specifiy.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/tags_filter.sim b/tests/script/general/parser/tags_filter.sim index f0ac3bdcba..3d3e79b6f5 100644 --- a/tests/script/general/parser/tags_filter.sim +++ b/tests/script/general/parser/tags_filter.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/tbnameIn.sim b/tests/script/general/parser/tbnameIn.sim index 2ee5f38ab1..003a86f90b 100644 --- a/tests/script/general/parser/tbnameIn.sim +++ b/tests/script/general/parser/tbnameIn.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 100 sql connect diff --git a/tests/script/general/parser/timestamp.sim b/tests/script/general/parser/timestamp.sim index 7d7362bcb5..0a87bce51d 100644 --- a/tests/script/general/parser/timestamp.sim +++ b/tests/script/general/parser/timestamp.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/parser/topbot.sim b/tests/script/general/parser/topbot.sim index f5c78d07a1..3e73e4967b 100644 --- a/tests/script/general/parser/topbot.sim +++ b/tests/script/general/parser/topbot.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 200 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/parser/union.sim b/tests/script/general/parser/union.sim index 1b184245c3..d50daea656 100644 --- a/tests/script/general/parser/union.sim +++ b/tests/script/general/parser/union.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c debugFlag -v 135 system sh/cfg.sh -n dnode1 -c rpcDebugFlag -v 135 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 diff --git a/tests/script/general/parser/where.sim b/tests/script/general/parser/where.sim index 5f9e0ec208..ace1ca6f5b 100644 --- a/tests/script/general/parser/where.sim +++ b/tests/script/general/parser/where.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/stable/disk.sim b/tests/script/general/stable/disk.sim index 35088c757c..1faae78e89 100644 --- a/tests/script/general/stable/disk.sim +++ b/tests/script/general/stable/disk.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/stable/dnode3.sim b/tests/script/general/stable/dnode3.sim index 2859f644bb..872cfb8d2e 100644 --- a/tests/script/general/stable/dnode3.sim +++ b/tests/script/general/stable/dnode3.sim @@ -4,10 +4,10 @@ system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 4 diff --git a/tests/script/general/stable/metrics.sim b/tests/script/general/stable/metrics.sim index 5bda2ad42e..a3dca3f1a5 100644 --- a/tests/script/general/stable/metrics.sim +++ b/tests/script/general/stable/metrics.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/stable/refcount.sim b/tests/script/general/stable/refcount.sim index e609ccc055..6629dc1177 100644 --- a/tests/script/general/stable/refcount.sim +++ b/tests/script/general/stable/refcount.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/stable/show.sim b/tests/script/general/stable/show.sim index 836a848ce0..5fe05b41eb 100644 --- a/tests/script/general/stable/show.sim +++ b/tests/script/general/stable/show.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/stable/values.sim b/tests/script/general/stable/values.sim index 5e5416e4e9..fb2c908da2 100644 --- a/tests/script/general/stable/values.sim +++ b/tests/script/general/stable/values.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/stable/vnode3.sim b/tests/script/general/stable/vnode3.sim index 0889a8f0b7..61948b5063 100644 --- a/tests/script/general/stable/vnode3.sim +++ b/tests/script/general/stable/vnode3.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/stream/metrics_del.sim b/tests/script/general/stream/metrics_del.sim index 030f9fc527..321658cd8d 100644 --- a/tests/script/general/stream/metrics_del.sim +++ b/tests/script/general/stream/metrics_del.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/stream/metrics_replica1_vnoden.sim b/tests/script/general/stream/metrics_replica1_vnoden.sim index d7541bac66..4629063c44 100644 --- a/tests/script/general/stream/metrics_replica1_vnoden.sim +++ b/tests/script/general/stream/metrics_replica1_vnoden.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 1000 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 3 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/stream/restart_stream.sim b/tests/script/general/stream/restart_stream.sim index ce06f24df7..5da6907536 100644 --- a/tests/script/general/stream/restart_stream.sim +++ b/tests/script/general/stream/restart_stream.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 @@ -96,7 +96,7 @@ endi print =============== step4 system sh/exec.sh -n dnode1 -s stop system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start print =============== step5 diff --git a/tests/script/general/stream/stream_3.sim b/tests/script/general/stream/stream_3.sim index 632fe78c7f..31490dc5ac 100644 --- a/tests/script/general/stream/stream_3.sim +++ b/tests/script/general/stream/stream_3.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 @@ -108,7 +108,7 @@ print =============== step7 system sh/exec.sh -n dnode1 -s stop system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 4000 diff --git a/tests/script/general/stream/stream_restart.sim b/tests/script/general/stream/stream_restart.sim index dd7bdf1a91..4bf6760703 100644 --- a/tests/script/general/stream/stream_restart.sim +++ b/tests/script/general/stream/stream_restart.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/stream/table_del.sim b/tests/script/general/stream/table_del.sim index 7ddce53c4f..3cbce538d5 100644 --- a/tests/script/general/stream/table_del.sim +++ b/tests/script/general/stream/table_del.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/stream/table_replica1_vnoden.sim b/tests/script/general/stream/table_replica1_vnoden.sim index 3c30897d2b..be67a31b4e 100644 --- a/tests/script/general/stream/table_replica1_vnoden.sim +++ b/tests/script/general/stream/table_replica1_vnoden.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 1000 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 3 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/table/bigint.sim b/tests/script/general/table/bigint.sim index 0b2841f0f8..d75f406d77 100644 --- a/tests/script/general/table/bigint.sim +++ b/tests/script/general/table/bigint.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/binary.sim b/tests/script/general/table/binary.sim index fd2aa5ec44..47915530ef 100644 --- a/tests/script/general/table/binary.sim +++ b/tests/script/general/table/binary.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/bool.sim b/tests/script/general/table/bool.sim index 59297e90a9..e49637448f 100644 --- a/tests/script/general/table/bool.sim +++ b/tests/script/general/table/bool.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/column2.sim b/tests/script/general/table/column2.sim index 85d59fef49..441766f2d4 100644 --- a/tests/script/general/table/column2.sim +++ b/tests/script/general/table/column2.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/column_name.sim b/tests/script/general/table/column_name.sim index 480bcd0610..47fcfab5a8 100644 --- a/tests/script/general/table/column_name.sim +++ b/tests/script/general/table/column_name.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/column_num.sim b/tests/script/general/table/column_num.sim index b055027f59..a18173bc8f 100644 --- a/tests/script/general/table/column_num.sim +++ b/tests/script/general/table/column_num.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/column_value.sim b/tests/script/general/table/column_value.sim index 92ce02ade5..1edf8c2992 100644 --- a/tests/script/general/table/column_value.sim +++ b/tests/script/general/table/column_value.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/date.sim b/tests/script/general/table/date.sim index 7dea76dbc4..23188e12e0 100644 --- a/tests/script/general/table/date.sim +++ b/tests/script/general/table/date.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/db.table.sim b/tests/script/general/table/db.table.sim index 717f5158c4..906396402a 100644 --- a/tests/script/general/table/db.table.sim +++ b/tests/script/general/table/db.table.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/delete_reuse1.sim b/tests/script/general/table/delete_reuse1.sim index 26c82e201b..db59425487 100644 --- a/tests/script/general/table/delete_reuse1.sim +++ b/tests/script/general/table/delete_reuse1.sim @@ -4,10 +4,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1 diff --git a/tests/script/general/table/delete_reuse2.sim b/tests/script/general/table/delete_reuse2.sim index 2e3f01a3a2..f2784a3f5f 100644 --- a/tests/script/general/table/delete_reuse2.sim +++ b/tests/script/general/table/delete_reuse2.sim @@ -4,10 +4,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1 diff --git a/tests/script/general/table/delete_writing.sim b/tests/script/general/table/delete_writing.sim index 342915f0e8..b7350f26a7 100644 --- a/tests/script/general/table/delete_writing.sim +++ b/tests/script/general/table/delete_writing.sim @@ -4,10 +4,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 1 diff --git a/tests/script/general/table/describe.sim b/tests/script/general/table/describe.sim index ca5cf6f6e0..e59371e530 100644 --- a/tests/script/general/table/describe.sim +++ b/tests/script/general/table/describe.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/double.sim b/tests/script/general/table/double.sim index c46029e391..ab3f2428bd 100644 --- a/tests/script/general/table/double.sim +++ b/tests/script/general/table/double.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/fill.sim b/tests/script/general/table/fill.sim index fd79e09ba1..069eeff6cf 100644 --- a/tests/script/general/table/fill.sim +++ b/tests/script/general/table/fill.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/float.sim b/tests/script/general/table/float.sim index bbeb56e370..2d0ea0e5ea 100644 --- a/tests/script/general/table/float.sim +++ b/tests/script/general/table/float.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/int.sim b/tests/script/general/table/int.sim index 142c8b4f04..f30b5b28f5 100644 --- a/tests/script/general/table/int.sim +++ b/tests/script/general/table/int.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/limit.sim b/tests/script/general/table/limit.sim index 45a20f680d..dd38453d0c 100644 --- a/tests/script/general/table/limit.sim +++ b/tests/script/general/table/limit.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 129 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 8 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/table/smallint.sim b/tests/script/general/table/smallint.sim index 53dfbe15bf..f622ce7853 100644 --- a/tests/script/general/table/smallint.sim +++ b/tests/script/general/table/smallint.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/table.sim b/tests/script/general/table/table.sim index 5d6f2ee1a3..c9806c40c6 100644 --- a/tests/script/general/table/table.sim +++ b/tests/script/general/table/table.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/table_len.sim b/tests/script/general/table/table_len.sim index f4c27926fb..d95c9ab0aa 100644 --- a/tests/script/general/table/table_len.sim +++ b/tests/script/general/table/table_len.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/tinyint.sim b/tests/script/general/table/tinyint.sim index 5ad8a6933a..afa931fc79 100644 --- a/tests/script/general/table/tinyint.sim +++ b/tests/script/general/table/tinyint.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/table/vgroup.sim b/tests/script/general/table/vgroup.sim index f7806e316e..d306a4731d 100644 --- a/tests/script/general/table/vgroup.sim +++ b/tests/script/general/table/vgroup.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 4 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/tag/3.sim b/tests/script/general/tag/3.sim index 878fdc0414..20185f5f01 100644 --- a/tests/script/general/tag/3.sim +++ b/tests/script/general/tag/3.sim @@ -1,6 +1,6 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/4.sim b/tests/script/general/tag/4.sim index d5ac6476d9..ee3c8efa6c 100644 --- a/tests/script/general/tag/4.sim +++ b/tests/script/general/tag/4.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/5.sim b/tests/script/general/tag/5.sim index ae6d49e9f8..895b1a9492 100644 --- a/tests/script/general/tag/5.sim +++ b/tests/script/general/tag/5.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/6.sim b/tests/script/general/tag/6.sim index 71957dad9f..9190998bb3 100644 --- a/tests/script/general/tag/6.sim +++ b/tests/script/general/tag/6.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/bigint.sim b/tests/script/general/tag/bigint.sim index c8e6e72825..3e5d528980 100644 --- a/tests/script/general/tag/bigint.sim +++ b/tests/script/general/tag/bigint.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/binary.sim b/tests/script/general/tag/binary.sim index 771e7dc263..960f45675d 100644 --- a/tests/script/general/tag/binary.sim +++ b/tests/script/general/tag/binary.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/binary_binary.sim b/tests/script/general/tag/binary_binary.sim index 5660b1b320..3a0fb56848 100644 --- a/tests/script/general/tag/binary_binary.sim +++ b/tests/script/general/tag/binary_binary.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/bool.sim b/tests/script/general/tag/bool.sim index 828e89f3c7..e37cba669b 100644 --- a/tests/script/general/tag/bool.sim +++ b/tests/script/general/tag/bool.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/bool_binary.sim b/tests/script/general/tag/bool_binary.sim index fc25399c5a..9f6e4f7344 100644 --- a/tests/script/general/tag/bool_binary.sim +++ b/tests/script/general/tag/bool_binary.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/bool_int.sim b/tests/script/general/tag/bool_int.sim index aa443cca62..60345c2d68 100644 --- a/tests/script/general/tag/bool_int.sim +++ b/tests/script/general/tag/bool_int.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/column.sim b/tests/script/general/tag/column.sim index 36610d78da..5a0cd169c5 100644 --- a/tests/script/general/tag/column.sim +++ b/tests/script/general/tag/column.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/create.sim b/tests/script/general/tag/create.sim index d387b4345f..95b4166543 100644 --- a/tests/script/general/tag/create.sim +++ b/tests/script/general/tag/create.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/double.sim b/tests/script/general/tag/double.sim index 514c35dc47..f17043393f 100644 --- a/tests/script/general/tag/double.sim +++ b/tests/script/general/tag/double.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/float.sim b/tests/script/general/tag/float.sim index bfc7e0f569..35bf7d6090 100644 --- a/tests/script/general/tag/float.sim +++ b/tests/script/general/tag/float.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/int.sim b/tests/script/general/tag/int.sim index 2518aeb285..4eea02c9cd 100644 --- a/tests/script/general/tag/int.sim +++ b/tests/script/general/tag/int.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/int_binary.sim b/tests/script/general/tag/int_binary.sim index cb7aa16209..9a75697676 100644 --- a/tests/script/general/tag/int_binary.sim +++ b/tests/script/general/tag/int_binary.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/int_float.sim b/tests/script/general/tag/int_float.sim index afd0a3644a..a03c4b7148 100644 --- a/tests/script/general/tag/int_float.sim +++ b/tests/script/general/tag/int_float.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/smallint.sim b/tests/script/general/tag/smallint.sim index 598b397890..e69eef05f2 100644 --- a/tests/script/general/tag/smallint.sim +++ b/tests/script/general/tag/smallint.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/tag/tinyint.sim b/tests/script/general/tag/tinyint.sim index 3c173a66bf..2d70dc7d48 100644 --- a/tests/script/general/tag/tinyint.sim +++ b/tests/script/general/tag/tinyint.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/user/monitor.sim b/tests/script/general/user/monitor.sim index 016848c06d..90aad59932 100644 --- a/tests/script/general/user/monitor.sim +++ b/tests/script/general/user/monitor.sim @@ -2,7 +2,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 print ========== step1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c monitor -v 1 system sh/cfg.sh -n dnode1 -c monitorInterval -v 1 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/general/vector/metrics_field.sim b/tests/script/general/vector/metrics_field.sim index 84c1ed37e7..2719805c63 100644 --- a/tests/script/general/vector/metrics_field.sim +++ b/tests/script/general/vector/metrics_field.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/metrics_mix.sim b/tests/script/general/vector/metrics_mix.sim index 2c7fc86f9f..7c9bb3b668 100644 --- a/tests/script/general/vector/metrics_mix.sim +++ b/tests/script/general/vector/metrics_mix.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/metrics_query.sim b/tests/script/general/vector/metrics_query.sim index 46afe7df20..fd635a3104 100644 --- a/tests/script/general/vector/metrics_query.sim +++ b/tests/script/general/vector/metrics_query.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/metrics_tag.sim b/tests/script/general/vector/metrics_tag.sim index be13ac764b..1d412d35d3 100644 --- a/tests/script/general/vector/metrics_tag.sim +++ b/tests/script/general/vector/metrics_tag.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/metrics_time.sim b/tests/script/general/vector/metrics_time.sim index 0b82153860..d0152439bf 100644 --- a/tests/script/general/vector/metrics_time.sim +++ b/tests/script/general/vector/metrics_time.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/multi.sim b/tests/script/general/vector/multi.sim index 2ca9b7f48f..1101b0b0db 100644 --- a/tests/script/general/vector/multi.sim +++ b/tests/script/general/vector/multi.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/single.sim b/tests/script/general/vector/single.sim index eee5364a4f..e979a0ffb7 100644 --- a/tests/script/general/vector/single.sim +++ b/tests/script/general/vector/single.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/table_field.sim b/tests/script/general/vector/table_field.sim index 65c50dadc2..d86eb99331 100644 --- a/tests/script/general/vector/table_field.sim +++ b/tests/script/general/vector/table_field.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/table_mix.sim b/tests/script/general/vector/table_mix.sim index 12808fd6a6..5c4fb52888 100644 --- a/tests/script/general/vector/table_mix.sim +++ b/tests/script/general/vector/table_mix.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/table_query.sim b/tests/script/general/vector/table_query.sim index 3e9d2d0b77..9ef18255a9 100644 --- a/tests/script/general/vector/table_query.sim +++ b/tests/script/general/vector/table_query.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/general/vector/table_time.sim b/tests/script/general/vector/table_time.sim index 552bdb2a99..c38546b117 100644 --- a/tests/script/general/vector/table_time.sim +++ b/tests/script/general/vector/table_time.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sleep 2000 diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt index 4f42d043d9..fc56e34dca 100644 --- a/tests/script/jenkins/basic.txt +++ b/tests/script/jenkins/basic.txt @@ -68,6 +68,8 @@ cd ../../../debug; make ./test.sh -f general/db/repeat.sim ./test.sh -f general/db/tables.sim ./test.sh -f general/db/vnodes.sim +./test.sh -f general/db/topic1.sim +./test.sh -f general/db/topic2.sim ./test.sh -f general/db/nosuchfile.sim ./test.sh -f general/field/2.sim diff --git a/tests/script/jenkins/basic_7.txt b/tests/script/jenkins/basic_7.txt index 27d7d4ff97..d951e0a48d 100644 --- a/tests/script/jenkins/basic_7.txt +++ b/tests/script/jenkins/basic_7.txt @@ -38,6 +38,8 @@ ./test.sh -f general/db/repeat.sim ./test.sh -f general/db/tables.sim ./test.sh -f general/db/vnodes.sim +./test.sh -f general/db/topic1.sim +./test.sh -f general/db/topic2.sim ./test.sh -f general/table/autocreate.sim ./test.sh -f general/table/basic1.sim ./test.sh -f general/table/basic2.sim diff --git a/tests/script/unique/big/tcp.sim b/tests/script/unique/big/tcp.sim index 3c5cf92c7f..b282e2e222 100644 --- a/tests/script/unique/big/tcp.sim +++ b/tests/script/unique/big/tcp.sim @@ -1,7 +1,7 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 30000 system sh/cfg.sh -n dnode1 -c dDebugFlag -v 131 diff --git a/tests/script/unique/cluster/cache.sim b/tests/script/unique/cluster/cache.sim index 7a5afae79d..33aaea425c 100644 --- a/tests/script/unique/cluster/cache.sim +++ b/tests/script/unique/cluster/cache.sim @@ -4,8 +4,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c httpMaxThreads -v 2 system sh/cfg.sh -n dnode2 -c httpMaxThreads -v 2 system sh/cfg.sh -n dnode1 -c monitor -v 1 @@ -55,3 +55,11 @@ if $rows < 10 then endi #sql create table sys.st as select avg(taosd), avg(system) from sys.cpu interval(30s) + +sql show log.vgroups +if $data05 != master then + return -1 +endi +if $data15 != master then + return -1 +endi diff --git a/tests/script/unique/stable/dnode2.sim b/tests/script/unique/stable/dnode2.sim index 5c227f8cec..3ca8c4ee20 100644 --- a/tests/script/unique/stable/dnode2.sim +++ b/tests/script/unique/stable/dnode2.sim @@ -1,8 +1,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/unique/stable/dnode3.sim b/tests/script/unique/stable/dnode3.sim index 436ae73595..d0708c8154 100644 --- a/tests/script/unique/stable/dnode3.sim +++ b/tests/script/unique/stable/dnode3.sim @@ -2,9 +2,9 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 4 diff --git a/tests/script/unique/stream/metrics_balance.sim b/tests/script/unique/stream/metrics_balance.sim index b78cfc33a1..ff48c22367 100644 --- a/tests/script/unique/stream/metrics_balance.sim +++ b/tests/script/unique/stream/metrics_balance.sim @@ -8,8 +8,8 @@ system sh/cfg.sh -n dnode1 -c statusInterval -v 1 system sh/cfg.sh -n dnode2 -c statusInterval -v 1 system sh/cfg.sh -n dnode1 -c balanceInterval -v 10 system sh/cfg.sh -n dnode2 -c balanceInterval -v 10 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 4 diff --git a/tests/script/unique/stream/metrics_replica1_dnode2.sim b/tests/script/unique/stream/metrics_replica1_dnode2.sim index bbc4d5174c..20c37cefc3 100644 --- a/tests/script/unique/stream/metrics_replica1_dnode2.sim +++ b/tests/script/unique/stream/metrics_replica1_dnode2.sim @@ -4,8 +4,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/unique/stream/metrics_replica2_dnode2.sim b/tests/script/unique/stream/metrics_replica2_dnode2.sim index e9944daf37..aa8c187101 100644 --- a/tests/script/unique/stream/metrics_replica2_dnode2.sim +++ b/tests/script/unique/stream/metrics_replica2_dnode2.sim @@ -4,8 +4,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sql connect diff --git a/tests/script/unique/stream/metrics_replica2_dnode2_vnoden.sim b/tests/script/unique/stream/metrics_replica2_dnode2_vnoden.sim index f60355cd6a..be2fcefe66 100644 --- a/tests/script/unique/stream/metrics_replica2_dnode2_vnoden.sim +++ b/tests/script/unique/stream/metrics_replica2_dnode2_vnoden.sim @@ -4,8 +4,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/unique/stream/metrics_replica2_dnode3.sim b/tests/script/unique/stream/metrics_replica2_dnode3.sim index 981f5e9b70..f7b17610c3 100644 --- a/tests/script/unique/stream/metrics_replica2_dnode3.sim +++ b/tests/script/unique/stream/metrics_replica2_dnode3.sim @@ -6,9 +6,9 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 4 diff --git a/tests/script/unique/stream/metrics_replica3_dnode4.sim b/tests/script/unique/stream/metrics_replica3_dnode4.sim index 902e9db16b..4027128003 100644 --- a/tests/script/unique/stream/metrics_replica3_dnode4.sim +++ b/tests/script/unique/stream/metrics_replica3_dnode4.sim @@ -8,10 +8,10 @@ system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 4 diff --git a/tests/script/unique/stream/metrics_vnode_stop.sim b/tests/script/unique/stream/metrics_vnode_stop.sim index f1a0981d70..cd84cb3cdf 100644 --- a/tests/script/unique/stream/metrics_vnode_stop.sim +++ b/tests/script/unique/stream/metrics_vnode_stop.sim @@ -4,8 +4,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 2 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 2 system sh/exec.sh -n dnode1 -s start @@ -99,8 +99,8 @@ system sh/exec.sh -n dnode1 -s stop system sh/exec.sh -n dnode2 -s stop system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/exec.sh -n dnode2 -s start sleep 2000 diff --git a/tests/script/unique/stream/table_balance.sim b/tests/script/unique/stream/table_balance.sim index e8dec54e3e..45e054e2ef 100644 --- a/tests/script/unique/stream/table_balance.sim +++ b/tests/script/unique/stream/table_balance.sim @@ -6,8 +6,8 @@ system sh/cfg.sh -n dnode1 -c statusInterval -v 1 system sh/cfg.sh -n dnode2 -c statusInterval -v 1 system sh/cfg.sh -n dnode1 -c balanceInterval -v 10 system sh/cfg.sh -n dnode2 -c balanceInterval -v 10 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode2 -c mnodeEqualVnodeNum -v 0 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 diff --git a/tests/script/unique/stream/table_replica1_dnode2.sim b/tests/script/unique/stream/table_replica1_dnode2.sim index aaab2990b4..ccc6026e9c 100644 --- a/tests/script/unique/stream/table_replica1_dnode2.sim +++ b/tests/script/unique/stream/table_replica1_dnode2.sim @@ -2,8 +2,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/unique/stream/table_replica2_dnode2.sim b/tests/script/unique/stream/table_replica2_dnode2.sim index da24b5ab4e..947fa0d2f9 100644 --- a/tests/script/unique/stream/table_replica2_dnode2.sim +++ b/tests/script/unique/stream/table_replica2_dnode2.sim @@ -4,8 +4,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start sql connect diff --git a/tests/script/unique/stream/table_replica2_dnode2_vnoden.sim b/tests/script/unique/stream/table_replica2_dnode2_vnoden.sim index 0717e6f965..7530036239 100644 --- a/tests/script/unique/stream/table_replica2_dnode2_vnoden.sim +++ b/tests/script/unique/stream/table_replica2_dnode2_vnoden.sim @@ -4,8 +4,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/exec.sh -n dnode1 -s start diff --git a/tests/script/unique/stream/table_replica2_dnode3.sim b/tests/script/unique/stream/table_replica2_dnode3.sim index 10d9feec53..49eb3563b3 100644 --- a/tests/script/unique/stream/table_replica2_dnode3.sim +++ b/tests/script/unique/stream/table_replica2_dnode3.sim @@ -6,9 +6,9 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 4 diff --git a/tests/script/unique/stream/table_replica3_dnode4.sim b/tests/script/unique/stream/table_replica3_dnode4.sim index 3b9552084b..2cc443c72f 100644 --- a/tests/script/unique/stream/table_replica3_dnode4.sim +++ b/tests/script/unique/stream/table_replica3_dnode4.sim @@ -8,10 +8,10 @@ system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode2 -c maxtablesPerVnode -v 4 system sh/cfg.sh -n dnode3 -c maxtablesPerVnode -v 4 diff --git a/tests/script/unique/stream/table_vnode_stop.sim b/tests/script/unique/stream/table_vnode_stop.sim index 229d814e42..625de32a8d 100644 --- a/tests/script/unique/stream/table_vnode_stop.sim +++ b/tests/script/unique/stream/table_vnode_stop.sim @@ -4,8 +4,8 @@ system sh/stop_dnodes.sh system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 system sh/cfg.sh -n dnode1 -c numOfMnodes -v 2 system sh/cfg.sh -n dnode2 -c numOfMnodes -v 2 system sh/exec.sh -n dnode1 -s start @@ -100,8 +100,8 @@ system sh/exec.sh -n dnode1 -s stop system sh/exec.sh -n dnode2 -s stop system sh/deploy.sh -n dnode1 -i 1 system sh/deploy.sh -n dnode2 -i 2 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 sleep 2000 system sh/exec.sh -n dnode2 -s start diff --git a/tests/script/unique/vnode/backup/replica4.sim b/tests/script/unique/vnode/backup/replica4.sim index bccc17e682..c0ff267c73 100644 --- a/tests/script/unique/vnode/backup/replica4.sim +++ b/tests/script/unique/vnode/backup/replica4.sim @@ -10,10 +10,10 @@ system sh/deploy.sh -n dnode2 -i 2 system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start $x = 0 diff --git a/tests/script/unique/vnode/backup/replica5.sim b/tests/script/unique/vnode/backup/replica5.sim index d29d11fdaf..1223cf6b58 100644 --- a/tests/script/unique/vnode/backup/replica5.sim +++ b/tests/script/unique/vnode/backup/replica5.sim @@ -12,11 +12,11 @@ system sh/deploy.sh -n dnode3 -i 3 system sh/deploy.sh -n dnode4 -i 4 system sh/deploy.sh -n dnode5 -i 5 -system sh/cfg.sh -n dnode1 -c walLevel -v 0 -system sh/cfg.sh -n dnode2 -c walLevel -v 0 -system sh/cfg.sh -n dnode3 -c walLevel -v 0 -system sh/cfg.sh -n dnode4 -c walLevel -v 0 -system sh/cfg.sh -n dnode5 -c walLevel -v 0 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/cfg.sh -n dnode2 -c walLevel -v 1 +system sh/cfg.sh -n dnode3 -c walLevel -v 1 +system sh/cfg.sh -n dnode4 -c walLevel -v 1 +system sh/cfg.sh -n dnode5 -c walLevel -v 1 system sh/exec.sh -n dnode1 -s start