diff --git a/.drone.yml b/.drone.yml
index b520f308ba68e2acd631795fbcfbf91a1b64c2a9..085a07acf94a57cbcaf076c149cebdf243f8ff74 100644
--- a/.drone.yml
+++ b/.drone.yml
@@ -15,7 +15,7 @@ steps:
- mkdir debug
- cd debug
- cmake ..
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -23,6 +23,7 @@ steps:
branch:
- develop
- master
+ - 2.0
---
kind: pipeline
name: test_arm64_bionic
@@ -39,7 +40,7 @@ steps:
- mkdir debug
- cd debug
- cmake .. -DCPUTYPE=aarch64 > /dev/null
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -66,7 +67,7 @@ steps:
- mkdir debug
- cd debug
- cmake .. -DCPUTYPE=aarch64 > /dev/null
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -91,7 +92,7 @@ steps:
- mkdir debug
- cd debug
- cmake .. -DCPUTYPE=aarch64 > /dev/null
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -116,7 +117,7 @@ steps:
- mkdir debug
- cd debug
- cmake .. -DCPUTYPE=aarch64 > /dev/null
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -142,7 +143,7 @@ steps:
- mkdir debug
- cd debug
- cmake .. -DCPUTYPE=aarch32 > /dev/null
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -150,6 +151,7 @@ steps:
branch:
- develop
- master
+ - 2.0
---
kind: pipeline
name: build_trusty
@@ -168,7 +170,7 @@ steps:
- mkdir debug
- cd debug
- cmake ..
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -176,6 +178,7 @@ steps:
branch:
- develop
- master
+ - 2.0
---
kind: pipeline
name: build_xenial
@@ -193,7 +196,7 @@ steps:
- mkdir debug
- cd debug
- cmake ..
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -201,7 +204,7 @@ steps:
branch:
- develop
- master
-
+ - 2.0
---
kind: pipeline
name: build_bionic
@@ -218,7 +221,7 @@ steps:
- mkdir debug
- cd debug
- cmake ..
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -226,6 +229,7 @@ steps:
branch:
- develop
- master
+ - 2.0
---
kind: pipeline
name: build_centos7
@@ -241,7 +245,7 @@ steps:
- mkdir debug
- cd debug
- cmake ..
- - make
+ - make -j4
trigger:
event:
- pull_request
@@ -249,4 +253,4 @@ steps:
branch:
- develop
- master
-
+ - 2.0
\ No newline at end of file
diff --git a/Jenkinsfile b/Jenkinsfile
index 0eb9a1aa95348a97950fdbbc1e93f125fda0a2ee..6109e4811a34fb159e6b17c3bf7c5af3c884ea3d 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -160,7 +160,6 @@ pipeline {
skipbuild='2'
skipbuild=sh(script: "git log -2 --pretty=%B | fgrep -ie '[skip ci]' -e '[ci skip]' && echo 1 || echo 2", returnStdout:true)
println skipbuild
-
}
sh'''
rm -rf ${WORKSPACE}.tes
@@ -225,6 +224,26 @@ pipeline {
steps {
timeout(time: 55, unit: 'MINUTES'){
pre_test()
+ sh '''
+ rm -rf /var/lib/taos/*
+ rm -rf /var/log/taos/*
+ nohup taosd >/dev/null &
+ sleep 10
+ '''
+ sh '''
+ cd ${WKC}/tests/examples/nodejs
+ npm install td2.0-connector > /dev/null 2>&1
+ node nodejsChecker.js host=localhost
+ '''
+ sh '''
+ cd ${WKC}/tests/examples/C#/taosdemo
+ mcs -out:taosdemo *.cs > /dev/null 2>&1
+ echo '' |./taosdemo
+ '''
+ sh '''
+ cd ${WKC}/tests/gotest
+ bash batchtest.sh
+ '''
sh '''
cd ${WKC}/tests
./test-all.sh b1fq
@@ -246,12 +265,12 @@ pipeline {
}
}
timeout(time: 60, unit: 'MINUTES'){
- sh '''
- cd ${WKC}/tests/pytest
- rm -rf /var/lib/taos/*
- rm -rf /var/log/taos/*
- ./handle_crash_gen_val_log.sh
- '''
+ // sh '''
+ // cd ${WKC}/tests/pytest
+ // rm -rf /var/lib/taos/*
+ // rm -rf /var/log/taos/*
+ // ./handle_crash_gen_val_log.sh
+ // '''
sh '''
cd ${WKC}/tests/pytest
rm -rf /var/lib/taos/*
diff --git a/cmake/version.inc b/cmake/version.inc
index ffceecf49215bcef9136c0b5d2f0f1e1290c9ed1..261e3e8162f1bae6498f6edc09f23cb243e1f5c2 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.1.6.0")
+ SET(TD_VER_NUMBER "2.1.7.2")
ENDIF ()
IF (DEFINED VERCOMPATIBLE)
diff --git a/deps/MsvcLibX/src/iconv.c b/deps/MsvcLibX/src/iconv.c
index 40b6e6462d9d0a6dc53509e8645cfba50b446256..1ec0dc73547852e37a23ff308cb740bbd88d872c 100644
--- a/deps/MsvcLibX/src/iconv.c
+++ b/deps/MsvcLibX/src/iconv.c
@@ -98,6 +98,7 @@ int ConvertString(char *buf, size_t nBytes, UINT cpFrom, UINT cpTo, LPCSTR lpDef
char *DupAndConvert(const char *string, UINT cpFrom, UINT cpTo, LPCSTR lpDefaultChar) {
int nBytes;
char *pBuf;
+ char *pBuf1;
nBytes = 4 * ((int)lstrlen(string) + 1); /* Worst case for the size needed */
pBuf = (char *)malloc(nBytes);
if (!pBuf) {
@@ -110,8 +111,9 @@ char *DupAndConvert(const char *string, UINT cpFrom, UINT cpTo, LPCSTR lpDefault
free(pBuf);
return NULL;
}
- pBuf = realloc(pBuf, nBytes+1);
- return pBuf;
+ pBuf1 = realloc(pBuf, nBytes+1);
+ if(pBuf1 == NULL && pBuf != NULL) free(pBuf);
+ return pBuf1;
}
int CountCharacters(const char *string, UINT cp) {
diff --git a/deps/MsvcLibX/src/main.c b/deps/MsvcLibX/src/main.c
index f366b081ad688e15dc62dd0c8a7ccf9bb409afe0..85f4c83f24400e12c4a4b996b863df94e07cf819 100644
--- a/deps/MsvcLibX/src/main.c
+++ b/deps/MsvcLibX/src/main.c
@@ -68,6 +68,7 @@ int BreakArgLine(LPSTR pszCmdLine, char ***pppszArg) {
int iString = FALSE; /* TRUE = string mode; FALSE = non-string mode */
int nBackslash = 0;
char **ppszArg;
+ char **ppszArg1;
int iArg = FALSE; /* TRUE = inside an argument; FALSE = between arguments */
ppszArg = (char **)malloc((argc+1)*sizeof(char *));
@@ -89,7 +90,10 @@ int BreakArgLine(LPSTR pszCmdLine, char ***pppszArg) {
if ((!iArg) && (c != ' ') && (c != '\t')) { /* Beginning of a new argument */
iArg = TRUE;
ppszArg[argc++] = pszCopy+j;
- ppszArg = (char **)realloc(ppszArg, (argc+1)*sizeof(char *));
+ ppszArg1 = (char **)realloc(ppszArg, (argc+1)*sizeof(char *));
+ if(ppszArg1 == NULL && ppszArg != NULL)
+ free(ppszArg);
+ ppszArg = ppszArg1;
if (!ppszArg) return -1;
pszCopy[j] = c0 = '\0';
}
@@ -212,7 +216,7 @@ int _initU(void) {
fprintf(stderr, "Warning: Can't convert the argument line to UTF-8\n");
_acmdln[0] = '\0';
}
- realloc(_acmdln, n+1); /* Resize the memory block to fit the UTF-8 line */
+ //realloc(_acmdln, n+1); /* Resize the memory block to fit the UTF-8 line */
/* Should not fail since we make it smaller */
/* Record the console code page, to allow converting the output accordingly */
diff --git a/deps/MsvcLibX/src/realpath.c b/deps/MsvcLibX/src/realpath.c
index 5fbcf773a24d0950ac8099cd9274fcbb3157a954..e2ba755f2d8b60e545e8ead71d198e60ca7a47c0 100644
--- a/deps/MsvcLibX/src/realpath.c
+++ b/deps/MsvcLibX/src/realpath.c
@@ -196,6 +196,7 @@ not_compact_enough:
/* Normally defined in stdlib.h. Output buf must contain PATH_MAX bytes */
char *realpath(const char *path, char *outbuf) {
char *pOutbuf = outbuf;
+ char *pOutbuf1 = NULL;
int iErr;
const char *pc;
@@ -242,8 +243,11 @@ realpath_failed:
return NULL;
}
- if (!outbuf) pOutbuf = realloc(pOutbuf, strlen(pOutbuf) + 1);
- return pOutbuf;
+ if (!outbuf) {
+ pOutbuf1 = realloc(pOutbuf, strlen(pOutbuf) + 1);
+ if(pOutbuf1 == NULL && pOutbuf) free(pOutbuf);
+ }
+ return pOutbuf1;
}
#endif
@@ -517,6 +521,7 @@ int ResolveLinksA(const char *path, char *buf, size_t bufsize) {
/* Normally defined in stdlib.h. Output buf must contain PATH_MAX bytes */
char *realpathU(const char *path, char *outbuf) {
char *pOutbuf = outbuf;
+ char *pOutbuf1 = NULL;
char *pPath1 = NULL;
char *pPath2 = NULL;
int iErr;
@@ -590,10 +595,13 @@ realpathU_failed:
}
DEBUG_LEAVE(("return 0x%p; // \"%s\"\n", pOutbuf, pOutbuf));
- if (!outbuf) pOutbuf = realloc(pOutbuf, strlen(pOutbuf) + 1);
+ if (!outbuf) {
+ pOutbuf1 = realloc(pOutbuf, strlen(pOutbuf) + 1);
+ if(pOutbuf1 == NULL && pOutbuf) free(pOutbuf);
+ }
free(pPath1);
free(pPath2);
- return pOutbuf;
+ return pOutbuf1;
}
#endif /* defined(_WIN32) */
diff --git a/deps/TSZ b/deps/TSZ
index 0ca5b15a8eac40327dd737be52c926fa5675712c..ceda5bf9fcd7836509ac97dcc0056b3f1dd48cc5 160000
--- a/deps/TSZ
+++ b/deps/TSZ
@@ -1 +1 @@
-Subproject commit 0ca5b15a8eac40327dd737be52c926fa5675712c
+Subproject commit ceda5bf9fcd7836509ac97dcc0056b3f1dd48cc5
diff --git a/documentation20/cn/01.evaluation/docs.md b/documentation20/cn/01.evaluation/docs.md
index 7f70ccec5681ffd751cd1372d9c0926bf3f3beda..4263391dbcb5a02cce3af2766b60799f15d13af4 100644
--- a/documentation20/cn/01.evaluation/docs.md
+++ b/documentation20/cn/01.evaluation/docs.md
@@ -2,18 +2,18 @@
## TDengine 简介
-TDengine是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，在时序空间大数据处理上，有着自己独到的优势。
+TDengine 是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL 数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，在时序空间大数据处理上，有着自己独到的优势。
-TDengine的模块之一是时序数据库。但除此之外，为减少研发的复杂度、系统维护的难度，TDengine还提供缓存、消息队列、订阅、流式计算等功能，为物联网、工业互联网大数据的处理提供全栈的技术方案，是一个高效易用的物联网大数据平台。与Hadoop等典型的大数据平台相比，它具有如下鲜明的特点：
+TDengine 的模块之一是时序数据库。但除此之外，为减少研发的复杂度、系统维护的难度，TDengine 还提供缓存、消息队列、订阅、流式计算等功能，为物联网、工业互联网大数据的处理提供全栈的技术方案，是一个高效易用的物联网大数据平台。与 Hadoop 等典型的大数据平台相比，它具有如下鲜明的特点：
-* __10倍以上的性能提升__：定义了创新的数据存储结构，单核每秒能处理至少2万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快十倍以上。
-* __硬件或云服务成本降至1/5__：由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10。
-* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成Kafka/Redis/HBase/Spark/HDFS等软件，大幅降低应用开发和维护的复杂度成本。
-* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell, Python, R, MATLAB随时进行。
-* __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, HiveMQ, Prometheus, MATLAB, R等集成。后续将支持OPC, Hadoop, Spark等, BI工具也将无缝连接。
-* __零运维成本、零学习成本__：安装集群简单快捷，无需分库分表，实时备份。类似标准SQL，支持RESTful, 支持Python/Java/C/C++/C#/Go/Node.js, 与MySQL相似，零学习成本。
+* __10 倍以上的性能提升__：定义了创新的数据存储结构，单核每秒能处理至少 2 万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快十倍以上。
+* __硬件或云服务成本降至 1/5__：由于超强性能，计算资源不到通用大数据方案的 1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的 1/10。
+* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成 Kafka/Redis/HBase/Spark/HDFS 等软件，大幅降低应用开发和维护的复杂度成本。
+* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过 Shell, Python, R, MATLAB 随时进行。
+* __与第三方工具无缝连接__：不用一行代码，即可与 Telegraf, Grafana, EMQ, HiveMQ, Prometheus, MATLAB, R 等集成。后续将支持 OPC, Hadoop, Spark 等，BI 工具也将无缝连接。
+* __零运维成本、零学习成本__：安装集群简单快捷，无需分库分表，实时备份。类标准 SQL，支持 RESTful，支持 Python/Java/C/C++/C#/Go/Node.js, 与 MySQL 相似，零学习成本。
-采用TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM等通用型数据。
+采用 TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM 等通用型数据。
图 1. TDengine技术生态图
@@ -21,42 +21,47 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
## TDengine 总体适用场景
-作为一个IOT大数据平台，TDengine的典型适用场景是在IOT范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如CRM，ERP等，不在本文讨论范围内。
+作为一个 IOT 大数据平台，TDengine 的典型适用场景是在 IOT 范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如 CRM，ERP 等，不在本文讨论范围内。
### 数据源特点和需求
-从数据源角度，设计人员可以从下面几个角度分析TDengine在目标应用系统里面的适用性。
+
+从数据源角度，设计人员可以从下面几个角度分析 TDengine 在目标应用系统里面的适用性。
|数据源特点和需求|不适用|可能适用|非常适用|简单说明|
|---|---|---|---|---|
-|总体数据量巨大| | | √ |TDengine在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。|
-|数据输入速度偶尔或者持续巨大| | | √ | TDengine的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。|
-|数据源数目巨大| | | √ |TDengine设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。|
+|总体数据量巨大| | | √ | TDengine 在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。|
+|数据输入速度偶尔或者持续巨大| | | √ | TDengine 的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。|
+|数据源数目巨大| | | √ | TDengine 设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。|
### 系统架构要求
+
|系统架构要求|不适用|可能适用|非常适用|简单说明|
|---|---|---|---|---|
-|要求简单可靠的系统架构| | | √ |TDengine的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
-|要求容错和高可靠| | | √ |TDengine的集群功能，自动提供容错灾备等高可靠功能。|
-|标准化规范| | | √ |TDengine使用标准的SQL语言提供主要功能，遵守标准化规范。|
+|要求简单可靠的系统架构| | | √ | TDengine 的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
+|要求容错和高可靠| | | √ | TDengine 的集群功能，自动提供容错灾备等高可靠功能。|
+|标准化规范| | | √ | TDengine 使用标准的SQL语言提供主要功能，遵守标准化规范。|
### 系统功能需求
+
|系统功能需求|不适用|可能适用|非常适用|简单说明|
|---|---|---|---|---|
-|要求完整的内置数据处理算法| | √ | |TDengine的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
-|需要大量的交叉查询处理| | √ | |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑TDengine和关系型数据系统配合实现系统功能。|
+|要求完整的内置数据处理算法| | √ | | TDengine 的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
+|需要大量的交叉查询处理| | √ | |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑 TDengine 和关系型数据系统配合实现系统功能。|
### 系统性能需求
+
|系统性能需求|不适用|可能适用|非常适用|简单说明|
|---|---|---|---|---|
-|要求较大的总体处理能力| | | √ |TDengine的集群功能可以轻松地让多服务器配合达成处理能力的提升。|
-|要求高速处理数据 | | | √ |TDengine的专门为IOT优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。|
-|要求快速处理小粒度数据| | | √ |这方面TDengine性能可以完全对标关系型和NoSQL型数据处理系统。|
+|要求较大的总体处理能力| | | √ | TDengine 的集群功能可以轻松地让多服务器配合达成处理能力的提升。|
+|要求高速处理数据 | | | √ | TDengine 的专门为 IOT 优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。|
+|要求快速处理小粒度数据| | | √ |这方面 TDengine 性能可以完全对标关系型和 NoSQL 型数据处理系统。|
### 系统维护需求
+
|系统维护需求|不适用|可能适用|非常适用|简单说明|
|---|---|---|---|---|
-|要求系统可靠运行| | | √ |TDengine的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
+|要求系统可靠运行| | | √ | TDengine 的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
|要求运维学习成本可控| | | √ |同上。|
-|要求市场有大量人才储备| √ | | |TDengine作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务。|
+|要求市场有大量人才储备| √ | | | TDengine 作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务。|
diff --git a/packaging/cfg/taos.cfg b/packaging/cfg/taos.cfg
index bbe6eae419536274094bb97f71d27c59721913bc..3ae4e9941e96abb4c93b99ae86c40b3e3583bd08 100644
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -144,6 +144,9 @@ keepColumnName 1
# max length of an SQL
# maxSQLLength 65480
+# max length of WildCards
+# maxWildCardsLength 100
+
# the maximum number of records allowed for super table time sorting
# maxNumOfOrderedRes 100000
diff --git a/packaging/tools/make_install.sh b/packaging/tools/make_install.sh
index 7851587c826c1667386d6dc9c91f1eef748927db..0849a76e31a631bae7a6ba0d6ef7ffcb58b8480b 100755
--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@@ -19,18 +19,21 @@ else
fi
# Dynamic directory
-data_dir="/var/lib/taos"
+
if [ "$osType" != "Darwin" ]; then
+ data_dir="/var/lib/taos"
log_dir="/var/log/taos"
else
- log_dir=~/TDengine/log
+ data_dir="/usr/local/var/lib/taos"
+ log_dir="/usr/local/var/log/taos"
fi
-data_link_dir="/usr/local/taos/data"
-log_link_dir="/usr/local/taos/log"
-
-cfg_install_dir="/etc/taos"
+if [ "$osType" != "Darwin" ]; then
+ cfg_install_dir="/etc/taos"
+else
+ cfg_install_dir="/usr/local/etc/taos"
+fi
if [ "$osType" != "Darwin" ]; then
bin_link_dir="/usr/bin"
@@ -44,10 +47,18 @@ else
fi
#install main path
-install_main_dir="/usr/local/taos"
+if [ "$osType" != "Darwin" ]; then
+ install_main_dir="/usr/local/taos"
+else
+ install_main_dir="/usr/local/Cellar/tdengine/${verNumber}"
+fi
# old bin dir
-bin_dir="/usr/local/taos/bin"
+if [ "$osType" != "Darwin" ]; then
+ bin_dir="/usr/local/taos/bin"
+else
+ bin_dir="/usr/local/Cellar/tdengine/${verNumber}/bin"
+fi
service_config_dir="/etc/systemd/system"
@@ -59,12 +70,11 @@ GREEN_UNDERLINE='\033[4;32m'
NC='\033[0m'
csudo=""
-if command -v sudo > /dev/null; then
- csudo="sudo"
-fi
if [ "$osType" != "Darwin" ]; then
-
+ if command -v sudo > /dev/null; then
+ csudo="sudo"
+ fi
initd_mod=0
service_mod=2
if pidof systemd &> /dev/null; then
@@ -137,17 +147,17 @@ function install_main_path() {
function install_bin() {
# Remove links
- ${csudo} rm -f ${bin_link_dir}/taos || :
+ ${csudo} rm -f ${bin_link_dir}/taos || :
+ ${csudo} rm -f ${bin_link_dir}/taosd || :
+ ${csudo} rm -f ${bin_link_dir}/taosdemo || :
+ ${csudo} rm -f ${bin_link_dir}/taosdump || :
if [ "$osType" != "Darwin" ]; then
- ${csudo} rm -f ${bin_link_dir}/taosd || :
- ${csudo} rm -f ${bin_link_dir}/taosdemo || :
- ${csudo} rm -f ${bin_link_dir}/taosdump || :
+ ${csudo} rm -f ${bin_link_dir}/perfMonitor || :
${csudo} rm -f ${bin_link_dir}/set_core || :
+ ${csudo} rm -f ${bin_link_dir}/rmtaos || :
fi
-
- ${csudo} rm -f ${bin_link_dir}/rmtaos || :
-
+
${csudo} cp -r ${binary_dir}/build/bin/* ${install_main_dir}/bin
${csudo} cp -r ${script_dir}/taosd-dump-cfg.gdb ${install_main_dir}/bin
@@ -161,19 +171,18 @@ function install_bin() {
${csudo} chmod 0555 ${install_main_dir}/bin/*
#Make link
- [ -x ${install_main_dir}/bin/taos ] && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos || :
+ [ -x ${install_main_dir}/bin/taos ] && ${csudo} ln -s ${install_main_dir}/bin/taos ${bin_link_dir}/taos || :
+ [ -x ${install_main_dir}/bin/taosd ] && ${csudo} ln -s ${install_main_dir}/bin/taosd ${bin_link_dir}/taosd || :
+ [ -x ${install_main_dir}/bin/taosdump ] && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump || :
+ [ -x ${install_main_dir}/bin/taosdemo ] && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || :
if [ "$osType" != "Darwin" ]; then
- [ -x ${install_main_dir}/bin/taosd ] && ${csudo} ln -s ${install_main_dir}/bin/taosd ${bin_link_dir}/taosd || :
- [ -x ${install_main_dir}/bin/taosdump ] && ${csudo} ln -s ${install_main_dir}/bin/taosdump ${bin_link_dir}/taosdump || :
- [ -x ${install_main_dir}/bin/taosdemo ] && ${csudo} ln -s ${install_main_dir}/bin/taosdemo ${bin_link_dir}/taosdemo || :
+ [ -x ${install_main_dir}/bin/perfMonitor ] && ${csudo} ln -s ${install_main_dir}/bin/perfMonitor ${bin_link_dir}/perfMonitor || :
[ -x ${install_main_dir}/set_core.sh ] && ${csudo} ln -s ${install_main_dir}/bin/set_core.sh ${bin_link_dir}/set_core || :
fi
-
+
if [ "$osType" != "Darwin" ]; then
- [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/rmtaos || :
- else
- [ -x ${install_main_dir}/bin/remove_client.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove_client.sh ${bin_link_dir}/rmtaos || :
+ [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/rmtaos || :
fi
}
@@ -220,7 +229,7 @@ function install_jemalloc() {
fi
if [ -d /etc/ld.so.conf.d ]; then
- ${csudo} echo "/usr/local/lib" > /etc/ld.so.conf.d/jemalloc.conf
+ echo "/usr/local/lib" | ${csudo} tee /etc/ld.so.conf.d/jemalloc.conf
${csudo} ldconfig
else
echo "/etc/ld.so.conf.d not found!"
@@ -246,10 +255,8 @@ function install_lib() {
fi
else
${csudo} cp -Rf ${binary_dir}/build/lib/libtaos.* ${install_main_dir}/driver && ${csudo} chmod 777 ${install_main_dir}/driver/*
- ${csudo} ln -sf ${install_main_dir}/driver/libtaos.1.dylib ${lib_link_dir}/libtaos.1.dylib
- ${csudo} ln -sf ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib
fi
-
+
install_jemalloc
if [ "$osType" != "Darwin" ]; then
@@ -259,10 +266,14 @@ function install_lib() {
function install_header() {
- ${csudo} rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taoserror.h || :
+ if [ "$osType" != "Darwin" ]; then
+ ${csudo} rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taoserror.h || :
+ fi
${csudo} cp -f ${source_dir}/src/inc/taos.h ${source_dir}/src/inc/taoserror.h ${install_main_dir}/include && ${csudo} chmod 644 ${install_main_dir}/include/*
- ${csudo} ln -s ${install_main_dir}/include/taos.h ${inc_link_dir}/taos.h
- ${csudo} ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
+ if [ "$osType" != "Darwin" ]; then
+ ${csudo} ln -s ${install_main_dir}/include/taos.h ${inc_link_dir}/taos.h
+ ${csudo} ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
+ fi
}
function install_config() {
@@ -270,23 +281,20 @@ function install_config() {
if [ ! -f ${cfg_install_dir}/taos.cfg ]; then
${csudo} mkdir -p ${cfg_install_dir}
- [ -f ${script_dir}/../cfg/taos.cfg ] && ${csudo} cp ${script_dir}/../cfg/taos.cfg ${cfg_install_dir}
+ [ -f ${script_dir}/../cfg/taos.cfg ] &&
+ ${csudo} cp ${script_dir}/../cfg/taos.cfg ${cfg_install_dir}
${csudo} chmod 644 ${cfg_install_dir}/*
fi
${csudo} cp -f ${script_dir}/../cfg/taos.cfg ${install_main_dir}/cfg/taos.cfg.org
- ${csudo} ln -s ${cfg_install_dir}/taos.cfg ${install_main_dir}/cfg
+
+ if [ "$osType" != "Darwin" ]; then ${csudo} ln -s ${cfg_install_dir}/taos.cfg ${install_main_dir}/cfg
+ fi
}
function install_log() {
${csudo} rm -rf ${log_dir} || :
-
- if [ "$osType" != "Darwin" ]; then
- ${csudo} mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
- else
- mkdir -p ${log_dir} && chmod 777 ${log_dir}
- fi
-
+ ${csudo} mkdir -p ${log_dir} && ${csudo} chmod 777 ${log_dir}
${csudo} ln -s ${log_dir} ${install_main_dir}/log
}
@@ -307,7 +315,6 @@ function install_connector() {
echo "WARNING: go connector not found, please check if want to use it!"
fi
${csudo} cp -rf ${source_dir}/src/connector/python ${install_main_dir}/connector
-
${csudo} cp ${binary_dir}/build/lib/*.jar ${install_main_dir}/connector &> /dev/null && ${csudo} chmod 777 ${install_main_dir}/connector/*.jar || echo &> /dev/null
}
@@ -487,24 +494,21 @@ function install_TDengine() {
else
echo -e "${GREEN}Start to install TDEngine Client ...${NC}"
fi
-
+
install_main_path
- if [ "$osType" != "Darwin" ]; then
- install_data
- fi
+ install_data
install_log
install_header
install_lib
install_connector
install_examples
-
install_bin
-
+
if [ "$osType" != "Darwin" ]; then
install_service
fi
-
+
install_config
if [ "$osType" != "Darwin" ]; then
diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml
index c04fa3298bd3acdee8fb88fb4f2eead2632a441f..ea5ce3bc52468d7efcc1ece78f46cbbc8c2c3a7e 100644
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -1,6 +1,6 @@
name: tdengine
base: core18
-version: '2.1.6.0'
+version: '2.1.7.2'
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.1.6.0
+ - usr/lib/libtaos.so.2.1.7.2
- usr/lib/libtaos.so.1
- usr/lib/libtaos.so
diff --git a/src/balance/src/bnScore.c b/src/balance/src/bnScore.c
index 7d94df1c23ab7824dbada0423beec14530a2101c..04a14357c9e602807f5aa254d8a5ea25bc4b328d 100644
--- a/src/balance/src/bnScore.c
+++ b/src/balance/src/bnScore.c
@@ -116,8 +116,17 @@ void bnCleanupDnodes() {
static void bnCheckDnodesSize(int32_t dnodesNum) {
if (tsBnDnodes.maxSize <= dnodesNum) {
- tsBnDnodes.maxSize = dnodesNum * 2;
- tsBnDnodes.list = realloc(tsBnDnodes.list, tsBnDnodes.maxSize * sizeof(SDnodeObj *));
+ int32_t maxSize = dnodesNum * 2;
+ SDnodeObj** list1 = NULL;
+ int32_t retry = 0;
+
+ while(list1 == NULL && retry++ < 3) {
+ list1 = realloc(tsBnDnodes.list, maxSize * sizeof(SDnodeObj *));
+ }
+ if(list1) {
+ tsBnDnodes.list = list1;
+ tsBnDnodes.maxSize = maxSize;
+ }
}
}
diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt
index 2f83557d63c288173f8b541caf32fe9fe2e73338..0d06e5d39c0ed1916e0c2af7ccce5918e31ac42f 100644
--- a/src/client/CMakeLists.txt
+++ b/src/client/CMakeLists.txt
@@ -4,6 +4,8 @@ PROJECT(TDengine)
INCLUDE_DIRECTORIES(inc)
INCLUDE_DIRECTORIES(jni)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/zlib-1.2.11/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/plugins/http/inc)
AUX_SOURCE_DIRECTORY(src SRC)
IF (TD_LINUX)
diff --git a/src/client/inc/tscSubquery.h b/src/client/inc/tscSubquery.h
index f0349c2b3dc5b03b44afdca682f314709ecf6886..a012ca5a7fe741b8859465504cbc971a7e46952c 100644
--- a/src/client/inc/tscSubquery.h
+++ b/src/client/inc/tscSubquery.h
@@ -50,6 +50,12 @@ void tscUnlockByThread(int64_t *lockedBy);
int tsInsertInitialCheck(SSqlObj *pSql);
+void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs);
+
+void tscFreeRetrieveSup(SSqlObj *pSql);
+
+
+
#ifdef __cplusplus
}
#endif
diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index b3674a7bf5bf94806dfd576b4e81af95413bb5bd..81e430f5c2ae2e8e4c0dda10ae3daff6d90d897c 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -29,15 +29,16 @@ extern "C" {
#include "tsched.h"
#include "tsclient.h"
-#define UTIL_TABLE_IS_SUPER_TABLE(metaInfo) \
+#define UTIL_TABLE_IS_SUPER_TABLE(metaInfo) \
(((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_SUPER_TABLE))
+
#define UTIL_TABLE_IS_CHILD_TABLE(metaInfo) \
(((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_CHILD_TABLE))
-
-#define UTIL_TABLE_IS_NORMAL_TABLE(metaInfo)\
+
+#define UTIL_TABLE_IS_NORMAL_TABLE(metaInfo) \
(!(UTIL_TABLE_IS_SUPER_TABLE(metaInfo) || UTIL_TABLE_IS_CHILD_TABLE(metaInfo)))
-#define UTIL_TABLE_IS_TMP_TABLE(metaInfo) \
+#define UTIL_TABLE_IS_TMP_TABLE(metaInfo) \
(((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_TEMP_TABLE))
#pragma pack(push,1)
@@ -142,6 +143,7 @@ bool tscIsSessionWindowQuery(SQueryInfo* pQueryInfo);
bool tscIsSecondStageQuery(SQueryInfo* pQueryInfo);
bool tsIsArithmeticQueryOnAggResult(SQueryInfo* pQueryInfo);
bool tscGroupbyColumn(SQueryInfo* pQueryInfo);
+int32_t tscGetTopBotQueryExprIndex(SQueryInfo* pQueryInfo);
bool tscIsTopBotQuery(SQueryInfo* pQueryInfo);
bool hasTagValOutput(SQueryInfo* pQueryInfo);
bool timeWindowInterpoRequired(SQueryInfo *pQueryInfo);
@@ -188,6 +190,7 @@ void tscFieldInfoClear(SFieldInfo* pFieldInfo);
void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc, const SArray* pExprList);
static FORCE_INLINE int32_t tscNumOfFields(SQueryInfo* pQueryInfo) { return pQueryInfo->fieldsInfo.numOfOutput; }
+int32_t tscGetFirstInvisibleFieldPos(SQueryInfo* pQueryInfo);
int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2, int32_t *diffSize);
void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t uid);
@@ -358,6 +361,8 @@ SNewVgroupInfo createNewVgroupInfo(SVgroupMsg *pVgroupMsg);
void tscRemoveTableMetaBuf(STableMetaInfo* pTableMetaInfo, uint64_t id);
+char* cloneCurrentDBName(SSqlObj* pSql);
+
#ifdef __cplusplus
}
#endif
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 4ead7d41801c9ccf0b1e3c5fe69a439629802bbb..b9aaea8469795771854919a2584d28d5c3f4e9e3 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -38,6 +38,11 @@ extern "C" {
#include "qUtil.h"
#include "tcmdtype.h"
+typedef enum {
+ TAOS_REQ_FROM_SHELL,
+ TAOS_REQ_FROM_HTTP
+} SReqOrigin;
+
// forward declaration
struct SSqlInfo;
@@ -123,17 +128,15 @@ typedef struct {
int32_t kvLen; // len of SKVRow
} SMemRowInfo;
typedef struct {
- uint8_t memRowType;
- uint8_t compareStat; // 0 unknown, 1 need compare, 2 no need
- TDRowTLenT dataRowInitLen;
+ uint8_t memRowType; // default is 0, that is SDataRow
+ uint8_t compareStat; // 0 no need, 1 need compare
TDRowTLenT kvRowInitLen;
SMemRowInfo *rowInfo;
} SMemRowBuilder;
typedef enum {
- ROW_COMPARE_UNKNOWN = 0,
+ ROW_COMPARE_NO_NEED = 0,
ROW_COMPARE_NEED = 1,
- ROW_COMPARE_NO_NEED = 2,
} ERowCompareStat;
int tsParseTime(SStrToken *pToken, int64_t *time, char **next, char *error, int16_t timePrec);
@@ -309,6 +312,7 @@ typedef struct {
char * data;
TAOS_ROW tsrow;
TAOS_ROW urow;
+ bool dataConverted;
int32_t* length; // length for each field for current row
char ** buffer; // Buffer used to put multibytes encoded using unicode (wchar_t)
SColumnIndex* pColumnIndex;
@@ -342,6 +346,7 @@ typedef struct STscObj {
SRpcCorEpSet *tscCorMgmtEpSet;
pthread_mutex_t mutex;
int32_t numOfObj; // number of sqlObj from this tscObj
+ SReqOrigin from;
} STscObj;
typedef struct SSubqueryState {
@@ -377,6 +382,7 @@ typedef struct SSqlObj {
SSubqueryState subState;
struct SSqlObj **pSubs;
+ struct SSqlObj *rootObj;
int64_t metaRid;
int64_t svgroupRid;
@@ -441,7 +447,7 @@ int32_t tscTansformFuncForSTableQuery(SQueryInfo *pQueryInfo);
void tscRestoreFuncForSTableQuery(SQueryInfo *pQueryInfo);
int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
-void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
+void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo, bool converted);
void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock, bool convertNchar);
void handleDownstreamOperator(SSqlObj** pSqlList, int32_t numOfUpstream, SQueryInfo* px, SSqlObj* pParent);
@@ -488,6 +494,7 @@ bool tscHasReachLimitation(SQueryInfo *pQueryInfo, SSqlRes *pRes);
void tscSetBoundColumnInfo(SParsedDataColInfo *pColInfo, SSchema *pSchema, int32_t numOfCols);
char *tscGetErrorMsgPayload(SSqlCmd *pCmd);
+int32_t tscErrorMsgWithCode(int32_t code, char* dstBuffer, const char* errMsg, const char* sql);
int32_t tscInvalidOperationMsg(char *msg, const char *additionalInfo, const char *sql);
int32_t tscSQLSyntaxErrMsg(char* msg, const char* additionalInfo, const char* sql);
diff --git a/src/client/src/TSDBJNIConnector.c b/src/client/src/TSDBJNIConnector.c
index 7ba613de88f2d358e4a359cfa5fb0d5f32a1071e..506c8d64b9f4213713656ecd08612a103e0b1b2d 100644
--- a/src/client/src/TSDBJNIConnector.c
+++ b/src/client/src/TSDBJNIConnector.c
@@ -20,12 +20,42 @@
#include "com_taosdata_jdbc_TSDBJNIConnector.h"
-#define jniFatal(...) { if (jniDebugFlag & DEBUG_FATAL) { taosPrintLog("JNI FATAL ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); }}
-#define jniError(...) { if (jniDebugFlag & DEBUG_ERROR) { taosPrintLog("JNI ERROR ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); }}
-#define jniWarn(...) { if (jniDebugFlag & DEBUG_WARN) { taosPrintLog("JNI WARN ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); }}
-#define jniInfo(...) { if (jniDebugFlag & DEBUG_INFO) { taosPrintLog("JNI ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); }}
-#define jniDebug(...) { if (jniDebugFlag & DEBUG_DEBUG) { taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); }}
-#define jniTrace(...) { if (jniDebugFlag & DEBUG_TRACE) { taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); }}
+#define jniFatal(...) \
+ { \
+ if (jniDebugFlag & DEBUG_FATAL) { \
+ taosPrintLog("JNI FATAL ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); \
+ } \
+ }
+#define jniError(...) \
+ { \
+ if (jniDebugFlag & DEBUG_ERROR) { \
+ taosPrintLog("JNI ERROR ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); \
+ } \
+ }
+#define jniWarn(...) \
+ { \
+ if (jniDebugFlag & DEBUG_WARN) { \
+ taosPrintLog("JNI WARN ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); \
+ } \
+ }
+#define jniInfo(...) \
+ { \
+ if (jniDebugFlag & DEBUG_INFO) { \
+ taosPrintLog("JNI ", tscEmbedded ? 255 : jniDebugFlag, __VA_ARGS__); \
+ } \
+ }
+#define jniDebug(...) \
+ { \
+ if (jniDebugFlag & DEBUG_DEBUG) { \
+ taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); \
+ } \
+ }
+#define jniTrace(...) \
+ { \
+ if (jniDebugFlag & DEBUG_TRACE) { \
+ taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); \
+ } \
+ }
int __init = 0;
@@ -60,14 +90,14 @@ jmethodID g_blockdataSetByteArrayFp;
jmethodID g_blockdataSetNumOfRowsFp;
jmethodID g_blockdataSetNumOfColsFp;
-#define JNI_SUCCESS 0
-#define JNI_TDENGINE_ERROR -1
+#define JNI_SUCCESS 0
+#define JNI_TDENGINE_ERROR -1
#define JNI_CONNECTION_NULL -2
#define JNI_RESULT_SET_NULL -3
#define JNI_NUM_OF_FIELDS_0 -4
-#define JNI_SQL_NULL -5
-#define JNI_FETCH_END -6
-#define JNI_OUT_OF_MEMORY -7
+#define JNI_SQL_NULL -5
+#define JNI_FETCH_END -6
+#define JNI_OUT_OF_MEMORY -7
static void jniGetGlobalMethod(JNIEnv *env) {
// make sure init function executed once
@@ -129,13 +159,13 @@ static void jniGetGlobalMethod(JNIEnv *env) {
}
static int32_t check_for_params(jobject jobj, jlong conn, jlong res) {
- if ((TAOS*) conn == NULL) {
+ if ((TAOS *)conn == NULL) {
jniError("jobj:%p, connection is closed", jobj);
return JNI_CONNECTION_NULL;
}
- if ((TAOS_RES *) res == NULL) {
- jniError("jobj:%p, conn:%p, res is null", jobj, (TAOS*) conn);
+ if ((TAOS_RES *)res == NULL) {
+ jniError("jobj:%p, conn:%p, res is null", jobj, (TAOS *)conn);
return JNI_RESULT_SET_NULL;
}
@@ -216,7 +246,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setOptions(JNIEnv
JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_connectImp(JNIEnv *env, jobject jobj, jstring jhost,
jint jport, jstring jdbName, jstring juser,
jstring jpass) {
- jlong ret = 0;
+ jlong ret = 0;
const char *host = NULL;
const char *user = NULL;
const char *pass = NULL;
@@ -246,7 +276,7 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_connectImp(JNIEn
jniDebug("jobj:%p, pass not specified, use default password", jobj);
}
- ret = (jlong) taos_connect((char *)host, (char *)user, (char *)pass, (char *)dbname, (uint16_t)jport);
+ ret = (jlong)taos_connect((char *)host, (char *)user, (char *)pass, (char *)dbname, (uint16_t)jport);
if (ret == 0) {
jniError("jobj:%p, conn:%p, connect to database failed, host=%s, user=%s, dbname=%s, port=%d", jobj, (void *)ret,
(char *)host, (char *)user, (char *)dbname, (int32_t)jport);
@@ -289,7 +319,7 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp(
jsize len = (*env)->GetArrayLength(env, jsql);
- char *str = (char *) calloc(1, sizeof(char) * (len + 1));
+ char *str = (char *)calloc(1, sizeof(char) * (len + 1));
if (str == NULL) {
jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
return JNI_OUT_OF_MEMORY;
@@ -315,16 +345,17 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp(
}
free(str);
- return (jlong) pSql;
+ return (jlong)pSql;
}
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrCodeImp(JNIEnv *env, jobject jobj, jlong con, jlong tres) {
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrCodeImp(JNIEnv *env, jobject jobj, jlong con,
+ jlong tres) {
int32_t code = check_for_params(jobj, con, tres);
if (code != JNI_SUCCESS) {
return code;
}
- return (jint)taos_errno((TAOS_RES*) tres);
+ return (jint)taos_errno((TAOS_RES *)tres);
}
JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrMsgImp(JNIEnv *env, jobject jobj, jlong tres) {
@@ -334,7 +365,7 @@ JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrMsgImp(J
JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultSetImp(JNIEnv *env, jobject jobj, jlong con,
jlong tres) {
- TAOS *tscon = (TAOS *)con;
+ TAOS * tscon = (TAOS *)con;
int32_t code = check_for_params(jobj, con, tres);
if (code != JNI_SUCCESS) {
return code;
@@ -359,7 +390,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_isUpdateQueryImp(
SSqlObj *pSql = (TAOS_RES *)tres;
- return (tscIsUpdateQuery(pSql)? 1:0);
+ return (tscIsUpdateQuery(pSql) ? 1 : 0);
}
JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_freeResultSetImp(JNIEnv *env, jobject jobj, jlong con,
@@ -370,21 +401,22 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_freeResultSetImp(
}
taos_free_result((void *)res);
- jniDebug("jobj:%p, conn:%p, free resultset:%p", jobj, (TAOS*) con, (void *)res);
+ jniDebug("jobj:%p, conn:%p, free resultset:%p", jobj, (TAOS *)con, (void *)res);
return JNI_SUCCESS;
}
JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getAffectedRowsImp(JNIEnv *env, jobject jobj, jlong con,
jlong res) {
- TAOS *tscon = (TAOS *)con;
+ TAOS * tscon = (TAOS *)con;
int32_t code = check_for_params(jobj, con, res);
if (code != JNI_SUCCESS) {
return code;
}
jint ret = taos_affected_rows((SSqlObj *)res);
- jniDebug("jobj:%p, conn:%p, sql:%p, res: %p, affect rows:%d", jobj, tscon, (TAOS *)con, (TAOS_RES *)res, (int32_t)ret);
+ jniDebug("jobj:%p, conn:%p, sql:%p, res: %p, affect rows:%d", jobj, tscon, (TAOS *)con, (TAOS_RES *)res,
+ (int32_t)ret);
return ret;
}
@@ -392,13 +424,13 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getAffectedRowsIm
JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getSchemaMetaDataImp(JNIEnv *env, jobject jobj,
jlong con, jlong res,
jobject arrayListObj) {
- TAOS *tscon = (TAOS *)con;
+ TAOS * tscon = (TAOS *)con;
int32_t code = check_for_params(jobj, con, res);
if (code != JNI_SUCCESS) {
return code;
}
- TAOS_RES* tres = (TAOS_RES*) res;
+ TAOS_RES * tres = (TAOS_RES *)res;
TAOS_FIELD *fields = taos_fetch_fields(tres);
int32_t num_fields = taos_num_fields(tres);
@@ -452,7 +484,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
int32_t numOfFields = taos_num_fields(result);
if (numOfFields == 0) {
- jniError("jobj:%p, conn:%p, resultset:%p, fields size %d", jobj, tscon, (void*)res, numOfFields);
+ jniError("jobj:%p, conn:%p, resultset:%p, fields size %d", jobj, tscon, (void *)res, numOfFields);
return JNI_NUM_OF_FIELDS_0;
}
@@ -460,7 +492,8 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
if (row == NULL) {
int code = taos_errno(result);
if (code == TSDB_CODE_SUCCESS) {
- jniDebug("jobj:%p, conn:%p, resultset:%p, fields size is %d, fetch row to the end", jobj, tscon, (void*)res, numOfFields);
+ jniDebug("jobj:%p, conn:%p, resultset:%p, fields size is %d, fetch row to the end", jobj, tscon, (void *)res,
+ numOfFields);
return JNI_FETCH_END;
} else {
jniDebug("jobj:%p, conn:%p, interrupted query", jobj, tscon);
@@ -468,7 +501,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
}
}
- int32_t* length = taos_fetch_lengths(result);
+ int32_t *length = taos_fetch_lengths(result);
char tmp[TSDB_MAX_BYTES_PER_ROW] = {0};
@@ -533,7 +566,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
}
JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchBlockImp(JNIEnv *env, jobject jobj, jlong con,
- jlong res, jobject rowobj) {
+ jlong res, jobject rowobj) {
TAOS * tscon = (TAOS *)con;
int32_t code = check_for_params(jobj, con, res);
if (code != JNI_SUCCESS) {
@@ -564,8 +597,13 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchBlockImp(JNI
(*env)->CallVoidMethod(env, rowobj, g_blockdataSetNumOfColsFp, (jint)numOfFields);
for (int i = 0; i < numOfFields; i++) {
- (*env)->CallVoidMethod(env, rowobj, g_blockdataSetByteArrayFp, i, fields[i].bytes * numOfRows,
- jniFromNCharToByteArray(env, (char *)row[i], fields[i].bytes * numOfRows));
+ int bytes = fields[i].bytes;
+
+ if (fields[i].type == TSDB_DATA_TYPE_BINARY || fields[i].type == TSDB_DATA_TYPE_NCHAR) {
+ bytes += 2;
+ }
+ (*env)->CallVoidMethod(env, rowobj, g_blockdataSetByteArrayFp, i, bytes * numOfRows,
+ jniFromNCharToByteArray(env, (char *)row[i], bytes * numOfRows));
}
return JNI_SUCCESS;
@@ -585,7 +623,8 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeConnectionIm
}
JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_subscribeImp(JNIEnv *env, jobject jobj, jlong con,
- jboolean restart, jstring jtopic, jstring jsql, jint jinterval) {
+ jboolean restart, jstring jtopic,
+ jstring jsql, jint jinterval) {
jlong sub = 0;
TAOS *taos = (TAOS *)con;
char *topic = NULL;
@@ -682,8 +721,8 @@ JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getTsCharset(J
* @param res the TAOS_RES object, i.e. the SSqlObject
* @return precision 0:ms 1:us 2:ns
*/
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultTimePrecisionImp(JNIEnv *env, jobject jobj, jlong con,
- jlong res) {
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultTimePrecisionImp(JNIEnv *env, jobject jobj,
+ jlong con, jlong res) {
TAOS *tscon = (TAOS *)con;
if (tscon == NULL) {
jniError("jobj:%p, connection is closed", jobj);
@@ -699,7 +738,8 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultTimePrec
return taos_result_precision(result);
}
-JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_prepareStmtImp(JNIEnv *env, jobject jobj, jbyteArray jsql, jlong con) {
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_prepareStmtImp(JNIEnv *env, jobject jobj,
+ jbyteArray jsql, jlong con) {
TAOS *tscon = (TAOS *)con;
if (tscon == NULL) {
jniError("jobj:%p, connection already closed", jobj);
@@ -713,7 +753,7 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_prepareStmtImp(J
jsize len = (*env)->GetArrayLength(env, jsql);
- char *str = (char *) calloc(1, sizeof(char) * (len + 1));
+ char *str = (char *)calloc(1, sizeof(char) * (len + 1));
if (str == NULL) {
jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
return JNI_OUT_OF_MEMORY;
@@ -724,25 +764,27 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_prepareStmtImp(J
// todo handle error
}
- TAOS_STMT* pStmt = taos_stmt_init(tscon);
- int32_t code = taos_stmt_prepare(pStmt, str, len);
+ TAOS_STMT *pStmt = taos_stmt_init(tscon);
+ int32_t code = taos_stmt_prepare(pStmt, str, len);
tfree(str);
if (code != TSDB_CODE_SUCCESS) {
jniError("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
return JNI_TDENGINE_ERROR;
}
- return (jlong) pStmt;
+ return (jlong)pStmt;
}
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameImp(JNIEnv *env, jobject jobj, jlong stmt, jstring jname, jlong conn) {
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameImp(JNIEnv *env, jobject jobj,
+ jlong stmt, jstring jname,
+ jlong conn) {
TAOS *tsconn = (TAOS *)conn;
if (tsconn == NULL) {
jniError("jobj:%p, connection already closed", jobj);
return JNI_CONNECTION_NULL;
}
- TAOS_STMT* pStmt = (TAOS_STMT*) stmt;
+ TAOS_STMT *pStmt = (TAOS_STMT *)stmt;
if (pStmt == NULL) {
jniError("jobj:%p, conn:%p, invalid stmt handle", jobj, tsconn);
return JNI_SQL_NULL;
@@ -750,7 +792,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameI
const char *name = (*env)->GetStringUTFChars(env, jname, NULL);
- int32_t code = taos_stmt_set_tbname((void*)stmt, name);
+ int32_t code = taos_stmt_set_tbname((void *)stmt, name);
if (code != TSDB_CODE_SUCCESS) {
(*env)->ReleaseStringUTFChars(env, jname, name);
@@ -763,8 +805,9 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameI
return JNI_SUCCESS;
}
-JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(JNIEnv *env, jobject jobj, jlong stmt,
- jbyteArray colDataList, jbyteArray lengthList, jbyteArray nullList, jint dataType, jint dataBytes, jint numOfRows, jint colIndex, jlong con) {
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(
+ JNIEnv *env, jobject jobj, jlong stmt, jbyteArray colDataList, jbyteArray lengthList, jbyteArray nullList,
+ jint dataType, jint dataBytes, jint numOfRows, jint colIndex, jlong con) {
TAOS *tscon = (TAOS *)con;
if (tscon == NULL) {
jniError("jobj:%p, connection already closed", jobj);
@@ -798,14 +841,14 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(J
}
// bind multi-rows with only one invoke.
- TAOS_MULTI_BIND* b = calloc(1, sizeof(TAOS_MULTI_BIND));
+ TAOS_MULTI_BIND *b = calloc(1, sizeof(TAOS_MULTI_BIND));
- b->num = numOfRows;
- b->buffer_type = dataType; // todo check data type
- b->buffer_length = IS_VAR_DATA_TYPE(dataType)? dataBytes:tDataTypes[dataType].bytes;
- b->is_null = nullArray;
- b->buffer = colBuf;
- b->length = (int32_t*)lengthArray;
+ b->num = numOfRows;
+ b->buffer_type = dataType; // todo check data type
+ b->buffer_length = IS_VAR_DATA_TYPE(dataType) ? dataBytes : tDataTypes[dataType].bytes;
+ b->is_null = nullArray;
+ b->buffer = colBuf;
+ b->length = (int32_t *)lengthArray;
// set the length and is_null array
if (!IS_VAR_DATA_TYPE(dataType)) {
@@ -829,14 +872,15 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(J
return JNI_SUCCESS;
}
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeBatchImp(JNIEnv *env, jobject jobj, jlong stmt, jlong con) {
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeBatchImp(JNIEnv *env, jobject jobj, jlong stmt,
+ jlong con) {
TAOS *tscon = (TAOS *)con;
if (tscon == NULL) {
jniError("jobj:%p, connection already closed", jobj);
return JNI_CONNECTION_NULL;
}
- TAOS_STMT *pStmt = (TAOS_STMT*) stmt;
+ TAOS_STMT *pStmt = (TAOS_STMT *)stmt;
if (pStmt == NULL) {
jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
return JNI_SQL_NULL;
@@ -853,14 +897,15 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeBatchImp(J
return JNI_SUCCESS;
}
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeStmt(JNIEnv *env, jobject jobj, jlong stmt, jlong con) {
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeStmt(JNIEnv *env, jobject jobj, jlong stmt,
+ jlong con) {
TAOS *tscon = (TAOS *)con;
if (tscon == NULL) {
jniError("jobj:%p, connection already closed", jobj);
return JNI_CONNECTION_NULL;
}
- TAOS_STMT *pStmt = (TAOS_STMT*) stmt;
+ TAOS_STMT *pStmt = (TAOS_STMT *)stmt;
if (pStmt == NULL) {
jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
return JNI_SQL_NULL;
@@ -876,15 +921,16 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeStmt(JNIEnv
return JNI_SUCCESS;
}
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setTableNameTagsImp(JNIEnv *env, jobject jobj,
- jlong stmt, jstring tableName, jint numOfTags, jbyteArray tags, jbyteArray typeList, jbyteArray lengthList, jbyteArray nullList, jlong conn) {
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setTableNameTagsImp(
+ JNIEnv *env, jobject jobj, jlong stmt, jstring tableName, jint numOfTags, jbyteArray tags, jbyteArray typeList,
+ jbyteArray lengthList, jbyteArray nullList, jlong conn) {
TAOS *tsconn = (TAOS *)conn;
if (tsconn == NULL) {
jniError("jobj:%p, connection already closed", jobj);
return JNI_CONNECTION_NULL;
}
- TAOS_STMT* pStmt = (TAOS_STMT*) stmt;
+ TAOS_STMT *pStmt = (TAOS_STMT *)stmt;
if (pStmt == NULL) {
jniError("jobj:%p, conn:%p, invalid stmt handle", jobj, tsconn);
return JNI_SQL_NULL;
@@ -898,39 +944,39 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setTableNameTagsI
}
len = (*env)->GetArrayLength(env, lengthList);
- int64_t *lengthArray = (int64_t*) calloc(1, len);
- (*env)->GetByteArrayRegion(env, lengthList, 0, len, (jbyte*) lengthArray);
+ int64_t *lengthArray = (int64_t *)calloc(1, len);
+ (*env)->GetByteArrayRegion(env, lengthList, 0, len, (jbyte *)lengthArray);
if ((*env)->ExceptionCheck(env)) {
}
len = (*env)->GetArrayLength(env, typeList);
- char *typeArray = (char*) calloc(1, len);
- (*env)->GetByteArrayRegion(env, typeList, 0, len, (jbyte*) typeArray);
+ char *typeArray = (char *)calloc(1, len);
+ (*env)->GetByteArrayRegion(env, typeList, 0, len, (jbyte *)typeArray);
if ((*env)->ExceptionCheck(env)) {
}
len = (*env)->GetArrayLength(env, nullList);
- int32_t *nullArray = (int32_t*) calloc(1, len);
- (*env)->GetByteArrayRegion(env, nullList, 0, len, (jbyte*) nullArray);
+ int32_t *nullArray = (int32_t *)calloc(1, len);
+ (*env)->GetByteArrayRegion(env, nullList, 0, len, (jbyte *)nullArray);
if ((*env)->ExceptionCheck(env)) {
}
const char *name = (*env)->GetStringUTFChars(env, tableName, NULL);
- char* curTags = tagsData;
+ char * curTags = tagsData;
TAOS_BIND *tagsBind = calloc(numOfTags, sizeof(TAOS_BIND));
- for(int32_t i = 0; i < numOfTags; ++i) {
+ for (int32_t i = 0; i < numOfTags; ++i) {
tagsBind[i].buffer_type = typeArray[i];
- tagsBind[i].buffer = curTags;
+ tagsBind[i].buffer = curTags;
tagsBind[i].is_null = &nullArray[i];
- tagsBind[i].length = (uintptr_t*) &lengthArray[i];
+ tagsBind[i].length = (uintptr_t *)&lengthArray[i];
curTags += lengthArray[i];
}
- int32_t code = taos_stmt_set_tbname_tags((void*)stmt, name, tagsBind);
+ int32_t code = taos_stmt_set_tbname_tags((void *)stmt, name, tagsBind);
- int32_t nTags = (int32_t) numOfTags;
+ int32_t nTags = (int32_t)numOfTags;
jniDebug("jobj:%p, conn:%p, set table name:%s, numOfTags:%d", jobj, tsconn, name, nTags);
tfree(tagsData);
@@ -948,28 +994,28 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setTableNameTagsI
}
JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_insertLinesImp(JNIEnv *env, jobject jobj,
- jobjectArray lines, jlong conn) {
+ jobjectArray lines, jlong conn) {
TAOS *taos = (TAOS *)conn;
if (taos == NULL) {
jniError("jobj:%p, connection already closed", jobj);
return JNI_CONNECTION_NULL;
}
- int numLines = (*env)->GetArrayLength(env, lines);
- char** c_lines = calloc(numLines, sizeof(char*));
+ int numLines = (*env)->GetArrayLength(env, lines);
+ char **c_lines = calloc(numLines, sizeof(char *));
if (c_lines == NULL) {
jniError("c_lines:%p, alloc memory failed", c_lines);
return JNI_OUT_OF_MEMORY;
}
for (int i = 0; i < numLines; ++i) {
- jstring line = (jstring) ((*env)->GetObjectArrayElement(env, lines, i));
- c_lines[i] = (char*)(*env)->GetStringUTFChars(env, line, 0);
+ jstring line = (jstring)((*env)->GetObjectArrayElement(env, lines, i));
+ c_lines[i] = (char *)(*env)->GetStringUTFChars(env, line, 0);
}
int code = taos_insert_lines(taos, c_lines, numLines);
for (int i = 0; i < numLines; ++i) {
- jstring line = (jstring) ((*env)->GetObjectArrayElement(env, lines, i));
+ jstring line = (jstring)((*env)->GetObjectArrayElement(env, lines, i));
(*env)->ReleaseStringUTFChars(env, line, c_lines[i]);
}
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index f39169c193d3483e4db6a35aa42f5187ef1bf723..7a7e1adc1ee238980f1a2d3fc002b4df46118133 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -44,6 +44,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
pSql->maxRetry = TSDB_MAX_REPLICA;
pSql->fp = fp;
pSql->fetchFp = fp;
+ pSql->rootObj = pSql;
registerSqlObj(pSql);
@@ -168,6 +169,9 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
} else {
pRes->code = numOfRows;
}
+ if (pRes->code == TSDB_CODE_SUCCESS) {
+ pRes->code = TSDB_CODE_TSC_INVALID_QHANDLE;
+ }
tscAsyncResultOnError(pSql);
return;
@@ -358,15 +362,6 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
}
if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_STMT_INSERT)) { // stmt insert
- STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
- code = tscGetTableMeta(pSql, pTableMetaInfo);
- if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
- taosReleaseRef(tscObjRef, pSql->self);
- return;
- } else {
- assert(code == TSDB_CODE_SUCCESS);
- }
-
(*pSql->fp)(pSql->param, pSql, code);
} else if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_FILE_INSERT)) { // file insert
tscImportDataFromFile(pSql);
diff --git a/src/client/src/tscGlobalmerge.c b/src/client/src/tscGlobalmerge.c
index e696d54abd91ad45eccae23f2650088dab3c91ce..130abdf4a73ade3951070a100555d15270c265f2 100644
--- a/src/client/src/tscGlobalmerge.c
+++ b/src/client/src/tscGlobalmerge.c
@@ -35,6 +35,7 @@ typedef struct SCompareParam {
static bool needToMerge(SSDataBlock* pBlock, SArray* columnIndexList, int32_t index, char **buf) {
int32_t ret = 0;
+
size_t size = taosArrayGetSize(columnIndexList);
if (size > 0) {
ret = compare_aRv(pBlock, columnIndexList, (int32_t) size, index, buf, TSDB_ORDER_ASC);
@@ -564,9 +565,11 @@ static void savePrevOrderColumns(char** prevRow, SArray* pColumnList, SSDataBloc
(*hasPrev) = true;
}
+// tsdb_func_tag function only produce one row of result. Therefore, we need to copy the
+// output value to multiple rows
static void setTagValueForMultipleRows(SQLFunctionCtx* pCtx, int32_t numOfOutput, int32_t numOfRows) {
if (numOfRows <= 1) {
- return ;
+ return;
}
for (int32_t k = 0; k < numOfOutput; ++k) {
@@ -574,12 +577,49 @@ static void setTagValueForMultipleRows(SQLFunctionCtx* pCtx, int32_t numOfOutput
continue;
}
- int32_t inc = numOfRows - 1; // tsdb_func_tag function only produce one row of result
- char* src = pCtx[k].pOutput;
+ char* src = pCtx[k].pOutput;
+ char* dst = pCtx[k].pOutput + pCtx[k].outputBytes;
- for (int32_t i = 0; i < inc; ++i) {
- pCtx[k].pOutput += pCtx[k].outputBytes;
- memcpy(pCtx[k].pOutput, src, (size_t)pCtx[k].outputBytes);
+ // Let's start from the second row, as the first row has result value already.
+ for (int32_t i = 1; i < numOfRows; ++i) {
+ memcpy(dst, src, (size_t)pCtx[k].outputBytes);
+ dst += pCtx[k].outputBytes;
+ }
+ }
+}
+
+static void doMergeResultImpl(SMultiwayMergeInfo* pInfo, SQLFunctionCtx *pCtx, int32_t numOfExpr, int32_t rowIndex, char** pDataPtr) {
+ for (int32_t j = 0; j < numOfExpr; ++j) {
+ pCtx[j].pInput = pDataPtr[j] + pCtx[j].inputBytes * rowIndex;
+ }
+
+ for (int32_t j = 0; j < numOfExpr; ++j) {
+ int32_t functionId = pCtx[j].functionId;
+ if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
+ continue;
+ }
+
+ if (functionId < 0) {
+ SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
+ doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
+ } else {
+ aAggs[functionId].mergeFunc(&pCtx[j]);
+ }
+ }
+}
+
+static void doFinalizeResultImpl(SMultiwayMergeInfo* pInfo, SQLFunctionCtx *pCtx, int32_t numOfExpr) {
+ for(int32_t j = 0; j < numOfExpr; ++j) {
+ int32_t functionId = pCtx[j].functionId;
+ if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
+ continue;
+ }
+
+ if (functionId < 0) {
+ SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
+ doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
+ } else {
+ aAggs[functionId].xFinalize(&pCtx[j]);
}
}
}
@@ -588,52 +628,18 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
SMultiwayMergeInfo* pInfo = pOperator->info;
SQLFunctionCtx* pCtx = pInfo->binfo.pCtx;
- char** add = calloc(pBlock->info.numOfCols, POINTER_BYTES);
+ char** addrPtr = calloc(pBlock->info.numOfCols, POINTER_BYTES);
for(int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
- add[i] = pCtx[i].pInput;
+ addrPtr[i] = pCtx[i].pInput;
pCtx[i].size = 1;
}
for(int32_t i = 0; i < pBlock->info.rows; ++i) {
if (pInfo->hasPrev) {
if (needToMerge(pBlock, pInfo->orderColumnList, i, pInfo->prevRow)) {
- for (int32_t j = 0; j < numOfExpr; ++j) {
- pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
- }
-
- for (int32_t j = 0; j < numOfExpr; ++j) {
- int32_t functionId = pCtx[j].functionId;
- if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
- continue;
- }
-
- if (functionId < 0) {
- SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-
- doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
-
- continue;
- }
-
- aAggs[functionId].mergeFunc(&pCtx[j]);
- }
+ doMergeResultImpl(pInfo, pCtx, numOfExpr, i, addrPtr);
} else {
- for(int32_t j = 0; j < numOfExpr; ++j) { // TODO refactor
- int32_t functionId = pCtx[j].functionId;
- if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
- continue;
- }
-
- if (functionId < 0) {
- SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-
- doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
-
- continue;
- }
-
- aAggs[functionId].xFinalize(&pCtx[j]);
- }
+ doFinalizeResultImpl(pInfo, pCtx, numOfExpr);
int32_t numOfRows = getNumOfResult(pOperator->pRuntimeEnv, pInfo->binfo.pCtx, pOperator->numOfOutput);
setTagValueForMultipleRows(pCtx, pOperator->numOfOutput, numOfRows);
@@ -643,7 +649,7 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
for(int32_t j = 0; j < numOfExpr; ++j) {
pCtx[j].pOutput += (pCtx[j].outputBytes * numOfRows);
if (pCtx[j].functionId == TSDB_FUNC_TOP || pCtx[j].functionId == TSDB_FUNC_BOTTOM) {
- pCtx[j].ptsOutputBuf = pCtx[0].pOutput;
+ if(j>0) pCtx[j].ptsOutputBuf = pCtx[j-1].pOutput;
}
}
@@ -655,48 +661,10 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
aAggs[pCtx[j].functionId].init(&pCtx[j], pCtx[j].resultInfo);
}
- for (int32_t j = 0; j < numOfExpr; ++j) {
- pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
- }
-
- for (int32_t j = 0; j < numOfExpr; ++j) {
- int32_t functionId = pCtx[j].functionId;
- if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
- continue;
- }
-
- if (functionId < 0) {
- SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-
- doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
-
- continue;
- }
-
- aAggs[functionId].mergeFunc(&pCtx[j]);
- }
+ doMergeResultImpl(pInfo, pCtx, numOfExpr, i, addrPtr);
}
} else {
- for (int32_t j = 0; j < numOfExpr; ++j) {
- pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
- }
-
- for (int32_t j = 0; j < numOfExpr; ++j) {
- int32_t functionId = pCtx[j].functionId;
- if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
- continue;
- }
-
- if (functionId < 0) {
- SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-
- doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
-
- continue;
- }
-
- aAggs[functionId].mergeFunc(&pCtx[j]);
- }
+ doMergeResultImpl(pInfo, pCtx, numOfExpr, i, addrPtr);
}
savePrevOrderColumns(pInfo->prevRow, pInfo->orderColumnList, pBlock, i, &pInfo->hasPrev);
@@ -704,11 +672,11 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
{
for(int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
- pCtx[i].pInput = add[i];
+ pCtx[i].pInput = addrPtr[i];
}
}
- tfree(add);
+ tfree(addrPtr);
}
static bool isAllSourcesCompleted(SGlobalMerger *pMerger) {
@@ -816,6 +784,8 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
SLocalDataSource *pOneDataSrc = pMerger->pLocalDataSrc[pTree->pNode[0].index];
bool sameGroup = true;
if (pInfo->hasPrev) {
+
+ // todo refactor extract method
int32_t numOfCols = (int32_t)taosArrayGetSize(pInfo->orderColumnList);
// if this row belongs to current result set group
@@ -955,9 +925,10 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
break;
}
+ bool sameGroup = true;
if (pAggInfo->hasGroupColData) {
- bool sameGroup = isSameGroup(pAggInfo->groupColumnList, pBlock, pAggInfo->currentGroupColData);
- if (!sameGroup) {
+ sameGroup = isSameGroup(pAggInfo->groupColumnList, pBlock, pAggInfo->currentGroupColData);
+ if (!sameGroup && !pAggInfo->multiGroupResults) {
*newgroup = true;
pAggInfo->hasDataBlockForNewGroup = true;
pAggInfo->pExistBlock = pBlock;
@@ -976,26 +947,11 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
}
if (handleData) { // data in current group is all handled
- for(int32_t j = 0; j < pOperator->numOfOutput; ++j) {
- int32_t functionId = pAggInfo->binfo.pCtx[j].functionId;
- if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
- continue;
- }
-
- if (functionId < 0) {
- SUdfInfo* pUdfInfo = taosArrayGet(pAggInfo->udfInfo, -1 * functionId - 1);
-
- doInvokeUdf(pUdfInfo, &pAggInfo->binfo.pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
-
- continue;
- }
-
- aAggs[functionId].xFinalize(&pAggInfo->binfo.pCtx[j]);
- }
+ doFinalizeResultImpl(pAggInfo, pAggInfo->binfo.pCtx, pOperator->numOfOutput);
int32_t numOfRows = getNumOfResult(pOperator->pRuntimeEnv, pAggInfo->binfo.pCtx, pOperator->numOfOutput);
- pAggInfo->binfo.pRes->info.rows += numOfRows;
+ pAggInfo->binfo.pRes->info.rows += numOfRows;
setTagValueForMultipleRows(pAggInfo->binfo.pCtx, pOperator->numOfOutput, numOfRows);
}
@@ -1019,71 +975,127 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
return (pRes->info.rows != 0)? pRes:NULL;
}
-static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
- SSLimitOperatorInfo *pInfo = pOperator->info;
- assert(pInfo->currentGroupOffset >= 0);
+static void doHandleDataInCurrentGroup(SSLimitOperatorInfo* pInfo, SSDataBlock* pBlock, int32_t rowIndex) {
+ if (pInfo->currentOffset > 0) {
+ pInfo->currentOffset -= 1;
+ } else {
+ // discard the data rows in current group
+ if (pInfo->limit.limit < 0 || (pInfo->limit.limit >= 0 && pInfo->rowsTotal < pInfo->limit.limit)) {
+ size_t num1 = taosArrayGetSize(pInfo->pRes->pDataBlock);
+ for (int32_t i = 0; i < num1; ++i) {
+ SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
+ SColumnInfoData *pDstInfoData = taosArrayGet(pInfo->pRes->pDataBlock, i);
- SSDataBlock* pBlock = NULL;
- if (pInfo->currentGroupOffset == 0) {
- publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
- pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
- publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
- if (pBlock == NULL) {
- setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
- }
+ SColumnInfo *pColInfo = &pColInfoData->info;
+
+ char *pSrc = rowIndex * pColInfo->bytes + (char *)pColInfoData->pData;
+ char *pDst = (char *)pDstInfoData->pData + (pInfo->pRes->info.rows * pColInfo->bytes);
- if (*newgroup == false && pInfo->limit.limit > 0 && pInfo->rowsTotal >= pInfo->limit.limit) {
- while ((*newgroup) == false) { // ignore the remain blocks
- publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
- pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
- publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
- if (pBlock == NULL) {
- setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
- return NULL;
- }
+ memcpy(pDst, pSrc, pColInfo->bytes);
}
+
+ pInfo->rowsTotal += 1;
+ pInfo->pRes->info.rows += 1;
}
+ }
+}
+
+static void ensureOutputBuf(SSLimitOperatorInfo * pInfo, SSDataBlock *pResultBlock, int32_t numOfRows) {
+ if (pInfo->capacity < pResultBlock->info.rows + numOfRows) {
+ int32_t total = pResultBlock->info.rows + numOfRows;
+
+ size_t num = taosArrayGetSize(pResultBlock->pDataBlock);
+ for (int32_t i = 0; i < num; ++i) {
+ SColumnInfoData *pInfoData = taosArrayGet(pResultBlock->pDataBlock, i);
+
+ char *tmp = realloc(pInfoData->pData, total * pInfoData->info.bytes);
+ if (tmp != NULL) {
+ pInfoData->pData = tmp;
+ } else {
+ // todo handle the malloc failure
+ }
- return pBlock;
+ pInfo->capacity = total;
+ pInfo->threshold = (int64_t) (total * 0.8);
+ }
}
+}
- publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
- pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
- publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+enum {
+ BLOCK_NEW_GROUP = 1,
+ BLOCK_NO_GROUP = 2,
+ BLOCK_SAME_GROUP = 3,
+};
- if (pBlock == NULL) {
- setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
- return NULL;
+static int32_t doSlimitImpl(SOperatorInfo* pOperator, SSLimitOperatorInfo* pInfo, SSDataBlock* pBlock) {
+ int32_t rowIndex = 0;
+
+ while (rowIndex < pBlock->info.rows) {
+ int32_t numOfCols = (int32_t)taosArrayGetSize(pInfo->orderColumnList);
+
+ bool samegroup = true;
+ if (pInfo->hasPrev) {
+ for (int32_t i = 0; i < numOfCols; ++i) {
+ SColIndex *pIndex = taosArrayGet(pInfo->orderColumnList, i);
+ SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, pIndex->colIndex);
+
+ SColumnInfo *pColInfo = &pColInfoData->info;
+
+ char *d = rowIndex * pColInfo->bytes + (char *)pColInfoData->pData;
+ int32_t ret = columnValueAscendingComparator(pInfo->prevRow[i], d, pColInfo->type, pColInfo->bytes);
+ if (ret != 0) { // it is a new group
+ samegroup = false;
+ break;
+ }
+ }
}
- while(1) {
- if (*newgroup) {
- pInfo->currentGroupOffset -= 1;
- *newgroup = false;
+ if (!samegroup || !pInfo->hasPrev) {
+ pInfo->ignoreCurrentGroup = false;
+ savePrevOrderColumns(pInfo->prevRow, pInfo->orderColumnList, pBlock, rowIndex, &pInfo->hasPrev);
+
+ pInfo->currentOffset = pInfo->limit.offset; // reset the offset value for a new group
+ pInfo->rowsTotal = 0;
+
+ if (pInfo->currentGroupOffset > 0) {
+ pInfo->ignoreCurrentGroup = true;
+ pInfo->currentGroupOffset -= 1; // now we are in the next group data
+ rowIndex += 1;
+ continue;
+ }
+
+ // A new group has arrived according to the result rows, and the group limitation has already reached.
+ // Let's jump out of current loop and return immediately.
+ if (pInfo->slimit.limit >= 0 && pInfo->groupTotal >= pInfo->slimit.limit) {
+ setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
+ pOperator->status = OP_EXEC_DONE;
+ return BLOCK_NO_GROUP;
}
- while ((*newgroup) == false) {
- publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
- pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
- publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+ pInfo->groupTotal += 1;
- if (pBlock == NULL) {
- setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
- return NULL;
- }
+ // data in current group not allowed, return if current result does not belong to the previous group.And there
+ // are results exists in current SSDataBlock
+ if (!pInfo->multigroupResult && !samegroup && pInfo->pRes->info.rows > 0) {
+ return BLOCK_NEW_GROUP;
}
- // now we have got the first data block of the next group.
- if (pInfo->currentGroupOffset == 0) {
- return pBlock;
+ doHandleDataInCurrentGroup(pInfo, pBlock, rowIndex);
+
+ } else { // handle the offset in the same group
+ // All the data in current group needs to be discarded, due to the limit parameter in the SQL statement
+ if (pInfo->ignoreCurrentGroup) {
+ rowIndex += 1;
+ continue;
}
+
+ doHandleDataInCurrentGroup(pInfo, pBlock, rowIndex);
}
- return NULL;
+ rowIndex += 1;
+ }
+
+ return BLOCK_SAME_GROUP;
}
SSDataBlock* doSLimit(void* param, bool* newgroup) {
@@ -1093,63 +1105,41 @@ SSDataBlock* doSLimit(void* param, bool* newgroup) {
}
SSLimitOperatorInfo *pInfo = pOperator->info;
+ pInfo->pRes->info.rows = 0;
- SSDataBlock *pBlock = NULL;
- while (1) {
- pBlock = skipGroupBlock(pOperator, newgroup);
- if (pBlock == NULL) {
- setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
- return NULL;
- }
-
- if (*newgroup) { // a new group arrives
- pInfo->groupTotal += 1;
- pInfo->rowsTotal = 0;
- pInfo->currentOffset = pInfo->limit.offset;
- }
+ if (pInfo->pPrevBlock != NULL) {
+ ensureOutputBuf(pInfo, pInfo->pRes, pInfo->pPrevBlock->info.rows);
+ int32_t ret = doSlimitImpl(pOperator, pInfo, pInfo->pPrevBlock);
+ assert(ret != BLOCK_NEW_GROUP);
- assert(pInfo->currentGroupOffset == 0);
-
- if (pInfo->currentOffset >= pBlock->info.rows) {
- pInfo->currentOffset -= pBlock->info.rows;
- } else {
- if (pInfo->currentOffset == 0) {
- break;
- }
-
- int32_t remain = (int32_t)(pBlock->info.rows - pInfo->currentOffset);
- pBlock->info.rows = remain;
+ pInfo->pPrevBlock = NULL;
+ }
- // move the remain rows of this data block to the front.
- for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
- SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
+ assert(pInfo->currentGroupOffset >= 0);
- int16_t bytes = pColInfoData->info.bytes;
- memmove(pColInfoData->pData, pColInfoData->pData + bytes * pInfo->currentOffset, remain * bytes);
- }
+ while(1) {
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
+ SSDataBlock *pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
- pInfo->currentOffset = 0;
- break;
+ if (pBlock == NULL) {
+ return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes;
}
- }
-
- if (pInfo->slimit.limit > 0 && pInfo->groupTotal > pInfo->slimit.limit) { // reach the group limit, abort
- return NULL;
- }
- if (pInfo->limit.limit > 0 && (pInfo->rowsTotal + pBlock->info.rows >= pInfo->limit.limit)) {
- pBlock->info.rows = (int32_t)(pInfo->limit.limit - pInfo->rowsTotal);
- pInfo->rowsTotal = pInfo->limit.limit;
+ ensureOutputBuf(pInfo, pInfo->pRes, pBlock->info.rows);
+ int32_t ret = doSlimitImpl(pOperator, pInfo, pBlock);
+ if (ret == BLOCK_NEW_GROUP) {
+ pInfo->pPrevBlock = pBlock;
+ return pInfo->pRes;
+ }
- if (pInfo->slimit.limit > 0 && pInfo->groupTotal >= pInfo->slimit.limit) {
- pOperator->status = OP_EXEC_DONE;
+ if (pOperator->status == OP_EXEC_DONE) {
+ return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes;
}
- // setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- } else {
- pInfo->rowsTotal += pBlock->info.rows;
+ // now the number of rows in current group is enough, let's return to the invoke function
+ if (pInfo->pRes->info.rows > pInfo->threshold) {
+ return pInfo->pRes;
+ }
}
-
- return pBlock;
}
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 89e3832007f11dc0ede00e639d75875f142b12f1..fdcfcb02de470a23afd552be81292c31572fcc55 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -51,20 +51,18 @@ int initMemRowBuilder(SMemRowBuilder *pBuilder, uint32_t nRows, uint3
}
}
+ // default compareStat is ROW_COMPARE_NO_NEED
if (nBoundCols == 0) { // file input
pBuilder->memRowType = SMEM_ROW_DATA;
- pBuilder->compareStat = ROW_COMPARE_NO_NEED;
return TSDB_CODE_SUCCESS;
} else {
float boundRatio = ((float)nBoundCols / (float)nCols);
if (boundRatio < KVRatioKV) {
pBuilder->memRowType = SMEM_ROW_KV;
- pBuilder->compareStat = ROW_COMPARE_NO_NEED;
return TSDB_CODE_SUCCESS;
} else if (boundRatio > KVRatioData) {
pBuilder->memRowType = SMEM_ROW_DATA;
- pBuilder->compareStat = ROW_COMPARE_NO_NEED;
return TSDB_CODE_SUCCESS;
}
pBuilder->compareStat = ROW_COMPARE_NEED;
@@ -76,7 +74,6 @@ int initMemRowBuilder(SMemRowBuilder *pBuilder, uint32_t nRows, uint3
}
}
- pBuilder->dataRowInitLen = TD_MEM_ROW_DATA_HEAD_SIZE + allNullLen;
pBuilder->kvRowInitLen = TD_MEM_ROW_KV_HEAD_SIZE + nBoundCols * sizeof(SColIdx);
if (nRows > 0) {
@@ -86,7 +83,7 @@ int initMemRowBuilder(SMemRowBuilder *pBuilder, uint32_t nRows, uint3
}
for (int i = 0; i < nRows; ++i) {
- (pBuilder->rowInfo + i)->dataLen = pBuilder->dataRowInitLen;
+ (pBuilder->rowInfo + i)->dataLen = TD_MEM_ROW_DATA_HEAD_SIZE + allNullLen;
(pBuilder->rowInfo + i)->kvLen = pBuilder->kvRowInitLen;
}
}
@@ -117,7 +114,7 @@ int tsParseTime(SStrToken *pToken, int64_t *time, char **next, char *error, int1
}
for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
- if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
+ if (isspace(pToken->z[k])) continue;
if (pToken->z[k] == ',') {
*next = pTokenEnd;
*time = useconds;
@@ -460,7 +457,7 @@ int tsParseOneRow(char **str, STableDataBlocks *pDataBlocks, int16_t timePrec, i
STableMeta * pTableMeta = pDataBlocks->pTableMeta;
SSchema * schema = tscGetTableSchema(pTableMeta);
SMemRowBuilder * pBuilder = &pDataBlocks->rowBuilder;
- int32_t dataLen = pBuilder->dataRowInitLen;
+ int32_t dataLen = spd->allNullLen + TD_MEM_ROW_DATA_HEAD_SIZE;
int32_t kvLen = pBuilder->kvRowInitLen;
bool isParseBindParam = false;
@@ -809,13 +806,12 @@ int tscSortRemoveDataBlockDupRows(STableDataBlocks *dataBuf, SBlockKeyInfo *pBlk
// allocate memory
size_t nAlloc = nRows * sizeof(SBlockKeyTuple);
if (pBlkKeyInfo->pKeyTuple == NULL || pBlkKeyInfo->maxBytesAlloc < nAlloc) {
- size_t nRealAlloc = nAlloc + 10 * sizeof(SBlockKeyTuple);
- char * tmp = trealloc(pBlkKeyInfo->pKeyTuple, nRealAlloc);
+ char *tmp = trealloc(pBlkKeyInfo->pKeyTuple, nAlloc);
if (tmp == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
pBlkKeyInfo->pKeyTuple = (SBlockKeyTuple *)tmp;
- pBlkKeyInfo->maxBytesAlloc = (int32_t)nRealAlloc;
+ pBlkKeyInfo->maxBytesAlloc = (int32_t)nAlloc;
}
memset(pBlkKeyInfo->pKeyTuple, 0, nAlloc);
@@ -1593,7 +1589,8 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
ret = tsParseInsertSql(pSql);
if (pSql->parseRetry < 1 && (ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_OPERATION)) {
- tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, clear meta cache and retry ", pSql->self, tstrerror(ret));
+ SInsertStatementParam* pInsertParam = &pCmd->insertParam;
+ tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, msg:%s, clear meta cache and retry ", pSql->self, pInsertParam->msg, tstrerror(ret));
tscResetSqlCmd(pCmd, true);
pSql->parseRetry++;
@@ -1697,7 +1694,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
STableComInfo tinfo = tscGetTableInfo(pTableMeta);
- SInsertStatementParam* pInsertParam = &pCmd->insertParam;
+ SInsertStatementParam *pInsertParam = &pCmd->insertParam;
destroyTableNameList(pInsertParam);
pInsertParam->pDataBlocks = tscDestroyBlockArrayList(pInsertParam->pDataBlocks);
@@ -1726,12 +1723,6 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
goto _error;
}
- if (TSDB_CODE_SUCCESS !=
- (ret = initMemRowBuilder(&pTableDataBlock->rowBuilder, 0, tinfo.numOfColumns, pTableDataBlock->numOfParams,
- pTableDataBlock->boundColumnInfo.allNullLen))) {
- goto _error;
- }
-
while ((readLen = tgetline(&line, &n, fp)) != -1) {
if (('\r' == line[readLen - 1]) || ('\n' == line[readLen - 1])) {
line[--readLen] = 0;
@@ -1767,6 +1758,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
pSql->res.numOfRows = 0;
code = doPackSendDataBlock(pSql, pInsertParam, pTableMeta, count, pTableDataBlock);
if (code != TSDB_CODE_SUCCESS) {
+ pParentSql->res.code = code;
goto _error;
}
@@ -1787,6 +1779,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
}
_error:
+ pParentSql->res.code = code;
tfree(tokenBuf);
tfree(line);
taos_free_result(pSql);
diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 2a16f1aad6525a25da652f643dc7b7f91debd432..1bad1c72409baa9921a096e500c71a2e1a172ad4 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -33,7 +33,6 @@ typedef struct {
int16_t length;
char* value;
- //===================================
uint32_t fieldSchemaIdx;
} TAOS_SML_KV;
@@ -48,7 +47,6 @@ typedef struct {
TAOS_SML_KV* fields;
int32_t fieldNum;
- //================================
uint32_t schemaIdx;
} TAOS_SML_DATA_POINT;
@@ -62,10 +60,22 @@ typedef enum {
typedef struct {
uint64_t id;
-
} SSmlLinesInfo;
+
//=================================================================================================
+static uint64_t linesSmlHandleId = 0;
+
+uint64_t genLinesSmlId() {
+ uint64_t id;
+
+ do {
+ id = atomic_add_fetch_64(&linesSmlHandleId, 1);
+ } while (id == 0);
+
+ return id;
+}
+
int compareSmlColKv(const void* p1, const void* p2) {
TAOS_SML_KV* kv1 = (TAOS_SML_KV*)p1;
TAOS_SML_KV* kv2 = (TAOS_SML_KV*)p2;
@@ -173,6 +183,40 @@ static int32_t buildSmlKvSchema(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* arra
return 0;
}
+static int32_t getSmlMd5ChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen,
+ SSmlLinesInfo* info) {
+ tscDebug("SML:0x%"PRIx64" taos_sml_insert get child table name through md5", info->id);
+ qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
+
+ SStringBuilder sb; memset(&sb, 0, sizeof(sb));
+ char sTableName[TSDB_TABLE_NAME_LEN] = {0};
+ strtolower(sTableName, point->stableName);
+ taosStringBuilderAppendString(&sb, sTableName);
+ for (int j = 0; j < point->tagNum; ++j) {
+ taosStringBuilderAppendChar(&sb, ',');
+ TAOS_SML_KV* tagKv = point->tags + j;
+ char tagName[TSDB_COL_NAME_LEN] = {0};
+ strtolower(tagName, tagKv->key);
+ taosStringBuilderAppendString(&sb, tagName);
+ taosStringBuilderAppendChar(&sb, '=');
+ taosStringBuilderAppend(&sb, tagKv->value, tagKv->length);
+ }
+ size_t len = 0;
+ char* keyJoined = taosStringBuilderGetResult(&sb, &len);
+ MD5_CTX context;
+ MD5Init(&context);
+ MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
+ MD5Final(&context);
+ *tableNameLen = snprintf(tableName, *tableNameLen,
+ "t_%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
+ context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
+ context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
+ context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
+ taosStringBuilderDestroy(&sb);
+ tscDebug("SML:0x%"PRIx64" child table name: %s", info->id, tableName);
+ return 0;
+}
+
static int32_t buildDataPointSchemas(TAOS_SML_DATA_POINT* points, int numPoint, SArray* stableSchemas, SSmlLinesInfo* info) {
int32_t code = 0;
SHashObj* sname2shema = taosHashInit(32,
@@ -203,6 +247,15 @@ static int32_t buildDataPointSchemas(TAOS_SML_DATA_POINT* points, int numPoint,
for (int j = 0; j < point->tagNum; ++j) {
TAOS_SML_KV* tagKv = point->tags + j;
+ if (!point->childTableName) {
+ char childTableName[TSDB_TABLE_NAME_LEN];
+ int32_t tableNameLen = TSDB_TABLE_NAME_LEN;
+ getSmlMd5ChildTableName(point, childTableName, &tableNameLen, info);
+ point->childTableName = calloc(1, tableNameLen+1);
+ strncpy(point->childTableName, childTableName, tableNameLen);
+ point->childTableName[tableNameLen] = '\0';
+ }
+
code = buildSmlKvSchema(tagKv, pStableSchema->tagHash, pStableSchema->tags, info);
if (code != 0) {
tscError("SML:0x%"PRIx64" build data point schema failed. point no.: %d, tag key: %s", info->id, i, tagKv->key);
@@ -319,7 +372,23 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
buildColumnDescription(action->alterSTable.field, result+n, capacity-n, &outBytes);
TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
code = taos_errno(res);
+ char* errStr = taos_errstr(res);
+ char* begin = strstr(errStr, "duplicated column names");
+ bool tscDupColNames = (begin != NULL);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%"PRIx64" apply schema action. error: %s", info->id, errStr);
+ }
taos_free_result(res);
+
+ if (code == TSDB_CODE_MND_FIELD_ALREAY_EXIST || code == TSDB_CODE_MND_TAG_ALREAY_EXIST || tscDupColNames) {
+ TAOS_RES* res2 = taos_query(taos, "RESET QUERY CACHE");
+ code = taos_errno(res2);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
+ }
+ taos_free_result(res2);
+ taosMsleep(500);
+ }
break;
}
case SCHEMA_ACTION_ADD_TAG: {
@@ -328,7 +397,23 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
result+n, capacity-n, &outBytes);
TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
code = taos_errno(res);
+ char* errStr = taos_errstr(res);
+ char* begin = strstr(errStr, "duplicated column names");
+ bool tscDupColNames = (begin != NULL);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%"PRIx64" apply schema action. error : %s", info->id, taos_errstr(res));
+ }
taos_free_result(res);
+
+ if (code == TSDB_CODE_MND_TAG_ALREAY_EXIST || code == TSDB_CODE_MND_FIELD_ALREAY_EXIST || tscDupColNames) {
+ TAOS_RES* res2 = taos_query(taos, "RESET QUERY CACHE");
+ code = taos_errno(res2);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
+ }
+ taos_free_result(res2);
+ taosMsleep(500);
+ }
break;
}
case SCHEMA_ACTION_CHANGE_COLUMN_SIZE: {
@@ -337,7 +422,20 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
capacity-n, &outBytes);
TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
code = taos_errno(res);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%"PRIx64" apply schema action. error : %s", info->id, taos_errstr(res));
+ }
taos_free_result(res);
+
+ if (code == TSDB_CODE_MND_INVALID_COLUMN_LENGTH || code == TSDB_CODE_TSC_INVALID_COLUMN_LENGTH) {
+ TAOS_RES* res2 = taos_query(taos, "RESET QUERY CACHE");
+ code = taos_errno(res2);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
+ }
+ taos_free_result(res2);
+ taosMsleep(500);
+ }
break;
}
case SCHEMA_ACTION_CHANGE_TAG_SIZE: {
@@ -346,7 +444,20 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
capacity-n, &outBytes);
TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
code = taos_errno(res);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%"PRIx64" apply schema action. error : %s", info->id, taos_errstr(res));
+ }
taos_free_result(res);
+
+ if (code == TSDB_CODE_MND_INVALID_TAG_LENGTH || code == TSDB_CODE_TSC_INVALID_TAG_LENGTH) {
+ TAOS_RES* res2 = taos_query(taos, "RESET QUERY CACHE");
+ code = taos_errno(res2);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
+ }
+ taos_free_result(res2);
+ taosMsleep(500);
+ }
break;
}
case SCHEMA_ACTION_CREATE_STABLE: {
@@ -375,7 +486,20 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
outBytes = snprintf(pos, freeBytes, ")");
TAOS_RES* res = taos_query(taos, result);
code = taos_errno(res);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%"PRIx64" apply schema action. error : %s", info->id, taos_errstr(res));
+ }
taos_free_result(res);
+
+ if (code == TSDB_CODE_MND_TABLE_ALREADY_EXIST) {
+ TAOS_RES* res2 = taos_query(taos, "RESET QUERY CACHE");
+ code = taos_errno(res2);
+ if (code != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
+ }
+ taos_free_result(res2);
+ taosMsleep(500);
+ }
break;
}
@@ -385,7 +509,7 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
free(result);
if (code != 0) {
- tscError("SML:0x%"PRIx64 "apply schema action failure. %s", info->id, tstrerror(code));
+ tscError("SML:0x%"PRIx64 " apply schema action failure. %s", info->id, tstrerror(code));
}
return code;
}
@@ -398,70 +522,12 @@ static int32_t destroySmlSTableSchema(SSmlSTableSchema* schema) {
return 0;
}
-int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema, SSmlLinesInfo* info) {
- int32_t code = 0;
-
- STscObj *pObj = (STscObj *)taos;
- if (pObj == NULL || pObj->signature != pObj) {
- terrno = TSDB_CODE_TSC_DISCONNECTED;
- return TSDB_CODE_TSC_DISCONNECTED;
- }
-
- tscDebug("SML:0x%"PRIx64" load table schema. super table name: %s", info->id, tableName);
-
- char tableNameLowerCase[TSDB_TABLE_NAME_LEN];
- strtolower(tableNameLowerCase, tableName);
-
- char sql[256];
- snprintf(sql, 256, "describe %s", tableNameLowerCase);
- TAOS_RES* res = taos_query(taos, sql);
- code = taos_errno(res);
- if (code != 0) {
- tscError("SML:0x%"PRIx64" describe table failure. %s", info->id, taos_errstr(res));
- taos_free_result(res);
- return code;
- }
- taos_free_result(res);
-
- SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
- if (pSql == NULL){
- tscError("failed to allocate memory, reason:%s", strerror(errno));
- code = TSDB_CODE_TSC_OUT_OF_MEMORY;
- return code;
- }
- pSql->pTscObj = taos;
- pSql->signature = pSql;
- pSql->fp = NULL;
-
- SStrToken tableToken = {.z=tableNameLowerCase, .n=(uint32_t)strlen(tableNameLowerCase), .type=TK_ID};
- tGetToken(tableNameLowerCase, &tableToken.type);
- // Check if the table name available or not
- if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
- code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
- sprintf(pSql->cmd.payload, "table name is invalid");
- tscFreeSqlObj(pSql);
- return code;
- }
-
- SName sname = {0};
- if ((code = tscSetTableFullName(&sname, &tableToken, pSql)) != TSDB_CODE_SUCCESS) {
- tscFreeSqlObj(pSql);
- return code;
- }
- char fullTableName[TSDB_TABLE_FNAME_LEN] = {0};
- memset(fullTableName, 0, tListLen(fullTableName));
- tNameExtractFullName(&sname, fullTableName);
- tscFreeSqlObj(pSql);
-
+static int32_t fillDbSchema(STableMeta* tableMeta, char* tableName, SSmlSTableSchema* schema, SSmlLinesInfo* info) {
schema->tags = taosArrayInit(8, sizeof(SSchema));
schema->fields = taosArrayInit(64, sizeof(SSchema));
schema->tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
schema->fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
- size_t size = 0;
- STableMeta* tableMeta = NULL;
- taosHashGetCloneExt(tscTableMetaMap, fullTableName, strlen(fullTableName), NULL, (void **)&tableMeta, &size);
-
tstrncpy(schema->sTableName, tableName, strlen(tableName)+1);
schema->precision = tableMeta->tableInfo.precision;
for (int i=0; itableInfo.numOfColumns; ++i) {
@@ -484,9 +550,93 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema, SSm
size_t tagIndex = taosArrayGetSize(schema->tags) - 1;
taosHashPut(schema->tagHash, field.name, strlen(field.name), &tagIndex, sizeof(tagIndex));
}
- tscDebug("SML:0x%"PRIx64 " load table meta succeed. table name: %s, columns number: %d, tag number: %d, precision: %d",
+ tscDebug("SML:0x%"PRIx64 " load table schema succeed. table name: %s, columns number: %d, tag number: %d, precision: %d",
info->id, tableName, tableMeta->tableInfo.numOfColumns, tableMeta->tableInfo.numOfTags, schema->precision);
- free(tableMeta); tableMeta = NULL;
+ return TSDB_CODE_SUCCESS;
+}
+
+static int32_t retrieveTableMeta(TAOS* taos, char* tableName, STableMeta** pTableMeta, SSmlLinesInfo* info) {
+ int32_t code = 0;
+ int32_t retries = 0;
+ STableMeta* tableMeta = NULL;
+ while (retries++ < TSDB_MAX_REPLICA && tableMeta == NULL) {
+ STscObj* pObj = (STscObj*)taos;
+ if (pObj == NULL || pObj->signature != pObj) {
+ terrno = TSDB_CODE_TSC_DISCONNECTED;
+ return TSDB_CODE_TSC_DISCONNECTED;
+ }
+
+ tscDebug("SML:0x%" PRIx64 " retrieve table meta. super table name: %s", info->id, tableName);
+
+ char tableNameLowerCase[TSDB_TABLE_NAME_LEN];
+ strtolower(tableNameLowerCase, tableName);
+
+ char sql[256];
+ snprintf(sql, 256, "describe %s", tableNameLowerCase);
+ TAOS_RES* res = taos_query(taos, sql);
+ code = taos_errno(res);
+ if (code != 0) {
+ tscError("SML:0x%" PRIx64 " describe table failure. %s", info->id, taos_errstr(res));
+ taos_free_result(res);
+ return code;
+ }
+ taos_free_result(res);
+
+ SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
+ if (pSql == NULL) {
+ tscError("SML:0x%" PRIx64 " failed to allocate memory, reason:%s", info->id, strerror(errno));
+ code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+ return code;
+ }
+ pSql->pTscObj = taos;
+ pSql->signature = pSql;
+ pSql->fp = NULL;
+
+ registerSqlObj(pSql);
+ SStrToken tableToken = {.z = tableNameLowerCase, .n = (uint32_t)strlen(tableNameLowerCase), .type = TK_ID};
+ tGetToken(tableNameLowerCase, &tableToken.type);
+ // Check if the table name available or not
+ if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
+ code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+ sprintf(pSql->cmd.payload, "table name is invalid");
+ taosReleaseRef(tscObjRef, pSql->self);
+ return code;
+ }
+
+ SName sname = {0};
+ if ((code = tscSetTableFullName(&sname, &tableToken, pSql)) != TSDB_CODE_SUCCESS) {
+ taosReleaseRef(tscObjRef, pSql->self);
+ return code;
+ }
+ char fullTableName[TSDB_TABLE_FNAME_LEN] = {0};
+ memset(fullTableName, 0, tListLen(fullTableName));
+ tNameExtractFullName(&sname, fullTableName);
+ taosReleaseRef(tscObjRef, pSql->self);
+
+ size_t size = 0;
+ taosHashGetCloneExt(tscTableMetaMap, fullTableName, strlen(fullTableName), NULL, (void**)&tableMeta, &size);
+ }
+
+ if (tableMeta != NULL) {
+ *pTableMeta = tableMeta;
+ return TSDB_CODE_SUCCESS;
+ } else {
+ tscError("SML:0x%" PRIx64 " failed to retrieve table meta. super table name: %s", info->id, tableName);
+ return TSDB_CODE_TSC_NO_META_CACHED;
+ }
+}
+
+static int32_t loadTableSchemaFromDB(TAOS* taos, char* tableName, SSmlSTableSchema* schema, SSmlLinesInfo* info) {
+ int32_t code = 0;
+ STableMeta* tableMeta = NULL;
+ code = retrieveTableMeta(taos, tableName, &tableMeta, info);
+ if (code == TSDB_CODE_SUCCESS) {
+ assert(tableMeta != NULL);
+ fillDbSchema(tableMeta, tableName, schema, info);
+ free(tableMeta);
+ tableMeta = NULL;
+ }
+
return code;
}
@@ -498,7 +648,7 @@ static int32_t modifyDBSchemas(TAOS* taos, SArray* stableSchemas, SSmlLinesInfo*
SSmlSTableSchema dbSchema;
memset(&dbSchema, 0, sizeof(SSmlSTableSchema));
- code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema, info);
+ code = loadTableSchemaFromDB(taos, pointSchema->sTableName, &dbSchema, info);
if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
SSchemaAction schemaAction = {0};
schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
@@ -507,7 +657,7 @@ static int32_t modifyDBSchemas(TAOS* taos, SArray* stableSchemas, SSmlLinesInfo*
schemaAction.createSTable.tags = pointSchema->tags;
schemaAction.createSTable.fields = pointSchema->fields;
applySchemaAction(taos, &schemaAction, info);
- code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema, info);
+ code = loadTableSchemaFromDB(taos, pointSchema->sTableName, &dbSchema, info);
if (code != 0) {
tscError("SML:0x%"PRIx64" reconcile point schema failed. can not create %s", info->id, pointSchema->sTableName);
return code;
@@ -567,74 +717,6 @@ static int32_t modifyDBSchemas(TAOS* taos, SArray* stableSchemas, SSmlLinesInfo*
return 0;
}
-static int32_t getSmlMd5ChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen,
- SSmlLinesInfo* info) {
- tscDebug("SML:0x%"PRIx64" taos_sml_insert get child table name through md5", info->id);
- qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
-
- SStringBuilder sb; memset(&sb, 0, sizeof(sb));
- char sTableName[TSDB_TABLE_NAME_LEN] = {0};
- strtolower(sTableName, point->stableName);
- taosStringBuilderAppendString(&sb, sTableName);
- for (int j = 0; j < point->tagNum; ++j) {
- taosStringBuilderAppendChar(&sb, ',');
- TAOS_SML_KV* tagKv = point->tags + j;
- char tagName[TSDB_COL_NAME_LEN] = {0};
- strtolower(tagName, tagKv->key);
- taosStringBuilderAppendString(&sb, tagName);
- taosStringBuilderAppendChar(&sb, '=');
- taosStringBuilderAppend(&sb, tagKv->value, tagKv->length);
- }
- size_t len = 0;
- char* keyJoined = taosStringBuilderGetResult(&sb, &len);
- MD5_CTX context;
- MD5Init(&context);
- MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
- MD5Final(&context);
- *tableNameLen = snprintf(tableName, *tableNameLen,
- "t_%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
- context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
- context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
- context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
- taosStringBuilderDestroy(&sb);
- tscDebug("SML:0x%"PRIx64" child table name: %s", info->id, tableName);
- return 0;
-}
-
-
-static int32_t changeChildTableTagValue(TAOS* taos, const char* cTableName, const char* tagName, TAOS_BIND* bind, SSmlLinesInfo* info) {
- char sql[512];
- sprintf(sql, "alter table %s set tag %s=?", cTableName, tagName);
-
- int32_t code;
- TAOS_STMT* stmt = taos_stmt_init(taos);
- code = taos_stmt_prepare(stmt, sql, (unsigned long)strlen(sql));
-
- if (code != 0) {
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
- return code;
- }
-
- code = taos_stmt_bind_param(stmt, bind);
- if (code != 0) {
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
- return code;
- }
-
- code = taos_stmt_execute(stmt);
- if (code != 0) {
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
- return code;
- }
-
- code = taos_stmt_close(stmt);
- if (code != 0) {
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
- return code;
- }
- return code;
-}
-
static int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, const char* sTableName,
SArray* tagsSchema, SArray* tagsBind, SSmlLinesInfo* info) {
size_t numTags = taosArrayGetSize(tagsSchema);
@@ -673,113 +755,162 @@ static int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, co
free(sql);
if (code != 0) {
- tfree(stmt);
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
+ tscError("SML:0x%"PRIx64" taos_stmt_prepare returns %d:%s", info->id, code, tstrerror(code));
+ taos_stmt_close(stmt);
return code;
}
code = taos_stmt_bind_param(stmt, TARRAY_GET_START(tagsBind));
if (code != 0) {
- tfree(stmt);
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
+ tscError("SML:0x%"PRIx64" taos_stmt_bind_param returns %d:%s", info->id, code, tstrerror(code));
+ taos_stmt_close(stmt);
return code;
}
code = taos_stmt_execute(stmt);
if (code != 0) {
- tfree(stmt);
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
+ tscError("SML:0x%"PRIx64" taos_stmt_execute returns %d:%s", info->id, code, tstrerror(code));
+ taos_stmt_close(stmt);
return code;
}
code = taos_stmt_close(stmt);
if (code != 0) {
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
+ tscError("SML:0x%"PRIx64" taos_stmt_close return %d:%s", info->id, code, tstrerror(code));
return code;
}
return code;
}
-static int32_t insertChildTableBatch(TAOS* taos, char* cTableName, SArray* colsSchema, SArray* rowsBind, SSmlLinesInfo* info) {
- size_t numCols = taosArrayGetSize(colsSchema);
- char* sql = malloc(tsMaxSQLStringLen+1);
- if (sql == NULL) {
- tscError("malloc sql memory error");
- return TSDB_CODE_TSC_OUT_OF_MEMORY;
- }
-
- int32_t freeBytes = tsMaxSQLStringLen + 1 ;
- sprintf(sql, "insert into ? (");
-
- for (int i = 0; i < numCols; ++i) {
- SSchema* colSchema = taosArrayGet(colsSchema, i);
- snprintf(sql+strlen(sql), freeBytes-strlen(sql), "%s,", colSchema->name);
- }
- snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ") values (");
-
- for (int i = 0; i < numCols; ++i) {
- snprintf(sql+strlen(sql), freeBytes-strlen(sql), "?,");
- }
- snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ")");
- sql[strlen(sql)] = '\0';
-
- tscDebug("SML:0x%"PRIx64" insert rows into child table %s. num of rows: %zu", info->id, cTableName, taosArrayGetSize(rowsBind));
-
+static int32_t doInsertChildTableWithStmt(TAOS* taos, char* sql, char* cTableName, SArray* batchBind, SSmlLinesInfo* info) {
int32_t code = 0;
- int32_t try = 0;
TAOS_STMT* stmt = taos_stmt_init(taos);
if (stmt == NULL) {
- tfree(sql);
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
+
code = taos_stmt_prepare(stmt, sql, (unsigned long)strlen(sql));
- tfree(sql);
if (code != 0) {
- tfree(stmt);
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
+ tscError("SML:0x%"PRIx64" taos_stmt_prepare return %d:%s", info->id, code, tstrerror(code));
+ taos_stmt_close(stmt);
return code;
}
+ bool tryAgain = false;
+ int32_t try = 0;
do {
code = taos_stmt_set_tbname(stmt, cTableName);
if (code != 0) {
- tfree(stmt);
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
+ tscError("SML:0x%"PRIx64" taos_stmt_set_tbname return %d:%s", info->id, code, tstrerror(code));
+ taos_stmt_close(stmt);
return code;
}
- size_t rows = taosArrayGetSize(rowsBind);
+ size_t rows = taosArrayGetSize(batchBind);
for (int32_t i = 0; i < rows; ++i) {
- TAOS_BIND* colsBinds = taosArrayGetP(rowsBind, i);
+ TAOS_BIND* colsBinds = taosArrayGetP(batchBind, i);
code = taos_stmt_bind_param(stmt, colsBinds);
if (code != 0) {
- tfree(stmt);
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
+ tscError("SML:0x%"PRIx64" taos_stmt_bind_param return %d:%s", info->id, code, tstrerror(code));
+ taos_stmt_close(stmt);
return code;
}
code = taos_stmt_add_batch(stmt);
if (code != 0) {
- tfree(stmt);
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
+ tscError("SML:0x%"PRIx64" taos_stmt_add_batch return %d:%s", info->id, code, tstrerror(code));
+ taos_stmt_close(stmt);
return code;
}
}
code = taos_stmt_execute(stmt);
if (code != 0) {
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
+ tscError("SML:0x%"PRIx64" taos_stmt_execute return %d:%s, try:%d", info->id, code, tstrerror(code), try);
}
- } while (code == TSDB_CODE_TDB_TABLE_RECONFIGURE && try++ < TSDB_MAX_REPLICA);
- if (code != 0) {
- tscError("SML:0x%"PRIx64" %s", info->id, taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- } else {
- taos_stmt_close(stmt);
+ tryAgain = false;
+ if ((code == TSDB_CODE_TDB_INVALID_TABLE_ID
+ || code == TSDB_CODE_VND_INVALID_VGROUP_ID
+ || code == TSDB_CODE_TDB_TABLE_RECONFIGURE
+ || code == TSDB_CODE_APP_NOT_READY
+ || code == TSDB_CODE_RPC_NETWORK_UNAVAIL) && try++ < TSDB_MAX_REPLICA) {
+ tryAgain = true;
+ }
+
+ if (code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) {
+ TAOS_RES* res2 = taos_query(taos, "RESET QUERY CACHE");
+ int32_t code2 = taos_errno(res2);
+ if (code2 != TSDB_CODE_SUCCESS) {
+ tscError("SML:0x%" PRIx64 " insert child table. reset query cache. error: %s", info->id, taos_errstr(res2));
+ }
+ taos_free_result(res2);
+ if (tryAgain) {
+ taosMsleep(100 * (2 << try));
+ }
+ }
+ if (code == TSDB_CODE_APP_NOT_READY || code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
+ if (tryAgain) {
+ taosMsleep( 100 * (2 << try));
+ }
+ }
+ } while (tryAgain);
+
+
+ taos_stmt_close(stmt);
+ return code;
+}
+
+static int32_t insertChildTableBatch(TAOS* taos, char* cTableName, SArray* colsSchema, SArray* rowsBind, size_t rowSize, SSmlLinesInfo* info) {
+ size_t numCols = taosArrayGetSize(colsSchema);
+ char* sql = malloc(tsMaxSQLStringLen+1);
+ if (sql == NULL) {
+ tscError("malloc sql memory error");
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
+ int32_t freeBytes = tsMaxSQLStringLen + 1 ;
+ sprintf(sql, "insert into ? (");
+
+ for (int i = 0; i < numCols; ++i) {
+ SSchema* colSchema = taosArrayGet(colsSchema, i);
+ snprintf(sql+strlen(sql), freeBytes-strlen(sql), "%s,", colSchema->name);
+ }
+ snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ") values (");
+
+ for (int i = 0; i < numCols; ++i) {
+ snprintf(sql+strlen(sql), freeBytes-strlen(sql), "?,");
+ }
+ snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ")");
+ sql[strlen(sql)] = '\0';
+
+ size_t rows = taosArrayGetSize(rowsBind);
+ size_t maxBatchSize = TSDB_MAX_WAL_SIZE/rowSize * 4 / 5;
+ size_t batchSize = MIN(maxBatchSize, rows);
+ tscDebug("SML:0x%"PRIx64" insert rows into child table %s. num of rows: %zu, batch size: %zu",
+ info->id, cTableName, rows, batchSize);
+ SArray* batchBind = taosArrayInit(batchSize, POINTER_BYTES);
+ int32_t code = TSDB_CODE_SUCCESS;
+ for (int i = 0; i < rows;) {
+ int j = i;
+ for (; j < i + batchSize && j i) {
+ tscDebug("SML:0x%"PRIx64" insert child table batch from line %d to line %d.", info->id, i, j - 1);
+ code = doInsertChildTableWithStmt(taos, sql, cTableName, batchBind, info);
+ if (code != 0) {
+ taosArrayDestroy(batchBind);
+ tfree(sql);
+ return code;
+ }
+ taosArrayClear(batchBind);
+ }
+ i = j;
+ }
+ taosArrayDestroy(batchBind);
+ tfree(sql);
return code;
}
@@ -787,15 +918,6 @@ static int32_t arrangePointsByChildTableName(TAOS_SML_DATA_POINT* points, int nu
SHashObj* cname2points, SArray* stableSchemas, SSmlLinesInfo* info) {
for (int32_t i = 0; i < numPoints; ++i) {
TAOS_SML_DATA_POINT * point = points + i;
- if (!point->childTableName) {
- char childTableName[TSDB_TABLE_NAME_LEN];
- int32_t tableNameLen = TSDB_TABLE_NAME_LEN;
- getSmlMd5ChildTableName(point, childTableName, &tableNameLen, info);
- point->childTableName = calloc(1, tableNameLen+1);
- strncpy(point->childTableName, childTableName, tableNameLen);
- point->childTableName[tableNameLen] = '\0';
- }
-
SSmlSTableSchema* stableSchema = taosArrayGet(stableSchemas, point->schemaIdx);
for (int j = 0; j < point->tagNum; ++j) {
@@ -843,15 +965,6 @@ static int32_t applyChildTableTags(TAOS* taos, char* cTableName, char* sTableNam
tagKVs[kv->fieldSchemaIdx] = kv;
}
}
-
- int32_t notNullTagsIndices[TSDB_MAX_TAGS] = {0};
- int32_t numNotNullTags = 0;
- for (int32_t i = 0; i < numTags; ++i) {
- if (tagKVs[i] != NULL) {
- notNullTagsIndices[numNotNullTags] = i;
- ++numNotNullTags;
- }
- }
SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
taosArraySetSize(tagBinds, numTags);
@@ -871,65 +984,8 @@ static int32_t applyChildTableTags(TAOS* taos, char* cTableName, char* sTableNam
bind->is_null = NULL;
}
- // select tag1,tag2,... from stable where tbname in (ctable)
- char* sql = malloc(tsMaxSQLStringLen+1);
- int freeBytes = tsMaxSQLStringLen + 1;
- snprintf(sql, freeBytes, "select tbname, ");
- for (int i = 0; i < numNotNullTags ; ++i) {
- snprintf(sql + strlen(sql), freeBytes-strlen(sql), "%s,", tagKVs[notNullTagsIndices[i]]->key);
- }
- snprintf(sql + strlen(sql) - 1, freeBytes - strlen(sql) + 1,
- " from %s where tbname in (\'%s\')", sTableName, cTableName);
- sql[strlen(sql)] = '\0';
-
- TAOS_RES* result = taos_query(taos, sql);
- free(sql);
-
- int32_t code = taos_errno(result);
- if (code != 0) {
- tscError("SML:0x%"PRIx64" get child table %s tags failed. error string %s", info->id, cTableName, taos_errstr(result));
- goto cleanup;
- }
-
- // check tag value and set tag values if different
- TAOS_ROW row = taos_fetch_row(result);
- if (row != NULL) {
- int numFields = taos_field_count(result);
- TAOS_FIELD* fields = taos_fetch_fields(result);
- int* lengths = taos_fetch_lengths(result);
- for (int i = 1; i < numFields; ++i) {
- uint8_t dbType = fields[i].type;
- int32_t length = lengths[i];
- char* val = row[i];
-
- TAOS_SML_KV* tagKV = tagKVs[notNullTagsIndices[i-1]];
- if (tagKV->type != dbType) {
- tscError("SML:0x%"PRIx64" child table %s tag %s type mismatch. point type : %d, db type : %d",
- info->id, cTableName, tagKV->key, tagKV->type, dbType);
- return TSDB_CODE_TSC_INVALID_VALUE;
- }
-
- assert(tagKV->value);
+ int32_t code = creatChildTableIfNotExists(taos, cTableName, sTableName, sTableSchema->tags, tagBinds, info);
- if (val == NULL || length != tagKV->length || memcmp(tagKV->value, val, length) != 0) {
- TAOS_BIND* bind = taosArrayGet(tagBinds, tagKV->fieldSchemaIdx);
- code = changeChildTableTagValue(taos, cTableName, tagKV->key, bind, info);
- if (code != 0) {
- tscError("SML:0x%"PRIx64" change child table tag failed. table name %s, tag %s", info->id, cTableName, tagKV->key);
- goto cleanup;
- }
- }
- }
- tscDebug("SML:0x%"PRIx64" successfully applied point tags. child table: %s", info->id, cTableName);
- } else {
- code = creatChildTableIfNotExists(taos, cTableName, sTableName, sTableSchema->tags, tagBinds, info);
- if (code != 0) {
- goto cleanup;
- }
- }
-
-cleanup:
- taos_free_result(result);
for (int i = 0; i < taosArrayGetSize(tagBinds); ++i) {
TAOS_BIND* bind = taosArrayGet(tagBinds, i);
free(bind->length);
@@ -939,7 +995,7 @@ cleanup:
}
static int32_t applyChildTableFields(TAOS* taos, SSmlSTableSchema* sTableSchema, char* cTableName,
- SArray* cTablePoints, SSmlLinesInfo* info) {
+ SArray* cTablePoints, size_t rowSize, SSmlLinesInfo* info) {
int32_t code = TSDB_CODE_SUCCESS;
size_t numCols = taosArrayGetSize(sTableSchema->fields);
@@ -973,7 +1029,7 @@ static int32_t applyChildTableFields(TAOS* taos, SSmlSTableSchema* sTableSchema,
taosArrayPush(rowsBind, &colBinds);
}
- code = insertChildTableBatch(taos, cTableName, sTableSchema->fields, rowsBind, info);
+ code = insertChildTableBatch(taos, cTableName, sTableSchema->fields, rowsBind, rowSize, info);
if (code != 0) {
tscError("SML:0x%"PRIx64" insert into child table %s failed. error %s", info->id, cTableName, tstrerror(code));
}
@@ -1000,7 +1056,6 @@ static int32_t applyDataPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t
while (pCTablePoints) {
SArray* cTablePoints = *pCTablePoints;
-
TAOS_SML_DATA_POINT* point = taosArrayGetP(cTablePoints, 0);
SSmlSTableSchema* sTableSchema = taosArrayGet(stableSchemas, point->schemaIdx);
@@ -1011,10 +1066,17 @@ static int32_t applyDataPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t
goto cleanup;
}
- tscDebug("SML:0x%"PRIx64" apply child table points. child table: %s", info->id, point->childTableName);
- code = applyChildTableFields(taos, sTableSchema, point->childTableName, cTablePoints, info);
+ size_t rowSize = 0;
+ size_t numCols = taosArrayGetSize(sTableSchema->fields);
+ for (int i = 0; i < numCols; ++i) {
+ SSchema* colSchema = taosArrayGet(sTableSchema->fields, i);
+ rowSize += colSchema->bytes;
+ }
+
+ tscDebug("SML:0x%"PRIx64" apply child table points. child table: %s, row size: %zu", info->id, point->childTableName, rowSize);
+ code = applyChildTableFields(taos, sTableSchema, point->childTableName, cTablePoints, rowSize, info);
if (code != 0) {
- tscError("Apply child table fields failed. child table %s, error %s", point->childTableName, tstrerror(code));
+ tscError("SML:0x%"PRIx64" Apply child table fields failed. child table %s, error %s", info->id, point->childTableName, tstrerror(code));
goto cleanup;
}
@@ -1034,7 +1096,7 @@ cleanup:
return code;
}
-int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint, SSmlLinesInfo* info) {
+int tscSmlInsert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint, SSmlLinesInfo* info) {
tscDebug("SML:0x%"PRIx64" taos_sml_insert. number of points: %d", info->id, numPoint);
int32_t code = TSDB_CODE_SUCCESS;
@@ -1070,6 +1132,14 @@ clean_up:
return code;
}
+int tsc_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
+ SSmlLinesInfo* info = calloc(1, sizeof(SSmlLinesInfo));
+ info->id = genLinesSmlId();
+ int code = tscSmlInsert(taos, points, numPoint, info);
+ free(info);
+ return code;
+}
+
//=========================================================================
/* Field Escape charaters
@@ -2076,18 +2146,6 @@ int32_t tscParseLine(const char* sql, TAOS_SML_DATA_POINT* smlData, SSmlLinesInf
//=========================================================================
-static uint64_t linesSmlHandleId = 0;
-
-uint64_t genLinesSmlId() {
- uint64_t id;
-
- do {
- id = atomic_add_fetch_64(&linesSmlHandleId, 1);
- } while (id == 0);
-
- return id;
-}
-
void destroySmlDataPoint(TAOS_SML_DATA_POINT* point) {
for (int i=0; itagNum; ++i) {
free((point->tags+i)->key);
@@ -2157,7 +2215,7 @@ int taos_insert_lines(TAOS* taos, char* lines[], int numLines) {
}
TAOS_SML_DATA_POINT* points = TARRAY_GET_START(lpPoints);
- code = taos_sml_insert(taos, points, (int)numPoints, info);
+ code = tscSmlInsert(taos, points, (int)numPoints, info);
if (code != 0) {
tscError("SML:0x%"PRIx64" taos_sml_insert error: %s", info->id, tstrerror((code)));
}
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 40664241c1858f75ca1ebc6c1ec1f9cfe56358a7..6fb5b3c8d1116674937bb5930b3082ced5cd4485 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -86,6 +86,10 @@ typedef struct STscStmt {
return _code; \
} while (0)
+#define STMT_CHECK if (pStmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) { \
+ STMT_RET(TSDB_CODE_TSC_DISCONNECTED); \
+ }
+
static int32_t invalidOperationMsg(char* dstBuffer, const char* errMsg) {
return tscInvalidOperationMsg(dstBuffer, errMsg, NULL);
}
@@ -155,6 +159,22 @@ static int normalStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
var->i64 = *(int64_t*)tb->buffer;
break;
+ case TSDB_DATA_TYPE_UTINYINT:
+ var->u64 = *(uint8_t*)tb->buffer;
+ break;
+
+ case TSDB_DATA_TYPE_USMALLINT:
+ var->u64 = *(uint16_t*)tb->buffer;
+ break;
+
+ case TSDB_DATA_TYPE_UINT:
+ var->u64 = *(uint32_t*)tb->buffer;
+ break;
+
+ case TSDB_DATA_TYPE_UBIGINT:
+ var->u64 = *(uint64_t*)tb->buffer;
+ break;
+
case TSDB_DATA_TYPE_FLOAT:
var->dKey = GET_FLOAT_VAL(tb->buffer);
break;
@@ -206,6 +226,8 @@ static int normalStmtPrepare(STscStmt* stmt) {
return code;
}
start = i + token.n;
+ } else if (token.type == TK_ILLEGAL) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(&stmt->pSql->cmd), "invalid sql");
}
i += token.n;
@@ -259,9 +281,17 @@ static char* normalStmtBuildSql(STscStmt* stmt) {
case TSDB_DATA_TYPE_SMALLINT:
case TSDB_DATA_TYPE_INT:
case TSDB_DATA_TYPE_BIGINT:
+ case TSDB_DATA_TYPE_TIMESTAMP:
taosStringBuilderAppendInteger(&sb, var->i64);
break;
+ case TSDB_DATA_TYPE_UTINYINT:
+ case TSDB_DATA_TYPE_USMALLINT:
+ case TSDB_DATA_TYPE_UINT:
+ case TSDB_DATA_TYPE_UBIGINT:
+ taosStringBuilderAppendUnsignedInteger(&sb, var->u64);
+ break;
+
case TSDB_DATA_TYPE_FLOAT:
case TSDB_DATA_TYPE_DOUBLE:
taosStringBuilderAppendDouble(&sb, var->dKey);
@@ -1492,6 +1522,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
pSql->isBind = true;
pStmt->pSql = pSql;
pStmt->last = STMT_INIT;
+ registerSqlObj(pSql);
return pStmt;
}
@@ -1499,9 +1530,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
STscStmt* pStmt = (STscStmt*)stmt;
- if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
if (sql == NULL) {
tscError("sql is NULL");
@@ -1527,8 +1556,9 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
pCmd->insertParam.insertType = TSDB_QUERY_TYPE_STMT_INSERT;
pCmd->insertParam.objectId = pSql->self;
- pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
-
+ char* sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
+ if(sqlstr == NULL && pSql->sqlstr) free(pSql->sqlstr);
+ pSql->sqlstr = sqlstr;
if (pSql->sqlstr == NULL) {
tscError("%p failed to malloc sql string buffer", pSql);
STMT_RET(TSDB_CODE_TSC_OUT_OF_MEMORY);
@@ -1546,8 +1576,6 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
pSql->cmd.insertParam.numOfParams = 0;
pSql->cmd.batchSize = 0;
- registerSqlObj(pSql);
-
int32_t ret = stmtParseInsertTbTags(pSql, pStmt);
if (ret != TSDB_CODE_SUCCESS) {
STMT_RET(ret);
@@ -1577,9 +1605,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
STscStmt* pStmt = (STscStmt*)stmt;
int32_t code = 0;
- if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
SSqlObj* pSql = pStmt->pSql;
SSqlCmd* pCmd = &pSql->cmd;
@@ -1739,6 +1765,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
STscStmt* pStmt = (STscStmt*)stmt;
+ STMT_CHECK
pStmt->mtb.subSet = true;
return taos_stmt_set_tbname_tags(stmt, name, NULL);
}
@@ -1747,6 +1774,7 @@ int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
STscStmt* pStmt = (STscStmt*)stmt;
+ STMT_CHECK
pStmt->mtb.subSet = false;
return taos_stmt_set_tbname_tags(stmt, name, NULL);
}
@@ -1754,6 +1782,9 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
int taos_stmt_close(TAOS_STMT* stmt) {
STscStmt* pStmt = (STscStmt*)stmt;
+ if (pStmt == NULL || pStmt->taos == NULL) {
+ STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
+ }
if (!pStmt->isInsert) {
SNormalStmt* normal = &pStmt->normal;
if (normal->params != NULL) {
@@ -1775,8 +1806,9 @@ int taos_stmt_close(TAOS_STMT* stmt) {
pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->mtb.pTableBlockHashList, rmMeta);
if (pStmt->pSql){
taosHashCleanup(pStmt->pSql->cmd.insertParam.pTableBlockHashList);
+ pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
}
- pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
+
taosArrayDestroy(pStmt->mtb.tags);
tfree(pStmt->mtb.sqlstr);
}
@@ -1789,9 +1821,7 @@ int taos_stmt_close(TAOS_STMT* stmt) {
int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
STscStmt* pStmt = (STscStmt*)stmt;
- if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
if (pStmt->isInsert) {
if (pStmt->multiTbInsert) {
@@ -1820,9 +1850,7 @@ int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
STscStmt* pStmt = (STscStmt*)stmt;
- if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX) {
tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1853,9 +1881,7 @@ int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int colIdx) {
STscStmt* pStmt = (STscStmt*)stmt;
- if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX || colIdx < 0) {
tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1888,9 +1914,7 @@ int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, in
int taos_stmt_add_batch(TAOS_STMT* stmt) {
STscStmt* pStmt = (STscStmt*)stmt;
- if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
if (pStmt->isInsert) {
if (pStmt->last != STMT_BIND && pStmt->last != STMT_BIND_COL) {
@@ -1917,9 +1941,7 @@ int taos_stmt_reset(TAOS_STMT* stmt) {
int taos_stmt_execute(TAOS_STMT* stmt) {
int ret = 0;
STscStmt* pStmt = (STscStmt*)stmt;
- if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
if (pStmt->isInsert) {
if (pStmt->last != STMT_ADD_BATCH) {
@@ -1940,11 +1962,7 @@ int taos_stmt_execute(TAOS_STMT* stmt) {
if (sql == NULL) {
ret = TSDB_CODE_TSC_OUT_OF_MEMORY;
} else {
- if (pStmt->pSql != NULL) {
- tscFreeSqlObj(pStmt->pSql);
- pStmt->pSql = NULL;
- }
-
+ taosReleaseRef(tscObjRef, pStmt->pSql->self);
pStmt->pSql = taos_query((TAOS*)pStmt->taos, sql);
ret = taos_errno(pStmt->pSql);
free(sql);
@@ -1965,7 +1983,6 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
tscError("result has been used already.");
return NULL;
}
-
TAOS_RES* result = pStmt->pSql;
pStmt->pSql = NULL;
return result;
@@ -1974,9 +1991,7 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
STscStmt* pStmt = (STscStmt*)stmt;
- if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
if (insert) *insert = pStmt->isInsert;
@@ -1986,9 +2001,7 @@ int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
STscStmt* pStmt = (STscStmt*)stmt;
- if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
if (pStmt->isInsert) {
SSqlObj* pSql = pStmt->pSql;
@@ -2005,9 +2018,7 @@ int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
STscStmt* pStmt = (STscStmt*)stmt;
- if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
- STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
- }
+ STMT_CHECK
if (pStmt->isInsert) {
SSqlCmd* pCmd = &pStmt->pSql->cmd;
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 6df724881e145a5698a73b228761dc68187465dd..4f36f0c193a5d12c7c7cb963398debcda8ead2ce 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -70,7 +70,6 @@ static int convertTimestampStrToInt64(tVariant *pVar, int32_t precision);
static bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType, uint8_t precision);
static bool has(SArray* pFieldList, int32_t startIdx, const char* name);
-static char* cloneCurrentDBName(SSqlObj* pSql);
static int32_t getDelimiterIndex(SStrToken* pTableName);
static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd);
static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pCmd);
@@ -116,7 +115,7 @@ static int32_t validateColumnName(char* name);
static int32_t setKillInfo(SSqlObj* pSql, struct SSqlInfo* pInfo, int32_t killType);
static int32_t setCompactVnodeInfo(SSqlObj* pSql, struct SSqlInfo* pInfo);
-static bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField);
+static int32_t validateOneTag(SSqlCmd* pCmd, TAOS_FIELD* pTagField);
static bool hasTimestampForPointInterpQuery(SQueryInfo* pQueryInfo);
static bool hasNormalColumnFilter(SQueryInfo* pQueryInfo);
@@ -422,7 +421,6 @@ int32_t readFromFile(char *name, uint32_t *len, void **buf) {
return TSDB_CODE_TSC_APP_ERROR;
}
close(fd);
- tfree(*buf);
return TSDB_CODE_SUCCESS;
}
@@ -888,6 +886,7 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
}
case TSDB_SQL_SELECT: {
+ const char * msg1 = "no nested query supported in union clause";
code = loadAllTableMeta(pSql, pInfo);
if (code != TSDB_CODE_SUCCESS) {
return code;
@@ -901,6 +900,10 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
tscTrace("0x%"PRIx64" start to parse the %dth subclause, total:%"PRIzu, pSql->self, i, size);
+ if (size > 1 && pSqlNode->from && pSqlNode->from->type == SQL_NODE_FROM_SUBQUERY) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+ }
+
// normalizeSqlNode(pSqlNode); // normalize the column name in each function
if ((code = validateSqlNode(pSql, pSqlNode, pQueryInfo)) != TSDB_CODE_SUCCESS) {
return code;
@@ -921,7 +924,6 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
pQueryInfo = pCmd->active;
pQueryInfo->pUdfInfo = pUdfInfo;
pQueryInfo->udfCopy = true;
-
}
}
@@ -1075,12 +1077,13 @@ int32_t validateIntervalNode(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pS
const char* msg1 = "sliding cannot be used without interval";
const char* msg2 = "interval cannot be less than 1 us";
const char* msg3 = "interval value is too small";
+ const char* msg4 = "only point interpolation query requires keyword EVERY";
SSqlCmd* pCmd = &pSql->cmd;
STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
-
+
if (!TPARSER_HAS_TOKEN(pSqlNode->interval.interval)) {
if (TPARSER_HAS_TOKEN(pSqlNode->sliding)) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
@@ -1106,7 +1109,6 @@ int32_t validateIntervalNode(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pS
}
if (pQueryInfo->interval.intervalUnit != 'n' && pQueryInfo->interval.intervalUnit != 'y') {
-
// interval cannot be less than 10 milliseconds
if (convertTimePrecision(pQueryInfo->interval.interval, tinfo.precision, TSDB_TIME_PRECISION_MICRO) < tsMinIntervalTime) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
@@ -1121,6 +1123,11 @@ int32_t validateIntervalNode(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pS
return TSDB_CODE_TSC_INVALID_OPERATION;
}
+ bool interpQuery = tscIsPointInterpQuery(pQueryInfo);
+ if ((pSqlNode->interval.token == TK_EVERY && (!interpQuery)) || (pSqlNode->interval.token == TK_INTERVAL && interpQuery)) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
+ }
+
// The following part is used to check for the invalid query expression.
return checkInvalidExprForTimeWindow(pCmd, pQueryInfo);
}
@@ -1530,9 +1537,7 @@ static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pC
/*
* tags name /column name is truncated in sql.y
*/
-bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
- //const char* msg1 = "timestamp not allowed in tags";
- const char* msg2 = "duplicated column names";
+int32_t validateOneTag(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
const char* msg3 = "tag length too long";
const char* msg4 = "invalid tag name";
const char* msg5 = "invalid binary/nchar tag length";
@@ -1547,8 +1552,7 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
// no more max columns
if (numOfTags + numOfCols >= TSDB_MAX_COLUMNS) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
}
// no more than 6 tags
@@ -1556,8 +1560,7 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
char msg[128] = {0};
sprintf(msg, "tags no more than %d", TSDB_MAX_TAGS);
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
}
// no timestamp allowable
@@ -1567,8 +1570,7 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
//}
if ((pTagField->type < TSDB_DATA_TYPE_BOOL) || (pTagField->type > TSDB_DATA_TYPE_UBIGINT)) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
}
SSchema* pTagSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
@@ -1580,20 +1582,17 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
// length less than TSDB_MAX_TASG_LEN
if (nLen + pTagField->bytes > TSDB_MAX_TAGS_LEN) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
}
// tags name can not be a keyword
if (validateColumnName(pTagField->name) != TSDB_CODE_SUCCESS) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
}
// binary(val), val can not be equalled to or less than 0
if ((pTagField->type == TSDB_DATA_TYPE_BINARY || pTagField->type == TSDB_DATA_TYPE_NCHAR) && pTagField->bytes <= 0) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
}
// field name must be unique
@@ -1601,17 +1600,15 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
for (int32_t i = 0; i < numOfTags + numOfCols; ++i) {
if (strncasecmp(pTagField->name, pSchema[i].name, sizeof(pTagField->name) - 1) == 0) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "duplicated column names");
}
}
- return true;
+ return TSDB_CODE_SUCCESS;
}
-bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
+int32_t validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
const char* msg1 = "too many columns";
- const char* msg2 = "duplicated column names";
const char* msg3 = "column length too long";
const char* msg4 = "invalid data type";
const char* msg5 = "invalid column name";
@@ -1626,18 +1623,15 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
// no more max columns
if (numOfCols >= TSDB_MAX_COLUMNS || numOfTags + numOfCols >= TSDB_MAX_COLUMNS) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
}
if (pColField->type < TSDB_DATA_TYPE_BOOL || pColField->type > TSDB_DATA_TYPE_UBIGINT) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
}
if (validateColumnName(pColField->name) != TSDB_CODE_SUCCESS) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
}
SSchema* pSchema = tscGetTableSchema(pTableMeta);
@@ -1648,25 +1642,23 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
}
if (pColField->bytes <= 0) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
}
// length less than TSDB_MAX_BYTES_PER_ROW
if (nLen + pColField->bytes > TSDB_MAX_BYTES_PER_ROW) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
- return false;
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
}
// field name must be unique
for (int32_t i = 0; i < numOfTags + numOfCols; ++i) {
if (strncasecmp(pColField->name, pSchema[i].name, sizeof(pColField->name) - 1) == 0) {
- invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
- return false;
+ //return tscErrorMsgWithCode(TSDB_CODE_TSC_DUP_COL_NAMES, tscGetErrorMsgPayload(pCmd), pColField->name, NULL);
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "duplicated column names");
}
}
- return true;
+ return TSDB_CODE_SUCCESS;
}
/* is contained in pFieldList or not */
@@ -1682,14 +1674,6 @@ static bool has(SArray* pFieldList, int32_t startIdx, const char* name) {
static char* getAccountId(SSqlObj* pSql) { return pSql->pTscObj->acctId; }
-static char* cloneCurrentDBName(SSqlObj* pSql) {
- pthread_mutex_lock(&pSql->pTscObj->mutex);
- char *p = strdup(pSql->pTscObj->db);
- pthread_mutex_unlock(&pSql->pTscObj->mutex);
-
- return p;
-}
-
/* length limitation, strstr cannot be applied */
static int32_t getDelimiterIndex(SStrToken* pTableName) {
for (uint32_t i = 0; i < pTableName->n; ++i) {
@@ -1940,20 +1924,6 @@ static void addPrimaryTsColIntoResult(SQueryInfo* pQueryInfo, SSqlCmd* pCmd) {
pQueryInfo->type |= TSDB_QUERY_TYPE_PROJECTION_QUERY;
}
-bool isValidDistinctSql(SQueryInfo* pQueryInfo) {
- if (pQueryInfo == NULL) {
- return false;
- }
- if ((pQueryInfo->type & TSDB_QUERY_TYPE_STABLE_QUERY) != TSDB_QUERY_TYPE_STABLE_QUERY
- && (pQueryInfo->type & TSDB_QUERY_TYPE_TABLE_QUERY) != TSDB_QUERY_TYPE_TABLE_QUERY) {
- return false;
- }
- if (tscNumOfExprs(pQueryInfo) == 1){
- return true;
- }
- return false;
-}
-
static bool hasNoneUserDefineExpr(SQueryInfo* pQueryInfo) {
size_t numOfExprs = taosArrayGetSize(pQueryInfo->exprList);
for (int32_t i = 0; i < numOfExprs; ++i) {
@@ -2043,8 +2013,11 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
const char* msg1 = "too many items in selection clause";
const char* msg2 = "functions or others can not be mixed up";
const char* msg3 = "not support query expression";
- const char* msg4 = "only support distinct one column or tag";
+ const char* msg4 = "not support distinct mixed with proj/agg func";
const char* msg5 = "invalid function name";
+ const char* msg6 = "not support distinct mixed with join";
+ const char* msg7 = "not support distinct mixed with groupby";
+ const char* msg8 = "not support distinct in nest query";
// too many result columns not support order by in query
if (taosArrayGetSize(pSelNodeList) > TSDB_MAX_COLUMNS) {
@@ -2055,19 +2028,31 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
pQueryInfo->colList = taosArrayInit(4, POINTER_BYTES);
}
+
bool hasDistinct = false;
+ bool hasAgg = false;
size_t numOfExpr = taosArrayGetSize(pSelNodeList);
+ int32_t distIdx = -1;
for (int32_t i = 0; i < numOfExpr; ++i) {
int32_t outputIndex = (int32_t)tscNumOfExprs(pQueryInfo);
tSqlExprItem* pItem = taosArrayGet(pSelNodeList, i);
if (hasDistinct == false) {
hasDistinct = (pItem->distinct == true);
+ distIdx = hasDistinct ? i : -1;
}
int32_t type = pItem->pNode->type;
if (type == SQL_NODE_SQLFUNCTION) {
+ hasAgg = true;
+ if (hasDistinct) break;
+
pItem->pNode->functionId = isValidFunction(pItem->pNode->Expr.operand.z, pItem->pNode->Expr.operand.n);
+
+ if (pItem->pNode->functionId == TSDB_FUNC_BLKINFO && taosArrayGetSize(pQueryInfo->pUpstream) > 0) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
+ }
+
SUdfInfo* pUdfInfo = NULL;
if (pItem->pNode->functionId < 0) {
pUdfInfo = isValidUdf(pQueryInfo->pUdfInfo, pItem->pNode->Expr.operand.z, pItem->pNode->Expr.operand.n);
@@ -2102,10 +2087,22 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
}
}
+ //TODO(dengyihao), refactor as function
+ //handle distinct func mixed with other func
if (hasDistinct == true) {
- if (!isValidDistinctSql(pQueryInfo) ) {
+ if (distIdx != 0 || hasAgg) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
+ }
+ if (joinQuery) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
}
+ if (pQueryInfo->groupbyExpr.numOfGroupCols != 0) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
+ }
+ if (pQueryInfo->pDownstream != NULL) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg8);
+ }
+
pQueryInfo->distinct = true;
}
@@ -2451,6 +2448,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
const char* msg10 = "derivative duration should be greater than 1 Second";
const char* msg11 = "third parameter in derivative should be 0 or 1";
const char* msg12 = "parameter is out of range [1, 100]";
+ const char* msg13 = "parameter list required";
switch (functionId) {
case TSDB_FUNC_COUNT: {
@@ -2590,13 +2588,13 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
// set the first column ts for diff query
if (functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_DERIVATIVE) {
- colIndex += 1;
SColumnIndex indexTS = {.tableIndex = index.tableIndex, .columnIndex = 0};
SExprInfo* pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &indexTS, TSDB_DATA_TYPE_TIMESTAMP,
TSDB_KEYSIZE, getNewResColId(pCmd), TSDB_KEYSIZE, false);
+ tstrncpy(pExpr->base.aliasName, aAggs[TSDB_FUNC_TS_DUMMY].name, sizeof(pExpr->base.aliasName));
SColumnList ids = createColumnList(1, 0, 0);
- insertResultField(pQueryInfo, 0, &ids, TSDB_KEYSIZE, TSDB_DATA_TYPE_TIMESTAMP, aAggs[TSDB_FUNC_TS_DUMMY].name, pExpr);
+ insertResultField(pQueryInfo, colIndex, &ids, TSDB_KEYSIZE, TSDB_DATA_TYPE_TIMESTAMP, aAggs[TSDB_FUNC_TS_DUMMY].name, pExpr);
}
SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pCmd), intermediateResSize, false);
@@ -2630,7 +2628,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
tickPerSec /= TSDB_TICK_PER_SECOND(TSDB_TIME_PRECISION_MICRO);
} else if (info.precision == TSDB_TIME_PRECISION_MICRO) {
tickPerSec /= TSDB_TICK_PER_SECOND(TSDB_TIME_PRECISION_MILLI);
- }
+ }
if (tickPerSec <= 0 || tickPerSec < TSDB_TICK_PER_SECOND(info.precision)) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg10);
@@ -2664,8 +2662,8 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
assert(ids.num == 1);
tscColumnListInsert(pQueryInfo->colList, ids.ids[0].columnIndex, pExpr->base.uid, pSchema);
}
-
tscInsertPrimaryTsSourceColumn(pQueryInfo, pExpr->base.uid);
+
return TSDB_CODE_SUCCESS;
}
@@ -2869,7 +2867,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
const int32_t TS_COLUMN_INDEX = PRIMARYKEY_TIMESTAMP_COL_INDEX;
SColumnList ids = createColumnList(1, index.tableIndex, TS_COLUMN_INDEX);
- insertResultField(pQueryInfo, TS_COLUMN_INDEX, &ids, TSDB_KEYSIZE, TSDB_DATA_TYPE_TIMESTAMP,
+ insertResultField(pQueryInfo, colIndex, &ids, TSDB_KEYSIZE, TSDB_DATA_TYPE_TIMESTAMP,
aAggs[TSDB_FUNC_TS].name, pExpr);
colIndex += 1; // the first column is ts
@@ -3002,6 +3000,10 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
}
+ if (taosArrayGetSize(pItem->pNode->Expr.paramList) <= 0) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg13);
+ }
+
tSqlExprItem* pParamElem = taosArrayGet(pItem->pNode->Expr.paramList, 0);;
if (pParamElem->pNode->tokenId != TK_ID) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
@@ -3047,7 +3049,6 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
tscColumnListInsert(pQueryInfo->colList, index.columnIndex, uid, &s);
}
}
-
tscInsertPrimaryTsSourceColumn(pQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
return TSDB_CODE_SUCCESS;
}
@@ -3218,7 +3219,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
pCmd->command = TSDB_SQL_SHOW;
const char* msg1 = "invalid name";
- const char* msg2 = "pattern filter string too long";
+ const char* msg2 = "wildcard string should be less than %d characters";
const char* msg3 = "database name too long";
const char* msg4 = "invalid ip address";
const char* msg5 = "database name is empty";
@@ -3262,8 +3263,10 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
}
- if (!tscValidateTableNameLength(pCmd->payloadLen)) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ if (pPattern->n > tsMaxWildCardsLen){
+ char tmp[64] = {0};
+ sprintf(tmp, msg2, tsMaxWildCardsLen);
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), tmp);
}
}
} else if (showType == TSDB_MGMT_TABLE_VNODES) {
@@ -3474,6 +3477,27 @@ static bool groupbyTagsOrNull(SQueryInfo* pQueryInfo) {
return true;
}
+bool groupbyTbname(SQueryInfo* pQueryInfo) {
+ if (pQueryInfo->groupbyExpr.columnInfo == NULL ||
+ taosArrayGetSize(pQueryInfo->groupbyExpr.columnInfo) == 0) {
+ return false;
+ }
+
+ size_t s = taosArrayGetSize(pQueryInfo->groupbyExpr.columnInfo);
+ for (int32_t i = 0; i < s; i++) {
+ SColIndex* colIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, i);
+ if (colIndex->colIndex == TSDB_TBNAME_COLUMN_INDEX) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+
+
+
+
static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool twQuery) {
int32_t startIdx = 0;
int32_t aggUdf = 0;
@@ -4394,15 +4418,17 @@ static int32_t validateNullExpr(tSqlExpr* pExpr, char* msgBuf) {
// check for like expression
static int32_t validateLikeExpr(tSqlExpr* pExpr, STableMeta* pTableMeta, int32_t index, char* msgBuf) {
- const char* msg1 = "wildcard string should be less than 20 characters";
+ const char* msg1 = "wildcard string should be less than %d characters";
const char* msg2 = "illegal column name";
tSqlExpr* pLeft = pExpr->pLeft;
tSqlExpr* pRight = pExpr->pRight;
if (pExpr->tokenId == TK_LIKE) {
- if (pRight->value.nLen > TSDB_PATTERN_STRING_MAX_LEN) {
- return invalidOperationMsg(msgBuf, msg1);
+ if (pRight->value.nLen > tsMaxWildCardsLen) {
+ char tmp[64] = {0};
+ sprintf(tmp, msg1, tsMaxWildCardsLen);
+ return invalidOperationMsg(msgBuf, tmp);
}
SSchema* pSchema = tscGetTableSchema(pTableMeta);
@@ -4508,7 +4534,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
*/
tSqlExprDestroy(*pExpr);
} else {
- ret = setExprToCond(&pCondExpr->pTimewindow, *pExpr, msg3, parentOptr, pQueryInfo->msg);
+ ret = setExprToCond(&pCondExpr->pTimewindow, *pExpr, msg3, parentOptr, pCmd->payload);
}
*pExpr = NULL; // remove this expression
@@ -4546,7 +4572,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
}
pQueryInfo->type |= TSDB_QUERY_TYPE_JOIN_QUERY;
- ret = setExprToCond(&pCondExpr->pJoinExpr, *pExpr, NULL, parentOptr, pQueryInfo->msg);
+ ret = setExprToCond(&pCondExpr->pJoinExpr, *pExpr, NULL, parentOptr, pCmd->payload);
*pExpr = NULL;
} else {
// do nothing
@@ -4564,7 +4590,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
}
- ret = setExprToCond(&pCondExpr->pColumnCond, *pExpr, NULL, parentOptr, pQueryInfo->msg);
+ ret = setExprToCond(&pCondExpr->pColumnCond, *pExpr, NULL, parentOptr, pCmd->payload);
*pExpr = NULL; // remove it from expr tree
}
@@ -4868,10 +4894,6 @@ static void cleanQueryExpr(SCondExpr* pCondExpr) {
tSqlExprDestroy(pCondExpr->pTableCond);
}
- if (pCondExpr->pTagCond) {
- tSqlExprDestroy(pCondExpr->pTagCond);
- }
-
if (pCondExpr->pColumnCond) {
tSqlExprDestroy(pCondExpr->pColumnCond);
}
@@ -5366,6 +5388,7 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
const char* msg3 = "top/bottom not support fill";
const char* msg4 = "illegal value or data overflow";
const char* msg5 = "fill only available for interval query";
+ const char* msg6 = "not supported function now";
if ((!isTimeWindowQuery(pQueryInfo)) && (!tscIsPointInterpQuery(pQueryInfo))) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
@@ -5404,6 +5427,9 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
}
} else if (strncasecmp(pItem->pVar.pz, "prev", 4) == 0 && pItem->pVar.nLen == 4) {
pQueryInfo->fillType = TSDB_FILL_PREV;
+ if (tscIsPointInterpQuery(pQueryInfo) && pQueryInfo->order.order == TSDB_ORDER_DESC) {
+ return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
+ }
} else if (strncasecmp(pItem->pVar.pz, "next", 4) == 0 && pItem->pVar.nLen == 4) {
pQueryInfo->fillType = TSDB_FILL_NEXT;
} else if (strncasecmp(pItem->pVar.pz, "linear", 6) == 0 && pItem->pVar.nLen == 6) {
@@ -5482,14 +5508,19 @@ static void setDefaultOrderInfo(SQueryInfo* pQueryInfo) {
pQueryInfo->order.order = TSDB_ORDER_ASC;
if (isTopBottomQuery(pQueryInfo)) {
pQueryInfo->order.orderColId = PRIMARYKEY_TIMESTAMP_COL_INDEX;
- } else { // in case of select tbname from super_table, the defualt order column can not be the primary ts column
- pQueryInfo->order.orderColId = INT32_MIN;
+ } else { // in case of select tbname from super_table, the default order column can not be the primary ts column
+ pQueryInfo->order.orderColId = INT32_MIN; // todo define a macro
}
/* for super table query, set default ascending order for group output */
if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
pQueryInfo->groupbyExpr.orderType = TSDB_ORDER_ASC;
}
+
+ if (pQueryInfo->distinct) {
+ pQueryInfo->order.order = TSDB_ORDER_ASC;
+ pQueryInfo->order.orderColId = PRIMARYKEY_TIMESTAMP_COL_INDEX;
+ }
}
int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode, SSchema* pSchema) {
@@ -5497,21 +5528,17 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
const char* msg1 = "invalid column name";
const char* msg2 = "order by primary timestamp, first tag or groupby column in groupby clause allowed";
const char* msg3 = "invalid column in order by clause, only primary timestamp or first tag in groupby clause allowed";
+ const char* msg4 = "orderby column must projected in subquery";
setDefaultOrderInfo(pQueryInfo);
STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-
- if (pQueryInfo->distinct == true) {
- pQueryInfo->order.order = TSDB_ORDER_ASC;
- pQueryInfo->order.orderColId = 0;
- return TSDB_CODE_SUCCESS;
- }
- if (pSqlNode->pSortOrder == NULL) {
+ if (pQueryInfo->distinct || pSqlNode->pSortOrder == NULL) {
return TSDB_CODE_SUCCESS;
}
- SArray* pSortorder = pSqlNode->pSortOrder;
+ char* pMsgBuf = tscGetErrorMsgPayload(pCmd);
+ SArray* pSortOrder = pSqlNode->pSortOrder;
/*
* for table query, there is only one or none order option is allowed, which is the
@@ -5519,19 +5546,19 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
*
* for super table query, the order option must be less than 3.
*/
- size_t size = taosArrayGetSize(pSortorder);
- if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
+ size_t size = taosArrayGetSize(pSortOrder);
+ if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo) || UTIL_TABLE_IS_TMP_TABLE(pTableMetaInfo)) {
if (size > 1) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
+ return invalidOperationMsg(pMsgBuf, msg0);
}
} else {
if (size > 2) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
+ return invalidOperationMsg(pMsgBuf, msg3);
}
}
// handle the first part of order by
- tVariant* pVar = taosArrayGet(pSortorder, 0);
+ tVariant* pVar = taosArrayGet(pSortOrder, 0);
// e.g., order by 1 asc, return directly with out further check.
if (pVar->nType >= TSDB_DATA_TYPE_TINYINT && pVar->nType <= TSDB_DATA_TYPE_BIGINT) {
@@ -5543,7 +5570,7 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) { // super table query
if (getColumnIndexByName(&columnName, pQueryInfo, &index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+ return invalidOperationMsg(pMsgBuf, msg1);
}
bool orderByTags = false;
@@ -5555,7 +5582,7 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
// it is a tag column
if (pQueryInfo->groupbyExpr.columnInfo == NULL) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ return invalidOperationMsg(pMsgBuf, msg2);
}
SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, 0);
if (relTagIndex == pColIndex->colIndex) {
@@ -5576,13 +5603,14 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
orderByGroupbyCol = true;
}
}
+
if (!(orderByTags || orderByTS || orderByGroupbyCol) && !isTopBottomQuery(pQueryInfo)) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
+ return invalidOperationMsg(pMsgBuf, msg3);
} else { // order by top/bottom result value column is not supported in case of interval query.
assert(!(orderByTags && orderByTS && orderByGroupbyCol));
}
- size_t s = taosArrayGetSize(pSortorder);
+ size_t s = taosArrayGetSize(pSortOrder);
if (s == 1) {
if (orderByTags) {
pQueryInfo->groupbyExpr.orderIndex = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
@@ -5595,13 +5623,15 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
pQueryInfo->groupbyExpr.orderType = p1->sortOrder;
pQueryInfo->order.orderColId = pSchema[index.columnIndex].colId;
} else if (isTopBottomQuery(pQueryInfo)) {
+ int32_t topBotIndex = tscGetTopBotQueryExprIndex(pQueryInfo);
+ assert(topBotIndex >= 1);
/* order of top/bottom query in interval is not valid */
- SExprInfo* pExpr = tscExprGet(pQueryInfo, 0);
+ SExprInfo* pExpr = tscExprGet(pQueryInfo, topBotIndex-1);
assert(pExpr->base.functionId == TSDB_FUNC_TS);
- pExpr = tscExprGet(pQueryInfo, 1);
+ pExpr = tscExprGet(pQueryInfo, topBotIndex);
if (pExpr->base.colInfo.colIndex != index.columnIndex && index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ return invalidOperationMsg(pMsgBuf, msg2);
}
tVariantListItem* p1 = taosArrayGet(pSqlNode->pSortOrder, 0);
@@ -5616,12 +5646,21 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
// orderby ts query on super table
if (tscOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
+ bool found = false;
+ for (int32_t i = 0; i < tscNumOfExprs(pQueryInfo); ++i) {
+ SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+ if (pExpr->base.functionId == TSDB_FUNC_PRJ && pExpr->base.colInfo.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+ found = true;
+ break;
+ }
+ }
+ if (!found && pQueryInfo->pDownstream) {
+ return invalidOperationMsg(pMsgBuf, msg4);
+ }
addPrimaryTsColIntoResult(pQueryInfo, pCmd);
}
}
- }
-
- if (s == 2) {
+ } else {
tVariantListItem *pItem = taosArrayGet(pSqlNode->pSortOrder, 0);
if (orderByTags) {
pQueryInfo->groupbyExpr.orderIndex = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
@@ -5638,22 +5677,23 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
tVariant* pVar2 = &pItem->pVar;
SStrToken cname = {pVar2->nLen, pVar2->nType, pVar2->pz};
if (getColumnIndexByName(&cname, pQueryInfo, &index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+ return invalidOperationMsg(pMsgBuf, msg1);
}
if (index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ return invalidOperationMsg(pMsgBuf, msg2);
} else {
- tVariantListItem* p1 = taosArrayGet(pSortorder, 1);
+ tVariantListItem* p1 = taosArrayGet(pSortOrder, 1);
pQueryInfo->order.order = p1->sortOrder;
pQueryInfo->order.orderColId = PRIMARYKEY_TIMESTAMP_COL_INDEX;
}
}
- } else { // meter query
- if (getColumnIndexByName(&columnName, pQueryInfo, &index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+ } else if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo) || UTIL_TABLE_IS_CHILD_TABLE(pTableMetaInfo)) { // check order by clause for normal table & temp table
+ if (getColumnIndexByName(&columnName, pQueryInfo, &index, pMsgBuf) != TSDB_CODE_SUCCESS) {
+ return invalidOperationMsg(pMsgBuf, msg1);
}
+
if (index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX && !isTopBottomQuery(pQueryInfo)) {
bool validOrder = false;
SArray *columnInfo = pQueryInfo->groupbyExpr.columnInfo;
@@ -5661,13 +5701,14 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
SColIndex* pColIndex = taosArrayGet(columnInfo, 0);
validOrder = (pColIndex->colIndex == index.columnIndex);
}
+
if (!validOrder) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ return invalidOperationMsg(pMsgBuf, msg2);
}
+
tVariantListItem* p1 = taosArrayGet(pSqlNode->pSortOrder, 0);
pQueryInfo->groupbyExpr.orderIndex = pSchema[index.columnIndex].colId;
pQueryInfo->groupbyExpr.orderType = p1->sortOrder;
-
}
if (isTopBottomQuery(pQueryInfo)) {
@@ -5677,19 +5718,22 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
SColIndex* pColIndex = taosArrayGet(columnInfo, 0);
validOrder = (pColIndex->colIndex == index.columnIndex);
} else {
+ int32_t topBotIndex = tscGetTopBotQueryExprIndex(pQueryInfo);
+ assert(topBotIndex >= 1);
/* order of top/bottom query in interval is not valid */
- SExprInfo* pExpr = tscExprGet(pQueryInfo, 0);
+ SExprInfo* pExpr = tscExprGet(pQueryInfo, topBotIndex-1);
assert(pExpr->base.functionId == TSDB_FUNC_TS);
- pExpr = tscExprGet(pQueryInfo, 1);
+ pExpr = tscExprGet(pQueryInfo, topBotIndex);
if (pExpr->base.colInfo.colIndex != index.columnIndex && index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ return invalidOperationMsg(pMsgBuf, msg2);
}
+
validOrder = true;
}
if (!validOrder) {
- return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ return invalidOperationMsg(pMsgBuf, msg2);
}
tVariantListItem* pItem = taosArrayGet(pSqlNode->pSortOrder, 0);
@@ -5699,6 +5743,18 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
return TSDB_CODE_SUCCESS;
}
+ tVariantListItem* pItem = taosArrayGet(pSqlNode->pSortOrder, 0);
+ pQueryInfo->order.order = pItem->sortOrder;
+ pQueryInfo->order.orderColId = pSchema[index.columnIndex].colId;
+ } else {
+ // handle the temp table order by clause. You can order by any single column in case of the temp table, created by
+ // inner subquery.
+ assert(UTIL_TABLE_IS_TMP_TABLE(pTableMetaInfo) && taosArrayGetSize(pSqlNode->pSortOrder) == 1);
+
+ if (getColumnIndexByName(&columnName, pQueryInfo, &index, pMsgBuf) != TSDB_CODE_SUCCESS) {
+ return invalidOperationMsg(pMsgBuf, msg1);
+ }
+
tVariantListItem* pItem = taosArrayGet(pSqlNode->pSortOrder, 0);
pQueryInfo->order.order = pItem->sortOrder;
pQueryInfo->order.orderColId = pSchema[index.columnIndex].colId;
@@ -5733,7 +5789,6 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
const char* msg19 = "invalid new tag name";
const char* msg20 = "table is not super table";
const char* msg21 = "only binary/nchar column length could be modified";
- const char* msg22 = "new column length should be bigger than old one";
const char* msg23 = "only column length coulbe be modified";
const char* msg24 = "invalid binary/nchar column length";
@@ -5785,8 +5840,9 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
}
TAOS_FIELD* p = taosArrayGet(pFieldList, 0);
- if (!validateOneTags(pCmd, p)) {
- return TSDB_CODE_TSC_INVALID_OPERATION;
+ int32_t ret = validateOneTag(pCmd, p);
+ if (ret != TSDB_CODE_SUCCESS) {
+ return ret;
}
tscFieldInfoAppend(&pQueryInfo->fieldsInfo, p);
@@ -5888,6 +5944,10 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
tVariantListItem* pItem = taosArrayGet(pVarList, 1);
SSchema* pTagsSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex.columnIndex);
+
+ if (IS_VAR_DATA_TYPE(pTagsSchema->type) && (pItem->pVar.nLen > pTagsSchema->bytes * TSDB_NCHAR_SIZE)) {
+ return invalidOperationMsg(pMsg, msg14);
+ }
pAlterSQL->tagData.data = calloc(1, pTagsSchema->bytes * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE);
if (tVariantDump(&pItem->pVar, pAlterSQL->tagData.data, pTagsSchema->type, true) != TSDB_CODE_SUCCESS) {
@@ -5958,8 +6018,9 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
}
TAOS_FIELD* p = taosArrayGet(pFieldList, 0);
- if (!validateOneColumn(pCmd, p)) {
- return TSDB_CODE_TSC_INVALID_OPERATION;
+ int32_t ret = validateOneColumn(pCmd, p);
+ if (ret != TSDB_CODE_SUCCESS) {
+ return ret;
}
tscFieldInfoAppend(&pQueryInfo->fieldsInfo, p);
@@ -6022,7 +6083,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
}
if (pItem->bytes <= pColSchema->bytes) {
- return invalidOperationMsg(pMsg, msg22);
+ return tscErrorMsgWithCode(TSDB_CODE_TSC_INVALID_COLUMN_LENGTH, pMsg, pItem->name, NULL);
}
SSchema* pSchema = (SSchema*) pTableMetaInfo->pTableMeta->schema;
@@ -6073,7 +6134,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
}
if (pItem->bytes <= pColSchema->bytes) {
- return invalidOperationMsg(pMsg, msg22);
+ return tscErrorMsgWithCode(TSDB_CODE_TSC_INVALID_TAG_LENGTH, pMsg, pItem->name, NULL);
}
SSchema* pSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
@@ -6863,7 +6924,6 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
const char* msg1 = "interval not allowed in group by normal column";
STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-
SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
SSchema* tagSchema = NULL;
@@ -6889,9 +6949,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
s = &pSchema[colIndex];
}
}
-
- size_t size = tscNumOfExprs(pQueryInfo);
-
+
if (TSDB_COL_IS_TAG(pColIndex->flag)) {
int32_t f = TSDB_FUNC_TAG;
@@ -6899,8 +6957,10 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
f = TSDB_FUNC_TAGPRJ;
}
+ int32_t pos = tscGetFirstInvisibleFieldPos(pQueryInfo);
+
SColumnIndex index = {.tableIndex = pQueryInfo->groupbyExpr.tableIndex, .columnIndex = colIndex};
- SExprInfo* pExpr = tscExprAppend(pQueryInfo, f, &index, s->type, s->bytes, getNewResColId(pCmd), s->bytes, true);
+ SExprInfo* pExpr = tscExprInsert(pQueryInfo, pos, f, &index, s->type, s->bytes, getNewResColId(pCmd), s->bytes, true);
memset(pExpr->base.aliasName, 0, sizeof(pExpr->base.aliasName));
tstrncpy(pExpr->base.aliasName, s->name, sizeof(pExpr->base.aliasName));
@@ -6910,13 +6970,15 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
// NOTE: tag column does not add to source column list
SColumnList ids = createColumnList(1, 0, pColIndex->colIndex);
- insertResultField(pQueryInfo, (int32_t)size, &ids, s->bytes, (int8_t)s->type, s->name, pExpr);
+ insertResultField(pQueryInfo, pos, &ids, s->bytes, (int8_t)s->type, s->name, pExpr);
} else {
// if this query is "group by" normal column, time window query is not allowed
if (isTimeWindowQuery(pQueryInfo)) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
}
+ size_t size = tscNumOfExprs(pQueryInfo);
+
bool hasGroupColumn = false;
for (int32_t j = 0; j < size; ++j) {
SExprInfo* pExpr = tscExprGet(pQueryInfo, j);
@@ -7064,6 +7126,35 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, char*
}
}
+
+int32_t validateFunctionFromUpstream(SQueryInfo* pQueryInfo, char* msg) {
+ const char* msg1 = "TWA/Diff/Derivative/Irate are not allowed to apply to super table without group by tbname";
+
+ int32_t numOfExprs = (int32_t)tscNumOfExprs(pQueryInfo);
+ size_t upNum = taosArrayGetSize(pQueryInfo->pUpstream);
+
+ for (int32_t i = 0; i < numOfExprs; ++i) {
+ SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+
+ int32_t f = pExpr->base.functionId;
+ if (f == TSDB_FUNC_DERIVATIVE || f == TSDB_FUNC_TWA || f == TSDB_FUNC_IRATE || f == TSDB_FUNC_DIFF) {
+ for (int32_t j = 0; j < upNum; ++j) {
+ SQueryInfo* pUp = taosArrayGetP(pQueryInfo->pUpstream, j);
+ STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pUp, 0);
+ bool isSTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo);
+ if ((!isSTable) || groupbyTbname(pUp)) {
+ return TSDB_CODE_SUCCESS;
+ }
+ }
+
+ return invalidOperationMsg(msg, msg1);
+ }
+ }
+
+ return TSDB_CODE_SUCCESS;
+}
+
+
int32_t doLocalQueryProcess(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode) {
const char* msg1 = "only one expression allowed";
const char* msg2 = "invalid expression in select clause";
@@ -7790,7 +7881,7 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelect
size_t n = tscNumOfExprs(pQueryInfo);
*pExpr = tscExprGet(pQueryInfo, (int32_t)n - 1);
- SInternalField* pField = taosArrayGet(pQueryInfo->fieldsInfo.internalField, n - 1);
+ SInternalField* pField = taosArrayGetLast(pQueryInfo->fieldsInfo.internalField);
pField->visible = false;
return TSDB_CODE_SUCCESS;
@@ -8038,6 +8129,10 @@ static int32_t getTableNameFromSubquery(SSqlNode* pSqlNode, SArray* tableNameLis
int32_t num = (int32_t)taosArrayGetSize(sub->pSubquery);
for (int32_t i = 0; i < num; ++i) {
SSqlNode* p = taosArrayGetP(sub->pSubquery, i);
+ if (p->from == NULL) {
+ return TSDB_CODE_TSC_INVALID_OPERATION;
+ }
+
if (p->from->type == SQL_NODE_FROM_TABLELIST) {
int32_t code = getTableNameFromSqlNode(p, tableNameList, msgBuf, pSql);
if (code != TSDB_CODE_SUCCESS) {
@@ -8142,7 +8237,10 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
size_t len = strlen(name);
- taosHashGetCloneExt(tscTableMetaMap, name, len, NULL, (void **)&pTableMeta, &tableMetaCapacity);
+ if (NULL == taosHashGetCloneExt(tscTableMetaMap, name, len, NULL, (void **)&pTableMeta, &tableMetaCapacity)){
+ tfree(pTableMeta);
+ tableMetaCapacity = 0;
+ }
if (pTableMeta && pTableMeta->id.uid > 0) {
tscDebug("0x%"PRIx64" retrieve table meta %s from local buf", pSql->self, name);
@@ -8371,7 +8469,7 @@ static STableMeta* extractTempTableMetaFromSubquery(SQueryInfo* pUpstream) {
n += 1;
}
-
+ info->numOfColumns = n;
return meta;
}
@@ -8383,6 +8481,7 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
if (taosArrayGetSize(subInfo->pSubquery) >= 2) {
return invalidOperationMsg(msgBuf, "not support union in subquery");
}
+
SQueryInfo* pSub = calloc(1, sizeof(SQueryInfo));
tscInitQueryInfo(pSub);
@@ -8394,18 +8493,19 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
pSub->pUdfInfo = pUdfInfo;
pSub->udfCopy = true;
+ pSub->pDownstream = pQueryInfo;
+ taosArrayPush(pQueryInfo->pUpstream, &pSub);
int32_t code = validateSqlNode(pSql, p, pSub);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
- pSub->pDownstream = pQueryInfo;
-
// create dummy table meta info
STableMetaInfo* pTableMetaInfo1 = calloc(1, sizeof(STableMetaInfo));
if (pTableMetaInfo1 == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
+
pTableMetaInfo1->pTableMeta = extractTempTableMetaFromSubquery(pSub);
pTableMetaInfo1->tableMetaCapacity = tscGetTableMetaSize(pTableMetaInfo1->pTableMeta);
@@ -8418,8 +8518,6 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
tstrncpy(pTableMetaInfo1->aliasName, subInfo->aliasName.z, subInfo->aliasName.n + 1);
}
- taosArrayPush(pQueryInfo->pUpstream, &pSub);
-
// NOTE: order mix up in subquery not support yet.
pQueryInfo->order = pSub->order;
@@ -8458,8 +8556,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
const char* msg8 = "condition missing for join query";
const char* msg9 = "not support 3 level select";
- int32_t code = TSDB_CODE_SUCCESS;
-
+ int32_t code = TSDB_CODE_SUCCESS;
SSqlCmd* pCmd = &pSql->cmd;
STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
@@ -8490,7 +8587,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
// check if there is 3 level select
SRelElementPair* subInfo = taosArrayGet(pSqlNode->from->list, i);
SSqlNode* p = taosArrayGetP(subInfo->pSubquery, 0);
- if (p->from->type == SQL_NODE_FROM_SUBQUERY){
+ if (p->from->type == SQL_NODE_FROM_SUBQUERY) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
}
@@ -8582,6 +8679,15 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
}
}
+ // disable group result mixed up if interval/session window query exists.
+ if (isTimeWindowQuery(pQueryInfo)) {
+ size_t num = taosArrayGetSize(pQueryInfo->pUpstream);
+ for(int32_t i = 0; i < num; ++i) {
+ SQueryInfo* pUp = taosArrayGetP(pQueryInfo->pUpstream, i);
+ pUp->multigroupResult = false;
+ }
+ }
+
// parse the having clause in the first place
int32_t joinQuery = (pSqlNode->from != NULL && taosArrayGetSize(pSqlNode->from->list) > 1);
if (validateHavingClause(pQueryInfo, pSqlNode->pHaving, pCmd, pSqlNode->pSelNodeList, joinQuery, timeWindowQuery) !=
@@ -8602,6 +8708,10 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
return code;
}
+ if ((code = validateFunctionFromUpstream(pQueryInfo, tscGetErrorMsgPayload(pCmd))) != TSDB_CODE_SUCCESS) {
+ return code;
+ }
+
// updateFunctionInterBuf(pQueryInfo, false);
updateLastScanOrderIfNeeded(pQueryInfo);
@@ -8754,8 +8864,6 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
pQueryInfo->simpleAgg = isSimpleAggregateRv(pQueryInfo);
pQueryInfo->onlyTagQuery = onlyTagPrjFunction(pQueryInfo);
pQueryInfo->groupbyColumn = tscGroupbyColumn(pQueryInfo);
- //pQueryInfo->globalMerge = tscIsTwoStageSTableQuery(pQueryInfo, 0);
-
pQueryInfo->arithmeticOnAgg = tsIsArithmeticQueryOnAggResult(pQueryInfo);
pQueryInfo->orderProjectQuery = tscOrderedProjectionQueryOnSTable(pQueryInfo, 0);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 3e8dfac1da0cb192282989b9ab1137427365b6d0..df5ffcecf58a61587c0b0fe38f3efc3053c7d6d1 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -337,16 +337,189 @@ int tscSendMsgToServer(SSqlObj *pSql) {
return TSDB_CODE_SUCCESS;
}
-static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
- SRpcMsg* rpcMsg = pSchedMsg->ahandle;
- SRpcEpSet* pEpSet = pSchedMsg->thandle;
+//static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
+// SRpcMsg* rpcMsg = pSchedMsg->ahandle;
+// SRpcEpSet* pEpSet = pSchedMsg->thandle;
+//
+// TSDB_CACHE_PTR_TYPE handle = (TSDB_CACHE_PTR_TYPE) rpcMsg->ahandle;
+// SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, handle);
+// if (pSql == NULL) {
+// rpcFreeCont(rpcMsg->pCont);
+// free(rpcMsg);
+// free(pEpSet);
+// return;
+// }
+//
+// assert(pSql->self == handle);
+//
+// STscObj *pObj = pSql->pTscObj;
+// SSqlRes *pRes = &pSql->res;
+// SSqlCmd *pCmd = &pSql->cmd;
+//
+// pSql->rpcRid = -1;
+//
+// if (pObj->signature != pObj) {
+// tscDebug("0x%"PRIx64" DB connection is closed, cmd:%d pObj:%p signature:%p", pSql->self, pCmd->command, pObj, pObj->signature);
+//
+// taosRemoveRef(tscObjRef, handle);
+// taosReleaseRef(tscObjRef, handle);
+// rpcFreeCont(rpcMsg->pCont);
+// free(rpcMsg);
+// free(pEpSet);
+// return;
+// }
+//
+// SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+// if (pQueryInfo != NULL && pQueryInfo->type == TSDB_QUERY_TYPE_FREE_RESOURCE) {
+// tscDebug("0x%"PRIx64" sqlObj needs to be released or DB connection is closed, cmd:%d type:%d, pObj:%p signature:%p",
+// pSql->self, pCmd->command, pQueryInfo->type, pObj, pObj->signature);
+//
+// taosRemoveRef(tscObjRef, handle);
+// taosReleaseRef(tscObjRef, handle);
+// rpcFreeCont(rpcMsg->pCont);
+// free(rpcMsg);
+// free(pEpSet);
+// return;
+// }
+//
+// if (pEpSet) {
+// if (!tscEpSetIsEqual(&pSql->epSet, pEpSet)) {
+// if (pCmd->command < TSDB_SQL_MGMT) {
+// tscUpdateVgroupInfo(pSql, pEpSet);
+// } else {
+// tscUpdateMgmtEpSet(pSql, pEpSet);
+// }
+// }
+// }
+//
+// int32_t cmd = pCmd->command;
+//
+// // set the flag to denote that sql string needs to be re-parsed and build submit block with table schema
+// if (cmd == TSDB_SQL_INSERT && rpcMsg->code == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
+// pSql->cmd.insertParam.schemaAttached = 1;
+// }
+//
+// // single table query error need to be handled here.
+// if ((cmd == TSDB_SQL_SELECT || cmd == TSDB_SQL_UPDATE_TAGS_VAL) &&
+// (((rpcMsg->code == TSDB_CODE_TDB_INVALID_TABLE_ID || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID)) ||
+// rpcMsg->code == TSDB_CODE_RPC_NETWORK_UNAVAIL || rpcMsg->code == TSDB_CODE_APP_NOT_READY)) {
+//
+// // 1. super table subquery
+// // 2. nest queries are all not updated the tablemeta and retry parse the sql after cleanup local tablemeta/vgroup id buffer
+// if ((TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY | TSDB_QUERY_TYPE_SUBQUERY |
+// TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) &&
+// !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_PROJECTION_QUERY)) ||
+// (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_NEST_SUBQUERY)) || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_SUBQUERY) && pQueryInfo->distinct)) {
+// // do nothing in case of super table subquery
+// } else {
+// pSql->retry += 1;
+// tscWarn("0x%" PRIx64 " it shall renew table meta, code:%s, retry:%d", pSql->self, tstrerror(rpcMsg->code), pSql->retry);
+//
+// pSql->res.code = rpcMsg->code; // keep the previous error code
+// if (pSql->retry > pSql->maxRetry) {
+// tscError("0x%" PRIx64 " max retry %d reached, give up", pSql->self, pSql->maxRetry);
+// } else {
+// // wait for a little bit moment and then retry
+// // todo do not sleep in rpc callback thread, add this process into queue to process
+// if (rpcMsg->code == TSDB_CODE_APP_NOT_READY || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID) {
+// int32_t duration = getWaitingTimeInterval(pSql->retry);
+// taosMsleep(duration);
+// }
+//
+// pSql->retryReason = rpcMsg->code;
+// rpcMsg->code = tscRenewTableMeta(pSql, 0);
+// // if there is an error occurring, proceed to the following error handling procedure.
+// if (rpcMsg->code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+// taosReleaseRef(tscObjRef, handle);
+// rpcFreeCont(rpcMsg->pCont);
+// free(rpcMsg);
+// free(pEpSet);
+// return;
+// }
+// }
+// }
+// }
+//
+// pRes->rspLen = 0;
+//
+// if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
+// tscDebug("0x%"PRIx64" query is cancelled, code:%s", pSql->self, tstrerror(pRes->code));
+// } else {
+// pRes->code = rpcMsg->code;
+// }
+//
+// if (pRes->code == TSDB_CODE_SUCCESS) {
+// tscDebug("0x%"PRIx64" reset retry counter to be 0 due to success rsp, old:%d", pSql->self, pSql->retry);
+// pSql->retry = 0;
+// }
+//
+// if (pRes->code != TSDB_CODE_TSC_QUERY_CANCELLED) {
+// assert(rpcMsg->msgType == pCmd->msgType + 1);
+// pRes->code = rpcMsg->code;
+// pRes->rspType = rpcMsg->msgType;
+// pRes->rspLen = rpcMsg->contLen;
+//
+// if (pRes->rspLen > 0 && rpcMsg->pCont) {
+// char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen);
+// if (tmp == NULL) {
+// pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+// } else {
+// pRes->pRsp = tmp;
+// memcpy(pRes->pRsp, rpcMsg->pCont, pRes->rspLen);
+// }
+// } else {
+// tfree(pRes->pRsp);
+// }
+//
+// /*
+// * There is not response callback function for submit response.
+// * The actual inserted number of points is the first number.
+// */
+// if (rpcMsg->msgType == TSDB_MSG_TYPE_SUBMIT_RSP && pRes->pRsp != NULL) {
+// SShellSubmitRspMsg *pMsg = (SShellSubmitRspMsg*)pRes->pRsp;
+// pMsg->code = htonl(pMsg->code);
+// pMsg->numOfRows = htonl(pMsg->numOfRows);
+// pMsg->affectedRows = htonl(pMsg->affectedRows);
+// pMsg->failedRows = htonl(pMsg->failedRows);
+// pMsg->numOfFailedBlocks = htonl(pMsg->numOfFailedBlocks);
+//
+// pRes->numOfRows += pMsg->affectedRows;
+// tscDebug("0x%"PRIx64" SQL cmd:%s, code:%s inserted rows:%d rspLen:%d", pSql->self, sqlCmd[pCmd->command],
+// tstrerror(pRes->code), pMsg->affectedRows, pRes->rspLen);
+// } else {
+// tscDebug("0x%"PRIx64" SQL cmd:%s, code:%s rspLen:%d", pSql->self, sqlCmd[pCmd->command], tstrerror(pRes->code), pRes->rspLen);
+// }
+// }
+//
+// if (pRes->code == TSDB_CODE_SUCCESS && tscProcessMsgRsp[pCmd->command]) {
+// rpcMsg->code = (*tscProcessMsgRsp[pCmd->command])(pSql);
+// }
+//
+// bool shouldFree = tscShouldBeFreed(pSql);
+// if (rpcMsg->code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+// if (rpcMsg->code != TSDB_CODE_SUCCESS) {
+// pRes->code = rpcMsg->code;
+// }
+// rpcMsg->code = (pRes->code == TSDB_CODE_SUCCESS) ? (int32_t)pRes->numOfRows : pRes->code;
+// (*pSql->fp)(pSql->param, pSql, rpcMsg->code);
+// }
+//
+// if (shouldFree) { // in case of table-meta/vgrouplist query, automatically free it
+// tscDebug("0x%"PRIx64" sqlObj is automatically freed", pSql->self);
+// taosRemoveRef(tscObjRef, handle);
+// }
+//
+// taosReleaseRef(tscObjRef, handle);
+// rpcFreeCont(rpcMsg->pCont);
+// free(rpcMsg);
+// free(pEpSet);
+//}
+void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
TSDB_CACHE_PTR_TYPE handle = (TSDB_CACHE_PTR_TYPE) rpcMsg->ahandle;
SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, handle);
if (pSql == NULL) {
rpcFreeCont(rpcMsg->pCont);
- free(rpcMsg);
- free(pEpSet);
return;
}
@@ -357,15 +530,12 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
SSqlCmd *pCmd = &pSql->cmd;
pSql->rpcRid = -1;
-
if (pObj->signature != pObj) {
tscDebug("0x%"PRIx64" DB connection is closed, cmd:%d pObj:%p signature:%p", pSql->self, pCmd->command, pObj, pObj->signature);
taosRemoveRef(tscObjRef, handle);
taosReleaseRef(tscObjRef, handle);
rpcFreeCont(rpcMsg->pCont);
- free(rpcMsg);
- free(pEpSet);
return;
}
@@ -377,8 +547,6 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
taosRemoveRef(tscObjRef, handle);
taosReleaseRef(tscObjRef, handle);
rpcFreeCont(rpcMsg->pCont);
- free(rpcMsg);
- free(pEpSet);
return;
}
@@ -409,7 +577,8 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
if ((TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY | TSDB_QUERY_TYPE_SUBQUERY |
TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) &&
!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_PROJECTION_QUERY)) ||
- (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_NEST_SUBQUERY))) {
+ (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_NEST_SUBQUERY)) || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_SUBQUERY) && pQueryInfo->distinct)
+ || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_QUERY))) {
// do nothing in case of super table subquery
} else {
pSql->retry += 1;
@@ -432,8 +601,6 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
if (rpcMsg->code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
taosReleaseRef(tscObjRef, handle);
rpcFreeCont(rpcMsg->pCont);
- free(rpcMsg);
- free(pEpSet);
return;
}
}
@@ -511,29 +678,6 @@ static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
taosReleaseRef(tscObjRef, handle);
rpcFreeCont(rpcMsg->pCont);
- free(rpcMsg);
- free(pEpSet);
-}
-
-void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
- SSchedMsg schedMsg = {0};
-
- schedMsg.fp = doProcessMsgFromServer;
-
- SRpcMsg* rpcMsgCopy = calloc(1, sizeof(SRpcMsg));
- memcpy(rpcMsgCopy, rpcMsg, sizeof(struct SRpcMsg));
- schedMsg.ahandle = (void*)rpcMsgCopy;
-
- SRpcEpSet* pEpSetCopy = NULL;
- if (pEpSet != NULL) {
- pEpSetCopy = calloc(1, sizeof(SRpcEpSet));
- memcpy(pEpSetCopy, pEpSet, sizeof(SRpcEpSet));
- }
-
- schedMsg.thandle = (void*)pEpSetCopy;
- schedMsg.msg = NULL;
-
- taosScheduleTask(tscQhandle, &schedMsg);
}
int doBuildAndSendMsg(SSqlObj *pSql) {
@@ -698,6 +842,11 @@ static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql) {
tableSerialize = totalTables * sizeof(STableIdInfo);
}
+ SCond* pCond = &pQueryInfo->tagCond.tbnameCond;
+ if (pCond->len > 0) {
+ srcColListSize += pCond->len;
+ }
+
return MIN_QUERY_MSG_PKT_SIZE + minMsgSize() + sizeof(SQueryTableMsg) + srcColListSize + srcColFilterSize + srcTagFilterSize +
exprSize + tsBufSize + tableSerialize + sqlLen + 4096 + pQueryInfo->bufLen;
}
@@ -880,16 +1029,16 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
}
SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
+ STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+ STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
SQueryAttr query = {{0}};
tscCreateQueryFromQueryInfo(pQueryInfo, &query, pSql);
+ query.vgId = pTableMeta->vgId;
SArray* tableScanOperator = createTableScanPlan(&query);
SArray* queryOperator = createExecOperatorPlan(&query);
- STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
- STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
-
SQueryTableMsg *pQueryMsg = (SQueryTableMsg *)pCmd->payload;
tstrncpy(pQueryMsg->version, version, tListLen(pQueryMsg->version));
@@ -1383,7 +1532,6 @@ int32_t tscBuildSyncDbReplicaMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
}
int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
- STscObj *pObj = pSql->pTscObj;
SSqlCmd *pCmd = &pSql->cmd;
pCmd->msgType = TSDB_MSG_TYPE_CM_SHOW;
pCmd->payloadLen = sizeof(SShowMsg) + 100;
@@ -1406,9 +1554,9 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
}
if (tNameIsEmpty(&pTableMetaInfo->name)) {
- pthread_mutex_lock(&pObj->mutex);
- tstrncpy(pShowMsg->db, pObj->db, sizeof(pShowMsg->db));
- pthread_mutex_unlock(&pObj->mutex);
+ char *p = cloneCurrentDBName(pSql);
+ tstrncpy(pShowMsg->db, p, sizeof(pShowMsg->db));
+ tfree(p);
} else {
tNameGetFullDbName(&pTableMetaInfo->name, pShowMsg->db);
}
@@ -1744,7 +1892,7 @@ static int tscLocalResultCommonBuilder(SSqlObj *pSql, int32_t numOfRes) {
return pRes->code;
}
- tscSetResRawPtr(pRes, pQueryInfo);
+ tscSetResRawPtr(pRes, pQueryInfo, pRes->dataConverted);
} else {
tscResetForNextRetrieve(pRes);
}
@@ -2659,7 +2807,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
(tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) &&
!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_QUERY) &&
!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE))) {
- tscSetResRawPtr(pRes, pQueryInfo);
+ tscSetResRawPtr(pRes, pQueryInfo, pRes->dataConverted);
}
if (pSql->pSubscription != NULL) {
@@ -2824,7 +2972,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
pNew->self, numOfTable, numOfVgroupList, numOfUdf, pNew->cmd.payloadLen);
pNew->fp = fp;
- pNew->param = (void *)pSql->self;
+ pNew->param = (void *)pSql->rootObj->self;
tscDebug("0x%"PRIx64" metaRid from 0x%" PRIx64 " to 0x%" PRIx64 , pSql->self, pSql->metaRid, pNew->self);
@@ -2849,7 +2997,10 @@ int32_t tscGetTableMetaImpl(SSqlObj* pSql, STableMetaInfo *pTableMetaInfo, bool
memset(pTableMetaInfo->pTableMeta, 0, pTableMetaInfo->tableMetaCapacity);
}
}
- taosHashGetCloneExt(tscTableMetaMap, name, len, NULL, (void **)&(pTableMetaInfo->pTableMeta), &pTableMetaInfo->tableMetaCapacity);
+ if (NULL == taosHashGetCloneExt(tscTableMetaMap, name, len, NULL, (void **)&(pTableMetaInfo->pTableMeta), &pTableMetaInfo->tableMetaCapacity)) {
+ tfree(pTableMetaInfo->pTableMeta);
+ pTableMetaInfo->tableMetaCapacity = 0;
+ }
STableMeta* pMeta = pTableMetaInfo->pTableMeta;
if (pMeta && pMeta->id.uid > 0) {
@@ -2860,6 +3011,8 @@ int32_t tscGetTableMetaImpl(SSqlObj* pSql, STableMetaInfo *pTableMetaInfo, bool
return getTableMetaFromMnode(pSql, pTableMetaInfo, autocreate);
}
}
+
+ tscDebug("0x%"PRIx64 " %s retrieve tableMeta from cache, numOfCols:%d, numOfTags:%d", pSql->self, name, pMeta->tableInfo.numOfColumns, pMeta->tableInfo.numOfTags);
return TSDB_CODE_SUCCESS;
}
@@ -2967,6 +3120,12 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
pCmd->pTableMetaMap = tscCleanupTableMetaMap(pCmd->pTableMetaMap);
pCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+ SSqlCmd* pCmd2 = &pSql->rootObj->cmd;
+ pCmd2->pTableMetaMap = tscCleanupTableMetaMap(pCmd2->pTableMetaMap);
+ pCmd2->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+
+ pSql->rootObj->retryReason = pSql->retryReason;
+
SArray* pNameList = taosArrayInit(1, POINTER_BYTES);
SArray* vgroupList = taosArrayInit(1, POINTER_BYTES);
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 6f3d5c3a63c8d9c82eb7776c0a346abc88676ec1..e292db30fd1983d78e3712238b2de6cd18638956 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -874,6 +874,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
pSql->pTscObj = taos;
pSql->signature = pSql;
+ pSql->rootObj = pSql;
SSqlCmd *pCmd = &pSql->cmd;
pCmd->resColumnId = TSDB_RES_COL_ID;
@@ -887,7 +888,9 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
return TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
}
- pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
+ char* sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
+ if(sqlstr == NULL && pSql->sqlstr) free(pSql->sqlstr);
+ pSql->sqlstr = sqlstr;
if (pSql->sqlstr == NULL) {
tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
tfree(pSql);
@@ -980,6 +983,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
pSql->pTscObj = taos;
pSql->signature = pSql;
+ pSql->rootObj = pSql;
int32_t code = (uint8_t) tscTransferTableNameList(pSql, str, length, plist);
free(str);
diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index 2c4bc5f76463ee6bc811e9b6fa3631b534f64478..63459a5979ef4545a1e3c56048bebdf236ce1e9b 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -679,6 +679,7 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c
pSql->signature = pSql;
pSql->pTscObj = pObj;
+ pSql->rootObj = pSql;
SSqlCmd *pCmd = &pSql->cmd;
SSqlRes *pRes = &pSql->res;
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index 52ba424fa5adcd43ac5b624b7f486c06df71f2c4..0c5eac66e2260f584cafe3855e76418a4462f325 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -127,6 +127,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
pSql->signature = pSql;
pSql->pTscObj = pObj;
pSql->pSubscription = pSub;
+ pSql->rootObj = pSql;
pSub->pSql = pSql;
SSqlCmd* pCmd = &pSql->cmd;
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 2e7e02cfd546ad377309411e4e4bf509e419b575..8e579ad2210920c442a4c447c2fed267b658b546 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -15,8 +15,9 @@
#define _GNU_SOURCE
#include "os.h"
-
#include "texpr.h"
+
+#include "tsched.h"
#include "qTsbuf.h"
#include "tcompare.h"
#include "tscLog.h"
@@ -859,6 +860,40 @@ static bool checkForDuplicateTagVal(SSchema* pColSchema, SJoinSupporter* p1, SSq
return true;
}
+
+bool tscReparseSql(SSqlObj *sql, int32_t code){
+ if (!((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && sql->retry < sql->maxRetry)) {
+ return true;
+ }
+
+ tscFreeSubobj(sql);
+ tfree(sql->pSubs);
+
+ sql->res.code = TSDB_CODE_SUCCESS;
+ sql->retry++;
+
+ tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", sql->self,
+ tstrerror(code), sql->retry);
+
+ tscResetSqlCmd(&sql->cmd, true);
+ code = tsParseSql(sql, true);
+ if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+ return false;
+ }
+
+ if (code != TSDB_CODE_SUCCESS) {
+ sql->res.code = code;
+ tscAsyncResultOnError(sql);
+ return false;
+ }
+
+ SQueryInfo* pQueryInfo = tscGetQueryInfo(&sql->cmd);
+ executeQuery(sql, pQueryInfo);
+
+ return false;
+}
+
+
static void setTidTagType(SJoinSupporter* p, uint8_t type) {
for (int32_t i = 0; i < p->num; ++i) {
STidTags * tag = (STidTags*) varDataVal(p->pIdTagList + i * p->tagSize);
@@ -1101,6 +1136,10 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
return;
}
+ if (!tscReparseSql(pParentSql->rootObj, pParentSql->res.code)) {
+ return;
+ }
+
tscAsyncResultOnError(pParentSql);
return;
@@ -1118,6 +1157,10 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
return;
}
+ if (!tscReparseSql(pParentSql->rootObj, pParentSql->res.code)) {
+ return;
+ }
+
tscAsyncResultOnError(pParentSql);
return;
}
@@ -1255,6 +1298,10 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
return;
}
+ if (!tscReparseSql(pParentSql->rootObj, pParentSql->res.code)) {
+ return;
+ }
+
tscAsyncResultOnError(pParentSql);
return;
@@ -1271,6 +1318,10 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
return;
}
+ if (!tscReparseSql(pParentSql->rootObj, pParentSql->res.code)) {
+ return;
+ }
+
tscAsyncResultOnError(pParentSql);
return;
}
@@ -1400,6 +1451,10 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
if (quitAllSubquery(pSql, pParentSql, pSupporter)) {
return;
}
+
+ if (!tscReparseSql(pParentSql->rootObj, pParentSql->res.code)) {
+ return;
+ }
tscAsyncResultOnError(pParentSql);
return;
@@ -1727,6 +1782,7 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
// tscFieldInfoUpdateOffset(pQueryInfo);
}
+
void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
SSqlObj* pSql = (SSqlObj*)tres;
@@ -1746,6 +1802,10 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
return;
}
+ if (!tscReparseSql(pParentSql->rootObj, pParentSql->res.code)) {
+ return;
+ }
+
tscAsyncResultOnError(pParentSql);
return;
@@ -1761,6 +1821,10 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
if (quitAllSubquery(pSql, pParentSql, pSupporter)) {
return;
}
+
+ if (!tscReparseSql(pParentSql->rootObj, pParentSql->res.code)) {
+ return;
+ }
tscAsyncResultOnError(pParentSql);
@@ -2034,17 +2098,14 @@ void tscHandleMasterJoinQuery(SSqlObj* pSql) {
tscAsyncResultOnError(pSql);
}
-static void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs) {
+void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs) {
assert(numOfSubs <= pSql->subState.numOfSub && numOfSubs >= 0);
for(int32_t i = 0; i < numOfSubs; ++i) {
SSqlObj* pSub = pSql->pSubs[i];
assert(pSub != NULL);
-
- SRetrieveSupport* pSupport = pSub->param;
-
- tfree(pSupport->localBuffer);
- tfree(pSupport);
+
+ tscFreeRetrieveSup(pSub);
taos_free_result(pSub);
}
@@ -2267,7 +2328,7 @@ void tscFirstRoundCallback(void* param, TAOS_RES* tres, int code) {
destroySup(pSup);
taos_free_result(pSql);
- parent->res.code = code;
+ parent->res.code = c;
tscAsyncResultOnError(parent);
return;
}
@@ -2397,6 +2458,10 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
} else {
SSchema ss = {.type = (uint8_t)pCol->info.type, .bytes = pCol->info.bytes, .colId = (int16_t)pCol->columnIndex};
tscColumnListInsert(pNewQueryInfo->colList, pCol->columnIndex, pCol->tableUid, &ss);
+ int32_t ti = tscColumnExists(pNewQueryInfo->colList, pCol->columnIndex, pCol->tableUid);
+ assert(ti >= 0);
+ SColumn* x = taosArrayGetP(pNewQueryInfo->colList, ti);
+ tscColumnCopy(x, pCol);
}
}
}
@@ -2424,6 +2489,30 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
return terrno;
}
+typedef struct SPair {
+ int32_t first;
+ int32_t second;
+} SPair;
+
+static void doSendQueryReqs(SSchedMsg* pSchedMsg) {
+ SSqlObj* pSql = pSchedMsg->ahandle;
+ SPair* p = pSchedMsg->msg;
+
+ for (int32_t i = p->first; i < p->second; ++i) {
+ if (i >= pSql->subState.numOfSub) {
+ tfree(p);
+ return;
+ }
+ SSqlObj* pSub = pSql->pSubs[i];
+ SRetrieveSupport* pSupport = pSub->param;
+
+ tscDebug("0x%"PRIx64" sub:0x%"PRIx64" launch subquery, orderOfSub:%d.", pSql->self, pSub->self, pSupport->subqueryIndex);
+ tscBuildAndSendRequest(pSub, NULL);
+ }
+
+ tfree(p);
+}
+
int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
SSqlRes *pRes = &pSql->res;
SSqlCmd *pCmd = &pSql->cmd;
@@ -2546,19 +2635,44 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
doCleanupSubqueries(pSql, i);
return pRes->code;
}
-
- for(int32_t j = 0; j < pState->numOfSub; ++j) {
- SSqlObj* pSub = pSql->pSubs[j];
- SRetrieveSupport* pSupport = pSub->param;
-
- tscDebug("0x%"PRIx64" sub:0x%"PRIx64" launch subquery, orderOfSub:%d.", pSql->self, pSub->self, pSupport->subqueryIndex);
- tscBuildAndSendRequest(pSub, NULL);
+
+ // concurrently sent the query requests.
+ const int32_t MAX_REQUEST_PER_TASK = 8;
+
+ int32_t numOfTasks = (pState->numOfSub + MAX_REQUEST_PER_TASK - 1)/MAX_REQUEST_PER_TASK;
+ assert(numOfTasks >= 1);
+
+ int32_t num;
+ if (pState->numOfSub / numOfTasks == MAX_REQUEST_PER_TASK) {
+ num = MAX_REQUEST_PER_TASK;
+ } else {
+ num = pState->numOfSub / numOfTasks + 1;
+ }
+ tscDebug("0x%"PRIx64 " query will be sent by %d threads", pSql->self, numOfTasks);
+
+ for(int32_t j = 0; j < numOfTasks; ++j) {
+ SSchedMsg schedMsg = {0};
+ schedMsg.fp = doSendQueryReqs;
+ schedMsg.ahandle = (void*)pSql;
+
+ schedMsg.thandle = NULL;
+ SPair* p = calloc(1, sizeof(SPair));
+ p->first = j * num;
+
+ if (j == numOfTasks - 1) {
+ p->second = pState->numOfSub;
+ } else {
+ p->second = (j + 1) * num;
+ }
+
+ schedMsg.msg = p;
+ taosScheduleTask(tscQhandle, &schedMsg);
}
return TSDB_CODE_SUCCESS;
}
-static void tscFreeRetrieveSup(SSqlObj *pSql) {
+void tscFreeRetrieveSup(SSqlObj *pSql) {
SRetrieveSupport *trsupport = pSql->param;
void* p = atomic_val_compare_exchange_ptr(&pSql->param, trsupport, 0);
@@ -2716,33 +2830,36 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
if (!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE)) {
int32_t code = pParentSql->res.code;
- if ((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && pParentSql->retry < pParentSql->maxRetry) {
- // remove the cached tableMeta and vgroup id list, and then parse the sql again
- SSqlCmd* pParentCmd = &pParentSql->cmd;
- STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pParentCmd, 0);
- tscRemoveTableMetaBuf(pTableMetaInfo, pParentSql->self);
+ SSqlObj *userSql = pParentSql->rootObj;
- pParentCmd->pTableMetaMap = tscCleanupTableMetaMap(pParentCmd->pTableMetaMap);
- pParentCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+ if ((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && userSql->retry < userSql->maxRetry) {
+ if (userSql != pParentSql) {
+ tscFreeRetrieveSup(pParentSql);
+ }
+
+ tscFreeSubobj(userSql);
+ tfree(userSql->pSubs);
- pParentSql->res.code = TSDB_CODE_SUCCESS;
- pParentSql->retry++;
+ userSql->res.code = TSDB_CODE_SUCCESS;
+ userSql->retry++;
- tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", pParentSql->self,
- tstrerror(code), pParentSql->retry);
+ tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", userSql->self,
+ tstrerror(code), userSql->retry);
- code = tsParseSql(pParentSql, true);
+ tscResetSqlCmd(&userSql->cmd, true);
+ code = tsParseSql(userSql, true);
if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
return;
}
if (code != TSDB_CODE_SUCCESS) {
- pParentSql->res.code = code;
- tscAsyncResultOnError(pParentSql);
+ userSql->res.code = code;
+ tscAsyncResultOnError(userSql);
return;
}
- executeQuery(pParentSql, pQueryInfo);
+ pQueryInfo = tscGetQueryInfo(&userSql->cmd);
+ executeQuery(userSql, pQueryInfo);
} else {
(*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.code);
}
@@ -2812,7 +2929,6 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
pParentSql->self, pState->numOfSub, pState->numOfRetrievedRows);
SQueryInfo *pPQueryInfo = tscGetQueryInfo(&pParentSql->cmd);
- tscClearInterpInfo(pPQueryInfo);
code = tscCreateGlobalMerger(trsupport->pExtMemBuffer, pState->numOfSub, pDesc, pPQueryInfo, &pParentSql->res.pMerger, pParentSql->self);
pParentSql->res.code = code;
@@ -2927,7 +3043,7 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
tscDebug("0x%"PRIx64" sub:0x%"PRIx64" retrieve numOfRows:%d totalNumOfRows:%" PRIu64 " from ep:%s, orderOfSub:%d",
pParentSql->self, pSql->self, pRes->numOfRows, pState->numOfRetrievedRows, pSql->epSet.fqdn[pSql->epSet.inUse], idx);
- if (num > tsMaxNumOfOrderedResults && /*tscIsProjectionQueryOnSTable(pQueryInfo, 0) &&*/ !(tscGetQueryInfo(&pParentSql->cmd)->distinct)) {
+ if (num > tsMaxNumOfOrderedResults && tscIsProjectionQueryOnSTable(pQueryInfo, 0) && !(tscGetQueryInfo(&pParentSql->cmd)->distinct)) {
tscError("0x%"PRIx64" sub:0x%"PRIx64" num of OrderedRes is too many, max allowed:%" PRId32 " , current:%" PRId64,
pParentSql->self, pSql->self, tsMaxNumOfOrderedResults, num);
tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_TSC_SORTED_RES_TOO_MANY);
@@ -3351,6 +3467,7 @@ static void doBuildResFromSubqueries(SSqlObj* pSql) {
}
if (numOfRes == 0) { // no result any more, free all subquery objects
+ pSql->res.completed = true;
freeJoinSubqueryObj(pSql);
return;
}
@@ -3397,6 +3514,8 @@ static void doBuildResFromSubqueries(SSqlObj* pSql) {
char* pData = getResultBlockPosition(pCmd1, pRes1, pIndex->columnIndex, &bytes);
memcpy(data, pData, bytes * numOfRes);
+ pRes->dataConverted = pRes1->dataConverted;
+
data += bytes * numOfRes;
}
@@ -3422,7 +3541,7 @@ static void doBuildResFromSubqueries(SSqlObj* pSql) {
doArithmeticCalculate(pQueryInfo, pFilePage, rowSize, finalRowSize);
pRes->data = pFilePage->data;
- tscSetResRawPtr(pRes, pQueryInfo);
+ tscSetResRawPtr(pRes, pQueryInfo, pRes->dataConverted);
}
void tscBuildResFromSubqueries(SSqlObj *pSql) {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 3c35795b0dda8e4c147ed36d4931410dbe7c13a7..0e414e36c884b0a1866f0a735cf235121eb63065 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -29,6 +29,7 @@
#include "tsclient.h"
#include "ttimer.h"
#include "ttokendef.h"
+#include "httpInt.h"
static void freeQueryInfoImpl(SQueryInfo* pQueryInfo);
@@ -60,6 +61,21 @@ int32_t converToStr(char *str, int type, void *buf, int32_t bufSize, int32_t *le
case TSDB_DATA_TYPE_TIMESTAMP:
n = sprintf(str, "%" PRId64, *(int64_t*)buf);
break;
+ case TSDB_DATA_TYPE_UTINYINT:
+ n = sprintf(str, "%d", *(uint8_t*)buf);
+ break;
+
+ case TSDB_DATA_TYPE_USMALLINT:
+ n = sprintf(str, "%d", *(uint16_t*)buf);
+ break;
+
+ case TSDB_DATA_TYPE_UINT:
+ n = sprintf(str, "%d", *(uint32_t*)buf);
+ break;
+
+ case TSDB_DATA_TYPE_UBIGINT:
+ n = sprintf(str, "%" PRId64, *(uint64_t*)buf);
+ break;
case TSDB_DATA_TYPE_FLOAT:
n = sprintf(str, "%f", GET_FLOAT_VAL(buf));
@@ -369,6 +385,27 @@ bool tscGroupbyColumn(SQueryInfo* pQueryInfo) {
return false;
}
+int32_t tscGetTopBotQueryExprIndex(SQueryInfo* pQueryInfo) {
+ size_t numOfExprs = tscNumOfExprs(pQueryInfo);
+
+ for (int32_t i = 0; i < numOfExprs; ++i) {
+ SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+ if (pExpr == NULL) {
+ continue;
+ }
+
+ if (pExpr->base.functionId == TSDB_FUNC_TS) {
+ continue;
+ }
+
+ if (pExpr->base.functionId == TSDB_FUNC_TOP || pExpr->base.functionId == TSDB_FUNC_BOTTOM) {
+ return i;
+ }
+ }
+
+ return -1;
+}
+
bool tscIsTopBotQuery(SQueryInfo* pQueryInfo) {
size_t numOfExprs = tscNumOfExprs(pQueryInfo);
@@ -625,8 +662,10 @@ static void setResRawPtrImpl(SSqlRes* pRes, SInternalField* pInfo, int32_t i, bo
} else if (convertNchar && pInfo->field.type == TSDB_DATA_TYPE_NCHAR) {
// convert unicode to native code in a temporary buffer extra one byte for terminated symbol
- pRes->buffer[i] = realloc(pRes->buffer[i], pInfo->field.bytes * pRes->numOfRows);
-
+ char* buffer = realloc(pRes->buffer[i], pInfo->field.bytes * pRes->numOfRows);
+ if(buffer == NULL)
+ return ;
+ pRes->buffer[i] = buffer;
// string terminated char for binary data
memset(pRes->buffer[i], 0, pInfo->field.bytes * pRes->numOfRows);
@@ -652,9 +691,13 @@ static void setResRawPtrImpl(SSqlRes* pRes, SInternalField* pInfo, int32_t i, bo
memcpy(pRes->urow[i], pRes->buffer[i], pInfo->field.bytes * pRes->numOfRows);
}
+
+ if (convertNchar) {
+ pRes->dataConverted = true;
+ }
}
-void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
+void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo, bool converted) {
assert(pRes->numOfCols > 0);
if (pRes->numOfRows == 0) {
return;
@@ -667,7 +710,7 @@ void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
pRes->length[i] = pInfo->field.bytes;
offset += pInfo->field.bytes;
- setResRawPtrImpl(pRes, pInfo, i, true);
+ setResRawPtrImpl(pRes, pInfo, i, converted ? false : true);
}
}
@@ -1206,7 +1249,6 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
createInputDataFilterInfo(px, numOfCol1, &numOfFilterCols, &pFilterInfo);
SOperatorInfo* pSourceOperator = createDummyInputOperator(pSqlObjList[0], pSchema, numOfCol1, pFilterInfo, numOfFilterCols);
-
pOutput->precision = pSqlObjList[0]->res.precision;
SSchema* schema = NULL;
@@ -1502,7 +1544,6 @@ void tscFreeSqlObj(SSqlObj* pSql) {
tscFreeSqlResult(pSql);
tscResetSqlCmd(pCmd, false);
- memset(pCmd->payload, 0, (size_t)pCmd->allocSize);
tfree(pCmd->payload);
pCmd->allocSize = 0;
@@ -2072,6 +2113,22 @@ TAOS_FIELD tscCreateField(int8_t type, const char* name, int16_t bytes) {
return f;
}
+int32_t tscGetFirstInvisibleFieldPos(SQueryInfo* pQueryInfo) {
+ if (pQueryInfo->fieldsInfo.numOfOutput <= 0 || pQueryInfo->fieldsInfo.internalField == NULL) {
+ return 0;
+ }
+
+ for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
+ SInternalField* pField = taosArrayGet(pQueryInfo->fieldsInfo.internalField, i);
+ if (!pField->visible) {
+ return i;
+ }
+ }
+
+ return pQueryInfo->fieldsInfo.numOfOutput;
+}
+
+
SInternalField* tscFieldInfoAppend(SFieldInfo* pFieldInfo, TAOS_FIELD* pField) {
assert(pFieldInfo != NULL);
pFieldInfo->numOfOutput++;
@@ -3041,6 +3098,7 @@ void tscInitQueryInfo(SQueryInfo* pQueryInfo) {
pQueryInfo->slimit.offset = 0;
pQueryInfo->pUpstream = taosArrayInit(4, POINTER_BYTES);
pQueryInfo->window = TSWINDOW_INITIALIZER;
+ pQueryInfo->multigroupResult = true;
}
int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
@@ -3052,7 +3110,6 @@ int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
}
tscInitQueryInfo(pQueryInfo);
-
pQueryInfo->msg = pCmd->payload; // pointer to the parent error message buffer
if (pCmd->pQueryInfo == NULL) {
@@ -3134,6 +3191,7 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
pQueryInfo->window = pSrc->window;
pQueryInfo->sessionWindow = pSrc->sessionWindow;
pQueryInfo->pTableMetaInfo = NULL;
+ pQueryInfo->multigroupResult = pSrc->multigroupResult;
pQueryInfo->bufLen = pSrc->bufLen;
pQueryInfo->orderProjectQuery = pSrc->orderProjectQuery;
@@ -3371,6 +3429,7 @@ void tscResetForNextRetrieve(SSqlRes* pRes) {
pRes->row = 0;
pRes->numOfRows = 0;
+ pRes->dataConverted = false;
}
void tscInitResForMerge(SSqlRes* pRes) {
@@ -3400,6 +3459,7 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, in
pNew->pTscObj = pSql->pTscObj;
pNew->signature = pNew;
+ pNew->rootObj = pSql->rootObj;
SSqlCmd* pCmd = &pNew->cmd;
pCmd->command = cmd;
@@ -3480,7 +3540,8 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
pNew->pTscObj = pSql->pTscObj;
pNew->signature = pNew;
- pNew->sqlstr = strdup(pSql->sqlstr);
+ pNew->sqlstr = strdup(pSql->sqlstr);
+ pNew->rootObj = pSql->rootObj;
tsem_init(&pNew->rspSem, 0, 0);
SSqlCmd* pnCmd = &pNew->cmd;
@@ -3532,8 +3593,10 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
pNewQueryInfo->numOfTables = 0;
pNewQueryInfo->pTableMetaInfo = NULL;
pNewQueryInfo->bufLen = pQueryInfo->bufLen;
-
pNewQueryInfo->buf = malloc(pQueryInfo->bufLen);
+ pNewQueryInfo->multigroupResult = pQueryInfo->multigroupResult;
+
+ pNewQueryInfo->distinct = pQueryInfo->distinct;
if (pNewQueryInfo->buf == NULL) {
terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
goto _error;
@@ -3744,8 +3807,7 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
int32_t index = ps->subqueryIndex;
bool ret = subAndCheckDone(pSql, pParentSql, index);
- tfree(ps);
- pSql->param = NULL;
+ tscFreeRetrieveSup(pSql);
if (!ret) {
tscDebug("0x%"PRIx64" sub:0x%"PRIx64" orderOfSub:%d completed, not all subquery finished", pParentSql->self, pSql->self, index);
@@ -3755,35 +3817,57 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
// todo refactor
tscDebug("0x%"PRIx64" all subquery response received, retry", pParentSql->self);
- SSqlCmd* pParentCmd = &pParentSql->cmd;
- STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pParentCmd, 0);
- tscRemoveTableMetaBuf(pTableMetaInfo, pParentSql->self);
+ SSqlObj *rootObj = pParentSql->rootObj;
+
+ if (code && !((code == TSDB_CODE_TDB_INVALID_TABLE_ID || code == TSDB_CODE_VND_INVALID_VGROUP_ID) && rootObj->retry < rootObj->maxRetry)) {
+ pParentSql->res.code = code;
+
+ tscAsyncResultOnError(pParentSql);
+ return;
+ }
+
+ tscFreeSubobj(pParentSql);
+ tfree(pParentSql->pSubs);
- pParentCmd->pTableMetaMap = tscCleanupTableMetaMap(pParentCmd->pTableMetaMap);
- pParentCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+ tscFreeSubobj(rootObj);
+ tfree(rootObj->pSubs);
- pParentSql->res.code = TSDB_CODE_SUCCESS;
- pParentSql->retry++;
+ rootObj->res.code = TSDB_CODE_SUCCESS;
+ rootObj->retry++;
- tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", pParentSql->self,
- tstrerror(code), pParentSql->retry);
+ tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", rootObj->self,
+ tstrerror(code), rootObj->retry);
- code = tsParseSql(pParentSql, true);
+
+ tscResetSqlCmd(&rootObj->cmd, true);
+
+ code = tsParseSql(rootObj, true);
if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
return;
}
if (code != TSDB_CODE_SUCCESS) {
- pParentSql->res.code = code;
- tscAsyncResultOnError(pParentSql);
+ rootObj->res.code = code;
+ tscAsyncResultOnError(rootObj);
return;
}
- SQueryInfo *pQueryInfo = tscGetQueryInfo(pParentCmd);
- executeQuery(pParentSql, pQueryInfo);
+ SQueryInfo *pQueryInfo = tscGetQueryInfo(&rootObj->cmd);
+
+ executeQuery(rootObj, pQueryInfo);
+ return;
+ }
+
+ if (pSql->cmd.command == TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
+ SSqlObj* pParentSql = ps->pParentSql;
+
+ pParentSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
+
+ (*pParentSql->fp)(pParentSql->param, pParentSql, 0);
return;
}
+
taos_fetch_rows_a(tres, tscSubqueryRetrieveCallback, param);
}
@@ -3802,9 +3886,11 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
}
if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) { // nest query. do execute it firstly
+ assert(pSql->subState.numOfSub == 0);
pSql->subState.numOfSub = (int32_t) taosArrayGetSize(pQueryInfo->pUpstream);
-
+ assert(pSql->pSubs == NULL);
pSql->pSubs = calloc(pSql->subState.numOfSub, POINTER_BYTES);
+ assert(pSql->subState.states == NULL);
pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(int8_t));
code = pthread_mutex_init(&pSql->subState.mutex, NULL);
@@ -3829,7 +3915,12 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
pNew->signature = pNew;
pNew->sqlstr = strdup(pSql->sqlstr);
pNew->fp = tscSubqueryCompleteCallback;
- pNew->maxRetry = pSql->maxRetry;
+ pNew->fetchFp = tscSubqueryCompleteCallback;
+ pNew->maxRetry = pSql->maxRetry;
+ pNew->rootObj = pSql->rootObj;
+
+ pNew->cmd.resColumnId = TSDB_RES_COL_ID;
+
tsem_init(&pNew->rspSem, 0, 0);
SRetrieveSupport* ps = calloc(1, sizeof(SRetrieveSupport)); // todo use object id
@@ -4006,6 +4097,31 @@ int32_t tscInvalidOperationMsg(char* msg, const char* additionalInfo, const char
return TSDB_CODE_TSC_INVALID_OPERATION;
}
+int32_t tscErrorMsgWithCode(int32_t code, char* dstBuffer, const char* errMsg, const char* sql) {
+ const char* msgFormat1 = "%s:%s";
+ const char* msgFormat2 = "%s:\'%s\' (%s)";
+ const char* msgFormat3 = "%s:\'%s\'";
+
+ const int32_t BACKWARD_CHAR_STEP = 0;
+
+ if (sql == NULL) {
+ assert(errMsg != NULL);
+ sprintf(dstBuffer, msgFormat1, tstrerror(code), errMsg);
+ return code;
+ }
+
+ char buf[64] = {0}; // only extract part of sql string
+ strncpy(buf, (sql - BACKWARD_CHAR_STEP), tListLen(buf) - 1);
+
+ if (errMsg != NULL) {
+ sprintf(dstBuffer, msgFormat2, tstrerror(code), buf, errMsg);
+ } else {
+ sprintf(dstBuffer, msgFormat3, tstrerror(code), buf); // no additional information for invalid sql error
+ }
+
+ return code;
+}
+
bool tscHasReachLimitation(SQueryInfo* pQueryInfo, SSqlRes* pRes) {
assert(pQueryInfo != NULL && pQueryInfo->clauseLimit != 0);
return (pQueryInfo->clauseLimit > 0 && pRes->numOfClauseTotal >= pQueryInfo->clauseLimit);
@@ -4364,8 +4480,11 @@ int32_t tscCreateTableMetaFromSTableMeta(STableMeta** ppChild, const char* name,
STableMeta* p = NULL;
size_t sz = 0;
STableMeta* pChild = *ppChild;
-
- taosHashGetCloneExt(tscTableMetaMap, pChild->sTableName, strnlen(pChild->sTableName, TSDB_TABLE_FNAME_LEN), NULL, (void **)&p, &sz);
+ STableMeta* pChild1;
+
+ if(NULL == taosHashGetCloneExt(tscTableMetaMap, pChild->sTableName, strnlen(pChild->sTableName, TSDB_TABLE_FNAME_LEN), NULL, (void **)&p, &sz)) {
+ tfree(p);
+ }
// tableMeta exists, build child table meta according to the super table meta
// the uid need to be checked in addition to the general name of the super table.
@@ -4374,7 +4493,10 @@ int32_t tscCreateTableMetaFromSTableMeta(STableMeta** ppChild, const char* name,
int32_t totalBytes = (p->tableInfo.numOfColumns + p->tableInfo.numOfTags) * sizeof(SSchema);
int32_t tableMetaSize = sizeof(STableMeta) + totalBytes;
if (*tableMetaCapacity < tableMetaSize) {
- pChild = realloc(pChild, tableMetaSize);
+ pChild1 = realloc(pChild, tableMetaSize);
+ if(pChild1 == NULL)
+ return -1;
+ pChild = pChild1;
*tableMetaCapacity = (size_t)tableMetaSize;
}
@@ -4646,6 +4768,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
pQueryAttr->distinct = pQueryInfo->distinct;
pQueryAttr->sw = pQueryInfo->sessionWindow;
pQueryAttr->stateWindow = pQueryInfo->stateWindow;
+ pQueryAttr->multigroupResult = pQueryInfo->multigroupResult;
pQueryAttr->numOfCols = numOfCols;
pQueryAttr->numOfOutput = numOfOutput;
@@ -4720,7 +4843,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
}
if (pQueryAttr->fillType != TSDB_FILL_NONE) {
- pQueryAttr->fillVal = calloc(pQueryAttr->numOfOutput, sizeof(int64_t));
+ pQueryAttr->fillVal = calloc(pQueryInfo->numOfFillVal, sizeof(int64_t));
memcpy(pQueryAttr->fillVal, pQueryInfo->fillVal, pQueryInfo->numOfFillVal * sizeof(int64_t));
}
@@ -4918,3 +5041,31 @@ void tscRemoveTableMetaBuf(STableMetaInfo* pTableMetaInfo, uint64_t id) {
taosHashRemove(tscTableMetaMap, fname, len);
tscDebug("0x%"PRIx64" remove table meta %s, numOfRemain:%d", id, fname, (int32_t) taosHashGetSize(tscTableMetaMap));
}
+
+char* cloneCurrentDBName(SSqlObj* pSql) {
+ char *p = NULL;
+ HttpContext *pCtx = NULL;
+
+ pthread_mutex_lock(&pSql->pTscObj->mutex);
+ STscObj *pTscObj = pSql->pTscObj;
+ switch (pTscObj->from) {
+ case TAOS_REQ_FROM_HTTP:
+ pCtx = pSql->param;
+ if (pCtx && pCtx->db[0] != '\0') {
+ char db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN] = {0};
+ int32_t len = sprintf(db, "%s%s%s", pTscObj->acctId, TS_PATH_DELIMITER, pCtx->db);
+ assert(len <= sizeof(db));
+
+ p = strdup(db);
+ }
+ break;
+ default:
+ break;
+ }
+ if (p == NULL) {
+ p = strdup(pSql->pTscObj->db);
+ }
+ pthread_mutex_unlock(&pSql->pTscObj->mutex);
+
+ return p;
+}
diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h
index 46259c8488617b77a940736d073454d4349a7774..a01c3775397e25849d9e8ff70409db7ac0af90ba 100644
--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -547,8 +547,9 @@ SKVRow tdGetKVRowFromBuilder(SKVRowBuilder *pBuilder);
static FORCE_INLINE int tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId, int8_t type, void *value) {
if (pBuilder->nCols >= pBuilder->tCols) {
pBuilder->tCols *= 2;
- pBuilder->pColIdx = (SColIdx *)realloc((void *)(pBuilder->pColIdx), sizeof(SColIdx) * pBuilder->tCols);
- if (pBuilder->pColIdx == NULL) return -1;
+ SColIdx* pColIdx = (SColIdx *)realloc((void *)(pBuilder->pColIdx), sizeof(SColIdx) * pBuilder->tCols);
+ if (pColIdx == NULL) return -1;
+ pBuilder->pColIdx = pColIdx;
}
pBuilder->pColIdx[pBuilder->nCols].colId = colId;
@@ -561,8 +562,9 @@ static FORCE_INLINE int tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId,
while (tlen > pBuilder->alloc - pBuilder->size) {
pBuilder->alloc *= 2;
}
- pBuilder->buf = realloc(pBuilder->buf, pBuilder->alloc);
- if (pBuilder->buf == NULL) return -1;
+ void* buf = realloc(pBuilder->buf, pBuilder->alloc);
+ if (buf == NULL) return -1;
+ pBuilder->buf = buf;
}
memcpy(POINTER_SHIFT(pBuilder->buf, pBuilder->size), value, tlen);
diff --git a/src/common/inc/tglobal.h b/src/common/inc/tglobal.h
index 7290db6ec978b85ad71ea744b7ea37c6488cb9fa..a384cf6e70485b8f7d1b06b7f7e86ba92776b547 100644
--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -59,6 +59,7 @@ extern char tsLocale[];
extern char tsCharset[]; // default encode string
extern int8_t tsEnableCoreFile;
extern int32_t tsCompressMsgSize;
+extern int32_t tsMaxNumOfDistinctResults;
extern char tsTempDir[];
//query buffer management
@@ -70,6 +71,7 @@ extern int8_t tsKeepOriginalColumnName;
// client
extern int32_t tsMaxSQLStringLen;
+extern int32_t tsMaxWildCardsLen;
extern int8_t tsTscEnableRecordSql;
extern int32_t tsMaxNumOfOrderedResults;
extern int32_t tsMinSlidingTime;
@@ -123,6 +125,7 @@ extern int32_t tsHttpMaxThreads;
extern int8_t tsHttpEnableCompress;
extern int8_t tsHttpEnableRecordSql;
extern int8_t tsTelegrafUseFieldNum;
+extern int8_t tsHttpDbNameMandatory;
// mqtt
extern int8_t tsEnableMqttModule;
@@ -156,6 +159,7 @@ extern char tsDataDir[];
extern char tsLogDir[];
extern char tsScriptDir[];
extern int64_t tsTickPerDay[3];
+extern int32_t tsTopicBianryLen;
// system info
extern char tsOsName[];
diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c
index a3a6c0fed40e053b33dd8c77a031ea9eabf00664..181afa225d9d8943c0e0d3b64d128decff1b34f2 100644
--- a/src/common/src/tdataformat.c
+++ b/src/common/src/tdataformat.c
@@ -138,8 +138,9 @@ int tdAddColToSchema(STSchemaBuilder *pBuilder, int8_t type, int16_t colId, int1
if (pBuilder->nCols >= pBuilder->tCols) {
pBuilder->tCols *= 2;
- pBuilder->columns = (STColumn *)realloc(pBuilder->columns, sizeof(STColumn) * pBuilder->tCols);
- if (pBuilder->columns == NULL) return -1;
+ STColumn* columns = (STColumn *)realloc(pBuilder->columns, sizeof(STColumn) * pBuilder->tCols);
+ if (columns == NULL) return -1;
+ pBuilder->columns = columns;
}
STColumn *pCol = &(pBuilder->columns[pBuilder->nCols]);
diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c
index a58303e9fc98a0dab30da1440c32cf03c5b1fa1e..e97f3a7338d0122b3b1aae6243d8a867f638de37 100644
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -25,6 +25,10 @@
#include "tutil.h"
#include "tlocale.h"
#include "ttimezone.h"
+#include "tcompare.h"
+
+// TSDB
+bool tsdbForceKeepFile = false;
// cluster
char tsFirst[TSDB_EP_LEN] = {0};
@@ -75,15 +79,19 @@ int32_t tsCompressMsgSize = -1;
// client
int32_t tsMaxSQLStringLen = TSDB_MAX_ALLOWED_SQL_LEN;
+int32_t tsMaxWildCardsLen = TSDB_PATTERN_STRING_DEFAULT_LEN;
int8_t tsTscEnableRecordSql = 0;
// the maximum number of results for projection query on super table that are returned from
// one virtual node, to order according to timestamp
-int32_t tsMaxNumOfOrderedResults = 100000;
+int32_t tsMaxNumOfOrderedResults = 1000000;
// 10 ms for sliding time, the value will changed in case of time precision changed
int32_t tsMinSlidingTime = 10;
+// the maxinum number of distict query result
+int32_t tsMaxNumOfDistinctResults = 1000 * 10000;
+
// 1 us for interval time range, changed accordingly
int32_t tsMinIntervalTime = 1;
@@ -157,6 +165,7 @@ int32_t tsHttpMaxThreads = 2;
int8_t tsHttpEnableCompress = 1;
int8_t tsHttpEnableRecordSql = 0;
int8_t tsTelegrafUseFieldNum = 0;
+int8_t tsHttpDbNameMandatory = 0;
// mqtt
int8_t tsEnableMqttModule = 0; // not finished yet, not started it by default
@@ -191,6 +200,7 @@ char tsScriptDir[PATH_MAX] = {0};
char tsTempDir[PATH_MAX] = "/tmp/";
int32_t tsDiskCfgNum = 0;
+int32_t tsTopicBianryLen = 16000;
#ifndef _STORAGE
SDiskCfg tsDiskCfg[1];
@@ -541,6 +551,16 @@ static void doInitGlobalConfig(void) {
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
+ cfg.option = "maxNumOfDistinctRes";
+ cfg.ptr = &tsMaxNumOfDistinctResults;
+ cfg.valType = TAOS_CFG_VTYPE_INT32;
+ cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW | TSDB_CFG_CTYPE_B_CLIENT;
+ cfg.minValue = 10*10000;
+ cfg.maxValue = 10000*10000;
+ cfg.ptrLength = 0;
+ cfg.unitType = TAOS_CFG_UTYPE_NONE;
+ taosInitConfigOption(cfg);
+
cfg.option = "numOfMnodes";
cfg.ptr = &tsNumOfMnodes;
cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -984,12 +1004,22 @@ static void doInitGlobalConfig(void) {
cfg.unitType = TAOS_CFG_UTYPE_BYTE;
taosInitConfigOption(cfg);
+ cfg.option = "maxWildCardsLength";
+ cfg.ptr = &tsMaxWildCardsLen;
+ cfg.valType = TAOS_CFG_VTYPE_INT32;
+ cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT | TSDB_CFG_CTYPE_B_SHOW;
+ cfg.minValue = 0;
+ cfg.maxValue = TSDB_MAX_FIELD_LEN;
+ cfg.ptrLength = 0;
+ cfg.unitType = TAOS_CFG_UTYPE_BYTE;
+ taosInitConfigOption(cfg);
+
cfg.option = "maxNumOfOrderedRes";
cfg.ptr = &tsMaxNumOfOrderedResults;
cfg.valType = TAOS_CFG_VTYPE_INT32;
cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT | TSDB_CFG_CTYPE_B_SHOW;
- cfg.minValue = TSDB_MAX_SQL_LEN;
- cfg.maxValue = TSDB_MAX_ALLOWED_SQL_LEN;
+ cfg.minValue = 100000;
+ cfg.maxValue = 100000000;
cfg.ptrLength = 0;
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
@@ -1188,6 +1218,16 @@ static void doInitGlobalConfig(void) {
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
+ cfg.option = "topicBinaryLen";
+ cfg.ptr = &tsTopicBianryLen;
+ cfg.valType = TAOS_CFG_VTYPE_INT32;
+ cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
+ cfg.minValue = 16;
+ cfg.maxValue = 16000;
+ cfg.ptrLength = 0;
+ cfg.unitType = TAOS_CFG_UTYPE_NONE;
+ taosInitConfigOption(cfg);
+
cfg.option = "httpEnableRecordSql";
cfg.ptr = &tsHttpEnableRecordSql;
cfg.valType = TAOS_CFG_VTYPE_INT8;
@@ -1228,6 +1268,16 @@ static void doInitGlobalConfig(void) {
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
+ cfg.option = "httpDbNameMandatory";
+ cfg.ptr = &tsHttpDbNameMandatory;
+ cfg.valType = TAOS_CFG_VTYPE_INT8;
+ cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
+ cfg.minValue = 0;
+ cfg.maxValue = 1;
+ cfg.ptrLength = 0;
+ cfg.unitType = TAOS_CFG_UTYPE_NONE;
+ taosInitConfigOption(cfg);
+
// debug flag
cfg.option = "numOfLogLines";
cfg.ptr = &tsNumOfLogLines;
@@ -1531,6 +1581,7 @@ static void doInitGlobalConfig(void) {
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
+ assert(tsGlobalConfigNum <= TSDB_CFG_MAX_NUM);
#ifdef TD_TSZ
// lossy compress
cfg.option = "lossyColumns";
diff --git a/src/common/src/ttypes.c b/src/common/src/ttypes.c
index eeffe49adc9e5efe97dde580584afad280ee2993..ee940531e6672e1c9b30a6db037d62bc8eac922b 100644
--- a/src/common/src/ttypes.c
+++ b/src/common/src/ttypes.c
@@ -38,11 +38,7 @@ const int32_t TYPE_BYTES[15] = {
#define DO_STATICS(__sum, __min, __max, __minIndex, __maxIndex, _list, _index) \
do { \
- if (_list[(_index)] >= (INT64_MAX - (__sum))) { \
- __sum = INT64_MAX; \
- } else { \
- (__sum) += (_list)[(_index)]; \
- } \
+ (__sum) += (_list)[(_index)]; \
if ((__min) > (_list)[(_index)]) { \
(__min) = (_list)[(_index)]; \
(__minIndex) = (_index); \
diff --git a/src/common/src/tvariant.c b/src/common/src/tvariant.c
index 9e0f7ffc7411ce5e2a5a81d0e58a67e231580d00..42ece19588d357ef551a4ecb9329dea246d2bae4 100644
--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -31,12 +31,12 @@ void tVariantCreate(tVariant *pVar, SStrToken *token) {
switch (token->type) {
case TSDB_DATA_TYPE_BOOL: {
- int32_t k = strncasecmp(token->z, "true", 4);
- if (k == 0) {
+ if (strncasecmp(token->z, "true", 4) == 0) {
pVar->i64 = TSDB_TRUE;
- } else {
- assert(strncasecmp(token->z, "false", 5) == 0);
+ } else if (strncasecmp(token->z, "false", 5) == 0) {
pVar->i64 = TSDB_FALSE;
+ } else {
+ return;
}
break;
diff --git a/src/connector/go b/src/connector/go
index b8f76da4a708d158ec3cc4b844571dc4414e36b4..050667e5b4d0eafa5387e4283e713559b421203f 160000
--- a/src/connector/go
+++ b/src/connector/go
@@ -1 +1 @@
-Subproject commit b8f76da4a708d158ec3cc4b844571dc4414e36b4
+Subproject commit 050667e5b4d0eafa5387e4283e713559b421203f
diff --git a/src/connector/grafanaplugin b/src/connector/grafanaplugin
index a44ec1ca493ad01b2bf825b6418f69e11f548206..32e2c97a4cf7bedaa99f5d6dd8cb036e7f4470df 160000
--- a/src/connector/grafanaplugin
+++ b/src/connector/grafanaplugin
@@ -1 +1 @@
-Subproject commit a44ec1ca493ad01b2bf825b6418f69e11f548206
+Subproject commit 32e2c97a4cf7bedaa99f5d6dd8cb036e7f4470df
diff --git a/src/connector/hivemq-tdengine-extension b/src/connector/hivemq-tdengine-extension
index ce5201014136503d34fecbd56494b67b4961056c..b62a26ecc164a310104df57691691b237e091c89 160000
--- a/src/connector/hivemq-tdengine-extension
+++ b/src/connector/hivemq-tdengine-extension
@@ -1 +1 @@
-Subproject commit ce5201014136503d34fecbd56494b67b4961056c
+Subproject commit b62a26ecc164a310104df57691691b237e091c89
diff --git a/src/connector/jdbc/pom.xml b/src/connector/jdbc/pom.xml
index fbeeeb56d30357294663a5ebf64608c57e066a7d..6b9fc9d96ce16700ee1243ef7c148a423a965d0b 100644
--- a/src/connector/jdbc/pom.xml
+++ b/src/connector/jdbc/pom.xml
@@ -117,7 +117,6 @@
**/DatetimeBefore1970Test.java
**/FailOverTest.java
**/InvalidResultSetPointerTest.java
- **/RestfulConnectionTest.java
**/TSDBJNIConnectorTest.java
**/TaosInfoMonitorTest.java
**/UnsignedNumberJniTest.java
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java
index 977ae665152fd1627cf25005061a4ca2aaa4e488..bdb3ea410005cadd865de1d9e080dd5b9f20834f 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java
@@ -40,13 +40,13 @@ public class TSDBError {
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_SUBSCRIBE_FAILED, "failed to create subscription");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_UNSUPPORTED_ENCODING, "Unsupported encoding");
- TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_TDENGINE_ERROR, "internal error of database");
+ TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_TDENGINE_ERROR, "internal error of database, please see taoslog for more details");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL, "JNI connection is NULL");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL, "JNI result set is NULL");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_NUM_OF_FIELDS_0, "invalid num of fields");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_SQL_NULL, "empty sql string");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_FETCH_END, "fetch to the end of resultSet");
- TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY, "JNI alloc memory failed");
+ TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY, "JNI alloc memory failed, please see taoslog for more details");
}
public static SQLException createSQLException(int errorCode) {
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 c634fe2e9503ff19afae85f285d921f330562612..4a9e80ba53b096f057840eab67e61418332dbf81 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
@@ -278,25 +278,20 @@ public class TSDBJNIConnector {
private native int validateCreateTableSqlImp(long connection, byte[] sqlBytes);
public long prepareStmt(String sql) throws SQLException {
- long stmt;
- try {
- stmt = prepareStmtImp(sql.getBytes(), this.taos);
- } catch (Exception e) {
- e.printStackTrace();
- throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_ENCODING);
- }
+ long stmt = prepareStmtImp(sql.getBytes(), this.taos);
if (stmt == TSDBConstants.JNI_CONNECTION_NULL) {
- throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL);
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL, "connection already closed");
}
-
if (stmt == TSDBConstants.JNI_SQL_NULL) {
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_SQL_NULL);
}
-
if (stmt == TSDBConstants.JNI_OUT_OF_MEMORY) {
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY);
}
+ if (stmt == TSDBConstants.JNI_TDENGINE_ERROR) {
+ throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_TDENGINE_ERROR);
+ }
return stmt;
}
@@ -313,8 +308,7 @@ public class TSDBJNIConnector {
private native int setBindTableNameImp(long stmt, String name, long conn);
public void setBindTableNameAndTags(long stmt, String tableName, int numOfTags, ByteBuffer tags, ByteBuffer typeList, ByteBuffer lengthList, ByteBuffer nullList) throws SQLException {
- int code = setTableNameTagsImp(stmt, tableName, numOfTags, tags.array(), typeList.array(), lengthList.array(),
- nullList.array(), this.taos);
+ int code = setTableNameTagsImp(stmt, tableName, numOfTags, tags.array(), typeList.array(), lengthList.array(), nullList.array(), this.taos);
if (code != TSDBConstants.JNI_SUCCESS) {
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "failed to bind table name and corresponding tags");
}
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java
index 6211f61dc505d2ccba5f11f3aacc980771b1a110..ff49677b01fa1c3a4d482cebd51269d5f1589e43 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java
@@ -32,6 +32,7 @@ import java.util.List;
import com.taosdata.jdbc.utils.NullType;
public class TSDBResultSetBlockData {
+ private static final int BINARY_LENGTH_OFFSET = 2;
private int numOfRows = 0;
private int rowIndex = 0;
@@ -404,10 +405,8 @@ public class TSDBResultSetBlockData {
case TSDBConstants.TSDB_DATA_TYPE_BINARY: {
ByteBuffer bb = (ByteBuffer) this.colData.get(col);
- bb.position(fieldSize * this.rowIndex);
-
+ bb.position((fieldSize + BINARY_LENGTH_OFFSET) * this.rowIndex);
int length = bb.getShort();
-
byte[] dest = new byte[length];
bb.get(dest, 0, length);
if (NullType.isBinaryNull(dest, length)) {
@@ -419,16 +418,13 @@ public class TSDBResultSetBlockData {
case TSDBConstants.TSDB_DATA_TYPE_NCHAR: {
ByteBuffer bb = (ByteBuffer) this.colData.get(col);
- bb.position(fieldSize * this.rowIndex);
-
+ bb.position((fieldSize + BINARY_LENGTH_OFFSET) * this.rowIndex);
int length = bb.getShort();
-
byte[] dest = new byte[length];
bb.get(dest, 0, length);
if (NullType.isNcharNull(dest, length)) {
return null;
}
-
try {
String charset = TaosGlobalConfig.getCharset();
return new String(dest, charset);
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
index 12a0ab57e2c35c7f1f550dd213db19a0effd4ebc..e818736096355c4937e5af0470b77c95486c86db 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
@@ -18,7 +18,7 @@ public class RestfulConnection extends AbstractConnection {
private final String url;
private final String database;
private final String token;
- /******************************************************/
+
private boolean isClosed;
private final DatabaseMetaData metadata;
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
index a88dc411f333fea82fa5310ee87f263b117f7e70..21c76f73b287e55ef14f5d70cf6a911a9cb543db 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
@@ -88,17 +88,24 @@ public class RestfulStatement extends AbstractStatement {
}
private String getUrl() throws SQLException {
+ String dbname = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_DBNAME);
+ if (dbname == null || dbname.trim().isEmpty()) {
+ dbname = "";
+ } else {
+ dbname = "/" + dbname.toLowerCase();
+ }
TimestampFormat timestampFormat = TimestampFormat.valueOf(conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT).trim().toUpperCase());
String url;
+
switch (timestampFormat) {
case TIMESTAMP:
- url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlt";
+ url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlt" + dbname;
break;
case UTC:
- url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlutc";
+ url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlutc" + dbname;
break;
default:
- url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
+ url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql" + dbname;
}
return url;
}
diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..18a2c32aca0535567dd42e886bc87ae618596a40
--- /dev/null
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java
@@ -0,0 +1,101 @@
+package com.taosdata.jdbc.cases;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.*;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class MultiConnectionWithDifferentDbTest {
+
+ private static String host = "127.0.0.1";
+ private static String db1 = "db1";
+ private static String db2 = "db2";
+
+ private long ts;
+
+ @Test
+ public void test() {
+ List threads = IntStream.range(1, 3).mapToObj(i -> new Thread(new Runnable() {
+ @Override
+ public void run() {
+ for (int j = 0; j < 10; j++) {
+ queryDb();
+ try {
+ TimeUnit.SECONDS.sleep(1);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ private void queryDb() {
+ String url = "jdbc:TAOS-RS://" + host + ":6041/db" + i + "?user=root&password=taosdata";
+ try (Connection connection = DriverManager.getConnection(url)) {
+ Statement stmt = connection.createStatement();
+
+ ResultSet rs = stmt.executeQuery("select * from weather");
+ assertNotNull(rs);
+ rs.next();
+ long actual = rs.getTimestamp("ts").getTime();
+ assertEquals(ts, actual);
+
+ int f1 = rs.getInt("f1");
+ assertEquals(i, f1);
+
+ String loc = i == 1 ? "beijing" : "shanghai";
+ String loc_actual = rs.getString("loc");
+ assertEquals(loc, loc_actual);
+
+ stmt.close();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+ }, "thread-" + i)).collect(Collectors.toList());
+
+ threads.forEach(Thread::start);
+
+ for (Thread t : threads) {
+ try {
+ t.join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ }
+
+ @Before
+ public void before() {
+ ts = System.currentTimeMillis();
+
+ try {
+ Connection conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata");
+
+ Statement stmt = conn.createStatement();
+ stmt.execute("drop database if exists " + db1);
+ stmt.execute("create database if not exists " + db1);
+ stmt.execute("use " + db1);
+ stmt.execute("create table weather(ts timestamp, f1 int) tags(loc nchar(10))");
+ stmt.execute("insert into t1 using weather tags('beijing') values(" + ts + ", 1)");
+
+ stmt.execute("drop database if exists " + db2);
+ stmt.execute("create database if not exists " + db2);
+ stmt.execute("use " + db2);
+ stmt.execute("create table weather(ts timestamp, f1 int) tags(loc nchar(10))");
+ stmt.execute("insert into t1 using weather tags('shanghai') values(" + ts + ", 2)");
+
+ conn.close();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+
+}
diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/DatabaseSpecifiedTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/DatabaseSpecifiedTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9fe51e7203fac7133783e47fd5b0cc07f33b2494
--- /dev/null
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/DatabaseSpecifiedTest.java
@@ -0,0 +1,69 @@
+package com.taosdata.jdbc.rs;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.*;
+
+import static org.junit.Assert.*;
+
+public class DatabaseSpecifiedTest {
+
+ private static String host = "127.0.0.1";
+ private static String dbname = "test_db_spec";
+
+ private Connection connection;
+ private long ts;
+
+ @Test
+ public void test() throws SQLException {
+ // when
+ connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/" + dbname + "?user=root&password=taosdata");
+ try (Statement stmt = connection.createStatement();) {
+ ResultSet rs = stmt.executeQuery("select * from weather");
+
+ //then
+ assertNotNull(rs);
+ rs.next();
+ long now = rs.getTimestamp("ts").getTime();
+ assertEquals(ts, now);
+ int f1 = rs.getInt(2);
+ assertEquals(1, f1);
+ String loc = rs.getString("loc");
+ assertEquals("beijing", loc);
+ }
+ connection.close();
+ }
+
+ @Before
+ public void before() {
+ ts = System.currentTimeMillis();
+ try {
+ Connection connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata");
+ Statement stmt = connection.createStatement();
+
+ stmt.execute("drop database if exists " + dbname);
+ stmt.execute("create database if not exists " + dbname);
+ stmt.execute("use " + dbname);
+ stmt.execute("create table weather(ts timestamp, f1 int) tags(loc nchar(10))");
+ stmt.execute("insert into t1 using weather tags('beijing') values( " + ts + ", 1)");
+
+ stmt.close();
+ connection.close();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+
+ @After
+ public void after() {
+ try {
+ if (connection != null)
+ connection.close();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+
+}
diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
index abd60f5b63d46b406f19b6be9dcbbab6b786de12..1c5c03aacb5e7ed5683c75414975224a67d49e21 100644
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
@@ -9,6 +9,8 @@ import org.junit.Test;
import java.sql.*;
import java.util.Properties;
+import static org.junit.Assert.assertEquals;
+
public class RestfulConnectionTest {
private static final String host = "127.0.0.1";
@@ -26,7 +28,7 @@ public class RestfulConnectionTest {
ResultSet rs = stmt.executeQuery("select server_status()");
rs.next();
int status = rs.getInt("server_status()");
- Assert.assertEquals(1, status);
+ assertEquals(1, status);
} catch (SQLException e) {
e.printStackTrace();
}
@@ -38,7 +40,7 @@ public class RestfulConnectionTest {
ResultSet rs = pstmt.executeQuery();
rs.next();
int status = rs.getInt("server_status()");
- Assert.assertEquals(1, status);
+ assertEquals(1, status);
}
@Test(expected = SQLFeatureNotSupportedException.class)
@@ -49,7 +51,7 @@ public class RestfulConnectionTest {
@Test
public void nativeSQL() throws SQLException {
String nativeSQL = conn.nativeSQL("select * from log.log");
- Assert.assertEquals("select * from log.log", nativeSQL);
+ assertEquals("select * from log.log", nativeSQL);
}
@Test
@@ -87,7 +89,7 @@ public class RestfulConnectionTest {
public void getMetaData() throws SQLException {
DatabaseMetaData meta = conn.getMetaData();
Assert.assertNotNull(meta);
- Assert.assertEquals("com.taosdata.jdbc.rs.RestfulDriver", meta.getDriverName());
+ assertEquals("com.taosdata.jdbc.rs.RestfulDriver", meta.getDriverName());
}
@Test
@@ -103,25 +105,25 @@ public class RestfulConnectionTest {
@Test
public void setCatalog() throws SQLException {
conn.setCatalog("test");
- Assert.assertEquals("test", conn.getCatalog());
+ assertEquals("test", conn.getCatalog());
}
@Test
public void getCatalog() throws SQLException {
conn.setCatalog("log");
- Assert.assertEquals("log", conn.getCatalog());
+ assertEquals("log", conn.getCatalog());
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setTransactionIsolation() throws SQLException {
conn.setTransactionIsolation(Connection.TRANSACTION_NONE);
- Assert.assertEquals(Connection.TRANSACTION_NONE, conn.getTransactionIsolation());
+ assertEquals(Connection.TRANSACTION_NONE, conn.getTransactionIsolation());
conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
}
@Test
public void getTransactionIsolation() throws SQLException {
- Assert.assertEquals(Connection.TRANSACTION_NONE, conn.getTransactionIsolation());
+ assertEquals(Connection.TRANSACTION_NONE, conn.getTransactionIsolation());
}
@Test
@@ -140,7 +142,7 @@ public class RestfulConnectionTest {
ResultSet rs = stmt.executeQuery("select server_status()");
rs.next();
int status = rs.getInt("server_status()");
- Assert.assertEquals(1, status);
+ assertEquals(1, status);
conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
}
@@ -152,7 +154,7 @@ public class RestfulConnectionTest {
ResultSet rs = pstmt.executeQuery();
rs.next();
int status = rs.getInt("server_status()");
- Assert.assertEquals(1, status);
+ assertEquals(1, status);
conn.prepareStatement("select server_status", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
}
@@ -175,13 +177,13 @@ public class RestfulConnectionTest {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setHoldability() throws SQLException {
conn.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
- Assert.assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, conn.getHoldability());
+ assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, conn.getHoldability());
conn.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
}
@Test
public void getHoldability() throws SQLException {
- Assert.assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, conn.getHoldability());
+ assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, conn.getHoldability());
}
@Test(expected = SQLFeatureNotSupportedException.class)
@@ -210,7 +212,7 @@ public class RestfulConnectionTest {
ResultSet rs = stmt.executeQuery("select server_status()");
rs.next();
int status = rs.getInt("server_status()");
- Assert.assertEquals(1, status);
+ assertEquals(1, status);
conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
}
@@ -222,7 +224,7 @@ public class RestfulConnectionTest {
ResultSet rs = pstmt.executeQuery();
rs.next();
int status = rs.getInt("server_status()");
- Assert.assertEquals(1, status);
+ assertEquals(1, status);
conn.prepareStatement("select server_status", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
}
@@ -299,11 +301,11 @@ public class RestfulConnectionTest {
Properties info = conn.getClientInfo();
String charset = info.getProperty(TSDBDriver.PROPERTY_KEY_CHARSET);
- Assert.assertEquals("UTF-8", charset);
+ assertEquals("UTF-8", charset);
String locale = info.getProperty(TSDBDriver.PROPERTY_KEY_LOCALE);
- Assert.assertEquals("en_US.UTF-8", locale);
+ assertEquals("en_US.UTF-8", locale);
String timezone = info.getProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE);
- Assert.assertEquals("UTC-8", timezone);
+ assertEquals("UTC-8", timezone);
}
@Test
@@ -313,11 +315,11 @@ public class RestfulConnectionTest {
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
String charset = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_CHARSET);
- Assert.assertEquals("UTF-8", charset);
+ assertEquals("UTF-8", charset);
String locale = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_LOCALE);
- Assert.assertEquals("en_US.UTF-8", locale);
+ assertEquals("en_US.UTF-8", locale);
String timezone = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIME_ZONE);
- Assert.assertEquals("UTC-8", timezone);
+ assertEquals("UTC-8", timezone);
}
@Test(expected = SQLFeatureNotSupportedException.class)
@@ -345,14 +347,15 @@ public class RestfulConnectionTest {
conn.abort(null);
}
- @Test(expected = SQLFeatureNotSupportedException.class)
+ @Test
public void setNetworkTimeout() throws SQLException {
conn.setNetworkTimeout(null, 1000);
}
- @Test(expected = SQLFeatureNotSupportedException.class)
+ @Test
public void getNetworkTimeout() throws SQLException {
- conn.getNetworkTimeout();
+ int timeout = conn.getNetworkTimeout();
+ assertEquals(0, timeout);
}
@Test
diff --git a/src/connector/nodejs/nodetaos/cinterface.js b/src/connector/nodejs/nodetaos/cinterface.js
index 03d27e5593ccb15d8ff47cd3c3dedba765d14fc1..5ba2739c35b1f0aef61ba3e52ae5d2f3a901df77 100644
--- a/src/connector/nodejs/nodetaos/cinterface.js
+++ b/src/connector/nodejs/nodetaos/cinterface.js
@@ -109,6 +109,24 @@ function convertDouble(data, num_of_rows, nbytes = 0, offset = 0, precision = 0)
return res;
}
+function convertBinary(data, num_of_rows, nbytes = 0, offset = 0, precision = 0) {
+ data = ref.reinterpret(data.deref(), nbytes * num_of_rows, offset);
+ let res = [];
+
+ let currOffset = 0;
+ while (currOffset < data.length) {
+ let len = data.readIntLE(currOffset, 2);
+ let dataEntry = data.slice(currOffset + 2, currOffset + len + 2); //one entry in a row under a column;
+ if (dataEntry[0] == 255) {
+ res.push(null)
+ } else {
+ res.push(dataEntry.toString("utf-8"));
+ }
+ currOffset += nbytes;
+ }
+ return res;
+}
+
function convertNchar(data, num_of_rows, nbytes = 0, offset = 0, precision = 0) {
data = ref.reinterpret(data.deref(), nbytes * num_of_rows, offset);
let res = [];
@@ -117,7 +135,11 @@ function convertNchar(data, num_of_rows, nbytes = 0, offset = 0, precision = 0)
while (currOffset < data.length) {
let len = data.readIntLE(currOffset, 2);
let dataEntry = data.slice(currOffset + 2, currOffset + len + 2); //one entry in a row under a column;
- res.push(dataEntry.toString("utf-8"));
+ if (dataEntry[0] == 255 && dataEntry[1] == 255) {
+ res.push(null)
+ } else {
+ res.push(dataEntry.toString("utf-8"));
+ }
currOffset += nbytes;
}
return res;
@@ -132,7 +154,7 @@ let convertFunctions = {
[FieldTypes.C_BIGINT]: convertBigint,
[FieldTypes.C_FLOAT]: convertFloat,
[FieldTypes.C_DOUBLE]: convertDouble,
- [FieldTypes.C_BINARY]: convertNchar,
+ [FieldTypes.C_BINARY]: convertBinary,
[FieldTypes.C_TIMESTAMP]: convertTimestamp,
[FieldTypes.C_NCHAR]: convertNchar
}
diff --git a/src/connector/nodejs/test/testnchar.js b/src/connector/nodejs/test/testnchar.js
new file mode 100644
index 0000000000000000000000000000000000000000..68fad89c22894ec358d55e9c03746fbd86ce0c99
--- /dev/null
+++ b/src/connector/nodejs/test/testnchar.js
@@ -0,0 +1,33 @@
+const taos = require('../tdengine');
+var conn = taos.connect({ host: "localhost" });
+var c1 = conn.cursor();
+
+
+function checkData(data, row, col, expect) {
+ let checkdata = data[row][col];
+ if (checkdata == expect) {
+ // console.log('check pass')
+ }
+ else {
+ console.log('check failed, expect ' + expect + ', but is ' + checkdata)
+ }
+}
+
+c1.execute('drop database if exists testnodejsnchar')
+c1.execute('create database testnodejsnchar')
+c1.execute('use testnodejsnchar');
+c1.execute('create table tb (ts timestamp, value float, text binary(200))')
+c1.execute("insert into tb values('2021-06-10 00:00:00', 24.7, '中文10000000000000000000000');") -
+c1.execute('insert into tb values(1623254400150, 24.7, NULL);')
+c1.execute('import into tb values(1623254400300, 24.7, "中文3中文10000000000000000000000中文10000000000000000000000中文10000000000000000000000中文10000000000000000000000");')
+sql = 'select * from tb;'
+
+console.log('*******************************************')
+
+c1.execute(sql);
+data = c1.fetchall();
+console.log(data)
+//check data about insert data
+checkData(data, 0, 2, '中文10000000000000000000000')
+checkData(data, 1, 2, null)
+checkData(data, 2, 2, '中文3中文10000000000000000000000中文10000000000000000000000中文10000000000000000000000中文10000000000000000000000')
\ No newline at end of file
diff --git a/src/connector/python/README.md b/src/connector/python/README.md
index a5dc2b72dafbeef0bf53fc1768f6afc66e714699..95ef26e1f0e73cee7d47ecb6ece1d6a95d2f89d3 100644
--- a/src/connector/python/README.md
+++ b/src/connector/python/README.md
@@ -1,6 +1,7 @@
# TDengine Connector for Python
-[TDengine] connector for Python enables python programs to access TDengine, using an API which is compliant with the Python DB API 2.0 (PEP-249). It uses TDengine C client library for client server communications.
+[TDengine](https://github.com/taosdata/TDengine) connector for Python enables python programs to access TDengine,
+ using an API which is compliant with the Python DB API 2.0 (PEP-249). It uses TDengine C client library for client server communications.
## Install
@@ -11,8 +12,417 @@ pip install ./TDengine/src/connector/python
## Source Code
-[TDengine] connector for Python source code is hosted on [GitHub](https://github.com/taosdata/TDengine/tree/develop/src/connector/python).
+[TDengine](https://github.com/taosdata/TDengine) connector for Python source code is hosted on [GitHub](https://github.com/taosdata/TDengine/tree/develop/src/connector/python).
-## License - AGPL
+## Examples
+
+### Query with PEP-249 API
+
+```python
+import taos
+
+conn = taos.connect()
+cursor = conn.cursor()
+
+cursor.execute("show databases")
+results = cursor.fetchall()
+for row in results:
+ print(row)
+cursor.close()
+conn.close()
+```
+
+### Query with objective API
+
+```python
+import taos
+
+conn = taos.connect()
+conn.exec("create database if not exists pytest")
+
+result = conn.query("show databases")
+num_of_fields = result.field_count
+for field in result.fields:
+ print(field)
+for row in result:
+ print(row)
+result.close()
+conn.exec("drop database pytest")
+conn.close()
+```
+
+### Query with async API
+
+```python
+from taos import *
+from ctypes import *
+import time
+
+def fetch_callback(p_param, p_result, num_of_rows):
+ print("fetched ", num_of_rows, "rows")
+ p = cast(p_param, POINTER(Counter))
+ result = TaosResult(p_result)
+
+ if num_of_rows == 0:
+ print("fetching completed")
+ p.contents.done = True
+ result.close()
+ return
+ if num_of_rows < 0:
+ p.contents.done = True
+ result.check_error(num_of_rows)
+ result.close()
+ return None
+
+ for row in result.rows_iter(num_of_rows):
+ # print(row)
+ None
+ p.contents.count += result.row_count
+ result.fetch_rows_a(fetch_callback, p_param)
+
+
+
+def query_callback(p_param, p_result, code):
+ # type: (c_void_p, c_void_p, c_int) -> None
+ if p_result == None:
+ return
+ result = TaosResult(p_result)
+ if code == 0:
+ result.fetch_rows_a(fetch_callback, p_param)
+ result.check_error(code)
+
+
+class Counter(Structure):
+ _fields_ = [("count", c_int), ("done", c_bool)]
+
+ def __str__(self):
+ return "{ count: %d, done: %s }" % (self.count, self.done)
+
+
+def test_query(conn):
+ # type: (TaosConnection) -> None
+ counter = Counter(count=0)
+ conn.query_a("select * from log.log", query_callback, byref(counter))
+
+ while not counter.done:
+ print("wait query callback")
+ time.sleep(1)
+ print(counter)
+ conn.close()
+
+
+if __name__ == "__main__":
+ test_query(connect())
+```
+
+### Statement API - Bind row after row
+
+```python
+from taos import *
+
+conn = connect()
+
+dbname = "pytest_taos_stmt"
+conn.exec("drop database if exists %s" % dbname)
+conn.exec("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+
+conn.exec(
+ "create table if not exists log(ts timestamp, bo bool, nil tinyint, \
+ ti tinyint, si smallint, ii int, bi bigint, tu tinyint unsigned, \
+ su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+ ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
+)
+
+stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+
+params = new_bind_params(16)
+params[0].timestamp(1626861392589)
+params[1].bool(True)
+params[2].null()
+params[3].tinyint(2)
+params[4].smallint(3)
+params[5].int(4)
+params[6].bigint(5)
+params[7].tinyint_unsigned(6)
+params[8].smallint_unsigned(7)
+params[9].int_unsigned(8)
+params[10].bigint_unsigned(9)
+params[11].float(10.1)
+params[12].double(10.11)
+params[13].binary("hello")
+params[14].nchar("stmt")
+params[15].timestamp(1626861392589)
+stmt.bind_param(params)
+
+params[0].timestamp(1626861392590)
+params[15].null()
+stmt.bind_param(params)
+stmt.execute()
+
+
+result = stmt.use_result()
+assert result.affected_rows == 2
+result.close()
+
+result = conn.query("select * from log")
+
+for row in result:
+ print(row)
+result.close()
+stmt.close()
+conn.close()
+
+```
+
+### Statement API - Bind multi rows
+
+```python
+from taos import *
+
+conn = connect()
+
+dbname = "pytest_taos_stmt"
+conn.exec("drop database if exists %s" % dbname)
+conn.exec("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+
+conn.exec(
+ "create table if not exists log(ts timestamp, bo bool, nil tinyint, \
+ ti tinyint, si smallint, ii int, bi bigint, tu tinyint unsigned, \
+ su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+ ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
+)
+
+stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+
+params = new_multi_binds(16)
+params[0].timestamp((1626861392589, 1626861392590, 1626861392591))
+params[1].bool((True, None, False))
+params[2].tinyint([-128, -128, None]) # -128 is tinyint null
+params[3].tinyint([0, 127, None])
+params[4].smallint([3, None, 2])
+params[5].int([3, 4, None])
+params[6].bigint([3, 4, None])
+params[7].tinyint_unsigned([3, 4, None])
+params[8].smallint_unsigned([3, 4, None])
+params[9].int_unsigned([3, 4, None])
+params[10].bigint_unsigned([3, 4, None])
+params[11].float([3, None, 1])
+params[12].double([3, None, 1.2])
+params[13].binary(["abc", "dddafadfadfadfadfa", None])
+params[14].nchar(["涛思数据", None, "a long string with 中文字符"])
+params[15].timestamp([None, None, 1626861392591])
+stmt.bind_param_batch(params)
+stmt.execute()
+
+
+result = stmt.use_result()
+assert result.affected_rows == 3
+result.close()
+
+result = conn.query("select * from log")
+for row in result:
+ print(row)
+result.close()
+stmt.close()
+conn.close()
+```
+
+### Statement API - Subscribe
+
+```python
+import taos
+
+conn = taos.connect()
+dbname = "pytest_taos_subscribe_callback"
+conn.exec("drop database if exists %s" % dbname)
+conn.exec("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+conn.exec("create table if not exists log(ts timestamp, n int)")
+for i in range(10):
+ conn.exec("insert into log values(now, %d)" % i)
+
+sub = conn.subscribe(True, "test", "select * from log", 1000)
+print("# consume from begin")
+for ts, n in sub.consume():
+ print(ts, n)
+
+print("# consume new data")
+for i in range(5):
+ conn.exec("insert into log values(now, %d)(now+1s, %d)" % (i, i))
+ result = sub.consume()
+ for ts, n in result:
+ print(ts, n)
+
+print("# consume with a stop condition")
+for i in range(10):
+ conn.exec("insert into log values(now, %d)" % int(random() * 10))
+ result = sub.consume()
+ try:
+ ts, n = next(result)
+ print(ts, n)
+ if n > 5:
+ result.stop_query()
+ print("## stopped")
+ break
+ except StopIteration:
+ continue
+
+sub.close()
+
+conn.exec("drop database if exists %s" % dbname)
+conn.close()
+```
+
+### Statement API - Subscribe asynchronously with callback
+
+```python
+from taos import *
+from ctypes import *
+
+import time
+
+
+def subscribe_callback(p_sub, p_result, p_param, errno):
+ # type: (c_void_p, c_void_p, c_void_p, c_int) -> None
+ print("# fetch in callback")
+ result = TaosResult(p_result)
+ result.check_error(errno)
+ for row in result.rows_iter():
+ ts, n = row()
+ print(ts, n)
+
+
+def test_subscribe_callback(conn):
+ # type: (TaosConnection) -> None
+ dbname = "pytest_taos_subscribe_callback"
+ try:
+ conn.exec("drop database if exists %s" % dbname)
+ conn.exec("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+ conn.exec("create table if not exists log(ts timestamp, n int)")
+
+ print("# subscribe with callback")
+ sub = conn.subscribe(False, "test", "select * from log", 1000, subscribe_callback)
+
+ for i in range(10):
+ conn.exec("insert into log values(now, %d)" % i)
+ time.sleep(0.7)
+ sub.close()
+
+ conn.exec("drop database if exists %s" % dbname)
+ conn.close()
+ except Exception as err:
+ conn.exec("drop database if exists %s" % dbname)
+ conn.close()
+ raise err
+
+
+if __name__ == "__main__":
+ test_subscribe_callback(connect())
+
+```
+
+### Statement API - Stream
+
+```python
+from taos import *
+from ctypes import *
+
+def stream_callback(p_param, p_result, p_row):
+ # type: (c_void_p, c_void_p, c_void_p) -> None
+
+ if p_result == None or p_row == None:
+ return
+ result = TaosResult(p_result)
+ row = TaosRow(result, p_row)
+ try:
+ ts, count = row()
+ p = cast(p_param, POINTER(Counter))
+ p.contents.count += count
+ print("[%s] inserted %d in 5s, total count: %d" % (ts.strftime("%Y-%m-%d %H:%M:%S"), count, p.contents.count))
+
+ except Exception as err:
+ print(err)
+ raise err
+
+
+class Counter(ctypes.Structure):
+ _fields_ = [
+ ("count", c_int),
+ ]
+
+ def __str__(self):
+ return "%d" % self.count
+
+
+def test_stream(conn):
+ # type: (TaosConnection) -> None
+ dbname = "pytest_taos_stream"
+ try:
+ conn.exec("drop database if exists %s" % dbname)
+ conn.exec("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+ conn.exec("create table if not exists log(ts timestamp, n int)")
+
+ result = conn.query("select count(*) from log interval(5s)")
+ assert result.field_count == 2
+ counter = Counter()
+ counter.count = 0
+ stream = conn.stream("select count(*) from log interval(5s)", stream_callback, param=byref(counter))
+
+ for _ in range(0, 20):
+ conn.exec("insert into log values(now,0)(now+1s, 1)(now + 2s, 2)")
+ time.sleep(2)
+ stream.close()
+ conn.exec("drop database if exists %s" % dbname)
+ conn.close()
+ except Exception as err:
+ conn.exec("drop database if exists %s" % dbname)
+ conn.close()
+ raise err
+
+
+if __name__ == "__main__":
+ test_stream(connect())
+```
+
+### Insert with line protocol
+
+```python
+import taos
+
+conn = taos.connect()
+dbname = "pytest_line"
+conn.exec("drop database if exists %s" % dbname)
+conn.exec("create database if not exists %s precision 'us'" % dbname)
+conn.select_db(dbname)
+
+lines = [
+ 'st,t1=3i64,t2=4f64,t3="t3" c1=3i64,c3=L"pass",c2=false,c4=4f64 1626006833639000000ns',
+ 'st,t1=4i64,t3="t4",t2=5f64,t4=5f64 c1=3i64,c3=L"pass it again",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns',
+ 'stf,t1=4i64,t3="t4",t2=5f64,t4=5f64 c1=3i64,c3=L"pass it again_stf",c2=false,c5=5f64,c6=7u64 1626006933641000000ns',
+]
+conn.insert_lines(lines)
+print("inserted")
+
+lines = [
+ 'stf,t1=5i64,t3="t4",t2=5f64,t4=5f64 c1=3i64,c3=L"pass it again_stf",c2=false,c5=5f64,c6=7u64 1626006933641000000ns',
+]
+conn.insert_lines(lines)
+
+result = conn.query("show tables")
+for row in result:
+ print(row)
+result.close()
+
+
+conn.exec("drop database if exists %s" % dbname)
+conn.close()
+
+```
+
+## License - AGPL-3.0
Keep same with [TDengine](https://github.com/taosdata/TDengine).
diff --git a/src/connector/python/examples/bind-multi.py b/src/connector/python/examples/bind-multi.py
new file mode 100644
index 0000000000000000000000000000000000000000..8530253aef58079e01f5eb71d8e12ab1649b7731
--- /dev/null
+++ b/src/connector/python/examples/bind-multi.py
@@ -0,0 +1,50 @@
+# encoding:UTF-8
+from taos import *
+
+conn = connect()
+
+dbname = "pytest_taos_stmt_multi"
+conn.execute("drop database if exists %s" % dbname)
+conn.execute("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+
+conn.execute(
+ "create table if not exists log(ts timestamp, bo bool, nil tinyint, \
+ ti tinyint, si smallint, ii int, bi bigint, tu tinyint unsigned, \
+ su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+ ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
+)
+
+stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+
+params = new_multi_binds(16)
+params[0].timestamp((1626861392589, 1626861392590, 1626861392591))
+params[1].bool((True, None, False))
+params[2].tinyint([-128, -128, None]) # -128 is tinyint null
+params[3].tinyint([0, 127, None])
+params[4].smallint([3, None, 2])
+params[5].int([3, 4, None])
+params[6].bigint([3, 4, None])
+params[7].tinyint_unsigned([3, 4, None])
+params[8].smallint_unsigned([3, 4, None])
+params[9].int_unsigned([3, 4, None])
+params[10].bigint_unsigned([3, 4, None])
+params[11].float([3, None, 1])
+params[12].double([3, None, 1.2])
+params[13].binary(["abc", "dddafadfadfadfadfa", None])
+params[14].nchar(["涛思数据", None, "a long string with 中文字符"])
+params[15].timestamp([None, None, 1626861392591])
+stmt.bind_param_batch(params)
+stmt.execute()
+
+
+result = stmt.use_result()
+assert result.affected_rows == 3
+result.close()
+
+result = conn.query("select * from log")
+for row in result:
+ print(row)
+result.close()
+stmt.close()
+conn.close()
\ No newline at end of file
diff --git a/src/connector/python/examples/bind-row.py b/src/connector/python/examples/bind-row.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ab9a9167ad23a6167c6586aac30ae6941dcee6d
--- /dev/null
+++ b/src/connector/python/examples/bind-row.py
@@ -0,0 +1,57 @@
+from taos import *
+
+conn = connect()
+
+dbname = "pytest_taos_stmt"
+conn.execute("drop database if exists %s" % dbname)
+conn.execute("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+
+conn.execute(
+ "create table if not exists log(ts timestamp, bo bool, nil tinyint, \
+ ti tinyint, si smallint, ii int, bi bigint, tu tinyint unsigned, \
+ su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+ ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
+)
+
+stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+
+params = new_bind_params(16)
+params[0].timestamp(1626861392589)
+params[1].bool(True)
+params[2].null()
+params[3].tinyint(2)
+params[4].smallint(3)
+params[5].int(4)
+params[6].bigint(5)
+params[7].tinyint_unsigned(6)
+params[8].smallint_unsigned(7)
+params[9].int_unsigned(8)
+params[10].bigint_unsigned(9)
+params[11].float(10.1)
+params[12].double(10.11)
+params[13].binary("hello")
+params[14].nchar("stmt")
+params[15].timestamp(1626861392589)
+stmt.bind_param(params)
+
+params[0].timestamp(1626861392590)
+params[15].null()
+stmt.bind_param(params)
+stmt.execute()
+
+
+result = stmt.use_result()
+assert result.affected_rows == 2
+# No need to explicitly close, but ok for you
+# result.close()
+
+result = conn.query("select * from log")
+
+for row in result:
+ print(row)
+
+# No need to explicitly close, but ok for you
+# result.close()
+# stmt.close()
+# conn.close()
diff --git a/src/connector/python/examples/demo.py b/src/connector/python/examples/demo.py
index 6c7c03f3e2c9630fab2af661d5c589066c21755f..3bc09046f3a33557e513425c06373c66958f2a2f 100644
--- a/src/connector/python/examples/demo.py
+++ b/src/connector/python/examples/demo.py
@@ -2,7 +2,7 @@ import taos
conn = taos.connect(host='127.0.0.1',
user='root',
- passworkd='taodata',
+ password='taosdata',
database='log')
cursor = conn.cursor()
diff --git a/src/connector/python/examples/insert-lines.py b/src/connector/python/examples/insert-lines.py
new file mode 100644
index 0000000000000000000000000000000000000000..0096b7e8cdf1328ee78805a1ee3134ad7cdfc447
--- /dev/null
+++ b/src/connector/python/examples/insert-lines.py
@@ -0,0 +1,22 @@
+import taos
+
+conn = taos.connect()
+dbname = "pytest_line"
+conn.execute("drop database if exists %s" % dbname)
+conn.execute("create database if not exists %s precision 'us'" % dbname)
+conn.select_db(dbname)
+
+lines = [
+ 'st,t1=3i64,t2=4f64,t3="t3" c1=3i64,c3=L"pass",c2=false,c4=4f64 1626006833639000000ns',
+]
+conn.insert_lines(lines)
+print("inserted")
+
+conn.insert_lines(lines)
+
+result = conn.query("show tables")
+for row in result:
+ print(row)
+
+
+conn.execute("drop database if exists %s" % dbname)
diff --git a/src/connector/python/examples/pep-249.py b/src/connector/python/examples/pep-249.py
new file mode 100644
index 0000000000000000000000000000000000000000..971a3c401f00b982096b8d429f65bce73cca4760
--- /dev/null
+++ b/src/connector/python/examples/pep-249.py
@@ -0,0 +1,9 @@
+import taos
+
+conn = taos.connect()
+cursor = conn.cursor()
+
+cursor.execute("show databases")
+results = cursor.fetchall()
+for row in results:
+ print(row)
diff --git a/src/connector/python/examples/query-async.py b/src/connector/python/examples/query-async.py
new file mode 100644
index 0000000000000000000000000000000000000000..b600b796974e47d5e5fc7d88998e95ba46bb92cd
--- /dev/null
+++ b/src/connector/python/examples/query-async.py
@@ -0,0 +1,62 @@
+from taos import *
+from ctypes import *
+import time
+
+def fetch_callback(p_param, p_result, num_of_rows):
+ print("fetched ", num_of_rows, "rows")
+ p = cast(p_param, POINTER(Counter))
+ result = TaosResult(p_result)
+
+ if num_of_rows == 0:
+ print("fetching completed")
+ p.contents.done = True
+ # should explicitly close the result in fetch completed or cause error
+ result.close()
+ return
+ if num_of_rows < 0:
+ p.contents.done = True
+ result.check_error(num_of_rows)
+ result.close()
+ return None
+
+ for row in result.rows_iter(num_of_rows):
+ # print(row)
+ None
+ p.contents.count += result.row_count
+ result.fetch_rows_a(fetch_callback, p_param)
+
+
+
+def query_callback(p_param, p_result, code):
+ # type: (c_void_p, c_void_p, c_int) -> None
+ if p_result == None:
+ return
+ result = TaosResult(p_result)
+ if code == 0:
+ result.fetch_rows_a(fetch_callback, p_param)
+ result.check_error(code)
+ # explicitly close result while query failed
+ result.close()
+
+
+class Counter(Structure):
+ _fields_ = [("count", c_int), ("done", c_bool)]
+
+ def __str__(self):
+ return "{ count: %d, done: %s }" % (self.count, self.done)
+
+
+def test_query(conn):
+ # type: (TaosConnection) -> None
+ counter = Counter(count=0)
+ conn.query_a("select * from log.log", query_callback, byref(counter))
+
+ while not counter.done:
+ print("wait query callback")
+ time.sleep(1)
+ print(counter)
+ # conn.close()
+
+
+if __name__ == "__main__":
+ test_query(connect())
\ No newline at end of file
diff --git a/src/connector/python/examples/query-objectively.py b/src/connector/python/examples/query-objectively.py
new file mode 100644
index 0000000000000000000000000000000000000000..104347cbf91e29e62fef26477b475053a8b8bc3e
--- /dev/null
+++ b/src/connector/python/examples/query-objectively.py
@@ -0,0 +1,12 @@
+import taos
+
+conn = taos.connect()
+conn.execute("create database if not exists pytest")
+
+result = conn.query("show databases")
+num_of_fields = result.field_count
+for field in result.fields:
+ print(field)
+for row in result:
+ print(row)
+conn.execute("drop database pytest")
diff --git a/src/connector/python/examples/subscribe-async.py b/src/connector/python/examples/subscribe-async.py
new file mode 100644
index 0000000000000000000000000000000000000000..3782ce5505152e78838406e313094eb911bea4a2
--- /dev/null
+++ b/src/connector/python/examples/subscribe-async.py
@@ -0,0 +1,43 @@
+from taos import *
+from ctypes import *
+
+import time
+
+
+def subscribe_callback(p_sub, p_result, p_param, errno):
+ # type: (c_void_p, c_void_p, c_void_p, c_int) -> None
+ print("# fetch in callback")
+ result = TaosResult(p_result)
+ result.check_error(errno)
+ for row in result.rows_iter():
+ ts, n = row()
+ print(ts, n)
+
+
+def test_subscribe_callback(conn):
+ # type: (TaosConnection) -> None
+ dbname = "pytest_taos_subscribe_callback"
+ try:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.execute("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+ conn.execute("create table if not exists log(ts timestamp, n int)")
+
+ print("# subscribe with callback")
+ sub = conn.subscribe(False, "test", "select * from log", 1000, subscribe_callback)
+
+ for i in range(10):
+ conn.execute("insert into log values(now, %d)" % i)
+ time.sleep(0.7)
+ # sub.close()
+
+ conn.execute("drop database if exists %s" % dbname)
+ # conn.close()
+ except Exception as err:
+ conn.execute("drop database if exists %s" % dbname)
+ # conn.close()
+ raise err
+
+
+if __name__ == "__main__":
+ test_subscribe_callback(connect())
diff --git a/src/connector/python/examples/subscribe-sync.py b/src/connector/python/examples/subscribe-sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a7f65f460280924ed3a577fe55b975fbf12c1a3
--- /dev/null
+++ b/src/connector/python/examples/subscribe-sync.py
@@ -0,0 +1,53 @@
+import taos
+import random
+
+conn = taos.connect()
+dbname = "pytest_taos_subscribe"
+conn.execute("drop database if exists %s" % dbname)
+conn.execute("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+conn.execute("create table if not exists log(ts timestamp, n int)")
+for i in range(10):
+ conn.execute("insert into log values(now, %d)" % i)
+
+sub = conn.subscribe(False, "test", "select * from log", 1000)
+print("# consume from begin")
+for ts, n in sub.consume():
+ print(ts, n)
+
+print("# consume new data")
+for i in range(5):
+ conn.execute("insert into log values(now, %d)(now+1s, %d)" % (i, i))
+ result = sub.consume()
+ for ts, n in result:
+ print(ts, n)
+
+sub.close(True)
+print("# keep progress consume")
+sub = conn.subscribe(False, "test", "select * from log", 1000)
+result = sub.consume()
+rows = result.fetch_all()
+# consume from latest subscription needs root privilege(for /var/lib/taos).
+assert result.row_count == 0
+print("## consumed ", len(rows), "rows")
+
+print("# consume with a stop condition")
+for i in range(10):
+ conn.execute("insert into log values(now, %d)" % random.randint(0, 10))
+ result = sub.consume()
+ try:
+ ts, n = next(result)
+ print(ts, n)
+ if n > 5:
+ result.stop_query()
+ print("## stopped")
+ break
+ except StopIteration:
+ continue
+
+sub.close()
+
+# sub.close()
+
+conn.execute("drop database if exists %s" % dbname)
+# conn.close()
diff --git a/src/connector/python/pyproject.toml b/src/connector/python/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a8099199563a0e5957a7d69e75bab65cca6d17db
--- /dev/null
+++ b/src/connector/python/pyproject.toml
@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "taos"
+version = "2.1.0"
+description = "TDengine connector for python"
+authors = ["Taosdata Inc. "]
+license = "AGPL-3.0"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^2.7 || ^3.4"
+typing = "*"
+
+[tool.poetry.dev-dependencies]
+pytest = [
+ { version = "^4.6", python = "^2.7" },
+ { version = "^6.2", python = "^3.7" }
+]
+pdoc = { version = "^7.1.1", python = "^3.7" }
+mypy = { version = "^0.910", python = "^3.6" }
+black = { version = "^21.7b0", python = "^3.6" }
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 119
diff --git a/src/connector/python/setup.py b/src/connector/python/setup.py
index 284861ca87dd77b1bc6799ad4cb32ff4c489e239..b7e10001737bc40c04173ea4a65e95248965ffda 100644
--- a/src/connector/python/setup.py
+++ b/src/connector/python/setup.py
@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
setuptools.setup(
name="taos",
- version="2.0.11",
+ version="2.1.0",
author="Taosdata Inc.",
author_email="support@taosdata.com",
description="TDengine python client package",
diff --git a/src/connector/python/taos/__init__.py b/src/connector/python/taos/__init__.py
index 52c6db311ecc4c2f944372ae3334fdc58cb6e779..75138eade3d60f7894d814babe58cec7aecc9a20 100644
--- a/src/connector/python/taos/__init__.py
+++ b/src/connector/python/taos/__init__.py
@@ -1,20 +1,478 @@
+# encoding:UTF-8
+"""
+# TDengine Connector for Python
-from .connection import TDengineConnection
-from .cursor import TDengineCursor
+[TDengine](https://github.com/taosdata/TDengine) connector for Python enables python programs to access TDengine,
+ using an API which is compliant with the Python DB API 2.0 (PEP-249). It uses TDengine C client library for client server communications.
-# For some reason, the following is needed for VS Code (through PyLance) to
+## Install
+
+```sh
+git clone --depth 1 https://github.com/taosdata/TDengine.git
+pip install ./TDengine/src/connector/python
+```
+
+## Source Code
+
+[TDengine](https://github.com/taosdata/TDengine) connector for Python source code is hosted on [GitHub](https://github.com/taosdata/TDengine/tree/develop/src/connector/python).
+
+## Examples
+
+### Query with PEP-249 API
+
+```python
+import taos
+
+conn = taos.connect()
+cursor = conn.cursor()
+
+cursor.execute("show databases")
+results = cursor.fetchall()
+for row in results:
+ print(row)
+cursor.close()
+conn.close()
+```
+
+### Query with objective API
+
+```python
+import taos
+
+conn = taos.connect()
+conn.exec("create database if not exists pytest")
+
+result = conn.query("show databases")
+num_of_fields = result.field_count
+for field in result.fields:
+ print(field)
+for row in result:
+ print(row)
+result.close()
+conn.exec("drop database pytest")
+conn.close()
+```
+
+### Query with async API
+
+```python
+from taos import *
+from ctypes import *
+import time
+
+def fetch_callback(p_param, p_result, num_of_rows):
+ print("fetched ", num_of_rows, "rows")
+ p = cast(p_param, POINTER(Counter))
+ result = TaosResult(p_result)
+
+ if num_of_rows == 0:
+ print("fetching completed")
+ p.contents.done = True
+ result.close()
+ return
+ if num_of_rows < 0:
+ p.contents.done = True
+ result.check_error(num_of_rows)
+ result.close()
+ return None
+
+ for row in result.rows_iter(num_of_rows):
+ # print(row)
+ None
+ p.contents.count += result.row_count
+ result.fetch_rows_a(fetch_callback, p_param)
+
+
+
+def query_callback(p_param, p_result, code):
+ # type: (c_void_p, c_void_p, c_int) -> None
+ if p_result == None:
+ return
+ result = TaosResult(p_result)
+ if code == 0:
+ result.fetch_rows_a(fetch_callback, p_param)
+ result.check_error(code)
+
+
+class Counter(Structure):
+ _fields_ = [("count", c_int), ("done", c_bool)]
+
+ def __str__(self):
+ return "{ count: %d, done: %s }" % (self.count, self.done)
+
+
+def test_query(conn):
+ # type: (TaosConnection) -> None
+ counter = Counter(count=0)
+ conn.query_a("select * from log.log", query_callback, byref(counter))
+
+ while not counter.done:
+ print("wait query callback")
+ time.sleep(1)
+ print(counter)
+ conn.close()
+
+
+if __name__ == "__main__":
+ test_query(connect())
+```
+
+### Statement API - Bind row after row
+
+```python
+from taos import *
+
+conn = connect()
+
+dbname = "pytest_taos_stmt"
+conn.exec("drop database if exists %s" % dbname)
+conn.exec("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+
+conn.exec(
+ "create table if not exists log(ts timestamp, bo bool, nil tinyint, \\
+ ti tinyint, si smallint, ii int, bi bigint, tu tinyint unsigned, \\
+ su smallint unsigned, iu int unsigned, bu bigint unsigned, \\
+ ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
+)
+
+stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+
+params = new_bind_params(16)
+params[0].timestamp(1626861392589)
+params[1].bool(True)
+params[2].null()
+params[3].tinyint(2)
+params[4].smallint(3)
+params[5].int(4)
+params[6].bigint(5)
+params[7].tinyint_unsigned(6)
+params[8].smallint_unsigned(7)
+params[9].int_unsigned(8)
+params[10].bigint_unsigned(9)
+params[11].float(10.1)
+params[12].double(10.11)
+params[13].binary("hello")
+params[14].nchar("stmt")
+params[15].timestamp(1626861392589)
+stmt.bind_param(params)
+
+params[0].timestamp(1626861392590)
+params[15].null()
+stmt.bind_param(params)
+stmt.execute()
+
+
+result = stmt.use_result()
+assert result.affected_rows == 2
+result.close()
+
+result = conn.query("select * from log")
+
+for row in result:
+ print(row)
+result.close()
+stmt.close()
+conn.close()
+
+```
+
+### Statement API - Bind multi rows
+
+```python
+from taos import *
+
+conn = connect()
+
+dbname = "pytest_taos_stmt"
+conn.exec("drop database if exists %s" % dbname)
+conn.exec("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+
+conn.exec(
+ "create table if not exists log(ts timestamp, bo bool, nil tinyint, \\
+ ti tinyint, si smallint, ii int, bi bigint, tu tinyint unsigned, \\
+ su smallint unsigned, iu int unsigned, bu bigint unsigned, \\
+ ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
+)
+
+stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+
+params = new_multi_binds(16)
+params[0].timestamp((1626861392589, 1626861392590, 1626861392591))
+params[1].bool((True, None, False))
+params[2].tinyint([-128, -128, None]) # -128 is tinyint null
+params[3].tinyint([0, 127, None])
+params[4].smallint([3, None, 2])
+params[5].int([3, 4, None])
+params[6].bigint([3, 4, None])
+params[7].tinyint_unsigned([3, 4, None])
+params[8].smallint_unsigned([3, 4, None])
+params[9].int_unsigned([3, 4, None])
+params[10].bigint_unsigned([3, 4, None])
+params[11].float([3, None, 1])
+params[12].double([3, None, 1.2])
+params[13].binary(["abc", "dddafadfadfadfadfa", None])
+params[14].nchar(["涛思数据", None, "a long string with 中文字符"])
+params[15].timestamp([None, None, 1626861392591])
+stmt.bind_param_batch(params)
+stmt.execute()
+
+
+result = stmt.use_result()
+assert result.affected_rows == 3
+result.close()
+
+result = conn.query("select * from log")
+for row in result:
+ print(row)
+result.close()
+stmt.close()
+conn.close()
+```
+
+### Statement API - Subscribe
+
+```python
+import taos
+
+conn = taos.connect()
+dbname = "pytest_taos_subscribe_callback"
+conn.exec("drop database if exists %s" % dbname)
+conn.exec("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+conn.exec("create table if not exists log(ts timestamp, n int)")
+for i in range(10):
+ conn.exec("insert into log values(now, %d)" % i)
+
+sub = conn.subscribe(True, "test", "select * from log", 1000)
+print("# consume from begin")
+for ts, n in sub.consume():
+ print(ts, n)
+
+print("# consume new data")
+for i in range(5):
+ conn.exec("insert into log values(now, %d)(now+1s, %d)" % (i, i))
+ result = sub.consume()
+ for ts, n in result:
+ print(ts, n)
+
+print("# consume with a stop condition")
+for i in range(10):
+ conn.exec("insert into log values(now, %d)" % int(random() * 10))
+ result = sub.consume()
+ try:
+ ts, n = next(result)
+ print(ts, n)
+ if n > 5:
+ result.stop_query()
+ print("## stopped")
+ break
+ except StopIteration:
+ continue
+
+sub.close()
+
+conn.exec("drop database if exists %s" % dbname)
+conn.close()
+```
+
+### Statement API - Subscribe asynchronously with callback
+
+```python
+from taos import *
+from ctypes import *
+
+import time
+
+
+def subscribe_callback(p_sub, p_result, p_param, errno):
+ # type: (c_void_p, c_void_p, c_void_p, c_int) -> None
+ print("# fetch in callback")
+ result = TaosResult(p_result)
+ result.check_error(errno)
+ for row in result.rows_iter():
+ ts, n = row()
+ print(ts, n)
+
+
+def test_subscribe_callback(conn):
+ # type: (TaosConnection) -> None
+ dbname = "pytest_taos_subscribe_callback"
+ try:
+ conn.exec("drop database if exists %s" % dbname)
+ conn.exec("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+ conn.exec("create table if not exists log(ts timestamp, n int)")
+
+ print("# subscribe with callback")
+ sub = conn.subscribe(False, "test", "select * from log", 1000, subscribe_callback)
+
+ for i in range(10):
+ conn.exec("insert into log values(now, %d)" % i)
+ time.sleep(0.7)
+ sub.close()
+
+ conn.exec("drop database if exists %s" % dbname)
+ conn.close()
+ except Exception as err:
+ conn.exec("drop database if exists %s" % dbname)
+ conn.close()
+ raise err
+
+
+if __name__ == "__main__":
+ test_subscribe_callback(connect())
+
+```
+
+### Statement API - Stream
+
+```python
+from taos import *
+from ctypes import *
+
+def stream_callback(p_param, p_result, p_row):
+ # type: (c_void_p, c_void_p, c_void_p) -> None
+
+ if p_result == None or p_row == None:
+ return
+ result = TaosResult(p_result)
+ row = TaosRow(result, p_row)
+ try:
+ ts, count = row()
+ p = cast(p_param, POINTER(Counter))
+ p.contents.count += count
+ print("[%s] inserted %d in 5s, total count: %d" % (ts.strftime("%Y-%m-%d %H:%M:%S"), count, p.contents.count))
+
+ except Exception as err:
+ print(err)
+ raise err
+
+
+class Counter(ctypes.Structure):
+ _fields_ = [
+ ("count", c_int),
+ ]
+
+ def __str__(self):
+ return "%d" % self.count
+
+
+def test_stream(conn):
+ # type: (TaosConnection) -> None
+ dbname = "pytest_taos_stream"
+ try:
+ conn.exec("drop database if exists %s" % dbname)
+ conn.exec("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+ conn.exec("create table if not exists log(ts timestamp, n int)")
+
+ result = conn.query("select count(*) from log interval(5s)")
+ assert result.field_count == 2
+ counter = Counter()
+ counter.count = 0
+ stream = conn.stream("select count(*) from log interval(5s)", stream_callback, param=byref(counter))
+
+ for _ in range(0, 20):
+ conn.exec("insert into log values(now,0)(now+1s, 1)(now + 2s, 2)")
+ time.sleep(2)
+ stream.close()
+ conn.exec("drop database if exists %s" % dbname)
+ conn.close()
+ except Exception as err:
+ conn.exec("drop database if exists %s" % dbname)
+ conn.close()
+ raise err
+
+
+if __name__ == "__main__":
+ test_stream(connect())
+```
+
+### Insert with line protocol
+
+```python
+import taos
+
+conn = taos.connect()
+dbname = "pytest_line"
+conn.exec("drop database if exists %s" % dbname)
+conn.exec("create database if not exists %s precision 'us'" % dbname)
+conn.select_db(dbname)
+
+lines = [
+ 'st,t1=3i64,t2=4f64,t3="t3" c1=3i64,c3=L"passit",c2=false,c4=4f64 1626006833639000000ns',
+ 'st,t1=4i64,t3="t4",t2=5f64,t4=5f64 c1=3i64,c3=L"passitagin",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns',
+ 'stf,t1=4i64,t3="t4",t2=5f64,t4=5f64 c1=3i64,c3=L"passitagin_stf",c2=false,c5=5f64,c6=7u64 1626006933641000000ns',
+]
+conn.insert_lines(lines)
+print("inserted")
+
+lines = [
+ 'stf,t1=5i64,t3="t4",t2=5f64,t4=5f64 c1=3i64,c3=L"passitagin_stf",c2=false,c5=5f64,c6=7u64 1626006933641000000ns',
+]
+conn.insert_lines(lines)
+
+result = conn.query("show tables")
+for row in result:
+ print(row)
+result.close()
+
+
+conn.exec("drop database if exists %s" % dbname)
+conn.close()
+
+```
+
+## License - AGPL-3.0
+
+Keep same with [TDengine](https://github.com/taosdata/TDengine).
+"""
+from .connection import TaosConnection
+
+# For some reason, the following is needed for VS Code (through PyLance) to
# recognize that "error" is a valid module of the "taos" package.
-from .error import ProgrammingError
+from .error import *
+from .bind import *
+from .field import *
+from .cursor import *
+from .result import *
+from .statement import *
+from .subscription import *
+
+try:
+ import importlib.metadata
+
+ __version__ = importlib.metadata.version("taos")
+except:
+ None
# Globals
threadsafety = 0
-paramstyle = 'pyformat'
-
-__all__ = ['connection', 'cursor']
+paramstyle = "pyformat"
+__all__ = [
+ # functions
+ "connect",
+ "new_bind_param",
+ "new_bind_params",
+ "new_multi_binds",
+ "new_multi_bind",
+ # objects
+ "TaosBind",
+ "TaosConnection",
+ "TaosCursor",
+ "TaosResult",
+ "TaosRows",
+ "TaosRow",
+ "TaosStmt",
+ "PrecisionEnum",
+]
def connect(*args, **kwargs):
- """ Function to return a TDengine connector object
+ # type: (..., ...) -> TaosConnection
+ """Function to return a TDengine connector object
Current supporting keyword parameters:
@dsn: Data source name as string
@@ -25,4 +483,4 @@ def connect(*args, **kwargs):
@rtype: TDengineConnector
"""
- return TDengineConnection(*args, **kwargs)
+ return TaosConnection(*args, **kwargs)
diff --git a/src/connector/python/taos/bind.py b/src/connector/python/taos/bind.py
new file mode 100644
index 0000000000000000000000000000000000000000..083ddc99aea8dc6f39b1f22ac5f77d2584a2fe69
--- /dev/null
+++ b/src/connector/python/taos/bind.py
@@ -0,0 +1,437 @@
+# encoding:UTF-8
+import ctypes
+from .constants import FieldType
+from .error import *
+from .precision import *
+from datetime import datetime
+from ctypes import *
+import sys
+
+_datetime_epoch = datetime.utcfromtimestamp(0)
+
+def _is_not_none(obj):
+ return obj != None
+
+class TaosBind(ctypes.Structure):
+ _fields_ = [
+ ("buffer_type", c_int),
+ ("buffer", c_void_p),
+ ("buffer_length", c_size_t),
+ ("length", POINTER(c_size_t)),
+ ("is_null", POINTER(c_int)),
+ ("is_unsigned", c_int),
+ ("error", POINTER(c_int)),
+ ("u", c_int64),
+ ("allocated", c_int),
+ ]
+
+ def null(self):
+ self.buffer_type = FieldType.C_NULL
+ self.is_null = pointer(c_int(1))
+
+ def bool(self, value):
+ self.buffer_type = FieldType.C_BOOL
+ self.buffer = cast(pointer(c_bool(value)), c_void_p)
+ self.buffer_length = sizeof(c_bool)
+
+ def tinyint(self, value):
+ self.buffer_type = FieldType.C_TINYINT
+ self.buffer = cast(pointer(c_int8(value)), c_void_p)
+ self.buffer_length = sizeof(c_int8)
+
+ def smallint(self, value):
+ self.buffer_type = FieldType.C_SMALLINT
+ self.buffer = cast(pointer(c_int16(value)), c_void_p)
+ self.buffer_length = sizeof(c_int16)
+
+ def int(self, value):
+ self.buffer_type = FieldType.C_INT
+ self.buffer = cast(pointer(c_int32(value)), c_void_p)
+ self.buffer_length = sizeof(c_int32)
+
+ def bigint(self, value):
+ self.buffer_type = FieldType.C_BIGINT
+ self.buffer = cast(pointer(c_int64(value)), c_void_p)
+ self.buffer_length = sizeof(c_int64)
+
+ def float(self, value):
+ self.buffer_type = FieldType.C_FLOAT
+ self.buffer = cast(pointer(c_float(value)), c_void_p)
+ self.buffer_length = sizeof(c_float)
+
+ def double(self, value):
+ self.buffer_type = FieldType.C_DOUBLE
+ self.buffer = cast(pointer(c_double(value)), c_void_p)
+ self.buffer_length = sizeof(c_double)
+
+ def binary(self, value):
+ buffer = None
+ length = 0
+ if isinstance(value, str):
+ bytes = value.encode("utf-8")
+ buffer = create_string_buffer(bytes)
+ length = len(bytes)
+ else:
+ buffer = value
+ length = len(value)
+ self.buffer_type = FieldType.C_BINARY
+ self.buffer = cast(buffer, c_void_p)
+ self.buffer_length = length
+ self.length = pointer(c_size_t(self.buffer_length))
+
+ def timestamp(self, value, precision=PrecisionEnum.Milliseconds):
+ if type(value) is datetime:
+ if precision == PrecisionEnum.Milliseconds:
+ ts = int(round((value - _datetime_epoch).total_seconds() * 1000))
+ elif precision == PrecisionEnum.Microseconds:
+ ts = int(round((value - _datetime_epoch).total_seconds() * 10000000))
+ else:
+ raise PrecisionError("datetime do not support nanosecond precision")
+ elif type(value) is float:
+ if precision == PrecisionEnum.Milliseconds:
+ ts = int(round(value * 1000))
+ elif precision == PrecisionEnum.Microseconds:
+ ts = int(round(value * 10000000))
+ else:
+ raise PrecisionError("time float do not support nanosecond precision")
+ elif isinstance(value, int) and not isinstance(value, bool):
+ ts = value
+ elif isinstance(value, str):
+ value = datetime.fromisoformat(value)
+ if precision == PrecisionEnum.Milliseconds:
+ ts = int(round(value * 1000))
+ elif precision == PrecisionEnum.Microseconds:
+ ts = int(round(value * 10000000))
+ else:
+ raise PrecisionError("datetime do not support nanosecond precision")
+
+ self.buffer_type = FieldType.C_TIMESTAMP
+ self.buffer = cast(pointer(c_int64(ts)), c_void_p)
+ self.buffer_length = sizeof(c_int64)
+
+ def nchar(self, value):
+ buffer = None
+ length = 0
+ if isinstance(value, str):
+ bytes = value.encode("utf-8")
+ buffer = create_string_buffer(bytes)
+ length = len(bytes)
+ else:
+ buffer = value
+ length = len(value)
+ self.buffer_type = FieldType.C_NCHAR
+ self.buffer = cast(buffer, c_void_p)
+ self.buffer_length = length
+ self.length = pointer(c_size_t(self.buffer_length))
+
+ def tinyint_unsigned(self, value):
+ self.buffer_type = FieldType.C_TINYINT_UNSIGNED
+ self.buffer = cast(pointer(c_uint8(value)), c_void_p)
+ self.buffer_length = sizeof(c_uint8)
+
+ def smallint_unsigned(self, value):
+ self.buffer_type = FieldType.C_SMALLINT_UNSIGNED
+ self.buffer = cast(pointer(c_uint16(value)), c_void_p)
+ self.buffer_length = sizeof(c_uint16)
+
+ def int_unsigned(self, value):
+ self.buffer_type = FieldType.C_INT_UNSIGNED
+ self.buffer = cast(pointer(c_uint32(value)), c_void_p)
+ self.buffer_length = sizeof(c_uint32)
+
+ def bigint_unsigned(self, value):
+ self.buffer_type = FieldType.C_BIGINT_UNSIGNED
+ self.buffer = cast(pointer(c_uint64(value)), c_void_p)
+ self.buffer_length = sizeof(c_uint64)
+
+
+def _datetime_to_timestamp(value, precision):
+ # type: (datetime | float | int | str | c_int64, PrecisionEnum) -> c_int64
+ if value is None:
+ return FieldType.C_BIGINT_NULL
+ if type(value) is datetime:
+ if precision == PrecisionEnum.Milliseconds:
+ return int(round((value - _datetime_epoch).total_seconds() * 1000))
+ elif precision == PrecisionEnum.Microseconds:
+ return int(round((value - _datetime_epoch).total_seconds() * 10000000))
+ else:
+ raise PrecisionError("datetime do not support nanosecond precision")
+ elif type(value) is float:
+ if precision == PrecisionEnum.Milliseconds:
+ return int(round(value * 1000))
+ elif precision == PrecisionEnum.Microseconds:
+ return int(round(value * 10000000))
+ else:
+ raise PrecisionError("time float do not support nanosecond precision")
+ elif isinstance(value, int) and not isinstance(value, bool):
+ return c_int64(value)
+ elif isinstance(value, str):
+ value = datetime.fromisoformat(value)
+ if precision == PrecisionEnum.Milliseconds:
+ return int(round(value * 1000))
+ elif precision == PrecisionEnum.Microseconds:
+ return int(round(value * 10000000))
+ else:
+ raise PrecisionError("datetime do not support nanosecond precision")
+ elif isinstance(value, c_int64):
+ return value
+ return FieldType.C_BIGINT_NULL
+
+
+class TaosMultiBind(ctypes.Structure):
+ _fields_ = [
+ ("buffer_type", c_int),
+ ("buffer", c_void_p),
+ ("buffer_length", c_size_t),
+ ("length", POINTER(c_int32)),
+ ("is_null", c_char_p),
+ ("num", c_int),
+ ]
+
+ def null(self, num):
+ self.buffer_type = FieldType.C_NULL
+ self.is_null = cast((c_char * num)(*[1 for _ in range(num)]), c_char_p)
+ self.buffer = c_void_p(None)
+ self.num = num
+
+ def bool(self, values):
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_int8 * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_BOOL_NULL for v in values])
+
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+ self.buffer_type = FieldType.C_BOOL
+ self.buffer_length = sizeof(c_bool)
+
+ def tinyint(self, values):
+ self.buffer_type = FieldType.C_TINYINT
+ self.buffer_length = sizeof(c_int8)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_int8 * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_TINYINT_NULL for v in values])
+
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+ def smallint(self, values):
+ self.buffer_type = FieldType.C_SMALLINT
+ self.buffer_length = sizeof(c_int16)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_int16 * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_SMALLINT_NULL for v in values])
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+ def int(self, values):
+ self.buffer_type = FieldType.C_INT
+ self.buffer_length = sizeof(c_int32)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_int32 * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_INT_NULL for v in values])
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+ def bigint(self, values):
+ self.buffer_type = FieldType.C_BIGINT
+ self.buffer_length = sizeof(c_int64)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_int64 * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_BIGINT_NULL for v in values])
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+ def float(self, values):
+ self.buffer_type = FieldType.C_FLOAT
+ self.buffer_length = sizeof(c_float)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_float * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_FLOAT_NULL for v in values])
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+ def double(self, values):
+ self.buffer_type = FieldType.C_DOUBLE
+ self.buffer_length = sizeof(c_double)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_double * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_DOUBLE_NULL for v in values])
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+ def _str_to_buffer(self, values):
+ self.num = len(values)
+ is_null = [1 if v == None else 0 for v in values]
+ self.is_null = cast((c_byte * self.num)(*is_null), c_char_p)
+
+ if sum(is_null) == self.num:
+ self.length = (c_int32 * len(values))(0 * self.num)
+ return
+ if sys.version_info < (3, 0):
+ _bytes = [bytes(value) if value is not None else None for value in values]
+ buffer_length = max(len(b) + 1 for b in _bytes if b is not None)
+ buffers = [
+ create_string_buffer(b, buffer_length) if b is not None else create_string_buffer(buffer_length)
+ for b in _bytes
+ ]
+ buffer_all = b''.join(v[:] for v in buffers)
+ self.buffer = cast(c_char_p(buffer_all), c_void_p)
+ else:
+ _bytes = [value.encode("utf-8") if value is not None else None for value in values]
+ buffer_length = max(len(b) for b in _bytes if b is not None)
+ self.buffer = cast(
+ c_char_p(
+ b"".join(
+ [
+ create_string_buffer(b, buffer_length)
+ if b is not None
+ else create_string_buffer(buffer_length)
+ for b in _bytes
+ ]
+ )
+ ),
+ c_void_p,
+ )
+ self.length = (c_int32 * len(values))(*[len(b) if b is not None else 0 for b in _bytes])
+ self.buffer_length = buffer_length
+ def binary(self, values):
+ self.buffer_type = FieldType.C_BINARY
+ self._str_to_buffer(values)
+
+ def timestamp(self, values, precision=PrecisionEnum.Milliseconds):
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_int64 * len(values)
+ buffer = buffer_type(*[_datetime_to_timestamp(value, precision) for value in values])
+
+ self.buffer_type = FieldType.C_TIMESTAMP
+ self.buffer = cast(buffer, c_void_p)
+ self.buffer_length = sizeof(c_int64)
+ self.num = len(values)
+
+ def nchar(self, values):
+ # type: (list[str]) -> None
+ self.buffer_type = FieldType.C_NCHAR
+ self._str_to_buffer(values)
+
+ def tinyint_unsigned(self, values):
+ self.buffer_type = FieldType.C_TINYINT_UNSIGNED
+ self.buffer_length = sizeof(c_uint8)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_uint8 * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_TINYINT_UNSIGNED_NULL for v in values])
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+ def smallint_unsigned(self, values):
+ self.buffer_type = FieldType.C_SMALLINT_UNSIGNED
+ self.buffer_length = sizeof(c_uint16)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_uint16 * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_SMALLINT_UNSIGNED_NULL for v in values])
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+ def int_unsigned(self, values):
+ self.buffer_type = FieldType.C_INT_UNSIGNED
+ self.buffer_length = sizeof(c_uint32)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_uint32 * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_INT_UNSIGNED_NULL for v in values])
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+ def bigint_unsigned(self, values):
+ self.buffer_type = FieldType.C_BIGINT_UNSIGNED
+ self.buffer_length = sizeof(c_uint64)
+
+ try:
+ buffer = cast(values, c_void_p)
+ except:
+ buffer_type = c_uint64 * len(values)
+ try:
+ buffer = buffer_type(*values)
+ except:
+ buffer = buffer_type(*[v if v is not None else FieldType.C_BIGINT_UNSIGNED_NULL for v in values])
+ self.buffer = cast(buffer, c_void_p)
+ self.num = len(values)
+
+
+def new_bind_param():
+ # type: () -> TaosBind
+ return TaosBind()
+
+
+def new_bind_params(size):
+ # type: (int) -> Array[TaosBind]
+ return (TaosBind * size)()
+
+
+def new_multi_bind():
+ # type: () -> TaosMultiBind
+ return TaosMultiBind()
+
+
+def new_multi_binds(size):
+ # type: (int) -> Array[TaosMultiBind]
+ return (TaosMultiBind * size)()
diff --git a/src/connector/python/taos/cinterface.py b/src/connector/python/taos/cinterface.py
index 660707bfcd04edb9d815b38d8ae806f35d2bfe2b..a1b6fe312b5725b8bf030701608d93c3e0c85706 100644
--- a/src/connector/python/taos/cinterface.py
+++ b/src/connector/python/taos/cinterface.py
@@ -1,295 +1,836 @@
+# encoding:UTF-8
+
import ctypes
-from .constants import FieldType
-from .error import *
-import math
-import datetime
import platform
+import sys
+from ctypes import *
+try:
+ from typing import Any
+except:
+ pass
+
+from .error import *
+from .bind import *
+from .field import *
+
+
+# stream callback
+stream_callback_type = CFUNCTYPE(None, c_void_p, c_void_p, c_void_p)
+stream_callback2_type = CFUNCTYPE(None, c_void_p)
+
+# C interface class
+class TaosOption:
+ Locale = (0,)
+ Charset = (1,)
+ Timezone = (2,)
+ ConfigDir = (3,)
+ ShellActivityTimer = (4,)
+ MaxOptions = (5,)
+
+
+def _load_taos_linux():
+ return ctypes.CDLL("libtaos.so")
+
+
+def _load_taos_darwin():
+ return ctypes.CDLL("libtaos.dylib")
+
+
+def _load_taos_windows():
+ return ctypes.windll.LoadLibrary("taos")
-def _convert_millisecond_to_datetime(milli):
- return datetime.datetime.fromtimestamp(0) + datetime.timedelta(seconds=milli/1000.0)
+def _load_taos():
+ load_func = {
+ "Linux": _load_taos_linux,
+ "Darwin": _load_taos_darwin,
+ "Windows": _load_taos_windows,
+ }
+ try:
+ return load_func[platform.system()]()
+ except:
+ raise InterfaceError('unsupported platform or failed to load taos client library')
-def _convert_microsecond_to_datetime(micro):
- return datetime.datetime.fromtimestamp(0) + datetime.timedelta(seconds=micro / 1000000.0)
+_libtaos = _load_taos()
+_libtaos.taos_fetch_fields.restype = ctypes.POINTER(TaosField)
+_libtaos.taos_init.restype = None
+_libtaos.taos_connect.restype = ctypes.c_void_p
+_libtaos.taos_fetch_row.restype = ctypes.POINTER(ctypes.c_void_p)
+_libtaos.taos_errstr.restype = ctypes.c_char_p
+_libtaos.taos_subscribe.restype = ctypes.c_void_p
+_libtaos.taos_consume.restype = ctypes.c_void_p
+_libtaos.taos_fetch_lengths.restype = ctypes.POINTER(ctypes.c_int)
+_libtaos.taos_free_result.restype = None
+_libtaos.taos_query.restype = ctypes.POINTER(ctypes.c_void_p)
+try:
+ _libtaos.taos_stmt_errstr.restype = c_char_p
+except AttributeError:
+ None
+finally:
+ None
-def _convert_nanosecond_to_datetime(nanosec):
- return nanosec
+_libtaos.taos_options.restype = None
-def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C bool row to python row
+
+def taos_options(option, *args):
+ # type: (TaosOption, Any) -> None
+ _libtaos.taos_options(option, *args)
+
+
+def taos_init():
+ # type: () -> None
"""
- _timestamp_converter = _convert_millisecond_to_datetime
- if precision == FieldType.C_TIMESTAMP_MILLI:
- _timestamp_converter = _convert_millisecond_to_datetime
- elif precision == FieldType.C_TIMESTAMP_MICRO:
- _timestamp_converter = _convert_microsecond_to_datetime
- elif precision == FieldType.C_TIMESTAMP_NANO:
- _timestamp_converter = _convert_nanosecond_to_datetime
- else:
- raise DatabaseError("Unknown precision returned from database")
+ C: taos_init
+ """
+ _libtaos.taos_init()
+
+
+_libtaos.taos_cleanup.restype = None
- return [
- None if ele == FieldType.C_BIGINT_NULL else _timestamp_converter(ele) for ele in ctypes.cast(
- data, ctypes.POINTER(
- ctypes.c_int64))[
- :abs(num_of_rows)]]
+def taos_cleanup():
+ # type: () -> None
+ """Cleanup workspace."""
+ _libtaos.taos_cleanup()
-def _crow_bool_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C bool row to python row
+
+_libtaos.taos_get_client_info.restype = c_char_p
+
+
+def taos_get_client_info():
+ # type: () -> str
+ """Get client version info."""
+ return _libtaos.taos_get_client_info().decode()
+
+
+_libtaos.taos_get_server_info.restype = c_char_p
+_libtaos.taos_get_server_info.argtypes = (c_void_p,)
+
+
+def taos_get_server_info(connection):
+ # type: (c_void_p) -> str
+ """Get server version as string."""
+ return _libtaos.taos_get_server_info(connection).decode()
+
+
+_libtaos.taos_close.restype = None
+_libtaos.taos_close.argtypes = (c_void_p,)
+
+
+def taos_close(connection):
+ # type: (c_void_p) -> None
+ """Close the TAOS* connection"""
+ _libtaos.taos_close(connection)
+
+
+_libtaos.taos_connect.restype = c_void_p
+_libtaos.taos_connect.argtypes = c_char_p, c_char_p, c_char_p, c_char_p, c_uint16
+
+
+def taos_connect(host=None, user="root", password="taosdata", db=None, port=0):
+ # type: (None|str, str, str, None|str, int) -> c_void_p
+ """Create TDengine database connection.
+
+ - host: server hostname/FQDN
+ - user: user name
+ - password: user password
+ - db: database name (optional)
+ - port: server port
+
+ @rtype: c_void_p, TDengine handle
"""
- return [
- None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(
- data, ctypes.POINTER(
- ctypes.c_byte))[
- :abs(num_of_rows)]]
+ # host
+ try:
+ _host = c_char_p(host.encode("utf-8")) if host is not None else None
+ except AttributeError:
+ raise AttributeError("host is expected as a str")
+
+ # user
+ try:
+ _user = c_char_p(user.encode("utf-8"))
+ except AttributeError:
+ raise AttributeError("user is expected as a str")
+
+ # password
+ try:
+ _password = c_char_p(password.encode("utf-8"))
+ except AttributeError:
+ raise AttributeError("password is expected as a str")
+
+ # db
+ try:
+ _db = c_char_p(db.encode("utf-8")) if db is not None else None
+ except AttributeError:
+ raise AttributeError("db is expected as a str")
+
+ # port
+ try:
+ _port = c_uint16(port)
+ except TypeError:
+ raise TypeError("port is expected as an uint16")
+
+ connection = cast(_libtaos.taos_connect(_host, _user, _password, _db, _port), c_void_p)
+
+ if connection.value is None:
+ raise ConnectionError("connect to TDengine failed")
+ return connection
+
+_libtaos.taos_connect_auth.restype = c_void_p
+_libtaos.taos_connect_auth.argtypes = c_char_p, c_char_p, c_char_p, c_char_p, c_uint16
-def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C tinyint row to python row
+
+def taos_connect_auth(host=None, user="root", auth="", db=None, port=0):
+ # type: (None|str, str, str, None|str, int) -> c_void_p
+ """Connect server with auth token.
+
+ - host: server hostname/FQDN
+ - user: user name
+ - auth: base64 encoded auth token
+ - db: database name (optional)
+ - port: server port
+
+ @rtype: c_void_p, TDengine handle
"""
- return [None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(
- data, ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)]]
+ # host
+ try:
+ _host = c_char_p(host.encode("utf-8")) if host is not None else None
+ except AttributeError:
+ raise AttributeError("host is expected as a str")
+
+ # user
+ try:
+ _user = c_char_p(user.encode("utf-8"))
+ except AttributeError:
+ raise AttributeError("user is expected as a str")
+
+ # auth
+ try:
+ _auth = c_char_p(auth.encode("utf-8"))
+ except AttributeError:
+ raise AttributeError("password is expected as a str")
+
+ # db
+ try:
+ _db = c_char_p(db.encode("utf-8")) if db is not None else None
+ except AttributeError:
+ raise AttributeError("db is expected as a str")
+
+ # port
+ try:
+ _port = c_int(port)
+ except TypeError:
+ raise TypeError("port is expected as an int")
+
+ connection = c_void_p(_libtaos.taos_connect_auth(_host, _user, _auth, _db, _port))
+
+ if connection.value is None:
+ raise ConnectionError("connect to TDengine failed")
+ return connection
+
+_libtaos.taos_query.restype = c_void_p
+_libtaos.taos_query.argtypes = c_void_p, c_char_p
+
+
+def taos_query(connection, sql):
+ # type: (c_void_p, str) -> c_void_p
+ """Run SQL
+
+ - sql: str, sql string to run
+
+ @return: TAOS_RES*, result pointer
-def _crow_tinyint_unsigned_to_python(
- data,
- num_of_rows,
- nbytes=None,
- precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C tinyint row to python row
"""
- return [
- None if ele == FieldType.C_TINYINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
- data, ctypes.POINTER(
- ctypes.c_ubyte))[
- :abs(num_of_rows)]]
+ try:
+ ptr = c_char_p(sql.encode("utf-8"))
+ res = c_void_p(_libtaos.taos_query(connection, ptr))
+ errno = taos_errno(res)
+ if errno != 0:
+ errstr = taos_errstr(res)
+ taos_free_result(res)
+ raise ProgrammingError(errstr, errno)
+ return res
+ except AttributeError:
+ raise AttributeError("sql is expected as a string")
+
+
+async_query_callback_type = CFUNCTYPE(None, c_void_p, c_void_p, c_int)
+_libtaos.taos_query_a.restype = None
+_libtaos.taos_query_a.argtypes = c_void_p, c_char_p, async_query_callback_type, c_void_p
+
+
+def taos_query_a(connection, sql, callback, param):
+ # type: (c_void_p, str, async_query_callback_type, c_void_p) -> c_void_p
+ _libtaos.taos_query_a(connection, c_char_p(sql.encode("utf-8")), async_query_callback_type(callback), param)
+
+
+async_fetch_rows_callback_type = CFUNCTYPE(None, c_void_p, c_void_p, c_int)
+_libtaos.taos_fetch_rows_a.restype = None
+_libtaos.taos_fetch_rows_a.argtypes = c_void_p, async_fetch_rows_callback_type, c_void_p
+
+
+def taos_fetch_rows_a(result, callback, param):
+ # type: (c_void_p, async_fetch_rows_callback_type, c_void_p) -> c_void_p
+ _libtaos.taos_fetch_rows_a(result, async_fetch_rows_callback_type(callback), param)
+
+
+def taos_affected_rows(result):
+ # type: (c_void_p) -> c_int
+ """The affected rows after runing query"""
+ return _libtaos.taos_affected_rows(result)
-def _crow_smallint_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C smallint row to python row
+subscribe_callback_type = CFUNCTYPE(None, c_void_p, c_void_p, c_void_p, c_int)
+_libtaos.taos_subscribe.restype = c_void_p
+# _libtaos.taos_subscribe.argtypes = c_void_p, c_int, c_char_p, c_char_p, subscribe_callback_type, c_void_p, c_int
+
+
+def taos_subscribe(connection, restart, topic, sql, interval, callback=None, param=None):
+ # type: (c_void_p, bool, str, str, c_int, subscribe_callback_type, c_void_p | None) -> c_void_p
+ """Create a subscription
+ @restart boolean,
+ @sql string, sql statement for data query, must be a 'select' statement.
+ @topic string, name of this subscription
"""
- return [
- None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(
- data, ctypes.POINTER(
- ctypes.c_short))[
- :abs(num_of_rows)]]
+ if callback != None:
+ callback = subscribe_callback_type(callback)
+ if param != None:
+ param = c_void_p(param)
+ return c_void_p(
+ _libtaos.taos_subscribe(
+ connection,
+ 1 if restart else 0,
+ c_char_p(topic.encode("utf-8")),
+ c_char_p(sql.encode("utf-8")),
+ callback or None,
+ param,
+ interval,
+ )
+ )
+
+
+_libtaos.taos_consume.restype = c_void_p
+_libtaos.taos_consume.argstype = c_void_p,
+
+
+def taos_consume(sub):
+ """Consume data of a subscription"""
+ return c_void_p(_libtaos.taos_consume(sub))
+
+
+_libtaos.taos_unsubscribe.restype = None
+_libtaos.taos_unsubscribe.argstype = c_void_p, c_int
+
+
+def taos_unsubscribe(sub, keep_progress):
+ """Cancel a subscription"""
+ _libtaos.taos_unsubscribe(sub, 1 if keep_progress else 0)
+
+
+def taos_use_result(result):
+ """Use result after calling self.query, it's just for 1.6."""
+ fields = []
+ pfields = taos_fetch_fields_raw(result)
+ for i in range(taos_field_count(result)):
+ fields.append(
+ {
+ "name": pfields[i].name,
+ "bytes": pfields[i].bytes,
+ "type": pfields[i].type,
+ }
+ )
+
+ return fields
-def _crow_smallint_unsigned_to_python(
- data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C smallint row to python row
+_libtaos.taos_fetch_block.restype = c_int
+_libtaos.taos_fetch_block.argtypes = c_void_p, c_void_p
+
+
+def taos_fetch_block_raw(result):
+ pblock = ctypes.c_void_p(0)
+ num_of_rows = _libtaos.taos_fetch_block(result, ctypes.byref(pblock))
+ if num_of_rows == 0:
+ return None, 0
+ return pblock, abs(num_of_rows)
+
+
+def taos_fetch_block(result, fields=None, field_count=None):
+ pblock = ctypes.c_void_p(0)
+ num_of_rows = _libtaos.taos_fetch_block(result, ctypes.byref(pblock))
+ if num_of_rows == 0:
+ return None, 0
+ precision = taos_result_precision(result)
+ if fields == None:
+ fields = taos_fetch_fields(result)
+ if field_count == None:
+ field_count = taos_field_count(result)
+ blocks = [None] * field_count
+ fieldLen = taos_fetch_lengths(result, field_count)
+ for i in range(len(fields)):
+ data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
+ if fields[i]["type"] not in CONVERT_FUNC:
+ raise DatabaseError("Invalid data type returned from database")
+ blocks[i] = CONVERT_FUNC_BLOCK[fields[i]["type"]](data, num_of_rows, fieldLen[i], precision)
+
+ return blocks, abs(num_of_rows)
+
+
+_libtaos.taos_fetch_row.restype = c_void_p
+_libtaos.taos_fetch_row.argtypes = (c_void_p,)
+
+
+def taos_fetch_row_raw(result):
+ # type: (c_void_p) -> c_void_p
+ row = c_void_p(_libtaos.taos_fetch_row(result))
+ if row:
+ return row
+ return None
+
+
+def taos_fetch_row(result, fields):
+ # type: (c_void_p, Array[TaosField]) -> tuple(c_void_p, int)
+ pblock = ctypes.c_void_p(0)
+ pblock = taos_fetch_row_raw(result)
+ if pblock:
+ num_of_rows = 1
+ precision = taos_result_precision(result)
+ field_count = taos_field_count(result)
+ blocks = [None] * field_count
+ field_lens = taos_fetch_lengths(result, field_count)
+ for i in range(field_count):
+ data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
+ if fields[i].type not in CONVERT_FUNC:
+ raise DatabaseError("Invalid data type returned from database")
+ if data is None:
+ blocks[i] = [None]
+ else:
+ blocks[i] = CONVERT_FUNC[fields[i].type](data, num_of_rows, field_lens[i], precision)
+ else:
+ return None, 0
+ return blocks, abs(num_of_rows)
+
+
+_libtaos.taos_free_result.argtypes = (c_void_p,)
+
+
+def taos_free_result(result):
+ # type: (c_void_p) -> None
+ if result != None:
+ _libtaos.taos_free_result(result)
+
+
+_libtaos.taos_field_count.restype = c_int
+_libtaos.taos_field_count.argstype = (c_void_p,)
+
+
+def taos_field_count(result):
+ # type: (c_void_p) -> int
+ return _libtaos.taos_field_count(result)
+
+
+def taos_num_fields(result):
+ # type: (c_void_p) -> int
+ return _libtaos.taos_num_fields(result)
+
+
+_libtaos.taos_fetch_fields.restype = c_void_p
+_libtaos.taos_fetch_fields.argstype = (c_void_p,)
+
+
+def taos_fetch_fields_raw(result):
+ # type: (c_void_p) -> c_void_p
+ return c_void_p(_libtaos.taos_fetch_fields(result))
+
+
+def taos_fetch_fields(result):
+ # type: (c_void_p) -> TaosFields
+ fields = taos_fetch_fields_raw(result)
+ count = taos_field_count(result)
+ return TaosFields(fields, count)
+
+
+def taos_fetch_lengths(result, field_count=None):
+ # type: (c_void_p, int) -> Array[int]
+ """Make sure to call taos_fetch_row or taos_fetch_block before fetch_lengths"""
+ lens = _libtaos.taos_fetch_lengths(result)
+ if field_count == None:
+ field_count = taos_field_count(result)
+ if not lens:
+ raise OperationalError("field length empty, use taos_fetch_row/block before it")
+ return lens[:field_count]
+
+
+def taos_result_precision(result):
+ # type: (c_void_p) -> c_int
+ return _libtaos.taos_result_precision(result)
+
+
+_libtaos.taos_errno.restype = c_int
+_libtaos.taos_errno.argstype = (c_void_p,)
+
+
+def taos_errno(result):
+ # type: (ctypes.c_void_p) -> c_int
+ """Return the error number."""
+ return _libtaos.taos_errno(result)
+
+
+_libtaos.taos_errstr.restype = c_char_p
+_libtaos.taos_errstr.argstype = (c_void_p,)
+
+
+def taos_errstr(result=c_void_p(None)):
+ # type: (ctypes.c_void_p) -> str
+ """Return the error styring"""
+ return _libtaos.taos_errstr(result).decode("utf-8")
+
+
+_libtaos.taos_stop_query.restype = None
+_libtaos.taos_stop_query.argstype = (c_void_p,)
+
+
+def taos_stop_query(result):
+ # type: (ctypes.c_void_p) -> None
+ """Stop current query"""
+ return _libtaos.taos_stop_query(result)
+
+
+_libtaos.taos_load_table_info.restype = c_int
+_libtaos.taos_load_table_info.argstype = (c_void_p, c_char_p)
+
+
+def taos_load_table_info(connection, tables):
+ # type: (ctypes.c_void_p, str) -> None
+ """Stop current query"""
+ errno = _libtaos.taos_load_table_info(connection, c_char_p(tables.encode("utf-8")))
+ if errno != 0:
+ msg = taos_errstr()
+ raise OperationalError(msg, errno)
+
+
+_libtaos.taos_validate_sql.restype = c_int
+_libtaos.taos_validate_sql.argstype = (c_void_p, c_char_p)
+
+
+def taos_validate_sql(connection, sql):
+ # type: (ctypes.c_void_p, str) -> None | str
+ """Get taosd server info"""
+ errno = _libtaos.taos_validate_sql(connection, ctypes.c_char_p(sql.encode("utf-8")))
+ if errno != 0:
+ msg = taos_errstr()
+ return msg
+ return None
+
+
+_libtaos.taos_print_row.restype = c_int
+_libtaos.taos_print_row.argstype = (c_char_p, c_void_p, c_void_p, c_int)
+
+
+def taos_print_row(row, fields, num_fields, buffer_size=4096):
+ # type: (ctypes.c_void_p, ctypes.c_void_p | TaosFields, int, int) -> str
+ """Print an row to string"""
+ p = ctypes.create_string_buffer(buffer_size)
+ if isinstance(fields, TaosFields):
+ _libtaos.taos_print_row(p, row, fields.as_ptr(), num_fields)
+ else:
+ _libtaos.taos_print_row(p, row, fields, num_fields)
+ if p:
+ return p.value.decode("utf-8")
+ raise OperationalError("taos_print_row failed")
+
+
+_libtaos.taos_select_db.restype = c_int
+_libtaos.taos_select_db.argstype = (c_void_p, c_char_p)
+
+
+def taos_select_db(connection, db):
+ # type: (ctypes.c_void_p, str) -> None
+ """Select database, eq to sql: use """
+ res = _libtaos.taos_select_db(connection, ctypes.c_char_p(db.encode("utf-8")))
+ if res != 0:
+ raise DatabaseError("select database error", res)
+
+
+try:
+ _libtaos.taos_open_stream.restype = c_void_p
+ _libtaos.taos_open_stream.argstype = c_void_p, c_char_p, stream_callback_type, c_int64, c_void_p, Any
+except:
+ pass
+
+
+def taos_open_stream(connection, sql, callback, stime=0, param=None, callback2=None):
+ # type: (ctypes.c_void_p, str, stream_callback_type, c_int64, c_void_p, c_void_p) -> ctypes.pointer
+ if callback2 != None:
+ callback2 = stream_callback2_type(callback2)
+ """Open an stream"""
+ return c_void_p(
+ _libtaos.taos_open_stream(
+ connection, ctypes.c_char_p(sql.encode("utf-8")), stream_callback_type(callback), stime, param, callback2
+ )
+ )
+
+
+_libtaos.taos_close_stream.restype = None
+_libtaos.taos_close_stream.argstype = (c_void_p,)
+
+
+def taos_close_stream(stream):
+ # type: (c_void_p) -> None
+ """Open an stream"""
+ return _libtaos.taos_close_stream(stream)
+
+
+_libtaos.taos_stmt_init.restype = c_void_p
+_libtaos.taos_stmt_init.argstype = (c_void_p,)
+
+
+def taos_stmt_init(connection):
+ # type: (c_void_p) -> (c_void_p)
+ """Create a statement query
+ @param(connection): c_void_p TAOS*
+ @rtype: c_void_p, *TAOS_STMT
"""
- return [
- None if ele == FieldType.C_SMALLINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
- data, ctypes.POINTER(
- ctypes.c_ushort))[
- :abs(num_of_rows)]]
+ return c_void_p(_libtaos.taos_stmt_init(connection))
+
+_libtaos.taos_stmt_prepare.restype = c_int
+_libtaos.taos_stmt_prepare.argstype = (c_void_p, c_char_p, c_int)
-def _crow_int_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C int row to python row
+
+def taos_stmt_prepare(stmt, sql):
+ # type: (ctypes.c_void_p, str) -> None
+ """Prepare a statement query
+ @stmt: c_void_p TAOS_STMT*
"""
- return [None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(
- data, ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)]]
+ buffer = sql.encode("utf-8")
+ res = _libtaos.taos_stmt_prepare(stmt, ctypes.c_char_p(buffer), len(buffer))
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
+
+_libtaos.taos_stmt_close.restype = c_int
+_libtaos.taos_stmt_close.argstype = (c_void_p,)
-def _crow_int_unsigned_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C int row to python row
+
+def taos_stmt_close(stmt):
+ # type: (ctypes.c_void_p) -> None
+ """Close a statement query
+ @stmt: c_void_p TAOS_STMT*
"""
- return [
- None if ele == FieldType.C_INT_UNSIGNED_NULL else ele for ele in ctypes.cast(
- data, ctypes.POINTER(
- ctypes.c_uint))[
- :abs(num_of_rows)]]
+ res = _libtaos.taos_stmt_close(stmt)
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
+
+try:
+ _libtaos.taos_stmt_errstr.restype = c_char_p
+ _libtaos.taos_stmt_errstr.argstype = (c_void_p,)
+except AttributeError:
+ print("WARNING: libtaos(%s) does not support taos_stmt_errstr" % taos_get_client_info())
-def _crow_bigint_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C bigint row to python row
+
+def taos_stmt_errstr(stmt):
+ # type: (ctypes.c_void_p) -> str
+ """Get error message from stetement query
+ @stmt: c_void_p TAOS_STMT*
"""
- return [None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(
- data, ctypes.POINTER(ctypes.c_int64))[:abs(num_of_rows)]]
+ err = c_char_p(_libtaos.taos_stmt_errstr(stmt))
+ if err:
+ return err.value.decode("utf-8")
+
+try:
+ _libtaos.taos_stmt_set_tbname.restype = c_int
+ _libtaos.taos_stmt_set_tbname.argstype = (c_void_p, c_char_p)
+except AttributeError:
+ print("WARNING: libtaos(%s) does not support taos_stmt_set_tbname" % taos_get_client_info())
-def _crow_bigint_unsigned_to_python(
- data,
- num_of_rows,
- nbytes=None,
- precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C bigint row to python row
+
+def taos_stmt_set_tbname(stmt, name):
+ # type: (ctypes.c_void_p, str) -> None
+ """Set table name of a statement query if exists.
+ @stmt: c_void_p TAOS_STMT*
"""
- return [
- None if ele == FieldType.C_BIGINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
- data, ctypes.POINTER(
- ctypes.c_uint64))[
- :abs(num_of_rows)]]
+ res = _libtaos.taos_stmt_set_tbname(stmt, c_char_p(name.encode("utf-8")))
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
+
+try:
+ _libtaos.taos_stmt_set_tbname_tags.restype = c_int
+ _libtaos.taos_stmt_set_tbname_tags.argstype = (c_void_p, c_char_p, c_void_p)
+except AttributeError:
+ print("WARNING: libtaos(%s) does not support taos_stmt_set_tbname_tags" % taos_get_client_info())
-def _crow_float_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C float row to python row
+
+def taos_stmt_set_tbname_tags(stmt, name, tags):
+ # type: (c_void_p, str, c_void_p) -> None
+ """Set table name with tags bind params.
+ @stmt: c_void_p TAOS_STMT*
"""
- return [None if math.isnan(ele) else ele for ele in ctypes.cast(
- data, ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)]]
+ res = _libtaos.taos_stmt_set_tbname_tags(stmt, ctypes.c_char_p(name.encode("utf-8")), tags)
+
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
+
+_libtaos.taos_stmt_is_insert.restype = c_int
+_libtaos.taos_stmt_is_insert.argstype = (c_void_p, POINTER(c_int))
-def _crow_double_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C double row to python row
+
+def taos_stmt_is_insert(stmt):
+ # type: (ctypes.c_void_p) -> bool
+ """Set table name with tags bind params.
+ @stmt: c_void_p TAOS_STMT*
"""
- return [None if math.isnan(ele) else ele for ele in ctypes.cast(
- data, ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)]]
+ is_insert = ctypes.c_int()
+ res = _libtaos.taos_stmt_is_insert(stmt, ctypes.byref(is_insert))
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
+ return is_insert == 0
+
+_libtaos.taos_stmt_num_params.restype = c_int
+_libtaos.taos_stmt_num_params.argstype = (c_void_p, POINTER(c_int))
-def _crow_binary_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C binary row to python row
+
+def taos_stmt_num_params(stmt):
+ # type: (ctypes.c_void_p) -> int
+ """Params number of the current statement query.
+ @stmt: TAOS_STMT*
"""
- assert(nbytes is not None)
- return [None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode(
- 'utf-8') for ele in (ctypes.cast(data, ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
+ num_params = ctypes.c_int()
+ res = _libtaos.taos_stmt_num_params(stmt, ctypes.byref(num_params))
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
+ return num_params.value
+
+_libtaos.taos_stmt_bind_param.restype = c_int
+_libtaos.taos_stmt_bind_param.argstype = (c_void_p, c_void_p)
-def _crow_nchar_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C nchar row to python row
+
+def taos_stmt_bind_param(stmt, bind):
+ # type: (ctypes.c_void_p, Array[TaosBind]) -> None
+ """Bind params in the statement query.
+ @stmt: TAOS_STMT*
+ @bind: TAOS_BIND*
"""
- assert(nbytes is not None)
- res = []
- for i in range(abs(num_of_rows)):
- try:
- if num_of_rows >= 0:
- tmpstr = ctypes.c_char_p(data)
- res.append(tmpstr.value.decode())
- else:
- res.append((ctypes.cast(data + nbytes * i,
- ctypes.POINTER(ctypes.c_wchar * (nbytes // 4))))[0].value)
- except ValueError:
- res.append(None)
+ # ptr = ctypes.cast(bind, POINTER(TaosBind))
+ # ptr = pointer(bind)
+ res = _libtaos.taos_stmt_bind_param(stmt, bind)
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
+
+try:
+ _libtaos.taos_stmt_bind_param_batch.restype = c_int
+ _libtaos.taos_stmt_bind_param_batch.argstype = (c_void_p, c_void_p)
+except AttributeError:
+ print("WARNING: libtaos(%s) does not support taos_stmt_bind_param_batch" % taos_get_client_info())
- return res
-def _crow_binary_to_python_block(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C binary row to python row
+def taos_stmt_bind_param_batch(stmt, bind):
+ # type: (ctypes.c_void_p, Array[TaosMultiBind]) -> None
+ """Bind params in the statement query.
+ @stmt: TAOS_STMT*
+ @bind: TAOS_BIND*
"""
- assert(nbytes is not None)
- res = []
- for i in range(abs(num_of_rows)):
- try:
- rbyte = ctypes.cast(
- data + nbytes * i,
- ctypes.POINTER(
- ctypes.c_short))[
- :1].pop()
- tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
- res.append(tmpstr.value.decode()[0:rbyte])
- except ValueError:
- res.append(None)
- return res
-
-
-def _crow_nchar_to_python_block(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
- """Function to convert C nchar row to python row
+ # ptr = ctypes.cast(bind, POINTER(TaosMultiBind))
+ # ptr = pointer(bind)
+ res = _libtaos.taos_stmt_bind_param_batch(stmt, bind)
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
+
+try:
+ _libtaos.taos_stmt_bind_single_param_batch.restype = c_int
+ _libtaos.taos_stmt_bind_single_param_batch.argstype = (c_void_p, c_void_p, c_int)
+except AttributeError:
+ print("WARNING: libtaos(%s) does not support taos_stmt_bind_single_param_batch" % taos_get_client_info())
+
+
+def taos_stmt_bind_single_param_batch(stmt, bind, col):
+ # type: (ctypes.c_void_p, Array[TaosMultiBind], c_int) -> None
+ """Bind params in the statement query.
+ @stmt: TAOS_STMT*
+ @bind: TAOS_MULTI_BIND*
+ @col: column index
"""
- assert(nbytes is not None)
- res = []
- for i in range(abs(num_of_rows)):
- try:
- tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
- res.append(tmpstr.value.decode())
- except ValueError:
- res.append(None)
- return res
-
-
-_CONVERT_FUNC = {
- FieldType.C_BOOL: _crow_bool_to_python,
- FieldType.C_TINYINT: _crow_tinyint_to_python,
- FieldType.C_SMALLINT: _crow_smallint_to_python,
- FieldType.C_INT: _crow_int_to_python,
- FieldType.C_BIGINT: _crow_bigint_to_python,
- FieldType.C_FLOAT: _crow_float_to_python,
- FieldType.C_DOUBLE: _crow_double_to_python,
- FieldType.C_BINARY: _crow_binary_to_python,
- FieldType.C_TIMESTAMP: _crow_timestamp_to_python,
- FieldType.C_NCHAR: _crow_nchar_to_python,
- FieldType.C_TINYINT_UNSIGNED: _crow_tinyint_unsigned_to_python,
- FieldType.C_SMALLINT_UNSIGNED: _crow_smallint_unsigned_to_python,
- FieldType.C_INT_UNSIGNED: _crow_int_unsigned_to_python,
- FieldType.C_BIGINT_UNSIGNED: _crow_bigint_unsigned_to_python
-}
-
-_CONVERT_FUNC_BLOCK = {
- FieldType.C_BOOL: _crow_bool_to_python,
- FieldType.C_TINYINT: _crow_tinyint_to_python,
- FieldType.C_SMALLINT: _crow_smallint_to_python,
- FieldType.C_INT: _crow_int_to_python,
- FieldType.C_BIGINT: _crow_bigint_to_python,
- FieldType.C_FLOAT: _crow_float_to_python,
- FieldType.C_DOUBLE: _crow_double_to_python,
- FieldType.C_BINARY: _crow_binary_to_python_block,
- FieldType.C_TIMESTAMP: _crow_timestamp_to_python,
- FieldType.C_NCHAR: _crow_nchar_to_python_block,
- FieldType.C_TINYINT_UNSIGNED: _crow_tinyint_unsigned_to_python,
- FieldType.C_SMALLINT_UNSIGNED: _crow_smallint_unsigned_to_python,
- FieldType.C_INT_UNSIGNED: _crow_int_unsigned_to_python,
- FieldType.C_BIGINT_UNSIGNED: _crow_bigint_unsigned_to_python
-}
-
-# Corresponding TAOS_FIELD structure in C
-
-
-class TaosField(ctypes.Structure):
- _fields_ = [('name', ctypes.c_char * 65),
- ('type', ctypes.c_char),
- ('bytes', ctypes.c_short)]
+ res = _libtaos.taos_stmt_bind_single_param_batch(stmt, bind, col)
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
-# C interface class
+_libtaos.taos_stmt_add_batch.restype = c_int
+_libtaos.taos_stmt_add_batch.argstype = (c_void_p,)
-def _load_taos_linux():
- return ctypes.CDLL('libtaos.so')
+def taos_stmt_add_batch(stmt):
+ # type: (ctypes.c_void_p) -> None
+ """Add current params into batch
+ @stmt: TAOS_STMT*
+ """
+ res = _libtaos.taos_stmt_add_batch(stmt)
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
-def _load_taos_darwin():
- return ctypes.CDLL('libtaos.dylib')
+_libtaos.taos_stmt_execute.restype = c_int
+_libtaos.taos_stmt_execute.argstype = (c_void_p,)
-def _load_taos_windows():
- return ctypes.windll.LoadLibrary('taos')
+def taos_stmt_execute(stmt):
+ # type: (ctypes.c_void_p) -> None
+ """Execute a statement query
+ @stmt: TAOS_STMT*
+ """
+ res = _libtaos.taos_stmt_execute(stmt)
+ if res != 0:
+ raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
-def _load_taos():
- load_func = {
- 'Linux': _load_taos_linux,
- 'Darwin': _load_taos_darwin,
- 'Windows': _load_taos_windows,
- }
- try:
- return load_func[platform.system()]()
- except:
- sys.exit('unsupported platform to TDengine connector')
+_libtaos.taos_stmt_use_result.restype = c_void_p
+_libtaos.taos_stmt_use_result.argstype = (c_void_p,)
-class CTaosInterface(object):
- libtaos = _load_taos()
-
- libtaos.taos_fetch_fields.restype = ctypes.POINTER(TaosField)
- libtaos.taos_init.restype = None
- libtaos.taos_connect.restype = ctypes.c_void_p
- # libtaos.taos_use_result.restype = ctypes.c_void_p
- libtaos.taos_fetch_row.restype = ctypes.POINTER(ctypes.c_void_p)
- libtaos.taos_errstr.restype = ctypes.c_char_p
- libtaos.taos_subscribe.restype = ctypes.c_void_p
- libtaos.taos_consume.restype = ctypes.c_void_p
- libtaos.taos_fetch_lengths.restype = ctypes.c_void_p
- libtaos.taos_free_result.restype = None
- libtaos.taos_errno.restype = ctypes.c_int
- libtaos.taos_query.restype = ctypes.POINTER(ctypes.c_void_p)
+def taos_stmt_use_result(stmt):
+ # type: (ctypes.c_void_p) -> None
+ """Get result of the statement.
+ @stmt: TAOS_STMT*
+ """
+ result = c_void_p(_libtaos.taos_stmt_use_result(stmt))
+ if result == None:
+ raise StatementError(taos_stmt_errstr(stmt))
+ return result
+
+try:
+ _libtaos.taos_insert_lines.restype = c_int
+ _libtaos.taos_insert_lines.argstype = c_void_p, c_void_p, c_int
+except AttributeError:
+ print("WARNING: libtaos(%s) does not support insert_lines" % taos_get_client_info())
+
+
+
+def taos_insert_lines(connection, lines):
+ # type: (c_void_p, list[str] | tuple(str)) -> None
+ num_of_lines = len(lines)
+ lines = (c_char_p(line.encode("utf-8")) for line in lines)
+ lines_type = ctypes.c_char_p * num_of_lines
+ p_lines = lines_type(*lines)
+ errno = _libtaos.taos_insert_lines(connection, p_lines, num_of_lines)
+ if errno != 0:
+ raise LinesError("insert lines error", errno)
+
+
+class CTaosInterface(object):
def __init__(self, config=None):
- '''
+ """
Function to initialize the class
@host : str, hostname to connect
@user : str, username to connect to server
@@ -298,304 +839,46 @@ class CTaosInterface(object):
@config : str, config directory
@rtype : None
- '''
+ """
if config is None:
self._config = ctypes.c_char_p(None)
else:
try:
- self._config = ctypes.c_char_p(config.encode('utf-8'))
+ self._config = ctypes.c_char_p(config.encode("utf-8"))
except AttributeError:
raise AttributeError("config is expected as a str")
if config is not None:
- CTaosInterface.libtaos.taos_options(3, self._config)
+ taos_options(3, self._config)
- CTaosInterface.libtaos.taos_init()
+ taos_init()
@property
def config(self):
- """ Get current config
- """
+ """Get current config"""
return self._config
- def connect(
- self,
- host=None,
- user="root",
- password="taosdata",
- db=None,
- port=0):
- '''
+ def connect(self, host=None, user="root", password="taosdata", db=None, port=0):
+ """
Function to connect to server
@rtype: c_void_p, TDengine handle
- '''
- # host
- try:
- _host = ctypes.c_char_p(host.encode(
- "utf-8")) if host is not None else ctypes.c_char_p(None)
- except AttributeError:
- raise AttributeError("host is expected as a str")
-
- # user
- try:
- _user = ctypes.c_char_p(user.encode("utf-8"))
- except AttributeError:
- raise AttributeError("user is expected as a str")
-
- # password
- try:
- _password = ctypes.c_char_p(password.encode("utf-8"))
- except AttributeError:
- raise AttributeError("password is expected as a str")
-
- # db
- try:
- _db = ctypes.c_char_p(
- db.encode("utf-8")) if db is not None else ctypes.c_char_p(None)
- except AttributeError:
- raise AttributeError("db is expected as a str")
-
- # port
- try:
- _port = ctypes.c_int(port)
- except TypeError:
- raise TypeError("port is expected as an int")
-
- connection = ctypes.c_void_p(CTaosInterface.libtaos.taos_connect(
- _host, _user, _password, _db, _port))
-
- if connection.value is None:
- print('connect to TDengine failed')
- raise ConnectionError("connect to TDengine failed")
- # sys.exit(1)
- # else:
- # print('connect to TDengine success')
-
- return connection
-
- @staticmethod
- def close(connection):
- '''Close the TDengine handle
- '''
- CTaosInterface.libtaos.taos_close(connection)
- # print('connection is closed')
-
- @staticmethod
- def query(connection, sql):
- '''Run SQL
-
- @sql: str, sql string to run
-
- @rtype: 0 on success and -1 on failure
- '''
- try:
- return CTaosInterface.libtaos.taos_query(
- connection, ctypes.c_char_p(sql.encode('utf-8')))
- except AttributeError:
- raise AttributeError("sql is expected as a string")
- # finally:
- # CTaosInterface.libtaos.close(connection)
-
- @staticmethod
- def affectedRows(result):
- """The affected rows after runing query
- """
- return CTaosInterface.libtaos.taos_affected_rows(result)
-
- @staticmethod
- def insertLines(connection, lines):
- '''
- insert through lines protocol
- @lines: list of str
- @rtype: tsdb error codes
- '''
- numLines = len(lines)
- c_lines_type = ctypes.c_char_p*numLines
- c_lines = c_lines_type()
- for i in range(numLines):
- c_lines[i] = ctypes.c_char_p(lines[i].encode('utf-8'))
- return CTaosInterface.libtaos.taos_insert_lines(connection, c_lines, ctypes.c_int(numLines))
-
- @staticmethod
- def subscribe(connection, restart, topic, sql, interval):
- """Create a subscription
- @restart boolean,
- @sql string, sql statement for data query, must be a 'select' statement.
- @topic string, name of this subscription
- """
- return ctypes.c_void_p(CTaosInterface.libtaos.taos_subscribe(
- connection,
- 1 if restart else 0,
- ctypes.c_char_p(topic.encode('utf-8')),
- ctypes.c_char_p(sql.encode('utf-8')),
- None,
- None,
- interval))
-
- @staticmethod
- def consume(sub):
- """Consume data of a subscription
- """
- result = ctypes.c_void_p(CTaosInterface.libtaos.taos_consume(sub))
- fields = []
- pfields = CTaosInterface.fetchFields(result)
- for i in range(CTaosInterface.libtaos.taos_num_fields(result)):
- fields.append({'name': pfields[i].name.decode('utf-8'),
- 'bytes': pfields[i].bytes,
- 'type': ord(pfields[i].type)})
- return result, fields
-
- @staticmethod
- def unsubscribe(sub, keepProgress):
- """Cancel a subscription
- """
- CTaosInterface.libtaos.taos_unsubscribe(sub, 1 if keepProgress else 0)
-
- @staticmethod
- def useResult(result):
- '''Use result after calling self.query
- '''
- fields = []
- pfields = CTaosInterface.fetchFields(result)
- for i in range(CTaosInterface.fieldsCount(result)):
- fields.append({'name': pfields[i].name.decode('utf-8'),
- 'bytes': pfields[i].bytes,
- 'type': ord(pfields[i].type)})
-
- return fields
-
- @staticmethod
- def fetchBlock(result, fields):
- pblock = ctypes.c_void_p(0)
- num_of_rows = CTaosInterface.libtaos.taos_fetch_block(
- result, ctypes.byref(pblock))
- if num_of_rows == 0:
- return None, 0
- precision = CTaosInterface.libtaos.taos_result_precision(result)
- blocks = [None] * len(fields)
- fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
- fieldLen = [
- ele for ele in ctypes.cast(
- fieldL, ctypes.POINTER(
- ctypes.c_int))[
- :len(fields)]]
- for i in range(len(fields)):
- data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
- if fields[i]['type'] not in _CONVERT_FUNC_BLOCK:
- raise DatabaseError("Invalid data type returned from database")
- blocks[i] = _CONVERT_FUNC_BLOCK[fields[i]['type']](
- data, num_of_rows, fieldLen[i], precision)
-
- return blocks, abs(num_of_rows)
-
- @staticmethod
- def fetchRow(result, fields):
- pblock = ctypes.c_void_p(0)
- pblock = CTaosInterface.libtaos.taos_fetch_row(result)
- if pblock:
- num_of_rows = 1
- precision = CTaosInterface.libtaos.taos_result_precision(result)
- blocks = [None] * len(fields)
- fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
- fieldLen = [
- ele for ele in ctypes.cast(
- fieldL, ctypes.POINTER(
- ctypes.c_int))[
- :len(fields)]]
- for i in range(len(fields)):
- data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
- if fields[i]['type'] not in _CONVERT_FUNC:
- raise DatabaseError(
- "Invalid data type returned from database")
- if data is None:
- blocks[i] = [None]
- else:
- blocks[i] = _CONVERT_FUNC[fields[i]['type']](
- data, num_of_rows, fieldLen[i], precision)
- else:
- return None, 0
- return blocks, abs(num_of_rows)
-
- @staticmethod
- def freeResult(result):
- CTaosInterface.libtaos.taos_free_result(result)
- result.value = None
-
- @staticmethod
- def fieldsCount(result):
- return CTaosInterface.libtaos.taos_field_count(result)
-
- @staticmethod
- def fetchFields(result):
- return CTaosInterface.libtaos.taos_fetch_fields(result)
-
- # @staticmethod
- # def fetchRow(result, fields):
- # l = []
- # row = CTaosInterface.libtaos.taos_fetch_row(result)
- # if not row:
- # return None
-
- # for i in range(len(fields)):
- # l.append(CTaosInterface.getDataValue(
- # row[i], fields[i]['type'], fields[i]['bytes']))
-
- # return tuple(l)
-
- # @staticmethod
- # def getDataValue(data, dtype, byte):
- # '''
- # '''
- # if not data:
- # return None
-
- # if (dtype == CTaosInterface.TSDB_DATA_TYPE_BOOL):
- # return ctypes.cast(data, ctypes.POINTER(ctypes.c_bool))[0]
- # elif (dtype == CTaosInterface.TSDB_DATA_TYPE_TINYINT):
- # return ctypes.cast(data, ctypes.POINTER(ctypes.c_byte))[0]
- # elif (dtype == CTaosInterface.TSDB_DATA_TYPE_SMALLINT):
- # return ctypes.cast(data, ctypes.POINTER(ctypes.c_short))[0]
- # elif (dtype == CTaosInterface.TSDB_DATA_TYPE_INT):
- # return ctypes.cast(data, ctypes.POINTER(ctypes.c_int))[0]
- # elif (dtype == CTaosInterface.TSDB_DATA_TYPE_BIGINT):
- # return ctypes.cast(data, ctypes.POINTER(ctypes.c_int64))[0]
- # elif (dtype == CTaosInterface.TSDB_DATA_TYPE_FLOAT):
- # return ctypes.cast(data, ctypes.POINTER(ctypes.c_float))[0]
- # elif (dtype == CTaosInterface.TSDB_DATA_TYPE_DOUBLE):
- # return ctypes.cast(data, ctypes.POINTER(ctypes.c_double))[0]
- # elif (dtype == CTaosInterface.TSDB_DATA_TYPE_BINARY):
- # return (ctypes.cast(data, ctypes.POINTER(ctypes.c_char))[0:byte]).rstrip('\x00')
- # elif (dtype == CTaosInterface.TSDB_DATA_TYPE_TIMESTAMP):
- # return ctypes.cast(data, ctypes.POINTER(ctypes.c_int64))[0]
- # elif (dtype == CTaosInterface.TSDB_DATA_TYPE_NCHAR):
- # return (ctypes.cast(data, ctypes.c_char_p).value).rstrip('\x00')
-
- @staticmethod
- def errno(result):
- """Return the error number.
- """
- return CTaosInterface.libtaos.taos_errno(result)
-
- @staticmethod
- def errStr(result):
- """Return the error styring
"""
- return CTaosInterface.libtaos.taos_errstr(result).decode('utf-8')
+ return taos_connect(host, user, password, db, port)
-if __name__ == '__main__':
+if __name__ == "__main__":
cinter = CTaosInterface()
conn = cinter.connect()
- result = cinter.query(conn, 'show databases')
+ result = cinter.query(conn, "show databases")
- print('Query Affected rows: {}'.format(cinter.affectedRows(result)))
+ print("Query Affected rows: {}".format(cinter.affected_rows(result)))
- fields = CTaosInterface.useResult(result)
+ fields = taos_fetch_fields_raw(result)
- data, num_of_rows = CTaosInterface.fetchBlock(result, fields)
+ data, num_of_rows = taos_fetch_block(result, fields)
print(data)
- cinter.freeResult(result)
+ cinter.free_result(result)
cinter.close(conn)
diff --git a/src/connector/python/taos/connection.py b/src/connector/python/taos/connection.py
index 88d06cd7186018788aeb25c982fc205441193cb8..7857c8c706dbe27fd9440e6bf2eb698b6822650e 100644
--- a/src/connector/python/taos/connection.py
+++ b/src/connector/python/taos/connection.py
@@ -1,11 +1,15 @@
-from .cursor import TDengineCursor
-from .subscription import TDengineSubscription
-from .cinterface import CTaosInterface
+# encoding:UTF-8
+from types import FunctionType
+from .cinterface import *
+from .cursor import TaosCursor
+from .subscription import TaosSubscription
+from .statement import TaosStmt
+from .stream import TaosStream
+from .result import *
-class TDengineConnection(object):
- """ TDengine connection object
- """
+class TaosConnection(object):
+ """TDengine connection object"""
def __init__(self, *args, **kwargs):
self._conn = None
@@ -21,63 +25,130 @@ class TDengineConnection(object):
def config(self, **kwargs):
# host
- if 'host' in kwargs:
- self._host = kwargs['host']
+ if "host" in kwargs:
+ self._host = kwargs["host"]
# user
- if 'user' in kwargs:
- self._user = kwargs['user']
+ if "user" in kwargs:
+ self._user = kwargs["user"]
# password
- if 'password' in kwargs:
- self._password = kwargs['password']
+ if "password" in kwargs:
+ self._password = kwargs["password"]
# database
- if 'database' in kwargs:
- self._database = kwargs['database']
+ if "database" in kwargs:
+ self._database = kwargs["database"]
# port
- if 'port' in kwargs:
- self._port = kwargs['port']
+ if "port" in kwargs:
+ self._port = kwargs["port"]
# config
- if 'config' in kwargs:
- self._config = kwargs['config']
+ if "config" in kwargs:
+ self._config = kwargs["config"]
self._chandle = CTaosInterface(self._config)
- self._conn = self._chandle.connect(
- self._host,
- self._user,
- self._password,
- self._database,
- self._port)
+ self._conn = self._chandle.connect(self._host, self._user, self._password, self._database, self._port)
def close(self):
- """Close current connection.
- """
- return CTaosInterface.close(self._conn)
-
- def subscribe(self, restart, topic, sql, interval):
- """Create a subscription.
- """
+ """Close current connection."""
+ if self._conn:
+ taos_close(self._conn)
+ self._conn = None
+
+ @property
+ def client_info(self):
+ # type: () -> str
+ return taos_get_client_info()
+
+ @property
+ def server_info(self):
+ # type: () -> str
+ return taos_get_server_info(self._conn)
+
+ def select_db(self, database):
+ # type: (str) -> None
+ taos_select_db(self._conn, database)
+
+ def execute(self, sql):
+ # type: (str) -> None
+ """Simplely execute sql ignoring the results"""
+ res = taos_query(self._conn, sql)
+ taos_free_result(res)
+
+ def query(self, sql):
+ # type: (str) -> TaosResult
+ result = taos_query(self._conn, sql)
+ return TaosResult(result, True, self)
+
+ def query_a(self, sql, callback, param):
+ # type: (str, async_query_callback_type, c_void_p) -> None
+ """Asynchronously query a sql with callback function"""
+ taos_query_a(self._conn, sql, callback, param)
+
+ def subscribe(self, restart, topic, sql, interval, callback=None, param=None):
+ # type: (bool, str, str, int, subscribe_callback_type, c_void_p) -> TaosSubscription
+ """Create a subscription."""
if self._conn is None:
return None
- sub = CTaosInterface.subscribe(
- self._conn, restart, topic, sql, interval)
- return TDengineSubscription(sub)
+ sub = taos_subscribe(self._conn, restart, topic, sql, interval, callback, param)
+ return TaosSubscription(sub, callback != None)
- def insertLines(self, lines):
- """
- insert lines through line protocol
- """
+ def statement(self, sql=None):
+ # type: (str | None) -> TaosStmt
if self._conn is None:
return None
- return CTaosInterface.insertLines(self._conn, lines)
-
- def cursor(self):
- """Return a new Cursor object using the connection.
+ stmt = taos_stmt_init(self._conn)
+ if sql != None:
+ taos_stmt_prepare(stmt, sql)
+
+ return TaosStmt(stmt)
+
+ def load_table_info(self, tables):
+ # type: (str) -> None
+ taos_load_table_info(self._conn, tables)
+
+ def stream(self, sql, callback, stime=0, param=None, callback2=None):
+ # type: (str, Callable[[Any, TaosResult, TaosRows], None], int, Any, c_void_p) -> TaosStream
+ # cb = cast(callback, stream_callback_type)
+ # ref = byref(cb)
+
+ stream = taos_open_stream(self._conn, sql, callback, stime, param, callback2)
+ return TaosStream(stream)
+
+ def insert_lines(self, lines):
+ # type: (list[str]) -> None
+ """Line protocol and schemaless support
+
+ ## Example
+
+ ```python
+ import taos
+ conn = taos.connect()
+ conn.exec("drop database if exists test")
+ conn.select_db("test")
+ lines = [
+ 'ste,t2=5,t3=L"ste" c1=true,c2=4,c3="string" 1626056811855516532',
+ ]
+ conn.insert_lines(lines)
+ ```
+
+ ## Exception
+
+ ```python
+ try:
+ conn.insert_lines(lines)
+ except SchemalessError as err:
+ print(err)
+ ```
"""
- return TDengineCursor(self)
+ return taos_insert_lines(self._conn, lines)
+
+ def cursor(self):
+ # type: () -> TaosCursor
+ """Return a new Cursor object using the connection."""
+ return TaosCursor(self)
def commit(self):
"""Commit any pending transaction to the database.
@@ -87,17 +158,18 @@ class TDengineConnection(object):
pass
def rollback(self):
- """Void functionality
- """
+ """Void functionality"""
pass
def clear_result_set(self):
- """Clear unused result set on this connection.
- """
+ """Clear unused result set on this connection."""
pass
+ def __del__(self):
+ self.close()
+
if __name__ == "__main__":
- conn = TDengineConnection(host='192.168.1.107')
+ conn = TaosConnection()
conn.close()
print("Hello world")
diff --git a/src/connector/python/taos/constants.py b/src/connector/python/taos/constants.py
index 85689b02db76b0032558b983d8ae8d9297229c42..8ad5b69fc099718fa4f4b8c08cf689b17663eae0 100644
--- a/src/connector/python/taos/constants.py
+++ b/src/connector/python/taos/constants.py
@@ -1,12 +1,14 @@
+# encoding:UTF-8
+
"""Constants in TDengine python
"""
-from .dbapi import *
+import ctypes, struct
class FieldType(object):
- """TDengine Field Types
- """
+ """TDengine Field Types"""
+
# type_code
C_NULL = 0
C_BOOL = 1
@@ -34,9 +36,9 @@ class FieldType(object):
C_INT_UNSIGNED_NULL = 4294967295
C_BIGINT_NULL = -9223372036854775808
C_BIGINT_UNSIGNED_NULL = 18446744073709551615
- C_FLOAT_NULL = float('nan')
- C_DOUBLE_NULL = float('nan')
- C_BINARY_NULL = bytearray([int('0xff', 16)])
+ C_FLOAT_NULL = ctypes.c_float(struct.unpack(" name (mondatory)
- > type_code (mondatory)
+ > name (mandatory)
+ > type_code (mandatory)
> display_size
> internal_size
> precision
@@ -55,8 +55,7 @@ class TDengineCursor(object):
raise OperationalError("Invalid use of fetch iterator")
if self._block_rows <= self._block_iter:
- block, self._block_rows = CTaosInterface.fetchRow(
- self._result, self._fields)
+ block, self._block_rows = taos_fetch_row(self._result, self._fields)
if self._block_rows == 0:
raise StopIteration
self._block = list(map(tuple, zip(*block)))
@@ -69,20 +68,17 @@ class TDengineCursor(object):
@property
def description(self):
- """Return the description of the object.
- """
+ """Return the description of the object."""
return self._description
@property
def rowcount(self):
- """Return the rowcount of the object
- """
+ """Return the rowcount of the object"""
return self._rowcount
@property
def affected_rows(self):
- """Return the rowcount of insertion
- """
+ """Return the rowcount of insertion"""
return self._affected_rows
def callproc(self, procname, *args):
@@ -96,8 +92,7 @@ class TDengineCursor(object):
self._logfile = logfile
def close(self):
- """Close the cursor.
- """
+ """Close the cursor."""
if self._connection is None:
return False
@@ -107,8 +102,7 @@ class TDengineCursor(object):
return True
def execute(self, operation, params=None):
- """Prepare and execute a database operation (query or command).
- """
+ """Prepare and execute a database operation (query or command)."""
if not operation:
return None
@@ -124,104 +118,91 @@ class TDengineCursor(object):
# global querySeqNum
# querySeqNum += 1
- # localSeqNum = querySeqNum # avoid raice condition
+ # localSeqNum = querySeqNum # avoid race condition
# print(" >> Exec Query ({}): {}".format(localSeqNum, str(stmt)))
- self._result = CTaosInterface.query(self._connection._conn, stmt)
+ self._result = taos_query(self._connection._conn, stmt)
# print(" << Query ({}) Exec Done".format(localSeqNum))
- if (self._logfile):
+ if self._logfile:
with open(self._logfile, "a") as logfile:
logfile.write("%s;\n" % operation)
- errno = CTaosInterface.libtaos.taos_errno(self._result)
- if errno == 0:
- if CTaosInterface.fieldsCount(self._result) == 0:
- self._affected_rows += CTaosInterface.affectedRows(
- self._result)
- return CTaosInterface.affectedRows(self._result)
- else:
- self._fields = CTaosInterface.useResult(
- self._result)
- return self._handle_result()
+ if taos_field_count(self._result) == 0:
+ affected_rows = taos_affected_rows(self._result)
+ self._affected_rows += affected_rows
+ return affected_rows
else:
- raise ProgrammingError(
- CTaosInterface.errStr(
- self._result), errno)
+ self._fields = taos_fetch_fields(self._result)
+ return self._handle_result()
def executemany(self, operation, seq_of_parameters):
- """Prepare a database operation (query or command) and then execute it against all parameter sequences or mappings found in the sequence seq_of_parameters.
- """
+ """Prepare a database operation (query or command) and then execute it against all parameter sequences or mappings found in the sequence seq_of_parameters."""
pass
def fetchone(self):
- """Fetch the next row of a query result set, returning a single sequence, or None when no more data is available.
- """
+ """Fetch the next row of a query result set, returning a single sequence, or None when no more data is available."""
pass
def fetchmany(self):
pass
def istype(self, col, dataType):
- if (dataType.upper() == "BOOL"):
- if (self._description[col][1] == FieldType.C_BOOL):
+ if dataType.upper() == "BOOL":
+ if self._description[col][1] == FieldType.C_BOOL:
return True
- if (dataType.upper() == "TINYINT"):
- if (self._description[col][1] == FieldType.C_TINYINT):
+ if dataType.upper() == "TINYINT":
+ if self._description[col][1] == FieldType.C_TINYINT:
return True
- if (dataType.upper() == "TINYINT UNSIGNED"):
- if (self._description[col][1] == FieldType.C_TINYINT_UNSIGNED):
+ if dataType.upper() == "TINYINT UNSIGNED":
+ if self._description[col][1] == FieldType.C_TINYINT_UNSIGNED:
return True
- if (dataType.upper() == "SMALLINT"):
- if (self._description[col][1] == FieldType.C_SMALLINT):
+ if dataType.upper() == "SMALLINT":
+ if self._description[col][1] == FieldType.C_SMALLINT:
return True
- if (dataType.upper() == "SMALLINT UNSIGNED"):
- if (self._description[col][1] == FieldType.C_SMALLINT_UNSIGNED):
+ if dataType.upper() == "SMALLINT UNSIGNED":
+ if self._description[col][1] == FieldType.C_SMALLINT_UNSIGNED:
return True
- if (dataType.upper() == "INT"):
- if (self._description[col][1] == FieldType.C_INT):
+ if dataType.upper() == "INT":
+ if self._description[col][1] == FieldType.C_INT:
return True
- if (dataType.upper() == "INT UNSIGNED"):
- if (self._description[col][1] == FieldType.C_INT_UNSIGNED):
+ if dataType.upper() == "INT UNSIGNED":
+ if self._description[col][1] == FieldType.C_INT_UNSIGNED:
return True
- if (dataType.upper() == "BIGINT"):
- if (self._description[col][1] == FieldType.C_BIGINT):
+ if dataType.upper() == "BIGINT":
+ if self._description[col][1] == FieldType.C_BIGINT:
return True
- if (dataType.upper() == "BIGINT UNSIGNED"):
- if (self._description[col][1] == FieldType.C_BIGINT_UNSIGNED):
+ if dataType.upper() == "BIGINT UNSIGNED":
+ if self._description[col][1] == FieldType.C_BIGINT_UNSIGNED:
return True
- if (dataType.upper() == "FLOAT"):
- if (self._description[col][1] == FieldType.C_FLOAT):
+ if dataType.upper() == "FLOAT":
+ if self._description[col][1] == FieldType.C_FLOAT:
return True
- if (dataType.upper() == "DOUBLE"):
- if (self._description[col][1] == FieldType.C_DOUBLE):
+ if dataType.upper() == "DOUBLE":
+ if self._description[col][1] == FieldType.C_DOUBLE:
return True
- if (dataType.upper() == "BINARY"):
- if (self._description[col][1] == FieldType.C_BINARY):
+ if dataType.upper() == "BINARY":
+ if self._description[col][1] == FieldType.C_BINARY:
return True
- if (dataType.upper() == "TIMESTAMP"):
- if (self._description[col][1] == FieldType.C_TIMESTAMP):
+ if dataType.upper() == "TIMESTAMP":
+ if self._description[col][1] == FieldType.C_TIMESTAMP:
return True
- if (dataType.upper() == "NCHAR"):
- if (self._description[col][1] == FieldType.C_NCHAR):
+ if dataType.upper() == "NCHAR":
+ if self._description[col][1] == FieldType.C_NCHAR:
return True
return False
def fetchall_row(self):
- """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
- """
+ """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation."""
if self._result is None or self._fields is None:
raise OperationalError("Invalid use of fetchall")
buffer = [[] for i in range(len(self._fields))]
self._rowcount = 0
while True:
- block, num_of_fields = CTaosInterface.fetchRow(
- self._result, self._fields)
- errno = CTaosInterface.libtaos.taos_errno(self._result)
+ block, num_of_fields = taos_fetch_row(self._result, self._fields)
+ errno = taos_errno(self._result)
if errno != 0:
- raise ProgrammingError(
- CTaosInterface.errStr(
- self._result), errno)
+ raise ProgrammingError(taos_errstr(self._result), errno)
if num_of_fields == 0:
break
self._rowcount += num_of_fields
@@ -230,19 +211,16 @@ class TDengineCursor(object):
return list(map(tuple, zip(*buffer)))
def fetchall(self):
- if self._result is None or self._fields is None:
+ if self._result is None:
raise OperationalError("Invalid use of fetchall")
-
- buffer = [[] for i in range(len(self._fields))]
+ fields = self._fields if self._fields is not None else taos_fetch_fields(self._result)
+ buffer = [[] for i in range(len(fields))]
self._rowcount = 0
while True:
- block, num_of_fields = CTaosInterface.fetchBlock(
- self._result, self._fields)
- errno = CTaosInterface.libtaos.taos_errno(self._result)
+ block, num_of_fields = taos_fetch_block(self._result, self._fields)
+ errno = taos_errno(self._result)
if errno != 0:
- raise ProgrammingError(
- CTaosInterface.errStr(
- self._result), errno)
+ raise ProgrammingError(taos_errstr(self._result), errno)
if num_of_fields == 0:
break
self._rowcount += num_of_fields
@@ -250,9 +228,12 @@ class TDengineCursor(object):
buffer[i].extend(block[i])
return list(map(tuple, zip(*buffer)))
+ def stop_query(self):
+ if self._result != None:
+ taos_stop_query(self._result)
+
def nextset(self):
- """
- """
+ """ """
pass
def setinputsize(self, sizes):
@@ -262,12 +243,11 @@ class TDengineCursor(object):
pass
def _reset_result(self):
- """Reset the result to unused version.
- """
+ """Reset the result to unused version."""
self._description = []
self._rowcount = -1
if self._result is not None:
- CTaosInterface.freeResult(self._result)
+ taos_free_result(self._result)
self._result = None
self._fields = None
self._block = None
@@ -276,11 +256,12 @@ class TDengineCursor(object):
self._affected_rows = 0
def _handle_result(self):
- """Handle the return result from query.
- """
+ """Handle the return result from query."""
self._description = []
for ele in self._fields:
- self._description.append(
- (ele['name'], ele['type'], None, None, None, None, False))
+ self._description.append((ele["name"], ele["type"], None, None, None, None, False))
return self._result
+
+ def __del__(self):
+ self.close()
diff --git a/src/connector/python/taos/dbapi.py b/src/connector/python/taos/dbapi.py
deleted file mode 100644
index 594681ada953abf388e503c23199043cf686e1a3..0000000000000000000000000000000000000000
--- a/src/connector/python/taos/dbapi.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""Type Objects and Constructors.
-"""
-
-import time
-import datetime
-
-
-class DBAPITypeObject(object):
- def __init__(self, *values):
- self.values = values
-
- def __com__(self, other):
- if other in self.values:
- return 0
- if other < self.values:
- return 1
- else:
- return -1
-
-
-Date = datetime.date
-Time = datetime.time
-Timestamp = datetime.datetime
-
-
-def DataFromTicks(ticks):
- return Date(*time.localtime(ticks)[:3])
-
-
-def TimeFromTicks(ticks):
- return Time(*time.localtime(ticks)[3:6])
-
-
-def TimestampFromTicks(ticks):
- return Timestamp(*time.localtime(ticks)[:6])
-
-
-Binary = bytes
-
-# STRING = DBAPITypeObject(*constants.FieldType.get_string_types())
-# BINARY = DBAPITypeObject(*constants.FieldType.get_binary_types())
-# NUMBER = BAPITypeObject(*constants.FieldType.get_number_types())
-# DATETIME = DBAPITypeObject(*constants.FieldType.get_timestamp_types())
-# ROWID = DBAPITypeObject()
diff --git a/src/connector/python/taos/error.py b/src/connector/python/taos/error.py
index c584badce8320cd35dc81e8f6b613c56163b1a29..a30adbb162f1c194bdfcf4cca5c43f01107a9776 100644
--- a/src/connector/python/taos/error.py
+++ b/src/connector/python/taos/error.py
@@ -1,66 +1,86 @@
+# encoding:UTF-8
"""Python exceptions
"""
class Error(Exception):
- def __init__(self, msg=None, errno=None):
+ def __init__(self, msg=None, errno=0xffff):
self.msg = msg
- self._full_msg = self.msg
self.errno = errno
+ self._full_msg = "[0x%04x]: %s" % (self.errno & 0xffff, self.msg)
def __str__(self):
return self._full_msg
class Warning(Exception):
- """Exception raised for important warnings like data truncations while inserting.
- """
+ """Exception raised for important warnings like data truncations while inserting."""
+
pass
class InterfaceError(Error):
- """Exception raised for errors that are related to the database interface rather than the database itself.
- """
+ """Exception raised for errors that are related to the database interface rather than the database itself."""
+
pass
class DatabaseError(Error):
- """Exception raised for errors that are related to the database.
- """
+ """Exception raised for errors that are related to the database."""
+
pass
+class ConnectionError(Error):
+ """Exceptin raised for connection failed"""
+ pass
class DataError(DatabaseError):
- """Exception raised for errors that are due to problems with the processed data like division by zero, numeric value out of range.
- """
+ """Exception raised for errors that are due to problems with the processed data like division by zero, numeric value out of range."""
+
pass
class OperationalError(DatabaseError):
- """Exception raised for errors that are related to the database's operation and not necessarily under the control of the programmer
- """
+ """Exception raised for errors that are related to the database's operation and not necessarily under the control of the programmer"""
+
pass
class IntegrityError(DatabaseError):
- """Exception raised when the relational integrity of the database is affected.
- """
+ """Exception raised when the relational integrity of the database is affected."""
+
pass
class InternalError(DatabaseError):
- """Exception raised when the database encounters an internal error.
- """
+ """Exception raised when the database encounters an internal error."""
+
pass
class ProgrammingError(DatabaseError):
- """Exception raised for programming errors.
- """
+ """Exception raised for programming errors."""
+
pass
class NotSupportedError(DatabaseError):
- """Exception raised in case a method or database API was used which is not supported by the database,.
- """
+ """Exception raised in case a method or database API was used which is not supported by the database,."""
+
pass
+
+
+class StatementError(DatabaseError):
+ """Exception raised in STMT API."""
+
+ pass
+
+class ResultError(DatabaseError):
+ """Result related APIs."""
+
+ pass
+
+class LinesError(DatabaseError):
+ """taos_insert_lines errors."""
+
+ pass
\ No newline at end of file
diff --git a/src/connector/python/taos/field.py b/src/connector/python/taos/field.py
new file mode 100644
index 0000000000000000000000000000000000000000..445cd8afdba6f2512c73be95c9b0dbd8dc00da8a
--- /dev/null
+++ b/src/connector/python/taos/field.py
@@ -0,0 +1,302 @@
+# encoding:UTF-8
+import ctypes
+import math
+import datetime
+from ctypes import *
+
+from .constants import FieldType
+from .error import *
+
+_datetime_epoch = datetime.datetime.fromtimestamp(0)
+
+def _convert_millisecond_to_datetime(milli):
+ return _datetime_epoch + datetime.timedelta(seconds=milli / 1000.0)
+
+
+def _convert_microsecond_to_datetime(micro):
+ return _datetime_epoch + datetime.timedelta(seconds=micro / 1000000.0)
+
+
+def _convert_nanosecond_to_datetime(nanosec):
+ return nanosec
+
+
+def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C bool row to python row"""
+ _timestamp_converter = _convert_millisecond_to_datetime
+ if precision == FieldType.C_TIMESTAMP_MILLI:
+ _timestamp_converter = _convert_millisecond_to_datetime
+ elif precision == FieldType.C_TIMESTAMP_MICRO:
+ _timestamp_converter = _convert_microsecond_to_datetime
+ elif precision == FieldType.C_TIMESTAMP_NANO:
+ _timestamp_converter = _convert_nanosecond_to_datetime
+ else:
+ raise DatabaseError("Unknown precision returned from database")
+
+ return [
+ None if ele == FieldType.C_BIGINT_NULL else _timestamp_converter(ele)
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_int64))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_bool_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C bool row to python row"""
+ return [
+ None if ele == FieldType.C_BOOL_NULL else bool(ele)
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_byte))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C tinyint row to python row"""
+ return [
+ None if ele == FieldType.C_TINYINT_NULL else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_byte))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_tinyint_unsigned_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C tinyint row to python row"""
+ return [
+ None if ele == FieldType.C_TINYINT_UNSIGNED_NULL else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_ubyte))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_smallint_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C smallint row to python row"""
+ return [
+ None if ele == FieldType.C_SMALLINT_NULL else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_short))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_smallint_unsigned_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C smallint row to python row"""
+ return [
+ None if ele == FieldType.C_SMALLINT_UNSIGNED_NULL else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_ushort))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_int_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C int row to python row"""
+ return [
+ None if ele == FieldType.C_INT_NULL else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_int))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_int_unsigned_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C int row to python row"""
+ return [
+ None if ele == FieldType.C_INT_UNSIGNED_NULL else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_uint))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_bigint_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C bigint row to python row"""
+ return [
+ None if ele == FieldType.C_BIGINT_NULL else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_int64))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_bigint_unsigned_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C bigint row to python row"""
+ return [
+ None if ele == FieldType.C_BIGINT_UNSIGNED_NULL else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_uint64))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_float_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C float row to python row"""
+ return [
+ None if math.isnan(ele) else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_float))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_double_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C double row to python row"""
+ return [
+ None if math.isnan(ele) else ele
+ for ele in ctypes.cast(data, ctypes.POINTER(ctypes.c_double))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_binary_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C binary row to python row"""
+ assert nbytes is not None
+ return [
+ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode("utf-8")
+ for ele in (ctypes.cast(data, ctypes.POINTER(ctypes.c_char * nbytes)))[: abs(num_of_rows)]
+ ]
+
+
+def _crow_nchar_to_python(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C nchar row to python row"""
+ assert nbytes is not None
+ res = []
+ for i in range(abs(num_of_rows)):
+ try:
+ if num_of_rows >= 0:
+ tmpstr = ctypes.c_char_p(data)
+ res.append(tmpstr.value.decode())
+ else:
+ res.append(
+ (
+ ctypes.cast(
+ data + nbytes * i,
+ ctypes.POINTER(ctypes.c_wchar * (nbytes // 4)),
+ )
+ )[0].value
+ )
+ except ValueError:
+ res.append(None)
+
+ return res
+
+
+def _crow_binary_to_python_block(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C binary row to python row"""
+ assert nbytes is not None
+ res = []
+ for i in range(abs(num_of_rows)):
+ try:
+ rbyte = ctypes.cast(data + nbytes * i, ctypes.POINTER(ctypes.c_short))[:1].pop()
+ tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
+ res.append(tmpstr.value.decode()[0:rbyte])
+ except ValueError:
+ res.append(None)
+ return res
+
+
+def _crow_nchar_to_python_block(data, num_of_rows, nbytes=None, precision=FieldType.C_TIMESTAMP_UNKNOWN):
+ """Function to convert C nchar row to python row"""
+ assert nbytes is not None
+ res = []
+ for i in range(abs(num_of_rows)):
+ try:
+ tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
+ res.append(tmpstr.value.decode())
+ except ValueError:
+ res.append(None)
+ return res
+
+
+CONVERT_FUNC = {
+ FieldType.C_BOOL: _crow_bool_to_python,
+ FieldType.C_TINYINT: _crow_tinyint_to_python,
+ FieldType.C_SMALLINT: _crow_smallint_to_python,
+ FieldType.C_INT: _crow_int_to_python,
+ FieldType.C_BIGINT: _crow_bigint_to_python,
+ FieldType.C_FLOAT: _crow_float_to_python,
+ FieldType.C_DOUBLE: _crow_double_to_python,
+ FieldType.C_BINARY: _crow_binary_to_python,
+ FieldType.C_TIMESTAMP: _crow_timestamp_to_python,
+ FieldType.C_NCHAR: _crow_nchar_to_python,
+ FieldType.C_TINYINT_UNSIGNED: _crow_tinyint_unsigned_to_python,
+ FieldType.C_SMALLINT_UNSIGNED: _crow_smallint_unsigned_to_python,
+ FieldType.C_INT_UNSIGNED: _crow_int_unsigned_to_python,
+ FieldType.C_BIGINT_UNSIGNED: _crow_bigint_unsigned_to_python,
+}
+
+CONVERT_FUNC_BLOCK = {
+ FieldType.C_BOOL: _crow_bool_to_python,
+ FieldType.C_TINYINT: _crow_tinyint_to_python,
+ FieldType.C_SMALLINT: _crow_smallint_to_python,
+ FieldType.C_INT: _crow_int_to_python,
+ FieldType.C_BIGINT: _crow_bigint_to_python,
+ FieldType.C_FLOAT: _crow_float_to_python,
+ FieldType.C_DOUBLE: _crow_double_to_python,
+ FieldType.C_BINARY: _crow_binary_to_python_block,
+ FieldType.C_TIMESTAMP: _crow_timestamp_to_python,
+ FieldType.C_NCHAR: _crow_nchar_to_python_block,
+ FieldType.C_TINYINT_UNSIGNED: _crow_tinyint_unsigned_to_python,
+ FieldType.C_SMALLINT_UNSIGNED: _crow_smallint_unsigned_to_python,
+ FieldType.C_INT_UNSIGNED: _crow_int_unsigned_to_python,
+ FieldType.C_BIGINT_UNSIGNED: _crow_bigint_unsigned_to_python,
+}
+
+# Corresponding TAOS_FIELD structure in C
+
+
+class TaosField(ctypes.Structure):
+ _fields_ = [
+ ("_name", ctypes.c_char * 65),
+ ("_type", ctypes.c_uint8),
+ ("_bytes", ctypes.c_uint16),
+ ]
+
+ @property
+ def name(self):
+ return self._name.decode("utf-8")
+
+ @property
+ def length(self):
+ """alias to self.bytes"""
+ return self._bytes
+
+ @property
+ def bytes(self):
+ return self._bytes
+
+ @property
+ def type(self):
+ return self._type
+
+ def __dict__(self):
+ return {"name": self.name, "type": self.type, "bytes": self.length}
+
+ def __str__(self):
+ return "{name: %s, type: %d, bytes: %d}" % (self.name, self.type, self.length)
+
+ def __getitem__(self, item):
+ return getattr(self, item)
+
+
+class TaosFields(object):
+ def __init__(self, fields, count):
+ if isinstance(fields, c_void_p):
+ self._fields = cast(fields, POINTER(TaosField))
+ if isinstance(fields, POINTER(TaosField)):
+ self._fields = fields
+ self._count = count
+ self._iter = 0
+
+ def as_ptr(self):
+ return self._fields
+
+ @property
+ def count(self):
+ return self._count
+
+ @property
+ def fields(self):
+ return self._fields
+
+ def __next__(self):
+ return self._next_field()
+
+ def next(self):
+ return self._next_field()
+
+ def _next_field(self):
+ if self._iter < self.count:
+ field = self._fields[self._iter]
+ self._iter += 1
+ return field
+ else:
+ raise StopIteration
+
+ def __getitem__(self, item):
+ return self._fields[item]
+
+ def __iter__(self):
+ return self
+
+ def __len__(self):
+ return self.count
diff --git a/src/connector/python/taos/precision.py b/src/connector/python/taos/precision.py
new file mode 100644
index 0000000000000000000000000000000000000000..d67da592cce6d2121ec8f2eed78a30d6fa0c446b
--- /dev/null
+++ b/src/connector/python/taos/precision.py
@@ -0,0 +1,12 @@
+class PrecisionEnum(object):
+ """Precision enums"""
+
+ Milliseconds = 0
+ Microseconds = 1
+ Nanoseconds = 2
+
+
+class PrecisionError(Exception):
+ """Python datetime does not support nanoseconds error"""
+
+ pass
diff --git a/src/connector/python/taos/result.py b/src/connector/python/taos/result.py
new file mode 100644
index 0000000000000000000000000000000000000000..81151733615d1b7fdc3318b6e53888ae39d32b14
--- /dev/null
+++ b/src/connector/python/taos/result.py
@@ -0,0 +1,245 @@
+from .cinterface import *
+
+# from .connection import TaosConnection
+from .error import *
+
+
+class TaosResult(object):
+ """TDengine result interface"""
+
+ def __init__(self, result, close_after=False, conn=None):
+ # type: (c_void_p, bool, TaosConnection) -> TaosResult
+ # to make the __del__ order right
+ self._conn = conn
+ self._close_after = close_after
+ self._result = result
+ self._fields = None
+ self._field_count = None
+ self._precision = None
+
+ self._block = None
+ self._block_length = None
+ self._row_count = 0
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ return self._next_row()
+
+ def next(self):
+ # fetch next row
+ return self._next_row()
+
+ def _next_row(self):
+ if self._result is None or self.fields is None:
+ raise OperationalError("Invalid use of fetch iterator")
+
+ if self._block == None or self._block_iter >= self._block_length:
+ self._block, self._block_length = self.fetch_block()
+ self._block_iter = 0
+ # self._row_count += self._block_length
+
+ raw = self._block[self._block_iter]
+ self._block_iter += 1
+ return raw
+
+ @property
+ def fields(self):
+ """fields definitions of the current result"""
+ if self._result is None:
+ raise ResultError("no result object setted")
+ if self._fields == None:
+ self._fields = taos_fetch_fields(self._result)
+
+ return self._fields
+
+ @property
+ def field_count(self):
+ """Field count of the current result, eq to taos_field_count(result)"""
+ return self.fields.count
+
+ @property
+ def row_count(self):
+ """Return the rowcount of the object"""
+ return self._row_count
+
+ @property
+ def precision(self):
+ if self._precision == None:
+ self._precision = taos_result_precision(self._result)
+ return self._precision
+
+ @property
+ def affected_rows(self):
+ return taos_affected_rows(self._result)
+
+ # @property
+ def field_lengths(self):
+ return taos_fetch_lengths(self._result, self.field_count)
+
+ def rows_iter(self, num_of_rows=None):
+ return TaosRows(self, num_of_rows)
+
+ def blocks_iter(self):
+ return TaosBlocks(self)
+
+ def fetch_block(self):
+ if self._result is None:
+ raise OperationalError("Invalid use of fetch iterator")
+
+ block, length = taos_fetch_block_raw(self._result)
+ if length == 0:
+ raise StopIteration
+ precision = self.precision
+ field_count = self.field_count
+ fields = self.fields
+ blocks = [None] * field_count
+ lengths = self.field_lengths()
+ for i in range(field_count):
+ data = ctypes.cast(block, ctypes.POINTER(ctypes.c_void_p))[i]
+ if fields[i].type not in CONVERT_FUNC_BLOCK:
+ raise DatabaseError("Invalid data type returned from database")
+ blocks[i] = CONVERT_FUNC_BLOCK[fields[i].type](data, length, lengths[i], precision)
+
+ return list(map(tuple, zip(*blocks))), length
+
+ def fetch_all(self):
+ if self._result is None:
+ raise OperationalError("Invalid use of fetchall")
+
+ if self._fields == None:
+ self._fields = taos_fetch_fields(self._result)
+ buffer = [[] for i in range(len(self._fields))]
+ self._row_count = 0
+ while True:
+ block, num_of_fields = taos_fetch_block(self._result, self._fields)
+ errno = taos_errno(self._result)
+ if errno != 0:
+ raise ProgrammingError(taos_errstr(self._result), errno)
+ if num_of_fields == 0:
+ break
+ self._row_count += num_of_fields
+ for i in range(len(self._fields)):
+ buffer[i].extend(block[i])
+ return list(map(tuple, zip(*buffer)))
+
+ def fetch_rows_a(self, callback, param):
+ taos_fetch_rows_a(self._result, callback, param)
+
+ def stop_query(self):
+ return taos_stop_query(self._result)
+
+ def errno(self):
+ """**DO NOT** use this directly unless you know what you are doing"""
+ return taos_errno(self._result)
+
+ def errstr(self):
+ return taos_errstr(self._result)
+
+ def check_error(self, errno=None, close=True):
+ if errno == None:
+ errno = self.errno()
+ if errno != 0:
+ msg = self.errstr()
+ self.close()
+ raise OperationalError(msg, errno)
+
+ def close(self):
+ """free result object."""
+ if self._result != None and self._close_after:
+ taos_free_result(self._result)
+ self._result = None
+ self._fields = None
+ self._field_count = None
+ self._field_lengths = None
+
+ def __del__(self):
+ self.close()
+
+
+class TaosRows:
+ """TDengine result rows iterator"""
+
+ def __init__(self, result, num_of_rows=None):
+ self._result = result
+ self._num_of_rows = num_of_rows
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ return self._next_row()
+
+ def next(self):
+ return self._next_row()
+
+ def _next_row(self):
+ if self._result is None:
+ raise OperationalError("Invalid use of fetch iterator")
+ if self._num_of_rows != None and self._num_of_rows <= self._result._row_count:
+ raise StopIteration
+
+ row = taos_fetch_row_raw(self._result._result)
+ if not row:
+ raise StopIteration
+ self._result._row_count += 1
+ return TaosRow(self._result, row)
+
+ @property
+ def row_count(self):
+ """Return the rowcount of the object"""
+ return self._result._row_count
+
+
+class TaosRow:
+ def __init__(self, result, row):
+ self._result = result
+ self._row = row
+
+ def __str__(self):
+ return taos_print_row(self._row, self._result.fields, self._result.field_count)
+
+ def __call__(self):
+ return self.as_tuple()
+
+ def _astuple(self):
+ return self.as_tuple()
+
+ def __iter__(self):
+ return self.as_tuple()
+
+ def as_ptr(self):
+ return self._row
+
+ def as_tuple(self):
+ precision = self._result.precision
+ field_count = self._result.field_count
+ blocks = [None] * field_count
+ fields = self._result.fields
+ field_lens = self._result.field_lengths()
+ for i in range(field_count):
+ data = ctypes.cast(self._row, ctypes.POINTER(ctypes.c_void_p))[i]
+ if fields[i].type not in CONVERT_FUNC:
+ raise DatabaseError("Invalid data type returned from database")
+ if data is None:
+ blocks[i] = None
+ else:
+ blocks[i] = CONVERT_FUNC[fields[i].type](data, 1, field_lens[i], precision)[0]
+ return tuple(blocks)
+
+
+class TaosBlocks:
+ """TDengine result blocks iterator"""
+
+ def __init__(self, result):
+ self._result = result
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ return self._result.fetch_block()
+
+ def next(self):
+ return self._result.fetch_block()
diff --git a/src/connector/python/taos/statement.py b/src/connector/python/taos/statement.py
new file mode 100644
index 0000000000000000000000000000000000000000..155e98173b7f920640aa84d0fcda618d2669bb1e
--- /dev/null
+++ b/src/connector/python/taos/statement.py
@@ -0,0 +1,85 @@
+from taos.cinterface import *
+from taos.error import *
+from taos.result import *
+
+
+class TaosStmt(object):
+ """TDengine STMT interface"""
+
+ def __init__(self, stmt, conn = None):
+ self._conn = conn
+ self._stmt = stmt
+
+ def set_tbname(self, name):
+ """Set table name if needed.
+
+ Note that the set_tbname* method should only used in insert statement
+ """
+ if self._stmt is None:
+ raise StatementError("Invalid use of set_tbname")
+ taos_stmt_set_tbname(self._stmt, name)
+
+ def prepare(self, sql):
+ # type: (str) -> None
+ taos_stmt_prepare(self._stmt, sql)
+
+ def set_tbname_tags(self, name, tags):
+ # type: (str, Array[TaosBind]) -> None
+ """Set table name with tags, tags is array of BindParams"""
+ if self._stmt is None:
+ raise StatementError("Invalid use of set_tbname")
+ taos_stmt_set_tbname_tags(self._stmt, name, tags)
+
+ def bind_param(self, params, add_batch=True):
+ # type: (Array[TaosBind], bool) -> None
+ if self._stmt is None:
+ raise StatementError("Invalid use of stmt")
+ taos_stmt_bind_param(self._stmt, params)
+ if add_batch:
+ taos_stmt_add_batch(self._stmt)
+
+ def bind_param_batch(self, binds, add_batch=True):
+ # type: (Array[TaosMultiBind], bool) -> None
+ if self._stmt is None:
+ raise StatementError("Invalid use of stmt")
+ taos_stmt_bind_param_batch(self._stmt, binds)
+ if add_batch:
+ taos_stmt_add_batch(self._stmt)
+
+ def add_batch(self):
+ if self._stmt is None:
+ raise StatementError("Invalid use of stmt")
+ taos_stmt_add_batch(self._stmt)
+
+ def execute(self):
+ if self._stmt is None:
+ raise StatementError("Invalid use of execute")
+ taos_stmt_execute(self._stmt)
+
+ def use_result(self):
+ result = taos_stmt_use_result(self._stmt)
+ return TaosResult(result)
+
+ def close(self):
+ """Close stmt."""
+ if self._stmt is None:
+ return
+ taos_stmt_close(self._stmt)
+ self._stmt = None
+
+ def __del__(self):
+ self.close()
+
+
+if __name__ == "__main__":
+ from taos.connection import TaosConnection
+
+ conn = TaosConnection()
+
+ stmt = conn.statement("select * from log.log limit 10")
+ stmt.execute()
+ result = stmt.use_result()
+ for row in result:
+ print(row)
+ stmt.close()
+ conn.close()
diff --git a/src/connector/python/taos/stream.py b/src/connector/python/taos/stream.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe3c8c85e3279511972293882224bf20c30dfa64
--- /dev/null
+++ b/src/connector/python/taos/stream.py
@@ -0,0 +1,22 @@
+from taos.cinterface import *
+from taos.error import *
+from taos.result import *
+
+
+class TaosStream(object):
+ """TDengine Stream interface"""
+
+ def __init__(self, stream):
+ self._raw = stream
+
+ def as_ptr(self):
+ return self._raw
+
+ def close(self):
+ """Close stmt."""
+ if self._raw is not None:
+ taos_close_stream(self._raw)
+ self._raw = None
+
+ def __del__(self):
+ self.close()
diff --git a/src/connector/python/taos/subscription.py b/src/connector/python/taos/subscription.py
index 270d9de09217fc58a389981a3542698dd1c0428a..3c6958b6f8d55791b9753a84a4bbd7653bdae780 100644
--- a/src/connector/python/taos/subscription.py
+++ b/src/connector/python/taos/subscription.py
@@ -1,49 +1,41 @@
-from .cinterface import CTaosInterface
+from taos.result import TaosResult
+from .cinterface import *
from .error import *
-class TDengineSubscription(object):
- """TDengine subscription object
- """
+class TaosSubscription(object):
+ """TDengine subscription object"""
- def __init__(self, sub):
+ def __init__(self, sub, with_callback = False):
self._sub = sub
+ self._with_callback = with_callback
def consume(self):
- """Consume rows of a subscription
- """
+ """Consume rows of a subscription"""
if self._sub is None:
raise OperationalError("Invalid use of consume")
-
- result, fields = CTaosInterface.consume(self._sub)
- buffer = [[] for i in range(len(fields))]
- while True:
- block, num_of_fields = CTaosInterface.fetchBlock(result, fields)
- if num_of_fields == 0:
- break
- for i in range(len(fields)):
- buffer[i].extend(block[i])
-
- self.fields = fields
- return list(map(tuple, zip(*buffer)))
+ if self._with_callback:
+ raise OperationalError("DONOT use consume method in an subscription with callback")
+ result = taos_consume(self._sub)
+ return TaosResult(result)
def close(self, keepProgress=True):
- """Close the Subscription.
- """
+ """Close the Subscription."""
if self._sub is None:
return False
- CTaosInterface.unsubscribe(self._sub, keepProgress)
+ taos_unsubscribe(self._sub, keepProgress)
+ self._sub = None
return True
+
+ def __del__(self):
+ self.close()
+
+if __name__ == "__main__":
+ from .connection import TaosConnection
-if __name__ == '__main__':
- from .connection import TDengineConnection
- conn = TDengineConnection(
- host="127.0.0.1",
- user="root",
- password="taosdata",
- database="test")
+ conn = TaosConnection(host="127.0.0.1", user="root", password="taosdata", database="test")
# Generate a cursor object to run SQL commands
sub = conn.subscribe(True, "test", "select * from meters;", 1000)
diff --git a/src/connector/python/taos/timestamp.py b/src/connector/python/taos/timestamp.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab5679fdf12e2942aa94f76716ff98e6d2a88d69
--- /dev/null
+++ b/src/connector/python/taos/timestamp.py
@@ -0,0 +1,17 @@
+
+class TimestampType(object):
+ """Choose which type that parsing TDengine timestamp data to
+
+ - DATETIME: use python datetime.datetime, note that it does not support nanosecond precision,
+ and python taos will use raw c_int64 as a fallback for nanosecond results.
+ - NUMPY: use numpy.datetime64 type.
+ - RAW: use raw c_int64.
+ - TAOS: use taos' TaosTimestamp.
+ """
+ DATETIME = 0,
+ NUMPY = 1,
+ RAW = 2,
+ TAOS = 3,
+
+class TaosTimestamp:
+ pass
diff --git a/src/connector/python/tests/test-td6231.py b/src/connector/python/tests/test-td6231.py
new file mode 100644
index 0000000000000000000000000000000000000000..e55d22c10734eedcbd5be8012eaeb3fb3d51e381
--- /dev/null
+++ b/src/connector/python/tests/test-td6231.py
@@ -0,0 +1,50 @@
+from taos import *
+
+conn = connect()
+
+dbname = "pytest_taos_stmt_multi"
+conn.execute("drop database if exists %s" % dbname)
+conn.execute("create database if not exists %s" % dbname)
+conn.select_db(dbname)
+
+conn.execute(
+ "create table if not exists log(ts timestamp, bo bool, nil tinyint, \
+ ti tinyint, si smallint, ii int, bi bigint, tu tinyint unsigned, \
+ su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+ ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
+)
+
+stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+
+params = new_multi_binds(16)
+params[0].timestamp((1626861392589, 1626861392590, 1626861392591))
+params[1].bool((True, None, False))
+params[2].tinyint([-128, -128, None]) # -128 is tinyint null
+params[3].tinyint([0, 127, None])
+params[4].smallint([3, None, 2])
+params[5].int([3, 4, None])
+params[6].bigint([3, 4, None])
+params[7].tinyint_unsigned([3, 4, None])
+params[8].smallint_unsigned([3, 4, None])
+params[9].int_unsigned([3, 4, None])
+params[10].bigint_unsigned([3, 4, None])
+params[11].float([3, None, 1])
+params[12].double([3, None, 1.2])
+params[13].binary(["abc", "dddafadfadfadfadfa", None])
+# params[14].nchar(["涛思数据", None, "a long string with 中文字符"])
+params[14].nchar([None, None, None])
+params[15].timestamp([None, None, 1626861392591])
+stmt.bind_param_batch(params)
+stmt.execute()
+
+
+result = stmt.use_result()
+assert result.affected_rows == 3
+result.close()
+
+result = conn.query("select * from log")
+for row in result:
+ print(row)
+result.close()
+stmt.close()
+conn.close()
diff --git a/src/connector/python/tests/test_ctaos.py b/src/connector/python/tests/test_ctaos.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b9566931f2b29dcbdc8646d2f087ebf40e716cc
--- /dev/null
+++ b/src/connector/python/tests/test_ctaos.py
@@ -0,0 +1,162 @@
+from taos.cinterface import *
+from taos.precision import *
+from taos.bind import *
+
+import time
+import datetime
+import pytest
+
+@pytest.fixture
+def conn():
+ return CTaosInterface().connect()
+
+
+def test_simple(conn, caplog):
+ dbname = "pytest_ctaos_simple"
+ try:
+ res = taos_query(conn, "create database if not exists %s" % dbname)
+ taos_free_result(res)
+
+ taos_select_db(conn, dbname)
+
+ res = taos_query(
+ conn,
+ "create table if not exists log(ts timestamp, level tinyint, content binary(100), ipaddr binary(134))",
+ )
+ taos_free_result(res)
+
+ res = taos_query(conn, "insert into log values(now, 1, 'hello', 'test')")
+ taos_free_result(res)
+
+ res = taos_query(conn, "select level,content,ipaddr from log limit 1")
+
+ fields = taos_fetch_fields_raw(res)
+ field_count = taos_field_count(res)
+
+ fields = taos_fetch_fields(res)
+ for field in fields:
+ print(field)
+
+ # field_lengths = taos_fetch_lengths(res, field_count)
+ # if not field_lengths:
+ # raise "fetch lengths error"
+
+ row = taos_fetch_row_raw(res)
+ rowstr = taos_print_row(row, fields, field_count)
+ assert rowstr == "1 hello test"
+
+ row, num = taos_fetch_row(res, fields)
+ print(row)
+ taos_free_result(res)
+ taos_query(conn, "drop database if exists " + dbname)
+ taos_close(conn)
+ except Exception as err:
+ taos_query(conn, "drop database if exists " + dbname)
+ raise err
+
+
+def test_stmt(conn, caplog):
+ dbname = "pytest_ctaos_stmt"
+ try:
+ res = taos_query(conn, "drop database if exists %s" % dbname)
+ taos_free_result(res)
+ res = taos_query(conn, "create database if not exists %s" % dbname)
+ taos_free_result(res)
+
+ taos_select_db(conn, dbname)
+
+ res = taos_query(
+ conn,
+ "create table if not exists log(ts timestamp, nil tinyint, ti tinyint, si smallint, ii int,\
+ bi bigint, tu tinyint unsigned, su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+ ff float, dd double, bb binary(100), nn nchar(100))",
+ )
+ taos_free_result(res)
+
+ stmt = taos_stmt_init(conn)
+
+ taos_stmt_prepare(stmt, "insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+
+ params = new_bind_params(14)
+ params[0].timestamp(1626861392589, PrecisionEnum.Milliseconds)
+ params[1].null()
+ params[2].tinyint(2)
+ params[3].smallint(3)
+ params[4].int(4)
+ params[5].bigint(5)
+ params[6].tinyint_unsigned(6)
+ params[7].smallint_unsigned(7)
+ params[8].int_unsigned(8)
+ params[9].bigint_unsigned(9)
+ params[10].float(10.1)
+ params[11].double(10.11)
+ params[12].binary("hello")
+ params[13].nchar("stmt")
+ taos_stmt_bind_param(stmt, params)
+ taos_stmt_add_batch(stmt)
+ taos_stmt_execute(stmt)
+
+ res = taos_query(conn, "select * from log limit 1")
+
+ fields = taos_fetch_fields(res)
+ filed_count = taos_field_count(res)
+
+ row = taos_fetch_row_raw(res)
+ rowstr = taos_print_row(row, fields, filed_count, 100)
+
+ taos_free_result(res)
+ taos_query(conn, "drop database if exists " + dbname)
+ taos_close(conn)
+
+ assert rowstr == "1626861392589 NULL 2 3 4 5 6 7 8 9 10.100000 10.110000 hello stmt"
+ except Exception as err:
+ taos_query(conn, "drop database if exists " + dbname)
+ raise err
+
+def stream_callback(param, result, row):
+ # type: (c_void_p, c_void_p, c_void_p) -> None
+ try:
+ if result == None or row == None:
+ return
+ result = c_void_p(result)
+ row = c_void_p(row)
+ fields = taos_fetch_fields_raw(result)
+ num_fields = taos_field_count(result)
+ s = taos_print_row(row, fields, num_fields)
+ print(s)
+ taos_stop_query(result)
+ except Exception as err:
+ print(err)
+
+def test_stream(conn, caplog):
+ dbname = "pytest_ctaos_stream"
+ try:
+ res = taos_query(conn, "create database if not exists %s" % dbname)
+ taos_free_result(res)
+
+ taos_select_db(conn, dbname)
+
+ res = taos_query(
+ conn,
+ "create table if not exists log(ts timestamp, n int)",
+ )
+ taos_free_result(res)
+
+ res = taos_query(conn, "select count(*) from log interval(5s)")
+ cc = taos_num_fields(res)
+ assert cc == 2
+
+ stream = taos_open_stream(conn, "select count(*) from log interval(5s)", stream_callback, 0, None, None)
+ print("waiting for data")
+ time.sleep(1)
+
+ for i in range(0, 2):
+ res = taos_query(conn, "insert into log values(now,0)(now+1s, 1)(now + 2s, 2)")
+ taos_free_result(res)
+ time.sleep(2)
+ taos_close_stream(stream)
+ taos_query(conn, "drop database if exists " + dbname)
+ taos_close(conn)
+ except Exception as err:
+ taos_query(conn, "drop database if exists " + dbname)
+ raise err
diff --git a/src/connector/python/tests/test_info.py b/src/connector/python/tests/test_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..bddfec7ef9ddbc203adfcadd262839048466592c
--- /dev/null
+++ b/src/connector/python/tests/test_info.py
@@ -0,0 +1,23 @@
+from taos.cinterface import *
+
+from taos import *
+
+import pytest
+
+@pytest.fixture
+def conn():
+ return connect()
+
+def test_client_info():
+ print(taos_get_client_info())
+ None
+
+def test_server_info(conn):
+ # type: (TaosConnection) -> None
+ print(conn.client_info)
+ print(conn.server_info)
+ None
+
+if __name__ == "__main__":
+ test_client_info()
+ test_server_info(connect())
diff --git a/src/connector/python/tests/test_lines.py b/src/connector/python/tests/test_lines.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd9d2cdb39d6f4f2612581ce7284c057c456ef91
--- /dev/null
+++ b/src/connector/python/tests/test_lines.py
@@ -0,0 +1,57 @@
+from taos.error import OperationalError
+from taos import connect, new_bind_params, PrecisionEnum
+from taos import *
+
+from ctypes import *
+import taos
+import pytest
+
+
+@pytest.fixture
+def conn():
+ # type: () -> taos.TaosConnection
+ return connect()
+
+
+def test_insert_lines(conn):
+ # type: (TaosConnection) -> None
+
+ dbname = "pytest_taos_insert_lines"
+ try:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.execute("create database if not exists %s precision 'us'" % dbname)
+ conn.select_db(dbname)
+
+ lines = [
+ 'st,t1=3i64,t2=4f64,t3="t3" c1=3i64,c3=L"passit",c2=false,c4=4f64 1626006833639000000ns',
+ 'st,t1=4i64,t3="t4",t2=5f64,t4=5f64 c1=3i64,c3=L"passitagin",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns',
+ 'stf,t1=4i64,t3="t4",t2=5f64,t4=5f64 c1=3i64,c3=L"passitagin_stf",c2=false,c5=5f64,c6=7u64 1626006933641000000ns',
+ ]
+ conn.insert_lines(lines)
+ print("inserted")
+
+ lines = [
+ 'stf,t1=5i64,t3="t4",t2=5f64,t4=5f64 c1=3i64,c3=L"passitagin_stf",c2=false,c5=5f64,c6=7u64 1626006933641000000ns',
+ ]
+ conn.insert_lines(lines)
+ print("inserted")
+ result = conn.query("select * from st")
+ print(*result.fields)
+ all = result.rows_iter()
+ for row in all:
+ print(row)
+ result.close()
+ print(result.row_count)
+
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+
+ except Exception as err:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+ print(err)
+ raise err
+
+
+if __name__ == "__main__":
+ test_insert_lines(connect())
diff --git a/src/connector/python/tests/test_query.py b/src/connector/python/tests/test_query.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4e139b1f14df29e8b6304dd2ca03519ea274f43
--- /dev/null
+++ b/src/connector/python/tests/test_query.py
@@ -0,0 +1,43 @@
+from datetime import datetime
+import taos
+import pytest
+
+@pytest.fixture
+def conn():
+ return taos.connect()
+
+def test_query(conn):
+ """This test will use fetch_block for rows fetching, significantly faster than rows_iter"""
+ result = conn.query("select * from log.log limit 10000")
+ fields = result.fields
+ for field in fields:
+ print("field: %s" % field)
+ start = datetime.now()
+ for row in result:
+ # print(row)
+ None
+ end = datetime.now()
+ elapsed = end - start
+ print("elapsed time: ", elapsed)
+ result.close()
+ conn.close()
+
+def test_query_row_iter(conn):
+ """This test will use fetch_row for each row fetching, this is the only way in async callback"""
+ result = conn.query("select * from log.log limit 10000")
+ fields = result.fields
+ for field in fields:
+ print("field: %s" % field)
+ start = datetime.now()
+ for row in result.rows_iter():
+ # print(row)
+ None
+ end = datetime.now()
+ elapsed = end - start
+ print("elapsed time: ", elapsed)
+ result.close()
+ conn.close()
+
+if __name__ == "__main__":
+ test_query(taos.connect(database = "log"))
+ test_query_row_iter(taos.connect(database = "log"))
diff --git a/src/connector/python/tests/test_query_a.py b/src/connector/python/tests/test_query_a.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b4be5695a87f1fd1017435b13983df7c4f70f06
--- /dev/null
+++ b/src/connector/python/tests/test_query_a.py
@@ -0,0 +1,66 @@
+from taos import *
+from ctypes import *
+import taos
+import pytest
+import time
+
+
+@pytest.fixture
+def conn():
+ return taos.connect()
+
+def fetch_callback(p_param, p_result, num_of_rows):
+ print("fetched ", num_of_rows, "rows")
+ p = cast(p_param, POINTER(Counter))
+ result = TaosResult(p_result)
+
+ if num_of_rows == 0:
+ print("fetching completed")
+ p.contents.done = True
+ result.close()
+ return
+ if num_of_rows < 0:
+ p.contents.done = True
+ result.check_error(num_of_rows)
+ result.close()
+ return None
+
+ for row in result.rows_iter(num_of_rows):
+ # print(row)
+ None
+ p.contents.count += result.row_count
+ result.fetch_rows_a(fetch_callback, p_param)
+
+
+
+def query_callback(p_param, p_result, code):
+ # type: (c_void_p, c_void_p, c_int) -> None
+ if p_result == None:
+ return
+ result = TaosResult(p_result)
+ if code == 0:
+ result.fetch_rows_a(fetch_callback, p_param)
+ result.check_error(code)
+
+
+class Counter(Structure):
+ _fields_ = [("count", c_int), ("done", c_bool)]
+
+ def __str__(self):
+ return "{ count: %d, done: %s }" % (self.count, self.done)
+
+
+def test_query(conn):
+ # type: (TaosConnection) -> None
+ counter = Counter(count=0)
+ conn.query_a("select * from log.log", query_callback, byref(counter))
+
+ while not counter.done:
+ print("wait query callback")
+ time.sleep(1)
+ print(counter)
+ conn.close()
+
+
+if __name__ == "__main__":
+ test_query(taos.connect())
diff --git a/src/connector/python/tests/test_stmt.py b/src/connector/python/tests/test_stmt.py
new file mode 100644
index 0000000000000000000000000000000000000000..938ba10eb3d2377a63f7972deb99dbd47f7de1b2
--- /dev/null
+++ b/src/connector/python/tests/test_stmt.py
@@ -0,0 +1,149 @@
+from taos import *
+
+from ctypes import *
+from datetime import datetime
+import taos
+import pytest
+
+@pytest.fixture
+def conn():
+ # type: () -> taos.TaosConnection
+ return connect()
+
+def test_stmt_insert(conn):
+ # type: (TaosConnection) -> None
+
+ dbname = "pytest_taos_stmt"
+ try:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.execute("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+
+ conn.execute(
+ "create table if not exists log(ts timestamp, bo bool, nil tinyint, ti tinyint, si smallint, ii int,\
+ bi bigint, tu tinyint unsigned, su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+ ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
+ )
+ conn.load_table_info("log")
+
+
+ stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+ params = new_bind_params(16)
+ params[0].timestamp(1626861392589, PrecisionEnum.Milliseconds)
+ params[1].bool(True)
+ params[2].null()
+ params[3].tinyint(2)
+ params[4].smallint(3)
+ params[5].int(4)
+ params[6].bigint(5)
+ params[7].tinyint_unsigned(6)
+ params[8].smallint_unsigned(7)
+ params[9].int_unsigned(8)
+ params[10].bigint_unsigned(9)
+ params[11].float(10.1)
+ params[12].double(10.11)
+ params[13].binary("hello")
+ params[14].nchar("stmt")
+ params[15].timestamp(1626861392589, PrecisionEnum.Milliseconds)
+
+ stmt.bind_param(params)
+ stmt.execute()
+
+ result = stmt.use_result()
+ assert result.affected_rows == 1
+ result.close()
+ stmt.close()
+
+ stmt = conn.statement("select * from log")
+ stmt.execute()
+ result = stmt.use_result()
+ row = result.next()
+ print(row)
+ assert row[2] == None
+ for i in range(3, 11):
+ assert row[i] == i - 1
+ #float == may not work as expected
+ # assert row[10] == c_float(10.1)
+ assert row[12] == 10.11
+ assert row[13] == "hello"
+ assert row[14] == "stmt"
+
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+
+ except Exception as err:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+ raise err
+
+def test_stmt_insert_multi(conn):
+ # type: (TaosConnection) -> None
+
+ dbname = "pytest_taos_stmt_multi"
+ try:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.execute("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+
+ conn.execute(
+ "create table if not exists log(ts timestamp, bo bool, nil tinyint, ti tinyint, si smallint, ii int,\
+ bi bigint, tu tinyint unsigned, su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+ ff float, dd double, bb binary(100), nn nchar(100), tt timestamp)",
+ )
+ conn.load_table_info("log")
+
+ start = datetime.now()
+ stmt = conn.statement("insert into log values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
+
+ params = new_multi_binds(16)
+ params[0].timestamp((1626861392589, 1626861392590, 1626861392591))
+ params[1].bool((True, None, False))
+ params[2].tinyint([-128, -128, None]) # -128 is tinyint null
+ params[3].tinyint([0, 127, None])
+ params[4].smallint([3, None, 2])
+ params[5].int([3, 4, None])
+ params[6].bigint([3, 4, None])
+ params[7].tinyint_unsigned([3, 4, None])
+ params[8].smallint_unsigned([3, 4, None])
+ params[9].int_unsigned([3, 4, None])
+ params[10].bigint_unsigned([3, 4, None])
+ params[11].float([3, None, 1])
+ params[12].double([3, None, 1.2])
+ params[13].binary(["abc", "dddafadfadfadfadfa", None])
+ params[14].nchar(["涛思数据", None, "a long string with 中文字符"])
+ params[15].timestamp([None, None, 1626861392591])
+ stmt.bind_param_batch(params)
+
+ stmt.execute()
+ end = datetime.now()
+ print("elapsed time: ", end - start)
+ result = stmt.use_result()
+ assert result.affected_rows == 3
+ result.close()
+ stmt.close()
+
+ stmt = conn.statement("select * from log")
+ stmt.execute()
+ result = stmt.use_result()
+ for row in result:
+ print(row)
+ result.close()
+
+ stmt.close()
+
+ # start = datetime.now()
+ # conn.query("insert into log values(1626861392660, true, NULL, 0, 3,3,3,3,3,3,3,3.0,3.0, 'abc','涛思数据',NULL)(1626861392661, true, NULL, 0, 3,3,3,3,3,3,3,3.0,3.0, 'abc','涛思数据',NULL)(1626861392662, true, NULL, 0, 3,3,3,3,3,3,3,3.0,3.0, 'abc','涛思数据',NULL)")
+
+ # end = datetime.now()
+ # print("elapsed time: ", end - start)
+
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+
+ except Exception as err:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+ raise err
+if __name__ == "__main__":
+ test_stmt_insert(connect())
+ test_stmt_insert_multi(connect())
\ No newline at end of file
diff --git a/src/connector/python/tests/test_stream.py b/src/connector/python/tests/test_stream.py
new file mode 100644
index 0000000000000000000000000000000000000000..de6e20928b176e51bc6d350fb01268459f4e7f95
--- /dev/null
+++ b/src/connector/python/tests/test_stream.py
@@ -0,0 +1,70 @@
+from taos.cinterface import *
+from taos.precision import *
+from taos.bind import *
+from taos import *
+from ctypes import *
+import time
+import pytest
+
+
+@pytest.fixture
+def conn():
+ return connect()
+
+
+def stream_callback(p_param, p_result, p_row):
+ # type: (c_void_p, c_void_p, c_void_p) -> None
+
+ if p_result == None or p_row == None:
+ return
+ result = TaosResult(p_result)
+ row = TaosRow(result, p_row)
+ try:
+ ts, count = row()
+ p = cast(p_param, POINTER(Counter))
+ p.contents.count += count
+ print("[%s] inserted %d in 5s, total count: %d" % (ts.strftime("%Y-%m-%d %H:%M:%S"), count, p.contents.count))
+
+ except Exception as err:
+ print(err)
+ raise err
+
+
+class Counter(ctypes.Structure):
+ _fields_ = [
+ ("count", c_int),
+ ]
+
+ def __str__(self):
+ return "%d" % self.count
+
+
+def test_stream(conn):
+ # type: (TaosConnection) -> None
+ dbname = "pytest_taos_stream"
+ try:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.execute("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+ conn.execute("create table if not exists log(ts timestamp, n int)")
+
+ result = conn.query("select count(*) from log interval(5s)")
+ assert result.field_count == 2
+ counter = Counter()
+ counter.count = 0
+ stream = conn.stream("select count(*) from log interval(5s)", stream_callback, param=byref(counter))
+
+ for _ in range(0, 20):
+ conn.execute("insert into log values(now,0)(now+1s, 1)(now + 2s, 2)")
+ time.sleep(2)
+ stream.close()
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+ except Exception as err:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+ raise err
+
+
+if __name__ == "__main__":
+ test_stream(connect())
diff --git a/src/connector/python/tests/test_subscribe.py b/src/connector/python/tests/test_subscribe.py
new file mode 100644
index 0000000000000000000000000000000000000000..99fe5b263625c63200f416ec98fcb561773becd8
--- /dev/null
+++ b/src/connector/python/tests/test_subscribe.py
@@ -0,0 +1,100 @@
+from taos.subscription import TaosSubscription
+from taos import *
+from ctypes import *
+import taos
+import pytest
+import time
+from random import random
+
+
+@pytest.fixture
+def conn():
+ return taos.connect()
+
+
+def test_subscribe(conn):
+ # type: (TaosConnection) -> None
+
+ dbname = "pytest_taos_subscribe_callback"
+ try:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.execute("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+ conn.execute("create table if not exists log(ts timestamp, n int)")
+ for i in range(10):
+ conn.execute("insert into log values(now, %d)" % i)
+
+ sub = conn.subscribe(True, "test", "select * from log", 1000)
+ print("# consume from begin")
+ for ts, n in sub.consume():
+ print(ts, n)
+
+ print("# consume new data")
+ for i in range(5):
+ conn.execute("insert into log values(now, %d)(now+1s, %d)" % (i, i))
+ result = sub.consume()
+ for ts, n in result:
+ print(ts, n)
+
+ print("# consume with a stop condition")
+ for i in range(10):
+ conn.execute("insert into log values(now, %d)" % int(random() * 10))
+ result = sub.consume()
+ try:
+ ts, n = next(result)
+ print(ts, n)
+ if n > 5:
+ result.stop_query()
+ print("## stopped")
+ break
+ except StopIteration:
+ continue
+
+ sub.close()
+
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+ except Exception as err:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+ raise err
+
+
+def subscribe_callback(p_sub, p_result, p_param, errno):
+ # type: (c_void_p, c_void_p, c_void_p, c_int) -> None
+ print("callback")
+ result = TaosResult(p_result)
+ result.check_error(errno)
+ for row in result.rows_iter():
+ ts, n = row()
+ print(ts, n)
+
+
+def test_subscribe_callback(conn):
+ # type: (TaosConnection) -> None
+ dbname = "pytest_taos_subscribe_callback"
+ try:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.execute("create database if not exists %s" % dbname)
+ conn.select_db(dbname)
+ conn.execute("create table if not exists log(ts timestamp, n int)")
+
+ print("# subscribe with callback")
+ sub = conn.subscribe(False, "test", "select * from log", 1000, subscribe_callback)
+
+ for i in range(10):
+ conn.execute("insert into log values(now, %d)" % i)
+ time.sleep(0.7)
+ sub.close()
+
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+ except Exception as err:
+ conn.execute("drop database if exists %s" % dbname)
+ conn.close()
+ raise err
+
+
+if __name__ == "__main__":
+ test_subscribe(taos.connect())
+ test_subscribe_callback(taos.connect())
diff --git a/src/dnode/src/dnodeMain.c b/src/dnode/src/dnodeMain.c
index eac04fe7bb2c53bd55dcbf8b6f5044d99007dc6c..5291fb73a05da27f98252b680542a83ec41c94a7 100644
--- a/src/dnode/src/dnodeMain.c
+++ b/src/dnode/src/dnodeMain.c
@@ -166,7 +166,6 @@ int32_t dnodeInitSystem() {
taosInitGlobalCfg();
taosReadGlobalLogCfg();
taosSetCoreDump();
- taosInitNotes();
dnodeInitTmr();
if (dnodeCreateDir(tsLogDir) < 0) {
@@ -188,6 +187,8 @@ int32_t dnodeInitSystem() {
dInfo("start to initialize TDengine");
+ taosInitNotes();
+
if (dnodeInitComponents() != 0) {
return -1;
}
diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index 94be247b0d8163be09ffff981636258779b6bfca..bc4ddbe067b0997695ef22bbcc21228df9e92199 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -87,6 +87,8 @@ extern const int32_t TYPE_BYTES[15];
#define TSDB_DEFAULT_PASS "taosdata"
#endif
+#define SHELL_MAX_PASSWORD_LEN 20
+
#define TSDB_TRUE 1
#define TSDB_FALSE 0
#define TSDB_OK 0
diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index 2214078f5587799ff4daea4f708e920a95e97fcf..000703464cfb8c687e473b7559e1048c42f8a6de 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -103,6 +103,9 @@ int32_t* taosGetErrno();
#define TSDB_CODE_TSC_FILE_EMPTY TAOS_DEF_ERROR_CODE(0, 0x021A) //"File is empty")
#define TSDB_CODE_TSC_LINE_SYNTAX_ERROR TAOS_DEF_ERROR_CODE(0, 0x021B) //"Syntax error in Line")
#define TSDB_CODE_TSC_NO_META_CACHED TAOS_DEF_ERROR_CODE(0, 0x021C) //"No table meta cached")
+#define TSDB_CODE_TSC_DUP_COL_NAMES TAOS_DEF_ERROR_CODE(0, 0x021D) //"duplicated column names")
+#define TSDB_CODE_TSC_INVALID_TAG_LENGTH TAOS_DEF_ERROR_CODE(0, 0x021E) //"Invalid tag length")
+#define TSDB_CODE_TSC_INVALID_COLUMN_LENGTH TAOS_DEF_ERROR_CODE(0, 0x021F) //"Invalid column length")
// mnode
#define TSDB_CODE_MND_MSG_NOT_PROCESSED TAOS_DEF_ERROR_CODE(0, 0x0300) //"Message not processed")
@@ -185,6 +188,9 @@ int32_t* taosGetErrno();
#define TSDB_CODE_MND_INVALID_FUNC TAOS_DEF_ERROR_CODE(0, 0x0374) //"Invalid func")
#define TSDB_CODE_MND_INVALID_FUNC_BUFSIZE TAOS_DEF_ERROR_CODE(0, 0x0375) //"Invalid func bufSize")
+#define TSDB_CODE_MND_INVALID_TAG_LENGTH TAOS_DEF_ERROR_CODE(0, 0x0376) //"invalid tag length")
+#define TSDB_CODE_MND_INVALID_COLUMN_LENGTH TAOS_DEF_ERROR_CODE(0, 0x0377) //"invalid column length")
+
#define TSDB_CODE_MND_DB_NOT_SELECTED TAOS_DEF_ERROR_CODE(0, 0x0380) //"Database not specified or available")
#define TSDB_CODE_MND_DB_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x0381) //"Database already exists")
#define TSDB_CODE_MND_INVALID_DB_OPTION TAOS_DEF_ERROR_CODE(0, 0x0382) //"Invalid database options")
diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index e89fed628262eb78067c63e0f74347dc29123378..0a84d7f13b735e0589b4df5e17122ed2b0fe69b2 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -92,124 +92,125 @@
#define TK_ACCOUNT 74
#define TK_USE 75
#define TK_DESCRIBE 76
-#define TK_ALTER 77
-#define TK_PASS 78
-#define TK_PRIVILEGE 79
-#define TK_LOCAL 80
-#define TK_COMPACT 81
-#define TK_LP 82
-#define TK_RP 83
-#define TK_IF 84
-#define TK_EXISTS 85
-#define TK_AS 86
-#define TK_OUTPUTTYPE 87
-#define TK_AGGREGATE 88
-#define TK_BUFSIZE 89
-#define TK_PPS 90
-#define TK_TSERIES 91
-#define TK_DBS 92
-#define TK_STORAGE 93
-#define TK_QTIME 94
-#define TK_CONNS 95
-#define TK_STATE 96
-#define TK_COMMA 97
-#define TK_KEEP 98
-#define TK_CACHE 99
-#define TK_REPLICA 100
-#define TK_QUORUM 101
-#define TK_DAYS 102
-#define TK_MINROWS 103
-#define TK_MAXROWS 104
-#define TK_BLOCKS 105
-#define TK_CTIME 106
-#define TK_WAL 107
-#define TK_FSYNC 108
-#define TK_COMP 109
-#define TK_PRECISION 110
-#define TK_UPDATE 111
-#define TK_CACHELAST 112
-#define TK_PARTITIONS 113
-#define TK_UNSIGNED 114
-#define TK_TAGS 115
-#define TK_USING 116
-#define TK_NULL 117
-#define TK_NOW 118
-#define TK_SELECT 119
-#define TK_UNION 120
-#define TK_ALL 121
-#define TK_DISTINCT 122
-#define TK_FROM 123
-#define TK_VARIABLE 124
-#define TK_INTERVAL 125
-#define TK_SESSION 126
-#define TK_STATE_WINDOW 127
-#define TK_FILL 128
-#define TK_SLIDING 129
-#define TK_ORDER 130
-#define TK_BY 131
-#define TK_ASC 132
-#define TK_DESC 133
-#define TK_GROUP 134
-#define TK_HAVING 135
-#define TK_LIMIT 136
-#define TK_OFFSET 137
-#define TK_SLIMIT 138
-#define TK_SOFFSET 139
-#define TK_WHERE 140
-#define TK_RESET 141
-#define TK_QUERY 142
-#define TK_SYNCDB 143
-#define TK_ADD 144
-#define TK_COLUMN 145
-#define TK_MODIFY 146
-#define TK_TAG 147
-#define TK_CHANGE 148
-#define TK_SET 149
-#define TK_KILL 150
-#define TK_CONNECTION 151
-#define TK_STREAM 152
-#define TK_COLON 153
-#define TK_ABORT 154
-#define TK_AFTER 155
-#define TK_ATTACH 156
-#define TK_BEFORE 157
-#define TK_BEGIN 158
-#define TK_CASCADE 159
-#define TK_CLUSTER 160
-#define TK_CONFLICT 161
-#define TK_COPY 162
-#define TK_DEFERRED 163
-#define TK_DELIMITERS 164
-#define TK_DETACH 165
-#define TK_EACH 166
-#define TK_END 167
-#define TK_EXPLAIN 168
-#define TK_FAIL 169
-#define TK_FOR 170
-#define TK_IGNORE 171
-#define TK_IMMEDIATE 172
-#define TK_INITIALLY 173
-#define TK_INSTEAD 174
-#define TK_MATCH 175
-#define TK_KEY 176
-#define TK_OF 177
-#define TK_RAISE 178
-#define TK_REPLACE 179
-#define TK_RESTRICT 180
-#define TK_ROW 181
-#define TK_STATEMENT 182
-#define TK_TRIGGER 183
-#define TK_VIEW 184
-#define TK_SEMI 185
-#define TK_NONE 186
-#define TK_PREV 187
-#define TK_LINEAR 188
-#define TK_IMPORT 189
-#define TK_TBNAME 190
-#define TK_JOIN 191
-#define TK_INSERT 192
-#define TK_INTO 193
-#define TK_VALUES 194
+#define TK_DESC 77
+#define TK_ALTER 78
+#define TK_PASS 79
+#define TK_PRIVILEGE 80
+#define TK_LOCAL 81
+#define TK_COMPACT 82
+#define TK_LP 83
+#define TK_RP 84
+#define TK_IF 85
+#define TK_EXISTS 86
+#define TK_AS 87
+#define TK_OUTPUTTYPE 88
+#define TK_AGGREGATE 89
+#define TK_BUFSIZE 90
+#define TK_PPS 91
+#define TK_TSERIES 92
+#define TK_DBS 93
+#define TK_STORAGE 94
+#define TK_QTIME 95
+#define TK_CONNS 96
+#define TK_STATE 97
+#define TK_COMMA 98
+#define TK_KEEP 99
+#define TK_CACHE 100
+#define TK_REPLICA 101
+#define TK_QUORUM 102
+#define TK_DAYS 103
+#define TK_MINROWS 104
+#define TK_MAXROWS 105
+#define TK_BLOCKS 106
+#define TK_CTIME 107
+#define TK_WAL 108
+#define TK_FSYNC 109
+#define TK_COMP 110
+#define TK_PRECISION 111
+#define TK_UPDATE 112
+#define TK_CACHELAST 113
+#define TK_PARTITIONS 114
+#define TK_UNSIGNED 115
+#define TK_TAGS 116
+#define TK_USING 117
+#define TK_NULL 118
+#define TK_NOW 119
+#define TK_SELECT 120
+#define TK_UNION 121
+#define TK_ALL 122
+#define TK_DISTINCT 123
+#define TK_FROM 124
+#define TK_VARIABLE 125
+#define TK_INTERVAL 126
+#define TK_EVERY 127
+#define TK_SESSION 128
+#define TK_STATE_WINDOW 129
+#define TK_FILL 130
+#define TK_SLIDING 131
+#define TK_ORDER 132
+#define TK_BY 133
+#define TK_ASC 134
+#define TK_GROUP 135
+#define TK_HAVING 136
+#define TK_LIMIT 137
+#define TK_OFFSET 138
+#define TK_SLIMIT 139
+#define TK_SOFFSET 140
+#define TK_WHERE 141
+#define TK_RESET 142
+#define TK_QUERY 143
+#define TK_SYNCDB 144
+#define TK_ADD 145
+#define TK_COLUMN 146
+#define TK_MODIFY 147
+#define TK_TAG 148
+#define TK_CHANGE 149
+#define TK_SET 150
+#define TK_KILL 151
+#define TK_CONNECTION 152
+#define TK_STREAM 153
+#define TK_COLON 154
+#define TK_ABORT 155
+#define TK_AFTER 156
+#define TK_ATTACH 157
+#define TK_BEFORE 158
+#define TK_BEGIN 159
+#define TK_CASCADE 160
+#define TK_CLUSTER 161
+#define TK_CONFLICT 162
+#define TK_COPY 163
+#define TK_DEFERRED 164
+#define TK_DELIMITERS 165
+#define TK_DETACH 166
+#define TK_EACH 167
+#define TK_END 168
+#define TK_EXPLAIN 169
+#define TK_FAIL 170
+#define TK_FOR 171
+#define TK_IGNORE 172
+#define TK_IMMEDIATE 173
+#define TK_INITIALLY 174
+#define TK_INSTEAD 175
+#define TK_MATCH 176
+#define TK_KEY 177
+#define TK_OF 178
+#define TK_RAISE 179
+#define TK_REPLACE 180
+#define TK_RESTRICT 181
+#define TK_ROW 182
+#define TK_STATEMENT 183
+#define TK_TRIGGER 184
+#define TK_VIEW 185
+#define TK_SEMI 186
+#define TK_NONE 187
+#define TK_PREV 188
+#define TK_LINEAR 189
+#define TK_IMPORT 190
+#define TK_TBNAME 191
+#define TK_JOIN 192
+#define TK_INSERT 193
+#define TK_INTO 194
+#define TK_VALUES 195
#define TK_SPACE 300
diff --git a/src/inc/twal.h b/src/inc/twal.h
index bce398d6f95518379c1cd4c0d95a4f6324aab4d7..868a1fbd780232303b42e58185ffc00730c17546 100644
--- a/src/inc/twal.h
+++ b/src/inc/twal.h
@@ -32,7 +32,7 @@ typedef enum {
typedef struct {
int8_t msgType;
- int8_t sver;
+ int8_t sver; // sver 2 for WAL SDataRow/SMemRow compatibility
int8_t reserved[2];
int32_t len;
uint64_t version;
diff --git a/src/kit/shell/inc/shell.h b/src/kit/shell/inc/shell.h
index 2374150c529df5bcaefd848a00d9050cd8e43870..f207a866ddc712165340c06b026aa99081f91c81 100644
--- a/src/kit/shell/inc/shell.h
+++ b/src/kit/shell/inc/shell.h
@@ -25,7 +25,6 @@
#define MAX_USERNAME_SIZE 64
#define MAX_DBNAME_SIZE 64
#define MAX_IP_SIZE 20
-#define MAX_PASSWORD_SIZE 20
#define MAX_HISTORY_SIZE 1000
#define MAX_COMMAND_SIZE 1048586
#define HISTORY_FILE ".taos_history"
@@ -56,6 +55,8 @@ typedef struct SShellArguments {
int abort;
int port;
int pktLen;
+ int pktNum;
+ char* pktType;
char* netTestRole;
} SShellArguments;
diff --git a/src/kit/shell/src/shellCheck.c b/src/kit/shell/src/shellCheck.c
index d78f1a6b996110f9cdce37e60dfbb85323a3a848..7fc8b1409a7602df48108d0e7f4763da48ed6497 100644
--- a/src/kit/shell/src/shellCheck.c
+++ b/src/kit/shell/src/shellCheck.c
@@ -72,12 +72,13 @@ static int32_t shellShowTables(TAOS *con, char *db) {
int32_t tbIndex = tbNum++;
if (tbMallocNum < tbNum) {
tbMallocNum = (tbMallocNum * 2 + 1);
- tbNames = realloc(tbNames, tbMallocNum * sizeof(char *));
- if (tbNames == NULL) {
+ char** tbNames1 = realloc(tbNames, tbMallocNum * sizeof(char *));
+ if (tbNames1 == NULL) {
fprintf(stdout, "failed to malloc tablenames, num:%d\n", tbMallocNum);
code = TSDB_CODE_TSC_OUT_OF_MEMORY;
break;
}
+ tbNames = tbNames1;
}
tbNames[tbIndex] = malloc(TSDB_TABLE_NAME_LEN);
diff --git a/src/kit/shell/src/shellDarwin.c b/src/kit/shell/src/shellDarwin.c
index 4dcd8b3d50628f626e681700e131ffb0a3b875e1..9161860f07dfb0683a47ea4ccb2a759ae49562e7 100644
--- a/src/kit/shell/src/shellDarwin.c
+++ b/src/kit/shell/src/shellDarwin.c
@@ -64,6 +64,10 @@ void printHelp() {
exit(EXIT_SUCCESS);
}
+char DARWINCLIENT_VERSION[] = "Welcome to the TDengine shell from %s, Client Version:%s\n"
+ "Copyright (c) 2020 by TAOS Data, Inc. All rights reserved.\n\n";
+char g_password[SHELL_MAX_PASSWORD_LEN];
+
void shellParseArgument(int argc, char *argv[], SShellArguments *arguments) {
wordexp_t full_path;
for (int i = 1; i < argc; i++) {
@@ -77,10 +81,27 @@ void shellParseArgument(int argc, char *argv[], SShellArguments *arguments) {
}
}
// for password
- else if (strcmp(argv[i], "-p") == 0) {
- arguments->is_use_passwd = true;
+ else if ((strncmp(argv[i], "-p", 2) == 0)
+ || (strncmp(argv[i], "--password", 10) == 0)) {
+ strcpy(tsOsName, "Darwin");
+ printf(DARWINCLIENT_VERSION, tsOsName, taos_get_client_info());
+ if ((strlen(argv[i]) == 2)
+ || (strncmp(argv[i], "--password", 10) == 0)) {
+ printf("Enter password: ");
+ taosSetConsoleEcho(false);
+ if (scanf("%s", g_password) > 1) {
+ fprintf(stderr, "password read error\n");
+ }
+ taosSetConsoleEcho(true);
+ getchar();
+ } else {
+ tstrncpy(g_password, (char *)(argv[i] + 2), SHELL_MAX_PASSWORD_LEN);
+ }
+ arguments->password = g_password;
+ strcpy(argv[i], "");
+ argc -= 1;
}
- // for management port
+ // for management port
else if (strcmp(argv[i], "-P") == 0) {
if (i < argc - 1) {
arguments->port = atoi(argv[++i]);
@@ -98,7 +119,7 @@ void shellParseArgument(int argc, char *argv[], SShellArguments *arguments) {
exit(EXIT_FAILURE);
}
} else if (strcmp(argv[i], "-c") == 0) {
- if (i < argc - 1) {
+ if (i < argc - 1) {
if (strlen(argv[++i]) >= TSDB_FILENAME_LEN) {
fprintf(stderr, "config file path: %s overflow max len %d\n", argv[i], TSDB_FILENAME_LEN - 1);
exit(EXIT_FAILURE);
diff --git a/src/kit/shell/src/shellEngine.c b/src/kit/shell/src/shellEngine.c
index 58f4b7ff02b673288878aa44671ba2a544556cc5..51a25d59c4550e955e37e6a67430a56a57a6d8bc 100644
--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
@@ -65,7 +65,15 @@ extern TAOS *taos_connect_auth(const char *ip, const char *user, const char *aut
*/
TAOS *shellInit(SShellArguments *_args) {
printf("\n");
- printf(CLIENT_VERSION, tsOsName, taos_get_client_info());
+ if (!_args->is_use_passwd) {
+#ifdef TD_WINDOWS
+ strcpy(tsOsName, "Windows");
+#elif defined(TD_DARWIN)
+ strcpy(tsOsName, "Darwin");
+#endif
+ printf(CLIENT_VERSION, tsOsName, taos_get_client_info());
+ }
+
fflush(stdout);
// set options before initializing
@@ -73,9 +81,7 @@ TAOS *shellInit(SShellArguments *_args) {
taos_options(TSDB_OPTION_TIMEZONE, _args->timezone);
}
- if (_args->is_use_passwd) {
- if (_args->password == NULL) _args->password = getpass("Enter password: ");
- } else {
+ if (!_args->is_use_passwd) {
_args->password = TSDB_DEFAULT_PASS;
}
@@ -170,7 +176,7 @@ static int32_t shellRunSingleCommand(TAOS *con, char *command) {
system("clear");
return 0;
}
-
+
if (regex_match(command, "^[\t ]*set[ \t]+max_binary_display_width[ \t]+(default|[1-9][0-9]*)[ \t;]*$", REG_EXTENDED | REG_ICASE)) {
strtok(command, " \t");
strtok(NULL, " \t");
@@ -182,7 +188,7 @@ static int32_t shellRunSingleCommand(TAOS *con, char *command) {
}
return 0;
}
-
+
if (regex_match(command, "^[ \t]*source[\t ]+[^ ]+[ \t;]*$", REG_EXTENDED | REG_ICASE)) {
/* If source file. */
char *c_ptr = strtok(command, " ;");
@@ -247,7 +253,7 @@ int32_t shellRunCommand(TAOS* con, char* command) {
esc = false;
continue;
}
-
+
if (c == '\\') {
esc = true;
continue;
@@ -336,8 +342,8 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
}
if (!tscIsUpdateQuery(pSql)) { // select and show kinds of commands
- int error_no = 0;
-
+ int error_no = 0;
+
int numOfRows = shellDumpResult(pSql, fname, &error_no, printMode);
if (numOfRows < 0) {
atomic_store_64(&result, 0);
@@ -530,7 +536,7 @@ static int dumpResultToFile(const char* fname, TAOS_RES* tres) {
fprintf(fp, "%s", fields[col].name);
}
fputc('\n', fp);
-
+
int numOfRows = 0;
do {
int32_t* length = taos_fetch_lengths(tres);
@@ -716,7 +722,7 @@ static int verticalPrintResult(TAOS_RES* tres) {
int numOfRows = 0;
int showMore = 1;
- do {
+ do {
if (numOfRows < resShowMaxNum) {
printf("*************************** %d.row ***************************\n", numOfRows + 1);
@@ -851,7 +857,7 @@ static int horizontalPrintResult(TAOS_RES* tres) {
int numOfRows = 0;
int showMore = 1;
-
+
do {
int32_t* length = taos_fetch_lengths(tres);
if (numOfRows < resShowMaxNum) {
@@ -867,7 +873,7 @@ static int horizontalPrintResult(TAOS_RES* tres) {
printf("[You can add limit statement to show more or redirect results to specific file to get all.]\n");
showMore = 0;
}
-
+
numOfRows++;
row = taos_fetch_row(tres);
} while(row != NULL);
@@ -909,7 +915,7 @@ void read_history() {
if (errno != ENOENT) {
fprintf(stderr, "Failed to open file %s, reason:%s\n", f_history, strerror(errno));
}
-#endif
+#endif
return;
}
@@ -934,9 +940,9 @@ void write_history() {
FILE *f = fopen(f_history, "w");
if (f == NULL) {
-#ifndef WINDOWS
+#ifndef WINDOWS
fprintf(stderr, "Failed to open file %s for write, reason:%s\n", f_history, strerror(errno));
-#endif
+#endif
return;
}
@@ -982,13 +988,13 @@ void source_file(TAOS *con, char *fptr) {
/*
if (access(fname, F_OK) != 0) {
fprintf(stderr, "ERROR: file %s is not exist\n", fptr);
-
+
wordfree(&full_path);
free(cmd);
return;
}
*/
-
+
FILE *f = fopen(fname, "r");
if (f == NULL) {
fprintf(stderr, "ERROR: failed to open file %s\n", fname);
diff --git a/src/kit/shell/src/shellLinux.c b/src/kit/shell/src/shellLinux.c
index dc74f6fcaa152c547d734ed4e186b45b94ce8de5..93783b205560604c9d25c9f5dc2e73a239a67b8e 100644
--- a/src/kit/shell/src/shellLinux.c
+++ b/src/kit/shell/src/shellLinux.c
@@ -34,7 +34,7 @@ static char doc[] = "";
static char args_doc[] = "";
static struct argp_option options[] = {
{"host", 'h', "HOST", 0, "TDengine server FQDN to connect. The default host is localhost."},
- {"password", 'p', "PASSWORD", OPTION_ARG_OPTIONAL, "The password to use when connecting to the server."},
+ {"password", 'p', 0, 0, "The password to use when connecting to the server."},
{"port", 'P', "PORT", 0, "The TCP/IP port number to use for the connection."},
{"user", 'u', "USER", 0, "The user name to use when connecting to the server."},
{"auth", 'A', "Auth", 0, "The auth string to use when connecting to the server."},
@@ -47,9 +47,11 @@ static struct argp_option options[] = {
{"thread", 'T', "THREADNUM", 0, "Number of threads when using multi-thread to import data."},
{"check", 'k', "CHECK", 0, "Check tables."},
{"database", 'd', "DATABASE", 0, "Database to use when connecting to the server."},
- {"timezone", 't', "TIMEZONE", 0, "Time zone of the shell, default is local."},
- {"netrole", 'n', "NETROLE", 0, "Net role when network connectivity test, default is startup, options: client|server|rpc|startup|sync."},
+ {"timezone", 'z', "TIMEZONE", 0, "Time zone of the shell, default is local."},
+ {"netrole", 'n', "NETROLE", 0, "Net role when network connectivity test, default is startup, options: client|server|rpc|startup|sync|speen|fqdn."},
{"pktlen", 'l', "PKTLEN", 0, "Packet length used for net test, default is 1000 bytes."},
+ {"pktnum", 'N', "PKTNUM", 0, "Packet numbers used for net test, default is 100."},
+ {"pkttype", 'S', "PKTTYPE", 0, "Packet type used for net test, default is TCP."},
{0}};
static error_t parse_opt(int key, char *arg, struct argp_state *state) {
@@ -63,8 +65,6 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
arguments->host = arg;
break;
case 'p':
- arguments->is_use_passwd = true;
- if (arg) arguments->password = arg;
break;
case 'P':
if (arg) {
@@ -76,7 +76,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
}
break;
- case 't':
+ case 'z':
arguments->timezone = arg;
break;
case 'u':
@@ -108,7 +108,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
arguments->is_raw_time = true;
break;
case 'f':
- if (wordexp(arg, &full_path, 0) != 0) {
+ if ((0 == strlen(arg)) || (wordexp(arg, &full_path, 0) != 0)) {
fprintf(stderr, "Invalid path %s\n", arg);
return -1;
}
@@ -148,6 +148,17 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
return -1;
}
break;
+ case 'N':
+ if (arg) {
+ arguments->pktNum = atoi(arg);
+ } else {
+ fprintf(stderr, "Invalid packet number\n");
+ return -1;
+ }
+ break;
+ case 'S':
+ arguments->pktType = arg;
+ break;
case OPT_ABORT:
arguments->abort = 1;
break;
@@ -160,12 +171,48 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
/* Our argp parser. */
static struct argp argp = {options, parse_opt, args_doc, doc};
+char LINUXCLIENT_VERSION[] = "Welcome to the TDengine shell from %s, Client Version:%s\n"
+ "Copyright (c) 2020 by TAOS Data, Inc. All rights reserved.\n\n";
+char g_password[SHELL_MAX_PASSWORD_LEN];
+
+static void parse_args(
+ int argc, char *argv[], SShellArguments *arguments) {
+ for (int i = 1; i < argc; i++) {
+ if ((strncmp(argv[i], "-p", 2) == 0)
+ || (strncmp(argv[i], "--password", 10) == 0)) {
+ strcpy(tsOsName, "Linux");
+ printf(LINUXCLIENT_VERSION, tsOsName, taos_get_client_info());
+ if ((strlen(argv[i]) == 2)
+ || (strncmp(argv[i], "--password", 10) == 0)) {
+ printf("Enter password: ");
+ taosSetConsoleEcho(false);
+ if (scanf("%20s", g_password) > 1) {
+ fprintf(stderr, "password reading error\n");
+ }
+ taosSetConsoleEcho(true);
+ if (EOF == getchar()) {
+ fprintf(stderr, "getchar() return EOF\n");
+ }
+ } else {
+ tstrncpy(g_password, (char *)(argv[i] + 2), SHELL_MAX_PASSWORD_LEN);
+ strcpy(argv[i], "-p");
+ }
+ arguments->password = g_password;
+ arguments->is_use_passwd = true;
+ }
+ }
+}
+
void shellParseArgument(int argc, char *argv[], SShellArguments *arguments) {
static char verType[32] = {0};
sprintf(verType, "version: %s\n", version);
argp_program_version = verType;
-
+
+ if (argc > 1) {
+ parse_args(argc, argv, arguments);
+ }
+
argp_parse(&argp, argc, argv, 0, 0, arguments);
if (arguments->abort) {
#ifndef _ALPINE
diff --git a/src/kit/shell/src/shellMain.c b/src/kit/shell/src/shellMain.c
index 0c70386061b99baaf2f9448ddadbb250685f23d4..5c9dc0995dacecebd10b7f2b77e216ca97157db0 100644
--- a/src/kit/shell/src/shellMain.c
+++ b/src/kit/shell/src/shellMain.c
@@ -71,7 +71,9 @@ int checkVersion() {
// Global configurations
SShellArguments args = {
.host = NULL,
+#ifndef TD_WINDOWS
.password = NULL,
+#endif
.user = NULL,
.database = NULL,
.timezone = NULL,
@@ -83,6 +85,8 @@ SShellArguments args = {
.threadNum = 5,
.commands = NULL,
.pktLen = 1000,
+ .pktNum = 100,
+ .pktType = "TCP",
.netTestRole = NULL
};
@@ -116,7 +120,7 @@ int main(int argc, char* argv[]) {
printf("Failed to init taos");
exit(EXIT_FAILURE);
}
- taosNetTest(args.netTestRole, args.host, args.port, args.pktLen);
+ taosNetTest(args.netTestRole, args.host, args.port, args.pktLen, args.pktNum, args.pktType);
exit(0);
}
diff --git a/src/kit/shell/src/shellWindows.c b/src/kit/shell/src/shellWindows.c
index 87d11a3516a65e83201bf4ebe51f07e5394d5cdf..abec34b84c5ff65d6cb13492028cd36321d2d0ca 100644
--- a/src/kit/shell/src/shellWindows.c
+++ b/src/kit/shell/src/shellWindows.c
@@ -19,6 +19,9 @@
extern char configDir[];
+char WINCLIENT_VERSION[] = "Welcome to the TDengine shell from %s, Client Version:%s\n"
+ "Copyright (c) 2020 by TAOS Data, Inc. All rights reserved.\n\n";
+
void printVersion() {
printf("version: %s\n", version);
}
@@ -52,15 +55,21 @@ void printHelp() {
printf("%s%s\n", indent, "-t");
printf("%s%s%s\n", indent, indent, "Time zone of the shell, default is local.");
printf("%s%s\n", indent, "-n");
- printf("%s%s%s\n", indent, indent, "Net role when network connectivity test, default is startup, options: client|server|rpc|startup|sync.");
+ printf("%s%s%s\n", indent, indent, "Net role when network connectivity test, default is startup, options: client|server|rpc|startup|sync|speed|fqdn.");
printf("%s%s\n", indent, "-l");
printf("%s%s%s\n", indent, indent, "Packet length used for net test, default is 1000 bytes.");
+ printf("%s%s\n", indent, "-N");
+ printf("%s%s%s\n", indent, indent, "Packet numbers used for net test, default is 100.");
+ printf("%s%s\n", indent, "-S");
+ printf("%s%s%s\n", indent, indent, "Packet type used for net test, default is TCP.");
printf("%s%s\n", indent, "-V");
printf("%s%s%s\n", indent, indent, "Print program version.");
exit(EXIT_SUCCESS);
}
+char g_password[SHELL_MAX_PASSWORD_LEN];
+
void shellParseArgument(int argc, char *argv[], SShellArguments *arguments) {
for (int i = 1; i < argc; i++) {
// for host
@@ -73,11 +82,26 @@ void shellParseArgument(int argc, char *argv[], SShellArguments *arguments) {
}
}
// for password
- else if (strcmp(argv[i], "-p") == 0) {
- arguments->is_use_passwd = true;
- if (i < argc - 1 && argv[i + 1][0] != '-') {
- arguments->password = argv[++i];
- }
+ else if ((strncmp(argv[i], "-p", 2) == 0)
+ || (strncmp(argv[i], "--password", 10) == 0)) {
+ arguments->is_use_passwd = true;
+ strcpy(tsOsName, "Windows");
+ printf(WINCLIENT_VERSION, tsOsName, taos_get_client_info());
+ if ((strlen(argv[i]) == 2)
+ || (strncmp(argv[i], "--password", 10) == 0)) {
+ printf("Enter password: ");
+ taosSetConsoleEcho(false);
+ if (scanf("%s", g_password) > 1) {
+ fprintf(stderr, "password read error!\n");
+ }
+ taosSetConsoleEcho(true);
+ getchar();
+ } else {
+ tstrncpy(g_password, (char *)(argv[i] + 2), SHELL_MAX_PASSWORD_LEN);
+ }
+ arguments->password = g_password;
+ strcpy(argv[i], "");
+ argc -= 1;
}
// for management port
else if (strcmp(argv[i], "-P") == 0) {
@@ -104,7 +128,7 @@ void shellParseArgument(int argc, char *argv[], SShellArguments *arguments) {
exit(EXIT_FAILURE);
}
} else if (strcmp(argv[i], "-c") == 0) {
- if (i < argc - 1) {
+ if (i < argc - 1) {
char *tmp = argv[++i];
if (strlen(tmp) >= TSDB_FILENAME_LEN) {
fprintf(stderr, "config file path: %s overflow max len %d\n", tmp, TSDB_FILENAME_LEN - 1);
@@ -265,7 +289,7 @@ void *shellLoopQuery(void *arg) {
if (command == NULL) return NULL;
int32_t err = 0;
-
+
do {
memset(command, 0, MAX_COMMAND_SIZE);
shellPrintPrompt();
@@ -274,7 +298,7 @@ void *shellLoopQuery(void *arg) {
err = shellReadCommand(con, command);
if (err) {
break;
- }
+ }
} while (shellRunCommand(con, command) == 0);
return NULL;
diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 3b91de32b043fc5233fb589e8ff7f349aa01171c..5b0791f1f40396dc341c9310dad9282d48c81dd7 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -53,14 +53,6 @@
#include "taoserror.h"
#include "tutil.h"
-#define STMT_IFACE_ENABLED 1
-#define NANO_SECOND_ENABLED 1
-#define SET_THREADNAME_ENABLED 1
-
-#if SET_THREADNAME_ENABLED == 0
-#define setThreadName(name)
-#endif
-
#define REQ_EXTRA_BUF_LEN 1024
#define RESP_BUF_LEN 4096
@@ -77,13 +69,14 @@ extern char configDir[];
#define COL_BUFFER_LEN ((TSDB_COL_NAME_LEN + 15) * TSDB_MAX_COLUMNS)
#define MAX_USERNAME_SIZE 64
-#define MAX_PASSWORD_SIZE 16
#define MAX_HOSTNAME_SIZE 253 // https://man7.org/linux/man-pages/man7/hostname.7.html
#define MAX_TB_NAME_SIZE 64
#define MAX_DATA_SIZE (16*TSDB_MAX_COLUMNS)+20 // max record len: 16*MAX_COLUMNS, timestamp string and ,('') need extra space
#define OPT_ABORT 1 /* –abort */
#define MAX_FILE_NAME_LEN 256 // max file name length on linux is 255.
+#define DEFAULT_START_TIME 1500000000000
+
#define MAX_PREPARED_RAND 1000000
#define INT_BUFF_LEN 11
#define BIGINT_BUFF_LEN 21
@@ -111,6 +104,9 @@ extern char configDir[];
#define NOTE_BUFF_LEN (SMALL_BUFF_LEN*16)
#define DEFAULT_TIMESTAMP_STEP 1
+#define DEFAULT_INTERLACE_ROWS 0
+#define DEFAULT_DATATYPE_NUM 1
+#define DEFAULT_CHILDTABLES 10000
enum TEST_MODE {
@@ -210,13 +206,13 @@ enum _describe_table_index {
static char *g_dupstr = NULL;
typedef struct SArguments_S {
- char * metaFile;
+ char *metaFile;
uint32_t test_mode;
- char * host;
+ char *host;
uint16_t port;
uint16_t iface;
char * user;
- char password[MAX_PASSWORD_SIZE];
+ char password[SHELL_MAX_PASSWORD_LEN];
char * database;
int replica;
char * tb_prefix;
@@ -231,7 +227,7 @@ typedef struct SArguments_S {
char * output_file;
bool async_mode;
char * datatype[MAX_NUM_COLUMNS + 1];
- uint32_t len_of_binary;
+ uint32_t binwidth;
uint32_t num_of_CPR;
uint32_t num_of_threads;
uint64_t insert_interval;
@@ -295,11 +291,6 @@ typedef struct SSuperTable_S {
uint64_t lenOfTagOfOneRow;
char* sampleDataBuf;
-#if STMT_IFACE_ENABLED == 1
- char* sampleBindArray;
-#endif
- //int sampleRowCount;
- //int sampleUsePos;
uint32_t tagSource; // 0: rand, 1: tag sample
char* tagDataBuf;
@@ -366,7 +357,7 @@ typedef struct SDbs_S {
uint16_t port;
char user[MAX_USERNAME_SIZE];
- char password[MAX_PASSWORD_SIZE];
+ char password[SHELL_MAX_PASSWORD_LEN];
char resultFile[MAX_FILE_NAME_LEN];
bool use_metric;
bool insert_only;
@@ -374,7 +365,7 @@ typedef struct SDbs_S {
bool asyncMode;
uint32_t threadCount;
- uint32_t threadCountByCreateTbl;
+ uint32_t threadCountForCreateTbl;
uint32_t dbCount;
SDataBase db[MAX_DB_COUNT];
@@ -432,7 +423,7 @@ typedef struct SQueryMetaInfo_S {
uint16_t port;
struct sockaddr_in serv_addr;
char user[MAX_USERNAME_SIZE];
- char password[MAX_PASSWORD_SIZE];
+ char password[SHELL_MAX_PASSWORD_LEN];
char dbName[TSDB_DB_NAME_LEN];
char queryMode[SMALL_BUFF_LEN]; // taosc, rest
@@ -444,7 +435,8 @@ typedef struct SQueryMetaInfo_S {
typedef struct SThreadInfo_S {
TAOS * taos;
TAOS_STMT *stmt;
- int64_t *bind_ts;
+ char* sampleBindArray;
+ int64_t *bind_ts;
int threadID;
char db_name[TSDB_DB_NAME_LEN];
uint32_t time_precision;
@@ -454,6 +446,7 @@ typedef struct SThreadInfo_S {
uint64_t start_table_from;
uint64_t end_table_to;
int64_t ntables;
+ int64_t tables_created;
uint64_t data_of_rate;
int64_t start_time;
char* cols;
@@ -592,24 +585,22 @@ char *g_randdouble_buff = NULL;
char *g_aggreFunc[] = {"*", "count(*)", "avg(col0)", "sum(col0)",
"max(col0)", "min(col0)", "first(col0)", "last(col0)"};
-#define DEFAULT_DATATYPE_NUM 3
-
SArguments g_args = {
- NULL, // metaFile
- 0, // test_mode
- "127.0.0.1", // host
- 6030, // port
- INTERFACE_BUT, // iface
- "root", // user
+ NULL, // metaFile
+ 0, // test_mode
+ "localhost", // host
+ 6030, // port
+ INTERFACE_BUT, // iface
+ "root", // user
#ifdef _TD_POWER_
"powerdb", // password
#elif (_TD_TQ_ == true)
- "tqueue", // password
+ "tqueue", // password
#else
- "taosdata", // password
+ "taosdata", // password
#endif
- "test", // database
- 1, // replica
+ "test", // database
+ 1, // replica
"d", // tb_prefix
NULL, // sqlFile
true, // use_metric
@@ -626,16 +617,16 @@ SArguments g_args = {
"INT", // datatype
"FLOAT", // datatype. DEFAULT_DATATYPE_NUM is 3
},
- 16, // len_of_binary
+ 64, // binwidth
4, // num_of_CPR
10, // num_of_connections/thread
0, // insert_interval
DEFAULT_TIMESTAMP_STEP, // timestamp_step
1, // query_times
- 0, // interlace_rows;
+ DEFAULT_INTERLACE_ROWS, // interlace_rows;
30000, // num_of_RPR
(1024*1024), // max_sql_len
- 10000, // num_of_tables
+ DEFAULT_CHILDTABLES, // num_of_tables
10000, // num_of_DPT
0, // abort
0, // disorderRatio
@@ -646,10 +637,9 @@ SArguments g_args = {
true, // demo_mode;
};
-
-
static SDbs g_Dbs;
-static int64_t g_totalChildTables = 0;
+static int64_t g_totalChildTables = DEFAULT_CHILDTABLES;
+static int64_t g_actualChildTables = 0;
static SQueryMetaInfo g_queryInfo;
static FILE * g_fpOfInsertResult = NULL;
@@ -670,7 +660,28 @@ static FILE * g_fpOfInsertResult = NULL;
fprintf(stderr, "PERF: "fmt, __VA_ARGS__); } while(0)
#define errorPrint(fmt, ...) \
- do { fprintf(stderr, " \033[31m"); fprintf(stderr, "ERROR: "fmt, __VA_ARGS__); fprintf(stderr, " \033[0m"); } while(0)
+ do {\
+ fprintf(stderr, " \033[31m");\
+ fprintf(stderr, "ERROR: "fmt, __VA_ARGS__);\
+ fprintf(stderr, " \033[0m");\
+ } while(0)
+
+#define errorPrint2(fmt, ...) \
+ do {\
+ struct tm Tm, *ptm;\
+ struct timeval timeSecs; \
+ time_t curTime;\
+ gettimeofday(&timeSecs, NULL); \
+ curTime = timeSecs.tv_sec;\
+ ptm = localtime_r(&curTime, &Tm);\
+ fprintf(stderr, " \033[31m");\
+ fprintf(stderr, "%02d/%02d %02d:%02d:%02d.%06d %08" PRId64 " ",\
+ ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour,\
+ ptm->tm_min, ptm->tm_sec, (int32_t)timeSecs.tv_usec,\
+ taosGetSelfPthreadId());\
+ fprintf(stderr, " \033[0m");\
+ errorPrint(fmt, __VA_ARGS__);\
+ } while(0)
// for strncpy buffer overflow
#define min(a, b) (((a) < (b)) ? (a) : (b))
@@ -707,92 +718,100 @@ static void printVersion() {
}
static void printHelp() {
- char indent[10] = " ";
- printf("%s%s%s%s\n", indent, "-f", indent,
+ char indent[10] = " ";
+ printf("%s\n\n", "Usage: taosdemo [OPTION...]");
+ printf("%s%s%s%s\n", indent, "-f, --file=FILE", "\t\t",
"The meta file to the execution procedure. Default is './meta.json'.");
- printf("%s%s%s%s\n", indent, "-u", indent,
- "The TDengine user name to use when connecting to the server. Default is 'root'.");
+ printf("%s%s%s%s\n", indent, "-u, --user=USER", "\t\t",
+ "The user name to use when connecting to the server.");
#ifdef _TD_POWER_
- printf("%s%s%s%s\n", indent, "-p", indent,
- "The password to use when connecting to the server. Default is 'powerdb'.");
- printf("%s%s%s%s\n", indent, "-c", indent,
+ printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+ "The password to use when connecting to the server. Default is 'powerdb'");
+ printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
"Configuration directory. Default is '/etc/power/'.");
#elif (_TD_TQ_ == true)
- printf("%s%s%s%s\n", indent, "-p", indent,
- "The password to use when connecting to the server. Default is 'tqueue'.");
- printf("%s%s%s%s\n", indent, "-c", indent,
+ printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+ "The password to use when connecting to the server. Default is 'tqueue'");
+ printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
"Configuration directory. Default is '/etc/tq/'.");
#else
- printf("%s%s%s%s\n", indent, "-p", indent,
- "The password to use when connecting to the server. Default is 'taosdata'.");
- printf("%s%s%s%s\n", indent, "-c", indent,
- "Configuration directory. Default is '/etc/taos/'.");
+ printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+ "The password to use when connecting to the server.");
+ printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
+ "Configuration directory.");
#endif
- printf("%s%s%s%s\n", indent, "-h", indent,
- "The host to connect to TDengine. Default is localhost.");
- printf("%s%s%s%s\n", indent, "-P", indent,
- "The TCP/IP port number to use for the connection. Default is 0.");
- printf("%s%s%s%s\n", indent, "-I", indent,
-#if STMT_IFACE_ENABLED == 1
+ printf("%s%s%s%s\n", indent, "-h, --host=HOST", "\t\t",
+ "TDengine server FQDN to connect. The default host is localhost.");
+ printf("%s%s%s%s\n", indent, "-P, --port=PORT", "\t\t",
+ "The TCP/IP port number to use for the connection.");
+ printf("%s%s%s%s\n", indent, "-I, --interface=INTERFACE", "\t",
"The interface (taosc, rest, and stmt) taosdemo uses. Default is 'taosc'.");
-#else
- "The interface (taosc, rest) taosdemo uses. Default is 'taosc'.");
-#endif
- printf("%s%s%s%s\n", indent, "-d", indent,
+ printf("%s%s%s%s\n", indent, "-d, --database=DATABASE", "\t",
"Destination database. Default is 'test'.");
- printf("%s%s%s%s\n", indent, "-a", indent,
+ printf("%s%s%s%s\n", indent, "-a, --replica=REPLICA", "\t\t",
"Set the replica parameters of the database, Default 1, min: 1, max: 3.");
- printf("%s%s%s%s\n", indent, "-m", indent,
+ printf("%s%s%s%s\n", indent, "-m, --table-prefix=TABLEPREFIX", "\t",
"Table prefix name. Default is 'd'.");
- printf("%s%s%s%s\n", indent, "-s", indent, "The select sql file.");
- printf("%s%s%s%s\n", indent, "-N", indent, "Use normal table flag.");
- printf("%s%s%s%s\n", indent, "-o", indent,
+ printf("%s%s%s%s\n", indent, "-s, --sql-file=FILE", "\t\t", "The select sql file.");
+ printf("%s%s%s%s\n", indent, "-N, --normal-table", "\t\t", "Use normal table flag.");
+ printf("%s%s%s%s\n", indent, "-o, --output=FILE", "\t\t",
"Direct output to the named file. Default is './output.txt'.");
- printf("%s%s%s%s\n", indent, "-q", indent,
+ printf("%s%s%s%s\n", indent, "-s, --sql-file=FILE", "\t\t",
+ "The select sql file.");
+ printf("%s%s%s%s\n", indent, "-q, --query-mode=MODE", "\t\t",
"Query mode -- 0: SYNC, 1: ASYNC. Default is SYNC.");
- printf("%s%s%s%s\n", indent, "-b", indent,
+ printf("%s%s%s%s\n", indent, "-b, --data-type=DATATYPE", "\t",
"The data_type of columns, default: FLOAT, INT, FLOAT.");
- printf("%s%s%s%s\n", indent, "-w", indent,
- "The length of data_type 'BINARY' or 'NCHAR'. Default is 16");
- printf("%s%s%s%s%d%s%d\n", indent, "-l", indent,
- "The number of columns per record. Default is ",
+ printf("%s%s%s%s%d\n", indent, "-w, --binwidth=WIDTH", "\t\t",
+ "The width of data_type 'BINARY' or 'NCHAR'. Default is ",
+ g_args.binwidth);
+ printf("%s%s%s%s%d%s%d\n", indent, "-l, --columns=COLUMNS", "\t\t",
+ "The number of columns per record. Demo mode by default is ",
DEFAULT_DATATYPE_NUM,
- ". Max values is ",
+ " (float, int, float). Max values is ",
MAX_NUM_COLUMNS);
printf("%s%s%s%s\n", indent, indent, indent,
- "All of the new column(s) type is INT. If use -b to specify column type, -l will be ignored.");
- printf("%s%s%s%s\n", indent, "-T", indent,
+ "\t\t\t\tAll of the new column(s) type is INT. If use -b to specify column type, -l will be ignored.");
+ printf("%s%s%s%s\n", indent, "-T, --threads=NUMBER", "\t\t",
"The number of threads. Default is 10.");
- printf("%s%s%s%s\n", indent, "-i", indent,
+ printf("%s%s%s%s\n", indent, "-i, --insert-interval=NUMBER", "\t",
"The sleep time (ms) between insertion. Default is 0.");
- printf("%s%s%s%s%d.\n", indent, "-S", indent,
+ printf("%s%s%s%s%d.\n", indent, "-S, --time-step=TIME_STEP", "\t",
"The timestamp step between insertion. Default is ",
DEFAULT_TIMESTAMP_STEP);
- printf("%s%s%s%s\n", indent, "-r", indent,
+ printf("%s%s%s%s%d.\n", indent, "-B, --interlace-rows=NUMBER", "\t",
+ "The interlace rows of insertion. Default is ",
+ DEFAULT_INTERLACE_ROWS);
+ printf("%s%s%s%s\n", indent, "-r, --rec-per-req=NUMBER", "\t",
"The number of records per request. Default is 30000.");
- printf("%s%s%s%s\n", indent, "-t", indent,
+ printf("%s%s%s%s\n", indent, "-t, --tables=NUMBER", "\t\t",
"The number of tables. Default is 10000.");
- printf("%s%s%s%s\n", indent, "-n", indent,
+ printf("%s%s%s%s\n", indent, "-n, --records=NUMBER", "\t\t",
"The number of records per table. Default is 10000.");
- printf("%s%s%s%s\n", indent, "-M", indent,
+ printf("%s%s%s%s\n", indent, "-M, --random", "\t\t\t",
"The value of records generated are totally random.");
- printf("%s%s%s%s\n", indent, indent, indent,
- " The default is to simulate power equipment senario.");
- printf("%s%s%s%s\n", indent, "-x", indent, "Not insert only flag.");
- printf("%s%s%s%s\n", indent, "-y", indent, "Default input yes for prompt.");
- printf("%s%s%s%s\n", indent, "-O", indent,
- "Insert mode--0: In order, 1 ~ 50: disorder ratio. Default is in order.");
- printf("%s%s%s%s\n", indent, "-R", indent,
+ printf("%s\n", "\t\t\t\tThe default is to simulate power equipment senario.");
+ printf("%s%s%s%s\n", indent, "-x, --no-insert", "\t\t",
+ "No-insert flag.");
+ printf("%s%s%s%s\n", indent, "-y, --answer-yes", "\t\t", "Default input yes for prompt.");
+ printf("%s%s%s%s\n", indent, "-O, --disorder=NUMBER", "\t\t",
+ "Insert order mode--0: In order, 1 ~ 50: disorder ratio. Default is in order.");
+ printf("%s%s%s%s\n", indent, "-R, --disorder-range=NUMBER", "\t",
"Out of order data's range, ms, default is 1000.");
- printf("%s%s%s%s\n", indent, "-g", indent,
+ printf("%s%s%s%s\n", indent, "-g, --debug", "\t\t\t",
"Print debug info.");
- printf("%s%s%s\n", indent, "-V, --version\t",
- "Print version info.");
- printf("%s%s%s%s\n", indent, "--help\t", indent,
- "Print command line arguments list info.");
+ printf("%s%s%s%s\n", indent, "-?, --help\t", "\t\t",
+ "Give this help list");
+ printf("%s%s%s%s\n", indent, " --usage\t", "\t\t",
+ "Give a short usage message");
+ printf("%s%s\n", indent, "-V, --version\t\t\tPrint program version.");
/* printf("%s%s%s%s\n", indent, "-D", indent,
"Delete database if exists. 0: no, 1: yes, default is 1");
*/
+ printf("\nMandatory or optional arguments to long options are also mandatory or optional\n\
+for any corresponding short options.\n\
+\n\
+Report bugs to .\n");
}
static bool isStringNumber(char *input)
@@ -810,113 +829,434 @@ static bool isStringNumber(char *input)
return true;
}
+static void errorUnreconized(char *program, char *wrong_arg)
+{
+ fprintf(stderr, "%s: unrecognized options '%s'\n", program, wrong_arg);
+ fprintf(stderr, "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+static void errorPrintReqArg(char *program, char *wrong_arg)
+{
+ fprintf(stderr,
+ "%s: option requires an argument -- '%s'\n",
+ program, wrong_arg);
+ fprintf(stderr,
+ "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+static void errorPrintReqArg2(char *program, char *wrong_arg)
+{
+ fprintf(stderr,
+ "%s: option requires a number argument '-%s'\n",
+ program, wrong_arg);
+ fprintf(stderr,
+ "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+static void errorPrintReqArg3(char *program, char *wrong_arg)
+{
+ fprintf(stderr,
+ "%s: option '%s' requires an argument\n",
+ program, wrong_arg);
+ fprintf(stderr,
+ "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
static void parse_args(int argc, char *argv[], SArguments *arguments) {
for (int i = 1; i < argc; i++) {
- if (strcmp(argv[i], "-f") == 0) {
+ if ((0 == strncmp(argv[i], "-f", strlen("-f")))
+ || (0 == strncmp(argv[i], "--file", strlen("--file")))) {
arguments->demo_mode = false;
- arguments->metaFile = argv[++i];
- } else if (strcmp(argv[i], "-c") == 0) {
- if (argc == i+1) {
- printHelp();
- errorPrint("%s", "\n\t-c need a valid path following!\n");
+
+ if (2 == strlen(argv[i])) {
+ if (i+1 == argc) {
+ errorPrintReqArg(argv[0], "f");
+ exit(EXIT_FAILURE);
+ }
+ arguments->metaFile = argv[++i];
+ } else if (0 == strncmp(argv[i], "-f", strlen("-f"))) {
+ arguments->metaFile = (char *)(argv[i] + strlen("-f"));
+ } else if (strlen("--file") == strlen(argv[i])) {
+ if (i+1 == argc) {
+ errorPrintReqArg3(argv[0], "--file");
+ exit(EXIT_FAILURE);
+ }
+ arguments->metaFile = argv[++i];
+ } else if (0 == strncmp(argv[i], "--file=", strlen("--file="))) {
+ arguments->metaFile = (char *)(argv[i] + strlen("--file="));
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
- } else if (strcmp(argv[i], "-h") == 0) {
- if (argc == i+1) {
- printHelp();
- errorPrint("%s", "\n\t-h need a valid string following!\n");
+ } else if ((0 == strncmp(argv[i], "-c", strlen("-c")))
+ || (0 == strncmp(argv[i], "--config-dir", strlen("--config-dir")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "c");
+ exit(EXIT_FAILURE);
+ }
+ tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
+ } else if (0 == strncmp(argv[i], "-c", strlen("-c"))) {
+ tstrncpy(configDir, (char *)(argv[i] + strlen("-")), TSDB_FILENAME_LEN);
+ } else if (strlen("--config-dir") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--config-dir");
+ exit(EXIT_FAILURE);
+ }
+ tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
+ } else if (0 == strncmp(argv[i], "--config-dir=", strlen("--config-dir="))) {
+ tstrncpy(configDir, (char *)(argv[i] + strlen("--config-dir=")), TSDB_FILENAME_LEN);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->host = argv[++i];
- } else if (strcmp(argv[i], "-P") == 0) {
- if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-P need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-h", strlen("-h")))
+ || (0 == strncmp(argv[i], "--host", strlen("--host")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "h");
+ exit(EXIT_FAILURE);
+ }
+ arguments->host = argv[++i];
+ } else if (0 == strncmp(argv[i], "-h", strlen("-h"))) {
+ arguments->host = (char *)(argv[i] + strlen("-h"));
+ } else if (strlen("--host") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--host");
+ exit(EXIT_FAILURE);
+ }
+ arguments->host = argv[++i];
+ } else if (0 == strncmp(argv[i], "--host=", strlen("--host="))) {
+ arguments->host = (char *)(argv[i] + strlen("--host="));
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->port = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-I") == 0) {
- if (argc == i+1) {
- printHelp();
- errorPrint("%s", "\n\t-I need a valid string following!\n");
+ } else if (strcmp(argv[i], "-PP") == 0) {
+ arguments->performance_print = true;
+ } else if ((0 == strncmp(argv[i], "-P", strlen("-P")))
+ || (0 == strncmp(argv[i], "--port", strlen("--port")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "P");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "P");
+ exit(EXIT_FAILURE);
+ }
+ arguments->port = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--port=", strlen("--port="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--port=")))) {
+ arguments->port = atoi((char *)(argv[i]+strlen("--port=")));
+ }
+ } else if (0 == strncmp(argv[i], "-P", strlen("-P"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-P")))) {
+ arguments->port = atoi((char *)(argv[i]+strlen("-P")));
+ }
+ } else if (strlen("--port") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--port");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--port");
+ exit(EXIT_FAILURE);
+ }
+ arguments->port = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- ++i;
- if (0 == strcasecmp(argv[i], "taosc")) {
- arguments->iface = TAOSC_IFACE;
- } else if (0 == strcasecmp(argv[i], "rest")) {
- arguments->iface = REST_IFACE;
-#if STMT_IFACE_ENABLED == 1
- } else if (0 == strcasecmp(argv[i], "stmt")) {
- arguments->iface = STMT_IFACE;
-#endif
+ } else if ((0 == strncmp(argv[i], "-I", strlen("-I")))
+ || (0 == strncmp(argv[i], "--interface", strlen("--interface")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "I");
+ exit(EXIT_FAILURE);
+ }
+ if (0 == strcasecmp(argv[i+1], "taosc")) {
+ arguments->iface = TAOSC_IFACE;
+ } else if (0 == strcasecmp(argv[i+1], "rest")) {
+ arguments->iface = REST_IFACE;
+ } else if (0 == strcasecmp(argv[i+1], "stmt")) {
+ arguments->iface = STMT_IFACE;
+ } else {
+ errorPrintReqArg(argv[0], "I");
+ exit(EXIT_FAILURE);
+ }
+ i++;
+ } else if (0 == strncmp(argv[i], "--interface=", strlen("--interface="))) {
+ if (0 == strcasecmp((char *)(argv[i] + strlen("--interface=")), "taosc")) {
+ arguments->iface = TAOSC_IFACE;
+ } else if (0 == strcasecmp((char *)(argv[i] + strlen("--interface=")), "rest")) {
+ arguments->iface = REST_IFACE;
+ } else if (0 == strcasecmp((char *)(argv[i] + strlen("--interface=")), "stmt")) {
+ arguments->iface = STMT_IFACE;
+ } else {
+ errorPrintReqArg3(argv[0], "--interface");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-I", strlen("-I"))) {
+ if (0 == strcasecmp((char *)(argv[i] + strlen("-I")), "taosc")) {
+ arguments->iface = TAOSC_IFACE;
+ } else if (0 == strcasecmp((char *)(argv[i] + strlen("-I")), "rest")) {
+ arguments->iface = REST_IFACE;
+ } else if (0 == strcasecmp((char *)(argv[i] + strlen("-I")), "stmt")) {
+ arguments->iface = STMT_IFACE;
+ } else {
+ errorPrintReqArg3(argv[0], "-I");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--interface") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--interface");
+ exit(EXIT_FAILURE);
+ }
+ if (0 == strcasecmp(argv[i+1], "taosc")) {
+ arguments->iface = TAOSC_IFACE;
+ } else if (0 == strcasecmp(argv[i+1], "rest")) {
+ arguments->iface = REST_IFACE;
+ } else if (0 == strcasecmp(argv[i+1], "stmt")) {
+ arguments->iface = STMT_IFACE;
+ } else {
+ errorPrintReqArg3(argv[0], "--interface");
+ exit(EXIT_FAILURE);
+ }
+ i++;
} else {
- errorPrint("%s", "\n\t-I need a valid string following!\n");
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- } else if (strcmp(argv[i], "-u") == 0) {
- if (argc == i+1) {
- printHelp();
- errorPrint("%s", "\n\t-u need a valid string following!\n");
+ } else if ((0 == strncmp(argv[i], "-u", strlen("-u")))
+ || (0 == strncmp(argv[i], "--user", strlen("--user")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "u");
+ exit(EXIT_FAILURE);
+ }
+ arguments->user = argv[++i];
+ } else if (0 == strncmp(argv[i], "-u", strlen("-u"))) {
+ arguments->user = (char *)(argv[i++] + strlen("-u"));
+ } else if (0 == strncmp(argv[i], "--user=", strlen("--user="))) {
+ arguments->user = (char *)(argv[i++] + strlen("--user="));
+ } else if (strlen("--user") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--user");
+ exit(EXIT_FAILURE);
+ }
+ arguments->user = argv[++i];
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->user = argv[++i];
- } else if (strncmp(argv[i], "-p", 2) == 0) {
- if (strlen(argv[i]) == 2) {
- printf("Enter password:");
- scanf("%s", arguments->password);
+ } else if ((0 == strncmp(argv[i], "-p", strlen("-p")))
+ || (0 == strcmp(argv[i], "--password"))) {
+ if ((strlen(argv[i]) == 2) || (0 == strcmp(argv[i], "--password"))) {
+ printf("Enter password: ");
+ taosSetConsoleEcho(false);
+ if (scanf("%s", arguments->password) > 1) {
+ fprintf(stderr, "password read error!\n");
+ }
+ taosSetConsoleEcho(true);
} else {
- tstrncpy(arguments->password, (char *)(argv[i] + 2), MAX_PASSWORD_SIZE);
+ tstrncpy(arguments->password, (char *)(argv[i] + 2), SHELL_MAX_PASSWORD_LEN);
}
- } else if (strcmp(argv[i], "-o") == 0) {
- if (argc == i+1) {
- printHelp();
- errorPrint("%s", "\n\t-o need a valid string following!\n");
+ } else if ((0 == strncmp(argv[i], "-o", strlen("-o")))
+ || (0 == strncmp(argv[i], "--output", strlen("--output")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--output");
+ exit(EXIT_FAILURE);
+ }
+ arguments->output_file = argv[++i];
+ } else if (0 == strncmp(argv[i], "--output=", strlen("--output="))) {
+ arguments->output_file = (char *)(argv[i++] + strlen("--output="));
+ } else if (0 == strncmp(argv[i], "-o", strlen("-o"))) {
+ arguments->output_file = (char *)(argv[i++] + strlen("-o"));
+ } else if (strlen("--output") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--output");
+ exit(EXIT_FAILURE);
+ }
+ arguments->output_file = argv[++i];
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->output_file = argv[++i];
- } else if (strcmp(argv[i], "-s") == 0) {
- if (argc == i+1) {
- printHelp();
- errorPrint("%s", "\n\t-s need a valid string following!\n");
+ } else if ((0 == strncmp(argv[i], "-s", strlen("-s")))
+ || (0 == strncmp(argv[i], "--sql-file", strlen("--sql-file")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "s");
+ exit(EXIT_FAILURE);
+ }
+ arguments->sqlFile = argv[++i];
+ } else if (0 == strncmp(argv[i], "--sql-file=", strlen("--sql-file="))) {
+ arguments->host = (char *)(argv[i++] + strlen("--sql-file="));
+ } else if (0 == strncmp(argv[i], "-s", strlen("-s"))) {
+ arguments->host = (char *)(argv[i++] + strlen("-s"));
+ } else if (strlen("--sql-file") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--sql-file");
+ exit(EXIT_FAILURE);
+ }
+ arguments->sqlFile = argv[++i];
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->sqlFile = argv[++i];
- } else if (strcmp(argv[i], "-q") == 0) {
- if ((argc == i+1)
- || (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-q need a number following!\nQuery mode -- 0: SYNC, not-0: ASYNC. Default is SYNC.\n");
+ } else if ((0 == strncmp(argv[i], "-q", strlen("-q")))
+ || (0 == strncmp(argv[i], "--query-mode", strlen("--query-mode")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "q");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "q");
+ exit(EXIT_FAILURE);
+ }
+ arguments->async_mode = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--query-mode=", strlen("--query-mode="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--query-mode=")))) {
+ arguments->async_mode = atoi((char *)(argv[i]+strlen("--query-mode=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--query-mode");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-q", strlen("-q"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-q")))) {
+ arguments->async_mode = atoi((char *)(argv[i]+strlen("-q")));
+ } else {
+ errorPrintReqArg2(argv[0], "-q");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--query-mode") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--query-mode");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--query-mode");
+ exit(EXIT_FAILURE);
+ }
+ arguments->async_mode = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->async_mode = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-T") == 0) {
- if ((argc == i+1)
- || (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-T need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-T", strlen("-T")))
+ || (0 == strncmp(argv[i], "--threads", strlen("--threads")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "T");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "T");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_threads = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--threads=", strlen("--threads="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--threads=")))) {
+ arguments->num_of_threads = atoi((char *)(argv[i]+strlen("--threads=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--threads");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-T", strlen("-T"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-T")))) {
+ arguments->num_of_threads = atoi((char *)(argv[i]+strlen("-T")));
+ } else {
+ errorPrintReqArg2(argv[0], "-T");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--threads") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--threads");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--threads");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_threads = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->num_of_threads = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-i") == 0) {
- if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-i need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-i", strlen("-i")))
+ || (0 == strncmp(argv[i], "--insert-interval", strlen("--insert-interval")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "i");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "i");
+ exit(EXIT_FAILURE);
+ }
+ arguments->insert_interval = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--insert-interval=", strlen("--insert-interval="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--insert-interval=")))) {
+ arguments->insert_interval = atoi((char *)(argv[i]+strlen("--insert-interval=")));
+ } else {
+ errorPrintReqArg3(argv[0], "--insert-innterval");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-i", strlen("-i"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-i")))) {
+ arguments->insert_interval = atoi((char *)(argv[i]+strlen("-i")));
+ } else {
+ errorPrintReqArg3(argv[0], "-i");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--insert-interval")== strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--insert-interval");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--insert-interval");
+ exit(EXIT_FAILURE);
+ }
+ arguments->insert_interval = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->insert_interval = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-S") == 0) {
- if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("\n\t%s%s", argv[i], " need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-S", strlen("-S")))
+ || (0 == strncmp(argv[i], "--time-step", strlen("--time-step")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "S");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "S");
+ exit(EXIT_FAILURE);
+ }
+ arguments->async_mode = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--time-step=", strlen("--time-step="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--time-step=")))) {
+ arguments->async_mode = atoi((char *)(argv[i]+strlen("--time-step=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--time-step");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-S", strlen("-S"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-S")))) {
+ arguments->async_mode = atoi((char *)(argv[i]+strlen("-S")));
+ } else {
+ errorPrintReqArg2(argv[0], "-S");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--time-step") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--time-step");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--time-step");
+ exit(EXIT_FAILURE);
+ }
+ arguments->async_mode = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->timestamp_step = atoi(argv[++i]);
} else if (strcmp(argv[i], "-qt") == 0) {
if ((argc == i+1)
|| (!isStringNumber(argv[i+1]))) {
@@ -925,55 +1265,221 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
exit(EXIT_FAILURE);
}
arguments->query_times = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-B") == 0) {
- if ((argc == i+1)
- || (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-B need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-B", strlen("-B")))
+ || (0 == strncmp(argv[i], "--interlace-rows", strlen("--interlace-rows")))) {
+ if (strlen("-B") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "B");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "B");
+ exit(EXIT_FAILURE);
+ }
+ arguments->interlace_rows = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--interlace-rows=", strlen("--interlace-rows="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--interlace-rows=")))) {
+ arguments->interlace_rows = atoi((char *)(argv[i]+strlen("--interlace-rows=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--interlace-rows");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-B", strlen("-B"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-B")))) {
+ arguments->interlace_rows = atoi((char *)(argv[i]+strlen("-B")));
+ } else {
+ errorPrintReqArg2(argv[0], "-B");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--interlace-rows")== strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--interlace-rows");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--interlace-rows");
+ exit(EXIT_FAILURE);
+ }
+ arguments->interlace_rows = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->interlace_rows = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-r") == 0) {
- if ((argc == i+1)
- || (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-r need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-r", strlen("-r")))
+ || (0 == strncmp(argv[i], "--rec-per-req", 13))) {
+ if (strlen("-r") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "r");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "r");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_RPR = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--rec-per-req=", strlen("--rec-per-req="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--rec-per-req=")))) {
+ arguments->num_of_RPR = atoi((char *)(argv[i]+strlen("--rec-per-req=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--rec-per-req");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-r", strlen("-r"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-r")))) {
+ arguments->num_of_RPR = atoi((char *)(argv[i]+strlen("-r")));
+ } else {
+ errorPrintReqArg2(argv[0], "-r");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--rec-per-req")== strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--rec-per-req");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--rec-per-req");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_RPR = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->num_of_RPR = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-t") == 0) {
- if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-t need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-t", strlen("-t")))
+ || (0 == strncmp(argv[i], "--tables", strlen("--tables")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "t");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "t");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_tables = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--tables=", strlen("--tables="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--tables=")))) {
+ arguments->num_of_tables = atoi((char *)(argv[i]+strlen("--tables=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--tables");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-t", strlen("-t"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-t")))) {
+ arguments->num_of_tables = atoi((char *)(argv[i]+strlen("-t")));
+ } else {
+ errorPrintReqArg2(argv[0], "-t");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--tables") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--tables");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--tables");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_tables = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->num_of_tables = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-n") == 0) {
- if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-n need a number following!\n");
+
+ g_totalChildTables = arguments->num_of_tables;
+ } else if ((0 == strncmp(argv[i], "-n", strlen("-n")))
+ || (0 == strncmp(argv[i], "--records", strlen("--records")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "n");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "n");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_DPT = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--records=", strlen("--records="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--records=")))) {
+ arguments->num_of_DPT = atoi((char *)(argv[i]+strlen("--records=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--records");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-n", strlen("-n"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-n")))) {
+ arguments->num_of_DPT = atoi((char *)(argv[i]+strlen("-n")));
+ } else {
+ errorPrintReqArg2(argv[0], "-n");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--records") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--records");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--records");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_DPT = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->num_of_DPT = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-d") == 0) {
- if (argc == i+1) {
- printHelp();
- errorPrint("%s", "\n\t-d need a valid string following!\n");
+ } else if ((0 == strncmp(argv[i], "-d", strlen("-d")))
+ || (0 == strncmp(argv[i], "--database", strlen("--database")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "d");
+ exit(EXIT_FAILURE);
+ }
+ arguments->database = argv[++i];
+ } else if (0 == strncmp(argv[i], "--database=", strlen("--database="))) {
+ arguments->output_file = (char *)(argv[i] + strlen("--database="));
+ } else if (0 == strncmp(argv[i], "-d", strlen("-d"))) {
+ arguments->output_file = (char *)(argv[i] + strlen("-d"));
+ } else if (strlen("--database") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--database");
+ exit(EXIT_FAILURE);
+ }
+ arguments->database = argv[++i];
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->database = argv[++i];
- } else if (strcmp(argv[i], "-l") == 0) {
+ } else if ((0 == strncmp(argv[i], "-l", strlen("-l")))
+ || (0 == strncmp(argv[i], "--columns", strlen("--columns")))) {
arguments->demo_mode = false;
- if (argc == i+1) {
- if (!isStringNumber(argv[i+1])) {
- printHelp();
- errorPrint("%s", "\n\t-l need a number following!\n");
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "l");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "l");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_CPR = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--columns=", strlen("--columns="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--columns=")))) {
+ arguments->num_of_CPR = atoi((char *)(argv[i]+strlen("--columns=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--columns");
exit(EXIT_FAILURE);
}
+ } else if (0 == strncmp(argv[i], "-l", strlen("-l"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-l")))) {
+ arguments->num_of_CPR = atoi((char *)(argv[i]+strlen("-l")));
+ } else {
+ errorPrintReqArg2(argv[0], "-l");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--columns")== strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--columns");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--columns");
+ exit(EXIT_FAILURE);
+ }
+ arguments->num_of_CPR = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
+ exit(EXIT_FAILURE);
}
- arguments->num_of_CPR = atoi(argv[++i]);
if (arguments->num_of_CPR > MAX_NUM_COLUMNS) {
printf("WARNING: max acceptible columns count is %d\n", MAX_NUM_COLUMNS);
@@ -987,36 +1493,54 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
for (int col = arguments->num_of_CPR; col < MAX_NUM_COLUMNS; col++) {
arguments->datatype[col] = NULL;
}
- } else if (strcmp(argv[i], "-b") == 0) {
+ } else if ((0 == strncmp(argv[i], "-b", strlen("-b")))
+ || (0 == strncmp(argv[i], "--data-type", strlen("--data-type")))) {
arguments->demo_mode = false;
- if (argc == i+1) {
- printHelp();
- errorPrint("%s", "\n\t-b need valid string following!\n");
+
+ char *dataType;
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "b");
+ exit(EXIT_FAILURE);
+ }
+ dataType = argv[++i];
+ } else if (0 == strncmp(argv[i], "--data-type=", strlen("--data-type="))) {
+ dataType = (char *)(argv[i] + strlen("--data-type="));
+ } else if (0 == strncmp(argv[i], "-b", strlen("-b"))) {
+ dataType = (char *)(argv[i] + strlen("-b"));
+ } else if (strlen("--data-type") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--data-type");
+ exit(EXIT_FAILURE);
+ }
+ dataType = argv[++i];
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- ++i;
- if (strstr(argv[i], ",") == NULL) {
+
+ if (strstr(dataType, ",") == NULL) {
// only one col
- if (strcasecmp(argv[i], "INT")
- && strcasecmp(argv[i], "FLOAT")
- && strcasecmp(argv[i], "TINYINT")
- && strcasecmp(argv[i], "BOOL")
- && strcasecmp(argv[i], "SMALLINT")
- && strcasecmp(argv[i], "BIGINT")
- && strcasecmp(argv[i], "DOUBLE")
- && strcasecmp(argv[i], "BINARY")
- && strcasecmp(argv[i], "TIMESTAMP")
- && strcasecmp(argv[i], "NCHAR")) {
+ if (strcasecmp(dataType, "INT")
+ && strcasecmp(dataType, "FLOAT")
+ && strcasecmp(dataType, "TINYINT")
+ && strcasecmp(dataType, "BOOL")
+ && strcasecmp(dataType, "SMALLINT")
+ && strcasecmp(dataType, "BIGINT")
+ && strcasecmp(dataType, "DOUBLE")
+ && strcasecmp(dataType, "BINARY")
+ && strcasecmp(dataType, "TIMESTAMP")
+ && strcasecmp(dataType, "NCHAR")) {
printHelp();
errorPrint("%s", "-b: Invalid data_type!\n");
exit(EXIT_FAILURE);
}
- arguments->datatype[0] = argv[i];
+ arguments->datatype[0] = dataType;
arguments->datatype[1] = NULL;
} else {
// more than one col
int index = 0;
- g_dupstr = strdup(argv[i]);
+ g_dupstr = strdup(dataType);
char *running = g_dupstr;
char *token = strsep(&running, ",");
while(token != NULL) {
@@ -1041,75 +1565,227 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
arguments->datatype[index] = NULL;
}
- } else if (strcmp(argv[i], "-w") == 0) {
- if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-w need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-w", strlen("-w")))
+ || (0 == strncmp(argv[i], "--binwidth", strlen("--binwidth")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "w");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "w");
+ exit(EXIT_FAILURE);
+ }
+ arguments->binwidth = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--binwidth=", strlen("--binwidth="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--binwidth=")))) {
+ arguments->binwidth = atoi((char *)(argv[i]+strlen("--binwidth=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--binwidth");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-w", strlen("-w"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-w")))) {
+ arguments->binwidth = atoi((char *)(argv[i]+strlen("-w")));
+ } else {
+ errorPrintReqArg2(argv[0], "-w");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--binwidth") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--binwidth");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--binwidth");
+ exit(EXIT_FAILURE);
+ }
+ arguments->binwidth = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->len_of_binary = atoi(argv[++i]);
- } else if (strcmp(argv[i], "-m") == 0) {
- if ((argc == i+1) ||
- (isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-m need a letter-initial string following!\n");
+ } else if ((0 == strncmp(argv[i], "-m", strlen("-m")))
+ || (0 == strncmp(argv[i], "--table-prefix", strlen("--table-prefix")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "m");
+ exit(EXIT_FAILURE);
+ }
+ arguments->tb_prefix = argv[++i];
+ } else if (0 == strncmp(argv[i], "--table-prefix=", strlen("--table-prefix="))) {
+ arguments->tb_prefix = (char *)(argv[i] + strlen("--table-prefix="));
+ } else if (0 == strncmp(argv[i], "-m", strlen("-m"))) {
+ arguments->tb_prefix = (char *)(argv[i] + strlen("-m"));
+ } else if (strlen("--table-prefix") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--table-prefix");
+ exit(EXIT_FAILURE);
+ }
+ arguments->tb_prefix = argv[++i];
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->tb_prefix = argv[++i];
- } else if (strcmp(argv[i], "-N") == 0) {
+ } else if ((strcmp(argv[i], "-N") == 0)
+ || (0 == strcmp(argv[i], "--normal-table"))) {
arguments->use_metric = false;
- } else if (strcmp(argv[i], "-M") == 0) {
+ } else if ((strcmp(argv[i], "-M") == 0)
+ || (0 == strcmp(argv[i], "--random"))) {
arguments->demo_mode = false;
- } else if (strcmp(argv[i], "-x") == 0) {
+ } else if ((strcmp(argv[i], "-x") == 0)
+ || (0 == strcmp(argv[i], "--no-insert"))) {
arguments->insert_only = false;
- } else if (strcmp(argv[i], "-y") == 0) {
+ } else if ((strcmp(argv[i], "-y") == 0)
+ || (0 == strcmp(argv[i], "--answer-yes"))) {
arguments->answer_yes = true;
- } else if (strcmp(argv[i], "-g") == 0) {
+ } else if ((strcmp(argv[i], "-g") == 0)
+ || (0 == strcmp(argv[i], "--debug"))) {
arguments->debug_print = true;
} else if (strcmp(argv[i], "-gg") == 0) {
arguments->verbose_print = true;
- } else if (strcmp(argv[i], "-PP") == 0) {
- arguments->performance_print = true;
- } else if (strcmp(argv[i], "-O") == 0) {
- if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-O need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-O", strlen("-O")))
+ || (0 == strncmp(argv[i], "--disorder", strlen("--disorder")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "O");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "O");
+ exit(EXIT_FAILURE);
+ }
+ arguments->disorderRatio = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--disorder=", strlen("--disorder="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--disorder=")))) {
+ arguments->disorderRatio = atoi((char *)(argv[i]+strlen("--disorder=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--disorder");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-O", strlen("-O"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-O")))) {
+ arguments->disorderRatio = atoi((char *)(argv[i]+strlen("-O")));
+ } else {
+ errorPrintReqArg2(argv[0], "-O");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--disorder") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--disorder");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--disorder");
+ exit(EXIT_FAILURE);
+ }
+ arguments->disorderRatio = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->disorderRatio = atoi(argv[++i]);
-
if (arguments->disorderRatio > 50) {
+ errorPrint("Invalid disorder ratio %d, will be set to %d\n",
+ arguments->disorderRatio, 50);
arguments->disorderRatio = 50;
}
if (arguments->disorderRatio < 0) {
+ errorPrint("Invalid disorder ratio %d, will be set to %d\n",
+ arguments->disorderRatio, 0);
arguments->disorderRatio = 0;
}
+ } else if ((0 == strncmp(argv[i], "-R", strlen("-R")))
+ || (0 == strncmp(argv[i], "--disorder-range",
+ strlen("--disorder-range")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "R");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "R");
+ exit(EXIT_FAILURE);
+ }
+ arguments->disorderRange = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--disorder-range=",
+ strlen("--disorder-range="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--disorder-range=")))) {
+ arguments->disorderRange =
+ atoi((char *)(argv[i]+strlen("--disorder-rnage=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--disorder-range");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-R", strlen("-R"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-R")))) {
+ arguments->disorderRange =
+ atoi((char *)(argv[i]+strlen("-R")));
+ } else {
+ errorPrintReqArg2(argv[0], "-R");
+ exit(EXIT_FAILURE);
+ }
- } else if (strcmp(argv[i], "-R") == 0) {
- if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-R need a number following!\n");
+ if (arguments->disorderRange < 0) {
+ errorPrint("Invalid disorder range %d, will be set to %d\n",
+ arguments->disorderRange, 1000);
+ arguments->disorderRange = 1000;
+ }
+ } else if (strlen("--disorder-range") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--disorder-range");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--disorder-range");
+ exit(EXIT_FAILURE);
+ }
+ arguments->disorderRange = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
-
- arguments->disorderRange = atoi(argv[++i]);
- if (arguments->disorderRange < 0)
- arguments->disorderRange = 1000;
-
- } else if (strcmp(argv[i], "-a") == 0) {
- if ((argc == i+1) ||
- (!isStringNumber(argv[i+1]))) {
- printHelp();
- errorPrint("%s", "\n\t-a need a number following!\n");
+ } else if ((0 == strncmp(argv[i], "-a", strlen("-a")))
+ || (0 == strncmp(argv[i], "--replica",
+ strlen("--replica")))) {
+ if (2 == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg(argv[0], "a");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "a");
+ exit(EXIT_FAILURE);
+ }
+ arguments->replica = atoi(argv[++i]);
+ } else if (0 == strncmp(argv[i], "--replica=",
+ strlen("--replica="))) {
+ if (isStringNumber((char *)(argv[i] + strlen("--replica=")))) {
+ arguments->replica =
+ atoi((char *)(argv[i]+strlen("--replica=")));
+ } else {
+ errorPrintReqArg2(argv[0], "--replica");
+ exit(EXIT_FAILURE);
+ }
+ } else if (0 == strncmp(argv[i], "-a", strlen("-a"))) {
+ if (isStringNumber((char *)(argv[i] + strlen("-a")))) {
+ arguments->replica =
+ atoi((char *)(argv[i]+strlen("-a")));
+ } else {
+ errorPrintReqArg2(argv[0], "-a");
+ exit(EXIT_FAILURE);
+ }
+ } else if (strlen("--replica") == strlen(argv[i])) {
+ if (argc == i+1) {
+ errorPrintReqArg3(argv[0], "--replica");
+ exit(EXIT_FAILURE);
+ } else if (!isStringNumber(argv[i+1])) {
+ errorPrintReqArg2(argv[0], "--replica");
+ exit(EXIT_FAILURE);
+ }
+ arguments->replica = atoi(argv[++i]);
+ } else {
+ errorUnreconized(argv[0], argv[i]);
exit(EXIT_FAILURE);
}
- arguments->replica = atoi(argv[++i]);
+
if (arguments->replica > 3 || arguments->replica < 1) {
+ errorPrint("Invalid replica value %d, will be set to %d\n",
+ arguments->replica, 1);
arguments->replica = 1;
}
} else if (strcmp(argv[i], "-D") == 0) {
@@ -1118,16 +1794,40 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
errorPrint("%s", "\n\t-D need a valud (0~3) number following!\n");
exit(EXIT_FAILURE);
}
- } else if ((strcmp(argv[i], "--version") == 0) ||
- (strcmp(argv[i], "-V") == 0)){
+ } else if ((strcmp(argv[i], "--version") == 0)
+ || (strcmp(argv[i], "-V") == 0)) {
printVersion();
exit(0);
- } else if (strcmp(argv[i], "--help") == 0) {
+ } else if ((strcmp(argv[i], "--help") == 0)
+ || (strcmp(argv[i], "-?") == 0)) {
printHelp();
exit(0);
+ } else if (strcmp(argv[i], "--usage") == 0) {
+ printf(" Usage: taosdemo [-f JSONFILE] [-u USER] [-p PASSWORD] [-c CONFIG_DIR]\n\
+ [-h HOST] [-P PORT] [-I INTERFACE] [-d DATABASE] [-a REPLICA]\n\
+ [-m TABLEPREFIX] [-s SQLFILE] [-N] [-o OUTPUTFILE] [-q QUERYMODE]\n\
+ [-b DATATYPES] [-w WIDTH_OF_BINARY] [-l COLUNNS] [-T THREADNUMBER]\n\
+ [-i SLEEPTIME] [-S TIME_STEP] [-B INTERLACE_ROWS] [-t TABLES]\n\
+ [-n RECORDS] [-M] [-x] [-y] [-O ORDERMODE] [-R RANGE] [-a REPLIcA][-g]\n\
+ [--help] [--usage] [--version]\n");
+ exit(0);
} else {
- printHelp();
- errorPrint("%s", "ERROR: wrong options\n");
+ // to simulate argp_option output
+ if (strlen(argv[i]) > 2) {
+ if (0 == strncmp(argv[i], "--", 2)) {
+ fprintf(stderr, "%s: unrecognized options '%s'\n", argv[0], argv[i]);
+ } else if (0 == strncmp(argv[i], "-", 1)) {
+ char tmp[2] = {0};
+ tstrncpy(tmp, argv[i]+1, 2);
+ fprintf(stderr, "%s: invalid options -- '%s'\n", argv[0], tmp);
+ } else {
+ fprintf(stderr, "%s: Too many arguments\n", argv[0]);
+ }
+ } else {
+ fprintf(stderr, "%s invalid options -- '%s'\n", argv[0],
+ (char *)((char *)argv[i])+1);
+ }
+ fprintf(stderr, "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
exit(EXIT_FAILURE);
}
}
@@ -1144,7 +1844,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
}
g_args.num_of_CPR = columnCount;
- if (((arguments->debug_print) && (arguments->metaFile == NULL))
+ if (((arguments->debug_print) && (NULL != arguments->metaFile))
|| arguments->verbose_print) {
printf("###################################################################\n");
printf("# meta file: %s\n", arguments->metaFile);
@@ -1157,9 +1857,9 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
arguments->use_metric ? "true" : "false");
if (*(arguments->datatype)) {
printf("# Specified data type: ");
- for (int i = 0; i < MAX_NUM_COLUMNS; i++)
- if (arguments->datatype[i])
- printf("%s,", arguments->datatype[i]);
+ for (int c = 0; c < MAX_NUM_COLUMNS; c++)
+ if (arguments->datatype[c])
+ printf("%s,", arguments->datatype[c]);
else
break;
printf("\n");
@@ -1170,7 +1870,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
arguments->num_of_RPR);
printf("# Max SQL length: %"PRIu64"\n",
arguments->max_sql_len);
- printf("# Length of Binary: %d\n", arguments->len_of_binary);
+ printf("# Length of Binary: %d\n", arguments->binwidth);
printf("# Number of Threads: %d\n", arguments->num_of_threads);
printf("# Number of Tables: %"PRId64"\n",
arguments->num_of_tables);
@@ -1225,7 +1925,7 @@ static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
if (code != 0) {
if (!quiet) {
- errorPrint("Failed to execute %s, reason: %s\n",
+ errorPrint2("Failed to execute %s, reason: %s\n",
command, taos_errstr(res));
}
taos_free_result(res);
@@ -1247,7 +1947,7 @@ static void appendResultBufToFile(char *resultBuf, threadInfo *pThreadInfo)
{
pThreadInfo->fp = fopen(pThreadInfo->filePath, "at");
if (pThreadInfo->fp == NULL) {
- errorPrint(
+ errorPrint2(
"%s() LN%d, failed to open result file: %s, result will not save to file\n",
__func__, __LINE__, pThreadInfo->filePath);
return;
@@ -1266,7 +1966,7 @@ static void fetchResult(TAOS_RES *res, threadInfo* pThreadInfo) {
char* databuf = (char*) calloc(1, 100*1024*1024);
if (databuf == NULL) {
- errorPrint("%s() LN%d, failed to malloc, warning: save result to file slowly!\n",
+ errorPrint2("%s() LN%d, failed to malloc, warning: save result to file slowly!\n",
__func__, __LINE__);
return ;
}
@@ -1306,7 +2006,7 @@ static void selectAndGetResult(
if (0 == strncasecmp(g_queryInfo.queryMode, "taosc", strlen("taosc"))) {
TAOS_RES *res = taos_query(pThreadInfo->taos, command);
if (res == NULL || taos_errno(res) != 0) {
- errorPrint("%s() LN%d, failed to execute sql:%s, reason:%s\n",
+ errorPrint2("%s() LN%d, failed to execute sql:%s, reason:%s\n",
__func__, __LINE__, command, taos_errstr(res));
taos_free_result(res);
return;
@@ -1325,23 +2025,23 @@ static void selectAndGetResult(
}
} else {
- errorPrint("%s() LN%d, unknown query mode: %s\n",
+ errorPrint2("%s() LN%d, unknown query mode: %s\n",
__func__, __LINE__, g_queryInfo.queryMode);
}
}
-static char *rand_bool_str(){
+static char *rand_bool_str() {
static int cursor;
cursor++;
if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
- return g_randbool_buff + (cursor * BOOL_BUFF_LEN);
+ return g_randbool_buff + ((cursor % MAX_PREPARED_RAND) * BOOL_BUFF_LEN);
}
-static int32_t rand_bool(){
+static int32_t rand_bool() {
static int cursor;
cursor++;
- cursor = cursor % MAX_PREPARED_RAND;
- return g_randint[cursor] % 2;
+ if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
+ return g_randint[cursor % MAX_PREPARED_RAND] % 2;
}
static char *rand_tinyint_str()
@@ -1349,15 +2049,16 @@ static char *rand_tinyint_str()
static int cursor;
cursor++;
if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
- return g_randtinyint_buff + (cursor * TINYINT_BUFF_LEN);
+ return g_randtinyint_buff +
+ ((cursor % MAX_PREPARED_RAND) * TINYINT_BUFF_LEN);
}
static int32_t rand_tinyint()
{
static int cursor;
cursor++;
- cursor = cursor % MAX_PREPARED_RAND;
- return g_randint[cursor] % 128;
+ if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
+ return g_randint[cursor % MAX_PREPARED_RAND] % 128;
}
static char *rand_smallint_str()
@@ -1365,15 +2066,16 @@ static char *rand_smallint_str()
static int cursor;
cursor++;
if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
- return g_randsmallint_buff + (cursor * SMALLINT_BUFF_LEN);
+ return g_randsmallint_buff +
+ ((cursor % MAX_PREPARED_RAND) * SMALLINT_BUFF_LEN);
}
static int32_t rand_smallint()
{
static int cursor;
cursor++;
- cursor = cursor % MAX_PREPARED_RAND;
- return g_randint[cursor] % 32767;
+ if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
+ return g_randint[cursor % MAX_PREPARED_RAND] % 32767;
}
static char *rand_int_str()
@@ -1381,15 +2083,15 @@ static char *rand_int_str()
static int cursor;
cursor++;
if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
- return g_randint_buff + (cursor * INT_BUFF_LEN);
+ return g_randint_buff + ((cursor % MAX_PREPARED_RAND) * INT_BUFF_LEN);
}
static int32_t rand_int()
{
static int cursor;
cursor++;
- cursor = cursor % MAX_PREPARED_RAND;
- return g_randint[cursor];
+ if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
+ return g_randint[cursor % MAX_PREPARED_RAND];
}
static char *rand_bigint_str()
@@ -1397,15 +2099,16 @@ static char *rand_bigint_str()
static int cursor;
cursor++;
if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
- return g_randbigint_buff + (cursor * BIGINT_BUFF_LEN);
+ return g_randbigint_buff +
+ ((cursor % MAX_PREPARED_RAND) * BIGINT_BUFF_LEN);
}
static int64_t rand_bigint()
{
static int cursor;
cursor++;
- cursor = cursor % MAX_PREPARED_RAND;
- return g_randbigint[cursor];
+ if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
+ return g_randbigint[cursor % MAX_PREPARED_RAND];
}
static char *rand_float_str()
@@ -1413,7 +2116,7 @@ static char *rand_float_str()
static int cursor;
cursor++;
if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
- return g_randfloat_buff + (cursor * FLOAT_BUFF_LEN);
+ return g_randfloat_buff + ((cursor % MAX_PREPARED_RAND) * FLOAT_BUFF_LEN);
}
@@ -1421,8 +2124,8 @@ static float rand_float()
{
static int cursor;
cursor++;
- cursor = cursor % MAX_PREPARED_RAND;
- return g_randfloat[cursor];
+ if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
+ return g_randfloat[cursor % MAX_PREPARED_RAND];
}
static char *demo_current_float_str()
@@ -1430,15 +2133,17 @@ static char *demo_current_float_str()
static int cursor;
cursor++;
if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
- return g_rand_current_buff + (cursor * FLOAT_BUFF_LEN);
+ return g_rand_current_buff +
+ ((cursor % MAX_PREPARED_RAND) * FLOAT_BUFF_LEN);
}
static float UNUSED_FUNC demo_current_float()
{
static int cursor;
cursor++;
- cursor = cursor % MAX_PREPARED_RAND;
- return (float)(9.8 + 0.04 * (g_randint[cursor] % 10) + g_randfloat[cursor]/1000000000);
+ if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
+ return (float)(9.8 + 0.04 * (g_randint[cursor % MAX_PREPARED_RAND] % 10)
+ + g_randfloat[cursor % MAX_PREPARED_RAND]/1000000000);
}
static char *demo_voltage_int_str()
@@ -1446,29 +2151,31 @@ static char *demo_voltage_int_str()
static int cursor;
cursor++;
if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
- return g_rand_voltage_buff + (cursor * INT_BUFF_LEN);
+ return g_rand_voltage_buff +
+ ((cursor % MAX_PREPARED_RAND) * INT_BUFF_LEN);
}
static int32_t UNUSED_FUNC demo_voltage_int()
{
static int cursor;
cursor++;
- cursor = cursor % MAX_PREPARED_RAND;
- return 215 + g_randint[cursor] % 10;
+ if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
+ return 215 + g_randint[cursor % MAX_PREPARED_RAND] % 10;
}
static char *demo_phase_float_str() {
static int cursor;
cursor++;
if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
- return g_rand_phase_buff + (cursor * FLOAT_BUFF_LEN);
+ return g_rand_phase_buff + ((cursor % MAX_PREPARED_RAND) * FLOAT_BUFF_LEN);
}
-static float UNUSED_FUNC demo_phase_float(){
+static float UNUSED_FUNC demo_phase_float() {
static int cursor;
cursor++;
- cursor = cursor % MAX_PREPARED_RAND;
- return (float)((115 + g_randint[cursor] % 10 + g_randfloat[cursor]/1000000000)/360);
+ if (cursor > (MAX_PREPARED_RAND - 1)) cursor = 0;
+ return (float)((115 + g_randint[cursor % MAX_PREPARED_RAND] % 10
+ + g_randfloat[cursor % MAX_PREPARED_RAND]/1000000000)/360);
}
#if 0
@@ -1542,7 +2249,7 @@ static void init_rand_data() {
g_randdouble_buff = calloc(1, DOUBLE_BUFF_LEN * MAX_PREPARED_RAND);
assert(g_randdouble_buff);
- for (int i = 0; i < MAX_PREPARED_RAND; i++){
+ for (int i = 0; i < MAX_PREPARED_RAND; i++) {
g_randint[i] = (int)(taosRandom() % 65535);
sprintf(g_randint_buff + i * INT_BUFF_LEN, "%d",
g_randint[i]);
@@ -1619,7 +2326,7 @@ static int printfInsertMeta() {
printf("resultFile: \033[33m%s\033[0m\n", g_Dbs.resultFile);
printf("thread num of insert data: \033[33m%d\033[0m\n", g_Dbs.threadCount);
printf("thread num of create table: \033[33m%d\033[0m\n",
- g_Dbs.threadCountByCreateTbl);
+ g_Dbs.threadCountForCreateTbl);
printf("top insert interval: \033[33m%"PRIu64"\033[0m\n",
g_args.insert_interval);
printf("number of records per req: \033[33m%u\033[0m\n",
@@ -1688,9 +2395,7 @@ static int printfInsertMeta() {
}
if (g_Dbs.db[i].dbCfg.precision[0] != 0) {
if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
-#if NANO_SECOND_ENABLED == 1
|| (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))
-#endif
|| (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ns", 2))) {
printf(" precision: \033[33m%s\033[0m\n",
g_Dbs.db[i].dbCfg.precision);
@@ -1829,7 +2534,7 @@ static void printfInsertMetaToFile(FILE* fp) {
fprintf(fp, "configDir: %s\n", configDir);
fprintf(fp, "resultFile: %s\n", g_Dbs.resultFile);
fprintf(fp, "thread num of insert data: %d\n", g_Dbs.threadCount);
- fprintf(fp, "thread num of create table: %d\n", g_Dbs.threadCountByCreateTbl);
+ fprintf(fp, "thread num of create table: %d\n", g_Dbs.threadCountForCreateTbl);
fprintf(fp, "number of records per req: %u\n", g_args.num_of_RPR);
fprintf(fp, "max sql length: %"PRIu64"\n", g_args.max_sql_len);
fprintf(fp, "database count: %d\n", g_Dbs.dbCount);
@@ -1881,9 +2586,7 @@ static void printfInsertMetaToFile(FILE* fp) {
}
if (g_Dbs.db[i].dbCfg.precision[0] != 0) {
if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
-#if NANO_SECOND_ENABLED == 1
|| (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ns", 2))
-#endif
|| (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))) {
fprintf(fp, " precision: %s\n",
g_Dbs.db[i].dbCfg.precision);
@@ -2086,10 +2789,8 @@ static char* formatTimestamp(char* buf, int64_t val, int precision) {
time_t tt;
if (precision == TSDB_TIME_PRECISION_MICRO) {
tt = (time_t)(val / 1000000);
-#if NANO_SECOND_ENABLED == 1
} if (precision == TSDB_TIME_PRECISION_NANO) {
tt = (time_t)(val / 1000000000);
-#endif
} else {
tt = (time_t)(val / 1000);
}
@@ -2111,10 +2812,8 @@ static char* formatTimestamp(char* buf, int64_t val, int precision) {
if (precision == TSDB_TIME_PRECISION_MICRO) {
sprintf(buf + pos, ".%06d", (int)(val % 1000000));
-#if NANO_SECOND_ENABLED == 1
} else if (precision == TSDB_TIME_PRECISION_NANO) {
sprintf(buf + pos, ".%09d", (int)(val % 1000000000));
-#endif
} else {
sprintf(buf + pos, ".%03d", (int)(val % 1000));
}
@@ -2176,7 +2875,7 @@ static int xDumpResultToFile(const char* fname, TAOS_RES* tres) {
FILE* fp = fopen(fname, "at");
if (fp == NULL) {
- errorPrint("%s() LN%d, failed to open file: %s\n",
+ errorPrint2("%s() LN%d, failed to open file: %s\n",
__func__, __LINE__, fname);
return -1;
}
@@ -2223,7 +2922,7 @@ static int getDbFromServer(TAOS * taos, SDbInfo** dbInfos) {
int32_t code = taos_errno(res);
if (code != 0) {
- errorPrint( "failed to run , reason: %s\n",
+ errorPrint2("failed to run , reason: %s\n",
taos_errstr(res));
return -1;
}
@@ -2239,7 +2938,7 @@ static int getDbFromServer(TAOS * taos, SDbInfo** dbInfos) {
dbInfos[count] = (SDbInfo *)calloc(1, sizeof(SDbInfo));
if (dbInfos[count] == NULL) {
- errorPrint( "failed to allocate memory for some dbInfo[%d]\n", count);
+ errorPrint2("failed to allocate memory for some dbInfo[%d]\n", count);
return -1;
}
@@ -2392,7 +3091,7 @@ static int postProceSql(char *host, struct sockaddr_in *pServAddr, uint16_t port
request_buf = malloc(req_buf_len);
if (NULL == request_buf) {
- errorPrint("%s", "ERROR, cannot allocate memory.\n");
+ errorPrint("%s", "cannot allocate memory.\n");
exit(EXIT_FAILURE);
}
@@ -2531,7 +3230,7 @@ static int postProceSql(char *host, struct sockaddr_in *pServAddr, uint16_t port
static char* getTagValueFromTagSample(SSuperTable* stbInfo, int tagUsePos) {
char* dataBuf = (char*)calloc(TSDB_MAX_SQL_LEN+1, 1);
if (NULL == dataBuf) {
- errorPrint("%s() LN%d, calloc failed! size:%d\n",
+ errorPrint2("%s() LN%d, calloc failed! size:%d\n",
__func__, __LINE__, TSDB_MAX_SQL_LEN+1);
return NULL;
}
@@ -2596,7 +3295,7 @@ static char* generateTagValuesForStb(SSuperTable* stbInfo, int64_t tableSeq) {
if ((g_args.demo_mode) && (i == 0)) {
dataLen += snprintf(dataBuf + dataLen,
TSDB_MAX_SQL_LEN - dataLen,
- "%"PRId64",", tableSeq % 10);
+ "%"PRId64",", (tableSeq % 10) + 1);
} else {
dataLen += snprintf(dataBuf + dataLen,
TSDB_MAX_SQL_LEN - dataLen,
@@ -2631,7 +3330,7 @@ static char* generateTagValuesForStb(SSuperTable* stbInfo, int64_t tableSeq) {
dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
"%"PRId64",", rand_bigint());
} else {
- errorPrint("No support data type: %s\n", stbInfo->tags[i].dataType);
+ errorPrint2("No support data type: %s\n", stbInfo->tags[i].dataType);
tmfree(dataBuf);
return NULL;
}
@@ -2670,7 +3369,7 @@ static int calcRowLen(SSuperTable* superTbls) {
} else if (strcasecmp(dataType, "TIMESTAMP") == 0) {
lenOfOneRow += TIMESTAMP_BUFF_LEN;
} else {
- errorPrint("get error data type : %s\n", dataType);
+ errorPrint2("get error data type : %s\n", dataType);
exit(EXIT_FAILURE);
}
}
@@ -2701,7 +3400,7 @@ static int calcRowLen(SSuperTable* superTbls) {
} else if (strcasecmp(dataType, "DOUBLE") == 0) {
lenOfTagOfOneRow += superTbls->tags[tagIndex].dataLen + DOUBLE_BUFF_LEN;
} else {
- errorPrint("get error tag type : %s\n", dataType);
+ errorPrint2("get error tag type : %s\n", dataType);
exit(EXIT_FAILURE);
}
}
@@ -2738,7 +3437,7 @@ static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
if (code != 0) {
taos_free_result(res);
taos_close(taos);
- errorPrint("%s() LN%d, failed to run command %s\n",
+ errorPrint2("%s() LN%d, failed to run command %s\n",
__func__, __LINE__, command);
exit(EXIT_FAILURE);
}
@@ -2750,7 +3449,7 @@ static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
if (NULL == childTblName) {
taos_free_result(res);
taos_close(taos);
- errorPrint("%s() LN%d, failed to allocate memory!\n", __func__, __LINE__);
+ errorPrint2("%s() LN%d, failed to allocate memory!\n", __func__, __LINE__);
exit(EXIT_FAILURE);
}
}
@@ -2760,7 +3459,7 @@ static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
int32_t* len = taos_fetch_lengths(res);
if (0 == strlen((char *)row[0])) {
- errorPrint("%s() LN%d, No.%"PRId64" table return empty name\n",
+ errorPrint2("%s() LN%d, No.%"PRId64" table return empty name\n",
__func__, __LINE__, count);
exit(EXIT_FAILURE);
}
@@ -2781,7 +3480,7 @@ static int getChildNameOfSuperTableWithLimitAndOffset(TAOS * taos,
tmfree(childTblName);
taos_free_result(res);
taos_close(taos);
- errorPrint("%s() LN%d, realloc fail for save child table name of %s.%s\n",
+ errorPrint2("%s() LN%d, realloc fail for save child table name of %s.%s\n",
__func__, __LINE__, dbName, sTblName);
exit(EXIT_FAILURE);
}
@@ -2878,7 +3577,7 @@ static int getSuperTableFromServer(TAOS * taos, char* dbName,
int childTblCount = 10000;
superTbls->childTblName = (char*)calloc(1, childTblCount * TSDB_TABLE_NAME_LEN);
if (superTbls->childTblName == NULL) {
- errorPrint("%s() LN%d, alloc memory failed!\n", __func__, __LINE__);
+ errorPrint2("%s() LN%d, alloc memory failed!\n", __func__, __LINE__);
return -1;
}
getAllChildNameOfSuperTable(taos, dbName,
@@ -2904,7 +3603,7 @@ static int createSuperTable(
int lenOfOneRow = 0;
if (superTbl->columnCount == 0) {
- errorPrint("%s() LN%d, super table column count is %d\n",
+ errorPrint2("%s() LN%d, super table column count is %d\n",
__func__, __LINE__, superTbl->columnCount);
free(command);
return -1;
@@ -2968,7 +3667,7 @@ static int createSuperTable(
} else {
taos_close(taos);
free(command);
- errorPrint("%s() LN%d, config error data type : %s\n",
+ errorPrint2("%s() LN%d, config error data type : %s\n",
__func__, __LINE__, dataType);
exit(EXIT_FAILURE);
}
@@ -2981,7 +3680,7 @@ static int createSuperTable(
if (NULL == superTbl->colsOfCreateChildTable) {
taos_close(taos);
free(command);
- errorPrint("%s() LN%d, Failed when calloc, size:%d",
+ errorPrint2("%s() LN%d, Failed when calloc, size:%d",
__func__, __LINE__, len+1);
exit(EXIT_FAILURE);
}
@@ -2991,7 +3690,7 @@ static int createSuperTable(
__func__, __LINE__, superTbl->colsOfCreateChildTable);
if (superTbl->tagCount == 0) {
- errorPrint("%s() LN%d, super table tag count is %d\n",
+ errorPrint2("%s() LN%d, super table tag count is %d\n",
__func__, __LINE__, superTbl->tagCount);
free(command);
return -1;
@@ -3058,7 +3757,7 @@ static int createSuperTable(
} else {
taos_close(taos);
free(command);
- errorPrint("%s() LN%d, config error tag type : %s\n",
+ errorPrint2("%s() LN%d, config error tag type : %s\n",
__func__, __LINE__, dataType);
exit(EXIT_FAILURE);
}
@@ -3073,7 +3772,7 @@ static int createSuperTable(
"create table if not exists %s.%s (ts timestamp%s) tags %s",
dbName, superTbl->sTblName, cols, tags);
if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
- errorPrint( "create supertable %s failed!\n\n",
+ errorPrint2("create supertable %s failed!\n\n",
superTbl->sTblName);
free(command);
return -1;
@@ -3089,7 +3788,7 @@ int createDatabasesAndStables(char *command) {
int ret = 0;
taos = taos_connect(g_Dbs.host, g_Dbs.user, g_Dbs.password, NULL, g_Dbs.port);
if (taos == NULL) {
- errorPrint( "Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL));
+ errorPrint2("Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL));
return -1;
}
@@ -3175,10 +3874,8 @@ int createDatabasesAndStables(char *command) {
" fsync %d", g_Dbs.db[i].dbCfg.fsync);
}
if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
-#if NANO_SECOND_ENABLED == 1
|| (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision,
"ns", 2))
-#endif
|| (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision,
"us", 2))) {
dataLen += snprintf(command + dataLen, BUFFER_SIZE - dataLen,
@@ -3187,7 +3884,7 @@ int createDatabasesAndStables(char *command) {
if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
taos_close(taos);
- errorPrint( "\ncreate database %s failed!\n\n",
+ errorPrint("\ncreate database %s failed!\n\n",
g_Dbs.db[i].dbName);
return -1;
}
@@ -3217,7 +3914,7 @@ int createDatabasesAndStables(char *command) {
ret = getSuperTableFromServer(taos, g_Dbs.db[i].dbName,
&g_Dbs.db[i].superTbls[j]);
if (0 != ret) {
- errorPrint("\nget super table %s.%s info failed!\n\n",
+ errorPrint2("\nget super table %s.%s info failed!\n\n",
g_Dbs.db[i].dbName, g_Dbs.db[i].superTbls[j].sTblName);
continue;
}
@@ -3245,7 +3942,7 @@ static void* createTable(void *sarg)
pThreadInfo->buffer = calloc(buff_len, 1);
if (pThreadInfo->buffer == NULL) {
- errorPrint("%s() LN%d, Memory allocated failed!\n", __func__, __LINE__);
+ errorPrint2("%s() LN%d, Memory allocated failed!\n", __func__, __LINE__);
exit(EXIT_FAILURE);
}
@@ -3264,10 +3961,11 @@ static void* createTable(void *sarg)
pThreadInfo->db_name,
g_args.tb_prefix, i,
pThreadInfo->cols);
+ batchNum ++;
} else {
if (stbInfo == NULL) {
free(pThreadInfo->buffer);
- errorPrint("%s() LN%d, use metric, but super table info is NULL\n",
+ errorPrint2("%s() LN%d, use metric, but super table info is NULL\n",
__func__, __LINE__);
exit(EXIT_FAILURE);
} else {
@@ -3313,13 +4011,14 @@ static void* createTable(void *sarg)
len = 0;
if (0 != queryDbExec(pThreadInfo->taos, pThreadInfo->buffer,
- NO_INSERT_TYPE, false)){
- errorPrint( "queryDbExec() failed. buffer:\n%s\n", pThreadInfo->buffer);
+ NO_INSERT_TYPE, false)) {
+ errorPrint2("queryDbExec() failed. buffer:\n%s\n", pThreadInfo->buffer);
free(pThreadInfo->buffer);
return NULL;
}
+ pThreadInfo->tables_created += batchNum;
- uint64_t currentPrintTime = taosGetTimestampMs();
+ uint64_t currentPrintTime = taosGetTimestampMs();
if (currentPrintTime - lastPrintTime > 30*1000) {
printf("thread[%d] already create %"PRIu64" - %"PRIu64" tables\n",
pThreadInfo->threadID, pThreadInfo->start_table_from, i);
@@ -3330,7 +4029,7 @@ static void* createTable(void *sarg)
if (0 != len) {
if (0 != queryDbExec(pThreadInfo->taos, pThreadInfo->buffer,
NO_INSERT_TYPE, false)) {
- errorPrint( "queryDbExec() failed. buffer:\n%s\n", pThreadInfo->buffer);
+ errorPrint2("queryDbExec() failed. buffer:\n%s\n", pThreadInfo->buffer);
}
}
@@ -3375,7 +4074,7 @@ static int startMultiThreadCreateChildTable(
db_name,
g_Dbs.port);
if (pThreadInfo->taos == NULL) {
- errorPrint( "%s() LN%d, Failed to connect to TDengine, reason:%s\n",
+ errorPrint2("%s() LN%d, Failed to connect to TDengine, reason:%s\n",
__func__, __LINE__, taos_errstr(NULL));
free(pids);
free(infos);
@@ -3389,6 +4088,7 @@ static int startMultiThreadCreateChildTable(
pThreadInfo->use_metric = true;
pThreadInfo->cols = cols;
pThreadInfo->minDelay = UINT64_MAX;
+ pThreadInfo->tables_created = 0;
pthread_create(pids + i, NULL, createTable, pThreadInfo);
}
@@ -3399,6 +4099,8 @@ static int startMultiThreadCreateChildTable(
for (int i = 0; i < threads; i++) {
threadInfo *pThreadInfo = infos + i;
taos_close(pThreadInfo->taos);
+
+ g_actualChildTables += pThreadInfo->tables_created;
}
free(pids);
@@ -3425,14 +4127,13 @@ static void createChildTables() {
verbosePrint("%s() LN%d: %s\n", __func__, __LINE__,
g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
uint64_t startFrom = 0;
- g_totalChildTables += g_Dbs.db[i].superTbls[j].childTblCount;
verbosePrint("%s() LN%d: create %"PRId64" child tables from %"PRIu64"\n",
__func__, __LINE__, g_totalChildTables, startFrom);
startMultiThreadCreateChildTable(
g_Dbs.db[i].superTbls[j].colsOfCreateChildTable,
- g_Dbs.threadCountByCreateTbl,
+ g_Dbs.threadCountForCreateTbl,
startFrom,
g_Dbs.db[i].superTbls[j].childTblCount,
g_Dbs.db[i].dbName, &(g_Dbs.db[i].superTbls[j]));
@@ -3446,7 +4147,7 @@ static void createChildTables() {
|| (strncasecmp(g_args.datatype[j],
"NCHAR", strlen("NCHAR")) == 0)) {
snprintf(tblColsBuf + len, TSDB_MAX_BYTES_PER_ROW - len,
- ",C%d %s(%d)", j, g_args.datatype[j], g_args.len_of_binary);
+ ",C%d %s(%d)", j, g_args.datatype[j], g_args.binwidth);
} else {
snprintf(tblColsBuf + len, TSDB_MAX_BYTES_PER_ROW - len,
",C%d %s", j, g_args.datatype[j]);
@@ -3461,7 +4162,7 @@ static void createChildTables() {
g_Dbs.db[i].dbName, g_args.num_of_tables, tblColsBuf);
startMultiThreadCreateChildTable(
tblColsBuf,
- g_Dbs.threadCountByCreateTbl,
+ g_Dbs.threadCountForCreateTbl,
0,
g_args.num_of_tables,
g_Dbs.db[i].dbName,
@@ -3550,7 +4251,7 @@ static int readSampleFromCsvFileToMem(
FILE* fp = fopen(stbInfo->sampleFile, "r");
if (fp == NULL) {
- errorPrint( "Failed to open sample file: %s, reason:%s\n",
+ errorPrint("Failed to open sample file: %s, reason:%s\n",
stbInfo->sampleFile, strerror(errno));
return -1;
}
@@ -3562,7 +4263,7 @@ static int readSampleFromCsvFileToMem(
readLen = tgetline(&line, &n, fp);
if (-1 == readLen) {
if(0 != fseek(fp, 0, SEEK_SET)) {
- errorPrint( "Failed to fseek file: %s, reason:%s\n",
+ errorPrint("Failed to fseek file: %s, reason:%s\n",
stbInfo->sampleFile, strerror(errno));
fclose(fp);
return -1;
@@ -3605,7 +4306,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
// columns
cJSON *columns = cJSON_GetObjectItem(stbInfo, "columns");
if (columns && columns->type != cJSON_Array) {
- printf("ERROR: failed to read json, columns not found\n");
+ errorPrint("%s", "failed to read json, columns not found\n");
goto PARSE_OVER;
} else if (NULL == columns) {
superTbls->columnCount = 0;
@@ -3615,8 +4316,8 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
int columnSize = cJSON_GetArraySize(columns);
if ((columnSize + 1/* ts */) > TSDB_MAX_COLUMNS) {
- errorPrint("%s() LN%d, failed to read json, column size overflow, max column size is %d\n",
- __func__, __LINE__, TSDB_MAX_COLUMNS);
+ errorPrint("failed to read json, column size overflow, max column size is %d\n",
+ TSDB_MAX_COLUMNS);
goto PARSE_OVER;
}
@@ -3634,8 +4335,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
if (countObj && countObj->type == cJSON_Number) {
count = countObj->valueint;
} else if (countObj && countObj->type != cJSON_Number) {
- errorPrint("%s() LN%d, failed to read json, column count not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, column count not found\n");
goto PARSE_OVER;
} else {
count = 1;
@@ -3646,8 +4346,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
cJSON *dataType = cJSON_GetObjectItem(column, "type");
if (!dataType || dataType->type != cJSON_String
|| dataType->valuestring == NULL) {
- errorPrint("%s() LN%d: failed to read json, column type not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, column type not found\n");
goto PARSE_OVER;
}
//tstrncpy(superTbls->columns[k].dataType, dataType->valuestring, DATATYPE_BUFF_LEN);
@@ -3675,8 +4374,8 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
}
if ((index + 1 /* ts */) > MAX_NUM_COLUMNS) {
- errorPrint("%s() LN%d, failed to read json, column size overflow, allowed max column size is %d\n",
- __func__, __LINE__, MAX_NUM_COLUMNS);
+ errorPrint("failed to read json, column size overflow, allowed max column size is %d\n",
+ MAX_NUM_COLUMNS);
goto PARSE_OVER;
}
@@ -3687,15 +4386,14 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
// tags
cJSON *tags = cJSON_GetObjectItem(stbInfo, "tags");
if (!tags || tags->type != cJSON_Array) {
- errorPrint("%s() LN%d, failed to read json, tags not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, tags not found\n");
goto PARSE_OVER;
}
int tagSize = cJSON_GetArraySize(tags);
if (tagSize > TSDB_MAX_TAGS) {
- errorPrint("%s() LN%d, failed to read json, tags size overflow, max tag size is %d\n",
- __func__, __LINE__, TSDB_MAX_TAGS);
+ errorPrint("failed to read json, tags size overflow, max tag size is %d\n",
+ TSDB_MAX_TAGS);
goto PARSE_OVER;
}
@@ -3709,7 +4407,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
if (countObj && countObj->type == cJSON_Number) {
count = countObj->valueint;
} else if (countObj && countObj->type != cJSON_Number) {
- printf("ERROR: failed to read json, column count not found\n");
+ errorPrint("%s", "failed to read json, column count not found\n");
goto PARSE_OVER;
} else {
count = 1;
@@ -3720,8 +4418,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
cJSON *dataType = cJSON_GetObjectItem(tag, "type");
if (!dataType || dataType->type != cJSON_String
|| dataType->valuestring == NULL) {
- errorPrint("%s() LN%d, failed to read json, tag type not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, tag type not found\n");
goto PARSE_OVER;
}
tstrncpy(columnCase.dataType, dataType->valuestring,
@@ -3731,8 +4428,7 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
if (dataLen && dataLen->type == cJSON_Number) {
columnCase.dataLen = dataLen->valueint;
} else if (dataLen && dataLen->type != cJSON_Number) {
- errorPrint("%s() LN%d, failed to read json, column len not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, column len not found\n");
goto PARSE_OVER;
} else {
columnCase.dataLen = 0;
@@ -3747,16 +4443,16 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
}
if (index > TSDB_MAX_TAGS) {
- errorPrint("%s() LN%d, failed to read json, tags size overflow, allowed max tag count is %d\n",
- __func__, __LINE__, TSDB_MAX_TAGS);
+ errorPrint("failed to read json, tags size overflow, allowed max tag count is %d\n",
+ TSDB_MAX_TAGS);
goto PARSE_OVER;
}
superTbls->tagCount = index;
if ((superTbls->columnCount + superTbls->tagCount + 1 /* ts */) > TSDB_MAX_COLUMNS) {
- errorPrint("%s() LN%d, columns + tags is more than allowed max columns count: %d\n",
- __func__, __LINE__, TSDB_MAX_COLUMNS);
+ errorPrint("columns + tags is more than allowed max columns count: %d\n",
+ TSDB_MAX_COLUMNS);
goto PARSE_OVER;
}
ret = true;
@@ -3779,7 +4475,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!host) {
tstrncpy(g_Dbs.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
} else {
- printf("ERROR: failed to read json, host not found\n");
+ errorPrint("%s", "failed to read json, host not found\n");
goto PARSE_OVER;
}
@@ -3799,9 +4495,9 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
cJSON* password = cJSON_GetObjectItem(root, "password");
if (password && password->type == cJSON_String && password->valuestring != NULL) {
- tstrncpy(g_Dbs.password, password->valuestring, MAX_PASSWORD_SIZE);
+ tstrncpy(g_Dbs.password, password->valuestring, SHELL_MAX_PASSWORD_LEN);
} else if (!password) {
- tstrncpy(g_Dbs.password, "taosdata", MAX_PASSWORD_SIZE);
+ tstrncpy(g_Dbs.password, "taosdata", SHELL_MAX_PASSWORD_LEN);
}
cJSON* resultfile = cJSON_GetObjectItem(root, "result_file");
@@ -3817,42 +4513,38 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!threads) {
g_Dbs.threadCount = 1;
} else {
- printf("ERROR: failed to read json, threads not found\n");
+ errorPrint("%s", "failed to read json, threads not found\n");
goto PARSE_OVER;
}
cJSON* threads2 = cJSON_GetObjectItem(root, "thread_count_create_tbl");
if (threads2 && threads2->type == cJSON_Number) {
- g_Dbs.threadCountByCreateTbl = threads2->valueint;
+ g_Dbs.threadCountForCreateTbl = threads2->valueint;
} else if (!threads2) {
- g_Dbs.threadCountByCreateTbl = 1;
+ g_Dbs.threadCountForCreateTbl = 1;
} else {
- errorPrint("%s() LN%d, failed to read json, threads2 not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, threads2 not found\n");
goto PARSE_OVER;
}
cJSON* gInsertInterval = cJSON_GetObjectItem(root, "insert_interval");
if (gInsertInterval && gInsertInterval->type == cJSON_Number) {
if (gInsertInterval->valueint <0) {
- errorPrint("%s() LN%d, failed to read json, insert interval input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, insert interval input mistake\n");
goto PARSE_OVER;
}
g_args.insert_interval = gInsertInterval->valueint;
} else if (!gInsertInterval) {
g_args.insert_interval = 0;
} else {
- errorPrint("%s() LN%d, failed to read json, insert_interval input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, insert_interval input mistake\n");
goto PARSE_OVER;
}
cJSON* interlaceRows = cJSON_GetObjectItem(root, "interlace_rows");
if (interlaceRows && interlaceRows->type == cJSON_Number) {
if (interlaceRows->valueint < 0) {
- errorPrint("%s() LN%d, failed to read json, interlace_rows input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, interlace_rows input mistake\n");
goto PARSE_OVER;
}
@@ -3860,8 +4552,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!interlaceRows) {
g_args.interlace_rows = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
} else {
- errorPrint("%s() LN%d, failed to read json, interlace_rows input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, interlace_rows input mistake\n");
goto PARSE_OVER;
}
@@ -3934,14 +4625,14 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
cJSON* dbs = cJSON_GetObjectItem(root, "databases");
if (!dbs || dbs->type != cJSON_Array) {
- printf("ERROR: failed to read json, databases not found\n");
+ errorPrint("%s", "failed to read json, databases not found\n");
goto PARSE_OVER;
}
int dbSize = cJSON_GetArraySize(dbs);
if (dbSize > MAX_DB_COUNT) {
errorPrint(
- "ERROR: failed to read json, databases size overflow, max database is %d\n",
+ "failed to read json, databases size overflow, max database is %d\n",
MAX_DB_COUNT);
goto PARSE_OVER;
}
@@ -3954,13 +4645,13 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
// dbinfo
cJSON *dbinfo = cJSON_GetObjectItem(dbinfos, "dbinfo");
if (!dbinfo || dbinfo->type != cJSON_Object) {
- printf("ERROR: failed to read json, dbinfo not found\n");
+ errorPrint("%s", "failed to read json, dbinfo not found\n");
goto PARSE_OVER;
}
cJSON *dbName = cJSON_GetObjectItem(dbinfo, "name");
if (!dbName || dbName->type != cJSON_String || dbName->valuestring == NULL) {
- printf("ERROR: failed to read json, db name not found\n");
+ errorPrint("%s", "failed to read json, db name not found\n");
goto PARSE_OVER;
}
tstrncpy(g_Dbs.db[i].dbName, dbName->valuestring, TSDB_DB_NAME_LEN);
@@ -3975,8 +4666,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!drop) {
g_Dbs.db[i].drop = g_args.drop_database;
} else {
- errorPrint("%s() LN%d, failed to read json, drop input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, drop input mistake\n");
goto PARSE_OVER;
}
@@ -3988,7 +4678,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!precision) {
memset(g_Dbs.db[i].dbCfg.precision, 0, SMALL_BUFF_LEN);
} else {
- printf("ERROR: failed to read json, precision not found\n");
+ errorPrint("%s", "failed to read json, precision not found\n");
goto PARSE_OVER;
}
@@ -3998,7 +4688,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!update) {
g_Dbs.db[i].dbCfg.update = -1;
} else {
- printf("ERROR: failed to read json, update not found\n");
+ errorPrint("%s", "failed to read json, update not found\n");
goto PARSE_OVER;
}
@@ -4008,7 +4698,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!replica) {
g_Dbs.db[i].dbCfg.replica = -1;
} else {
- printf("ERROR: failed to read json, replica not found\n");
+ errorPrint("%s", "failed to read json, replica not found\n");
goto PARSE_OVER;
}
@@ -4018,7 +4708,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!keep) {
g_Dbs.db[i].dbCfg.keep = -1;
} else {
- printf("ERROR: failed to read json, keep not found\n");
+ errorPrint("%s", "failed to read json, keep not found\n");
goto PARSE_OVER;
}
@@ -4028,7 +4718,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!days) {
g_Dbs.db[i].dbCfg.days = -1;
} else {
- printf("ERROR: failed to read json, days not found\n");
+ errorPrint("%s", "failed to read json, days not found\n");
goto PARSE_OVER;
}
@@ -4038,7 +4728,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!cache) {
g_Dbs.db[i].dbCfg.cache = -1;
} else {
- printf("ERROR: failed to read json, cache not found\n");
+ errorPrint("%s", "failed to read json, cache not found\n");
goto PARSE_OVER;
}
@@ -4048,7 +4738,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!blocks) {
g_Dbs.db[i].dbCfg.blocks = -1;
} else {
- printf("ERROR: failed to read json, block not found\n");
+ errorPrint("%s", "failed to read json, block not found\n");
goto PARSE_OVER;
}
@@ -4068,7 +4758,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!minRows) {
g_Dbs.db[i].dbCfg.minRows = 0; // 0 means default
} else {
- printf("ERROR: failed to read json, minRows not found\n");
+ errorPrint("%s", "failed to read json, minRows not found\n");
goto PARSE_OVER;
}
@@ -4078,7 +4768,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!maxRows) {
g_Dbs.db[i].dbCfg.maxRows = 0; // 0 means default
} else {
- printf("ERROR: failed to read json, maxRows not found\n");
+ errorPrint("%s", "failed to read json, maxRows not found\n");
goto PARSE_OVER;
}
@@ -4088,7 +4778,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!comp) {
g_Dbs.db[i].dbCfg.comp = -1;
} else {
- printf("ERROR: failed to read json, comp not found\n");
+ errorPrint("%s", "failed to read json, comp not found\n");
goto PARSE_OVER;
}
@@ -4098,7 +4788,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!walLevel) {
g_Dbs.db[i].dbCfg.walLevel = -1;
} else {
- printf("ERROR: failed to read json, walLevel not found\n");
+ errorPrint("%s", "failed to read json, walLevel not found\n");
goto PARSE_OVER;
}
@@ -4108,7 +4798,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!cacheLast) {
g_Dbs.db[i].dbCfg.cacheLast = -1;
} else {
- printf("ERROR: failed to read json, cacheLast not found\n");
+ errorPrint("%s", "failed to read json, cacheLast not found\n");
goto PARSE_OVER;
}
@@ -4128,24 +4818,22 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!fsync) {
g_Dbs.db[i].dbCfg.fsync = -1;
} else {
- errorPrint("%s() LN%d, failed to read json, fsync input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, fsync input mistake\n");
goto PARSE_OVER;
}
// super_talbes
cJSON *stables = cJSON_GetObjectItem(dbinfos, "super_tables");
if (!stables || stables->type != cJSON_Array) {
- errorPrint("%s() LN%d, failed to read json, super_tables not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, super_tables not found\n");
goto PARSE_OVER;
}
int stbSize = cJSON_GetArraySize(stables);
if (stbSize > MAX_SUPER_TABLE_COUNT) {
errorPrint(
- "%s() LN%d, failed to read json, supertable size overflow, max supertable is %d\n",
- __func__, __LINE__, MAX_SUPER_TABLE_COUNT);
+ "failed to read json, supertable size overflow, max supertable is %d\n",
+ MAX_SUPER_TABLE_COUNT);
goto PARSE_OVER;
}
@@ -4158,8 +4846,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
cJSON *stbName = cJSON_GetObjectItem(stbInfo, "name");
if (!stbName || stbName->type != cJSON_String
|| stbName->valuestring == NULL) {
- errorPrint("%s() LN%d, failed to read json, stb name not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, stb name not found\n");
goto PARSE_OVER;
}
tstrncpy(g_Dbs.db[i].superTbls[j].sTblName, stbName->valuestring,
@@ -4167,7 +4854,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
cJSON *prefix = cJSON_GetObjectItem(stbInfo, "childtable_prefix");
if (!prefix || prefix->type != cJSON_String || prefix->valuestring == NULL) {
- printf("ERROR: failed to read json, childtable_prefix not found\n");
+ errorPrint("%s", "failed to read json, childtable_prefix not found\n");
goto PARSE_OVER;
}
tstrncpy(g_Dbs.db[i].superTbls[j].childTblPrefix, prefix->valuestring,
@@ -4188,7 +4875,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!autoCreateTbl) {
g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
} else {
- printf("ERROR: failed to read json, auto_create_table not found\n");
+ errorPrint("%s", "failed to read json, auto_create_table not found\n");
goto PARSE_OVER;
}
@@ -4196,9 +4883,9 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
if (batchCreateTbl && batchCreateTbl->type == cJSON_Number) {
g_Dbs.db[i].superTbls[j].batchCreateTableNum = batchCreateTbl->valueint;
} else if (!batchCreateTbl) {
- g_Dbs.db[i].superTbls[j].batchCreateTableNum = 1000;
+ g_Dbs.db[i].superTbls[j].batchCreateTableNum = 10;
} else {
- printf("ERROR: failed to read json, batch_create_tbl_num not found\n");
+ errorPrint("%s", "failed to read json, batch_create_tbl_num not found\n");
goto PARSE_OVER;
}
@@ -4218,8 +4905,8 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!childTblExists) {
g_Dbs.db[i].superTbls[j].childTblExists = TBL_NO_EXISTS;
} else {
- errorPrint("%s() LN%d, failed to read json, child_table_exists not found\n",
- __func__, __LINE__);
+ errorPrint("%s",
+ "failed to read json, child_table_exists not found\n");
goto PARSE_OVER;
}
@@ -4229,11 +4916,12 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
cJSON* count = cJSON_GetObjectItem(stbInfo, "childtable_count");
if (!count || count->type != cJSON_Number || 0 >= count->valueint) {
- errorPrint("%s() LN%d, failed to read json, childtable_count input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s",
+ "failed to read json, childtable_count input mistake\n");
goto PARSE_OVER;
}
g_Dbs.db[i].superTbls[j].childTblCount = count->valueint;
+ g_totalChildTables += g_Dbs.db[i].superTbls[j].childTblCount;
cJSON *dataSource = cJSON_GetObjectItem(stbInfo, "data_source");
if (dataSource && dataSource->type == cJSON_String
@@ -4245,8 +4933,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
tstrncpy(g_Dbs.db[i].superTbls[j].dataSource, "rand",
min(SMALL_BUFF_LEN, strlen("rand") + 1));
} else {
- errorPrint("%s() LN%d, failed to read json, data_source not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, data_source not found\n");
goto PARSE_OVER;
}
@@ -4257,13 +4944,11 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
g_Dbs.db[i].superTbls[j].iface= TAOSC_IFACE;
} else if (0 == strcasecmp(stbIface->valuestring, "rest")) {
g_Dbs.db[i].superTbls[j].iface= REST_IFACE;
-#if STMT_IFACE_ENABLED == 1
} else if (0 == strcasecmp(stbIface->valuestring, "stmt")) {
g_Dbs.db[i].superTbls[j].iface= STMT_IFACE;
-#endif
} else {
- errorPrint("%s() LN%d, failed to read json, insert_mode %s not recognized\n",
- __func__, __LINE__, stbIface->valuestring);
+ errorPrint("failed to read json, insert_mode %s not recognized\n",
+ stbIface->valuestring);
goto PARSE_OVER;
}
} else if (!stbIface) {
@@ -4277,7 +4962,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
if ((childTbl_limit) && (g_Dbs.db[i].drop != true)
&& (g_Dbs.db[i].superTbls[j].childTblExists == TBL_ALREADY_EXISTS)) {
if (childTbl_limit->type != cJSON_Number) {
- printf("ERROR: failed to read json, childtable_limit\n");
+ errorPrint("%s", "failed to read json, childtable_limit\n");
goto PARSE_OVER;
}
g_Dbs.db[i].superTbls[j].childTblLimit = childTbl_limit->valueint;
@@ -4290,7 +4975,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
&& (g_Dbs.db[i].superTbls[j].childTblExists == TBL_ALREADY_EXISTS)) {
if ((childTbl_offset->type != cJSON_Number)
|| (0 > childTbl_offset->valueint)) {
- printf("ERROR: failed to read json, childtable_offset\n");
+ errorPrint("%s", "failed to read json, childtable_offset\n");
goto PARSE_OVER;
}
g_Dbs.db[i].superTbls[j].childTblOffset = childTbl_offset->valueint;
@@ -4306,7 +4991,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
tstrncpy(g_Dbs.db[i].superTbls[j].startTimestamp,
"now", TSDB_DB_NAME_LEN);
} else {
- printf("ERROR: failed to read json, start_timestamp not found\n");
+ errorPrint("%s", "failed to read json, start_timestamp not found\n");
goto PARSE_OVER;
}
@@ -4316,7 +5001,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!timestampStep) {
g_Dbs.db[i].superTbls[j].timeStampStep = g_args.timestamp_step;
} else {
- printf("ERROR: failed to read json, timestamp_step not found\n");
+ errorPrint("%s", "failed to read json, timestamp_step not found\n");
goto PARSE_OVER;
}
@@ -4331,7 +5016,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
tstrncpy(g_Dbs.db[i].superTbls[j].sampleFormat, "csv",
SMALL_BUFF_LEN);
} else {
- printf("ERROR: failed to read json, sample_format not found\n");
+ errorPrint("%s", "failed to read json, sample_format not found\n");
goto PARSE_OVER;
}
@@ -4346,7 +5031,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
memset(g_Dbs.db[i].superTbls[j].sampleFile, 0,
MAX_FILE_NAME_LEN);
} else {
- printf("ERROR: failed to read json, sample_file not found\n");
+ errorPrint("%s", "failed to read json, sample_file not found\n");
goto PARSE_OVER;
}
@@ -4364,7 +5049,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
memset(g_Dbs.db[i].superTbls[j].tagsFile, 0, MAX_FILE_NAME_LEN);
g_Dbs.db[i].superTbls[j].tagSource = 0;
} else {
- printf("ERROR: failed to read json, tags_file not found\n");
+ errorPrint("%s", "failed to read json, tags_file not found\n");
goto PARSE_OVER;
}
@@ -4380,8 +5065,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!maxSqlLen) {
g_Dbs.db[i].superTbls[j].maxSqlLen = g_args.max_sql_len;
} else {
- errorPrint("%s() LN%d, failed to read json, stbMaxSqlLen input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, stbMaxSqlLen input mistake\n");
goto PARSE_OVER;
}
/*
@@ -4398,31 +5082,28 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!multiThreadWriteOneTbl) {
g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl = 0;
} else {
- printf("ERROR: failed to read json, multiThreadWriteOneTbl not found\n");
+ errorPrint("%s", "failed to read json, multiThreadWriteOneTbl not found\n");
goto PARSE_OVER;
}
*/
cJSON* insertRows = cJSON_GetObjectItem(stbInfo, "insert_rows");
if (insertRows && insertRows->type == cJSON_Number) {
if (insertRows->valueint < 0) {
- errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, insert_rows input mistake\n");
goto PARSE_OVER;
}
g_Dbs.db[i].superTbls[j].insertRows = insertRows->valueint;
} else if (!insertRows) {
g_Dbs.db[i].superTbls[j].insertRows = 0x7FFFFFFFFFFFFFFF;
} else {
- errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, insert_rows input mistake\n");
goto PARSE_OVER;
}
cJSON* stbInterlaceRows = cJSON_GetObjectItem(stbInfo, "interlace_rows");
if (stbInterlaceRows && stbInterlaceRows->type == cJSON_Number) {
if (stbInterlaceRows->valueint < 0) {
- errorPrint("%s() LN%d, failed to read json, interlace rows input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, interlace rows input mistake\n");
goto PARSE_OVER;
}
g_Dbs.db[i].superTbls[j].interlaceRows = stbInterlaceRows->valueint;
@@ -4440,8 +5121,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
g_Dbs.db[i].superTbls[j].interlaceRows = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
} else {
errorPrint(
- "%s() LN%d, failed to read json, interlace rows input mistake\n",
- __func__, __LINE__);
+ "%s", "failed to read json, interlace rows input mistake\n");
goto PARSE_OVER;
}
@@ -4457,7 +5137,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!disorderRatio) {
g_Dbs.db[i].superTbls[j].disorderRatio = 0;
} else {
- printf("ERROR: failed to read json, disorderRatio not found\n");
+ errorPrint("%s", "failed to read json, disorderRatio not found\n");
goto PARSE_OVER;
}
@@ -4467,7 +5147,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
} else if (!disorderRange) {
g_Dbs.db[i].superTbls[j].disorderRange = 1000;
} else {
- printf("ERROR: failed to read json, disorderRange not found\n");
+ errorPrint("%s", "failed to read json, disorderRange not found\n");
goto PARSE_OVER;
}
@@ -4475,8 +5155,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
if (insertInterval && insertInterval->type == cJSON_Number) {
g_Dbs.db[i].superTbls[j].insertInterval = insertInterval->valueint;
if (insertInterval->valueint < 0) {
- errorPrint("%s() LN%d, failed to read json, insert_interval input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, insert_interval input mistake\n");
goto PARSE_OVER;
}
} else if (!insertInterval) {
@@ -4484,8 +5163,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
__func__, __LINE__, g_args.insert_interval);
g_Dbs.db[i].superTbls[j].insertInterval = g_args.insert_interval;
} else {
- errorPrint("%s() LN%d, failed to read json, insert_interval input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, insert_interval input mistake\n");
goto PARSE_OVER;
}
@@ -4517,7 +5195,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
} else if (!host) {
tstrncpy(g_queryInfo.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
} else {
- printf("ERROR: failed to read json, host not found\n");
+ errorPrint("%s", "failed to read json, host not found\n");
goto PARSE_OVER;
}
@@ -4537,9 +5215,9 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
cJSON* password = cJSON_GetObjectItem(root, "password");
if (password && password->type == cJSON_String && password->valuestring != NULL) {
- tstrncpy(g_queryInfo.password, password->valuestring, MAX_PASSWORD_SIZE);
+ tstrncpy(g_queryInfo.password, password->valuestring, SHELL_MAX_PASSWORD_LEN);
} else if (!password) {
- tstrncpy(g_queryInfo.password, "taosdata", MAX_PASSWORD_SIZE);;
+ tstrncpy(g_queryInfo.password, "taosdata", SHELL_MAX_PASSWORD_LEN);;
}
cJSON *answerPrompt = cJSON_GetObjectItem(root, "confirm_parameter_prompt"); // yes, no,
@@ -4555,23 +5233,21 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
} else if (!answerPrompt) {
g_args.answer_yes = false;
} else {
- printf("ERROR: failed to read json, confirm_parameter_prompt not found\n");
+ errorPrint("%s", "failed to read json, confirm_parameter_prompt not found\n");
goto PARSE_OVER;
}
cJSON* gQueryTimes = cJSON_GetObjectItem(root, "query_times");
if (gQueryTimes && gQueryTimes->type == cJSON_Number) {
if (gQueryTimes->valueint <= 0) {
- errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s()", "failed to read json, query_times input mistake\n");
goto PARSE_OVER;
}
g_args.query_times = gQueryTimes->valueint;
} else if (!gQueryTimes) {
g_args.query_times = 1;
} else {
- errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, query_times input mistake\n");
goto PARSE_OVER;
}
@@ -4579,7 +5255,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
if (dbs && dbs->type == cJSON_String && dbs->valuestring != NULL) {
tstrncpy(g_queryInfo.dbName, dbs->valuestring, TSDB_DB_NAME_LEN);
} else if (!dbs) {
- printf("ERROR: failed to read json, databases not found\n");
+ errorPrint("%s", "failed to read json, databases not found\n");
goto PARSE_OVER;
}
@@ -4593,7 +5269,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
tstrncpy(g_queryInfo.queryMode, "taosc",
min(SMALL_BUFF_LEN, strlen("taosc") + 1));
} else {
- printf("ERROR: failed to read json, query_mode not found\n");
+ errorPrint("%s", "failed to read json, query_mode not found\n");
goto PARSE_OVER;
}
@@ -4603,7 +5279,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
g_queryInfo.specifiedQueryInfo.concurrent = 1;
g_queryInfo.specifiedQueryInfo.sqlCount = 0;
} else if (specifiedQuery->type != cJSON_Object) {
- printf("ERROR: failed to read json, super_table_query not found\n");
+ errorPrint("%s", "failed to read json, super_table_query not found\n");
goto PARSE_OVER;
} else {
cJSON* queryInterval = cJSON_GetObjectItem(specifiedQuery, "query_interval");
@@ -4618,8 +5294,8 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
if (specifiedQueryTimes && specifiedQueryTimes->type == cJSON_Number) {
if (specifiedQueryTimes->valueint <= 0) {
errorPrint(
- "%s() LN%d, failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
- __func__, __LINE__, specifiedQueryTimes->valueint);
+ "failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
+ specifiedQueryTimes->valueint);
goto PARSE_OVER;
}
@@ -4636,8 +5312,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
if (concurrent && concurrent->type == cJSON_Number) {
if (concurrent->valueint <= 0) {
errorPrint(
- "%s() LN%d, query sqlCount %d or concurrent %d is not correct.\n",
- __func__, __LINE__,
+ "query sqlCount %d or concurrent %d is not correct.\n",
g_queryInfo.specifiedQueryInfo.sqlCount,
g_queryInfo.specifiedQueryInfo.concurrent);
goto PARSE_OVER;
@@ -4655,8 +5330,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
} else if (0 == strcmp("async", specifiedAsyncMode->valuestring)) {
g_queryInfo.specifiedQueryInfo.asyncMode = ASYNC_MODE;
} else {
- errorPrint("%s() LN%d, failed to read json, async mode input error\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, async mode input error\n");
goto PARSE_OVER;
}
} else {
@@ -4679,7 +5353,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
} else if (0 == strcmp("no", restart->valuestring)) {
g_queryInfo.specifiedQueryInfo.subscribeRestart = false;
} else {
- printf("ERROR: failed to read json, subscribe restart error\n");
+ errorPrint("%s", "failed to read json, subscribe restart error\n");
goto PARSE_OVER;
}
} else {
@@ -4695,7 +5369,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
} else if (0 == strcmp("no", keepProgress->valuestring)) {
g_queryInfo.specifiedQueryInfo.subscribeKeepProgress = 0;
} else {
- printf("ERROR: failed to read json, subscribe keepProgress error\n");
+ errorPrint("%s", "failed to read json, subscribe keepProgress error\n");
goto PARSE_OVER;
}
} else {
@@ -4707,15 +5381,13 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
if (!specifiedSqls) {
g_queryInfo.specifiedQueryInfo.sqlCount = 0;
} else if (specifiedSqls->type != cJSON_Array) {
- errorPrint("%s() LN%d, failed to read json, super sqls not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, super sqls not found\n");
goto PARSE_OVER;
} else {
int superSqlSize = cJSON_GetArraySize(specifiedSqls);
if (superSqlSize * g_queryInfo.specifiedQueryInfo.concurrent
> MAX_QUERY_SQL_COUNT) {
- errorPrint("%s() LN%d, failed to read json, query sql(%d) * concurrent(%d) overflow, max is %d\n",
- __func__, __LINE__,
+ errorPrint("failed to read json, query sql(%d) * concurrent(%d) overflow, max is %d\n",
superSqlSize,
g_queryInfo.specifiedQueryInfo.concurrent,
MAX_QUERY_SQL_COUNT);
@@ -4729,7 +5401,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
cJSON *sqlStr = cJSON_GetObjectItem(sql, "sql");
if (!sqlStr || sqlStr->type != cJSON_String || sqlStr->valuestring == NULL) {
- printf("ERROR: failed to read json, sql not found\n");
+ errorPrint("%s", "failed to read json, sql not found\n");
goto PARSE_OVER;
}
tstrncpy(g_queryInfo.specifiedQueryInfo.sql[j],
@@ -4769,7 +5441,8 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
memset(g_queryInfo.specifiedQueryInfo.result[j],
0, MAX_FILE_NAME_LEN);
} else {
- printf("ERROR: failed to read json, super query result file not found\n");
+ errorPrint("%s",
+ "failed to read json, super query result file not found\n");
goto PARSE_OVER;
}
}
@@ -4782,7 +5455,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
g_queryInfo.superQueryInfo.threadCnt = 1;
g_queryInfo.superQueryInfo.sqlCount = 0;
} else if (superQuery->type != cJSON_Object) {
- printf("ERROR: failed to read json, sub_table_query not found\n");
+ errorPrint("%s", "failed to read json, sub_table_query not found\n");
ret = true;
goto PARSE_OVER;
} else {
@@ -4796,24 +5469,22 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
cJSON* superQueryTimes = cJSON_GetObjectItem(superQuery, "query_times");
if (superQueryTimes && superQueryTimes->type == cJSON_Number) {
if (superQueryTimes->valueint <= 0) {
- errorPrint("%s() LN%d, failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
- __func__, __LINE__, superQueryTimes->valueint);
+ errorPrint("failed to read json, query_times: %"PRId64", need be a valid (>0) number\n",
+ superQueryTimes->valueint);
goto PARSE_OVER;
}
g_queryInfo.superQueryInfo.queryTimes = superQueryTimes->valueint;
} else if (!superQueryTimes) {
g_queryInfo.superQueryInfo.queryTimes = g_args.query_times;
} else {
- errorPrint("%s() LN%d, failed to read json, query_times input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, query_times input mistake\n");
goto PARSE_OVER;
}
cJSON* threads = cJSON_GetObjectItem(superQuery, "threads");
if (threads && threads->type == cJSON_Number) {
if (threads->valueint <= 0) {
- errorPrint("%s() LN%d, failed to read json, threads input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, threads input mistake\n");
goto PARSE_OVER;
}
@@ -4835,8 +5506,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
tstrncpy(g_queryInfo.superQueryInfo.sTblName, stblname->valuestring,
TSDB_TABLE_NAME_LEN);
} else {
- errorPrint("%s() LN%d, failed to read json, super table name input error\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, super table name input error\n");
goto PARSE_OVER;
}
@@ -4848,8 +5518,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
} else if (0 == strcmp("async", superAsyncMode->valuestring)) {
g_queryInfo.superQueryInfo.asyncMode = ASYNC_MODE;
} else {
- errorPrint("%s() LN%d, failed to read json, async mode input error\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, async mode input error\n");
goto PARSE_OVER;
}
} else {
@@ -4859,8 +5528,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
cJSON* superInterval = cJSON_GetObjectItem(superQuery, "interval");
if (superInterval && superInterval->type == cJSON_Number) {
if (superInterval->valueint < 0) {
- errorPrint("%s() LN%d, failed to read json, interval input mistake\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, interval input mistake\n");
goto PARSE_OVER;
}
g_queryInfo.superQueryInfo.subscribeInterval = superInterval->valueint;
@@ -4878,7 +5546,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
} else if (0 == strcmp("no", subrestart->valuestring)) {
g_queryInfo.superQueryInfo.subscribeRestart = false;
} else {
- printf("ERROR: failed to read json, subscribe restart error\n");
+ errorPrint("%s", "failed to read json, subscribe restart error\n");
goto PARSE_OVER;
}
} else {
@@ -4894,7 +5562,8 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
} else if (0 == strcmp("no", superkeepProgress->valuestring)) {
g_queryInfo.superQueryInfo.subscribeKeepProgress = 0;
} else {
- printf("ERROR: failed to read json, subscribe super table keepProgress error\n");
+ errorPrint("%s",
+ "failed to read json, subscribe super table keepProgress error\n");
goto PARSE_OVER;
}
} else {
@@ -4931,14 +5600,13 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
if (!superSqls) {
g_queryInfo.superQueryInfo.sqlCount = 0;
} else if (superSqls->type != cJSON_Array) {
- errorPrint("%s() LN%d: failed to read json, super sqls not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, super sqls not found\n");
goto PARSE_OVER;
} else {
int superSqlSize = cJSON_GetArraySize(superSqls);
if (superSqlSize > MAX_QUERY_SQL_COUNT) {
- errorPrint("%s() LN%d, failed to read json, query sql size overflow, max is %d\n",
- __func__, __LINE__, MAX_QUERY_SQL_COUNT);
+ errorPrint("failed to read json, query sql size overflow, max is %d\n",
+ MAX_QUERY_SQL_COUNT);
goto PARSE_OVER;
}
@@ -4950,8 +5618,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
cJSON *sqlStr = cJSON_GetObjectItem(sql, "sql");
if (!sqlStr || sqlStr->type != cJSON_String
|| sqlStr->valuestring == NULL) {
- errorPrint("%s() LN%d, failed to read json, sql not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, sql not found\n");
goto PARSE_OVER;
}
tstrncpy(g_queryInfo.superQueryInfo.sql[j], sqlStr->valuestring,
@@ -4959,14 +5626,13 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
cJSON *result = cJSON_GetObjectItem(sql, "result");
if (result != NULL && result->type == cJSON_String
- && result->valuestring != NULL){
+ && result->valuestring != NULL) {
tstrncpy(g_queryInfo.superQueryInfo.result[j],
result->valuestring, MAX_FILE_NAME_LEN);
} else if (NULL == result) {
memset(g_queryInfo.superQueryInfo.result[j], 0, MAX_FILE_NAME_LEN);
} else {
- errorPrint("%s() LN%d, failed to read json, sub query result file not found\n",
- __func__, __LINE__);
+ errorPrint("%s", "failed to read json, sub query result file not found\n");
goto PARSE_OVER;
}
}
@@ -4984,7 +5650,7 @@ static bool getInfoFromJsonFile(char* file) {
FILE *fp = fopen(file, "r");
if (!fp) {
- printf("failed to read %s, reason:%s\n", file, strerror(errno));
+ errorPrint("failed to read %s, reason:%s\n", file, strerror(errno));
return false;
}
@@ -4995,14 +5661,14 @@ static bool getInfoFromJsonFile(char* file) {
if (len <= 0) {
free(content);
fclose(fp);
- printf("failed to read %s, content is null", file);
+ errorPrint("failed to read %s, content is null", file);
return false;
}
content[len] = 0;
cJSON* root = cJSON_Parse(content);
if (root == NULL) {
- printf("ERROR: failed to cjson parse %s, invalid json format\n", file);
+ errorPrint("failed to cjson parse %s, invalid json format\n", file);
goto PARSE_OVER;
}
@@ -5015,13 +5681,13 @@ static bool getInfoFromJsonFile(char* file) {
} else if (0 == strcasecmp("subscribe", filetype->valuestring)) {
g_args.test_mode = SUBSCRIBE_TEST;
} else {
- printf("ERROR: failed to read json, filetype not support\n");
+ errorPrint("%s", "failed to read json, filetype not support\n");
goto PARSE_OVER;
}
} else if (!filetype) {
g_args.test_mode = INSERT_TEST;
} else {
- printf("ERROR: failed to read json, filetype not found\n");
+ errorPrint("%s", "failed to read json, filetype not found\n");
goto PARSE_OVER;
}
@@ -5031,8 +5697,8 @@ static bool getInfoFromJsonFile(char* file) {
|| (SUBSCRIBE_TEST == g_args.test_mode)) {
ret = getMetaFromQueryJsonFile(root);
} else {
- errorPrint("%s() LN%d, input json file type error! please input correct file type: insert or query or subscribe\n",
- __func__, __LINE__);
+ errorPrint("%s",
+ "input json file type error! please input correct file type: insert or query or subscribe\n");
goto PARSE_OVER;
}
@@ -5069,22 +5735,6 @@ static void postFreeResource() {
free(g_Dbs.db[i].superTbls[j].sampleDataBuf);
g_Dbs.db[i].superTbls[j].sampleDataBuf = NULL;
}
-#if STMT_IFACE_ENABLED == 1
- if (g_Dbs.db[i].superTbls[j].sampleBindArray) {
- for (int k = 0; k < MAX_SAMPLES_ONCE_FROM_FILE; k++) {
- uintptr_t *tmp = (uintptr_t *)(*(uintptr_t *)(
- g_Dbs.db[i].superTbls[j].sampleBindArray
- + sizeof(uintptr_t *) * k));
- for (int c = 1; c < g_Dbs.db[i].superTbls[j].columnCount + 1; c++) {
- TAOS_BIND *bind = (TAOS_BIND *)((char *)tmp + (sizeof(TAOS_BIND) * c));
- if (bind)
- tmfree(bind->buffer);
- }
- tmfree((char *)tmp);
- }
- }
- tmfree((char *)g_Dbs.db[i].superTbls[j].sampleBindArray);
-#endif
if (0 != g_Dbs.db[i].superTbls[j].tagDataBuf) {
free(g_Dbs.db[i].superTbls[j].tagDataBuf);
@@ -5152,7 +5802,7 @@ static int64_t generateStbRowData(
|| (0 == strncasecmp(stbInfo->columns[i].dataType,
"NCHAR", 5))) {
if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
- errorPrint( "binary or nchar length overflow, max size:%u\n",
+ errorPrint2("binary or nchar length overflow, max size:%u\n",
(uint32_t)TSDB_MAX_BINARY_LEN);
return -1;
}
@@ -5164,7 +5814,7 @@ static int64_t generateStbRowData(
}
char* buf = (char*)calloc(stbInfo->columns[i].dataLen+1, 1);
if (NULL == buf) {
- errorPrint( "calloc failed! size:%d\n", stbInfo->columns[i].dataLen);
+ errorPrint2("calloc failed! size:%d\n", stbInfo->columns[i].dataLen);
return -1;
}
rand_string(buf, stbInfo->columns[i].dataLen);
@@ -5209,7 +5859,8 @@ static int64_t generateStbRowData(
"SMALLINT", 8)) {
tmp = rand_smallint_str();
tmpLen = strlen(tmp);
- tstrncpy(pstr + dataLen, tmp, min(tmpLen + 1, SMALLINT_BUFF_LEN));
+ tstrncpy(pstr + dataLen, tmp,
+ min(tmpLen + 1, SMALLINT_BUFF_LEN));
} else if (0 == strncasecmp(stbInfo->columns[i].dataType,
"TINYINT", 7)) {
tmp = rand_tinyint_str();
@@ -5222,11 +5873,12 @@ static int64_t generateStbRowData(
tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, BOOL_BUFF_LEN));
} else if (0 == strncasecmp(stbInfo->columns[i].dataType,
"TIMESTAMP", 9)) {
- tmp = rand_int_str();
+ tmp = rand_bigint_str();
tmpLen = strlen(tmp);
- tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, INT_BUFF_LEN));
+ tstrncpy(pstr + dataLen, tmp, min(tmpLen +1, BIGINT_BUFF_LEN));
} else {
- errorPrint( "Not support data type: %s\n", stbInfo->columns[i].dataType);
+ errorPrint2("Not support data type: %s\n",
+ stbInfo->columns[i].dataType);
return -1;
}
@@ -5239,8 +5891,7 @@ static int64_t generateStbRowData(
return 0;
}
- dataLen -= 1;
- dataLen += snprintf(pstr + dataLen, maxLen - dataLen, ")");
+ tstrncpy(pstr + dataLen - 1, ")", 2);
verbosePrint("%s() LN%d, dataLen:%"PRId64"\n", __func__, __LINE__, dataLen);
verbosePrint("%s() LN%d, recBuf:\n\t%s\n", __func__, __LINE__, recBuf);
@@ -5278,7 +5929,7 @@ static int64_t generateData(char *recBuf, char **data_type,
} else if (strcasecmp(data_type[i % columnCount], "BINARY") == 0) {
char *s = malloc(lenOfBinary + 1);
if (s == NULL) {
- errorPrint("%s() LN%d, memory allocation %d bytes failed\n",
+ errorPrint2("%s() LN%d, memory allocation %d bytes failed\n",
__func__, __LINE__, lenOfBinary + 1);
exit(EXIT_FAILURE);
}
@@ -5288,7 +5939,7 @@ static int64_t generateData(char *recBuf, char **data_type,
} else if (strcasecmp(data_type[i % columnCount], "NCHAR") == 0) {
char *s = malloc(lenOfBinary + 1);
if (s == NULL) {
- errorPrint("%s() LN%d, memory allocation %d bytes failed\n",
+ errorPrint2("%s() LN%d, memory allocation %d bytes failed\n",
__func__, __LINE__, lenOfBinary + 1);
exit(EXIT_FAILURE);
}
@@ -5309,26 +5960,102 @@ static int64_t generateData(char *recBuf, char **data_type,
return (int32_t)strlen(recBuf);
}
+static int generateSampleMemoryFromRand(SSuperTable *stbInfo)
+{
+ char data[MAX_DATA_SIZE];
+ memset(data, 0, MAX_DATA_SIZE);
+
+ char *buff = malloc(stbInfo->lenOfOneRow);
+ if (NULL == buff) {
+ errorPrint2("%s() LN%d, memory allocation %"PRId64" bytes failed\n",
+ __func__, __LINE__, stbInfo->lenOfOneRow);
+ exit(EXIT_FAILURE);
+ }
+
+ for (int i=0; i < MAX_SAMPLES_ONCE_FROM_FILE; i++) {
+ uint64_t pos = 0;
+ memset(buff, 0, stbInfo->lenOfOneRow);
+
+ for (int c = 0; c < stbInfo->columnCount; c++) {
+ char *tmp;
+ if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "BINARY", strlen("BINARY"))) {
+ rand_string(data, stbInfo->columns[c].dataLen);
+ pos += sprintf(buff + pos, "%s,", data);
+ } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "NCHAR", strlen("NCHAR"))) {
+ rand_string(data, stbInfo->columns[c].dataLen);
+ pos += sprintf(buff + pos, "%s,", data);
+ } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "INT", strlen("INT"))) {
+ if ((g_args.demo_mode) && (c == 1)) {
+ tmp = demo_voltage_int_str();
+ } else {
+ tmp = rand_int_str();
+ }
+ pos += sprintf(buff + pos, "%s,", tmp);
+ } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "BIGINT", strlen("BIGINT"))) {
+ pos += sprintf(buff + pos, "%s,", rand_bigint_str());
+ } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "FLOAT", strlen("FLOAT"))) {
+ if (g_args.demo_mode) {
+ if (c == 0) {
+ tmp = demo_current_float_str();
+ } else {
+ tmp = demo_phase_float_str();
+ }
+ } else {
+ tmp = rand_float_str();
+ }
+ pos += sprintf(buff + pos, "%s,", tmp);
+ } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "DOUBLE", strlen("DOUBLE"))) {
+ pos += sprintf(buff + pos, "%s,", rand_double_str());
+ } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "SMALLINT", strlen("SMALLINT"))) {
+ pos += sprintf(buff + pos, "%s,", rand_smallint_str());
+ } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "TINYINT", strlen("TINYINT"))) {
+ pos += sprintf(buff + pos, "%s,", rand_tinyint_str());
+ } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "BOOL", strlen("BOOL"))) {
+ pos += sprintf(buff + pos, "%s,", rand_bool_str());
+ } else if (0 == strncasecmp(stbInfo->columns[c].dataType,
+ "TIMESTAMP", strlen("TIMESTAMP"))) {
+ pos += sprintf(buff + pos, "%s,", rand_bigint_str());
+ }
+ }
+ *(buff + pos - 1) = 0;
+ memcpy(stbInfo->sampleDataBuf + i * stbInfo->lenOfOneRow, buff, pos);
+ }
+
+ free(buff);
+ return 0;
+}
+
static int prepareSampleDataForSTable(SSuperTable *stbInfo) {
- char* sampleDataBuf = NULL;
- sampleDataBuf = calloc(
+ stbInfo->sampleDataBuf = calloc(
stbInfo->lenOfOneRow * MAX_SAMPLES_ONCE_FROM_FILE, 1);
- if (sampleDataBuf == NULL) {
- errorPrint("%s() LN%d, Failed to calloc %"PRIu64" Bytes, reason:%s\n",
+ if (NULL == stbInfo->sampleDataBuf) {
+ errorPrint2("%s() LN%d, Failed to calloc %"PRIu64" Bytes, reason:%s\n",
__func__, __LINE__,
stbInfo->lenOfOneRow * MAX_SAMPLES_ONCE_FROM_FILE,
strerror(errno));
return -1;
}
- stbInfo->sampleDataBuf = sampleDataBuf;
- int ret = readSampleFromCsvFileToMem(stbInfo);
+ int ret;
+ if (0 == strncasecmp(stbInfo->dataSource, "sample", strlen("sample")))
+ ret = readSampleFromCsvFileToMem(stbInfo);
+ else
+ ret = generateSampleMemoryFromRand(stbInfo);
if (0 != ret) {
- errorPrint("%s() LN%d, read sample from csv file failed.\n",
+ errorPrint2("%s() LN%d, read sample from csv file failed.\n",
__func__, __LINE__);
- tmfree(sampleDataBuf);
+ tmfree(stbInfo->sampleDataBuf);
stbInfo->sampleDataBuf = NULL;
return -1;
}
@@ -5341,9 +6068,6 @@ static int32_t execInsert(threadInfo *pThreadInfo, uint32_t k)
int32_t affectedRows;
SSuperTable* stbInfo = pThreadInfo->stbInfo;
- verbosePrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
- __func__, __LINE__, pThreadInfo->buffer);
-
uint16_t iface;
if (stbInfo)
iface = stbInfo->iface;
@@ -5361,12 +6085,18 @@ static int32_t execInsert(threadInfo *pThreadInfo, uint32_t k)
switch(iface) {
case TAOSC_IFACE:
+ verbosePrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
+ __func__, __LINE__, pThreadInfo->buffer);
+
affectedRows = queryDbExec(
pThreadInfo->taos,
pThreadInfo->buffer, INSERT_TYPE, false);
break;
case REST_IFACE:
+ verbosePrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
+ __func__, __LINE__, pThreadInfo->buffer);
+
if (0 != postProceSql(g_Dbs.host, &g_Dbs.serv_addr, g_Dbs.port,
pThreadInfo->buffer, pThreadInfo)) {
affectedRows = -1;
@@ -5377,12 +6107,11 @@ static int32_t execInsert(threadInfo *pThreadInfo, uint32_t k)
}
break;
-#if STMT_IFACE_ENABLED == 1
case STMT_IFACE:
debugPrint("%s() LN%d, stmt=%p",
__func__, __LINE__, pThreadInfo->stmt);
if (0 != taos_stmt_execute(pThreadInfo->stmt)) {
- errorPrint("%s() LN%d, failied to execute insert statement. reason: %s\n",
+ errorPrint2("%s() LN%d, failied to execute insert statement. reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(pThreadInfo->stmt));
fprintf(stderr, "\n\033[31m === Please reduce batch number if WAL size exceeds limit. ===\033[0m\n\n");
@@ -5390,10 +6119,9 @@ static int32_t execInsert(threadInfo *pThreadInfo, uint32_t k)
}
affectedRows = k;
break;
-#endif
default:
- errorPrint("%s() LN%d: unknown insert mode: %d\n",
+ errorPrint2("%s() LN%d: unknown insert mode: %d\n",
__func__, __LINE__, stbInfo->iface);
affectedRows = 0;
}
@@ -5448,7 +6176,7 @@ static int32_t generateDataTailWithoutStb(
int64_t retLen = 0;
char **data_type = g_args.datatype;
- int lenOfBinary = g_args.len_of_binary;
+ int lenOfBinary = g_args.binwidth;
if (g_args.disorderRatio) {
retLen = generateData(data, data_type,
@@ -5621,7 +6349,7 @@ static int generateStbSQLHead(
tableSeq % stbInfo->tagSampleCount);
}
if (NULL == tagsValBuf) {
- errorPrint("%s() LN%d, tag buf failed to allocate memory\n",
+ errorPrint2("%s() LN%d, tag buf failed to allocate memory\n",
__func__, __LINE__);
return -1;
}
@@ -5763,7 +6491,6 @@ static int64_t generateInterlaceDataWithoutStb(
return k;
}
-#if STMT_IFACE_ENABLED == 1
static int32_t prepareStmtBindArrayByType(
TAOS_BIND *bind,
char *dataType, int32_t dataLen,
@@ -5773,7 +6500,7 @@ static int32_t prepareStmtBindArrayByType(
if (0 == strncasecmp(dataType,
"BINARY", strlen("BINARY"))) {
if (dataLen > TSDB_MAX_BINARY_LEN) {
- errorPrint( "binary length overflow, max size:%u\n",
+ errorPrint2("binary length overflow, max size:%u\n",
(uint32_t)TSDB_MAX_BINARY_LEN);
return -1;
}
@@ -5796,7 +6523,7 @@ static int32_t prepareStmtBindArrayByType(
} else if (0 == strncasecmp(dataType,
"NCHAR", strlen("NCHAR"))) {
if (dataLen > TSDB_MAX_BINARY_LEN) {
- errorPrint( "nchar length overflow, max size:%u\n",
+ errorPrint2("nchar length overflow, max size:%u\n",
(uint32_t)TSDB_MAX_BINARY_LEN);
return -1;
}
@@ -5818,6 +6545,7 @@ static int32_t prepareStmtBindArrayByType(
} else if (0 == strncasecmp(dataType,
"INT", strlen("INT"))) {
int32_t *bind_int = malloc(sizeof(int32_t));
+ assert(bind_int);
if (value) {
*bind_int = atoi(value);
@@ -5832,6 +6560,7 @@ static int32_t prepareStmtBindArrayByType(
} else if (0 == strncasecmp(dataType,
"BIGINT", strlen("BIGINT"))) {
int64_t *bind_bigint = malloc(sizeof(int64_t));
+ assert(bind_bigint);
if (value) {
*bind_bigint = atoll(value);
@@ -5846,6 +6575,7 @@ static int32_t prepareStmtBindArrayByType(
} else if (0 == strncasecmp(dataType,
"FLOAT", strlen("FLOAT"))) {
float *bind_float = malloc(sizeof(float));
+ assert(bind_float);
if (value) {
*bind_float = (float)atof(value);
@@ -5860,6 +6590,7 @@ static int32_t prepareStmtBindArrayByType(
} else if (0 == strncasecmp(dataType,
"DOUBLE", strlen("DOUBLE"))) {
double *bind_double = malloc(sizeof(double));
+ assert(bind_double);
if (value) {
*bind_double = atof(value);
@@ -5874,6 +6605,7 @@ static int32_t prepareStmtBindArrayByType(
} else if (0 == strncasecmp(dataType,
"SMALLINT", strlen("SMALLINT"))) {
int16_t *bind_smallint = malloc(sizeof(int16_t));
+ assert(bind_smallint);
if (value) {
*bind_smallint = (int16_t)atoi(value);
@@ -5888,6 +6620,7 @@ static int32_t prepareStmtBindArrayByType(
} else if (0 == strncasecmp(dataType,
"TINYINT", strlen("TINYINT"))) {
int8_t *bind_tinyint = malloc(sizeof(int8_t));
+ assert(bind_tinyint);
if (value) {
*bind_tinyint = (int8_t)atoi(value);
@@ -5902,6 +6635,7 @@ static int32_t prepareStmtBindArrayByType(
} else if (0 == strncasecmp(dataType,
"BOOL", strlen("BOOL"))) {
int8_t *bind_bool = malloc(sizeof(int8_t));
+ assert(bind_bool);
if (value) {
if (strncasecmp(value, "true", 4)) {
@@ -5921,6 +6655,7 @@ static int32_t prepareStmtBindArrayByType(
} else if (0 == strncasecmp(dataType,
"TIMESTAMP", strlen("TIMESTAMP"))) {
int64_t *bind_ts2 = malloc(sizeof(int64_t));
+ assert(bind_ts2);
if (value) {
if (strchr(value, ':') && strchr(value, '-')) {
@@ -5935,7 +6670,8 @@ static int32_t prepareStmtBindArrayByType(
if (TSDB_CODE_SUCCESS != taosParseTime(
value, &tmpEpoch, strlen(value),
timePrec, 0)) {
- errorPrint("Input %s, time format error!\n", value);
+ free(bind_ts2);
+ errorPrint2("Input %s, time format error!\n", value);
return -1;
}
*bind_ts2 = tmpEpoch;
@@ -5951,7 +6687,7 @@ static int32_t prepareStmtBindArrayByType(
bind->length = &bind->buffer_length;
bind->is_null = NULL;
} else {
- errorPrint( "No support data type: %s\n", dataType);
+ errorPrint2("Not support data type: %s\n", dataType);
return -1;
}
@@ -5968,7 +6704,7 @@ static int32_t prepareStmtBindArrayByTypeForRand(
if (0 == strncasecmp(dataType,
"BINARY", strlen("BINARY"))) {
if (dataLen > TSDB_MAX_BINARY_LEN) {
- errorPrint( "binary length overflow, max size:%u\n",
+ errorPrint2("binary length overflow, max size:%u\n",
(uint32_t)TSDB_MAX_BINARY_LEN);
return -1;
}
@@ -5991,7 +6727,7 @@ static int32_t prepareStmtBindArrayByTypeForRand(
} else if (0 == strncasecmp(dataType,
"NCHAR", strlen("NCHAR"))) {
if (dataLen > TSDB_MAX_BINARY_LEN) {
- errorPrint( "nchar length overflow, max size:%u\n",
+ errorPrint2("nchar length overflow, max size: %u\n",
(uint32_t)TSDB_MAX_BINARY_LEN);
return -1;
}
@@ -6143,7 +6879,7 @@ static int32_t prepareStmtBindArrayByTypeForRand(
if (TSDB_CODE_SUCCESS != taosParseTime(
value, &tmpEpoch, strlen(value),
timePrec, 0)) {
- errorPrint("Input %s, time format error!\n", value);
+ errorPrint2("Input %s, time format error!\n", value);
return -1;
}
*bind_ts2 = tmpEpoch;
@@ -6161,7 +6897,7 @@ static int32_t prepareStmtBindArrayByTypeForRand(
*ptr += bind->buffer_length;
} else {
- errorPrint( "No support data type: %s\n", dataType);
+ errorPrint2("No support data type: %s\n", dataType);
return -1;
}
@@ -6179,7 +6915,7 @@ static int32_t prepareStmtWithoutStb(
TAOS_STMT *stmt = pThreadInfo->stmt;
int ret = taos_stmt_set_tbname(stmt, tableName);
if (ret != 0) {
- errorPrint("failed to execute taos_stmt_set_tbname(%s). return 0x%x. reason: %s\n",
+ errorPrint2("failed to execute taos_stmt_set_tbname(%s). return 0x%x. reason: %s\n",
tableName, ret, taos_stmt_errstr(stmt));
return ret;
}
@@ -6188,7 +6924,7 @@ static int32_t prepareStmtWithoutStb(
char *bindArray = malloc(sizeof(TAOS_BIND) * (g_args.num_of_CPR + 1));
if (bindArray == NULL) {
- errorPrint("Failed to allocate %d bind params\n",
+ errorPrint2("Failed to allocate %d bind params\n",
(g_args.num_of_CPR + 1));
return -1;
}
@@ -6222,20 +6958,20 @@ static int32_t prepareStmtWithoutStb(
if ( -1 == prepareStmtBindArrayByType(
bind,
data_type[i],
- g_args.len_of_binary,
+ g_args.binwidth,
pThreadInfo->time_precision,
NULL)) {
return -1;
}
}
if (0 != taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray)) {
- errorPrint("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
break;
}
// if msg > 3MB, break
if (0 != taos_stmt_add_batch(stmt)) {
- errorPrint("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
break;
}
@@ -6256,10 +6992,10 @@ static int32_t prepareStbStmtBindTag(
char *tagsVal,
int32_t timePrec)
{
- char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.len_of_binary);
+ char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.binwidth);
if (bindBuffer == NULL) {
- errorPrint("%s() LN%d, Failed to allocate %d bind buffer\n",
- __func__, __LINE__, g_args.len_of_binary);
+ errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
+ __func__, __LINE__, DOUBLE_BUFF_LEN);
return -1;
}
@@ -6288,10 +7024,10 @@ static int32_t prepareStbStmtBindRand(
int64_t startTime, int32_t recSeq,
int32_t timePrec)
{
- char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.len_of_binary);
+ char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.binwidth);
if (bindBuffer == NULL) {
- errorPrint("%s() LN%d, Failed to allocate %d bind buffer\n",
- __func__, __LINE__, g_args.len_of_binary);
+ errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
+ __func__, __LINE__, DOUBLE_BUFF_LEN);
return -1;
}
@@ -6338,12 +7074,12 @@ static int32_t prepareStbStmtBindRand(
return 0;
}
-static int32_t prepareStbStmtBindWithSample(
+static int32_t prepareStbStmtBindStartTime(
+ char *tableName,
int64_t *ts,
char *bindArray, SSuperTable *stbInfo,
int64_t startTime, int32_t recSeq,
- int32_t timePrec,
- int64_t samplePos)
+ int32_t timePrec)
{
TAOS_BIND *bind;
@@ -6360,6 +7096,10 @@ static int32_t prepareStbStmtBindWithSample(
} else {
*bind_ts = startTime + stbInfo->timeStampStep * recSeq;
}
+
+ verbosePrint("%s() LN%d, tableName: %s, bind_ts=%"PRId64"\n",
+ __func__, __LINE__, tableName, *bind_ts);
+
bind->buffer_length = sizeof(int64_t);
bind->buffer = bind_ts;
bind->length = &bind->buffer_length;
@@ -6368,7 +7108,7 @@ static int32_t prepareStbStmtBindWithSample(
return 0;
}
-static int32_t prepareStbStmtRand(
+UNUSED_FUNC static int32_t prepareStbStmtRand(
threadInfo *pThreadInfo,
char *tableName,
int64_t tableSeq,
@@ -6393,7 +7133,7 @@ static int32_t prepareStbStmtRand(
}
if (NULL == tagsValBuf) {
- errorPrint("%s() LN%d, tag buf failed to allocate memory\n",
+ errorPrint2("%s() LN%d, tag buf failed to allocate memory\n",
__func__, __LINE__);
return -1;
}
@@ -6401,7 +7141,7 @@ static int32_t prepareStbStmtRand(
char *tagsArray = calloc(1, sizeof(TAOS_BIND) * stbInfo->tagCount);
if (NULL == tagsArray) {
tmfree(tagsValBuf);
- errorPrint("%s() LN%d, tag buf failed to allocate memory\n",
+ errorPrint2("%s() LN%d, tag buf failed to allocate memory\n",
__func__, __LINE__);
return -1;
}
@@ -6420,14 +7160,14 @@ static int32_t prepareStbStmtRand(
tmfree(tagsArray);
if (0 != ret) {
- errorPrint("%s() LN%d, stmt_set_tbname_tags() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_set_tbname_tags() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
return -1;
}
} else {
ret = taos_stmt_set_tbname(stmt, tableName);
if (0 != ret) {
- errorPrint("%s() LN%d, stmt_set_tbname() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_set_tbname() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
return -1;
}
@@ -6435,7 +7175,7 @@ static int32_t prepareStbStmtRand(
char *bindArray = calloc(1, sizeof(TAOS_BIND) * (stbInfo->columnCount + 1));
if (bindArray == NULL) {
- errorPrint("%s() LN%d, Failed to allocate %d bind params\n",
+ errorPrint2("%s() LN%d, Failed to allocate %d bind params\n",
__func__, __LINE__, (stbInfo->columnCount + 1));
return -1;
}
@@ -6454,7 +7194,7 @@ static int32_t prepareStbStmtRand(
}
ret = taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
if (0 != ret) {
- errorPrint("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
free(bindArray);
return -1;
@@ -6462,7 +7202,7 @@ static int32_t prepareStbStmtRand(
// if msg > 3MB, break
ret = taos_stmt_add_batch(stmt);
if (0 != ret) {
- errorPrint("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
free(bindArray);
return -1;
@@ -6506,7 +7246,7 @@ static int32_t prepareStbStmtWithSample(
}
if (NULL == tagsValBuf) {
- errorPrint("%s() LN%d, tag buf failed to allocate memory\n",
+ errorPrint2("%s() LN%d, tag buf failed to allocate memory\n",
__func__, __LINE__);
return -1;
}
@@ -6514,7 +7254,7 @@ static int32_t prepareStbStmtWithSample(
char *tagsArray = calloc(1, sizeof(TAOS_BIND) * stbInfo->tagCount);
if (NULL == tagsArray) {
tmfree(tagsValBuf);
- errorPrint("%s() LN%d, tag buf failed to allocate memory\n",
+ errorPrint2("%s() LN%d, tag buf failed to allocate memory\n",
__func__, __LINE__);
return -1;
}
@@ -6533,14 +7273,14 @@ static int32_t prepareStbStmtWithSample(
tmfree(tagsArray);
if (0 != ret) {
- errorPrint("%s() LN%d, stmt_set_tbname_tags() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_set_tbname_tags() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
return -1;
}
} else {
ret = taos_stmt_set_tbname(stmt, tableName);
if (0 != ret) {
- errorPrint("%s() LN%d, stmt_set_tbname() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_set_tbname() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
return -1;
}
@@ -6549,27 +7289,27 @@ static int32_t prepareStbStmtWithSample(
uint32_t k;
for (k = 0; k < batch;) {
char *bindArray = (char *)(*((uintptr_t *)
- (stbInfo->sampleBindArray + (sizeof(char *)) * (*pSamplePos))));
+ (pThreadInfo->sampleBindArray + (sizeof(char *)) * (*pSamplePos))));
/* columnCount + 1 (ts) */
- if (-1 == prepareStbStmtBindWithSample(
+ if (-1 == prepareStbStmtBindStartTime(
+ tableName,
pThreadInfo->bind_ts,
bindArray, stbInfo,
startTime, k,
- pThreadInfo->time_precision,
- *pSamplePos
+ pThreadInfo->time_precision
/* is column */)) {
return -1;
}
ret = taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
if (0 != ret) {
- errorPrint("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_bind_param() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
return -1;
}
// if msg > 3MB, break
ret = taos_stmt_add_batch(stmt);
if (0 != ret) {
- errorPrint("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
+ errorPrint2("%s() LN%d, stmt_add_batch() failed! reason: %s\n",
__func__, __LINE__, taos_stmt_errstr(stmt));
return -1;
}
@@ -6589,7 +7329,6 @@ static int32_t prepareStbStmtWithSample(
return k;
}
-#endif
static int32_t generateStbProgressiveData(
SSuperTable *stbInfo,
@@ -6678,8 +7417,6 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
int64_t nTimeStampStep;
uint64_t insert_interval;
- bool sourceRand;
-
SSuperTable* stbInfo = pThreadInfo->stbInfo;
if (stbInfo) {
@@ -6694,18 +7431,12 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
maxSqlLen = stbInfo->maxSqlLen;
nTimeStampStep = stbInfo->timeStampStep;
insert_interval = stbInfo->insertInterval;
- if (0 == strncasecmp(stbInfo->dataSource, "rand", 4)) {
- sourceRand = true;
- } else {
- sourceRand = false; // from sample data file
- }
} else {
insertRows = g_args.num_of_DPT;
interlaceRows = g_args.interlace_rows;
maxSqlLen = g_args.max_sql_len;
nTimeStampStep = g_args.timestamp_step;
insert_interval = g_args.insert_interval;
- sourceRand = true;
}
debugPrint("[%d] %s() LN%d: start_table_from=%"PRIu64" ntables=%"PRId64" insertRows=%"PRIu64"\n",
@@ -6731,7 +7462,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
pThreadInfo->buffer = calloc(maxSqlLen, 1);
if (NULL == pThreadInfo->buffer) {
- errorPrint( "%s() LN%d, Failed to alloc %"PRIu64" Bytes, reason:%s\n",
+ errorPrint2( "%s() LN%d, Failed to alloc %"PRIu64" Bytes, reason:%s\n",
__func__, __LINE__, maxSqlLen, strerror(errno));
return NULL;
}
@@ -6779,7 +7510,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
getTableName(tableName, pThreadInfo, tableSeq);
if (0 == strlen(tableName)) {
- errorPrint("[%d] %s() LN%d, getTableName return null\n",
+ errorPrint2("[%d] %s() LN%d, getTableName return null\n",
pThreadInfo->threadID, __func__, __LINE__);
free(pThreadInfo->buffer);
return NULL;
@@ -6790,29 +7521,14 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
int32_t generated;
if (stbInfo) {
if (stbInfo->iface == STMT_IFACE) {
-#if STMT_IFACE_ENABLED == 1
- if (sourceRand) {
- generated = prepareStbStmtRand(
- pThreadInfo,
- tableName,
- tableSeq,
- batchPerTbl,
- insertRows, 0,
- startTime
- );
- } else {
- generated = prepareStbStmtWithSample(
- pThreadInfo,
- tableName,
- tableSeq,
- batchPerTbl,
- insertRows, 0,
- startTime,
- &(pThreadInfo->samplePos));
- }
-#else
- generated = -1;
-#endif
+ generated = prepareStbStmtWithSample(
+ pThreadInfo,
+ tableName,
+ tableSeq,
+ batchPerTbl,
+ insertRows, 0,
+ startTime,
+ &(pThreadInfo->samplePos));
} else {
generated = generateStbInterlaceData(
pThreadInfo,
@@ -6830,16 +7546,12 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
pThreadInfo->threadID,
__func__, __LINE__,
tableName, batchPerTbl, startTime);
-#if STMT_IFACE_ENABLED == 1
generated = prepareStmtWithoutStb(
pThreadInfo,
tableName,
batchPerTbl,
insertRows, i,
startTime);
-#else
- generated = -1;
-#endif
} else {
generated = generateInterlaceDataWithoutStb(
tableName, batchPerTbl,
@@ -6854,7 +7566,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
debugPrint("[%d] %s() LN%d, generated records is %d\n",
pThreadInfo->threadID, __func__, __LINE__, generated);
if (generated < 0) {
- errorPrint("[%d] %s() LN%d, generated records is %d\n",
+ errorPrint2("[%d] %s() LN%d, generated records is %d\n",
pThreadInfo->threadID, __func__, __LINE__, generated);
goto free_of_interlace;
} else if (generated == 0) {
@@ -6908,7 +7620,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
startTs = taosGetTimestampUs();
if (recOfBatch == 0) {
- errorPrint("[%d] %s() LN%d Failed to insert records of batch %d\n",
+ errorPrint2("[%d] %s() LN%d Failed to insert records of batch %d\n",
pThreadInfo->threadID, __func__, __LINE__,
batchPerTbl);
if (batchPerTbl > 0) {
@@ -6935,7 +7647,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
pThreadInfo->totalDelay += delay;
if (recOfBatch != affectedRows) {
- errorPrint("[%d] %s() LN%d execInsert insert %d, affected rows: %"PRId64"\n%s\n",
+ errorPrint2("[%d] %s() LN%d execInsert insert %d, affected rows: %"PRId64"\n%s\n",
pThreadInfo->threadID, __func__, __LINE__,
recOfBatch, affectedRows, pThreadInfo->buffer);
goto free_of_interlace;
@@ -6993,7 +7705,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
pThreadInfo->buffer = calloc(maxSqlLen, 1);
if (NULL == pThreadInfo->buffer) {
- errorPrint( "Failed to alloc %"PRIu64" Bytes, reason:%s\n",
+ errorPrint2("Failed to alloc %"PRIu64" bytes, reason:%s\n",
maxSqlLen,
strerror(errno));
return NULL;
@@ -7006,17 +7718,6 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
pThreadInfo->totalInsertRows = 0;
pThreadInfo->totalAffectedRows = 0;
- bool sourceRand;
- if (stbInfo) {
- if (0 == strncasecmp(stbInfo->dataSource, "rand", 4)) {
- sourceRand = true;
- } else {
- sourceRand = false; // from sample data file
- }
- } else {
- sourceRand = true;
- }
-
pThreadInfo->samplePos = 0;
int percentComplete = 0;
@@ -7034,7 +7735,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
__func__, __LINE__,
pThreadInfo->threadID, tableSeq, tableName);
if (0 == strlen(tableName)) {
- errorPrint("[%d] %s() LN%d, getTableName return null\n",
+ errorPrint2("[%d] %s() LN%d, getTableName return null\n",
pThreadInfo->threadID, __func__, __LINE__);
free(pThreadInfo->buffer);
return NULL;
@@ -7049,31 +7750,19 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
pstr += len;
remainderBufLen -= len;
+ // measure prepare + insert
+ startTs = taosGetTimestampUs();
+
int32_t generated;
if (stbInfo) {
if (stbInfo->iface == STMT_IFACE) {
-#if STMT_IFACE_ENABLED == 1
- if (sourceRand) {
- generated = prepareStbStmtRand(
- pThreadInfo,
- tableName,
- tableSeq,
- g_args.num_of_RPR,
- insertRows,
- i, start_time
- );
- } else {
- generated = prepareStbStmtWithSample(
- pThreadInfo,
- tableName,
- tableSeq,
- g_args.num_of_RPR,
- insertRows, i, start_time,
- &(pThreadInfo->samplePos));
- }
-#else
- generated = -1;
-#endif
+ generated = prepareStbStmtWithSample(
+ pThreadInfo,
+ tableName,
+ tableSeq,
+ g_args.num_of_RPR,
+ insertRows, i, start_time,
+ &(pThreadInfo->samplePos));
} else {
generated = generateStbProgressiveData(
stbInfo,
@@ -7085,16 +7774,12 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
}
} else {
if (g_args.iface == STMT_IFACE) {
-#if STMT_IFACE_ENABLED == 1
generated = prepareStmtWithoutStb(
pThreadInfo,
tableName,
g_args.num_of_RPR,
insertRows, i,
start_time);
-#else
- generated = -1;
-#endif
} else {
generated = generateProgressiveDataWithoutStb(
tableName,
@@ -7105,6 +7790,11 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
&remainderBufLen);
}
}
+
+ verbosePrint("[%d] %s() LN%d generated=%d\n",
+ pThreadInfo->threadID,
+ __func__, __LINE__, generated);
+
if (generated > 0)
i += generated;
else
@@ -7113,7 +7803,8 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
start_time += generated * timeStampStep;
pThreadInfo->totalInsertRows += generated;
- startTs = taosGetTimestampUs();
+ // only measure insert
+ // startTs = taosGetTimestampUs();
int32_t affectedRows = execInsert(pThreadInfo, generated);
@@ -7131,7 +7822,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
pThreadInfo->totalDelay += delay;
if (affectedRows < 0) {
- errorPrint("%s() LN%d, affected rows: %d\n",
+ errorPrint2("%s() LN%d, affected rows: %d\n",
__func__, __LINE__, affectedRows);
goto free_of_progressive;
}
@@ -7293,7 +7984,7 @@ static int convertHostToServAddr(char *host, uint16_t port, struct sockaddr_in *
uint16_t rest_port = port + TSDB_PORT_HTTP;
struct hostent *server = gethostbyname(host);
if ((server == NULL) || (server->h_addr == NULL)) {
- errorPrint("%s", "ERROR, no such host");
+ errorPrint2("%s", "no such host");
return -1;
}
@@ -7314,26 +8005,28 @@ static int convertHostToServAddr(char *host, uint16_t port, struct sockaddr_in *
return 0;
}
-#if STMT_IFACE_ENABLED == 1
-static int parseSampleFileToStmt(SSuperTable *stbInfo, uint32_t timePrec)
+static int parseSampleFileToStmt(
+ threadInfo *pThreadInfo,
+ SSuperTable *stbInfo, uint32_t timePrec)
{
- stbInfo->sampleBindArray = calloc(1, sizeof(char *) * MAX_SAMPLES_ONCE_FROM_FILE);
- if (stbInfo->sampleBindArray == NULL) {
- errorPrint("%s() LN%d, Failed to allocate %"PRIu64" bind array buffer\n",
- __func__, __LINE__, (uint64_t)sizeof(char *) * MAX_SAMPLES_ONCE_FROM_FILE);
+ pThreadInfo->sampleBindArray =
+ calloc(1, sizeof(char *) * MAX_SAMPLES_ONCE_FROM_FILE);
+ if (pThreadInfo->sampleBindArray == NULL) {
+ errorPrint2("%s() LN%d, Failed to allocate %"PRIu64" bind array buffer\n",
+ __func__, __LINE__,
+ (uint64_t)sizeof(char *) * MAX_SAMPLES_ONCE_FROM_FILE);
return -1;
}
-
for (int i=0; i < MAX_SAMPLES_ONCE_FROM_FILE; i++) {
- char *bindArray = calloc(1, sizeof(TAOS_BIND) * (stbInfo->columnCount + 1));
+ char *bindArray =
+ calloc(1, sizeof(TAOS_BIND) * (stbInfo->columnCount + 1));
if (bindArray == NULL) {
- errorPrint("%s() LN%d, Failed to allocate %d bind params\n",
+ errorPrint2("%s() LN%d, Failed to allocate %d bind params\n",
__func__, __LINE__, (stbInfo->columnCount + 1));
return -1;
}
-
TAOS_BIND *bind;
int cursor = 0;
@@ -7360,7 +8053,7 @@ static int parseSampleFileToStmt(SSuperTable *stbInfo, uint32_t timePrec)
char *bindBuffer = calloc(1, index + 1);
if (bindBuffer == NULL) {
- errorPrint("%s() LN%d, Failed to allocate %d bind buffer\n",
+ errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
__func__, __LINE__, DOUBLE_BUFF_LEN);
return -1;
}
@@ -7380,12 +8073,12 @@ static int parseSampleFileToStmt(SSuperTable *stbInfo, uint32_t timePrec)
free(bindBuffer);
}
}
- *((uintptr_t *)(stbInfo->sampleBindArray + (sizeof(char *)) * i)) = (uintptr_t)bindArray;
+ *((uintptr_t *)(pThreadInfo->sampleBindArray + (sizeof(char *)) * i)) =
+ (uintptr_t)bindArray;
}
return 0;
}
-#endif
static void startMultiThreadInsertData(int threads, char* db_name,
char* precision, SSuperTable* stbInfo) {
@@ -7396,12 +8089,10 @@ static void startMultiThreadInsertData(int threads, char* db_name,
timePrec = TSDB_TIME_PRECISION_MILLI;
} else if (0 == strncasecmp(precision, "us", 2)) {
timePrec = TSDB_TIME_PRECISION_MICRO;
-#if NANO_SECOND_ENABLED == 1
} else if (0 == strncasecmp(precision, "ns", 2)) {
timePrec = TSDB_TIME_PRECISION_NANO;
-#endif
} else {
- errorPrint("Not support precision: %s\n", precision);
+ errorPrint2("Not support precision: %s\n", precision);
exit(EXIT_FAILURE);
}
}
@@ -7420,18 +8111,15 @@ static void startMultiThreadInsertData(int threads, char* db_name,
}
}
} else {
- start_time = 1500000000000;
+ start_time = DEFAULT_START_TIME;
}
debugPrint("%s() LN%d, start_time= %"PRId64"\n",
__func__, __LINE__, start_time);
- int64_t start = taosGetTimestampMs();
-
// read sample data from file first
- if ((stbInfo) && (0 == strncasecmp(stbInfo->dataSource,
- "sample", strlen("sample")))) {
+ if (stbInfo) {
if (0 != prepareSampleDataForSTable(stbInfo)) {
- errorPrint("%s() LN%d, prepare sample data for stable failed!\n",
+ errorPrint2("%s() LN%d, prepare sample data for stable failed!\n",
__func__, __LINE__);
exit(EXIT_FAILURE);
}
@@ -7441,7 +8129,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
g_Dbs.host, g_Dbs.user,
g_Dbs.password, db_name, g_Dbs.port);
if (NULL == taos0) {
- errorPrint("%s() LN%d, connect to server fail , reason: %s\n",
+ errorPrint2("%s() LN%d, connect to server fail , reason: %s\n",
__func__, __LINE__, taos_errstr(NULL));
exit(EXIT_FAILURE);
}
@@ -7496,7 +8184,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
limit * TSDB_TABLE_NAME_LEN);
if (stbInfo->childTblName == NULL) {
taos_close(taos0);
- errorPrint("%s() LN%d, alloc memory failed!\n", __func__, __LINE__);
+ errorPrint2("%s() LN%d, alloc memory failed!\n", __func__, __LINE__);
exit(EXIT_FAILURE);
}
@@ -7542,7 +8230,6 @@ static void startMultiThreadInsertData(int threads, char* db_name,
memset(pids, 0, threads * sizeof(pthread_t));
memset(infos, 0, threads * sizeof(threadInfo));
-#if STMT_IFACE_ENABLED == 1
char *stmtBuffer = calloc(1, BUFFER_SIZE);
assert(stmtBuffer);
if ((g_args.iface == STMT_IFACE)
@@ -7577,13 +8264,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
pstr += sprintf(pstr, ")");
debugPrint("%s() LN%d, stmtBuffer: %s", __func__, __LINE__, stmtBuffer);
-
- if ((stbInfo) && (0 == strncasecmp(stbInfo->dataSource,
- "sample", strlen("sample")))) {
- parseSampleFileToStmt(stbInfo, timePrec);
- }
}
-#endif
for (int i = 0; i < threads; i++) {
threadInfo *pThreadInfo = infos + i;
@@ -7604,24 +8285,22 @@ static void startMultiThreadInsertData(int threads, char* db_name,
g_Dbs.password, db_name, g_Dbs.port);
if (NULL == pThreadInfo->taos) {
free(infos);
- errorPrint(
+ errorPrint2(
"%s() LN%d, connect to server fail from insert sub thread, reason: %s\n",
__func__, __LINE__,
taos_errstr(NULL));
exit(EXIT_FAILURE);
}
-#if STMT_IFACE_ENABLED == 1
if ((g_args.iface == STMT_IFACE)
|| ((stbInfo)
&& (stbInfo->iface == STMT_IFACE))) {
-
pThreadInfo->stmt = taos_stmt_init(pThreadInfo->taos);
if (NULL == pThreadInfo->stmt) {
free(pids);
free(infos);
- errorPrint(
+ errorPrint2(
"%s() LN%d, failed init stmt, reason: %s\n",
__func__, __LINE__,
taos_errstr(NULL));
@@ -7629,17 +8308,20 @@ static void startMultiThreadInsertData(int threads, char* db_name,
}
int ret = taos_stmt_prepare(pThreadInfo->stmt, stmtBuffer, 0);
- if (ret != 0){
+ if (ret != 0) {
free(pids);
free(infos);
free(stmtBuffer);
- errorPrint("failed to execute taos_stmt_prepare. return 0x%x. reason: %s\n",
+ errorPrint2("failed to execute taos_stmt_prepare. return 0x%x. reason: %s\n",
ret, taos_stmt_errstr(pThreadInfo->stmt));
exit(EXIT_FAILURE);
}
pThreadInfo->bind_ts = malloc(sizeof(int64_t));
+
+ if (stbInfo) {
+ parseSampleFileToStmt(pThreadInfo, stbInfo, timePrec);
+ }
}
-#endif
} else {
pThreadInfo->taos = NULL;
}
@@ -7665,9 +8347,9 @@ static void startMultiThreadInsertData(int threads, char* db_name,
}
}
-#if STMT_IFACE_ENABLED == 1
free(stmtBuffer);
-#endif
+
+ int64_t start = taosGetTimestampUs();
for (int i = 0; i < threads; i++) {
pthread_join(pids[i], NULL);
@@ -7682,15 +8364,28 @@ static void startMultiThreadInsertData(int threads, char* db_name,
for (int i = 0; i < threads; i++) {
threadInfo *pThreadInfo = infos + i;
-#if STMT_IFACE_ENABLED == 1
if (pThreadInfo->stmt) {
taos_stmt_close(pThreadInfo->stmt);
tmfree((char *)pThreadInfo->bind_ts);
}
-#endif
tsem_destroy(&(pThreadInfo->lock_sem));
taos_close(pThreadInfo->taos);
+ if (pThreadInfo->sampleBindArray) {
+ for (int k = 0; k < MAX_SAMPLES_ONCE_FROM_FILE; k++) {
+ uintptr_t *tmp = (uintptr_t *)(*(uintptr_t *)(
+ pThreadInfo->sampleBindArray
+ + sizeof(uintptr_t *) * k));
+ for (int c = 1; c < pThreadInfo->stbInfo->columnCount + 1; c++) {
+ TAOS_BIND *bind = (TAOS_BIND *)((char *)tmp + (sizeof(TAOS_BIND) * c));
+ if (bind)
+ tmfree(bind->buffer);
+ }
+ tmfree((char *)tmp);
+ }
+ tmfree(pThreadInfo->sampleBindArray);
+ }
+
debugPrint("%s() LN%d, [%d] totalInsert=%"PRIu64" totalAffected=%"PRIu64"\n",
__func__, __LINE__,
pThreadInfo->threadID, pThreadInfo->totalInsertRows,
@@ -7713,43 +8408,40 @@ static void startMultiThreadInsertData(int threads, char* db_name,
if (cntDelay == 0) cntDelay = 1;
avgDelay = (double)totalDelay / cntDelay;
- int64_t end = taosGetTimestampMs();
+ int64_t end = taosGetTimestampUs();
int64_t t = end - start;
+ if (0 == t) t = 1;
- double tInMs = t/1000.0;
+ double tInMs = (double) t / 1000000.0;
if (stbInfo) {
- fprintf(stderr, "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
+ fprintf(stderr, "Spent %.4f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
tInMs, stbInfo->totalInsertRows,
stbInfo->totalAffectedRows,
threads, db_name, stbInfo->sTblName,
- (tInMs)?
- (double)(stbInfo->totalInsertRows/tInMs):FLT_MAX);
+ (double)(stbInfo->totalInsertRows/tInMs));
if (g_fpOfInsertResult) {
fprintf(g_fpOfInsertResult,
- "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
+ "Spent %.4f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
tInMs, stbInfo->totalInsertRows,
stbInfo->totalAffectedRows,
threads, db_name, stbInfo->sTblName,
- (tInMs)?
- (double)(stbInfo->totalInsertRows/tInMs):FLT_MAX);
+ (double)(stbInfo->totalInsertRows/tInMs));
}
} else {
- fprintf(stderr, "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s %.2f records/second\n\n",
+ fprintf(stderr, "Spent %.4f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s %.2f records/second\n\n",
tInMs, g_args.totalInsertRows,
g_args.totalAffectedRows,
threads, db_name,
- (tInMs)?
- (double)(g_args.totalInsertRows/tInMs):FLT_MAX);
+ (double)(g_args.totalInsertRows/tInMs));
if (g_fpOfInsertResult) {
fprintf(g_fpOfInsertResult,
- "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s %.2f records/second\n\n",
+ "Spent %.4f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s %.2f records/second\n\n",
tInMs, g_args.totalInsertRows,
g_args.totalAffectedRows,
threads, db_name,
- (tInMs)?
- (double)(g_args.totalInsertRows/tInMs):FLT_MAX);
+ (double)(g_args.totalInsertRows/tInMs));
}
}
@@ -7782,7 +8474,7 @@ static void *readTable(void *sarg) {
char *tb_prefix = pThreadInfo->tb_prefix;
FILE *fp = fopen(pThreadInfo->filePath, "a");
if (NULL == fp) {
- errorPrint( "fopen %s fail, reason:%s.\n", pThreadInfo->filePath, strerror(errno));
+ errorPrint2("fopen %s fail, reason:%s.\n", pThreadInfo->filePath, strerror(errno));
free(command);
return NULL;
}
@@ -7818,7 +8510,7 @@ static void *readTable(void *sarg) {
int32_t code = taos_errno(pSql);
if (code != 0) {
- errorPrint( "Failed to query:%s\n", taos_errstr(pSql));
+ errorPrint2("Failed to query:%s\n", taos_errstr(pSql));
taos_free_result(pSql);
taos_close(taos);
fclose(fp);
@@ -7900,7 +8592,7 @@ static void *readMetric(void *sarg) {
int32_t code = taos_errno(pSql);
if (code != 0) {
- errorPrint( "Failed to query:%s\n", taos_errstr(pSql));
+ errorPrint2("Failed to query:%s\n", taos_errstr(pSql));
taos_free_result(pSql);
taos_close(taos);
fclose(fp);
@@ -7947,7 +8639,7 @@ static int insertTestProcess() {
debugPrint("%d result file: %s\n", __LINE__, g_Dbs.resultFile);
g_fpOfInsertResult = fopen(g_Dbs.resultFile, "a");
if (NULL == g_fpOfInsertResult) {
- errorPrint( "Failed to open %s for save result\n", g_Dbs.resultFile);
+ errorPrint("Failed to open %s for save result\n", g_Dbs.resultFile);
return -1;
}
@@ -7980,18 +8672,30 @@ static int insertTestProcess() {
double start;
double end;
- // create child tables
- start = taosGetTimestampMs();
- createChildTables();
- end = taosGetTimestampMs();
-
if (g_totalChildTables > 0) {
- fprintf(stderr, "Spent %.4f seconds to create %"PRId64" tables with %d thread(s)\n\n",
- (end - start)/1000.0, g_totalChildTables, g_Dbs.threadCountByCreateTbl);
+ fprintf(stderr,
+ "creating %"PRId64" table(s) with %d thread(s)\n\n",
+ g_totalChildTables, g_Dbs.threadCountForCreateTbl);
if (g_fpOfInsertResult) {
fprintf(g_fpOfInsertResult,
- "Spent %.4f seconds to create %"PRId64" tables with %d thread(s)\n\n",
- (end - start)/1000.0, g_totalChildTables, g_Dbs.threadCountByCreateTbl);
+ "creating %"PRId64" table(s) with %d thread(s)\n\n",
+ g_totalChildTables, g_Dbs.threadCountForCreateTbl);
+ }
+
+ // create child tables
+ start = taosGetTimestampMs();
+ createChildTables();
+ end = taosGetTimestampMs();
+
+ fprintf(stderr,
+ "\nSpent %.4f seconds to create %"PRId64" table(s) with %d thread(s), actual %"PRId64" table(s) created\n\n",
+ (end - start)/1000.0, g_totalChildTables,
+ g_Dbs.threadCountForCreateTbl, g_actualChildTables);
+ if (g_fpOfInsertResult) {
+ fprintf(g_fpOfInsertResult,
+ "\nSpent %.4f seconds to create %"PRId64" table(s) with %d thread(s), actual %"PRId64" table(s) created\n\n",
+ (end - start)/1000.0, g_totalChildTables,
+ g_Dbs.threadCountForCreateTbl, g_actualChildTables);
}
}
@@ -8049,7 +8753,7 @@ static void *specifiedTableQuery(void *sarg) {
NULL,
g_queryInfo.port);
if (taos == NULL) {
- errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
+ errorPrint2("[%d] Failed to connect to TDengine, reason:%s\n",
pThreadInfo->threadID, taos_errstr(NULL));
return NULL;
} else {
@@ -8061,7 +8765,7 @@ static void *specifiedTableQuery(void *sarg) {
sprintf(sqlStr, "use %s", g_queryInfo.dbName);
if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
taos_close(pThreadInfo->taos);
- errorPrint( "use database %s failed!\n\n",
+ errorPrint("use database %s failed!\n\n",
g_queryInfo.dbName);
return NULL;
}
@@ -8227,7 +8931,7 @@ static int queryTestProcess() {
NULL,
g_queryInfo.port);
if (taos == NULL) {
- errorPrint( "Failed to connect to TDengine, reason:%s\n",
+ errorPrint("Failed to connect to TDengine, reason:%s\n",
taos_errstr(NULL));
exit(EXIT_FAILURE);
}
@@ -8285,7 +8989,7 @@ static int queryTestProcess() {
taos_close(taos);
free(infos);
free(pids);
- errorPrint( "use database %s failed!\n\n",
+ errorPrint2("use database %s failed!\n\n",
g_queryInfo.dbName);
return -1;
}
@@ -8383,7 +9087,7 @@ static int queryTestProcess() {
static void stable_sub_callback(
TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
if (res == NULL || taos_errno(res) != 0) {
- errorPrint("%s() LN%d, failed to subscribe result, code:%d, reason:%s\n",
+ errorPrint2("%s() LN%d, failed to subscribe result, code:%d, reason:%s\n",
__func__, __LINE__, code, taos_errstr(res));
return;
}
@@ -8396,7 +9100,7 @@ static void stable_sub_callback(
static void specified_sub_callback(
TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
if (res == NULL || taos_errno(res) != 0) {
- errorPrint("%s() LN%d, failed to subscribe result, code:%d, reason:%s\n",
+ errorPrint2("%s() LN%d, failed to subscribe result, code:%d, reason:%s\n",
__func__, __LINE__, code, taos_errstr(res));
return;
}
@@ -8435,7 +9139,7 @@ static TAOS_SUB* subscribeImpl(
}
if (tsub == NULL) {
- errorPrint("failed to create subscription. topic:%s, sql:%s\n", topic, sql);
+ errorPrint2("failed to create subscription. topic:%s, sql:%s\n", topic, sql);
return NULL;
}
@@ -8466,7 +9170,7 @@ static void *superSubscribe(void *sarg) {
g_queryInfo.dbName,
g_queryInfo.port);
if (pThreadInfo->taos == NULL) {
- errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
+ errorPrint2("[%d] Failed to connect to TDengine, reason:%s\n",
pThreadInfo->threadID, taos_errstr(NULL));
free(subSqlStr);
return NULL;
@@ -8477,7 +9181,7 @@ static void *superSubscribe(void *sarg) {
sprintf(sqlStr, "USE %s", g_queryInfo.dbName);
if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
taos_close(pThreadInfo->taos);
- errorPrint( "use database %s failed!\n\n",
+ errorPrint2("use database %s failed!\n\n",
g_queryInfo.dbName);
free(subSqlStr);
return NULL;
@@ -8613,7 +9317,7 @@ static void *specifiedSubscribe(void *sarg) {
g_queryInfo.dbName,
g_queryInfo.port);
if (pThreadInfo->taos == NULL) {
- errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
+ errorPrint2("[%d] Failed to connect to TDengine, reason:%s\n",
pThreadInfo->threadID, taos_errstr(NULL));
return NULL;
}
@@ -8720,7 +9424,7 @@ static int subscribeTestProcess() {
g_queryInfo.dbName,
g_queryInfo.port);
if (taos == NULL) {
- errorPrint( "Failed to connect to TDengine, reason:%s\n",
+ errorPrint2("Failed to connect to TDengine, reason:%s\n",
taos_errstr(NULL));
exit(EXIT_FAILURE);
}
@@ -8748,7 +9452,7 @@ static int subscribeTestProcess() {
g_queryInfo.specifiedQueryInfo.sqlCount);
} else {
if (g_queryInfo.specifiedQueryInfo.concurrent <= 0) {
- errorPrint("%s() LN%d, sepcified query sqlCount %d.\n",
+ errorPrint2("%s() LN%d, sepcified query sqlCount %d.\n",
__func__, __LINE__,
g_queryInfo.specifiedQueryInfo.sqlCount);
exit(EXIT_FAILURE);
@@ -8765,7 +9469,7 @@ static int subscribeTestProcess() {
g_queryInfo.specifiedQueryInfo.concurrent *
sizeof(threadInfo));
if ((NULL == pids) || (NULL == infos)) {
- errorPrint("%s() LN%d, malloc failed for create threads\n", __func__, __LINE__);
+ errorPrint2("%s() LN%d, malloc failed for create threads\n", __func__, __LINE__);
exit(EXIT_FAILURE);
}
@@ -8800,7 +9504,7 @@ static int subscribeTestProcess() {
g_queryInfo.superQueryInfo.threadCnt *
sizeof(threadInfo));
if ((NULL == pidsOfStable) || (NULL == infosOfStable)) {
- errorPrint("%s() LN%d, malloc failed for create threads\n",
+ errorPrint2("%s() LN%d, malloc failed for create threads\n",
__func__, __LINE__);
// taos_close(taos);
exit(EXIT_FAILURE);
@@ -8872,7 +9576,7 @@ static void initOfInsertMeta() {
tstrncpy(g_Dbs.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
g_Dbs.port = 6030;
tstrncpy(g_Dbs.user, TSDB_DEFAULT_USER, MAX_USERNAME_SIZE);
- tstrncpy(g_Dbs.password, TSDB_DEFAULT_PASS, MAX_PASSWORD_SIZE);
+ tstrncpy(g_Dbs.password, TSDB_DEFAULT_PASS, SHELL_MAX_PASSWORD_LEN);
g_Dbs.threadCount = 2;
g_Dbs.use_metric = g_args.use_metric;
@@ -8885,7 +9589,7 @@ static void initOfQueryMeta() {
tstrncpy(g_queryInfo.host, "127.0.0.1", MAX_HOSTNAME_SIZE);
g_queryInfo.port = 6030;
tstrncpy(g_queryInfo.user, TSDB_DEFAULT_USER, MAX_USERNAME_SIZE);
- tstrncpy(g_queryInfo.password, TSDB_DEFAULT_PASS, MAX_PASSWORD_SIZE);
+ tstrncpy(g_queryInfo.password, TSDB_DEFAULT_PASS, SHELL_MAX_PASSWORD_LEN);
}
static void setParaFromArg() {
@@ -8899,14 +9603,14 @@ static void setParaFromArg() {
tstrncpy(g_Dbs.user, g_args.user, MAX_USERNAME_SIZE);
}
- tstrncpy(g_Dbs.password, g_args.password, MAX_PASSWORD_SIZE);
+ tstrncpy(g_Dbs.password, g_args.password, SHELL_MAX_PASSWORD_LEN);
if (g_args.port) {
g_Dbs.port = g_args.port;
}
g_Dbs.threadCount = g_args.num_of_threads;
- g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
+ g_Dbs.threadCountForCreateTbl = g_args.num_of_threads;
g_Dbs.dbCount = 1;
g_Dbs.db[0].drop = true;
@@ -8938,7 +9642,7 @@ static void setParaFromArg() {
tstrncpy(g_Dbs.db[0].superTbls[0].sTblName, "meters", TSDB_TABLE_NAME_LEN);
g_Dbs.db[0].superTbls[0].childTblCount = g_args.num_of_tables;
g_Dbs.threadCount = g_args.num_of_threads;
- g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
+ g_Dbs.threadCountForCreateTbl = g_args.num_of_threads;
g_Dbs.asyncMode = g_args.async_mode;
g_Dbs.db[0].superTbls[0].autoCreateTable = PRE_CREATE_SUBTBL;
@@ -8969,7 +9673,7 @@ static void setParaFromArg() {
tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
data_type[i], min(DATATYPE_BUFF_LEN, strlen(data_type[i]) + 1));
- g_Dbs.db[0].superTbls[0].columns[i].dataLen = g_args.len_of_binary;
+ g_Dbs.db[0].superTbls[0].columns[i].dataLen = g_args.binwidth;
g_Dbs.db[0].superTbls[0].columnCount++;
}
@@ -8991,10 +9695,10 @@ static void setParaFromArg() {
tstrncpy(g_Dbs.db[0].superTbls[0].tags[1].dataType,
"BINARY", min(DATATYPE_BUFF_LEN, strlen("BINARY") + 1));
- g_Dbs.db[0].superTbls[0].tags[1].dataLen = g_args.len_of_binary;
+ g_Dbs.db[0].superTbls[0].tags[1].dataLen = g_args.binwidth;
g_Dbs.db[0].superTbls[0].tagCount = 2;
} else {
- g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
+ g_Dbs.threadCountForCreateTbl = g_args.num_of_threads;
g_Dbs.db[0].superTbls[0].tagCount = 0;
}
}
@@ -9066,7 +9770,7 @@ static void querySqlFile(TAOS* taos, char* sqlFile)
memcpy(cmd + cmd_len, line, read_len);
if (0 != queryDbExec(taos, cmd, NO_INSERT_TYPE, false)) {
- errorPrint("%s() LN%d, queryDbExec %s failed!\n",
+ errorPrint2("%s() LN%d, queryDbExec %s failed!\n",
__func__, __LINE__, cmd);
tmfree(cmd);
tmfree(line);
@@ -9116,7 +9820,7 @@ static void queryResult() {
pthread_t read_id;
threadInfo *pThreadInfo = calloc(1, sizeof(threadInfo));
assert(pThreadInfo);
- pThreadInfo->start_time = 1500000000000; // 2017-07-14 10:40:00.000
+ pThreadInfo->start_time = DEFAULT_START_TIME; // 2017-07-14 10:40:00.000
pThreadInfo->start_table_from = 0;
//pThreadInfo->do_aggreFunc = g_Dbs.do_aggreFunc;
@@ -9140,7 +9844,7 @@ static void queryResult() {
g_Dbs.port);
if (pThreadInfo->taos == NULL) {
free(pThreadInfo);
- errorPrint( "Failed to connect to TDengine, reason:%s\n",
+ errorPrint2("Failed to connect to TDengine, reason:%s\n",
taos_errstr(NULL));
exit(EXIT_FAILURE);
}
@@ -9162,7 +9866,7 @@ static void testCmdLine() {
if (strlen(configDir)) {
wordexp_t full_path;
if (wordexp(configDir, &full_path, 0) != 0) {
- errorPrint( "Invalid path %s\n", configDir);
+ errorPrint("Invalid path %s\n", configDir);
return;
}
taos_options(TSDB_OPTION_CONFIGDIR, full_path.we_wordv[0]);
@@ -9182,6 +9886,7 @@ int main(int argc, char *argv[]) {
debugPrint("meta file: %s\n", g_args.metaFile);
if (g_args.metaFile) {
+ g_totalChildTables = 0;
initOfInsertMeta();
initOfQueryMeta();
diff --git a/src/kit/taosdump/taosdump.c b/src/kit/taosdump/taosdump.c
index bea6e6510683e3a400623c2ef843d0ce6e34521c..ae2193a82eb447f0e948abc1757c21cab46ccf34 100644
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@@ -62,6 +62,20 @@ typedef struct {
#define errorPrint(fmt, ...) \
do { fprintf(stderr, "\033[31m"); fprintf(stderr, "ERROR: "fmt, __VA_ARGS__); fprintf(stderr, "\033[0m"); } while(0)
+static bool isStringNumber(char *input)
+{
+ int len = strlen(input);
+ if (0 == len) {
+ return false;
+ }
+
+ for (int i = 0; i < len; i++) {
+ if (!isdigit(input[i]))
+ return false;
+ }
+
+ return true;
+}
// -------------------------- SHOW DATABASE INTERFACE-----------------------
enum _show_db_index {
@@ -206,21 +220,20 @@ static struct argp_option options[] = {
{"host", 'h', "HOST", 0, "Server host dumping data from. Default is localhost.", 0},
{"user", 'u', "USER", 0, "User name used to connect to server. Default is root.", 0},
#ifdef _TD_POWER_
- {"password", 'p', "PASSWORD", 0, "User password to connect to server. Default is powerdb.", 0},
+ {"password", 'p', 0, 0, "User password to connect to server. Default is powerdb.", 0},
#else
- {"password", 'p', "PASSWORD", 0, "User password to connect to server. Default is taosdata.", 0},
+ {"password", 'p', 0, 0, "User password to connect to server. Default is taosdata.", 0},
#endif
{"port", 'P', "PORT", 0, "Port to connect", 0},
- {"cversion", 'v', "CVERION", 0, "client version", 0},
{"mysqlFlag", 'q', "MYSQLFLAG", 0, "mysqlFlag, Default is 0", 0},
// input/output file
{"outpath", 'o', "OUTPATH", 0, "Output file path.", 1},
{"inpath", 'i', "INPATH", 0, "Input file path.", 1},
{"resultFile", 'r', "RESULTFILE", 0, "DumpOut/In Result file path and name.", 1},
#ifdef _TD_POWER_
- {"config", 'c', "CONFIG_DIR", 0, "Configure directory. Default is /etc/power/taos.cfg.", 1},
+ {"config-dir", 'c', "CONFIG_DIR", 0, "Configure directory. Default is /etc/power/taos.cfg.", 1},
#else
- {"config", 'c', "CONFIG_DIR", 0, "Configure directory. Default is /etc/taos/taos.cfg.", 1},
+ {"config-dir", 'c', "CONFIG_DIR", 0, "Configure directory. Default is /etc/taos/taos.cfg.", 1},
#endif
{"encode", 'e', "ENCODE", 0, "Input file encoding.", 1},
// dump unit options
@@ -230,7 +243,7 @@ static struct argp_option options[] = {
// dump format options
{"schemaonly", 's', 0, 0, "Only dump schema.", 2},
{"without-property", 'N', 0, 0, "Dump schema without properties.", 2},
- {"avro", 'V', 0, 0, "Dump apache avro format data file. By default, dump sql command sequence.", 2},
+ {"avro", 'v', 0, 0, "Dump apache avro format data file. By default, dump sql command sequence.", 2},
{"start-time", 'S', "START_TIME", 0, "Start time to dump. Either epoch or ISO8601/RFC3339 format is acceptable. ISO8601 format example: 2017-10-01T00:00:00.000+0800 or 2017-10-0100:00:00:000+0800 or '2017-10-01 00:00:00.000+0800'", 4},
{"end-time", 'E', "END_TIME", 0, "End time to dump. Either epoch or ISO8601/RFC3339 format is acceptable. ISO8601 format example: 2017-10-01T00:00:00.000+0800 or 2017-10-0100:00:00.000+0800 or '2017-10-01 00:00:00.000+0800'", 5},
#if TSDB_SUPPORT_NANOSECOND == 1
@@ -243,8 +256,6 @@ static struct argp_option options[] = {
{"table-batch", 't', "TABLE_BATCH", 0, "Number of table dumpout into one output file. Default is 1.", 3},
{"thread_num", 'T', "THREAD_NUM", 0, "Number of thread for dump in file. Default is 5.", 3},
{"debug", 'g', 0, 0, "Print debug info.", 8},
- {"verbose", 'b', 0, 0, "Print verbose debug info.", 9},
- {"performanceprint", 'm', 0, 0, "Print performance debug info.", 10},
{0}
};
@@ -253,9 +264,8 @@ typedef struct arguments {
// connection option
char *host;
char *user;
- char *password;
+ char password[SHELL_MAX_PASSWORD_LEN];
uint16_t port;
- char cversion[12];
uint16_t mysqlFlag;
// output file
char outpath[MAX_FILE_NAME_LEN];
@@ -326,7 +336,6 @@ struct arguments g_args = {
"taosdata",
#endif
0,
- "",
0,
// outpath and inpath
"",
@@ -358,6 +367,24 @@ struct arguments g_args = {
false // performance_print
};
+static void errorPrintReqArg2(char *program, char *wrong_arg)
+{
+ fprintf(stderr,
+ "%s: option requires a number argument '-%s'\n",
+ program, wrong_arg);
+ fprintf(stderr,
+ "Try `taosdump --help' or `taosdump --usage' for more information.\n");
+}
+
+static void errorPrintReqArg3(char *program, char *wrong_arg)
+{
+ fprintf(stderr,
+ "%s: option '%s' requires an argument\n",
+ program, wrong_arg);
+ fprintf(stderr,
+ "Try `taosdump --help' or `taosdump --usage' for more information.\n");
+}
+
/* Parse a single option. */
static error_t parse_opt(int key, char *arg, struct argp_state *state) {
/* Get the input argument from argp_parse, which we
@@ -376,23 +403,17 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
g_args.user = arg;
break;
case 'p':
- g_args.password = arg;
break;
case 'P':
+ if (!isStringNumber(arg)) {
+ errorPrintReqArg2("taosdump", "P");
+ exit(EXIT_FAILURE);
+ }
g_args.port = atoi(arg);
break;
case 'q':
g_args.mysqlFlag = atoi(arg);
break;
- case 'v':
- if (wordexp(arg, &full_path, 0) != 0) {
- errorPrint("Invalid client vesion %s\n", arg);
- return -1;
- }
- tstrncpy(g_args.cversion, full_path.we_wordv[0], 11);
- wordfree(&full_path);
- break;
- // output file path
case 'o':
if (wordexp(arg, &full_path, 0) != 0) {
errorPrint("Invalid path %s\n", arg);
@@ -419,9 +440,13 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
g_args.resultFile = arg;
break;
case 'c':
+ if (0 == strlen(arg)) {
+ errorPrintReqArg3("taosdump", "-c or --config-dir");
+ exit(EXIT_FAILURE);
+ }
if (wordexp(arg, &full_path, 0) != 0) {
errorPrint("Invalid path %s\n", arg);
- return -1;
+ exit(EXIT_FAILURE);
}
tstrncpy(configDir, full_path.we_wordv[0], MAX_FILE_NAME_LEN);
wordfree(&full_path);
@@ -431,7 +456,6 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
break;
// dump unit option
case 'A':
- g_args.all_databases = true;
break;
case 'D':
g_args.databases = true;
@@ -443,7 +467,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
case 'N':
g_args.with_property = false;
break;
- case 'V':
+ case 'v':
g_args.avro = true;
break;
case 'S':
@@ -476,6 +500,10 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
g_args.table_batch = atoi(arg);
break;
case 'T':
+ if (!isStringNumber(arg)) {
+ errorPrint("%s", "\n\t-T need a number following!\n");
+ exit(EXIT_FAILURE);
+ }
g_args.thread_num = atoi(arg);
break;
case OPT_ABORT:
@@ -554,6 +582,40 @@ static void parse_precision_first(
}
}
+static void parse_args(
+ int argc, char *argv[], SArguments *arguments) {
+
+ for (int i = 1; i < argc; i++) {
+ if ((strncmp(argv[i], "-p", 2) == 0)
+ || (strncmp(argv[i], "--password", 10) == 0)) {
+ if ((strlen(argv[i]) == 2)
+ || (strncmp(argv[i], "--password", 10) == 0)) {
+ printf("Enter password: ");
+ taosSetConsoleEcho(false);
+ if(scanf("%20s", arguments->password) > 1) {
+ errorPrint("%s() LN%d, password read error!\n", __func__, __LINE__);
+ }
+ taosSetConsoleEcho(true);
+ } else {
+ tstrncpy(arguments->password, (char *)(argv[i] + 2),
+ SHELL_MAX_PASSWORD_LEN);
+ strcpy(argv[i], "-p");
+ }
+ } else if (strcmp(argv[i], "-gg") == 0) {
+ arguments->verbose_print = true;
+ strcpy(argv[i], "");
+ } else if (strcmp(argv[i], "-PP") == 0) {
+ arguments->performance_print = true;
+ strcpy(argv[i], "");
+ } else if (strcmp(argv[i], "-A") == 0) {
+ g_args.all_databases = true;
+ } else {
+ continue;
+ }
+
+ }
+}
+
static void parse_timestamp(
int argc, char *argv[], SArguments *arguments) {
for (int i = 1; i < argc; i++) {
@@ -612,13 +674,17 @@ static void parse_timestamp(
}
int main(int argc, char *argv[]) {
+ static char verType[32] = {0};
+ sprintf(verType, "version: %s\n", version);
+ argp_program_version = verType;
int ret = 0;
/* Parse our arguments; every option seen by parse_opt will be
reflected in arguments. */
- if (argc > 2) {
+ if (argc > 1) {
parse_precision_first(argc, argv, &g_args);
parse_timestamp(argc, argv, &g_args);
+ parse_args(argc, argv, &g_args);
}
argp_parse(&argp, argc, argv, 0, 0, &g_args);
@@ -637,7 +703,6 @@ int main(int argc, char *argv[]) {
printf("user: %s\n", g_args.user);
printf("password: %s\n", g_args.password);
printf("port: %u\n", g_args.port);
- printf("cversion: %s\n", g_args.cversion);
printf("mysqlFlag: %d\n", g_args.mysqlFlag);
printf("outpath: %s\n", g_args.outpath);
printf("inpath: %s\n", g_args.inpath);
@@ -666,11 +731,6 @@ int main(int argc, char *argv[]) {
}
}
printf("==============================\n");
-
- if (g_args.cversion[0] != 0){
- tstrncpy(version, g_args.cversion, 11);
- }
-
if (taosCheckParam(&g_args) < 0) {
exit(EXIT_FAILURE);
}
@@ -688,7 +748,6 @@ int main(int argc, char *argv[]) {
fprintf(g_fpOfResult, "user: %s\n", g_args.user);
fprintf(g_fpOfResult, "password: %s\n", g_args.password);
fprintf(g_fpOfResult, "port: %u\n", g_args.port);
- fprintf(g_fpOfResult, "cversion: %s\n", g_args.cversion);
fprintf(g_fpOfResult, "mysqlFlag: %d\n", g_args.mysqlFlag);
fprintf(g_fpOfResult, "outpath: %s\n", g_args.outpath);
fprintf(g_fpOfResult, "inpath: %s\n", g_args.inpath);
diff --git a/src/kit/taospack/taospack.c b/src/kit/taospack/taospack.c
index 33d779dfcf7abd1315107fd45f79eaed57581768..ddb9e660af4b4c479c0d8bc4b8be47c9f900dfce 100644
--- a/src/kit/taospack/taospack.c
+++ b/src/kit/taospack/taospack.c
@@ -18,6 +18,7 @@
#include
#include
+
#if defined(WINDOWS)
int main(int argc, char *argv[]) {
printf("welcome to use taospack tools v1.3 for windows.\n");
@@ -148,7 +149,10 @@ float* read_float(const char* inFile, int* pcount){
//printf(" buff=%s float=%.50f \n ", buf, floats[fi]);
if ( ++fi == malloc_cnt ) {
malloc_cnt += 100000;
- floats = realloc(floats, malloc_cnt*sizeof(float));
+ float* floats1 = realloc(floats, malloc_cnt*sizeof(float));
+ if(floats1 == NULL)
+ break;
+ floats = floats1;
}
memset(buf, 0, sizeof(buf));
}
@@ -601,7 +605,6 @@ void test_threadsafe_double(int thread_count){
}
-
void unitTestFloat() {
float ft1 [] = {1.11, 2.22, 3.333};
@@ -662,7 +665,50 @@ void unitTestFloat() {
free(ft2);
free(buff);
free(output);
-
+}
+
+void leakFloat() {
+
+ int cnt = sizeof(g_ft1)/sizeof(float);
+ float* floats = g_ft1;
+ int algorithm = 2;
+
+ // compress
+ const char* input = (const char*)floats;
+ int input_len = cnt * sizeof(float);
+ int output_len = input_len + 1024;
+ char* output = (char*) malloc(output_len);
+ char* buff = (char*) malloc(input_len);
+ int buff_len = input_len;
+
+ int ret_len = 0;
+ ret_len = tsCompressFloatLossy(input, input_len, cnt, output, output_len, algorithm, buff, buff_len);
+
+ if(ret_len == 0) {
+ printf(" compress float error.\n");
+ free(buff);
+ free(output);
+ return ;
+ }
+
+ float* ft2 = (float*)malloc(input_len);
+ ret_len = tsDecompressFloatLossy(output, ret_len, cnt, (char*)ft2, input_len, algorithm, buff, buff_len);
+ if(ret_len == 0) {
+ printf(" decompress float error.\n");
+ }
+
+ free(ft2);
+ free(buff);
+ free(output);
+}
+
+
+void leakTest(){
+ for(int i=0; i< 90000000000000; i++){
+ if(i%10000==0)
+ printf(" ---------- %d ---------------- \n", i);
+ leakFloat();
+ }
}
#define DB_CNT 500
@@ -689,7 +735,7 @@ extern char Compressor [];
// ----------------- main ----------------------
//
int main(int argc, char *argv[]) {
- printf("welcome to use taospack tools v1.3\n");
+ printf("welcome to use taospack tools v1.6\n");
//printf(" sizeof(int)=%d\n", (int)sizeof(int));
//printf(" sizeof(long)=%d\n", (int)sizeof(long));
@@ -753,6 +799,9 @@ int main(int argc, char *argv[]) {
if(strcmp(argv[1], "-mem") == 0) {
memTest();
}
+ else if(strcmp(argv[1], "-leak") == 0) {
+ leakTest();
+ }
}
else{
unitTestFloat();
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 0bc114ffdfe8d59f4941536b56bd95be96a03d0b..68529ab8a240c2313ae9417bef9f4112759b0c9f 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1518,6 +1518,13 @@ static int32_t mnodeChangeSuperTableColumn(SMnodeMsg *pMsg) {
// update
SSchema *schema = (SSchema *) (pStable->schema + col);
ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
+
+ if (pAlter->schema[0].bytes <= schema->bytes) {
+ mError("msg:%p, app:%p stable:%s, modify column len. column:%s, len from %d to %d", pMsg, pMsg->rpcMsg.ahandle,
+ pStable->info.tableId, name, schema->bytes, pAlter->schema[0].bytes);
+ return TSDB_CODE_MND_INVALID_COLUMN_LENGTH;
+ }
+
schema->bytes = pAlter->schema[0].bytes;
pStable->sversion++;
mInfo("msg:%p, app:%p stable %s, start to modify column %s len to %d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
@@ -1548,6 +1555,12 @@ static int32_t mnodeChangeSuperTableTag(SMnodeMsg *pMsg) {
// update
SSchema *schema = (SSchema *) (pStable->schema + col + pStable->numOfColumns);
ASSERT(schema->type == TSDB_DATA_TYPE_BINARY || schema->type == TSDB_DATA_TYPE_NCHAR);
+ if (pAlter->schema[0].bytes <= schema->bytes) {
+ mError("msg:%p, app:%p stable:%s, modify tag len. tag:%s, len from %d to %d", pMsg, pMsg->rpcMsg.ahandle,
+ pStable->info.tableId, name, schema->bytes, pAlter->schema[0].bytes);
+ return TSDB_CODE_MND_INVALID_TAG_LENGTH;
+ }
+
schema->bytes = pAlter->schema[0].bytes;
pStable->tversion++;
mInfo("msg:%p, app:%p stable %s, start to modify tag len %s to %d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
@@ -2921,10 +2934,11 @@ static SMultiTableMeta* ensureMsgBufferSpace(SMultiTableMeta *pMultiMeta, SArray
(*totalMallocLen) *= 2;
}
- pMultiMeta = realloc(pMultiMeta, *totalMallocLen);
- if (pMultiMeta == NULL) {
+ SMultiTableMeta* pMultiMeta1 = realloc(pMultiMeta, *totalMallocLen);
+ if (pMultiMeta1 == NULL) {
return NULL;
}
+ pMultiMeta = pMultiMeta1;
}
return pMultiMeta;
diff --git a/src/os/inc/osSystem.h b/src/os/inc/osSystem.h
index e7a3ec13ae1b3ff9a94724a4cd28e2b4bb40ac1c..4b7925074075b7eef04d2281d3ba7649740bae1e 100644
--- a/src/os/inc/osSystem.h
+++ b/src/os/inc/osSystem.h
@@ -24,6 +24,8 @@ void* taosLoadDll(const char *filename);
void* taosLoadSym(void* handle, char* name);
void taosCloseDll(void *handle);
+int taosSetConsoleEcho(bool on);
+
#ifdef __cplusplus
}
#endif
diff --git a/src/os/src/darwin/darwinSystem.c b/src/os/src/darwin/darwinSystem.c
index 17cafdd6644ed2adbb0a402689f9f300fa615d03..6f296c9fef4f8db5249e90892214c3b928873939 100644
--- a/src/os/src/darwin/darwinSystem.c
+++ b/src/os/src/darwin/darwinSystem.c
@@ -29,4 +29,30 @@ void* taosLoadSym(void* handle, char* name) {
void taosCloseDll(void *handle) {
}
+int taosSetConsoleEcho(bool on)
+{
+#if 0
+#define ECHOFLAGS (ECHO | ECHOE | ECHOK | ECHONL)
+ int err;
+ struct termios term;
+
+ if (tcgetattr(STDIN_FILENO, &term) == -1) {
+ perror("Cannot get the attribution of the terminal");
+ return -1;
+ }
+
+ if (on)
+ term.c_lflag|=ECHOFLAGS;
+ else
+ term.c_lflag &=~ECHOFLAGS;
+
+ err = tcsetattr(STDIN_FILENO,TCSAFLUSH,&term);
+ if (err == -1 && err == EINTR) {
+ perror("Cannot set the attribution of the terminal");
+ return -1;
+ }
+
+#endif
+ return 0;
+}
diff --git a/src/os/src/detail/osMemory.c b/src/os/src/detail/osMemory.c
index d8194feab4011501097fdcce937d88b87ea41af0..22954f1523dc229b8446e339a2d142a0b4b7b023 100644
--- a/src/os/src/detail/osMemory.c
+++ b/src/os/src/detail/osMemory.c
@@ -504,8 +504,9 @@ void * taosTRealloc(void *ptr, size_t size) {
void * tptr = (void *)((char *)ptr - sizeof(size_t));
size_t tsize = size + sizeof(size_t);
- tptr = realloc(tptr, tsize);
- if (tptr == NULL) return NULL;
+ void* tptr1 = realloc(tptr, tsize);
+ if (tptr1 == NULL) return NULL;
+ tptr = tptr1;
*(size_t *)tptr = size;
diff --git a/src/os/src/linux/linuxEnv.c b/src/os/src/linux/linuxEnv.c
index b7b268b19e6b6f92babb74cfd3f23793be037cd0..650a45aae42c8d2dfba63d8f4e7e6ec35b385ae8 100644
--- a/src/os/src/linux/linuxEnv.c
+++ b/src/os/src/linux/linuxEnv.c
@@ -50,14 +50,20 @@ void osInit() {
char* taosGetCmdlineByPID(int pid) {
static char cmdline[1024];
sprintf(cmdline, "/proc/%d/cmdline", pid);
- FILE* f = fopen(cmdline, "r");
- if (f) {
- size_t size;
- size = fread(cmdline, sizeof(char), 1024, f);
- if (size > 0) {
- if ('\n' == cmdline[size - 1]) cmdline[size - 1] = '\0';
- }
- fclose(f);
+
+ int fd = open(cmdline, O_RDONLY);
+ if (fd >= 0) {
+ int n = read(fd, cmdline, sizeof(cmdline) - 1);
+ if (n < 0) n = 0;
+
+ if (n > 0 && cmdline[n - 1] == '\n') --n;
+
+ cmdline[n] = 0;
+
+ close(fd);
+ } else {
+ cmdline[0] = 0;
}
+
return cmdline;
}
diff --git a/src/os/src/linux/osSystem.c b/src/os/src/linux/osSystem.c
index 052b7a22a8e9fe5dafffc4a90c8efa3643e4a06c..a82149dccb1f71e6fbdc2b62d066f04ff52c251d 100644
--- a/src/os/src/linux/osSystem.c
+++ b/src/os/src/linux/osSystem.c
@@ -51,4 +51,28 @@ void taosCloseDll(void *handle) {
}
}
+int taosSetConsoleEcho(bool on)
+{
+#define ECHOFLAGS (ECHO | ECHOE | ECHOK | ECHONL)
+ int err;
+ struct termios term;
+
+ if (tcgetattr(STDIN_FILENO, &term) == -1) {
+ perror("Cannot get the attribution of the terminal");
+ return -1;
+ }
+
+ if (on)
+ term.c_lflag |= ECHOFLAGS;
+ else
+ term.c_lflag &= ~ECHOFLAGS;
+
+ err = tcsetattr(STDIN_FILENO, TCSAFLUSH, &term);
+ if (err == -1 || err == EINTR) {
+ perror("Cannot set the attribution of the terminal");
+ return -1;
+ }
+
+ return 0;
+}
diff --git a/src/os/src/windows/wGetline.c b/src/os/src/windows/wGetline.c
index 553aecaf0a9be65fb5d532668d28ee1a77fbbd39..aa458548843b977ac7fed4070047ac8d693b2d31 100644
--- a/src/os/src/windows/wGetline.c
+++ b/src/os/src/windows/wGetline.c
@@ -81,11 +81,13 @@ int32_t getstr(char **lineptr, size_t *n, FILE *stream, char terminator, int32_t
*n += MIN_CHUNK;
nchars_avail = (int32_t)(*n + *lineptr - read_pos);
- *lineptr = realloc(*lineptr, *n);
- if (!*lineptr) {
+ char* lineptr1 = realloc(*lineptr, *n);
+ if (!lineptr1) {
errno = ENOMEM;
return -1;
}
+ *lineptr = lineptr1;
+
read_pos = *n - nchars_avail + *lineptr;
assert((*lineptr + *n) == (read_pos + nchars_avail));
}
diff --git a/src/os/src/windows/wSystem.c b/src/os/src/windows/wSystem.c
index 17cafdd6644ed2adbb0a402689f9f300fa615d03..564005f79be71c9e8649442e4b29651cdfd993fd 100644
--- a/src/os/src/windows/wSystem.c
+++ b/src/os/src/windows/wSystem.c
@@ -30,3 +30,17 @@ void taosCloseDll(void *handle) {
}
+int taosSetConsoleEcho(bool on)
+{
+ HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
+ DWORD mode = 0;
+ GetConsoleMode(hStdin, &mode );
+ if (on) {
+ mode |= ENABLE_ECHO_INPUT;
+ } else {
+ mode &= ~ENABLE_ECHO_INPUT;
+ }
+ SetConsoleMode(hStdin, mode);
+
+ return 0;
+}
diff --git a/src/plugins/http/CMakeLists.txt b/src/plugins/http/CMakeLists.txt
index 57fc2ee3a2692c239d7fa36d6e55ddae738a2720..89fdc141b66adafb9f882dd6f59eca54053aff6c 100644
--- a/src/plugins/http/CMakeLists.txt
+++ b/src/plugins/http/CMakeLists.txt
@@ -6,6 +6,7 @@ INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lz4/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
INCLUDE_DIRECTORIES(inc)
AUX_SOURCE_DIRECTORY(src SRC)
diff --git a/src/plugins/http/inc/httpInt.h b/src/plugins/http/inc/httpInt.h
index 0a5822b90893861eb12aea756bf877bc81730413..99a5b770aa140df0d0c5787091cb8950ae6dd25f 100644
--- a/src/plugins/http/inc/httpInt.h
+++ b/src/plugins/http/inc/httpInt.h
@@ -150,6 +150,7 @@ typedef struct HttpContext {
char ipstr[22];
char user[TSDB_USER_LEN]; // parsed from auth token or login message
char pass[HTTP_PASSWORD_LEN];
+ char db[/*TSDB_ACCT_ID_LEN + */TSDB_DB_NAME_LEN];
TAOS * taos;
void * ppContext;
HttpSession *session;
diff --git a/src/plugins/http/inc/httpRestHandle.h b/src/plugins/http/inc/httpRestHandle.h
index 632a1dc64739e39d1e9671fd41f9c224597eff07..df405685e91a520d8b948fdc056d9386626368a2 100644
--- a/src/plugins/http/inc/httpRestHandle.h
+++ b/src/plugins/http/inc/httpRestHandle.h
@@ -22,12 +22,12 @@
#include "httpResp.h"
#include "httpSql.h"
-#define REST_ROOT_URL_POS 0
-#define REST_ACTION_URL_POS 1
-#define REST_USER_URL_POS 2
-#define REST_PASS_URL_POS 3
+#define REST_ROOT_URL_POS 0
+#define REST_ACTION_URL_POS 1
+#define REST_USER_USEDB_URL_POS 2
+#define REST_PASS_URL_POS 3
void restInitHandle(HttpServer* pServer);
bool restProcessRequest(struct HttpContext* pContext);
-#endif
\ No newline at end of file
+#endif
diff --git a/src/plugins/http/src/httpParser.c b/src/plugins/http/src/httpParser.c
index 02f21037b8592cc847f02f1b2fbe3c01acd508d8..7066f19769754e78dffeed6a40b672584c0310f1 100644
--- a/src/plugins/http/src/httpParser.c
+++ b/src/plugins/http/src/httpParser.c
@@ -663,7 +663,7 @@ static int32_t httpParserOnTarget(HttpParser *parser, HTTP_PARSER_STATE state, c
HttpContext *pContext = parser->pContext;
int32_t ok = 0;
do {
- if (!isspace(c) && c != '\r' && c != '\n') {
+ if (!isspace(c)) {
if (httpAppendString(&parser->str, &c, 1)) {
httpError("context:%p, fd:%d, parser state:%d, char:[%c]%02x, oom", pContext, pContext->fd, state, c, c);
ok = -1;
diff --git a/src/plugins/http/src/httpRestHandle.c b/src/plugins/http/src/httpRestHandle.c
index a285670d20ae1e5a9c8bd6c41971fc57cda3320a..24e4f90244cf52799fde1a45054875a4bf3d1850 100644
--- a/src/plugins/http/src/httpRestHandle.c
+++ b/src/plugins/http/src/httpRestHandle.c
@@ -19,6 +19,7 @@
#include "httpLog.h"
#include "httpRestHandle.h"
#include "httpRestJson.h"
+#include "tglobal.h"
static HttpDecodeMethod restDecodeMethod = {"rest", restProcessRequest};
static HttpDecodeMethod restDecodeMethod2 = {"restful", restProcessRequest};
@@ -62,11 +63,11 @@ void restInitHandle(HttpServer* pServer) {
bool restGetUserFromUrl(HttpContext* pContext) {
HttpParser* pParser = pContext->parser;
- if (pParser->path[REST_USER_URL_POS].pos >= TSDB_USER_LEN || pParser->path[REST_USER_URL_POS].pos <= 0) {
+ if (pParser->path[REST_USER_USEDB_URL_POS].pos >= TSDB_USER_LEN || pParser->path[REST_USER_USEDB_URL_POS].pos <= 0) {
return false;
}
- tstrncpy(pContext->user, pParser->path[REST_USER_URL_POS].str, TSDB_USER_LEN);
+ tstrncpy(pContext->user, pParser->path[REST_USER_USEDB_URL_POS].str, TSDB_USER_LEN);
return true;
}
@@ -107,6 +108,24 @@ bool restProcessSqlRequest(HttpContext* pContext, int32_t timestampFmt) {
HttpSqlCmd* cmd = &(pContext->singleCmd);
cmd->nativSql = sql;
+ /* find if there is db_name in url */
+ pContext->db[0] = '\0';
+
+ HttpString *path = &pContext->parser->path[REST_USER_USEDB_URL_POS];
+ if (tsHttpDbNameMandatory) {
+ if (path->pos == 0) {
+ httpError("context:%p, fd:%d, user:%s, database name is mandatory", pContext, pContext->fd, pContext->user);
+ httpSendErrorResp(pContext, TSDB_CODE_HTTP_INVALID_URL);
+ return false;
+ }
+ }
+
+ if (path->pos > 0 && !(strlen(sql) > 4 && (sql[0] == 'u' || sql[0] == 'U') &&
+ (sql[1] == 's' || sql[1] == 'S') && (sql[2] == 'e' || sql[2] == 'E') && sql[3] == ' '))
+ {
+ snprintf(pContext->db, /*TSDB_ACCT_ID_LEN + */TSDB_DB_NAME_LEN, "%s", path->str);
+ }
+
pContext->reqType = HTTP_REQTYPE_SINGLE_SQL;
if (timestampFmt == REST_TIMESTAMP_FMT_LOCAL_STRING) {
pContext->encodeMethod = &restEncodeSqlLocalTimeStringMethod;
diff --git a/src/plugins/http/src/httpSql.c b/src/plugins/http/src/httpSql.c
index c2e723732a0f9d786994527c6cd1ac77f273a736..0dd451f72dbd78233ac8f73d552b6815e3a3fab8 100644
--- a/src/plugins/http/src/httpSql.c
+++ b/src/plugins/http/src/httpSql.c
@@ -419,6 +419,11 @@ void httpProcessRequest(HttpContext *pContext) {
&(pContext->taos));
httpDebug("context:%p, fd:%d, user:%s, try connect tdengine, taos:%p", pContext, pContext->fd, pContext->user,
pContext->taos);
+
+ if (pContext->taos != NULL) {
+ STscObj *pObj = pContext->taos;
+ pObj->from = TAOS_REQ_FROM_HTTP;
+ }
} else {
httpExecCmd(pContext);
}
diff --git a/src/plugins/monitor/src/monMain.c b/src/plugins/monitor/src/monMain.c
index 6e583fe0dfd809bac8c0aabf56e48bb33bd910ce..fea793fa860fd17ff30bcecae1436180bc6b34bf 100644
--- a/src/plugins/monitor/src/monMain.c
+++ b/src/plugins/monitor/src/monMain.c
@@ -34,7 +34,7 @@
#define monTrace(...) { if (monDebugFlag & DEBUG_TRACE) { taosPrintLog("MON ", monDebugFlag, __VA_ARGS__); }}
#define SQL_LENGTH 1030
-#define LOG_LEN_STR 100
+#define LOG_LEN_STR 512
#define IP_LEN_STR TSDB_EP_LEN
#define CHECK_INTERVAL 1000
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index 5fe68e456fa11c7dd1fe0a2cdb5bb615dbc1bf8b..7aab8dbca747f40a9f93ee826cea5f9a62a7b297 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -219,6 +219,7 @@ typedef struct SQueryAttr {
bool distinct; // distinct query or not
bool stateWindow; // window State on sub/normal table
bool createFilterOperator; // if filter operator is needed
+ bool multigroupResult; // multigroup result can exist in one SSDataBlock
int32_t interBufSize; // intermediate buffer sizse
int32_t havingNum; // having expr number
@@ -333,6 +334,7 @@ enum OPERATOR_TYPE_E {
OP_StateWindow = 22,
OP_AllTimeWindow = 23,
OP_AllMultiTableTimeInterval = 24,
+ OP_Order = 25,
};
typedef struct SOperatorInfo {
@@ -417,7 +419,6 @@ typedef struct STableScanInfo {
int32_t *rowCellInfoOffset;
SExprInfo *pExpr;
SSDataBlock block;
- bool loadExternalRows; // load external rows (prev & next rows)
int32_t numOfOutput;
int64_t elapsedTime;
@@ -460,16 +461,23 @@ typedef struct SLimitOperatorInfo {
} SLimitOperatorInfo;
typedef struct SSLimitOperatorInfo {
- int64_t groupTotal;
- int64_t currentGroupOffset;
-
- int64_t rowsTotal;
- int64_t currentOffset;
- SLimitVal limit;
- SLimitVal slimit;
-
- char **prevRow;
- SArray *orderColumnList;
+ int64_t groupTotal;
+ int64_t currentGroupOffset;
+
+ int64_t rowsTotal;
+ int64_t currentOffset;
+ SLimitVal limit;
+ SLimitVal slimit;
+
+ char **prevRow;
+ SArray *orderColumnList;
+ bool hasPrev;
+ bool ignoreCurrentGroup;
+ bool multigroupResult;
+ SSDataBlock *pRes; // result buffer
+ SSDataBlock *pPrevBlock;
+ int64_t capacity;
+ int64_t threshold;
} SSLimitOperatorInfo;
typedef struct SFilterOperatorInfo {
@@ -481,8 +489,9 @@ typedef struct SFillOperatorInfo {
SFillInfo *pFillInfo;
SSDataBlock *pRes;
int64_t totalInputRows;
-
+ void **p;
SSDataBlock *existNewGroupBlock;
+ bool multigroupResult;
} SFillOperatorInfo;
typedef struct SGroupbyOperatorInfo {
@@ -510,13 +519,21 @@ typedef struct SStateWindowOperatorInfo {
bool reptScan;
} SStateWindowOperatorInfo ;
+typedef struct SDistinctDataInfo {
+ int32_t index;
+ int32_t type;
+ int32_t bytes;
+} SDistinctDataInfo;
+
typedef struct SDistinctOperatorInfo {
SHashObj *pSet;
SSDataBlock *pRes;
bool recordNullVal; //has already record the null value, no need to try again
int64_t threshold;
int64_t outputCapacity;
- int32_t colIndex;
+ int32_t totalBytes;
+ char* buf;
+ SArray* pDistinctDataInfo;
} SDistinctOperatorInfo;
struct SGlobalMerger;
@@ -536,11 +553,18 @@ typedef struct SMultiwayMergeInfo {
bool hasDataBlockForNewGroup;
SSDataBlock *pExistBlock;
- bool hasPrev;
- bool groupMix;
SArray *udfInfo;
+ bool hasPrev;
+ bool multiGroupResults;
} SMultiwayMergeInfo;
+// todo support the disk-based sort
+typedef struct SOrderOperatorInfo {
+ int32_t colIndex;
+ int32_t order;
+ SSDataBlock *pDataBlock;
+} SOrderOperatorInfo;
+
void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream);
SOperatorInfo* createDataBlocksOptScanInfo(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv, int32_t repeatTime, int32_t reverseTime);
@@ -553,7 +577,7 @@ SOperatorInfo* createLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
SOperatorInfo* createTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
SOperatorInfo* createAllTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
-SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, bool multigroupResult);
SOperatorInfo* createGroupbyOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
SOperatorInfo* createMultiTableAggOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
SOperatorInfo* createMultiTableTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
@@ -562,14 +586,15 @@ SOperatorInfo* createTagScanOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInf
SOperatorInfo* createDistinctOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
SOperatorInfo* createMultiwaySortOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput,
- int32_t numOfRows, void* merger, bool groupMix);
-SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo);
+ int32_t numOfRows, void* merger);
+SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo, bool groupResultMixedUp);
SOperatorInfo* createStatewindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
-SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* merger);
+SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* merger, bool multigroupResult);
SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
SOperatorInfo* createJoinOperatorInfo(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput);
+SOperatorInfo* createOrderOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, SOrderVal* pOrderVal);
SSDataBlock* doGlobalAggregate(void* param, bool* newgroup);
SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
@@ -581,6 +606,8 @@ bool doFilterDataBlock(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilter
void doCompactSDataBlock(SSDataBlock* pBlock, int32_t numOfRows, int8_t* p);
SSDataBlock* createOutputBuf(SExprInfo* pExpr, int32_t numOfOutput, int32_t numOfRows);
+void copyTsColoum(SSDataBlock* pRes, SQLFunctionCtx* pCtx, int32_t numOfOutput);
+
void* destroyOutputBuf(SSDataBlock* pBlock);
void* doDestroyFilterInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols);
diff --git a/src/query/inc/qExtbuffer.h b/src/query/inc/qExtbuffer.h
index cf0e8ce31af91ad9d94feed2045265862a57545a..c06fae298c0a22a6d33e4230fa2ce160545b038a 100644
--- a/src/query/inc/qExtbuffer.h
+++ b/src/query/inc/qExtbuffer.h
@@ -220,6 +220,8 @@ tOrderDescriptor *tOrderDesCreate(const int32_t *orderColIdx, int32_t numOfOrder
void tOrderDescDestroy(tOrderDescriptor *pDesc);
+void taoscQSort(void** pCols, SSchema* pSchema, int32_t numOfCols, int32_t numOfRows, int32_t index, __compar_fn_t compareFn);
+
void tColModelAppend(SColumnModel *dstModel, tFilePage *dstPage, void *srcData, int32_t srcStartRows,
int32_t numOfRowsToWrite, int32_t srcCapacity);
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index 531ff06565dba837c696c6069d409ccf536cbe8c..c231c90996e00d84a70c7141eac69c5a59e20254 100644
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -80,6 +80,7 @@ typedef struct tVariantListItem {
} tVariantListItem;
typedef struct SIntervalVal {
+ int32_t token;
SStrToken interval;
SStrToken offset;
} SIntervalVal;
diff --git a/src/query/inc/qTableMeta.h b/src/query/inc/qTableMeta.h
index 0dae74ac8224329810064c773ecd478d4a89ad15..54de5185b02194bc7cd55a609cfee3815ace2f4f 100644
--- a/src/query/inc/qTableMeta.h
+++ b/src/query/inc/qTableMeta.h
@@ -148,6 +148,7 @@ typedef struct SQueryInfo {
bool orderProjectQuery;
bool stateWindow;
bool globalMerge;
+ bool multigroupResult;
} SQueryInfo;
/**
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index 96f1e680f17a650b1033c4b77719838d9119e539..920443232e9bfbe59f4b571646793a1c515928bc 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -94,15 +94,15 @@ cpxName(A) ::= DOT ids(Y). {A = Y; A.n += 1; }
cmd ::= SHOW CREATE TABLE ids(X) cpxName(Y). {
X.n += Y.n;
setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_TABLE, 1, &X);
-}
+}
cmd ::= SHOW CREATE STABLE ids(X) cpxName(Y). {
X.n += Y.n;
setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_STABLE, 1, &X);
-}
+}
cmd ::= SHOW CREATE DATABASE ids(X). {
setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_DATABASE, 1, &X);
-}
+}
cmd ::= SHOW dbPrefix(X) TABLES. {
setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &X, 0);
@@ -163,6 +163,11 @@ cmd ::= DESCRIBE ids(X) cpxName(Y). {
setDCLSqlElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &X);
}
+cmd ::= DESC ids(X) cpxName(Y). {
+ X.n += Y.n;
+ setDCLSqlElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &X);
+}
+
/////////////////////////////////THE ALTER STATEMENT////////////////////////////////////////
cmd ::= ALTER USER ids(X) PASS ids(Y). { setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &X, &Y, NULL); }
cmd ::= ALTER USER ids(X) PRIVILEGE ids(Y). { setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &X, NULL, &Y);}
@@ -274,7 +279,7 @@ wal(Y) ::= WAL INTEGER(X). { Y = X; }
fsync(Y) ::= FSYNC INTEGER(X). { Y = X; }
comp(Y) ::= COMP INTEGER(X). { Y = X; }
prec(Y) ::= PRECISION STRING(X). { Y = X; }
-update(Y) ::= UPDATE INTEGER(X). { Y = X; }
+update(Y) ::= UPDATE INTEGER(X). { Y = X; }
cachelast(Y) ::= CACHELAST INTEGER(X). { Y = X; }
partitions(Y) ::= PARTITIONS INTEGER(X). { Y = X; }
@@ -323,7 +328,7 @@ alter_topic_optr(Y) ::= alter_db_optr(Z). { Y = Z; Y.dbTyp
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). {
+typename(A) ::= ids(X). {
X.type = 0;
tSetColumnType (&A, &X);
}
@@ -479,7 +484,7 @@ tagitem(A) ::= PLUS(X) FLOAT(Y). {
//////////////////////// The SELECT statement /////////////////////////////////
%type select {SSqlNode*}
%destructor select {destroySqlNode($$);}
-select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) sliding_opt(S) session_option(H) windowstate_option(D) fill_opt(F)groupby_opt(P) having_opt(N) orderby_opt(Z) slimit_opt(G) limit_opt(L). {
+select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_option(K) sliding_opt(S) session_option(H) windowstate_option(D) fill_opt(F)groupby_opt(P) having_opt(N) orderby_opt(Z) slimit_opt(G) limit_opt(L). {
A = tSetQuerySqlNode(&T, W, X, Y, P, Z, &K, &H, &D, &S, F, &L, &G, N);
}
@@ -569,10 +574,14 @@ tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z) ids(F). {
%type tmvar {SStrToken}
tmvar(A) ::= VARIABLE(X). {A = X;}
-%type interval_opt {SIntervalVal}
-interval_opt(N) ::= INTERVAL LP tmvar(E) RP. {N.interval = E; N.offset.n = 0;}
-interval_opt(N) ::= INTERVAL LP tmvar(E) COMMA tmvar(X) RP. {N.interval = E; N.offset = X;}
-interval_opt(N) ::= . {memset(&N, 0, sizeof(N));}
+%type interval_option {SIntervalVal}
+interval_option(N) ::= intervalKey(A) LP tmvar(E) RP. {N.interval = E; N.offset.n = 0; N.token = A;}
+interval_option(N) ::= intervalKey(A) LP tmvar(E) COMMA tmvar(X) RP. {N.interval = E; N.offset = X; N.token = A;}
+interval_option(N) ::= . {memset(&N, 0, sizeof(N));}
+
+%type intervalKey {int32_t}
+intervalKey(A) ::= INTERVAL. {A = TK_INTERVAL;}
+intervalKey(A) ::= EVERY. {A = TK_EVERY; }
%type session_option {SSessionWindowVal}
session_option(X) ::= . {X.col.n = 0; X.gap.n = 0;}
@@ -581,6 +590,7 @@ session_option(X) ::= SESSION LP ids(V) cpxName(Z) COMMA tmvar(Y) RP. {
X.col = V;
X.gap = Y;
}
+
%type windowstate_option {SWindowStateVal}
windowstate_option(X) ::= . { X.col.n = 0; X.col.z = NULL;}
windowstate_option(X) ::= STATE_WINDOW LP ids(V) RP. { X.col = V; }
diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index 6eadedcaf30035ea932314eeeeb5eacf8e6da66a..f3275456fc3c320ee127d6861ad1e212f4d08c60 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -1214,6 +1214,31 @@ static int32_t minmax_merge_impl(SQLFunctionCtx *pCtx, int32_t bytes, char *outp
DUPATE_DATA_WITHOUT_TS(pCtx, *(int64_t *)output, v, notNullElems, isMin);
break;
}
+
+ case TSDB_DATA_TYPE_UTINYINT: {
+ uint8_t v = GET_UINT8_VAL(input);
+ DUPATE_DATA_WITHOUT_TS(pCtx, *(uint8_t *)output, v, notNullElems, isMin);
+ break;
+ }
+
+ case TSDB_DATA_TYPE_USMALLINT: {
+ uint16_t v = GET_UINT16_VAL(input);
+ DUPATE_DATA_WITHOUT_TS(pCtx, *(uint16_t *)output, v, notNullElems, isMin);
+ break;
+ }
+
+ case TSDB_DATA_TYPE_UINT: {
+ uint32_t v = GET_UINT32_VAL(input);
+ DUPATE_DATA_WITHOUT_TS(pCtx, *(uint32_t *)output, v, notNullElems, isMin);
+ break;
+ }
+
+ case TSDB_DATA_TYPE_UBIGINT: {
+ uint64_t v = GET_UINT64_VAL(input);
+ DUPATE_DATA_WITHOUT_TS(pCtx, *(uint64_t *)output, v, notNullElems, isMin);
+ break;
+ }
+
default:
break;
}
@@ -3670,6 +3695,8 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
return;
}
+ bool ascQuery = (pCtx->order == TSDB_ORDER_ASC);
+
if (pCtx->inputType == TSDB_DATA_TYPE_TIMESTAMP) {
*(TSKEY *)pCtx->pOutput = pCtx->startTs;
} else if (type == TSDB_FILL_NULL) {
@@ -3677,7 +3704,7 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
} else if (type == TSDB_FILL_SET_VALUE) {
tVariantDump(&pCtx->param[1], pCtx->pOutput, pCtx->inputType, true);
} else {
- if (pCtx->start.key != INT64_MIN && pCtx->start.key < pCtx->startTs && pCtx->end.key > pCtx->startTs) {
+ if (pCtx->start.key != INT64_MIN && ((ascQuery && pCtx->start.key <= pCtx->startTs && pCtx->end.key >= pCtx->startTs) || ((!ascQuery) && pCtx->start.key >= pCtx->startTs && pCtx->end.key <= pCtx->startTs))) {
if (type == TSDB_FILL_PREV) {
if (IS_NUMERIC_TYPE(pCtx->inputType) || pCtx->inputType == TSDB_DATA_TYPE_BOOL) {
SET_TYPED_DATA(pCtx->pOutput, pCtx->inputType, pCtx->start.val);
@@ -3716,13 +3743,14 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
TSKEY skey = GET_TS_DATA(pCtx, 0);
if (type == TSDB_FILL_PREV) {
- if (skey > pCtx->startTs) {
+ if ((ascQuery && skey > pCtx->startTs) || ((!ascQuery) && skey < pCtx->startTs)) {
return;
}
if (pCtx->size > 1) {
TSKEY ekey = GET_TS_DATA(pCtx, 1);
- if (ekey > skey && ekey <= pCtx->startTs) {
+ if ((ascQuery && ekey > skey && ekey <= pCtx->startTs) ||
+ ((!ascQuery) && ekey < skey && ekey >= pCtx->startTs)){
skey = ekey;
}
}
@@ -3731,10 +3759,10 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
TSKEY ekey = skey;
char* val = NULL;
- if (ekey < pCtx->startTs) {
+ if ((ascQuery && ekey < pCtx->startTs) || ((!ascQuery) && ekey > pCtx->startTs)) {
if (pCtx->size > 1) {
ekey = GET_TS_DATA(pCtx, 1);
- if (ekey < pCtx->startTs) {
+ if ((ascQuery && ekey < pCtx->startTs) || ((!ascQuery) && ekey > pCtx->startTs)) {
return;
}
@@ -3755,12 +3783,11 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
TSKEY ekey = GET_TS_DATA(pCtx, 1);
// no data generated yet
- if (!(skey < pCtx->startTs && ekey > pCtx->startTs)) {
+ if ((ascQuery && !(skey <= pCtx->startTs && ekey >= pCtx->startTs))
+ || ((!ascQuery) && !(skey >= pCtx->startTs && ekey <= pCtx->startTs))) {
return;
}
- assert(pCtx->start.key == INT64_MIN && skey < pCtx->startTs && ekey > pCtx->startTs);
-
char *start = GET_INPUT_DATA(pCtx, 0);
char *end = GET_INPUT_DATA(pCtx, 1);
@@ -3788,11 +3815,37 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
static void interp_function(SQLFunctionCtx *pCtx) {
// at this point, the value is existed, return directly
if (pCtx->size > 0) {
- // impose the timestamp check
- TSKEY key = GET_TS_DATA(pCtx, 0);
+ bool ascQuery = (pCtx->order == TSDB_ORDER_ASC);
+ TSKEY key;
+ char *pData;
+ int32_t typedData = 0;
+
+ if (ascQuery) {
+ key = GET_TS_DATA(pCtx, 0);
+ pData = GET_INPUT_DATA(pCtx, 0);
+ } else {
+ key = pCtx->start.key;
+ if (key == INT64_MIN) {
+ key = GET_TS_DATA(pCtx, 0);
+ pData = GET_INPUT_DATA(pCtx, 0);
+ } else {
+ if (!(IS_NUMERIC_TYPE(pCtx->inputType) || pCtx->inputType == TSDB_DATA_TYPE_BOOL)) {
+ pData = pCtx->start.ptr;
+ } else {
+ typedData = 1;
+ pData = (char *)&pCtx->start.val;
+ }
+ }
+ }
+
+ //if (key == pCtx->startTs && (ascQuery || !(IS_NUMERIC_TYPE(pCtx->inputType) || pCtx->inputType == TSDB_DATA_TYPE_BOOL))) {
if (key == pCtx->startTs) {
- char *pData = GET_INPUT_DATA(pCtx, 0);
- assignVal(pCtx->pOutput, pData, pCtx->inputBytes, pCtx->inputType);
+ if (typedData) {
+ SET_TYPED_DATA(pCtx->pOutput, pCtx->inputType, *(double *)pData);
+ } else {
+ assignVal(pCtx->pOutput, pData, pCtx->inputBytes, pCtx->inputType);
+ }
+
SET_VAL(pCtx, 1, 1);
} else {
interp_function_impl(pCtx);
@@ -4004,9 +4057,21 @@ static void irate_function(SQLFunctionCtx *pCtx) {
double v = 0;
GET_TYPED_DATA(v, double, pCtx->inputType, pData);
- if ((INT64_MIN == pRateInfo->lastKey) || primaryKey[i] > pRateInfo->lastKey) {
+ if (INT64_MIN == pRateInfo->lastKey) {
+ pRateInfo->lastValue = v;
+ pRateInfo->lastKey = primaryKey[i];
+ continue;
+ }
+
+ if (primaryKey[i] > pRateInfo->lastKey) {
+ if ((INT64_MIN == pRateInfo->firstKey) || pRateInfo->lastKey > pRateInfo->firstKey) {
+ pRateInfo->firstValue = pRateInfo->lastValue;
+ pRateInfo->firstKey = pRateInfo->lastKey;
+ }
+
pRateInfo->lastValue = v;
pRateInfo->lastKey = primaryKey[i];
+
continue;
}
@@ -4061,7 +4126,7 @@ static void mergeTableBlockDist(SResultRowCellInfo* pResInfo, const STableBlockD
} else {
pDist->maxRows = pSrc->maxRows;
pDist->minRows = pSrc->minRows;
-
+
int32_t maxSteps = TSDB_MAX_MAX_ROW_FBLOCK/TSDB_BLOCK_DIST_STEP_ROWS;
if (TSDB_MAX_MAX_ROW_FBLOCK % TSDB_BLOCK_DIST_STEP_ROWS != 0) {
++maxSteps;
@@ -4195,7 +4260,7 @@ void blockinfo_func_finalizer(SQLFunctionCtx* pCtx) {
taosArrayDestroy(pDist->dataBlockInfos);
pDist->dataBlockInfos = NULL;
}
-
+
// cannot set the numOfIteratedElems again since it is set during previous iteration
pResInfo->numOfRes = 1;
pResInfo->hasResult = DATA_SET_FLAG;
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index b1fb2add1b082d282b16d2f8c59382e5f702aa5e..4e9805acddc55cf07bd1a88a94a8d867a07b75f4 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -39,11 +39,12 @@
#define SET_REVERSE_SCAN_FLAG(runtime) ((runtime)->scanFlag = REVERSE_SCAN)
#define TSWINDOW_IS_EQUAL(t1, t2) (((t1).skey == (t2).skey) && ((t1).ekey == (t2).ekey))
-
#define SWITCH_ORDER(n) (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC))
#define SDATA_BLOCK_INITIALIZER (SDataBlockInfo) {{0}, 0}
+#define MULTI_KEY_DELIM "-"
+
#define TIME_WINDOW_COPY(_dst, _src) do {\
(_dst).skey = (_src).skey;\
(_dst).ekey = (_src).ekey;\
@@ -224,11 +225,18 @@ static void destroySFillOperatorInfo(void* param, int32_t numOfOutput);
static void destroyGroupbyOperatorInfo(void* param, int32_t numOfOutput);
static void destroyProjectOperatorInfo(void* param, int32_t numOfOutput);
static void destroyTagScanOperatorInfo(void* param, int32_t numOfOutput);
+static void destroyOrderOperatorInfo(void* param, int32_t numOfOutput);
static void destroySWindowOperatorInfo(void* param, int32_t numOfOutput);
static void destroyStateWindowOperatorInfo(void* param, int32_t numOfOutput);
static void destroyAggOperatorInfo(void* param, int32_t numOfOutput);
static void destroyOperatorInfo(SOperatorInfo* pOperator);
+static void doSetOperatorCompleted(SOperatorInfo* pOperator) {
+ pOperator->status = OP_EXEC_DONE;
+ if (pOperator->pRuntimeEnv != NULL) {
+ setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
+ }
+}
static int32_t doCopyToSDataBlock(SQueryRuntimeEnv* pRuntimeEnv, SGroupResInfo* pGroupResInfo, int32_t orderType, SSDataBlock* pBlock);
@@ -963,8 +971,6 @@ void doInvokeUdf(SUdfInfo* pUdfInfo, SQLFunctionCtx *pCtx, int32_t idx, int32_t
break;
}
}
-
- return;
}
static void doApplyFunctions(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx, STimeWindow* pWin, int32_t offset,
@@ -1326,6 +1332,16 @@ void doTimeWindowInterpolation(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo,
pCtx[k].end.key = curTs;
pCtx[k].end.val = v2;
+
+ if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+ if (prevRowIndex == -1) {
+ pCtx[k].start.ptr = (char *)pRuntimeEnv->prevRow[index];
+ } else {
+ pCtx[k].start.ptr = (char *)pColInfo->pData + prevRowIndex * pColInfo->info.bytes;
+ }
+
+ pCtx[k].end.ptr = (char *)pColInfo->pData + curRowIndex * pColInfo->info.bytes;
+ }
}
} else if (functionId == TSDB_FUNC_TWA) {
SPoint point1 = (SPoint){.key = prevTs, .val = &v1};
@@ -1595,6 +1611,7 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
SResultRow* pResult = NULL;
int32_t forwardStep = 0;
int32_t ret = 0;
+ STimeWindow preWin = win;
while (1) {
// null data, failed to allocate more memory buffer
@@ -1609,12 +1626,13 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
// window start(end) key interpolation
doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->pCtx, pResult, &win, startPos, forwardStep);
- doApplyFunctions(pRuntimeEnv, pInfo->pCtx, &win, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
+ doApplyFunctions(pRuntimeEnv, pInfo->pCtx, ascQuery ? &win : &preWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
+ preWin = win;
int32_t prevEndPos = (forwardStep - 1) * step + startPos;
startPos = getNextQualifiedWindow(pQueryAttr, &win, &pSDataBlock->info, tsCols, binarySearchForKey, prevEndPos);
if (startPos < 0) {
- if (win.skey <= pQueryAttr->window.ekey) {
+ if ((ascQuery && win.skey <= pQueryAttr->window.ekey) || ((!ascQuery) && win.ekey >= pQueryAttr->window.ekey)) {
int32_t code = setResultOutputBufByKey(pRuntimeEnv, pResultRowInfo, pSDataBlock->info.tid, &win, masterScan, &pResult, tableGroupId,
pInfo->pCtx, numOfOutput, pInfo->rowCellInfoOffset);
if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
@@ -1622,12 +1640,12 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
}
startPos = pSDataBlock->info.rows - 1;
-
+
// window start(end) key interpolation
doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->pCtx, pResult, &win, startPos, forwardStep);
- doApplyFunctions(pRuntimeEnv, pInfo->pCtx, &win, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
+ doApplyFunctions(pRuntimeEnv, pInfo->pCtx, ascQuery ? &win : &preWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
}
-
+
break;
}
setResultRowInterpo(pResult, RESULT_ROW_END_INTERP);
@@ -2213,6 +2231,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
}
break;
}
+
case OP_StateWindow: {
pRuntimeEnv->proot = createStatewindowOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
int32_t opType = pRuntimeEnv->proot->upstream[0]->operatorType;
@@ -2229,52 +2248,49 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
case OP_Filter: { // todo refactor
int32_t numOfFilterCols = 0;
-// if (pQueryAttr->numOfFilterCols > 0) {
-// pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1,
-// pQueryAttr->numOfOutput, pQueryAttr->tableCols, pQueryAttr->numOfFilterCols);
-// } else {
- if (pQueryAttr->stableQuery) {
- SColumnInfo* pColInfo =
- extractColumnFilterInfo(pQueryAttr->pExpr3, pQueryAttr->numOfExpr3, &numOfFilterCols);
- pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3,
- pQueryAttr->numOfExpr3, pColInfo, numOfFilterCols);
- freeColumnInfo(pColInfo, pQueryAttr->numOfExpr3);
- } else {
- SColumnInfo* pColInfo =
- extractColumnFilterInfo(pQueryAttr->pExpr1, pQueryAttr->numOfOutput, &numOfFilterCols);
- pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1,
- pQueryAttr->numOfOutput, pColInfo, numOfFilterCols);
- freeColumnInfo(pColInfo, pQueryAttr->numOfOutput);
- }
-// }
+ if (pQueryAttr->stableQuery) {
+ SColumnInfo* pColInfo =
+ extractColumnFilterInfo(pQueryAttr->pExpr3, pQueryAttr->numOfExpr3, &numOfFilterCols);
+ pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3,
+ pQueryAttr->numOfExpr3, pColInfo, numOfFilterCols);
+ freeColumnInfo(pColInfo, pQueryAttr->numOfExpr3);
+ } else {
+ SColumnInfo* pColInfo =
+ extractColumnFilterInfo(pQueryAttr->pExpr1, pQueryAttr->numOfOutput, &numOfFilterCols);
+ pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1,
+ pQueryAttr->numOfOutput, pColInfo, numOfFilterCols);
+ freeColumnInfo(pColInfo, pQueryAttr->numOfOutput);
+ }
+
break;
}
case OP_Fill: {
SOperatorInfo* pInfo = pRuntimeEnv->proot;
- pRuntimeEnv->proot = createFillOperatorInfo(pRuntimeEnv, pInfo, pInfo->pExpr, pInfo->numOfOutput);
+ pRuntimeEnv->proot = createFillOperatorInfo(pRuntimeEnv, pInfo, pInfo->pExpr, pInfo->numOfOutput, pQueryAttr->multigroupResult);
break;
}
case OP_MultiwayMergeSort: {
- bool groupMix = true;
- if(pQueryAttr->slimit.offset != 0 || pQueryAttr->slimit.limit != -1) {
- groupMix = false;
- }
- pRuntimeEnv->proot = createMultiwaySortOperatorInfo(pRuntimeEnv, pQueryAttr->pExpr1, pQueryAttr->numOfOutput,
- 4096, merger, groupMix); // TODO hack it
+ pRuntimeEnv->proot = createMultiwaySortOperatorInfo(pRuntimeEnv, pQueryAttr->pExpr1, pQueryAttr->numOfOutput, 4096, merger);
break;
}
- case OP_GlobalAggregate: {
+ case OP_GlobalAggregate: { // If fill operator exists, the result rows of different group can not be in the same SSDataBlock.
+ bool multigroupResult = pQueryAttr->multigroupResult;
+ if (pQueryAttr->multigroupResult) {
+ multigroupResult = (pQueryAttr->fillType == TSDB_FILL_NONE);
+ }
+
pRuntimeEnv->proot = createGlobalAggregateOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3,
- pQueryAttr->numOfExpr3, merger, pQueryAttr->pUdfInfo);
+ pQueryAttr->numOfExpr3, merger, pQueryAttr->pUdfInfo, multigroupResult);
break;
}
case OP_SLimit: {
- pRuntimeEnv->proot = createSLimitOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3,
- pQueryAttr->numOfExpr3, merger);
+ int32_t num = pRuntimeEnv->proot->numOfOutput;
+ SExprInfo* pExpr = pRuntimeEnv->proot->pExpr;
+ pRuntimeEnv->proot = createSLimitOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pExpr, num, merger, pQueryAttr->multigroupResult);
break;
}
@@ -2283,6 +2299,11 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
break;
}
+ case OP_Order: {
+ pRuntimeEnv->proot = createOrderOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput, &pQueryAttr->order);
+ break;
+ }
+
default: {
assert(0);
}
@@ -3092,7 +3113,7 @@ int32_t loadDataBlockOnDemand(SQueryRuntimeEnv* pRuntimeEnv, STableScanInfo* pTa
// check if this data block is required to load
if ((*status) != BLK_DATA_ALL_NEEDED) {
bool needFilter = true;
-
+
// the pCtx[i] result is belonged to previous time window since the outputBuf has not been set yet,
// the filter result may be incorrect. So in case of interval query, we need to set the correct time output buffer
if (QUERY_IS_INTERVAL_QUERY(pQueryAttr)) {
@@ -3575,6 +3596,7 @@ void setDefaultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, SOptrBasicInfo *pInfo, i
SResultRowInfo* pResultRowInfo = &pInfo->resultRowInfo;
int64_t tid = 0;
+ pRuntimeEnv->keyBuf = realloc(pRuntimeEnv->keyBuf, sizeof(tid) + sizeof(int64_t) + POINTER_BYTES);
SResultRow* pRow = doSetResultOutBufByKey(pRuntimeEnv, pResultRowInfo, tid, (char *)&tid, sizeof(tid), true, uid);
for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) {
@@ -3595,7 +3617,7 @@ void setDefaultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, SOptrBasicInfo *pInfo, i
// set the timestamp output buffer for top/bottom/diff query
int32_t fid = pCtx[i].functionId;
if (fid == TSDB_FUNC_TOP || fid == TSDB_FUNC_BOTTOM || fid == TSDB_FUNC_DIFF || fid == TSDB_FUNC_DERIVATIVE) {
- pCtx[i].ptsOutputBuf = pCtx[0].pOutput;
+ if(i>0) pCtx[i].ptsOutputBuf = pCtx[i-1].pOutput;
}
}
@@ -3627,10 +3649,40 @@ void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOf
SColumnInfoData *pColInfo = taosArrayGet(pDataBlock->pDataBlock, i);
pBInfo->pCtx[i].pOutput = pColInfo->pData + pColInfo->info.bytes * pDataBlock->info.rows;
- // re-estabilish output buffer pointer.
+ // set the correct pointer after the memory buffer reallocated.
int32_t functionId = pBInfo->pCtx[i].functionId;
if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_DERIVATIVE) {
- pBInfo->pCtx[i].ptsOutputBuf = pBInfo->pCtx[i-1].pOutput;
+ if(i>0) pBInfo->pCtx[i].ptsOutputBuf = pBInfo->pCtx[i-1].pOutput;
+ }
+ }
+}
+
+void copyTsColoum(SSDataBlock* pRes, SQLFunctionCtx* pCtx, int32_t numOfOutput) {
+ bool needCopyTs = false;
+ int32_t tsNum = 0;
+ char *src = NULL;
+ for (int32_t i = 0; i < numOfOutput; i++) {
+ int32_t functionId = pCtx[i].functionId;
+ if (functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_DERIVATIVE) {
+ needCopyTs = true;
+ if (i > 0 && pCtx[i-1].functionId == TSDB_FUNC_TS_DUMMY){
+ SColumnInfoData* pColRes = taosArrayGet(pRes->pDataBlock, i - 1); // find ts data
+ src = pColRes->pData;
+ }
+ }else if(functionId == TSDB_FUNC_TS_DUMMY) {
+ tsNum++;
+ }
+ }
+
+ if (!needCopyTs) return;
+ if (tsNum < 2) return;
+ if (src == NULL) return;
+
+ for (int32_t i = 0; i < numOfOutput; i++) {
+ int32_t functionId = pCtx[i].functionId;
+ if(functionId == TSDB_FUNC_TS_DUMMY) {
+ SColumnInfoData* pColRes = taosArrayGet(pRes->pDataBlock, i);
+ memcpy(pColRes->pData, src, pColRes->info.bytes * pRes->info.rows);
}
}
}
@@ -3830,7 +3882,7 @@ void setResultRowOutputBufInitCtx(SQueryRuntimeEnv *pRuntimeEnv, SResultRow *pRe
}
if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF) {
- pCtx[i].ptsOutputBuf = pCtx[0].pOutput;
+ if(i>0) pCtx[i].ptsOutputBuf = pCtx[i-1].pOutput;
}
if (!pResInfo->initialized) {
@@ -3891,7 +3943,7 @@ void setResultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, SResultRow *pResult, SQLF
int32_t functionId = pCtx[i].functionId;
if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_DERIVATIVE) {
- pCtx[i].ptsOutputBuf = pCtx[0].pOutput;
+ if(i>0) pCtx[i].ptsOutputBuf = pCtx[i-1].pOutput;
}
/*
@@ -4162,6 +4214,7 @@ static void toSSDataBlock(SGroupResInfo *pGroupResInfo, SQueryRuntimeEnv* pRunti
// refactor : extract method
SColumnInfoData* pInfoData = taosArrayGet(pBlock->pDataBlock, 0);
+
//add condition (pBlock->info.rows >= 1) just to runtime happy
if (pInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP && pBlock->info.rows >= 1) {
STimeWindow* w = &pBlock->info.window;
@@ -4241,15 +4294,15 @@ static void doCopyQueryResultToMsg(SQInfo *pQInfo, int32_t numOfRows, char *data
}
}
-int32_t doFillTimeIntervalGapsInResults(SFillInfo* pFillInfo, SSDataBlock *pOutput, int32_t capacity) {
- void** p = calloc(pFillInfo->numOfCols, POINTER_BYTES);
+int32_t doFillTimeIntervalGapsInResults(SFillInfo* pFillInfo, SSDataBlock *pOutput, int32_t capacity, void** p) {
for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
SColumnInfoData* pColInfoData = taosArrayGet(pOutput->pDataBlock, i);
- p[i] = pColInfoData->pData;
+ p[i] = pColInfoData->pData + (pColInfoData->info.bytes * pOutput->info.rows);
}
- pOutput->info.rows = (int32_t)taosFillResultDataBlock(pFillInfo, p, capacity);
- tfree(p);
+ int32_t numOfRows = (int32_t)taosFillResultDataBlock(pFillInfo, p, capacity - pOutput->info.rows);
+ pOutput->info.rows += numOfRows;
+
return pOutput->info.rows;
}
@@ -5266,7 +5319,7 @@ SArray* getResultGroupCheckColumns(SQueryAttr* pQuery) {
// TSDB_FUNC_TAG_DUMMY function needs to be ignored
if (index->colId == pExpr->colInfo.colId &&
- ((TSDB_COL_IS_TAG(pExpr->colInfo.flag) && pExpr->functionId == TSDB_FUNC_TAG) ||
+ ((TSDB_COL_IS_TAG(pExpr->colInfo.flag) && ((pExpr->functionId == TSDB_FUNC_TAG) || (pExpr->functionId == TSDB_FUNC_TAGPRJ))) ||
(TSDB_COL_IS_NORMAL_COL(pExpr->colInfo.flag) && pExpr->functionId == TSDB_FUNC_PRJ))) {
index->colIndex = j;
index->colId = pExpr->resColId;
@@ -5293,11 +5346,12 @@ static void destroyGlobalAggOperatorInfo(void* param, int32_t numOfOutput) {
static void destroySlimitOperatorInfo(void* param, int32_t numOfOutput) {
SSLimitOperatorInfo *pInfo = (SSLimitOperatorInfo*) param;
taosArrayDestroy(pInfo->orderColumnList);
+ pInfo->pRes = destroyOutputBuf(pInfo->pRes);
tfree(pInfo->prevRow);
}
SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream,
- SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo) {
+ SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo, bool groupResultMixedUp) {
SMultiwayMergeInfo* pInfo = calloc(1, sizeof(SMultiwayMergeInfo));
pInfo->resultRowFactor =
@@ -5305,15 +5359,14 @@ SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv,
pRuntimeEnv->scanFlag = MERGE_STAGE; // TODO init when creating pCtx
- pInfo->pMerge = param;
- pInfo->bufCapacity = 4096;
- pInfo->udfInfo = pUdfInfo;
-
- pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pInfo->bufCapacity * pInfo->resultRowFactor);
- pInfo->binfo.pCtx = createSQLFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset);
-
- pInfo->orderColumnList = getOrderCheckColumns(pRuntimeEnv->pQueryAttr);
- pInfo->groupColumnList = getResultGroupCheckColumns(pRuntimeEnv->pQueryAttr);
+ pInfo->multiGroupResults = groupResultMixedUp;
+ pInfo->pMerge = param;
+ pInfo->bufCapacity = 4096;
+ pInfo->udfInfo = pUdfInfo;
+ pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pInfo->bufCapacity * pInfo->resultRowFactor);
+ pInfo->binfo.pCtx = createSQLFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset);
+ pInfo->orderColumnList = getOrderCheckColumns(pRuntimeEnv->pQueryAttr);
+ pInfo->groupColumnList = getResultGroupCheckColumns(pRuntimeEnv->pQueryAttr);
// TODO refactor
int32_t len = 0;
@@ -5366,17 +5419,15 @@ SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv,
}
SOperatorInfo *createMultiwaySortOperatorInfo(SQueryRuntimeEnv *pRuntimeEnv, SExprInfo *pExpr, int32_t numOfOutput,
- int32_t numOfRows, void *merger, bool groupMix) {
+ int32_t numOfRows, void *merger) {
SMultiwayMergeInfo* pInfo = calloc(1, sizeof(SMultiwayMergeInfo));
- pInfo->pMerge = merger;
- pInfo->groupMix = groupMix;
- pInfo->bufCapacity = numOfRows;
-
+ pInfo->pMerge = merger;
+ pInfo->bufCapacity = numOfRows;
pInfo->orderColumnList = getResultGroupCheckColumns(pRuntimeEnv->pQueryAttr);
- pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, numOfRows);
+ pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, numOfRows);
- {
+ { // todo extract method to create prev compare buffer
int32_t len = 0;
for(int32_t i = 0; i < numOfOutput; ++i) {
len += pExpr[i].base.colBytes;
@@ -5384,8 +5435,8 @@ SOperatorInfo *createMultiwaySortOperatorInfo(SQueryRuntimeEnv *pRuntimeEnv, SEx
int32_t numOfCols = (pInfo->orderColumnList != NULL)? (int32_t) taosArrayGetSize(pInfo->orderColumnList):0;
pInfo->prevRow = calloc(1, (POINTER_BYTES * numOfCols + len));
- int32_t offset = POINTER_BYTES * numOfCols;
+ int32_t offset = POINTER_BYTES * numOfCols;
for(int32_t i = 0; i < numOfCols; ++i) {
pInfo->prevRow[i] = (char*)pInfo->prevRow + offset;
@@ -5401,12 +5452,122 @@ SOperatorInfo *createMultiwaySortOperatorInfo(SQueryRuntimeEnv *pRuntimeEnv, SEx
pOperator->status = OP_IN_EXECUTING;
pOperator->info = pInfo;
pOperator->pRuntimeEnv = pRuntimeEnv;
- pOperator->numOfOutput = pRuntimeEnv->pQueryAttr->numOfCols;
+ pOperator->numOfOutput = numOfOutput;
+ pOperator->pExpr = pExpr;
pOperator->exec = doMultiwayMergeSort;
pOperator->cleanup = destroyGlobalAggOperatorInfo;
return pOperator;
}
+static int32_t doMergeSDatablock(SSDataBlock* pDest, SSDataBlock* pSrc) {
+ assert(pSrc != NULL && pDest != NULL && pDest->info.numOfCols == pSrc->info.numOfCols);
+
+ int32_t numOfCols = pSrc->info.numOfCols;
+ for(int32_t i = 0; i < numOfCols; ++i) {
+ SColumnInfoData* pCol2 = taosArrayGet(pDest->pDataBlock, i);
+ SColumnInfoData* pCol1 = taosArrayGet(pSrc->pDataBlock, i);
+
+ int32_t newSize = (pDest->info.rows + pSrc->info.rows) * pCol2->info.bytes;
+ char* tmp = realloc(pCol2->pData, newSize);
+ if (tmp != NULL) {
+ pCol2->pData = tmp;
+ int32_t offset = pCol2->info.bytes * pDest->info.rows;
+ memcpy(pCol2->pData + offset, pCol1->pData, pSrc->info.rows * pCol2->info.bytes);
+ } else {
+ return TSDB_CODE_VND_OUT_OF_MEMORY;
+ }
+ }
+
+ pDest->info.rows += pSrc->info.rows;
+
+ return TSDB_CODE_SUCCESS;
+}
+
+static SSDataBlock* doSort(void* param, bool* newgroup) {
+ SOperatorInfo* pOperator = (SOperatorInfo*) param;
+ if (pOperator->status == OP_EXEC_DONE) {
+ return NULL;
+ }
+
+ SOrderOperatorInfo* pInfo = pOperator->info;
+
+ SSDataBlock* pBlock = NULL;
+ while(1) {
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
+ pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+ publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+
+ // start to flush data into disk and try do multiway merge sort
+ if (pBlock == NULL) {
+ doSetOperatorCompleted(pOperator);
+ break;
+ }
+
+ int32_t code = doMergeSDatablock(pInfo->pDataBlock, pBlock);
+ if (code != TSDB_CODE_SUCCESS) {
+ // todo handle error
+ }
+ }
+
+ int32_t numOfCols = pInfo->pDataBlock->info.numOfCols;
+ void** pCols = calloc(numOfCols, POINTER_BYTES);
+ SSchema* pSchema = calloc(numOfCols, sizeof(SSchema));
+
+ for(int32_t i = 0; i < numOfCols; ++i) {
+ SColumnInfoData* p1 = taosArrayGet(pInfo->pDataBlock->pDataBlock, i);
+ pCols[i] = p1->pData;
+ pSchema[i].colId = p1->info.colId;
+ pSchema[i].bytes = p1->info.bytes;
+ pSchema[i].type = (uint8_t) p1->info.type;
+ }
+
+ __compar_fn_t comp = getKeyComparFunc(pSchema[pInfo->colIndex].type, pInfo->order);
+ if (pInfo->pDataBlock->info.rows) {
+ taoscQSort(pCols, pSchema, numOfCols, pInfo->pDataBlock->info.rows, pInfo->colIndex, comp);
+ }
+
+ tfree(pCols);
+ tfree(pSchema);
+ return (pInfo->pDataBlock->info.rows > 0)? pInfo->pDataBlock:NULL;
+}
+
+SOperatorInfo *createOrderOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, SOrderVal* pOrderVal) {
+ SOrderOperatorInfo* pInfo = calloc(1, sizeof(SOrderOperatorInfo));
+
+ {
+ SSDataBlock* pDataBlock = calloc(1, sizeof(SSDataBlock));
+ pDataBlock->pDataBlock = taosArrayInit(numOfOutput, sizeof(SColumnInfoData));
+ for(int32_t i = 0; i < numOfOutput; ++i) {
+ SColumnInfoData col = {{0}};
+ col.info.colId = pExpr[i].base.colInfo.colId;
+ col.info.bytes = pExpr[i].base.colBytes;
+ col.info.type = pExpr[i].base.colType;
+ taosArrayPush(pDataBlock->pDataBlock, &col);
+
+ if (col.info.colId == pOrderVal->orderColId) {
+ pInfo->colIndex = i;
+ }
+ }
+
+ pDataBlock->info.numOfCols = numOfOutput;
+ pInfo->order = pOrderVal->order;
+ pInfo->pDataBlock = pDataBlock;
+ }
+
+ SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
+ pOperator->name = "InMemoryOrder";
+ pOperator->operatorType = OP_Order;
+ pOperator->blockingOptr = true;
+ pOperator->status = OP_IN_EXECUTING;
+ pOperator->info = pInfo;
+ pOperator->exec = doSort;
+ pOperator->cleanup = destroyOrderOperatorInfo;
+ pOperator->pRuntimeEnv = pRuntimeEnv;
+
+ appendUpstream(pOperator, upstream);
+ return pOperator;
+}
+
static int32_t getTableScanOrder(STableScanInfo* pTableScanInfo) {
return pTableScanInfo->order;
}
@@ -5451,8 +5612,7 @@ static SSDataBlock* doAggregate(void* param, bool* newgroup) {
doAggregateImpl(pOperator, pQueryAttr->window.skey, pInfo->pCtx, pBlock);
}
- pOperator->status = OP_EXEC_DONE;
- setQueryStatus(pRuntimeEnv, QUERY_COMPLETED);
+ doSetOperatorCompleted(pOperator);
finalizeQueryResult(pOperator, pInfo->pCtx, &pInfo->resultRowInfo, pInfo->rowCellInfoOffset);
pInfo->pRes->info.rows = getNumOfResult(pRuntimeEnv, pInfo->pCtx, pOperator->numOfOutput);
@@ -5528,7 +5688,7 @@ static SSDataBlock* doSTableAggregate(void* param, bool* newgroup) {
toSSDataBlock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pInfo->pRes);
if (pInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) {
- pOperator->status = OP_EXEC_DONE;
+ doSetOperatorCompleted(pOperator);
}
return pInfo->pRes;
@@ -5569,6 +5729,7 @@ static SSDataBlock* doProjectOperation(void* param, bool* newgroup) {
pRes->info.rows = getNumOfResult(pRuntimeEnv, pInfo->pCtx, pOperator->numOfOutput);
if (pRes->info.rows >= pRuntimeEnv->resultInfo.threshold) {
+ copyTsColoum(pRes, pInfo->pCtx, pOperator->numOfOutput);
clearNumOfRes(pInfo->pCtx, pOperator->numOfOutput);
return pRes;
}
@@ -5594,8 +5755,7 @@ static SSDataBlock* doProjectOperation(void* param, bool* newgroup) {
if (*newgroup) {
if (pRes->info.rows > 0) {
pProjectInfo->existDataBlock = pBlock;
- clearNumOfRes(pInfo->pCtx, pOperator->numOfOutput);
- return pInfo->pRes;
+ break;
} else { // init output buffer for a new group data
for (int32_t j = 0; j < pOperator->numOfOutput; ++j) {
aAggs[pInfo->pCtx[j].functionId].xFinalize(&pInfo->pCtx[j]);
@@ -5625,7 +5785,7 @@ static SSDataBlock* doProjectOperation(void* param, bool* newgroup) {
break;
}
}
-
+ copyTsColoum(pRes, pInfo->pCtx, pOperator->numOfOutput);
clearNumOfRes(pInfo->pCtx, pOperator->numOfOutput);
return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL;
}
@@ -5646,8 +5806,7 @@ static SSDataBlock* doLimit(void* param, bool* newgroup) {
publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
if (pBlock == NULL) {
- setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
+ doSetOperatorCompleted(pOperator);
return NULL;
}
@@ -5675,8 +5834,7 @@ static SSDataBlock* doLimit(void* param, bool* newgroup) {
pBlock->info.rows = (int32_t)(pInfo->limit - pInfo->total);
pInfo->total = pInfo->limit;
- setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
+ doSetOperatorCompleted(pOperator);
} else {
pInfo->total += pBlock->info.rows;
}
@@ -5711,8 +5869,7 @@ static SSDataBlock* doFilter(void* param, bool* newgroup) {
}
}
- setQueryStatus(pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
+ doSetOperatorCompleted(pOperator);
return NULL;
}
@@ -5727,9 +5884,8 @@ static SSDataBlock* doIntervalAgg(void* param, bool* newgroup) {
SQueryRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv;
if (pOperator->status == OP_RES_TO_RETURN) {
toSSDataBlock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pIntervalInfo->pRes);
-
if (pIntervalInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) {
- pOperator->status = OP_EXEC_DONE;
+ doSetOperatorCompleted(pOperator);
}
return pIntervalInfo->pRes;
@@ -5770,7 +5926,7 @@ static SSDataBlock* doIntervalAgg(void* param, bool* newgroup) {
toSSDataBlock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pIntervalInfo->pRes);
if (pIntervalInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) {
- pOperator->status = OP_EXEC_DONE;
+ doSetOperatorCompleted(pOperator);
}
return pIntervalInfo->pRes->info.rows == 0? NULL:pIntervalInfo->pRes;
@@ -5789,7 +5945,7 @@ static SSDataBlock* doAllIntervalAgg(void* param, bool* newgroup) {
toSSDataBlock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pIntervalInfo->pRes);
if (pIntervalInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) {
- pOperator->status = OP_EXEC_DONE;
+ doSetOperatorCompleted(pOperator);
}
return pIntervalInfo->pRes;
@@ -5848,7 +6004,7 @@ static SSDataBlock* doSTableIntervalAgg(void* param, bool* newgroup) {
if (pOperator->status == OP_RES_TO_RETURN) {
copyToSDataBlock(pRuntimeEnv, 3000, pIntervalInfo->pRes, pIntervalInfo->rowCellInfoOffset);
if (pIntervalInfo->pRes->info.rows == 0 || !hasRemainData(&pRuntimeEnv->groupResInfo)) {
- pOperator->status = OP_EXEC_DONE;
+ doSetOperatorCompleted(pOperator);
}
return pIntervalInfo->pRes;
@@ -6203,34 +6359,48 @@ static SSDataBlock* hashGroupbyAggregate(void* param, bool* newgroup) {
return pInfo->binfo.pRes;
}
-static SSDataBlock* doFill(void* param, bool* newgroup) {
- SOperatorInfo* pOperator = (SOperatorInfo*) param;
- if (pOperator->status == OP_EXEC_DONE) {
- return NULL;
- }
+static void doHandleRemainBlockForNewGroupImpl(SFillOperatorInfo *pInfo, SQueryRuntimeEnv* pRuntimeEnv, bool* newgroup) {
+ pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
+ int64_t ekey = Q_STATUS_EQUAL(pRuntimeEnv->status, QUERY_COMPLETED)?pRuntimeEnv->pQueryAttr->window.ekey:pInfo->existNewGroupBlock->info.window.ekey;
+ taosResetFillInfo(pInfo->pFillInfo, pInfo->pFillInfo->start);
- SFillOperatorInfo *pInfo = pOperator->info;
- SQueryRuntimeEnv *pRuntimeEnv = pOperator->pRuntimeEnv;
+ taosFillSetStartInfo(pInfo->pFillInfo, pInfo->existNewGroupBlock->info.rows, ekey);
+ taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->existNewGroupBlock);
+ doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity, pInfo->p);
+ pInfo->existNewGroupBlock = NULL;
+ *newgroup = true;
+}
+
+static void doHandleRemainBlockFromNewGroup(SFillOperatorInfo *pInfo, SQueryRuntimeEnv *pRuntimeEnv, bool *newgroup) {
if (taosFillHasMoreResults(pInfo->pFillInfo)) {
*newgroup = false;
- doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, (int32_t)pRuntimeEnv->resultInfo.capacity);
- return pInfo->pRes;
+ doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, (int32_t)pRuntimeEnv->resultInfo.capacity, pInfo->p);
+ if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold || (!pInfo->multigroupResult)) {
+ return;
+ }
}
// handle the cached new group data block
if (pInfo->existNewGroupBlock) {
- pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
- int64_t ekey = Q_STATUS_EQUAL(pRuntimeEnv->status, QUERY_COMPLETED)?pRuntimeEnv->pQueryAttr->window.ekey:pInfo->existNewGroupBlock->info.window.ekey;
- taosResetFillInfo(pInfo->pFillInfo, pInfo->pFillInfo->start);
+ doHandleRemainBlockForNewGroupImpl(pInfo, pRuntimeEnv, newgroup);
+ }
+}
- taosFillSetStartInfo(pInfo->pFillInfo, pInfo->existNewGroupBlock->info.rows, ekey);
- taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->existNewGroupBlock);
+static SSDataBlock* doFill(void* param, bool* newgroup) {
+ SOperatorInfo* pOperator = (SOperatorInfo*) param;
- doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity);
- pInfo->existNewGroupBlock = NULL;
- *newgroup = true;
- return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL;
+ SFillOperatorInfo *pInfo = pOperator->info;
+ pInfo->pRes->info.rows = 0;
+
+ if (pOperator->status == OP_EXEC_DONE) {
+ return NULL;
+ }
+
+ SQueryRuntimeEnv *pRuntimeEnv = pOperator->pRuntimeEnv;
+ doHandleRemainBlockFromNewGroup(pInfo, pRuntimeEnv, newgroup);
+ if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold || (!pInfo->multigroupResult && pInfo->pRes->info.rows > 0)) {
+ return pInfo->pRes;
}
while(1) {
@@ -6246,8 +6416,8 @@ static SSDataBlock* doFill(void* param, bool* newgroup) {
pInfo->existNewGroupBlock = pBlock;
*newgroup = false;
- // fill the previous group data block
- // before handle a new data block, close the fill operation for previous group data block
+ // Fill the previous group data block, before handle the data block of new group.
+ // Close the fill operation for previous group data block
taosFillSetStartInfo(pInfo->pFillInfo, 0, pRuntimeEnv->pQueryAttr->window.ekey);
} else {
if (pBlock == NULL) {
@@ -6259,36 +6429,36 @@ static SSDataBlock* doFill(void* param, bool* newgroup) {
taosFillSetStartInfo(pInfo->pFillInfo, 0, pRuntimeEnv->pQueryAttr->window.ekey);
} else {
pInfo->totalInputRows += pBlock->info.rows;
-
- int64_t ekey = /*Q_STATUS_EQUAL(pRuntimeEnv->status, QUERY_COMPLETED) ? pRuntimeEnv->pQueryAttr->window.ekey
- : */pBlock->info.window.ekey;
-
- taosFillSetStartInfo(pInfo->pFillInfo, pBlock->info.rows, ekey);
+ taosFillSetStartInfo(pInfo->pFillInfo, pBlock->info.rows, pBlock->info.window.ekey);
taosFillSetInputDataBlock(pInfo->pFillInfo, pBlock);
}
}
- doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity);
- if (pInfo->pRes->info.rows > 0) { // current group has no more result to return
- return pInfo->pRes;
- } else if (pInfo->existNewGroupBlock) { // try next group
- pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
- int64_t ekey = /*Q_STATUS_EQUAL(pRuntimeEnv->status, QUERY_COMPLETED) ? pRuntimeEnv->pQueryAttr->window.ekey
- :*/ pInfo->existNewGroupBlock->info.window.ekey;
- taosResetFillInfo(pInfo->pFillInfo, pInfo->pFillInfo->start);
+ doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity, pInfo->p);
- taosFillSetStartInfo(pInfo->pFillInfo, pInfo->existNewGroupBlock->info.rows, ekey);
- taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->existNewGroupBlock);
+ // current group has no more result to return
+ if (pInfo->pRes->info.rows > 0) {
+ // 1. The result in current group not reach the threshold of output result, continue
+ // 2. If multiple group results existing in one SSDataBlock is not allowed, return immediately
+ if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold || pBlock == NULL || (!pInfo->multigroupResult)) {
+ return pInfo->pRes;
+ }
- doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity);
- pInfo->existNewGroupBlock = NULL;
- *newgroup = true;
+ doHandleRemainBlockFromNewGroup(pInfo, pRuntimeEnv, newgroup);
+ if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold || pBlock == NULL) {
+ return pInfo->pRes;
+ }
- return (pInfo->pRes->info.rows > 0) ? pInfo->pRes : NULL;
+ } else if (pInfo->existNewGroupBlock) { // try next group
+ assert(pBlock != NULL);
+ doHandleRemainBlockForNewGroupImpl(pInfo, pRuntimeEnv, newgroup);
+
+ if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold) {
+ return pInfo->pRes;
+ }
} else {
return NULL;
}
- // return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL;
}
}
@@ -6389,6 +6559,7 @@ static void destroySFillOperatorInfo(void* param, int32_t numOfOutput) {
SFillOperatorInfo* pInfo = (SFillOperatorInfo*) param;
pInfo->pFillInfo = taosDestroyFillInfo(pInfo->pFillInfo);
pInfo->pRes = destroyOutputBuf(pInfo->pRes);
+ tfree(pInfo->p);
}
static void destroyGroupbyOperatorInfo(void* param, int32_t numOfOutput) {
@@ -6407,6 +6578,11 @@ static void destroyTagScanOperatorInfo(void* param, int32_t numOfOutput) {
pInfo->pRes = destroyOutputBuf(pInfo->pRes);
}
+static void destroyOrderOperatorInfo(void* param, int32_t numOfOutput) {
+ SOrderOperatorInfo* pInfo = (SOrderOperatorInfo*) param;
+ pInfo->pDataBlock = destroyOutputBuf(pInfo->pDataBlock);
+}
+
static void destroyConditionOperatorInfo(void* param, int32_t numOfOutput) {
SFilterOperatorInfo* pInfo = (SFilterOperatorInfo*) param;
doDestroyFilterInfo(pInfo->pFilterInfo, pInfo->numOfFilterCols);
@@ -6415,6 +6591,8 @@ static void destroyConditionOperatorInfo(void* param, int32_t numOfOutput) {
static void destroyDistinctOperatorInfo(void* param, int32_t numOfOutput) {
SDistinctOperatorInfo* pInfo = (SDistinctOperatorInfo*) param;
taosHashCleanup(pInfo->pSet);
+ tfree(pInfo->buf);
+ taosArrayDestroy(pInfo->pDistinctDataInfo);
pInfo->pRes = destroyOutputBuf(pInfo->pRes);
}
@@ -6725,10 +6903,10 @@ SOperatorInfo* createGroupbyOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperato
return pOperator;
}
-SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
- int32_t numOfOutput) {
+SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, bool multigroupResult) {
SFillOperatorInfo* pInfo = calloc(1, sizeof(SFillOperatorInfo));
pInfo->pRes = createOutputBuf(pExpr, numOfOutput, pRuntimeEnv->resultInfo.capacity);
+ pInfo->multigroupResult = multigroupResult;
{
SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
@@ -6743,6 +6921,8 @@ SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorIn
taosCreateFillInfo(pQueryAttr->order.order, w.skey, 0, (int32_t)pRuntimeEnv->resultInfo.capacity, numOfOutput,
pQueryAttr->interval.sliding, pQueryAttr->interval.slidingUnit,
(int8_t)pQueryAttr->precision, pQueryAttr->fillType, pColInfo, pRuntimeEnv->qinfo);
+
+ pInfo->p = calloc(pInfo->pFillInfo->numOfCols, POINTER_BYTES);
}
SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
@@ -6755,7 +6935,6 @@ SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorIn
pOperator->numOfOutput = numOfOutput;
pOperator->info = pInfo;
pOperator->pRuntimeEnv = pRuntimeEnv;
-
pOperator->exec = doFill;
pOperator->cleanup = destroySFillOperatorInfo;
@@ -6763,7 +6942,7 @@ SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorIn
return pOperator;
}
-SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* pMerger) {
+SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* pMerger, bool multigroupResult) {
SSLimitOperatorInfo* pInfo = calloc(1, sizeof(SSLimitOperatorInfo));
SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
@@ -6771,9 +6950,11 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
pInfo->orderColumnList = getResultGroupCheckColumns(pQueryAttr);
pInfo->slimit = pQueryAttr->slimit;
pInfo->limit = pQueryAttr->limit;
-
+ pInfo->capacity = pRuntimeEnv->resultInfo.capacity;
+ pInfo->threshold = (int64_t) (pInfo->capacity * 0.8);
+ pInfo->currentOffset = pQueryAttr->limit.offset;
pInfo->currentGroupOffset = pQueryAttr->slimit.offset;
- pInfo->currentOffset = pQueryAttr->limit.offset;
+ pInfo->multigroupResult= multigroupResult;
// TODO refactor
int32_t len = 0;
@@ -6781,10 +6962,10 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
len += pExpr[i].base.resBytes;
}
- int32_t numOfCols = pInfo->orderColumnList != NULL? (int32_t) taosArrayGetSize(pInfo->orderColumnList):0;
+ int32_t numOfCols = (pInfo->orderColumnList != NULL)? (int32_t) taosArrayGetSize(pInfo->orderColumnList):0;
pInfo->prevRow = calloc(1, (POINTER_BYTES * numOfCols + len));
- int32_t offset = POINTER_BYTES * numOfCols;
+ int32_t offset = POINTER_BYTES * numOfCols;
for(int32_t i = 0; i < numOfCols; ++i) {
pInfo->prevRow[i] = (char*)pInfo->prevRow + offset;
@@ -6792,6 +6973,8 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
offset += pExpr[index->colIndex].base.resBytes;
}
+ pInfo->pRes = createOutputBuf(pExpr, numOfOutput, pRuntimeEnv->resultInfo.capacity);
+
SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
pOperator->name = "SLimitOperator";
@@ -6957,6 +7140,52 @@ SOperatorInfo* createTagScanOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInf
return pOperator;
}
+static bool initMultiDistinctInfo(SDistinctOperatorInfo *pInfo, SOperatorInfo* pOperator, SSDataBlock *pBlock) {
+ if (taosArrayGetSize(pInfo->pDistinctDataInfo) == pOperator->numOfOutput) {
+ // distinct info already inited
+ return true;
+ }
+ for (int i = 0; i < pOperator->numOfOutput; i++) {
+ pInfo->totalBytes += pOperator->pExpr[i].base.colBytes;
+ }
+ for (int i = 0; i < pOperator->numOfOutput; i++) {
+ int numOfBlock = (int)taosArrayGetSize(pBlock->pDataBlock);
+ assert(i < numOfBlock);
+ for (int j = 0; j < numOfBlock; j++) {
+ SColumnInfoData* pColDataInfo = taosArrayGet(pBlock->pDataBlock, j);
+ if (pColDataInfo->info.colId == pOperator->pExpr[i].base.resColId) {
+ SDistinctDataInfo item = {.index = j, .type = pColDataInfo->info.type, .bytes = pColDataInfo->info.bytes};
+ taosArrayInsert(pInfo->pDistinctDataInfo, i, &item);
+ }
+ }
+ }
+ pInfo->totalBytes += (int32_t)strlen(MULTI_KEY_DELIM) * (pOperator->numOfOutput);
+ pInfo->buf = calloc(1, pInfo->totalBytes);
+ return taosArrayGetSize(pInfo->pDistinctDataInfo) == pOperator->numOfOutput ? true : false;
+}
+static void buildMultiDistinctKey(SDistinctOperatorInfo *pInfo, SSDataBlock *pBlock, int32_t rowId) {
+ char *p = pInfo->buf;
+ memset(p, 0, pInfo->totalBytes);
+
+ for (int i = 0; i < taosArrayGetSize(pInfo->pDistinctDataInfo); i++) {
+ SDistinctDataInfo* pDistDataInfo = (SDistinctDataInfo *)taosArrayGet(pInfo->pDistinctDataInfo, i);
+ SColumnInfoData* pColDataInfo = taosArrayGet(pBlock->pDataBlock, pDistDataInfo->index);
+ char *val = ((char *)pColDataInfo->pData) + pColDataInfo->info.bytes * rowId;
+ if (isNull(val, pDistDataInfo->type)) {
+ p += pDistDataInfo->bytes;
+ continue;
+ }
+ if (IS_VAR_DATA_TYPE(pDistDataInfo->type)) {
+ memcpy(p, varDataVal(val), varDataLen(val));
+ p += varDataLen(val);
+ } else {
+ memcpy(p, val, pDistDataInfo->bytes);
+ p += pDistDataInfo->bytes;
+ }
+ memcpy(p, MULTI_KEY_DELIM, strlen(MULTI_KEY_DELIM));
+ p += strlen(MULTI_KEY_DELIM);
+ }
+}
static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
SOperatorInfo* pOperator = (SOperatorInfo*) param;
@@ -6964,11 +7193,9 @@ static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
return NULL;
}
-
SDistinctOperatorInfo* pInfo = pOperator->info;
SSDataBlock* pRes = pInfo->pRes;
-
pRes->info.rows = 0;
SSDataBlock* pBlock = NULL;
while(1) {
@@ -6977,81 +7204,62 @@ static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
if (pBlock == NULL) {
- setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
+ doSetOperatorCompleted(pOperator);
break;
}
- if (pInfo->colIndex == -1) {
- for (int i = 0; i < taosArrayGetSize(pBlock->pDataBlock); i++) {
- SColumnInfoData* pColDataInfo = taosArrayGet(pBlock->pDataBlock, i);
- if (pColDataInfo->info.colId == pOperator->pExpr[0].base.resColId) {
- pInfo->colIndex = i;
- break;
+ if (!initMultiDistinctInfo(pInfo, pOperator, pBlock)) {
+ doSetOperatorCompleted(pOperator);
+ break;
+ }
+
+ // ensure result output buf
+ if (pRes->info.rows + pBlock->info.rows > pInfo->outputCapacity) {
+ int32_t newSize = pRes->info.rows + pBlock->info.rows;
+ for (int i = 0; i < taosArrayGetSize(pRes->pDataBlock); i++) {
+ SColumnInfoData* pResultColInfoData = taosArrayGet(pRes->pDataBlock, i);
+ SDistinctDataInfo* pDistDataInfo = taosArrayGet(pInfo->pDistinctDataInfo, i);
+ char* tmp = realloc(pResultColInfoData->pData, newSize * pDistDataInfo->bytes);
+ if (tmp == NULL) {
+ return NULL;
+ } else {
+ pResultColInfoData->pData = tmp;
+ }
}
- }
- }
- if (pInfo->colIndex == -1) {
- setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
- pOperator->status = OP_EXEC_DONE;
- return NULL;
- }
- SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pInfo->colIndex);
-
- int16_t bytes = pColInfoData->info.bytes;
- int16_t type = pColInfoData->info.type;
-
- // ensure the output buffer size
- SColumnInfoData* pResultColInfoData = taosArrayGet(pRes->pDataBlock, 0);
- if (pRes->info.rows + pBlock->info.rows > pInfo->outputCapacity) {
- int32_t newSize = pRes->info.rows + pBlock->info.rows;
- char* tmp = realloc(pResultColInfoData->pData, newSize * bytes);
- if (tmp == NULL) {
- return NULL;
- } else {
- pResultColInfoData->pData = tmp;
pInfo->outputCapacity = newSize;
- }
- }
-
- for(int32_t i = 0; i < pBlock->info.rows; ++i) {
- char* val = ((char*)pColInfoData->pData) + bytes * i;
- if (isNull(val, type)) {
- continue;
- }
- char* p = val;
- size_t keyLen = 0;
- if (IS_VAR_DATA_TYPE(pOperator->pExpr->base.colType)) {
- tstr* var = (tstr*)(val);
- p = var->data;
- keyLen = varDataLen(var);
- } else {
- keyLen = bytes;
- }
-
- int dummy;
- void* res = taosHashGet(pInfo->pSet, p, keyLen);
- if (res == NULL) {
- taosHashPut(pInfo->pSet, p, keyLen, &dummy, sizeof(dummy));
- char* start = pResultColInfoData->pData + bytes * pInfo->pRes->info.rows;
- memcpy(start, val, bytes);
+ }
+ for (int32_t i = 0; i < pBlock->info.rows; i++) {
+ buildMultiDistinctKey(pInfo, pBlock, i);
+ if (taosHashGet(pInfo->pSet, pInfo->buf, pInfo->totalBytes) == NULL) {
+ int32_t dummy;
+ taosHashPut(pInfo->pSet, pInfo->buf, pInfo->totalBytes, &dummy, sizeof(dummy));
+ for (int j = 0; j < taosArrayGetSize(pRes->pDataBlock); j++) {
+ SDistinctDataInfo* pDistDataInfo = taosArrayGet(pInfo->pDistinctDataInfo, j); // distinct meta info
+ SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pDistDataInfo->index); //src
+ SColumnInfoData* pResultColInfoData = taosArrayGet(pRes->pDataBlock, j); // dist
+ char* val = ((char*)pColInfoData->pData) + pDistDataInfo->bytes * i;
+ char *start = pResultColInfoData->pData + pDistDataInfo->bytes * pInfo->pRes->info.rows;
+ memcpy(start, val, pDistDataInfo->bytes);
+ }
pRes->info.rows += 1;
- }
- }
+ }
+ }
if (pRes->info.rows >= pInfo->threshold) {
break;
}
}
-
return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL;
}
SOperatorInfo* createDistinctOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput) {
SDistinctOperatorInfo* pInfo = calloc(1, sizeof(SDistinctOperatorInfo));
- pInfo->colIndex = -1;
- pInfo->threshold = 10000000; // distinct result threshold
- pInfo->outputCapacity = 4096;
- pInfo->pSet = taosHashInit(64, taosGetDefaultHashFunction(pExpr->base.colType), false, HASH_NO_LOCK);
+
+ pInfo->totalBytes = 0;
+ pInfo->buf = NULL;
+ pInfo->threshold = tsMaxNumOfDistinctResults; // distinct result threshold
+ pInfo->outputCapacity = 4096;
+ pInfo->pDistinctDataInfo = taosArrayInit(numOfOutput, sizeof(SDistinctDataInfo));
+ pInfo->pSet = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
pInfo->pRes = createOutputBuf(pExpr, numOfOutput, (int32_t) pInfo->outputCapacity);
SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
@@ -7257,10 +7465,12 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
pQueryMsg->numOfOutput = htons(pQueryMsg->numOfOutput);
pQueryMsg->numOfGroupCols = htons(pQueryMsg->numOfGroupCols);
pQueryMsg->tagCondLen = htonl(pQueryMsg->tagCondLen);
+
pQueryMsg->tsBuf.tsOffset = htonl(pQueryMsg->tsBuf.tsOffset);
pQueryMsg->tsBuf.tsLen = htonl(pQueryMsg->tsBuf.tsLen);
pQueryMsg->tsBuf.tsNumOfBlocks = htonl(pQueryMsg->tsBuf.tsNumOfBlocks);
pQueryMsg->tsBuf.tsOrder = htonl(pQueryMsg->tsBuf.tsOrder);
+
pQueryMsg->numOfTags = htonl(pQueryMsg->numOfTags);
pQueryMsg->tbnameCondLen = htonl(pQueryMsg->tbnameCondLen);
pQueryMsg->secondStageOutput = htonl(pQueryMsg->secondStageOutput);
diff --git a/src/query/src/qExtbuffer.c b/src/query/src/qExtbuffer.c
index cc47cc824bcf59f0839bc5a439d4d15b89e030ea..5152d172649eb91c20ce09c0bf369a5cc3c8de43 100644
--- a/src/query/src/qExtbuffer.c
+++ b/src/query/src/qExtbuffer.c
@@ -1102,3 +1102,57 @@ void tOrderDescDestroy(tOrderDescriptor *pDesc) {
destroyColumnModel(pDesc->pColumnModel);
tfree(pDesc);
}
+
+void taoscQSort(void** pCols, SSchema* pSchema, int32_t numOfCols, int32_t numOfRows, int32_t index, __compar_fn_t compareFn) {
+ assert(numOfRows > 0 && numOfCols > 0 && index >= 0 && index < numOfCols);
+
+ int32_t bytes = pSchema[index].bytes;
+ int32_t size = bytes + sizeof(int32_t);
+
+ char* buf = calloc(1, size * numOfRows);
+
+ for(int32_t i = 0; i < numOfRows; ++i) {
+ char* dest = buf + size * i;
+ memcpy(dest, ((char*) pCols[index]) + bytes * i, bytes);
+ *(int32_t*)(dest+bytes) = i;
+ }
+
+ qsort(buf, numOfRows, size, compareFn);
+
+ int32_t prevLength = 0;
+ char* p = NULL;
+
+ for(int32_t i = 0; i < numOfCols; ++i) {
+ int32_t bytes1 = pSchema[i].bytes;
+
+ if (i == index) {
+ for(int32_t j = 0; j < numOfRows; ++j){
+ char* src = buf + (j * size);
+ char* dest = ((char*)pCols[i]) + (j * bytes1);
+ memcpy(dest, src, bytes1);
+ }
+ } else {
+ // make sure memory buffer is enough
+ if (prevLength < bytes1) {
+ char *tmp = realloc(p, bytes1 * numOfRows);
+ assert(tmp);
+
+ p = tmp;
+ prevLength = bytes1;
+ }
+
+ memcpy(p, pCols[i], bytes1 * numOfRows);
+
+ for(int32_t j = 0; j < numOfRows; ++j){
+ char* dest = ((char*)pCols[i]) + bytes1 * j;
+
+ int32_t newPos = *(int32_t*)(buf + (j * size) + bytes);
+ char* src = p + (newPos * bytes1);
+ memcpy(dest, src, bytes1);
+ }
+ }
+ }
+
+ tfree(buf);
+ tfree(p);
+}
\ No newline at end of file
diff --git a/src/query/src/qFill.c b/src/query/src/qFill.c
index 1a86bbae36697224585522b5be836c61394c7cc4..cdcc164152dddbc34d03508a2bdd7379d6e50892 100644
--- a/src/query/src/qFill.c
+++ b/src/query/src/qFill.c
@@ -430,7 +430,7 @@ void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput)
SColumnInfoData* pColData = taosArrayGet(pInput->pDataBlock, i);
pFillInfo->pData[i] = pColData->pData;
- if (TSDB_COL_IS_TAG(pCol->flag)/* || IS_VAR_DATA_TYPE(pCol->col.type)*/) { // copy the tag value to tag value buffer
+ if (TSDB_COL_IS_TAG(pCol->flag)) { // copy the tag value to tag value buffer
SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
assert (pTag->col.colId == pCol->col.colId);
memcpy(pTag->tagVal, pColData->pData, pCol->col.bytes); // TODO not memcpy??
diff --git a/src/query/src/qPercentile.c b/src/query/src/qPercentile.c
index e3326cc26bc4216d131211473e807a9845d49133..024ba77de13086b7ff8e32ab2c4c7340d8806b6b 100644
--- a/src/query/src/qPercentile.c
+++ b/src/query/src/qPercentile.c
@@ -67,10 +67,18 @@ static int32_t setBoundingBox(MinMaxEntry* range, int16_t type, double minval, d
if (IS_SIGNED_NUMERIC_TYPE(type)) {
range->i64MinVal = (int64_t) minval;
- range->i64MaxVal = (int64_t) maxval;
+ if (maxval > INT64_MAX || (int64_t)maxval == INT64_MIN) {
+ range->i64MaxVal = INT64_MAX;
+ } else {
+ range->i64MaxVal = (int64_t) maxval;
+ }
} else if (IS_UNSIGNED_NUMERIC_TYPE(type)){
range->u64MinVal = (uint64_t) minval;
- range->u64MaxVal = (uint64_t) maxval;
+ if ((uint64_t)maxval > UINT64_MAX) {
+ range->u64MaxVal = UINT64_MAX;
+ } else {
+ range->u64MaxVal = (uint64_t) maxval;
+ }
} else {
range->dMinVal = minval;
range->dMaxVal = maxval;
@@ -127,8 +135,8 @@ int32_t tBucketIntHash(tMemBucket *pBucket, const void *value) {
index = (delta % pBucket->numOfSlots);
} else {
double slotSpan = (double)span / pBucket->numOfSlots;
- index = (int32_t)((v - pBucket->range.i64MinVal) / slotSpan);
- if (v == pBucket->range.i64MaxVal) {
+ index = (int32_t)(((double)v - pBucket->range.i64MinVal) / slotSpan);
+ if (index == pBucket->numOfSlots) {
index -= 1;
}
}
@@ -237,7 +245,7 @@ tMemBucket *tMemBucketCreate(int16_t nElemSize, int16_t dataType, double minval,
}
pBucket->elemPerPage = (pBucket->bufPageSize - sizeof(tFilePage))/pBucket->bytes;
- pBucket->comparFn = getKeyComparFunc(pBucket->type);
+ pBucket->comparFn = getKeyComparFunc(pBucket->type, TSDB_ORDER_ASC);
pBucket->hashFunc = getHashFunc(pBucket->type);
if (pBucket->hashFunc == NULL) {
diff --git a/src/query/src/qPlan.c b/src/query/src/qPlan.c
index b8a5ee7699b34fed82ad67a592a6ca9148cc92cb..1988fc9df7710f15770ca8a9994542d9f4bc8c66 100644
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -557,10 +557,9 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
int32_t op = 0;
if (onlyQueryTags(pQueryAttr)) { // do nothing for tags query
- if (onlyQueryTags(pQueryAttr)) {
- op = OP_TagScan;
- taosArrayPush(plan, &op);
- }
+ op = OP_TagScan;
+ taosArrayPush(plan, &op);
+
if (pQueryAttr->distinct) {
op = OP_Distinct;
taosArrayPush(plan, &op);
@@ -651,8 +650,14 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
taosArrayPush(plan, &op);
}
}
+
+ // outer query order by support
+ int32_t orderColId = pQueryAttr->order.orderColId;
+ if (pQueryAttr->vgId == 0 && orderColId != PRIMARYKEY_TIMESTAMP_COL_INDEX && orderColId != INT32_MIN) {
+ op = OP_Order;
+ taosArrayPush(plan, &op);
+ }
}
-
if (pQueryAttr->limit.limit > 0 || pQueryAttr->limit.offset > 0) {
op = OP_Limit;
@@ -693,7 +698,7 @@ SArray* createGlobalMergePlan(SQueryAttr* pQueryAttr) {
}
// fill operator
- if (pQueryAttr->fillType != TSDB_FILL_NONE && (!pQueryAttr->pointInterpQuery)) {
+ if (pQueryAttr->fillType != TSDB_FILL_NONE && pQueryAttr->interval.interval > 0) {
op = OP_Fill;
taosArrayPush(plan, &op);
}
diff --git a/src/query/src/qTsbuf.c b/src/query/src/qTsbuf.c
index 825b7960defc2547dfd7248bdc15d157e5808b24..99572f6e9345b933434e3685ecb79750a04388fc 100644
--- a/src/query/src/qTsbuf.c
+++ b/src/query/src/qTsbuf.c
@@ -223,8 +223,11 @@ static STSGroupBlockInfoEx* addOneGroupInfo(STSBuf* pTSBuf, int32_t id) {
static void shrinkBuffer(STSList* ptsData) {
// shrink tmp buffer size if it consumes too many memory compared to the pre-defined size
if (ptsData->allocSize >= ptsData->threshold * 2) {
- ptsData->rawBuf = realloc(ptsData->rawBuf, MEM_BUF_SIZE);
- ptsData->allocSize = MEM_BUF_SIZE;
+ char* rawBuf = realloc(ptsData->rawBuf, MEM_BUF_SIZE);
+ if(rawBuf) {
+ ptsData->rawBuf = rawBuf;
+ ptsData->allocSize = MEM_BUF_SIZE;
+ }
}
}
@@ -372,6 +375,16 @@ STSBlock* readDataFromDisk(STSBuf* pTSBuf, int32_t order, bool decomp) {
sz = fread(pBlock->payload, (size_t)pBlock->compLen, 1, pTSBuf->f);
if (decomp) {
+ if (pBlock->numOfElem * TSDB_KEYSIZE > pTSBuf->tsData.allocSize) {
+ pTSBuf->tsData.rawBuf = realloc(pTSBuf->tsData.rawBuf, pBlock->numOfElem * TSDB_KEYSIZE);
+ pTSBuf->tsData.allocSize = pBlock->numOfElem * TSDB_KEYSIZE;
+ }
+
+ if (pBlock->numOfElem * TSDB_KEYSIZE > pTSBuf->bufSize) {
+ pTSBuf->assistBuf = realloc(pTSBuf->assistBuf, pBlock->numOfElem * TSDB_KEYSIZE);
+ pTSBuf->bufSize = pBlock->numOfElem * TSDB_KEYSIZE;
+ }
+
pTSBuf->tsData.len =
tsDecompressTimestamp(pBlock->payload, pBlock->compLen, pBlock->numOfElem, pTSBuf->tsData.rawBuf,
pTSBuf->tsData.allocSize, TWO_STAGE_COMP, pTSBuf->assistBuf, pTSBuf->bufSize);
@@ -468,7 +481,7 @@ void tsBufAppend(STSBuf* pTSBuf, int32_t id, tVariant* tag, const char* pData, i
// the size of raw data exceeds the size of the default prepared buffer, so
// during getBufBlock, the output buffer needs to be large enough.
- if (ptsData->len >= ptsData->threshold) {
+ if (ptsData->len >= ptsData->threshold - TSDB_KEYSIZE) {
writeDataToDisk(pTSBuf);
shrinkBuffer(ptsData);
}
@@ -600,6 +613,10 @@ static void tsBufGetBlock(STSBuf* pTSBuf, int32_t groupIndex, int32_t blockIndex
expandBuffer(&pTSBuf->tsData, (int32_t)s);
}
+ if (s > pTSBuf->bufSize) {
+ pTSBuf->assistBuf = realloc(pTSBuf->assistBuf, s);
+ pTSBuf->bufSize = (int32_t)s;
+ }
pTSBuf->tsData.len =
tsDecompressTimestamp(pBlock->payload, pBlock->compLen, pBlock->numOfElem, pTSBuf->tsData.rawBuf,
pTSBuf->tsData.allocSize, TWO_STAGE_COMP, pTSBuf->assistBuf, pTSBuf->bufSize);
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index dc5123b7fbbe2b442e8f1c6d8a57b9a6b1d3678c..15b94f6d4ad0badbcb8b4bea662bac888f8b1047 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -97,28 +97,29 @@
#endif
/************* Begin control #defines *****************************************/
#define YYCODETYPE unsigned short int
-#define YYNOCODE 277
+#define YYNOCODE 279
#define YYACTIONTYPE unsigned short int
#define ParseTOKENTYPE SStrToken
typedef union {
int yyinit;
ParseTOKENTYPE yy0;
- TAOS_FIELD yy31;
- int yy52;
- SLimitVal yy126;
- SWindowStateVal yy144;
- SCreateTableSql* yy158;
- SCreateDbInfo yy214;
- SSessionWindowVal yy259;
- tSqlExpr* yy370;
- SRelationInfo* yy412;
- SCreatedTableInfo yy432;
- SSqlNode* yy464;
- int64_t yy501;
- tVariant yy506;
- SIntervalVal yy520;
- SArray* yy525;
- SCreateAcctInfo yy547;
+ SRelationInfo* yy8;
+ SWindowStateVal yy40;
+ SSqlNode* yy56;
+ SCreateDbInfo yy90;
+ int yy96;
+ int32_t yy104;
+ SSessionWindowVal yy147;
+ SCreatedTableInfo yy152;
+ SLimitVal yy166;
+ SCreateAcctInfo yy171;
+ TAOS_FIELD yy183;
+ int64_t yy325;
+ SIntervalVal yy400;
+ SArray* yy421;
+ tVariant yy430;
+ SCreateTableSql* yy438;
+ tSqlExpr* yy439;
} YYMINORTYPE;
#ifndef YYSTACKDEPTH
#define YYSTACKDEPTH 100
@@ -128,17 +129,17 @@ typedef union {
#define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
#define ParseARG_STORE yypParser->pInfo = pInfo
#define YYFALLBACK 1
-#define YYNSTATE 362
-#define YYNRULE 289
-#define YYNTOKEN 195
-#define YY_MAX_SHIFT 361
-#define YY_MIN_SHIFTREDUCE 567
-#define YY_MAX_SHIFTREDUCE 855
-#define YY_ERROR_ACTION 856
-#define YY_ACCEPT_ACTION 857
-#define YY_NO_ACTION 858
-#define YY_MIN_REDUCE 859
-#define YY_MAX_REDUCE 1147
+#define YYNSTATE 364
+#define YYNRULE 292
+#define YYNTOKEN 196
+#define YY_MAX_SHIFT 363
+#define YY_MIN_SHIFTREDUCE 572
+#define YY_MAX_SHIFTREDUCE 863
+#define YY_ERROR_ACTION 864
+#define YY_ACCEPT_ACTION 865
+#define YY_NO_ACTION 866
+#define YY_MIN_REDUCE 867
+#define YY_MAX_REDUCE 1158
/************* End control #defines *******************************************/
/* Define the yytestcase() macro to be a no-op if is not already defined
@@ -204,288 +205,289 @@ typedef union {
** yy_default[] Default action for each state.
**
*********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (753)
+#define YY_ACTTAB_COUNT (758)
static const YYACTIONTYPE yy_action[] = {
- /* 0 */ 206, 618, 245, 618, 618, 97, 244, 228, 359, 619,
- /* 10 */ 1123, 619, 619, 56, 57, 152, 60, 61, 654, 1027,
- /* 20 */ 248, 50, 1036, 59, 317, 64, 62, 65, 63, 984,
- /* 30 */ 249, 982, 983, 55, 54, 231, 985, 53, 52, 51,
- /* 40 */ 986, 1002, 987, 988, 53, 52, 51, 568, 569, 570,
- /* 50 */ 571, 572, 573, 574, 575, 576, 577, 578, 579, 580,
- /* 60 */ 581, 360, 206, 257, 229, 159, 206, 56, 57, 37,
- /* 70 */ 60, 61, 1124, 174, 248, 50, 1124, 59, 317, 64,
- /* 80 */ 62, 65, 63, 277, 276, 29, 79, 55, 54, 1033,
- /* 90 */ 206, 53, 52, 51, 56, 57, 315, 60, 61, 234,
- /* 100 */ 1124, 248, 50, 1014, 59, 317, 64, 62, 65, 63,
- /* 110 */ 358, 357, 144, 230, 55, 54, 85, 1011, 53, 52,
- /* 120 */ 51, 56, 58, 240, 60, 61, 347, 1014, 248, 50,
- /* 130 */ 94, 59, 317, 64, 62, 65, 63, 794, 1073, 242,
- /* 140 */ 289, 55, 54, 1014, 618, 53, 52, 51, 57, 23,
- /* 150 */ 60, 61, 619, 44, 248, 50, 1000, 59, 317, 64,
- /* 160 */ 62, 65, 63, 997, 998, 34, 1001, 55, 54, 857,
- /* 170 */ 361, 53, 52, 51, 43, 313, 354, 353, 312, 311,
- /* 180 */ 310, 352, 309, 308, 307, 351, 306, 350, 349, 976,
- /* 190 */ 964, 965, 966, 967, 968, 969, 970, 971, 972, 973,
- /* 200 */ 974, 975, 977, 978, 60, 61, 24, 1008, 248, 50,
- /* 210 */ 257, 59, 317, 64, 62, 65, 63, 1027, 122, 1027,
- /* 220 */ 175, 55, 54, 37, 209, 53, 52, 51, 247, 809,
- /* 230 */ 347, 215, 798, 232, 801, 270, 804, 135, 134, 214,
- /* 240 */ 315, 247, 809, 322, 85, 798, 14, 801, 37, 804,
- /* 250 */ 93, 159, 726, 241, 203, 723, 800, 724, 803, 725,
- /* 260 */ 226, 227, 257, 16, 318, 15, 37, 238, 5, 40,
- /* 270 */ 178, 1011, 1012, 226, 227, 177, 103, 108, 99, 107,
- /* 280 */ 96, 44, 204, 253, 254, 210, 64, 62, 65, 63,
- /* 290 */ 355, 945, 159, 302, 55, 54, 1010, 251, 53, 52,
- /* 300 */ 51, 1013, 78, 269, 256, 77, 120, 114, 125, 66,
- /* 310 */ 239, 702, 222, 124, 1011, 130, 133, 123, 37, 197,
- /* 320 */ 195, 193, 66, 127, 1072, 37, 192, 139, 138, 137,
- /* 330 */ 136, 799, 159, 802, 37, 43, 999, 354, 353, 337,
- /* 340 */ 336, 37, 352, 262, 810, 805, 351, 37, 350, 349,
- /* 350 */ 37, 806, 266, 265, 742, 55, 54, 810, 805, 53,
- /* 360 */ 52, 51, 326, 291, 806, 90, 1011, 727, 728, 327,
- /* 370 */ 37, 37, 252, 1011, 250, 807, 325, 324, 328, 258,
- /* 380 */ 82, 255, 1011, 332, 331, 329, 150, 148, 147, 1011,
- /* 390 */ 907, 333, 83, 917, 334, 1011, 908, 188, 1011, 271,
- /* 400 */ 188, 739, 92, 188, 70, 91, 1, 176, 3, 189,
- /* 410 */ 775, 776, 758, 38, 335, 339, 80, 273, 1011, 1011,
- /* 420 */ 766, 767, 73, 712, 294, 33, 154, 9, 714, 273,
- /* 430 */ 296, 713, 796, 830, 67, 26, 246, 38, 38, 746,
- /* 440 */ 811, 319, 67, 76, 95, 67, 71, 25, 1120, 617,
- /* 450 */ 808, 132, 131, 113, 25, 112, 1119, 6, 297, 18,
- /* 460 */ 1118, 17, 74, 25, 731, 729, 732, 730, 797, 20,
- /* 470 */ 1083, 19, 119, 224, 118, 701, 22, 225, 21, 207,
- /* 480 */ 208, 211, 205, 212, 213, 217, 218, 219, 216, 202,
- /* 490 */ 1143, 1082, 1135, 236, 267, 1079, 1078, 237, 338, 151,
- /* 500 */ 1035, 1046, 47, 1065, 1043, 149, 1064, 1025, 1028, 1044,
- /* 510 */ 274, 1048, 153, 170, 158, 1009, 278, 285, 171, 1007,
- /* 520 */ 172, 233, 166, 280, 161, 757, 160, 173, 162, 922,
- /* 530 */ 163, 299, 300, 301, 304, 305, 282, 292, 45, 290,
- /* 540 */ 75, 200, 288, 813, 272, 41, 72, 49, 316, 164,
- /* 550 */ 916, 323, 1142, 110, 1141, 1138, 286, 179, 330, 1134,
- /* 560 */ 284, 116, 1133, 1130, 180, 281, 942, 42, 39, 46,
- /* 570 */ 201, 904, 279, 126, 303, 902, 128, 129, 900, 899,
- /* 580 */ 259, 191, 897, 896, 895, 894, 893, 892, 891, 194,
- /* 590 */ 196, 888, 886, 884, 882, 198, 879, 199, 48, 81,
- /* 600 */ 86, 348, 283, 1066, 121, 340, 341, 342, 343, 344,
- /* 610 */ 223, 345, 346, 356, 855, 243, 298, 260, 261, 854,
- /* 620 */ 263, 220, 221, 264, 853, 836, 104, 921, 920, 105,
- /* 630 */ 835, 268, 273, 10, 293, 734, 275, 84, 30, 898,
- /* 640 */ 890, 183, 182, 943, 187, 181, 184, 185, 2, 140,
- /* 650 */ 186, 141, 142, 889, 4, 143, 980, 881, 87, 944,
- /* 660 */ 759, 165, 167, 168, 169, 880, 155, 157, 768, 156,
- /* 670 */ 235, 762, 88, 89, 990, 764, 287, 31, 11, 32,
- /* 680 */ 12, 13, 27, 295, 28, 96, 98, 101, 35, 100,
- /* 690 */ 632, 36, 102, 667, 665, 664, 663, 661, 660, 659,
- /* 700 */ 656, 314, 622, 106, 7, 320, 812, 321, 8, 109,
- /* 710 */ 814, 111, 68, 69, 115, 704, 703, 38, 117, 700,
- /* 720 */ 648, 646, 638, 644, 640, 642, 636, 634, 670, 669,
- /* 730 */ 668, 666, 662, 658, 657, 190, 620, 585, 583, 859,
- /* 740 */ 858, 858, 858, 858, 858, 858, 858, 858, 858, 858,
- /* 750 */ 858, 145, 146,
+ /* 0 */ 170, 624, 236, 624, 230, 361, 1023, 1045, 242, 625,
+ /* 10 */ 247, 625, 1023, 57, 58, 154, 61, 62, 281, 38,
+ /* 20 */ 250, 51, 624, 60, 319, 65, 63, 66, 64, 993,
+ /* 30 */ 625, 991, 992, 56, 55, 161, 994, 54, 53, 52,
+ /* 40 */ 995, 161, 996, 997, 865, 363, 1036, 573, 574, 575,
+ /* 50 */ 576, 577, 578, 579, 580, 581, 582, 583, 584, 585,
+ /* 60 */ 586, 362, 233, 232, 231, 57, 58, 1020, 61, 62,
+ /* 70 */ 208, 660, 250, 51, 1042, 60, 319, 65, 63, 66,
+ /* 80 */ 64, 1135, 1009, 279, 278, 56, 55, 80, 98, 54,
+ /* 90 */ 53, 52, 57, 58, 1036, 61, 62, 208, 86, 250,
+ /* 100 */ 51, 1017, 60, 319, 65, 63, 66, 64, 1134, 1084,
+ /* 110 */ 272, 291, 56, 55, 317, 1083, 54, 53, 52, 57,
+ /* 120 */ 59, 244, 61, 62, 1011, 1023, 250, 51, 95, 60,
+ /* 130 */ 319, 65, 63, 66, 64, 45, 802, 349, 1036, 56,
+ /* 140 */ 55, 161, 1022, 54, 53, 52, 58, 243, 61, 62,
+ /* 150 */ 767, 768, 250, 51, 234, 60, 319, 65, 63, 66,
+ /* 160 */ 64, 1006, 1007, 35, 1010, 56, 55, 317, 246, 54,
+ /* 170 */ 53, 52, 44, 315, 356, 355, 314, 313, 312, 354,
+ /* 180 */ 311, 310, 309, 353, 308, 352, 351, 985, 973, 974,
+ /* 190 */ 975, 976, 977, 978, 979, 980, 981, 982, 983, 984,
+ /* 200 */ 986, 987, 61, 62, 24, 23, 250, 51, 264, 60,
+ /* 210 */ 319, 65, 63, 66, 64, 92, 79, 268, 267, 56,
+ /* 220 */ 55, 123, 211, 54, 53, 52, 249, 817, 208, 217,
+ /* 230 */ 806, 93, 809, 349, 812, 137, 136, 135, 216, 1135,
+ /* 240 */ 249, 817, 324, 86, 806, 81, 809, 259, 812, 251,
+ /* 250 */ 1008, 205, 65, 63, 66, 64, 161, 175, 228, 229,
+ /* 260 */ 56, 55, 320, 916, 54, 53, 52, 5, 41, 179,
+ /* 270 */ 189, 624, 228, 229, 178, 104, 109, 100, 108, 625,
+ /* 280 */ 45, 732, 357, 954, 729, 38, 730, 38, 731, 121,
+ /* 290 */ 115, 126, 253, 304, 38, 16, 125, 15, 131, 134,
+ /* 300 */ 124, 206, 271, 38, 78, 258, 784, 128, 67, 208,
+ /* 310 */ 748, 224, 255, 256, 3, 190, 199, 197, 195, 808,
+ /* 320 */ 1135, 811, 67, 194, 141, 140, 139, 138, 293, 240,
+ /* 330 */ 91, 241, 926, 1020, 44, 1020, 356, 355, 328, 189,
+ /* 340 */ 38, 354, 1020, 818, 813, 353, 38, 352, 351, 708,
+ /* 350 */ 814, 1019, 807, 29, 810, 212, 38, 818, 813, 38,
+ /* 360 */ 1094, 56, 55, 783, 814, 54, 53, 52, 254, 38,
+ /* 370 */ 252, 38, 327, 326, 38, 14, 1131, 339, 338, 94,
+ /* 380 */ 917, 260, 745, 257, 329, 334, 333, 189, 1020, 259,
+ /* 390 */ 330, 54, 53, 52, 1020, 259, 752, 733, 734, 176,
+ /* 400 */ 331, 1, 177, 335, 1020, 1021, 273, 1020, 9, 97,
+ /* 410 */ 83, 84, 34, 336, 71, 337, 764, 1020, 341, 1020,
+ /* 420 */ 39, 774, 1020, 360, 359, 146, 152, 150, 149, 775,
+ /* 430 */ 156, 74, 718, 804, 321, 68, 296, 720, 77, 815,
+ /* 440 */ 248, 133, 132, 26, 298, 299, 39, 275, 275, 719,
+ /* 450 */ 39, 68, 838, 819, 623, 114, 72, 113, 96, 18,
+ /* 460 */ 1130, 17, 6, 68, 1129, 226, 25, 25, 25, 805,
+ /* 470 */ 707, 75, 816, 737, 735, 738, 736, 20, 227, 19,
+ /* 480 */ 120, 22, 119, 21, 209, 210, 213, 207, 214, 1154,
+ /* 490 */ 215, 1146, 1037, 1093, 219, 238, 220, 221, 218, 204,
+ /* 500 */ 1090, 1089, 239, 340, 269, 153, 1044, 1055, 48, 1076,
+ /* 510 */ 1052, 1053, 276, 1075, 1018, 1057, 151, 155, 160, 287,
+ /* 520 */ 171, 172, 280, 1016, 173, 174, 163, 235, 282, 284,
+ /* 530 */ 931, 164, 165, 1034, 166, 763, 301, 821, 302, 303,
+ /* 540 */ 306, 307, 46, 202, 162, 294, 42, 290, 168, 318,
+ /* 550 */ 925, 325, 76, 73, 50, 292, 1153, 288, 111, 1152,
+ /* 560 */ 283, 1149, 286, 49, 180, 305, 332, 1145, 167, 122,
+ /* 570 */ 350, 117, 1144, 1141, 181, 951, 43, 40, 47, 342,
+ /* 580 */ 203, 913, 127, 911, 129, 130, 909, 908, 261, 192,
+ /* 590 */ 193, 905, 904, 903, 902, 901, 900, 899, 196, 198,
+ /* 600 */ 896, 894, 892, 890, 200, 887, 201, 343, 274, 82,
+ /* 610 */ 87, 344, 285, 1077, 345, 346, 347, 348, 358, 863,
+ /* 620 */ 263, 262, 862, 266, 225, 245, 300, 265, 861, 844,
+ /* 630 */ 843, 270, 222, 275, 10, 85, 295, 930, 929, 223,
+ /* 640 */ 105, 740, 106, 277, 30, 88, 765, 907, 906, 157,
+ /* 650 */ 158, 142, 143, 898, 184, 183, 952, 187, 182, 185,
+ /* 660 */ 186, 188, 144, 897, 776, 145, 953, 889, 989, 2,
+ /* 670 */ 169, 888, 770, 33, 4, 159, 89, 237, 772, 90,
+ /* 680 */ 289, 999, 31, 11, 32, 12, 13, 27, 297, 28,
+ /* 690 */ 97, 99, 102, 36, 101, 638, 37, 103, 673, 671,
+ /* 700 */ 670, 669, 667, 666, 665, 662, 628, 316, 107, 7,
+ /* 710 */ 822, 820, 322, 8, 323, 710, 110, 69, 112, 70,
+ /* 720 */ 39, 709, 116, 118, 706, 654, 652, 644, 650, 646,
+ /* 730 */ 648, 642, 640, 676, 675, 674, 672, 668, 664, 663,
+ /* 740 */ 191, 590, 626, 588, 867, 866, 866, 866, 866, 866,
+ /* 750 */ 866, 866, 866, 866, 866, 866, 147, 148,
};
static const YYCODETYPE yy_lookahead[] = {
- /* 0 */ 265, 1, 205, 1, 1, 206, 205, 198, 199, 9,
- /* 10 */ 275, 9, 9, 13, 14, 199, 16, 17, 5, 246,
- /* 20 */ 20, 21, 199, 23, 24, 25, 26, 27, 28, 222,
- /* 30 */ 205, 224, 225, 33, 34, 262, 229, 37, 38, 39,
- /* 40 */ 233, 242, 235, 236, 37, 38, 39, 45, 46, 47,
+ /* 0 */ 253, 1, 245, 1, 199, 200, 249, 200, 245, 9,
+ /* 10 */ 206, 9, 249, 13, 14, 200, 16, 17, 271, 200,
+ /* 20 */ 20, 21, 1, 23, 24, 25, 26, 27, 28, 223,
+ /* 30 */ 9, 225, 226, 33, 34, 200, 230, 37, 38, 39,
+ /* 40 */ 234, 200, 236, 237, 197, 198, 247, 45, 46, 47,
/* 50 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
- /* 60 */ 58, 59, 265, 199, 62, 199, 265, 13, 14, 199,
- /* 70 */ 16, 17, 275, 209, 20, 21, 275, 23, 24, 25,
- /* 80 */ 26, 27, 28, 267, 268, 82, 86, 33, 34, 266,
- /* 90 */ 265, 37, 38, 39, 13, 14, 84, 16, 17, 244,
- /* 100 */ 275, 20, 21, 248, 23, 24, 25, 26, 27, 28,
- /* 110 */ 66, 67, 68, 243, 33, 34, 82, 247, 37, 38,
- /* 120 */ 39, 13, 14, 244, 16, 17, 90, 248, 20, 21,
- /* 130 */ 206, 23, 24, 25, 26, 27, 28, 83, 272, 244,
- /* 140 */ 274, 33, 34, 248, 1, 37, 38, 39, 14, 265,
- /* 150 */ 16, 17, 9, 119, 20, 21, 0, 23, 24, 25,
- /* 160 */ 26, 27, 28, 239, 240, 241, 242, 33, 34, 196,
- /* 170 */ 197, 37, 38, 39, 98, 99, 100, 101, 102, 103,
- /* 180 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 222,
- /* 190 */ 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
- /* 200 */ 233, 234, 235, 236, 16, 17, 44, 199, 20, 21,
- /* 210 */ 199, 23, 24, 25, 26, 27, 28, 246, 78, 246,
- /* 220 */ 209, 33, 34, 199, 62, 37, 38, 39, 1, 2,
- /* 230 */ 90, 69, 5, 262, 7, 262, 9, 75, 76, 77,
- /* 240 */ 84, 1, 2, 81, 82, 5, 82, 7, 199, 9,
- /* 250 */ 86, 199, 2, 245, 265, 5, 5, 7, 7, 9,
- /* 260 */ 33, 34, 199, 145, 37, 147, 199, 243, 63, 64,
- /* 270 */ 65, 247, 209, 33, 34, 70, 71, 72, 73, 74,
- /* 280 */ 116, 119, 265, 33, 34, 265, 25, 26, 27, 28,
- /* 290 */ 220, 221, 199, 88, 33, 34, 247, 69, 37, 38,
- /* 300 */ 39, 248, 206, 141, 69, 143, 63, 64, 65, 82,
- /* 310 */ 243, 5, 150, 70, 247, 72, 73, 74, 199, 63,
- /* 320 */ 64, 65, 82, 80, 272, 199, 70, 71, 72, 73,
- /* 330 */ 74, 5, 199, 7, 199, 98, 240, 100, 101, 33,
- /* 340 */ 34, 199, 105, 142, 117, 118, 109, 199, 111, 112,
- /* 350 */ 199, 124, 151, 152, 37, 33, 34, 117, 118, 37,
- /* 360 */ 38, 39, 243, 270, 124, 272, 247, 117, 118, 243,
- /* 370 */ 199, 199, 144, 247, 146, 124, 148, 149, 243, 144,
- /* 380 */ 83, 146, 247, 148, 149, 243, 63, 64, 65, 247,
- /* 390 */ 204, 243, 83, 204, 243, 247, 204, 211, 247, 83,
- /* 400 */ 211, 97, 249, 211, 97, 272, 207, 208, 202, 203,
- /* 410 */ 132, 133, 83, 97, 243, 243, 263, 120, 247, 247,
- /* 420 */ 83, 83, 97, 83, 83, 82, 97, 123, 83, 120,
- /* 430 */ 83, 83, 1, 83, 97, 97, 61, 97, 97, 122,
- /* 440 */ 83, 15, 97, 82, 97, 97, 139, 97, 265, 83,
- /* 450 */ 124, 78, 79, 145, 97, 147, 265, 82, 115, 145,
- /* 460 */ 265, 147, 137, 97, 5, 5, 7, 7, 37, 145,
- /* 470 */ 238, 147, 145, 265, 147, 114, 145, 265, 147, 265,
- /* 480 */ 265, 265, 265, 265, 265, 265, 265, 265, 265, 265,
- /* 490 */ 248, 238, 248, 238, 199, 238, 238, 238, 238, 199,
- /* 500 */ 199, 199, 264, 273, 199, 61, 273, 261, 246, 199,
- /* 510 */ 246, 199, 199, 250, 199, 246, 269, 199, 199, 199,
- /* 520 */ 199, 269, 254, 269, 259, 124, 260, 199, 258, 199,
- /* 530 */ 257, 199, 199, 199, 199, 199, 269, 130, 199, 134,
- /* 540 */ 136, 199, 128, 117, 200, 199, 138, 135, 199, 256,
- /* 550 */ 199, 199, 199, 199, 199, 199, 127, 199, 199, 199,
- /* 560 */ 126, 199, 199, 199, 199, 129, 199, 199, 199, 199,
- /* 570 */ 199, 199, 125, 199, 89, 199, 199, 199, 199, 199,
- /* 580 */ 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
- /* 590 */ 199, 199, 199, 199, 199, 199, 199, 199, 140, 200,
- /* 600 */ 200, 113, 200, 200, 96, 95, 51, 92, 94, 55,
- /* 610 */ 200, 93, 91, 84, 5, 200, 200, 153, 5, 5,
- /* 620 */ 153, 200, 200, 5, 5, 100, 206, 210, 210, 206,
- /* 630 */ 99, 142, 120, 82, 115, 83, 97, 121, 82, 200,
- /* 640 */ 200, 213, 217, 219, 212, 218, 216, 214, 207, 201,
- /* 650 */ 215, 201, 201, 200, 202, 201, 237, 200, 97, 221,
- /* 660 */ 83, 255, 253, 252, 251, 200, 82, 97, 83, 82,
- /* 670 */ 1, 83, 82, 82, 237, 83, 82, 97, 131, 97,
- /* 680 */ 131, 82, 82, 115, 82, 116, 78, 71, 87, 86,
- /* 690 */ 5, 87, 86, 9, 5, 5, 5, 5, 5, 5,
- /* 700 */ 5, 15, 85, 78, 82, 24, 83, 59, 82, 147,
- /* 710 */ 117, 147, 16, 16, 147, 5, 5, 97, 147, 83,
- /* 720 */ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- /* 730 */ 5, 5, 5, 5, 5, 97, 85, 61, 60, 0,
- /* 740 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 750 */ 276, 21, 21, 276, 276, 276, 276, 276, 276, 276,
- /* 760 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 770 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 780 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 790 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 800 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 810 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 820 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 830 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 840 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 850 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 860 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 870 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 880 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 890 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 900 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 910 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 920 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 930 */ 276, 276, 276, 276, 276, 276, 276, 276, 276, 276,
- /* 940 */ 276, 276, 276, 276, 276, 276, 276, 276,
+ /* 60 */ 58, 59, 263, 244, 62, 13, 14, 248, 16, 17,
+ /* 70 */ 266, 5, 20, 21, 267, 23, 24, 25, 26, 27,
+ /* 80 */ 28, 277, 0, 268, 269, 33, 34, 87, 207, 37,
+ /* 90 */ 38, 39, 13, 14, 247, 16, 17, 266, 83, 20,
+ /* 100 */ 21, 200, 23, 24, 25, 26, 27, 28, 277, 274,
+ /* 110 */ 263, 276, 33, 34, 85, 274, 37, 38, 39, 13,
+ /* 120 */ 14, 245, 16, 17, 243, 249, 20, 21, 207, 23,
+ /* 130 */ 24, 25, 26, 27, 28, 120, 84, 91, 247, 33,
+ /* 140 */ 34, 200, 249, 37, 38, 39, 14, 246, 16, 17,
+ /* 150 */ 126, 127, 20, 21, 263, 23, 24, 25, 26, 27,
+ /* 160 */ 28, 240, 241, 242, 243, 33, 34, 85, 206, 37,
+ /* 170 */ 38, 39, 99, 100, 101, 102, 103, 104, 105, 106,
+ /* 180 */ 107, 108, 109, 110, 111, 112, 113, 223, 224, 225,
+ /* 190 */ 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
+ /* 200 */ 236, 237, 16, 17, 44, 266, 20, 21, 143, 23,
+ /* 210 */ 24, 25, 26, 27, 28, 274, 207, 152, 153, 33,
+ /* 220 */ 34, 79, 62, 37, 38, 39, 1, 2, 266, 69,
+ /* 230 */ 5, 250, 7, 91, 9, 75, 76, 77, 78, 277,
+ /* 240 */ 1, 2, 82, 83, 5, 264, 7, 200, 9, 206,
+ /* 250 */ 241, 266, 25, 26, 27, 28, 200, 210, 33, 34,
+ /* 260 */ 33, 34, 37, 205, 37, 38, 39, 63, 64, 65,
+ /* 270 */ 212, 1, 33, 34, 70, 71, 72, 73, 74, 9,
+ /* 280 */ 120, 2, 221, 222, 5, 200, 7, 200, 9, 63,
+ /* 290 */ 64, 65, 69, 89, 200, 146, 70, 148, 72, 73,
+ /* 300 */ 74, 266, 142, 200, 144, 69, 77, 81, 83, 266,
+ /* 310 */ 37, 151, 33, 34, 203, 204, 63, 64, 65, 5,
+ /* 320 */ 277, 7, 83, 70, 71, 72, 73, 74, 272, 244,
+ /* 330 */ 274, 244, 205, 248, 99, 248, 101, 102, 244, 212,
+ /* 340 */ 200, 106, 248, 118, 119, 110, 200, 112, 113, 5,
+ /* 350 */ 125, 248, 5, 83, 7, 266, 200, 118, 119, 200,
+ /* 360 */ 239, 33, 34, 134, 125, 37, 38, 39, 145, 200,
+ /* 370 */ 147, 200, 149, 150, 200, 83, 266, 33, 34, 87,
+ /* 380 */ 205, 145, 98, 147, 244, 149, 150, 212, 248, 200,
+ /* 390 */ 244, 37, 38, 39, 248, 200, 123, 118, 119, 210,
+ /* 400 */ 244, 208, 209, 244, 248, 210, 84, 248, 124, 117,
+ /* 410 */ 84, 84, 83, 244, 98, 244, 84, 248, 244, 248,
+ /* 420 */ 98, 84, 248, 66, 67, 68, 63, 64, 65, 84,
+ /* 430 */ 98, 98, 84, 1, 15, 98, 84, 84, 83, 125,
+ /* 440 */ 61, 79, 80, 98, 84, 116, 98, 121, 121, 84,
+ /* 450 */ 98, 98, 84, 84, 84, 146, 140, 148, 98, 146,
+ /* 460 */ 266, 148, 83, 98, 266, 266, 98, 98, 98, 37,
+ /* 470 */ 115, 138, 125, 5, 5, 7, 7, 146, 266, 148,
+ /* 480 */ 146, 146, 148, 148, 266, 266, 266, 266, 266, 249,
+ /* 490 */ 266, 249, 247, 239, 266, 239, 266, 266, 266, 266,
+ /* 500 */ 239, 239, 239, 239, 200, 200, 200, 200, 265, 275,
+ /* 510 */ 200, 200, 247, 275, 247, 200, 61, 200, 200, 200,
+ /* 520 */ 251, 200, 270, 200, 200, 200, 260, 270, 270, 270,
+ /* 530 */ 200, 259, 258, 262, 257, 125, 200, 118, 200, 200,
+ /* 540 */ 200, 200, 200, 200, 261, 132, 200, 130, 255, 200,
+ /* 550 */ 200, 200, 137, 139, 136, 135, 200, 129, 200, 200,
+ /* 560 */ 131, 200, 128, 141, 200, 90, 200, 200, 256, 97,
+ /* 570 */ 114, 200, 200, 200, 200, 200, 200, 200, 200, 96,
+ /* 580 */ 200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
+ /* 590 */ 200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
+ /* 600 */ 200, 200, 200, 200, 200, 200, 200, 51, 201, 201,
+ /* 610 */ 201, 93, 201, 201, 95, 55, 94, 92, 85, 5,
+ /* 620 */ 5, 154, 5, 5, 201, 201, 201, 154, 5, 101,
+ /* 630 */ 100, 143, 201, 121, 83, 122, 116, 211, 211, 201,
+ /* 640 */ 207, 84, 207, 98, 83, 98, 84, 201, 201, 83,
+ /* 650 */ 83, 202, 202, 201, 214, 218, 220, 216, 219, 217,
+ /* 660 */ 215, 213, 202, 201, 84, 202, 222, 201, 238, 208,
+ /* 670 */ 254, 201, 84, 252, 203, 98, 83, 1, 84, 83,
+ /* 680 */ 83, 238, 98, 133, 98, 133, 83, 83, 116, 83,
+ /* 690 */ 117, 79, 71, 88, 87, 5, 88, 87, 9, 5,
+ /* 700 */ 5, 5, 5, 5, 5, 5, 86, 15, 79, 83,
+ /* 710 */ 118, 84, 24, 83, 59, 5, 148, 16, 148, 16,
+ /* 720 */ 98, 5, 148, 148, 84, 5, 5, 5, 5, 5,
+ /* 730 */ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ /* 740 */ 98, 61, 86, 60, 0, 278, 278, 278, 278, 278,
+ /* 750 */ 278, 278, 278, 278, 278, 278, 21, 21, 278, 278,
+ /* 760 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 770 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 780 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 790 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 800 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 810 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 820 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 830 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 840 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 850 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 860 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 870 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 880 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 890 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 900 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 910 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 920 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 930 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 940 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
+ /* 950 */ 278, 278, 278, 278,
};
-#define YY_SHIFT_COUNT (361)
+#define YY_SHIFT_COUNT (363)
#define YY_SHIFT_MIN (0)
-#define YY_SHIFT_MAX (739)
+#define YY_SHIFT_MAX (744)
static const unsigned short int yy_shift_ofst[] = {
- /* 0 */ 162, 76, 76, 237, 237, 12, 227, 240, 240, 3,
- /* 10 */ 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
- /* 20 */ 143, 143, 143, 0, 2, 240, 250, 250, 250, 34,
- /* 30 */ 34, 143, 143, 143, 156, 143, 143, 143, 143, 140,
- /* 40 */ 12, 36, 36, 13, 753, 753, 753, 240, 240, 240,
- /* 50 */ 240, 240, 240, 240, 240, 240, 240, 240, 240, 240,
- /* 60 */ 240, 240, 240, 240, 240, 240, 240, 250, 250, 250,
- /* 70 */ 306, 306, 306, 306, 306, 306, 306, 143, 143, 143,
- /* 80 */ 317, 143, 143, 143, 34, 34, 143, 143, 143, 143,
- /* 90 */ 278, 278, 304, 34, 143, 143, 143, 143, 143, 143,
- /* 100 */ 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
- /* 110 */ 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
- /* 120 */ 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
- /* 130 */ 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
- /* 140 */ 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
- /* 150 */ 143, 444, 444, 444, 401, 401, 401, 401, 444, 444,
- /* 160 */ 404, 408, 407, 412, 405, 414, 429, 434, 436, 447,
- /* 170 */ 458, 444, 444, 444, 485, 485, 488, 12, 12, 444,
- /* 180 */ 444, 508, 510, 555, 515, 514, 554, 518, 521, 488,
- /* 190 */ 13, 444, 529, 529, 444, 529, 444, 529, 444, 444,
- /* 200 */ 753, 753, 54, 81, 81, 108, 81, 134, 188, 205,
- /* 210 */ 261, 261, 261, 261, 243, 256, 322, 322, 322, 322,
- /* 220 */ 228, 235, 201, 164, 7, 7, 251, 326, 44, 323,
- /* 230 */ 316, 297, 309, 329, 337, 338, 307, 325, 340, 341,
- /* 240 */ 345, 347, 348, 343, 350, 357, 431, 375, 426, 366,
- /* 250 */ 118, 308, 314, 459, 460, 324, 327, 361, 331, 373,
- /* 260 */ 609, 464, 613, 614, 467, 618, 619, 525, 531, 489,
- /* 270 */ 512, 519, 551, 516, 552, 556, 539, 561, 577, 584,
- /* 280 */ 585, 587, 588, 570, 590, 592, 591, 669, 594, 580,
- /* 290 */ 547, 582, 549, 599, 519, 600, 568, 602, 569, 608,
- /* 300 */ 601, 603, 616, 685, 604, 606, 684, 689, 690, 691,
- /* 310 */ 692, 693, 694, 695, 617, 686, 625, 622, 623, 593,
- /* 320 */ 626, 681, 648, 696, 562, 564, 620, 620, 620, 620,
- /* 330 */ 697, 567, 571, 620, 620, 620, 710, 711, 636, 620,
- /* 340 */ 715, 716, 717, 718, 719, 720, 721, 722, 723, 724,
- /* 350 */ 725, 726, 727, 728, 729, 638, 651, 730, 731, 676,
- /* 360 */ 678, 739,
+ /* 0 */ 160, 73, 73, 235, 235, 29, 225, 239, 239, 270,
+ /* 10 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ /* 20 */ 21, 21, 21, 0, 2, 239, 279, 279, 279, 15,
+ /* 30 */ 15, 21, 21, 24, 21, 82, 21, 21, 21, 21,
+ /* 40 */ 142, 29, 46, 46, 66, 758, 758, 758, 239, 239,
+ /* 50 */ 239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
+ /* 60 */ 239, 239, 239, 239, 239, 239, 239, 239, 279, 279,
+ /* 70 */ 279, 344, 344, 344, 344, 344, 344, 344, 21, 21,
+ /* 80 */ 21, 273, 21, 21, 21, 15, 15, 21, 21, 21,
+ /* 90 */ 21, 229, 229, 284, 15, 21, 21, 21, 21, 21,
+ /* 100 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ /* 110 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ /* 120 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ /* 130 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ /* 140 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ /* 150 */ 21, 21, 21, 455, 455, 455, 410, 410, 410, 410,
+ /* 160 */ 455, 455, 415, 414, 413, 418, 420, 417, 428, 434,
+ /* 170 */ 429, 422, 455, 455, 455, 475, 475, 456, 29, 29,
+ /* 180 */ 455, 455, 472, 483, 556, 518, 519, 560, 522, 525,
+ /* 190 */ 456, 66, 455, 455, 533, 533, 455, 533, 455, 533,
+ /* 200 */ 455, 455, 758, 758, 52, 79, 79, 106, 79, 132,
+ /* 210 */ 186, 204, 227, 227, 227, 227, 226, 253, 328, 328,
+ /* 220 */ 328, 328, 223, 236, 65, 292, 354, 354, 314, 347,
+ /* 230 */ 357, 363, 322, 326, 327, 332, 337, 345, 316, 333,
+ /* 240 */ 348, 352, 353, 360, 365, 329, 368, 369, 432, 379,
+ /* 250 */ 419, 370, 149, 309, 313, 468, 469, 331, 334, 355,
+ /* 260 */ 335, 362, 614, 467, 615, 617, 473, 618, 623, 528,
+ /* 270 */ 530, 488, 512, 520, 551, 513, 557, 561, 545, 547,
+ /* 280 */ 562, 566, 580, 567, 588, 577, 593, 594, 596, 676,
+ /* 290 */ 597, 584, 550, 586, 552, 603, 520, 604, 572, 606,
+ /* 300 */ 573, 612, 605, 607, 621, 690, 608, 610, 689, 694,
+ /* 310 */ 695, 696, 697, 698, 699, 700, 620, 692, 629, 626,
+ /* 320 */ 627, 592, 630, 688, 655, 701, 568, 570, 622, 622,
+ /* 330 */ 622, 622, 703, 574, 575, 622, 622, 622, 710, 716,
+ /* 340 */ 640, 622, 720, 721, 722, 723, 724, 725, 726, 727,
+ /* 350 */ 728, 729, 730, 731, 732, 733, 734, 642, 656, 735,
+ /* 360 */ 736, 680, 683, 744,
};
-#define YY_REDUCE_COUNT (201)
-#define YY_REDUCE_MIN (-265)
-#define YY_REDUCE_MAX (465)
+#define YY_REDUCE_COUNT (203)
+#define YY_REDUCE_MIN (-253)
+#define YY_REDUCE_MAX (471)
static const short yy_reduce_ofst[] = {
- /* 0 */ -27, -33, -33, -193, -193, -76, -203, -199, -175, -184,
- /* 10 */ -130, -134, 93, 24, 67, 119, 126, 135, 142, 148,
- /* 20 */ 151, 171, 172, -177, -191, -265, -145, -121, -105, -227,
- /* 30 */ -29, 52, 133, 8, -201, -136, 11, 63, 49, 186,
- /* 40 */ 96, 189, 192, 70, 153, 199, 206, -116, -11, 17,
- /* 50 */ 20, 183, 191, 195, 208, 212, 214, 215, 216, 217,
- /* 60 */ 218, 219, 220, 221, 222, 223, 224, 53, 242, 244,
- /* 70 */ 232, 253, 255, 257, 258, 259, 260, 295, 300, 301,
- /* 80 */ 238, 302, 305, 310, 262, 264, 312, 313, 315, 318,
- /* 90 */ 230, 233, 263, 269, 319, 320, 321, 328, 330, 332,
- /* 100 */ 333, 334, 335, 336, 339, 342, 346, 349, 351, 352,
- /* 110 */ 353, 354, 355, 356, 358, 359, 360, 362, 363, 364,
- /* 120 */ 365, 367, 368, 369, 370, 371, 372, 374, 376, 377,
- /* 130 */ 378, 379, 380, 381, 382, 383, 384, 385, 386, 387,
- /* 140 */ 388, 389, 390, 391, 392, 393, 394, 395, 396, 397,
- /* 150 */ 398, 344, 399, 400, 247, 252, 254, 267, 402, 403,
- /* 160 */ 246, 266, 265, 270, 273, 293, 406, 268, 409, 411,
- /* 170 */ 413, 410, 415, 416, 417, 418, 419, 420, 423, 421,
- /* 180 */ 422, 424, 427, 425, 428, 430, 433, 435, 432, 437,
- /* 190 */ 438, 439, 448, 450, 440, 451, 453, 454, 457, 465,
- /* 200 */ 441, 452,
+ /* 0 */ -153, -36, -36, -194, -194, -79, -196, -38, 43, -185,
+ /* 10 */ -181, -165, 56, 85, 87, 94, 140, 146, 156, 159,
+ /* 20 */ 169, 171, 174, -193, -195, -169, -243, -237, -124, -201,
+ /* 30 */ -109, -159, -59, -253, -99, -119, 47, 189, 195, 103,
+ /* 40 */ 58, 9, 127, 175, 61, -19, 193, 111, -61, -15,
+ /* 50 */ 35, 89, 110, 194, 198, 199, 212, 218, 219, 220,
+ /* 60 */ 221, 222, 224, 228, 230, 231, 232, 233, -107, 240,
+ /* 70 */ 242, 121, 254, 256, 261, 262, 263, 264, 304, 305,
+ /* 80 */ 306, 243, 307, 310, 311, 245, 265, 315, 317, 318,
+ /* 90 */ 319, 234, 238, 269, 267, 321, 323, 324, 325, 330,
+ /* 100 */ 336, 338, 339, 340, 341, 342, 343, 346, 349, 350,
+ /* 110 */ 351, 356, 358, 359, 361, 364, 366, 367, 371, 372,
+ /* 120 */ 373, 374, 375, 376, 377, 378, 380, 381, 382, 383,
+ /* 130 */ 384, 385, 386, 387, 388, 389, 390, 391, 392, 393,
+ /* 140 */ 394, 395, 396, 397, 398, 399, 400, 401, 402, 403,
+ /* 150 */ 404, 405, 406, 407, 408, 409, 252, 257, 258, 259,
+ /* 160 */ 411, 412, 271, 283, 266, 272, 274, 277, 312, 293,
+ /* 170 */ 416, 421, 423, 424, 425, 426, 427, 430, 433, 435,
+ /* 180 */ 431, 438, 436, 439, 437, 440, 442, 445, 441, 448,
+ /* 190 */ 443, 444, 446, 447, 449, 450, 452, 460, 462, 463,
+ /* 200 */ 466, 470, 461, 471,
};
static const YYACTIONTYPE yy_default[] = {
- /* 0 */ 856, 979, 918, 989, 905, 915, 1126, 1126, 1126, 856,
- /* 10 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 20 */ 856, 856, 856, 1037, 876, 1126, 856, 856, 856, 856,
- /* 30 */ 856, 856, 856, 856, 915, 856, 856, 856, 856, 925,
- /* 40 */ 915, 925, 925, 856, 1032, 963, 981, 856, 856, 856,
- /* 50 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 60 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 70 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 80 */ 1039, 1045, 1042, 856, 856, 856, 1047, 856, 856, 856,
- /* 90 */ 1069, 1069, 1030, 856, 856, 856, 856, 856, 856, 856,
- /* 100 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 110 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 120 */ 856, 856, 856, 856, 856, 856, 903, 856, 901, 856,
- /* 130 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 140 */ 856, 856, 856, 856, 887, 856, 856, 856, 856, 856,
- /* 150 */ 856, 878, 878, 878, 856, 856, 856, 856, 878, 878,
- /* 160 */ 1076, 1080, 1062, 1074, 1070, 1057, 1055, 1053, 1061, 1052,
- /* 170 */ 1084, 878, 878, 878, 923, 923, 919, 915, 915, 878,
- /* 180 */ 878, 941, 939, 937, 929, 935, 931, 933, 927, 906,
- /* 190 */ 856, 878, 913, 913, 878, 913, 878, 913, 878, 878,
- /* 200 */ 963, 981, 856, 1085, 1075, 856, 1125, 1115, 1114, 856,
- /* 210 */ 1121, 1113, 1112, 1111, 856, 856, 1107, 1110, 1109, 1108,
- /* 220 */ 856, 856, 856, 856, 1117, 1116, 856, 856, 856, 856,
- /* 230 */ 856, 856, 856, 856, 856, 856, 1081, 1077, 856, 856,
- /* 240 */ 856, 856, 856, 856, 856, 856, 856, 1087, 856, 856,
- /* 250 */ 856, 856, 856, 856, 856, 856, 856, 991, 856, 856,
- /* 260 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 270 */ 1029, 856, 856, 856, 856, 856, 1041, 1040, 856, 856,
- /* 280 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 1071,
- /* 290 */ 856, 1063, 856, 856, 1003, 856, 856, 856, 856, 856,
- /* 300 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 310 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 320 */ 856, 856, 856, 856, 856, 856, 1144, 1139, 1140, 1137,
- /* 330 */ 856, 856, 856, 1136, 1131, 1132, 856, 856, 856, 1129,
- /* 340 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
- /* 350 */ 856, 856, 856, 856, 856, 947, 856, 885, 883, 856,
- /* 360 */ 874, 856,
+ /* 0 */ 864, 988, 927, 998, 914, 924, 1137, 1137, 1137, 864,
+ /* 10 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 20 */ 864, 864, 864, 1046, 884, 1137, 864, 864, 864, 864,
+ /* 30 */ 864, 864, 864, 1061, 864, 924, 864, 864, 864, 864,
+ /* 40 */ 934, 924, 934, 934, 864, 1041, 972, 990, 864, 864,
+ /* 50 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 60 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 70 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 80 */ 864, 1048, 1054, 1051, 864, 864, 864, 1056, 864, 864,
+ /* 90 */ 864, 1080, 1080, 1039, 864, 864, 864, 864, 864, 864,
+ /* 100 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 110 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 120 */ 864, 864, 864, 864, 864, 864, 864, 912, 864, 910,
+ /* 130 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 140 */ 864, 864, 864, 864, 864, 864, 895, 864, 864, 864,
+ /* 150 */ 864, 864, 864, 886, 886, 886, 864, 864, 864, 864,
+ /* 160 */ 886, 886, 1087, 1091, 1073, 1085, 1081, 1068, 1066, 1064,
+ /* 170 */ 1072, 1095, 886, 886, 886, 932, 932, 928, 924, 924,
+ /* 180 */ 886, 886, 950, 948, 946, 938, 944, 940, 942, 936,
+ /* 190 */ 915, 864, 886, 886, 922, 922, 886, 922, 886, 922,
+ /* 200 */ 886, 886, 972, 990, 864, 1096, 1086, 864, 1136, 1126,
+ /* 210 */ 1125, 864, 1132, 1124, 1123, 1122, 864, 864, 1118, 1121,
+ /* 220 */ 1120, 1119, 864, 864, 864, 864, 1128, 1127, 864, 864,
+ /* 230 */ 864, 864, 864, 864, 864, 864, 864, 864, 1092, 1088,
+ /* 240 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 1098,
+ /* 250 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 1000,
+ /* 260 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 270 */ 864, 864, 1038, 864, 864, 864, 864, 864, 1050, 1049,
+ /* 280 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 290 */ 864, 1082, 864, 1074, 864, 864, 1012, 864, 864, 864,
+ /* 300 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 310 */ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 320 */ 864, 864, 864, 864, 864, 864, 864, 864, 1155, 1150,
+ /* 330 */ 1151, 1148, 864, 864, 864, 1147, 1142, 1143, 864, 864,
+ /* 340 */ 864, 1140, 864, 864, 864, 864, 864, 864, 864, 864,
+ /* 350 */ 864, 864, 864, 864, 864, 864, 864, 956, 864, 893,
+ /* 360 */ 891, 864, 882, 864,
};
/********** End of lemon-generated parsing tables *****************************/
@@ -582,6 +584,7 @@ static const YYCODETYPE yyFallback[] = {
0, /* ACCOUNT => nothing */
0, /* USE => nothing */
0, /* DESCRIBE => nothing */
+ 1, /* DESC => ID */
0, /* ALTER => nothing */
0, /* PASS => nothing */
0, /* PRIVILEGE => nothing */
@@ -631,6 +634,7 @@ static const YYCODETYPE yyFallback[] = {
0, /* FROM => nothing */
0, /* VARIABLE => nothing */
0, /* INTERVAL => nothing */
+ 0, /* EVERY => nothing */
0, /* SESSION => nothing */
0, /* STATE_WINDOW => nothing */
0, /* FILL => nothing */
@@ -638,7 +642,6 @@ static const YYCODETYPE yyFallback[] = {
0, /* ORDER => nothing */
0, /* BY => nothing */
1, /* ASC => ID */
- 1, /* DESC => ID */
0, /* GROUP => nothing */
0, /* HAVING => nothing */
0, /* LIMIT => nothing */
@@ -863,205 +866,207 @@ static const char *const yyTokenName[] = {
/* 74 */ "ACCOUNT",
/* 75 */ "USE",
/* 76 */ "DESCRIBE",
- /* 77 */ "ALTER",
- /* 78 */ "PASS",
- /* 79 */ "PRIVILEGE",
- /* 80 */ "LOCAL",
- /* 81 */ "COMPACT",
- /* 82 */ "LP",
- /* 83 */ "RP",
- /* 84 */ "IF",
- /* 85 */ "EXISTS",
- /* 86 */ "AS",
- /* 87 */ "OUTPUTTYPE",
- /* 88 */ "AGGREGATE",
- /* 89 */ "BUFSIZE",
- /* 90 */ "PPS",
- /* 91 */ "TSERIES",
- /* 92 */ "DBS",
- /* 93 */ "STORAGE",
- /* 94 */ "QTIME",
- /* 95 */ "CONNS",
- /* 96 */ "STATE",
- /* 97 */ "COMMA",
- /* 98 */ "KEEP",
- /* 99 */ "CACHE",
- /* 100 */ "REPLICA",
- /* 101 */ "QUORUM",
- /* 102 */ "DAYS",
- /* 103 */ "MINROWS",
- /* 104 */ "MAXROWS",
- /* 105 */ "BLOCKS",
- /* 106 */ "CTIME",
- /* 107 */ "WAL",
- /* 108 */ "FSYNC",
- /* 109 */ "COMP",
- /* 110 */ "PRECISION",
- /* 111 */ "UPDATE",
- /* 112 */ "CACHELAST",
- /* 113 */ "PARTITIONS",
- /* 114 */ "UNSIGNED",
- /* 115 */ "TAGS",
- /* 116 */ "USING",
- /* 117 */ "NULL",
- /* 118 */ "NOW",
- /* 119 */ "SELECT",
- /* 120 */ "UNION",
- /* 121 */ "ALL",
- /* 122 */ "DISTINCT",
- /* 123 */ "FROM",
- /* 124 */ "VARIABLE",
- /* 125 */ "INTERVAL",
- /* 126 */ "SESSION",
- /* 127 */ "STATE_WINDOW",
- /* 128 */ "FILL",
- /* 129 */ "SLIDING",
- /* 130 */ "ORDER",
- /* 131 */ "BY",
- /* 132 */ "ASC",
- /* 133 */ "DESC",
- /* 134 */ "GROUP",
- /* 135 */ "HAVING",
- /* 136 */ "LIMIT",
- /* 137 */ "OFFSET",
- /* 138 */ "SLIMIT",
- /* 139 */ "SOFFSET",
- /* 140 */ "WHERE",
- /* 141 */ "RESET",
- /* 142 */ "QUERY",
- /* 143 */ "SYNCDB",
- /* 144 */ "ADD",
- /* 145 */ "COLUMN",
- /* 146 */ "MODIFY",
- /* 147 */ "TAG",
- /* 148 */ "CHANGE",
- /* 149 */ "SET",
- /* 150 */ "KILL",
- /* 151 */ "CONNECTION",
- /* 152 */ "STREAM",
- /* 153 */ "COLON",
- /* 154 */ "ABORT",
- /* 155 */ "AFTER",
- /* 156 */ "ATTACH",
- /* 157 */ "BEFORE",
- /* 158 */ "BEGIN",
- /* 159 */ "CASCADE",
- /* 160 */ "CLUSTER",
- /* 161 */ "CONFLICT",
- /* 162 */ "COPY",
- /* 163 */ "DEFERRED",
- /* 164 */ "DELIMITERS",
- /* 165 */ "DETACH",
- /* 166 */ "EACH",
- /* 167 */ "END",
- /* 168 */ "EXPLAIN",
- /* 169 */ "FAIL",
- /* 170 */ "FOR",
- /* 171 */ "IGNORE",
- /* 172 */ "IMMEDIATE",
- /* 173 */ "INITIALLY",
- /* 174 */ "INSTEAD",
- /* 175 */ "MATCH",
- /* 176 */ "KEY",
- /* 177 */ "OF",
- /* 178 */ "RAISE",
- /* 179 */ "REPLACE",
- /* 180 */ "RESTRICT",
- /* 181 */ "ROW",
- /* 182 */ "STATEMENT",
- /* 183 */ "TRIGGER",
- /* 184 */ "VIEW",
- /* 185 */ "SEMI",
- /* 186 */ "NONE",
- /* 187 */ "PREV",
- /* 188 */ "LINEAR",
- /* 189 */ "IMPORT",
- /* 190 */ "TBNAME",
- /* 191 */ "JOIN",
- /* 192 */ "INSERT",
- /* 193 */ "INTO",
- /* 194 */ "VALUES",
- /* 195 */ "error",
- /* 196 */ "program",
- /* 197 */ "cmd",
- /* 198 */ "dbPrefix",
- /* 199 */ "ids",
- /* 200 */ "cpxName",
- /* 201 */ "ifexists",
- /* 202 */ "alter_db_optr",
- /* 203 */ "alter_topic_optr",
- /* 204 */ "acct_optr",
- /* 205 */ "exprlist",
- /* 206 */ "ifnotexists",
- /* 207 */ "db_optr",
- /* 208 */ "topic_optr",
- /* 209 */ "typename",
- /* 210 */ "bufsize",
- /* 211 */ "pps",
- /* 212 */ "tseries",
- /* 213 */ "dbs",
- /* 214 */ "streams",
- /* 215 */ "storage",
- /* 216 */ "qtime",
- /* 217 */ "users",
- /* 218 */ "conns",
- /* 219 */ "state",
- /* 220 */ "intitemlist",
- /* 221 */ "intitem",
- /* 222 */ "keep",
- /* 223 */ "cache",
- /* 224 */ "replica",
- /* 225 */ "quorum",
- /* 226 */ "days",
- /* 227 */ "minrows",
- /* 228 */ "maxrows",
- /* 229 */ "blocks",
- /* 230 */ "ctime",
- /* 231 */ "wal",
- /* 232 */ "fsync",
- /* 233 */ "comp",
- /* 234 */ "prec",
- /* 235 */ "update",
- /* 236 */ "cachelast",
- /* 237 */ "partitions",
- /* 238 */ "signed",
- /* 239 */ "create_table_args",
- /* 240 */ "create_stable_args",
- /* 241 */ "create_table_list",
- /* 242 */ "create_from_stable",
- /* 243 */ "columnlist",
- /* 244 */ "tagitemlist",
- /* 245 */ "tagNamelist",
- /* 246 */ "select",
- /* 247 */ "column",
- /* 248 */ "tagitem",
- /* 249 */ "selcollist",
- /* 250 */ "from",
- /* 251 */ "where_opt",
- /* 252 */ "interval_opt",
- /* 253 */ "sliding_opt",
- /* 254 */ "session_option",
- /* 255 */ "windowstate_option",
- /* 256 */ "fill_opt",
- /* 257 */ "groupby_opt",
- /* 258 */ "having_opt",
- /* 259 */ "orderby_opt",
- /* 260 */ "slimit_opt",
- /* 261 */ "limit_opt",
- /* 262 */ "union",
- /* 263 */ "sclp",
- /* 264 */ "distinct",
- /* 265 */ "expr",
- /* 266 */ "as",
- /* 267 */ "tablelist",
- /* 268 */ "sub",
- /* 269 */ "tmvar",
- /* 270 */ "sortlist",
- /* 271 */ "sortitem",
- /* 272 */ "item",
- /* 273 */ "sortorder",
- /* 274 */ "grouplist",
- /* 275 */ "expritem",
+ /* 77 */ "DESC",
+ /* 78 */ "ALTER",
+ /* 79 */ "PASS",
+ /* 80 */ "PRIVILEGE",
+ /* 81 */ "LOCAL",
+ /* 82 */ "COMPACT",
+ /* 83 */ "LP",
+ /* 84 */ "RP",
+ /* 85 */ "IF",
+ /* 86 */ "EXISTS",
+ /* 87 */ "AS",
+ /* 88 */ "OUTPUTTYPE",
+ /* 89 */ "AGGREGATE",
+ /* 90 */ "BUFSIZE",
+ /* 91 */ "PPS",
+ /* 92 */ "TSERIES",
+ /* 93 */ "DBS",
+ /* 94 */ "STORAGE",
+ /* 95 */ "QTIME",
+ /* 96 */ "CONNS",
+ /* 97 */ "STATE",
+ /* 98 */ "COMMA",
+ /* 99 */ "KEEP",
+ /* 100 */ "CACHE",
+ /* 101 */ "REPLICA",
+ /* 102 */ "QUORUM",
+ /* 103 */ "DAYS",
+ /* 104 */ "MINROWS",
+ /* 105 */ "MAXROWS",
+ /* 106 */ "BLOCKS",
+ /* 107 */ "CTIME",
+ /* 108 */ "WAL",
+ /* 109 */ "FSYNC",
+ /* 110 */ "COMP",
+ /* 111 */ "PRECISION",
+ /* 112 */ "UPDATE",
+ /* 113 */ "CACHELAST",
+ /* 114 */ "PARTITIONS",
+ /* 115 */ "UNSIGNED",
+ /* 116 */ "TAGS",
+ /* 117 */ "USING",
+ /* 118 */ "NULL",
+ /* 119 */ "NOW",
+ /* 120 */ "SELECT",
+ /* 121 */ "UNION",
+ /* 122 */ "ALL",
+ /* 123 */ "DISTINCT",
+ /* 124 */ "FROM",
+ /* 125 */ "VARIABLE",
+ /* 126 */ "INTERVAL",
+ /* 127 */ "EVERY",
+ /* 128 */ "SESSION",
+ /* 129 */ "STATE_WINDOW",
+ /* 130 */ "FILL",
+ /* 131 */ "SLIDING",
+ /* 132 */ "ORDER",
+ /* 133 */ "BY",
+ /* 134 */ "ASC",
+ /* 135 */ "GROUP",
+ /* 136 */ "HAVING",
+ /* 137 */ "LIMIT",
+ /* 138 */ "OFFSET",
+ /* 139 */ "SLIMIT",
+ /* 140 */ "SOFFSET",
+ /* 141 */ "WHERE",
+ /* 142 */ "RESET",
+ /* 143 */ "QUERY",
+ /* 144 */ "SYNCDB",
+ /* 145 */ "ADD",
+ /* 146 */ "COLUMN",
+ /* 147 */ "MODIFY",
+ /* 148 */ "TAG",
+ /* 149 */ "CHANGE",
+ /* 150 */ "SET",
+ /* 151 */ "KILL",
+ /* 152 */ "CONNECTION",
+ /* 153 */ "STREAM",
+ /* 154 */ "COLON",
+ /* 155 */ "ABORT",
+ /* 156 */ "AFTER",
+ /* 157 */ "ATTACH",
+ /* 158 */ "BEFORE",
+ /* 159 */ "BEGIN",
+ /* 160 */ "CASCADE",
+ /* 161 */ "CLUSTER",
+ /* 162 */ "CONFLICT",
+ /* 163 */ "COPY",
+ /* 164 */ "DEFERRED",
+ /* 165 */ "DELIMITERS",
+ /* 166 */ "DETACH",
+ /* 167 */ "EACH",
+ /* 168 */ "END",
+ /* 169 */ "EXPLAIN",
+ /* 170 */ "FAIL",
+ /* 171 */ "FOR",
+ /* 172 */ "IGNORE",
+ /* 173 */ "IMMEDIATE",
+ /* 174 */ "INITIALLY",
+ /* 175 */ "INSTEAD",
+ /* 176 */ "MATCH",
+ /* 177 */ "KEY",
+ /* 178 */ "OF",
+ /* 179 */ "RAISE",
+ /* 180 */ "REPLACE",
+ /* 181 */ "RESTRICT",
+ /* 182 */ "ROW",
+ /* 183 */ "STATEMENT",
+ /* 184 */ "TRIGGER",
+ /* 185 */ "VIEW",
+ /* 186 */ "SEMI",
+ /* 187 */ "NONE",
+ /* 188 */ "PREV",
+ /* 189 */ "LINEAR",
+ /* 190 */ "IMPORT",
+ /* 191 */ "TBNAME",
+ /* 192 */ "JOIN",
+ /* 193 */ "INSERT",
+ /* 194 */ "INTO",
+ /* 195 */ "VALUES",
+ /* 196 */ "error",
+ /* 197 */ "program",
+ /* 198 */ "cmd",
+ /* 199 */ "dbPrefix",
+ /* 200 */ "ids",
+ /* 201 */ "cpxName",
+ /* 202 */ "ifexists",
+ /* 203 */ "alter_db_optr",
+ /* 204 */ "alter_topic_optr",
+ /* 205 */ "acct_optr",
+ /* 206 */ "exprlist",
+ /* 207 */ "ifnotexists",
+ /* 208 */ "db_optr",
+ /* 209 */ "topic_optr",
+ /* 210 */ "typename",
+ /* 211 */ "bufsize",
+ /* 212 */ "pps",
+ /* 213 */ "tseries",
+ /* 214 */ "dbs",
+ /* 215 */ "streams",
+ /* 216 */ "storage",
+ /* 217 */ "qtime",
+ /* 218 */ "users",
+ /* 219 */ "conns",
+ /* 220 */ "state",
+ /* 221 */ "intitemlist",
+ /* 222 */ "intitem",
+ /* 223 */ "keep",
+ /* 224 */ "cache",
+ /* 225 */ "replica",
+ /* 226 */ "quorum",
+ /* 227 */ "days",
+ /* 228 */ "minrows",
+ /* 229 */ "maxrows",
+ /* 230 */ "blocks",
+ /* 231 */ "ctime",
+ /* 232 */ "wal",
+ /* 233 */ "fsync",
+ /* 234 */ "comp",
+ /* 235 */ "prec",
+ /* 236 */ "update",
+ /* 237 */ "cachelast",
+ /* 238 */ "partitions",
+ /* 239 */ "signed",
+ /* 240 */ "create_table_args",
+ /* 241 */ "create_stable_args",
+ /* 242 */ "create_table_list",
+ /* 243 */ "create_from_stable",
+ /* 244 */ "columnlist",
+ /* 245 */ "tagitemlist",
+ /* 246 */ "tagNamelist",
+ /* 247 */ "select",
+ /* 248 */ "column",
+ /* 249 */ "tagitem",
+ /* 250 */ "selcollist",
+ /* 251 */ "from",
+ /* 252 */ "where_opt",
+ /* 253 */ "interval_option",
+ /* 254 */ "sliding_opt",
+ /* 255 */ "session_option",
+ /* 256 */ "windowstate_option",
+ /* 257 */ "fill_opt",
+ /* 258 */ "groupby_opt",
+ /* 259 */ "having_opt",
+ /* 260 */ "orderby_opt",
+ /* 261 */ "slimit_opt",
+ /* 262 */ "limit_opt",
+ /* 263 */ "union",
+ /* 264 */ "sclp",
+ /* 265 */ "distinct",
+ /* 266 */ "expr",
+ /* 267 */ "as",
+ /* 268 */ "tablelist",
+ /* 269 */ "sub",
+ /* 270 */ "tmvar",
+ /* 271 */ "intervalKey",
+ /* 272 */ "sortlist",
+ /* 273 */ "sortitem",
+ /* 274 */ "item",
+ /* 275 */ "sortorder",
+ /* 276 */ "grouplist",
+ /* 277 */ "expritem",
};
#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
@@ -1109,255 +1114,258 @@ static const char *const yyRuleName[] = {
/* 37 */ "cmd ::= DROP ACCOUNT ids",
/* 38 */ "cmd ::= USE ids",
/* 39 */ "cmd ::= DESCRIBE ids cpxName",
- /* 40 */ "cmd ::= ALTER USER ids PASS ids",
- /* 41 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
- /* 42 */ "cmd ::= ALTER DNODE ids ids",
- /* 43 */ "cmd ::= ALTER DNODE ids ids ids",
- /* 44 */ "cmd ::= ALTER LOCAL ids",
- /* 45 */ "cmd ::= ALTER LOCAL ids ids",
- /* 46 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
- /* 47 */ "cmd ::= ALTER TOPIC ids alter_topic_optr",
- /* 48 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
- /* 49 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
- /* 50 */ "cmd ::= COMPACT VNODES IN LP exprlist RP",
- /* 51 */ "ids ::= ID",
- /* 52 */ "ids ::= STRING",
- /* 53 */ "ifexists ::= IF EXISTS",
- /* 54 */ "ifexists ::=",
- /* 55 */ "ifnotexists ::= IF NOT EXISTS",
- /* 56 */ "ifnotexists ::=",
- /* 57 */ "cmd ::= CREATE DNODE ids",
- /* 58 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
- /* 59 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
- /* 60 */ "cmd ::= CREATE TOPIC ifnotexists ids topic_optr",
- /* 61 */ "cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
- /* 62 */ "cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
- /* 63 */ "cmd ::= CREATE USER ids PASS ids",
- /* 64 */ "bufsize ::=",
- /* 65 */ "bufsize ::= BUFSIZE INTEGER",
- /* 66 */ "pps ::=",
- /* 67 */ "pps ::= PPS INTEGER",
- /* 68 */ "tseries ::=",
- /* 69 */ "tseries ::= TSERIES INTEGER",
- /* 70 */ "dbs ::=",
- /* 71 */ "dbs ::= DBS INTEGER",
- /* 72 */ "streams ::=",
- /* 73 */ "streams ::= STREAMS INTEGER",
- /* 74 */ "storage ::=",
- /* 75 */ "storage ::= STORAGE INTEGER",
- /* 76 */ "qtime ::=",
- /* 77 */ "qtime ::= QTIME INTEGER",
- /* 78 */ "users ::=",
- /* 79 */ "users ::= USERS INTEGER",
- /* 80 */ "conns ::=",
- /* 81 */ "conns ::= CONNS INTEGER",
- /* 82 */ "state ::=",
- /* 83 */ "state ::= STATE ids",
- /* 84 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
- /* 85 */ "intitemlist ::= intitemlist COMMA intitem",
- /* 86 */ "intitemlist ::= intitem",
- /* 87 */ "intitem ::= INTEGER",
- /* 88 */ "keep ::= KEEP intitemlist",
- /* 89 */ "cache ::= CACHE INTEGER",
- /* 90 */ "replica ::= REPLICA INTEGER",
- /* 91 */ "quorum ::= QUORUM INTEGER",
- /* 92 */ "days ::= DAYS INTEGER",
- /* 93 */ "minrows ::= MINROWS INTEGER",
- /* 94 */ "maxrows ::= MAXROWS INTEGER",
- /* 95 */ "blocks ::= BLOCKS INTEGER",
- /* 96 */ "ctime ::= CTIME INTEGER",
- /* 97 */ "wal ::= WAL INTEGER",
- /* 98 */ "fsync ::= FSYNC INTEGER",
- /* 99 */ "comp ::= COMP INTEGER",
- /* 100 */ "prec ::= PRECISION STRING",
- /* 101 */ "update ::= UPDATE INTEGER",
- /* 102 */ "cachelast ::= CACHELAST INTEGER",
- /* 103 */ "partitions ::= PARTITIONS INTEGER",
- /* 104 */ "db_optr ::=",
- /* 105 */ "db_optr ::= db_optr cache",
- /* 106 */ "db_optr ::= db_optr replica",
- /* 107 */ "db_optr ::= db_optr quorum",
- /* 108 */ "db_optr ::= db_optr days",
- /* 109 */ "db_optr ::= db_optr minrows",
- /* 110 */ "db_optr ::= db_optr maxrows",
- /* 111 */ "db_optr ::= db_optr blocks",
- /* 112 */ "db_optr ::= db_optr ctime",
- /* 113 */ "db_optr ::= db_optr wal",
- /* 114 */ "db_optr ::= db_optr fsync",
- /* 115 */ "db_optr ::= db_optr comp",
- /* 116 */ "db_optr ::= db_optr prec",
- /* 117 */ "db_optr ::= db_optr keep",
- /* 118 */ "db_optr ::= db_optr update",
- /* 119 */ "db_optr ::= db_optr cachelast",
- /* 120 */ "topic_optr ::= db_optr",
- /* 121 */ "topic_optr ::= topic_optr partitions",
- /* 122 */ "alter_db_optr ::=",
- /* 123 */ "alter_db_optr ::= alter_db_optr replica",
- /* 124 */ "alter_db_optr ::= alter_db_optr quorum",
- /* 125 */ "alter_db_optr ::= alter_db_optr keep",
- /* 126 */ "alter_db_optr ::= alter_db_optr blocks",
- /* 127 */ "alter_db_optr ::= alter_db_optr comp",
- /* 128 */ "alter_db_optr ::= alter_db_optr update",
- /* 129 */ "alter_db_optr ::= alter_db_optr cachelast",
- /* 130 */ "alter_topic_optr ::= alter_db_optr",
- /* 131 */ "alter_topic_optr ::= alter_topic_optr partitions",
- /* 132 */ "typename ::= ids",
- /* 133 */ "typename ::= ids LP signed RP",
- /* 134 */ "typename ::= ids UNSIGNED",
- /* 135 */ "signed ::= INTEGER",
- /* 136 */ "signed ::= PLUS INTEGER",
- /* 137 */ "signed ::= MINUS INTEGER",
- /* 138 */ "cmd ::= CREATE TABLE create_table_args",
- /* 139 */ "cmd ::= CREATE TABLE create_stable_args",
- /* 140 */ "cmd ::= CREATE STABLE create_stable_args",
- /* 141 */ "cmd ::= CREATE TABLE create_table_list",
- /* 142 */ "create_table_list ::= create_from_stable",
- /* 143 */ "create_table_list ::= create_table_list create_from_stable",
- /* 144 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
- /* 145 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
- /* 146 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
- /* 147 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP",
- /* 148 */ "tagNamelist ::= tagNamelist COMMA ids",
- /* 149 */ "tagNamelist ::= ids",
- /* 150 */ "create_table_args ::= ifnotexists ids cpxName AS select",
- /* 151 */ "columnlist ::= columnlist COMMA column",
- /* 152 */ "columnlist ::= column",
- /* 153 */ "column ::= ids typename",
- /* 154 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 155 */ "tagitemlist ::= tagitem",
- /* 156 */ "tagitem ::= INTEGER",
- /* 157 */ "tagitem ::= FLOAT",
- /* 158 */ "tagitem ::= STRING",
- /* 159 */ "tagitem ::= BOOL",
- /* 160 */ "tagitem ::= NULL",
- /* 161 */ "tagitem ::= NOW",
- /* 162 */ "tagitem ::= MINUS INTEGER",
- /* 163 */ "tagitem ::= MINUS FLOAT",
- /* 164 */ "tagitem ::= PLUS INTEGER",
- /* 165 */ "tagitem ::= PLUS FLOAT",
- /* 166 */ "select ::= SELECT selcollist from where_opt interval_opt sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt",
- /* 167 */ "select ::= LP select RP",
- /* 168 */ "union ::= select",
- /* 169 */ "union ::= union UNION ALL select",
- /* 170 */ "cmd ::= union",
- /* 171 */ "select ::= SELECT selcollist",
- /* 172 */ "sclp ::= selcollist COMMA",
- /* 173 */ "sclp ::=",
- /* 174 */ "selcollist ::= sclp distinct expr as",
- /* 175 */ "selcollist ::= sclp STAR",
- /* 176 */ "as ::= AS ids",
- /* 177 */ "as ::= ids",
- /* 178 */ "as ::=",
- /* 179 */ "distinct ::= DISTINCT",
- /* 180 */ "distinct ::=",
- /* 181 */ "from ::= FROM tablelist",
- /* 182 */ "from ::= FROM sub",
- /* 183 */ "sub ::= LP union RP",
- /* 184 */ "sub ::= LP union RP ids",
- /* 185 */ "sub ::= sub COMMA LP union RP ids",
- /* 186 */ "tablelist ::= ids cpxName",
- /* 187 */ "tablelist ::= ids cpxName ids",
- /* 188 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 189 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 190 */ "tmvar ::= VARIABLE",
- /* 191 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 192 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
- /* 193 */ "interval_opt ::=",
- /* 194 */ "session_option ::=",
- /* 195 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
- /* 196 */ "windowstate_option ::=",
- /* 197 */ "windowstate_option ::= STATE_WINDOW LP ids RP",
- /* 198 */ "fill_opt ::=",
- /* 199 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 200 */ "fill_opt ::= FILL LP ID RP",
- /* 201 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 202 */ "sliding_opt ::=",
- /* 203 */ "orderby_opt ::=",
- /* 204 */ "orderby_opt ::= ORDER BY sortlist",
- /* 205 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 206 */ "sortlist ::= item sortorder",
- /* 207 */ "item ::= ids cpxName",
- /* 208 */ "sortorder ::= ASC",
- /* 209 */ "sortorder ::= DESC",
- /* 210 */ "sortorder ::=",
- /* 211 */ "groupby_opt ::=",
- /* 212 */ "groupby_opt ::= GROUP BY grouplist",
- /* 213 */ "grouplist ::= grouplist COMMA item",
- /* 214 */ "grouplist ::= item",
- /* 215 */ "having_opt ::=",
- /* 216 */ "having_opt ::= HAVING expr",
- /* 217 */ "limit_opt ::=",
- /* 218 */ "limit_opt ::= LIMIT signed",
- /* 219 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 220 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 221 */ "slimit_opt ::=",
- /* 222 */ "slimit_opt ::= SLIMIT signed",
- /* 223 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 224 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 225 */ "where_opt ::=",
- /* 226 */ "where_opt ::= WHERE expr",
- /* 227 */ "expr ::= LP expr RP",
- /* 228 */ "expr ::= ID",
- /* 229 */ "expr ::= ID DOT ID",
- /* 230 */ "expr ::= ID DOT STAR",
- /* 231 */ "expr ::= INTEGER",
- /* 232 */ "expr ::= MINUS INTEGER",
- /* 233 */ "expr ::= PLUS INTEGER",
- /* 234 */ "expr ::= FLOAT",
- /* 235 */ "expr ::= MINUS FLOAT",
- /* 236 */ "expr ::= PLUS FLOAT",
- /* 237 */ "expr ::= STRING",
- /* 238 */ "expr ::= NOW",
- /* 239 */ "expr ::= VARIABLE",
- /* 240 */ "expr ::= PLUS VARIABLE",
- /* 241 */ "expr ::= MINUS VARIABLE",
- /* 242 */ "expr ::= BOOL",
- /* 243 */ "expr ::= NULL",
- /* 244 */ "expr ::= ID LP exprlist RP",
- /* 245 */ "expr ::= ID LP STAR RP",
- /* 246 */ "expr ::= expr IS NULL",
- /* 247 */ "expr ::= expr IS NOT NULL",
- /* 248 */ "expr ::= expr LT expr",
- /* 249 */ "expr ::= expr GT expr",
- /* 250 */ "expr ::= expr LE expr",
- /* 251 */ "expr ::= expr GE expr",
- /* 252 */ "expr ::= expr NE expr",
- /* 253 */ "expr ::= expr EQ expr",
- /* 254 */ "expr ::= expr BETWEEN expr AND expr",
- /* 255 */ "expr ::= expr AND expr",
- /* 256 */ "expr ::= expr OR expr",
- /* 257 */ "expr ::= expr PLUS expr",
- /* 258 */ "expr ::= expr MINUS expr",
- /* 259 */ "expr ::= expr STAR expr",
- /* 260 */ "expr ::= expr SLASH expr",
- /* 261 */ "expr ::= expr REM expr",
- /* 262 */ "expr ::= expr LIKE expr",
- /* 263 */ "expr ::= expr IN LP exprlist RP",
- /* 264 */ "exprlist ::= exprlist COMMA expritem",
- /* 265 */ "exprlist ::= expritem",
- /* 266 */ "expritem ::= expr",
- /* 267 */ "expritem ::=",
- /* 268 */ "cmd ::= RESET QUERY CACHE",
- /* 269 */ "cmd ::= SYNCDB ids REPLICA",
- /* 270 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 271 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 272 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
- /* 273 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 274 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 275 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 276 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 277 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
- /* 278 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
- /* 279 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
- /* 280 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
- /* 281 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
- /* 282 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
- /* 283 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
- /* 284 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
- /* 285 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
- /* 286 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 287 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 288 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /* 40 */ "cmd ::= DESC ids cpxName",
+ /* 41 */ "cmd ::= ALTER USER ids PASS ids",
+ /* 42 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
+ /* 43 */ "cmd ::= ALTER DNODE ids ids",
+ /* 44 */ "cmd ::= ALTER DNODE ids ids ids",
+ /* 45 */ "cmd ::= ALTER LOCAL ids",
+ /* 46 */ "cmd ::= ALTER LOCAL ids ids",
+ /* 47 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
+ /* 48 */ "cmd ::= ALTER TOPIC ids alter_topic_optr",
+ /* 49 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
+ /* 50 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
+ /* 51 */ "cmd ::= COMPACT VNODES IN LP exprlist RP",
+ /* 52 */ "ids ::= ID",
+ /* 53 */ "ids ::= STRING",
+ /* 54 */ "ifexists ::= IF EXISTS",
+ /* 55 */ "ifexists ::=",
+ /* 56 */ "ifnotexists ::= IF NOT EXISTS",
+ /* 57 */ "ifnotexists ::=",
+ /* 58 */ "cmd ::= CREATE DNODE ids",
+ /* 59 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
+ /* 60 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
+ /* 61 */ "cmd ::= CREATE TOPIC ifnotexists ids topic_optr",
+ /* 62 */ "cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
+ /* 63 */ "cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
+ /* 64 */ "cmd ::= CREATE USER ids PASS ids",
+ /* 65 */ "bufsize ::=",
+ /* 66 */ "bufsize ::= BUFSIZE INTEGER",
+ /* 67 */ "pps ::=",
+ /* 68 */ "pps ::= PPS INTEGER",
+ /* 69 */ "tseries ::=",
+ /* 70 */ "tseries ::= TSERIES INTEGER",
+ /* 71 */ "dbs ::=",
+ /* 72 */ "dbs ::= DBS INTEGER",
+ /* 73 */ "streams ::=",
+ /* 74 */ "streams ::= STREAMS INTEGER",
+ /* 75 */ "storage ::=",
+ /* 76 */ "storage ::= STORAGE INTEGER",
+ /* 77 */ "qtime ::=",
+ /* 78 */ "qtime ::= QTIME INTEGER",
+ /* 79 */ "users ::=",
+ /* 80 */ "users ::= USERS INTEGER",
+ /* 81 */ "conns ::=",
+ /* 82 */ "conns ::= CONNS INTEGER",
+ /* 83 */ "state ::=",
+ /* 84 */ "state ::= STATE ids",
+ /* 85 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
+ /* 86 */ "intitemlist ::= intitemlist COMMA intitem",
+ /* 87 */ "intitemlist ::= intitem",
+ /* 88 */ "intitem ::= INTEGER",
+ /* 89 */ "keep ::= KEEP intitemlist",
+ /* 90 */ "cache ::= CACHE INTEGER",
+ /* 91 */ "replica ::= REPLICA INTEGER",
+ /* 92 */ "quorum ::= QUORUM INTEGER",
+ /* 93 */ "days ::= DAYS INTEGER",
+ /* 94 */ "minrows ::= MINROWS INTEGER",
+ /* 95 */ "maxrows ::= MAXROWS INTEGER",
+ /* 96 */ "blocks ::= BLOCKS INTEGER",
+ /* 97 */ "ctime ::= CTIME INTEGER",
+ /* 98 */ "wal ::= WAL INTEGER",
+ /* 99 */ "fsync ::= FSYNC INTEGER",
+ /* 100 */ "comp ::= COMP INTEGER",
+ /* 101 */ "prec ::= PRECISION STRING",
+ /* 102 */ "update ::= UPDATE INTEGER",
+ /* 103 */ "cachelast ::= CACHELAST INTEGER",
+ /* 104 */ "partitions ::= PARTITIONS INTEGER",
+ /* 105 */ "db_optr ::=",
+ /* 106 */ "db_optr ::= db_optr cache",
+ /* 107 */ "db_optr ::= db_optr replica",
+ /* 108 */ "db_optr ::= db_optr quorum",
+ /* 109 */ "db_optr ::= db_optr days",
+ /* 110 */ "db_optr ::= db_optr minrows",
+ /* 111 */ "db_optr ::= db_optr maxrows",
+ /* 112 */ "db_optr ::= db_optr blocks",
+ /* 113 */ "db_optr ::= db_optr ctime",
+ /* 114 */ "db_optr ::= db_optr wal",
+ /* 115 */ "db_optr ::= db_optr fsync",
+ /* 116 */ "db_optr ::= db_optr comp",
+ /* 117 */ "db_optr ::= db_optr prec",
+ /* 118 */ "db_optr ::= db_optr keep",
+ /* 119 */ "db_optr ::= db_optr update",
+ /* 120 */ "db_optr ::= db_optr cachelast",
+ /* 121 */ "topic_optr ::= db_optr",
+ /* 122 */ "topic_optr ::= topic_optr partitions",
+ /* 123 */ "alter_db_optr ::=",
+ /* 124 */ "alter_db_optr ::= alter_db_optr replica",
+ /* 125 */ "alter_db_optr ::= alter_db_optr quorum",
+ /* 126 */ "alter_db_optr ::= alter_db_optr keep",
+ /* 127 */ "alter_db_optr ::= alter_db_optr blocks",
+ /* 128 */ "alter_db_optr ::= alter_db_optr comp",
+ /* 129 */ "alter_db_optr ::= alter_db_optr update",
+ /* 130 */ "alter_db_optr ::= alter_db_optr cachelast",
+ /* 131 */ "alter_topic_optr ::= alter_db_optr",
+ /* 132 */ "alter_topic_optr ::= alter_topic_optr partitions",
+ /* 133 */ "typename ::= ids",
+ /* 134 */ "typename ::= ids LP signed RP",
+ /* 135 */ "typename ::= ids UNSIGNED",
+ /* 136 */ "signed ::= INTEGER",
+ /* 137 */ "signed ::= PLUS INTEGER",
+ /* 138 */ "signed ::= MINUS INTEGER",
+ /* 139 */ "cmd ::= CREATE TABLE create_table_args",
+ /* 140 */ "cmd ::= CREATE TABLE create_stable_args",
+ /* 141 */ "cmd ::= CREATE STABLE create_stable_args",
+ /* 142 */ "cmd ::= CREATE TABLE create_table_list",
+ /* 143 */ "create_table_list ::= create_from_stable",
+ /* 144 */ "create_table_list ::= create_table_list create_from_stable",
+ /* 145 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
+ /* 146 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
+ /* 147 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
+ /* 148 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP",
+ /* 149 */ "tagNamelist ::= tagNamelist COMMA ids",
+ /* 150 */ "tagNamelist ::= ids",
+ /* 151 */ "create_table_args ::= ifnotexists ids cpxName AS select",
+ /* 152 */ "columnlist ::= columnlist COMMA column",
+ /* 153 */ "columnlist ::= column",
+ /* 154 */ "column ::= ids typename",
+ /* 155 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 156 */ "tagitemlist ::= tagitem",
+ /* 157 */ "tagitem ::= INTEGER",
+ /* 158 */ "tagitem ::= FLOAT",
+ /* 159 */ "tagitem ::= STRING",
+ /* 160 */ "tagitem ::= BOOL",
+ /* 161 */ "tagitem ::= NULL",
+ /* 162 */ "tagitem ::= NOW",
+ /* 163 */ "tagitem ::= MINUS INTEGER",
+ /* 164 */ "tagitem ::= MINUS FLOAT",
+ /* 165 */ "tagitem ::= PLUS INTEGER",
+ /* 166 */ "tagitem ::= PLUS FLOAT",
+ /* 167 */ "select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt",
+ /* 168 */ "select ::= LP select RP",
+ /* 169 */ "union ::= select",
+ /* 170 */ "union ::= union UNION ALL select",
+ /* 171 */ "cmd ::= union",
+ /* 172 */ "select ::= SELECT selcollist",
+ /* 173 */ "sclp ::= selcollist COMMA",
+ /* 174 */ "sclp ::=",
+ /* 175 */ "selcollist ::= sclp distinct expr as",
+ /* 176 */ "selcollist ::= sclp STAR",
+ /* 177 */ "as ::= AS ids",
+ /* 178 */ "as ::= ids",
+ /* 179 */ "as ::=",
+ /* 180 */ "distinct ::= DISTINCT",
+ /* 181 */ "distinct ::=",
+ /* 182 */ "from ::= FROM tablelist",
+ /* 183 */ "from ::= FROM sub",
+ /* 184 */ "sub ::= LP union RP",
+ /* 185 */ "sub ::= LP union RP ids",
+ /* 186 */ "sub ::= sub COMMA LP union RP ids",
+ /* 187 */ "tablelist ::= ids cpxName",
+ /* 188 */ "tablelist ::= ids cpxName ids",
+ /* 189 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 190 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 191 */ "tmvar ::= VARIABLE",
+ /* 192 */ "interval_option ::= intervalKey LP tmvar RP",
+ /* 193 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP",
+ /* 194 */ "interval_option ::=",
+ /* 195 */ "intervalKey ::= INTERVAL",
+ /* 196 */ "intervalKey ::= EVERY",
+ /* 197 */ "session_option ::=",
+ /* 198 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
+ /* 199 */ "windowstate_option ::=",
+ /* 200 */ "windowstate_option ::= STATE_WINDOW LP ids RP",
+ /* 201 */ "fill_opt ::=",
+ /* 202 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 203 */ "fill_opt ::= FILL LP ID RP",
+ /* 204 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 205 */ "sliding_opt ::=",
+ /* 206 */ "orderby_opt ::=",
+ /* 207 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 208 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 209 */ "sortlist ::= item sortorder",
+ /* 210 */ "item ::= ids cpxName",
+ /* 211 */ "sortorder ::= ASC",
+ /* 212 */ "sortorder ::= DESC",
+ /* 213 */ "sortorder ::=",
+ /* 214 */ "groupby_opt ::=",
+ /* 215 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 216 */ "grouplist ::= grouplist COMMA item",
+ /* 217 */ "grouplist ::= item",
+ /* 218 */ "having_opt ::=",
+ /* 219 */ "having_opt ::= HAVING expr",
+ /* 220 */ "limit_opt ::=",
+ /* 221 */ "limit_opt ::= LIMIT signed",
+ /* 222 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 223 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 224 */ "slimit_opt ::=",
+ /* 225 */ "slimit_opt ::= SLIMIT signed",
+ /* 226 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 227 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 228 */ "where_opt ::=",
+ /* 229 */ "where_opt ::= WHERE expr",
+ /* 230 */ "expr ::= LP expr RP",
+ /* 231 */ "expr ::= ID",
+ /* 232 */ "expr ::= ID DOT ID",
+ /* 233 */ "expr ::= ID DOT STAR",
+ /* 234 */ "expr ::= INTEGER",
+ /* 235 */ "expr ::= MINUS INTEGER",
+ /* 236 */ "expr ::= PLUS INTEGER",
+ /* 237 */ "expr ::= FLOAT",
+ /* 238 */ "expr ::= MINUS FLOAT",
+ /* 239 */ "expr ::= PLUS FLOAT",
+ /* 240 */ "expr ::= STRING",
+ /* 241 */ "expr ::= NOW",
+ /* 242 */ "expr ::= VARIABLE",
+ /* 243 */ "expr ::= PLUS VARIABLE",
+ /* 244 */ "expr ::= MINUS VARIABLE",
+ /* 245 */ "expr ::= BOOL",
+ /* 246 */ "expr ::= NULL",
+ /* 247 */ "expr ::= ID LP exprlist RP",
+ /* 248 */ "expr ::= ID LP STAR RP",
+ /* 249 */ "expr ::= expr IS NULL",
+ /* 250 */ "expr ::= expr IS NOT NULL",
+ /* 251 */ "expr ::= expr LT expr",
+ /* 252 */ "expr ::= expr GT expr",
+ /* 253 */ "expr ::= expr LE expr",
+ /* 254 */ "expr ::= expr GE expr",
+ /* 255 */ "expr ::= expr NE expr",
+ /* 256 */ "expr ::= expr EQ expr",
+ /* 257 */ "expr ::= expr BETWEEN expr AND expr",
+ /* 258 */ "expr ::= expr AND expr",
+ /* 259 */ "expr ::= expr OR expr",
+ /* 260 */ "expr ::= expr PLUS expr",
+ /* 261 */ "expr ::= expr MINUS expr",
+ /* 262 */ "expr ::= expr STAR expr",
+ /* 263 */ "expr ::= expr SLASH expr",
+ /* 264 */ "expr ::= expr REM expr",
+ /* 265 */ "expr ::= expr LIKE expr",
+ /* 266 */ "expr ::= expr IN LP exprlist RP",
+ /* 267 */ "exprlist ::= exprlist COMMA expritem",
+ /* 268 */ "exprlist ::= expritem",
+ /* 269 */ "expritem ::= expr",
+ /* 270 */ "expritem ::=",
+ /* 271 */ "cmd ::= RESET QUERY CACHE",
+ /* 272 */ "cmd ::= SYNCDB ids REPLICA",
+ /* 273 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 274 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 275 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 276 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 277 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 278 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 279 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 280 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
+ /* 281 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
+ /* 282 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
+ /* 283 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 284 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
+ /* 285 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
+ /* 286 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
+ /* 287 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 288 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
+ /* 289 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 290 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 291 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
};
#endif /* NDEBUG */
@@ -1478,60 +1486,60 @@ static void yy_destructor(
** inside the C code.
*/
/********* Begin destructor definitions ***************************************/
- case 205: /* exprlist */
- case 249: /* selcollist */
- case 263: /* sclp */
+ case 206: /* exprlist */
+ case 250: /* selcollist */
+ case 264: /* sclp */
{
-tSqlExprListDestroy((yypminor->yy525));
+tSqlExprListDestroy((yypminor->yy421));
}
break;
- case 220: /* intitemlist */
- case 222: /* keep */
- case 243: /* columnlist */
- case 244: /* tagitemlist */
- case 245: /* tagNamelist */
- case 256: /* fill_opt */
- case 257: /* groupby_opt */
- case 259: /* orderby_opt */
- case 270: /* sortlist */
- case 274: /* grouplist */
-{
-taosArrayDestroy((yypminor->yy525));
+ case 221: /* intitemlist */
+ case 223: /* keep */
+ case 244: /* columnlist */
+ case 245: /* tagitemlist */
+ case 246: /* tagNamelist */
+ case 257: /* fill_opt */
+ case 258: /* groupby_opt */
+ case 260: /* orderby_opt */
+ case 272: /* sortlist */
+ case 276: /* grouplist */
+{
+taosArrayDestroy((yypminor->yy421));
}
break;
- case 241: /* create_table_list */
+ case 242: /* create_table_list */
{
-destroyCreateTableSql((yypminor->yy158));
+destroyCreateTableSql((yypminor->yy438));
}
break;
- case 246: /* select */
+ case 247: /* select */
{
-destroySqlNode((yypminor->yy464));
+destroySqlNode((yypminor->yy56));
}
break;
- case 250: /* from */
- case 267: /* tablelist */
- case 268: /* sub */
+ case 251: /* from */
+ case 268: /* tablelist */
+ case 269: /* sub */
{
-destroyRelationInfo((yypminor->yy412));
+destroyRelationInfo((yypminor->yy8));
}
break;
- case 251: /* where_opt */
- case 258: /* having_opt */
- case 265: /* expr */
- case 275: /* expritem */
+ case 252: /* where_opt */
+ case 259: /* having_opt */
+ case 266: /* expr */
+ case 277: /* expritem */
{
-tSqlExprDestroy((yypminor->yy370));
+tSqlExprDestroy((yypminor->yy439));
}
break;
- case 262: /* union */
+ case 263: /* union */
{
-destroyAllSqlNode((yypminor->yy525));
+destroyAllSqlNode((yypminor->yy421));
}
break;
- case 271: /* sortitem */
+ case 273: /* sortitem */
{
-tVariantDestroy(&(yypminor->yy506));
+tVariantDestroy(&(yypminor->yy430));
}
break;
/********* End destructor definitions *****************************************/
@@ -1825,295 +1833,298 @@ static const struct {
YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
signed char nrhs; /* Negative of the number of RHS symbols in the rule */
} yyRuleInfo[] = {
- { 196, -1 }, /* (0) program ::= cmd */
- { 197, -2 }, /* (1) cmd ::= SHOW DATABASES */
- { 197, -2 }, /* (2) cmd ::= SHOW TOPICS */
- { 197, -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
- { 197, -2 }, /* (4) cmd ::= SHOW MNODES */
- { 197, -2 }, /* (5) cmd ::= SHOW DNODES */
- { 197, -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
- { 197, -2 }, /* (7) cmd ::= SHOW USERS */
- { 197, -2 }, /* (8) cmd ::= SHOW MODULES */
- { 197, -2 }, /* (9) cmd ::= SHOW QUERIES */
- { 197, -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
- { 197, -2 }, /* (11) cmd ::= SHOW STREAMS */
- { 197, -2 }, /* (12) cmd ::= SHOW VARIABLES */
- { 197, -2 }, /* (13) cmd ::= SHOW SCORES */
- { 197, -2 }, /* (14) cmd ::= SHOW GRANTS */
- { 197, -2 }, /* (15) cmd ::= SHOW VNODES */
- { 197, -3 }, /* (16) cmd ::= SHOW VNODES IPTOKEN */
- { 198, 0 }, /* (17) dbPrefix ::= */
- { 198, -2 }, /* (18) dbPrefix ::= ids DOT */
- { 200, 0 }, /* (19) cpxName ::= */
- { 200, -2 }, /* (20) cpxName ::= DOT ids */
- { 197, -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
- { 197, -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
- { 197, -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
- { 197, -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
- { 197, -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE ids */
- { 197, -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
- { 197, -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE ids */
- { 197, -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
- { 197, -4 }, /* (29) cmd ::= SHOW dbPrefix VGROUPS ids */
- { 197, -5 }, /* (30) cmd ::= DROP TABLE ifexists ids cpxName */
- { 197, -5 }, /* (31) cmd ::= DROP STABLE ifexists ids cpxName */
- { 197, -4 }, /* (32) cmd ::= DROP DATABASE ifexists ids */
- { 197, -4 }, /* (33) cmd ::= DROP TOPIC ifexists ids */
- { 197, -3 }, /* (34) cmd ::= DROP FUNCTION ids */
- { 197, -3 }, /* (35) cmd ::= DROP DNODE ids */
- { 197, -3 }, /* (36) cmd ::= DROP USER ids */
- { 197, -3 }, /* (37) cmd ::= DROP ACCOUNT ids */
- { 197, -2 }, /* (38) cmd ::= USE ids */
- { 197, -3 }, /* (39) cmd ::= DESCRIBE ids cpxName */
- { 197, -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */
- { 197, -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
- { 197, -4 }, /* (42) cmd ::= ALTER DNODE ids ids */
- { 197, -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */
- { 197, -3 }, /* (44) cmd ::= ALTER LOCAL ids */
- { 197, -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */
- { 197, -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
- { 197, -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
- { 197, -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
- { 197, -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
- { 197, -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
- { 199, -1 }, /* (51) ids ::= ID */
- { 199, -1 }, /* (52) ids ::= STRING */
- { 201, -2 }, /* (53) ifexists ::= IF EXISTS */
- { 201, 0 }, /* (54) ifexists ::= */
- { 206, -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
- { 206, 0 }, /* (56) ifnotexists ::= */
- { 197, -3 }, /* (57) cmd ::= CREATE DNODE ids */
- { 197, -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
- { 197, -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
- { 197, -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
- { 197, -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
- { 197, -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
- { 197, -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
- { 210, 0 }, /* (64) bufsize ::= */
- { 210, -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
- { 211, 0 }, /* (66) pps ::= */
- { 211, -2 }, /* (67) pps ::= PPS INTEGER */
- { 212, 0 }, /* (68) tseries ::= */
- { 212, -2 }, /* (69) tseries ::= TSERIES INTEGER */
- { 213, 0 }, /* (70) dbs ::= */
- { 213, -2 }, /* (71) dbs ::= DBS INTEGER */
- { 214, 0 }, /* (72) streams ::= */
- { 214, -2 }, /* (73) streams ::= STREAMS INTEGER */
- { 215, 0 }, /* (74) storage ::= */
- { 215, -2 }, /* (75) storage ::= STORAGE INTEGER */
- { 216, 0 }, /* (76) qtime ::= */
- { 216, -2 }, /* (77) qtime ::= QTIME INTEGER */
- { 217, 0 }, /* (78) users ::= */
- { 217, -2 }, /* (79) users ::= USERS INTEGER */
- { 218, 0 }, /* (80) conns ::= */
- { 218, -2 }, /* (81) conns ::= CONNS INTEGER */
- { 219, 0 }, /* (82) state ::= */
- { 219, -2 }, /* (83) state ::= STATE ids */
- { 204, -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
- { 220, -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
- { 220, -1 }, /* (86) intitemlist ::= intitem */
- { 221, -1 }, /* (87) intitem ::= INTEGER */
- { 222, -2 }, /* (88) keep ::= KEEP intitemlist */
- { 223, -2 }, /* (89) cache ::= CACHE INTEGER */
- { 224, -2 }, /* (90) replica ::= REPLICA INTEGER */
- { 225, -2 }, /* (91) quorum ::= QUORUM INTEGER */
- { 226, -2 }, /* (92) days ::= DAYS INTEGER */
- { 227, -2 }, /* (93) minrows ::= MINROWS INTEGER */
- { 228, -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
- { 229, -2 }, /* (95) blocks ::= BLOCKS INTEGER */
- { 230, -2 }, /* (96) ctime ::= CTIME INTEGER */
- { 231, -2 }, /* (97) wal ::= WAL INTEGER */
- { 232, -2 }, /* (98) fsync ::= FSYNC INTEGER */
- { 233, -2 }, /* (99) comp ::= COMP INTEGER */
- { 234, -2 }, /* (100) prec ::= PRECISION STRING */
- { 235, -2 }, /* (101) update ::= UPDATE INTEGER */
- { 236, -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
- { 237, -2 }, /* (103) partitions ::= PARTITIONS INTEGER */
- { 207, 0 }, /* (104) db_optr ::= */
- { 207, -2 }, /* (105) db_optr ::= db_optr cache */
- { 207, -2 }, /* (106) db_optr ::= db_optr replica */
- { 207, -2 }, /* (107) db_optr ::= db_optr quorum */
- { 207, -2 }, /* (108) db_optr ::= db_optr days */
- { 207, -2 }, /* (109) db_optr ::= db_optr minrows */
- { 207, -2 }, /* (110) db_optr ::= db_optr maxrows */
- { 207, -2 }, /* (111) db_optr ::= db_optr blocks */
- { 207, -2 }, /* (112) db_optr ::= db_optr ctime */
- { 207, -2 }, /* (113) db_optr ::= db_optr wal */
- { 207, -2 }, /* (114) db_optr ::= db_optr fsync */
- { 207, -2 }, /* (115) db_optr ::= db_optr comp */
- { 207, -2 }, /* (116) db_optr ::= db_optr prec */
- { 207, -2 }, /* (117) db_optr ::= db_optr keep */
- { 207, -2 }, /* (118) db_optr ::= db_optr update */
- { 207, -2 }, /* (119) db_optr ::= db_optr cachelast */
- { 208, -1 }, /* (120) topic_optr ::= db_optr */
- { 208, -2 }, /* (121) topic_optr ::= topic_optr partitions */
- { 202, 0 }, /* (122) alter_db_optr ::= */
- { 202, -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */
- { 202, -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */
- { 202, -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */
- { 202, -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */
- { 202, -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */
- { 202, -2 }, /* (128) alter_db_optr ::= alter_db_optr update */
- { 202, -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */
- { 203, -1 }, /* (130) alter_topic_optr ::= alter_db_optr */
- { 203, -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */
- { 209, -1 }, /* (132) typename ::= ids */
- { 209, -4 }, /* (133) typename ::= ids LP signed RP */
- { 209, -2 }, /* (134) typename ::= ids UNSIGNED */
- { 238, -1 }, /* (135) signed ::= INTEGER */
- { 238, -2 }, /* (136) signed ::= PLUS INTEGER */
- { 238, -2 }, /* (137) signed ::= MINUS INTEGER */
- { 197, -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */
- { 197, -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */
- { 197, -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */
- { 197, -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */
- { 241, -1 }, /* (142) create_table_list ::= create_from_stable */
- { 241, -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */
- { 239, -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
- { 240, -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
- { 242, -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
- { 242, -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
- { 245, -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */
- { 245, -1 }, /* (149) tagNamelist ::= ids */
- { 239, -5 }, /* (150) create_table_args ::= ifnotexists ids cpxName AS select */
- { 243, -3 }, /* (151) columnlist ::= columnlist COMMA column */
- { 243, -1 }, /* (152) columnlist ::= column */
- { 247, -2 }, /* (153) column ::= ids typename */
- { 244, -3 }, /* (154) tagitemlist ::= tagitemlist COMMA tagitem */
- { 244, -1 }, /* (155) tagitemlist ::= tagitem */
- { 248, -1 }, /* (156) tagitem ::= INTEGER */
- { 248, -1 }, /* (157) tagitem ::= FLOAT */
- { 248, -1 }, /* (158) tagitem ::= STRING */
- { 248, -1 }, /* (159) tagitem ::= BOOL */
- { 248, -1 }, /* (160) tagitem ::= NULL */
- { 248, -1 }, /* (161) tagitem ::= NOW */
- { 248, -2 }, /* (162) tagitem ::= MINUS INTEGER */
- { 248, -2 }, /* (163) tagitem ::= MINUS FLOAT */
- { 248, -2 }, /* (164) tagitem ::= PLUS INTEGER */
- { 248, -2 }, /* (165) tagitem ::= PLUS FLOAT */
- { 246, -14 }, /* (166) select ::= SELECT selcollist from where_opt interval_opt sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
- { 246, -3 }, /* (167) select ::= LP select RP */
- { 262, -1 }, /* (168) union ::= select */
- { 262, -4 }, /* (169) union ::= union UNION ALL select */
- { 197, -1 }, /* (170) cmd ::= union */
- { 246, -2 }, /* (171) select ::= SELECT selcollist */
- { 263, -2 }, /* (172) sclp ::= selcollist COMMA */
- { 263, 0 }, /* (173) sclp ::= */
- { 249, -4 }, /* (174) selcollist ::= sclp distinct expr as */
- { 249, -2 }, /* (175) selcollist ::= sclp STAR */
- { 266, -2 }, /* (176) as ::= AS ids */
- { 266, -1 }, /* (177) as ::= ids */
- { 266, 0 }, /* (178) as ::= */
- { 264, -1 }, /* (179) distinct ::= DISTINCT */
- { 264, 0 }, /* (180) distinct ::= */
- { 250, -2 }, /* (181) from ::= FROM tablelist */
- { 250, -2 }, /* (182) from ::= FROM sub */
- { 268, -3 }, /* (183) sub ::= LP union RP */
- { 268, -4 }, /* (184) sub ::= LP union RP ids */
- { 268, -6 }, /* (185) sub ::= sub COMMA LP union RP ids */
- { 267, -2 }, /* (186) tablelist ::= ids cpxName */
- { 267, -3 }, /* (187) tablelist ::= ids cpxName ids */
- { 267, -4 }, /* (188) tablelist ::= tablelist COMMA ids cpxName */
- { 267, -5 }, /* (189) tablelist ::= tablelist COMMA ids cpxName ids */
- { 269, -1 }, /* (190) tmvar ::= VARIABLE */
- { 252, -4 }, /* (191) interval_opt ::= INTERVAL LP tmvar RP */
- { 252, -6 }, /* (192) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
- { 252, 0 }, /* (193) interval_opt ::= */
- { 254, 0 }, /* (194) session_option ::= */
- { 254, -7 }, /* (195) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
- { 255, 0 }, /* (196) windowstate_option ::= */
- { 255, -4 }, /* (197) windowstate_option ::= STATE_WINDOW LP ids RP */
- { 256, 0 }, /* (198) fill_opt ::= */
- { 256, -6 }, /* (199) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
- { 256, -4 }, /* (200) fill_opt ::= FILL LP ID RP */
- { 253, -4 }, /* (201) sliding_opt ::= SLIDING LP tmvar RP */
- { 253, 0 }, /* (202) sliding_opt ::= */
- { 259, 0 }, /* (203) orderby_opt ::= */
- { 259, -3 }, /* (204) orderby_opt ::= ORDER BY sortlist */
- { 270, -4 }, /* (205) sortlist ::= sortlist COMMA item sortorder */
- { 270, -2 }, /* (206) sortlist ::= item sortorder */
- { 272, -2 }, /* (207) item ::= ids cpxName */
- { 273, -1 }, /* (208) sortorder ::= ASC */
- { 273, -1 }, /* (209) sortorder ::= DESC */
- { 273, 0 }, /* (210) sortorder ::= */
- { 257, 0 }, /* (211) groupby_opt ::= */
- { 257, -3 }, /* (212) groupby_opt ::= GROUP BY grouplist */
- { 274, -3 }, /* (213) grouplist ::= grouplist COMMA item */
- { 274, -1 }, /* (214) grouplist ::= item */
- { 258, 0 }, /* (215) having_opt ::= */
- { 258, -2 }, /* (216) having_opt ::= HAVING expr */
- { 261, 0 }, /* (217) limit_opt ::= */
- { 261, -2 }, /* (218) limit_opt ::= LIMIT signed */
- { 261, -4 }, /* (219) limit_opt ::= LIMIT signed OFFSET signed */
- { 261, -4 }, /* (220) limit_opt ::= LIMIT signed COMMA signed */
- { 260, 0 }, /* (221) slimit_opt ::= */
- { 260, -2 }, /* (222) slimit_opt ::= SLIMIT signed */
- { 260, -4 }, /* (223) slimit_opt ::= SLIMIT signed SOFFSET signed */
- { 260, -4 }, /* (224) slimit_opt ::= SLIMIT signed COMMA signed */
- { 251, 0 }, /* (225) where_opt ::= */
- { 251, -2 }, /* (226) where_opt ::= WHERE expr */
- { 265, -3 }, /* (227) expr ::= LP expr RP */
- { 265, -1 }, /* (228) expr ::= ID */
- { 265, -3 }, /* (229) expr ::= ID DOT ID */
- { 265, -3 }, /* (230) expr ::= ID DOT STAR */
- { 265, -1 }, /* (231) expr ::= INTEGER */
- { 265, -2 }, /* (232) expr ::= MINUS INTEGER */
- { 265, -2 }, /* (233) expr ::= PLUS INTEGER */
- { 265, -1 }, /* (234) expr ::= FLOAT */
- { 265, -2 }, /* (235) expr ::= MINUS FLOAT */
- { 265, -2 }, /* (236) expr ::= PLUS FLOAT */
- { 265, -1 }, /* (237) expr ::= STRING */
- { 265, -1 }, /* (238) expr ::= NOW */
- { 265, -1 }, /* (239) expr ::= VARIABLE */
- { 265, -2 }, /* (240) expr ::= PLUS VARIABLE */
- { 265, -2 }, /* (241) expr ::= MINUS VARIABLE */
- { 265, -1 }, /* (242) expr ::= BOOL */
- { 265, -1 }, /* (243) expr ::= NULL */
- { 265, -4 }, /* (244) expr ::= ID LP exprlist RP */
- { 265, -4 }, /* (245) expr ::= ID LP STAR RP */
- { 265, -3 }, /* (246) expr ::= expr IS NULL */
- { 265, -4 }, /* (247) expr ::= expr IS NOT NULL */
- { 265, -3 }, /* (248) expr ::= expr LT expr */
- { 265, -3 }, /* (249) expr ::= expr GT expr */
- { 265, -3 }, /* (250) expr ::= expr LE expr */
- { 265, -3 }, /* (251) expr ::= expr GE expr */
- { 265, -3 }, /* (252) expr ::= expr NE expr */
- { 265, -3 }, /* (253) expr ::= expr EQ expr */
- { 265, -5 }, /* (254) expr ::= expr BETWEEN expr AND expr */
- { 265, -3 }, /* (255) expr ::= expr AND expr */
- { 265, -3 }, /* (256) expr ::= expr OR expr */
- { 265, -3 }, /* (257) expr ::= expr PLUS expr */
- { 265, -3 }, /* (258) expr ::= expr MINUS expr */
- { 265, -3 }, /* (259) expr ::= expr STAR expr */
- { 265, -3 }, /* (260) expr ::= expr SLASH expr */
- { 265, -3 }, /* (261) expr ::= expr REM expr */
- { 265, -3 }, /* (262) expr ::= expr LIKE expr */
- { 265, -5 }, /* (263) expr ::= expr IN LP exprlist RP */
- { 205, -3 }, /* (264) exprlist ::= exprlist COMMA expritem */
- { 205, -1 }, /* (265) exprlist ::= expritem */
- { 275, -1 }, /* (266) expritem ::= expr */
- { 275, 0 }, /* (267) expritem ::= */
- { 197, -3 }, /* (268) cmd ::= RESET QUERY CACHE */
- { 197, -3 }, /* (269) cmd ::= SYNCDB ids REPLICA */
- { 197, -7 }, /* (270) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
- { 197, -7 }, /* (271) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
- { 197, -7 }, /* (272) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
- { 197, -7 }, /* (273) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
- { 197, -7 }, /* (274) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
- { 197, -8 }, /* (275) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
- { 197, -9 }, /* (276) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
- { 197, -7 }, /* (277) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
- { 197, -7 }, /* (278) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
- { 197, -7 }, /* (279) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
- { 197, -7 }, /* (280) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
- { 197, -7 }, /* (281) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
- { 197, -7 }, /* (282) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
- { 197, -8 }, /* (283) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
- { 197, -9 }, /* (284) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
- { 197, -7 }, /* (285) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
- { 197, -3 }, /* (286) cmd ::= KILL CONNECTION INTEGER */
- { 197, -5 }, /* (287) cmd ::= KILL STREAM INTEGER COLON INTEGER */
- { 197, -5 }, /* (288) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+ { 197, -1 }, /* (0) program ::= cmd */
+ { 198, -2 }, /* (1) cmd ::= SHOW DATABASES */
+ { 198, -2 }, /* (2) cmd ::= SHOW TOPICS */
+ { 198, -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
+ { 198, -2 }, /* (4) cmd ::= SHOW MNODES */
+ { 198, -2 }, /* (5) cmd ::= SHOW DNODES */
+ { 198, -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
+ { 198, -2 }, /* (7) cmd ::= SHOW USERS */
+ { 198, -2 }, /* (8) cmd ::= SHOW MODULES */
+ { 198, -2 }, /* (9) cmd ::= SHOW QUERIES */
+ { 198, -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
+ { 198, -2 }, /* (11) cmd ::= SHOW STREAMS */
+ { 198, -2 }, /* (12) cmd ::= SHOW VARIABLES */
+ { 198, -2 }, /* (13) cmd ::= SHOW SCORES */
+ { 198, -2 }, /* (14) cmd ::= SHOW GRANTS */
+ { 198, -2 }, /* (15) cmd ::= SHOW VNODES */
+ { 198, -3 }, /* (16) cmd ::= SHOW VNODES IPTOKEN */
+ { 199, 0 }, /* (17) dbPrefix ::= */
+ { 199, -2 }, /* (18) dbPrefix ::= ids DOT */
+ { 201, 0 }, /* (19) cpxName ::= */
+ { 201, -2 }, /* (20) cpxName ::= DOT ids */
+ { 198, -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
+ { 198, -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
+ { 198, -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
+ { 198, -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
+ { 198, -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE ids */
+ { 198, -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
+ { 198, -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE ids */
+ { 198, -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
+ { 198, -4 }, /* (29) cmd ::= SHOW dbPrefix VGROUPS ids */
+ { 198, -5 }, /* (30) cmd ::= DROP TABLE ifexists ids cpxName */
+ { 198, -5 }, /* (31) cmd ::= DROP STABLE ifexists ids cpxName */
+ { 198, -4 }, /* (32) cmd ::= DROP DATABASE ifexists ids */
+ { 198, -4 }, /* (33) cmd ::= DROP TOPIC ifexists ids */
+ { 198, -3 }, /* (34) cmd ::= DROP FUNCTION ids */
+ { 198, -3 }, /* (35) cmd ::= DROP DNODE ids */
+ { 198, -3 }, /* (36) cmd ::= DROP USER ids */
+ { 198, -3 }, /* (37) cmd ::= DROP ACCOUNT ids */
+ { 198, -2 }, /* (38) cmd ::= USE ids */
+ { 198, -3 }, /* (39) cmd ::= DESCRIBE ids cpxName */
+ { 198, -3 }, /* (40) cmd ::= DESC ids cpxName */
+ { 198, -5 }, /* (41) cmd ::= ALTER USER ids PASS ids */
+ { 198, -5 }, /* (42) cmd ::= ALTER USER ids PRIVILEGE ids */
+ { 198, -4 }, /* (43) cmd ::= ALTER DNODE ids ids */
+ { 198, -5 }, /* (44) cmd ::= ALTER DNODE ids ids ids */
+ { 198, -3 }, /* (45) cmd ::= ALTER LOCAL ids */
+ { 198, -4 }, /* (46) cmd ::= ALTER LOCAL ids ids */
+ { 198, -4 }, /* (47) cmd ::= ALTER DATABASE ids alter_db_optr */
+ { 198, -4 }, /* (48) cmd ::= ALTER TOPIC ids alter_topic_optr */
+ { 198, -4 }, /* (49) cmd ::= ALTER ACCOUNT ids acct_optr */
+ { 198, -6 }, /* (50) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+ { 198, -6 }, /* (51) cmd ::= COMPACT VNODES IN LP exprlist RP */
+ { 200, -1 }, /* (52) ids ::= ID */
+ { 200, -1 }, /* (53) ids ::= STRING */
+ { 202, -2 }, /* (54) ifexists ::= IF EXISTS */
+ { 202, 0 }, /* (55) ifexists ::= */
+ { 207, -3 }, /* (56) ifnotexists ::= IF NOT EXISTS */
+ { 207, 0 }, /* (57) ifnotexists ::= */
+ { 198, -3 }, /* (58) cmd ::= CREATE DNODE ids */
+ { 198, -6 }, /* (59) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+ { 198, -5 }, /* (60) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+ { 198, -5 }, /* (61) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
+ { 198, -8 }, /* (62) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+ { 198, -9 }, /* (63) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+ { 198, -5 }, /* (64) cmd ::= CREATE USER ids PASS ids */
+ { 211, 0 }, /* (65) bufsize ::= */
+ { 211, -2 }, /* (66) bufsize ::= BUFSIZE INTEGER */
+ { 212, 0 }, /* (67) pps ::= */
+ { 212, -2 }, /* (68) pps ::= PPS INTEGER */
+ { 213, 0 }, /* (69) tseries ::= */
+ { 213, -2 }, /* (70) tseries ::= TSERIES INTEGER */
+ { 214, 0 }, /* (71) dbs ::= */
+ { 214, -2 }, /* (72) dbs ::= DBS INTEGER */
+ { 215, 0 }, /* (73) streams ::= */
+ { 215, -2 }, /* (74) streams ::= STREAMS INTEGER */
+ { 216, 0 }, /* (75) storage ::= */
+ { 216, -2 }, /* (76) storage ::= STORAGE INTEGER */
+ { 217, 0 }, /* (77) qtime ::= */
+ { 217, -2 }, /* (78) qtime ::= QTIME INTEGER */
+ { 218, 0 }, /* (79) users ::= */
+ { 218, -2 }, /* (80) users ::= USERS INTEGER */
+ { 219, 0 }, /* (81) conns ::= */
+ { 219, -2 }, /* (82) conns ::= CONNS INTEGER */
+ { 220, 0 }, /* (83) state ::= */
+ { 220, -2 }, /* (84) state ::= STATE ids */
+ { 205, -9 }, /* (85) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+ { 221, -3 }, /* (86) intitemlist ::= intitemlist COMMA intitem */
+ { 221, -1 }, /* (87) intitemlist ::= intitem */
+ { 222, -1 }, /* (88) intitem ::= INTEGER */
+ { 223, -2 }, /* (89) keep ::= KEEP intitemlist */
+ { 224, -2 }, /* (90) cache ::= CACHE INTEGER */
+ { 225, -2 }, /* (91) replica ::= REPLICA INTEGER */
+ { 226, -2 }, /* (92) quorum ::= QUORUM INTEGER */
+ { 227, -2 }, /* (93) days ::= DAYS INTEGER */
+ { 228, -2 }, /* (94) minrows ::= MINROWS INTEGER */
+ { 229, -2 }, /* (95) maxrows ::= MAXROWS INTEGER */
+ { 230, -2 }, /* (96) blocks ::= BLOCKS INTEGER */
+ { 231, -2 }, /* (97) ctime ::= CTIME INTEGER */
+ { 232, -2 }, /* (98) wal ::= WAL INTEGER */
+ { 233, -2 }, /* (99) fsync ::= FSYNC INTEGER */
+ { 234, -2 }, /* (100) comp ::= COMP INTEGER */
+ { 235, -2 }, /* (101) prec ::= PRECISION STRING */
+ { 236, -2 }, /* (102) update ::= UPDATE INTEGER */
+ { 237, -2 }, /* (103) cachelast ::= CACHELAST INTEGER */
+ { 238, -2 }, /* (104) partitions ::= PARTITIONS INTEGER */
+ { 208, 0 }, /* (105) db_optr ::= */
+ { 208, -2 }, /* (106) db_optr ::= db_optr cache */
+ { 208, -2 }, /* (107) db_optr ::= db_optr replica */
+ { 208, -2 }, /* (108) db_optr ::= db_optr quorum */
+ { 208, -2 }, /* (109) db_optr ::= db_optr days */
+ { 208, -2 }, /* (110) db_optr ::= db_optr minrows */
+ { 208, -2 }, /* (111) db_optr ::= db_optr maxrows */
+ { 208, -2 }, /* (112) db_optr ::= db_optr blocks */
+ { 208, -2 }, /* (113) db_optr ::= db_optr ctime */
+ { 208, -2 }, /* (114) db_optr ::= db_optr wal */
+ { 208, -2 }, /* (115) db_optr ::= db_optr fsync */
+ { 208, -2 }, /* (116) db_optr ::= db_optr comp */
+ { 208, -2 }, /* (117) db_optr ::= db_optr prec */
+ { 208, -2 }, /* (118) db_optr ::= db_optr keep */
+ { 208, -2 }, /* (119) db_optr ::= db_optr update */
+ { 208, -2 }, /* (120) db_optr ::= db_optr cachelast */
+ { 209, -1 }, /* (121) topic_optr ::= db_optr */
+ { 209, -2 }, /* (122) topic_optr ::= topic_optr partitions */
+ { 203, 0 }, /* (123) alter_db_optr ::= */
+ { 203, -2 }, /* (124) alter_db_optr ::= alter_db_optr replica */
+ { 203, -2 }, /* (125) alter_db_optr ::= alter_db_optr quorum */
+ { 203, -2 }, /* (126) alter_db_optr ::= alter_db_optr keep */
+ { 203, -2 }, /* (127) alter_db_optr ::= alter_db_optr blocks */
+ { 203, -2 }, /* (128) alter_db_optr ::= alter_db_optr comp */
+ { 203, -2 }, /* (129) alter_db_optr ::= alter_db_optr update */
+ { 203, -2 }, /* (130) alter_db_optr ::= alter_db_optr cachelast */
+ { 204, -1 }, /* (131) alter_topic_optr ::= alter_db_optr */
+ { 204, -2 }, /* (132) alter_topic_optr ::= alter_topic_optr partitions */
+ { 210, -1 }, /* (133) typename ::= ids */
+ { 210, -4 }, /* (134) typename ::= ids LP signed RP */
+ { 210, -2 }, /* (135) typename ::= ids UNSIGNED */
+ { 239, -1 }, /* (136) signed ::= INTEGER */
+ { 239, -2 }, /* (137) signed ::= PLUS INTEGER */
+ { 239, -2 }, /* (138) signed ::= MINUS INTEGER */
+ { 198, -3 }, /* (139) cmd ::= CREATE TABLE create_table_args */
+ { 198, -3 }, /* (140) cmd ::= CREATE TABLE create_stable_args */
+ { 198, -3 }, /* (141) cmd ::= CREATE STABLE create_stable_args */
+ { 198, -3 }, /* (142) cmd ::= CREATE TABLE create_table_list */
+ { 242, -1 }, /* (143) create_table_list ::= create_from_stable */
+ { 242, -2 }, /* (144) create_table_list ::= create_table_list create_from_stable */
+ { 240, -6 }, /* (145) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+ { 241, -10 }, /* (146) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+ { 243, -10 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+ { 243, -13 }, /* (148) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+ { 246, -3 }, /* (149) tagNamelist ::= tagNamelist COMMA ids */
+ { 246, -1 }, /* (150) tagNamelist ::= ids */
+ { 240, -5 }, /* (151) create_table_args ::= ifnotexists ids cpxName AS select */
+ { 244, -3 }, /* (152) columnlist ::= columnlist COMMA column */
+ { 244, -1 }, /* (153) columnlist ::= column */
+ { 248, -2 }, /* (154) column ::= ids typename */
+ { 245, -3 }, /* (155) tagitemlist ::= tagitemlist COMMA tagitem */
+ { 245, -1 }, /* (156) tagitemlist ::= tagitem */
+ { 249, -1 }, /* (157) tagitem ::= INTEGER */
+ { 249, -1 }, /* (158) tagitem ::= FLOAT */
+ { 249, -1 }, /* (159) tagitem ::= STRING */
+ { 249, -1 }, /* (160) tagitem ::= BOOL */
+ { 249, -1 }, /* (161) tagitem ::= NULL */
+ { 249, -1 }, /* (162) tagitem ::= NOW */
+ { 249, -2 }, /* (163) tagitem ::= MINUS INTEGER */
+ { 249, -2 }, /* (164) tagitem ::= MINUS FLOAT */
+ { 249, -2 }, /* (165) tagitem ::= PLUS INTEGER */
+ { 249, -2 }, /* (166) tagitem ::= PLUS FLOAT */
+ { 247, -14 }, /* (167) select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+ { 247, -3 }, /* (168) select ::= LP select RP */
+ { 263, -1 }, /* (169) union ::= select */
+ { 263, -4 }, /* (170) union ::= union UNION ALL select */
+ { 198, -1 }, /* (171) cmd ::= union */
+ { 247, -2 }, /* (172) select ::= SELECT selcollist */
+ { 264, -2 }, /* (173) sclp ::= selcollist COMMA */
+ { 264, 0 }, /* (174) sclp ::= */
+ { 250, -4 }, /* (175) selcollist ::= sclp distinct expr as */
+ { 250, -2 }, /* (176) selcollist ::= sclp STAR */
+ { 267, -2 }, /* (177) as ::= AS ids */
+ { 267, -1 }, /* (178) as ::= ids */
+ { 267, 0 }, /* (179) as ::= */
+ { 265, -1 }, /* (180) distinct ::= DISTINCT */
+ { 265, 0 }, /* (181) distinct ::= */
+ { 251, -2 }, /* (182) from ::= FROM tablelist */
+ { 251, -2 }, /* (183) from ::= FROM sub */
+ { 269, -3 }, /* (184) sub ::= LP union RP */
+ { 269, -4 }, /* (185) sub ::= LP union RP ids */
+ { 269, -6 }, /* (186) sub ::= sub COMMA LP union RP ids */
+ { 268, -2 }, /* (187) tablelist ::= ids cpxName */
+ { 268, -3 }, /* (188) tablelist ::= ids cpxName ids */
+ { 268, -4 }, /* (189) tablelist ::= tablelist COMMA ids cpxName */
+ { 268, -5 }, /* (190) tablelist ::= tablelist COMMA ids cpxName ids */
+ { 270, -1 }, /* (191) tmvar ::= VARIABLE */
+ { 253, -4 }, /* (192) interval_option ::= intervalKey LP tmvar RP */
+ { 253, -6 }, /* (193) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
+ { 253, 0 }, /* (194) interval_option ::= */
+ { 271, -1 }, /* (195) intervalKey ::= INTERVAL */
+ { 271, -1 }, /* (196) intervalKey ::= EVERY */
+ { 255, 0 }, /* (197) session_option ::= */
+ { 255, -7 }, /* (198) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+ { 256, 0 }, /* (199) windowstate_option ::= */
+ { 256, -4 }, /* (200) windowstate_option ::= STATE_WINDOW LP ids RP */
+ { 257, 0 }, /* (201) fill_opt ::= */
+ { 257, -6 }, /* (202) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+ { 257, -4 }, /* (203) fill_opt ::= FILL LP ID RP */
+ { 254, -4 }, /* (204) sliding_opt ::= SLIDING LP tmvar RP */
+ { 254, 0 }, /* (205) sliding_opt ::= */
+ { 260, 0 }, /* (206) orderby_opt ::= */
+ { 260, -3 }, /* (207) orderby_opt ::= ORDER BY sortlist */
+ { 272, -4 }, /* (208) sortlist ::= sortlist COMMA item sortorder */
+ { 272, -2 }, /* (209) sortlist ::= item sortorder */
+ { 274, -2 }, /* (210) item ::= ids cpxName */
+ { 275, -1 }, /* (211) sortorder ::= ASC */
+ { 275, -1 }, /* (212) sortorder ::= DESC */
+ { 275, 0 }, /* (213) sortorder ::= */
+ { 258, 0 }, /* (214) groupby_opt ::= */
+ { 258, -3 }, /* (215) groupby_opt ::= GROUP BY grouplist */
+ { 276, -3 }, /* (216) grouplist ::= grouplist COMMA item */
+ { 276, -1 }, /* (217) grouplist ::= item */
+ { 259, 0 }, /* (218) having_opt ::= */
+ { 259, -2 }, /* (219) having_opt ::= HAVING expr */
+ { 262, 0 }, /* (220) limit_opt ::= */
+ { 262, -2 }, /* (221) limit_opt ::= LIMIT signed */
+ { 262, -4 }, /* (222) limit_opt ::= LIMIT signed OFFSET signed */
+ { 262, -4 }, /* (223) limit_opt ::= LIMIT signed COMMA signed */
+ { 261, 0 }, /* (224) slimit_opt ::= */
+ { 261, -2 }, /* (225) slimit_opt ::= SLIMIT signed */
+ { 261, -4 }, /* (226) slimit_opt ::= SLIMIT signed SOFFSET signed */
+ { 261, -4 }, /* (227) slimit_opt ::= SLIMIT signed COMMA signed */
+ { 252, 0 }, /* (228) where_opt ::= */
+ { 252, -2 }, /* (229) where_opt ::= WHERE expr */
+ { 266, -3 }, /* (230) expr ::= LP expr RP */
+ { 266, -1 }, /* (231) expr ::= ID */
+ { 266, -3 }, /* (232) expr ::= ID DOT ID */
+ { 266, -3 }, /* (233) expr ::= ID DOT STAR */
+ { 266, -1 }, /* (234) expr ::= INTEGER */
+ { 266, -2 }, /* (235) expr ::= MINUS INTEGER */
+ { 266, -2 }, /* (236) expr ::= PLUS INTEGER */
+ { 266, -1 }, /* (237) expr ::= FLOAT */
+ { 266, -2 }, /* (238) expr ::= MINUS FLOAT */
+ { 266, -2 }, /* (239) expr ::= PLUS FLOAT */
+ { 266, -1 }, /* (240) expr ::= STRING */
+ { 266, -1 }, /* (241) expr ::= NOW */
+ { 266, -1 }, /* (242) expr ::= VARIABLE */
+ { 266, -2 }, /* (243) expr ::= PLUS VARIABLE */
+ { 266, -2 }, /* (244) expr ::= MINUS VARIABLE */
+ { 266, -1 }, /* (245) expr ::= BOOL */
+ { 266, -1 }, /* (246) expr ::= NULL */
+ { 266, -4 }, /* (247) expr ::= ID LP exprlist RP */
+ { 266, -4 }, /* (248) expr ::= ID LP STAR RP */
+ { 266, -3 }, /* (249) expr ::= expr IS NULL */
+ { 266, -4 }, /* (250) expr ::= expr IS NOT NULL */
+ { 266, -3 }, /* (251) expr ::= expr LT expr */
+ { 266, -3 }, /* (252) expr ::= expr GT expr */
+ { 266, -3 }, /* (253) expr ::= expr LE expr */
+ { 266, -3 }, /* (254) expr ::= expr GE expr */
+ { 266, -3 }, /* (255) expr ::= expr NE expr */
+ { 266, -3 }, /* (256) expr ::= expr EQ expr */
+ { 266, -5 }, /* (257) expr ::= expr BETWEEN expr AND expr */
+ { 266, -3 }, /* (258) expr ::= expr AND expr */
+ { 266, -3 }, /* (259) expr ::= expr OR expr */
+ { 266, -3 }, /* (260) expr ::= expr PLUS expr */
+ { 266, -3 }, /* (261) expr ::= expr MINUS expr */
+ { 266, -3 }, /* (262) expr ::= expr STAR expr */
+ { 266, -3 }, /* (263) expr ::= expr SLASH expr */
+ { 266, -3 }, /* (264) expr ::= expr REM expr */
+ { 266, -3 }, /* (265) expr ::= expr LIKE expr */
+ { 266, -5 }, /* (266) expr ::= expr IN LP exprlist RP */
+ { 206, -3 }, /* (267) exprlist ::= exprlist COMMA expritem */
+ { 206, -1 }, /* (268) exprlist ::= expritem */
+ { 277, -1 }, /* (269) expritem ::= expr */
+ { 277, 0 }, /* (270) expritem ::= */
+ { 198, -3 }, /* (271) cmd ::= RESET QUERY CACHE */
+ { 198, -3 }, /* (272) cmd ::= SYNCDB ids REPLICA */
+ { 198, -7 }, /* (273) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+ { 198, -7 }, /* (274) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+ { 198, -7 }, /* (275) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+ { 198, -7 }, /* (276) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+ { 198, -7 }, /* (277) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+ { 198, -8 }, /* (278) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+ { 198, -9 }, /* (279) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+ { 198, -7 }, /* (280) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+ { 198, -7 }, /* (281) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+ { 198, -7 }, /* (282) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+ { 198, -7 }, /* (283) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+ { 198, -7 }, /* (284) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+ { 198, -7 }, /* (285) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+ { 198, -8 }, /* (286) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+ { 198, -9 }, /* (287) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+ { 198, -7 }, /* (288) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+ { 198, -3 }, /* (289) cmd ::= KILL CONNECTION INTEGER */
+ { 198, -5 }, /* (290) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+ { 198, -5 }, /* (291) cmd ::= KILL QUERY INTEGER COLON INTEGER */
};
static void yy_accept(yyParser*); /* Forward Declaration */
@@ -2194,9 +2205,9 @@ static void yy_reduce(
/********** Begin reduce actions **********************************************/
YYMINORTYPE yylhsminor;
case 0: /* program ::= cmd */
- case 138: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==138);
- case 139: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==139);
- case 140: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==140);
+ case 139: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==139);
+ case 140: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==140);
+ case 141: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==141);
{}
break;
case 1: /* cmd ::= SHOW DATABASES */
@@ -2347,784 +2358,793 @@ static void yy_reduce(
{ setDCLSqlElems(pInfo, TSDB_SQL_USE_DB, 1, &yymsp[0].minor.yy0);}
break;
case 39: /* cmd ::= DESCRIBE ids cpxName */
+ case 40: /* cmd ::= DESC ids cpxName */ yytestcase(yyruleno==40);
{
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
setDCLSqlElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &yymsp[-1].minor.yy0);
}
break;
- case 40: /* cmd ::= ALTER USER ids PASS ids */
+ case 41: /* cmd ::= ALTER USER ids PASS ids */
{ setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, NULL); }
break;
- case 41: /* cmd ::= ALTER USER ids PRIVILEGE ids */
+ case 42: /* cmd ::= ALTER USER ids PRIVILEGE ids */
{ setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &yymsp[-2].minor.yy0, NULL, &yymsp[0].minor.yy0);}
break;
- case 42: /* cmd ::= ALTER DNODE ids ids */
+ case 43: /* cmd ::= ALTER DNODE ids ids */
{ setDCLSqlElems(pInfo, TSDB_SQL_CFG_DNODE, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
break;
- case 43: /* cmd ::= ALTER DNODE ids ids ids */
+ case 44: /* 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 44: /* cmd ::= ALTER LOCAL ids */
+ case 45: /* cmd ::= ALTER LOCAL ids */
{ setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &yymsp[0].minor.yy0); }
break;
- case 45: /* cmd ::= ALTER LOCAL ids ids */
+ case 46: /* cmd ::= ALTER LOCAL ids ids */
{ setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
break;
- case 46: /* cmd ::= ALTER DATABASE ids alter_db_optr */
- case 47: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==47);
-{ SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy214, &t);}
+ case 47: /* cmd ::= ALTER DATABASE ids alter_db_optr */
+ case 48: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==48);
+{ SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy90, &t);}
break;
- case 48: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy547);}
+ case 49: /* cmd ::= ALTER ACCOUNT ids acct_optr */
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy171);}
break;
- case 49: /* 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.yy547);}
+ case 50: /* 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.yy171);}
break;
- case 50: /* cmd ::= COMPACT VNODES IN LP exprlist RP */
-{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy525);}
+ case 51: /* cmd ::= COMPACT VNODES IN LP exprlist RP */
+{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy421);}
break;
- case 51: /* ids ::= ID */
- case 52: /* ids ::= STRING */ yytestcase(yyruleno==52);
+ case 52: /* ids ::= ID */
+ case 53: /* ids ::= STRING */ yytestcase(yyruleno==53);
{yylhsminor.yy0 = yymsp[0].minor.yy0; }
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
- case 53: /* ifexists ::= IF EXISTS */
+ case 54: /* ifexists ::= IF EXISTS */
{ yymsp[-1].minor.yy0.n = 1;}
break;
- case 54: /* ifexists ::= */
- case 56: /* ifnotexists ::= */ yytestcase(yyruleno==56);
- case 180: /* distinct ::= */ yytestcase(yyruleno==180);
+ case 55: /* ifexists ::= */
+ case 57: /* ifnotexists ::= */ yytestcase(yyruleno==57);
+ case 181: /* distinct ::= */ yytestcase(yyruleno==181);
{ yymsp[1].minor.yy0.n = 0;}
break;
- case 55: /* ifnotexists ::= IF NOT EXISTS */
+ case 56: /* ifnotexists ::= IF NOT EXISTS */
{ yymsp[-2].minor.yy0.n = 1;}
break;
- case 57: /* cmd ::= CREATE DNODE ids */
+ case 58: /* cmd ::= CREATE DNODE ids */
{ setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
break;
- case 58: /* 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.yy547);}
+ case 59: /* 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.yy171);}
break;
- case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
- case 60: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==60);
-{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy214, &yymsp[-2].minor.yy0);}
+ case 60: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+ case 61: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==61);
+{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy90, &yymsp[-2].minor.yy0);}
break;
- case 61: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy31, &yymsp[0].minor.yy0, 1);}
+ case 62: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy183, &yymsp[0].minor.yy0, 1);}
break;
- case 62: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy31, &yymsp[0].minor.yy0, 2);}
+ case 63: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy183, &yymsp[0].minor.yy0, 2);}
break;
- case 63: /* cmd ::= CREATE USER ids PASS ids */
+ case 64: /* cmd ::= CREATE USER ids PASS ids */
{ setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
break;
- case 64: /* bufsize ::= */
- case 66: /* pps ::= */ yytestcase(yyruleno==66);
- case 68: /* tseries ::= */ yytestcase(yyruleno==68);
- case 70: /* dbs ::= */ yytestcase(yyruleno==70);
- case 72: /* streams ::= */ yytestcase(yyruleno==72);
- case 74: /* storage ::= */ yytestcase(yyruleno==74);
- case 76: /* qtime ::= */ yytestcase(yyruleno==76);
- case 78: /* users ::= */ yytestcase(yyruleno==78);
- case 80: /* conns ::= */ yytestcase(yyruleno==80);
- case 82: /* state ::= */ yytestcase(yyruleno==82);
+ case 65: /* bufsize ::= */
+ case 67: /* pps ::= */ yytestcase(yyruleno==67);
+ case 69: /* tseries ::= */ yytestcase(yyruleno==69);
+ case 71: /* dbs ::= */ yytestcase(yyruleno==71);
+ case 73: /* streams ::= */ yytestcase(yyruleno==73);
+ case 75: /* storage ::= */ yytestcase(yyruleno==75);
+ case 77: /* qtime ::= */ yytestcase(yyruleno==77);
+ case 79: /* users ::= */ yytestcase(yyruleno==79);
+ case 81: /* conns ::= */ yytestcase(yyruleno==81);
+ case 83: /* state ::= */ yytestcase(yyruleno==83);
{ yymsp[1].minor.yy0.n = 0; }
break;
- case 65: /* bufsize ::= BUFSIZE INTEGER */
- case 67: /* pps ::= PPS INTEGER */ yytestcase(yyruleno==67);
- case 69: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==69);
- case 71: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==71);
- case 73: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==73);
- case 75: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==75);
- case 77: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==77);
- case 79: /* users ::= USERS INTEGER */ yytestcase(yyruleno==79);
- case 81: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==81);
- case 83: /* state ::= STATE ids */ yytestcase(yyruleno==83);
+ case 66: /* bufsize ::= BUFSIZE INTEGER */
+ case 68: /* pps ::= PPS INTEGER */ yytestcase(yyruleno==68);
+ case 70: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==70);
+ case 72: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==72);
+ case 74: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==74);
+ case 76: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==76);
+ case 78: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==78);
+ case 80: /* users ::= USERS INTEGER */ yytestcase(yyruleno==80);
+ case 82: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==82);
+ case 84: /* state ::= STATE ids */ yytestcase(yyruleno==84);
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
- case 84: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-{
- yylhsminor.yy547.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
- yylhsminor.yy547.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
- yylhsminor.yy547.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
- yylhsminor.yy547.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
- yylhsminor.yy547.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
- yylhsminor.yy547.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
- yylhsminor.yy547.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
- yylhsminor.yy547.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
- yylhsminor.yy547.stat = yymsp[0].minor.yy0;
-}
- yymsp[-8].minor.yy547 = yylhsminor.yy547;
- break;
- case 85: /* intitemlist ::= intitemlist COMMA intitem */
- case 154: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==154);
-{ yylhsminor.yy525 = tVariantListAppend(yymsp[-2].minor.yy525, &yymsp[0].minor.yy506, -1); }
- yymsp[-2].minor.yy525 = yylhsminor.yy525;
- break;
- case 86: /* intitemlist ::= intitem */
- case 155: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==155);
-{ yylhsminor.yy525 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1); }
- yymsp[0].minor.yy525 = yylhsminor.yy525;
- break;
- case 87: /* intitem ::= INTEGER */
- case 156: /* tagitem ::= INTEGER */ yytestcase(yyruleno==156);
- case 157: /* tagitem ::= FLOAT */ yytestcase(yyruleno==157);
- case 158: /* tagitem ::= STRING */ yytestcase(yyruleno==158);
- case 159: /* tagitem ::= BOOL */ yytestcase(yyruleno==159);
-{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy506 = yylhsminor.yy506;
- break;
- case 88: /* keep ::= KEEP intitemlist */
-{ yymsp[-1].minor.yy525 = yymsp[0].minor.yy525; }
- break;
- case 89: /* cache ::= CACHE INTEGER */
- case 90: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==90);
- case 91: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==91);
- case 92: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==92);
- case 93: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==93);
- case 94: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==94);
- case 95: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==95);
- case 96: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==96);
- case 97: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==97);
- case 98: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==98);
- case 99: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==99);
- case 100: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==100);
- case 101: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==101);
- case 102: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==102);
- case 103: /* partitions ::= PARTITIONS INTEGER */ yytestcase(yyruleno==103);
+ case 85: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+{
+ yylhsminor.yy171.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+ yylhsminor.yy171.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+ yylhsminor.yy171.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+ yylhsminor.yy171.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+ yylhsminor.yy171.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+ yylhsminor.yy171.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+ yylhsminor.yy171.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+ yylhsminor.yy171.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+ yylhsminor.yy171.stat = yymsp[0].minor.yy0;
+}
+ yymsp[-8].minor.yy171 = yylhsminor.yy171;
+ break;
+ case 86: /* intitemlist ::= intitemlist COMMA intitem */
+ case 155: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==155);
+{ yylhsminor.yy421 = tVariantListAppend(yymsp[-2].minor.yy421, &yymsp[0].minor.yy430, -1); }
+ yymsp[-2].minor.yy421 = yylhsminor.yy421;
+ break;
+ case 87: /* intitemlist ::= intitem */
+ case 156: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==156);
+{ yylhsminor.yy421 = tVariantListAppend(NULL, &yymsp[0].minor.yy430, -1); }
+ yymsp[0].minor.yy421 = yylhsminor.yy421;
+ break;
+ case 88: /* intitem ::= INTEGER */
+ case 157: /* tagitem ::= INTEGER */ yytestcase(yyruleno==157);
+ case 158: /* tagitem ::= FLOAT */ yytestcase(yyruleno==158);
+ case 159: /* tagitem ::= STRING */ yytestcase(yyruleno==159);
+ case 160: /* tagitem ::= BOOL */ yytestcase(yyruleno==160);
+{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy430, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy430 = yylhsminor.yy430;
+ break;
+ case 89: /* keep ::= KEEP intitemlist */
+{ yymsp[-1].minor.yy421 = yymsp[0].minor.yy421; }
+ break;
+ case 90: /* cache ::= CACHE INTEGER */
+ case 91: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==91);
+ case 92: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==92);
+ case 93: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==93);
+ case 94: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==94);
+ case 95: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==95);
+ case 96: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==96);
+ case 97: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==97);
+ case 98: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==98);
+ case 99: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==99);
+ case 100: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==100);
+ case 101: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==101);
+ case 102: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==102);
+ case 103: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==103);
+ case 104: /* partitions ::= PARTITIONS INTEGER */ yytestcase(yyruleno==104);
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
- case 104: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy214); yymsp[1].minor.yy214.dbType = TSDB_DB_TYPE_DEFAULT;}
- break;
- case 105: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 106: /* db_optr ::= db_optr replica */
- case 123: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==123);
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 107: /* db_optr ::= db_optr quorum */
- case 124: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==124);
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 108: /* db_optr ::= db_optr days */
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 109: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 110: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 111: /* db_optr ::= db_optr blocks */
- case 126: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==126);
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 112: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 113: /* db_optr ::= db_optr wal */
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 114: /* db_optr ::= db_optr fsync */
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 115: /* db_optr ::= db_optr comp */
- case 127: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==127);
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 116: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.precision = yymsp[0].minor.yy0; }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 117: /* db_optr ::= db_optr keep */
- case 125: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==125);
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.keep = yymsp[0].minor.yy525; }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 118: /* db_optr ::= db_optr update */
- case 128: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==128);
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 119: /* db_optr ::= db_optr cachelast */
- case 129: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==129);
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 120: /* topic_optr ::= db_optr */
- case 130: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==130);
-{ yylhsminor.yy214 = yymsp[0].minor.yy214; yylhsminor.yy214.dbType = TSDB_DB_TYPE_TOPIC; }
- yymsp[0].minor.yy214 = yylhsminor.yy214;
- break;
- case 121: /* topic_optr ::= topic_optr partitions */
- case 131: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==131);
-{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy214 = yylhsminor.yy214;
- break;
- case 122: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy214); yymsp[1].minor.yy214.dbType = TSDB_DB_TYPE_DEFAULT;}
- break;
- case 132: /* typename ::= ids */
-{
+ case 105: /* db_optr ::= */
+{setDefaultCreateDbOption(&yymsp[1].minor.yy90); yymsp[1].minor.yy90.dbType = TSDB_DB_TYPE_DEFAULT;}
+ break;
+ case 106: /* db_optr ::= db_optr cache */
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 107: /* db_optr ::= db_optr replica */
+ case 124: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==124);
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 108: /* db_optr ::= db_optr quorum */
+ case 125: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==125);
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 109: /* db_optr ::= db_optr days */
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 110: /* db_optr ::= db_optr minrows */
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 111: /* db_optr ::= db_optr maxrows */
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 112: /* db_optr ::= db_optr blocks */
+ case 127: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==127);
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 113: /* db_optr ::= db_optr ctime */
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 114: /* db_optr ::= db_optr wal */
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 115: /* db_optr ::= db_optr fsync */
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 116: /* db_optr ::= db_optr comp */
+ case 128: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==128);
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 117: /* db_optr ::= db_optr prec */
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.precision = yymsp[0].minor.yy0; }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 118: /* db_optr ::= db_optr keep */
+ case 126: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==126);
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.keep = yymsp[0].minor.yy421; }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 119: /* db_optr ::= db_optr update */
+ case 129: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==129);
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 120: /* db_optr ::= db_optr cachelast */
+ case 130: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==130);
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 121: /* topic_optr ::= db_optr */
+ case 131: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==131);
+{ yylhsminor.yy90 = yymsp[0].minor.yy90; yylhsminor.yy90.dbType = TSDB_DB_TYPE_TOPIC; }
+ yymsp[0].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 122: /* topic_optr ::= topic_optr partitions */
+ case 132: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==132);
+{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy90 = yylhsminor.yy90;
+ break;
+ case 123: /* alter_db_optr ::= */
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy90); yymsp[1].minor.yy90.dbType = TSDB_DB_TYPE_DEFAULT;}
+ break;
+ case 133: /* typename ::= ids */
+{
yymsp[0].minor.yy0.type = 0;
- tSetColumnType (&yylhsminor.yy31, &yymsp[0].minor.yy0);
+ tSetColumnType (&yylhsminor.yy183, &yymsp[0].minor.yy0);
}
- yymsp[0].minor.yy31 = yylhsminor.yy31;
+ yymsp[0].minor.yy183 = yylhsminor.yy183;
break;
- case 133: /* typename ::= ids LP signed RP */
+ case 134: /* typename ::= ids LP signed RP */
{
- if (yymsp[-1].minor.yy501 <= 0) {
+ if (yymsp[-1].minor.yy325 <= 0) {
yymsp[-3].minor.yy0.type = 0;
- tSetColumnType(&yylhsminor.yy31, &yymsp[-3].minor.yy0);
+ tSetColumnType(&yylhsminor.yy183, &yymsp[-3].minor.yy0);
} else {
- yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy501; // negative value of name length
- tSetColumnType(&yylhsminor.yy31, &yymsp[-3].minor.yy0);
+ yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy325; // negative value of name length
+ tSetColumnType(&yylhsminor.yy183, &yymsp[-3].minor.yy0);
}
}
- yymsp[-3].minor.yy31 = yylhsminor.yy31;
+ yymsp[-3].minor.yy183 = yylhsminor.yy183;
break;
- case 134: /* typename ::= ids UNSIGNED */
+ case 135: /* 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);
- tSetColumnType (&yylhsminor.yy31, &yymsp[-1].minor.yy0);
+ tSetColumnType (&yylhsminor.yy183, &yymsp[-1].minor.yy0);
}
- yymsp[-1].minor.yy31 = yylhsminor.yy31;
+ yymsp[-1].minor.yy183 = yylhsminor.yy183;
break;
- case 135: /* signed ::= INTEGER */
-{ yylhsminor.yy501 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[0].minor.yy501 = yylhsminor.yy501;
+ case 136: /* signed ::= INTEGER */
+{ yylhsminor.yy325 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[0].minor.yy325 = yylhsminor.yy325;
break;
- case 136: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy501 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ case 137: /* signed ::= PLUS INTEGER */
+{ yymsp[-1].minor.yy325 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
break;
- case 137: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy501 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+ case 138: /* signed ::= MINUS INTEGER */
+{ yymsp[-1].minor.yy325 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
break;
- case 141: /* cmd ::= CREATE TABLE create_table_list */
-{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy158;}
+ case 142: /* cmd ::= CREATE TABLE create_table_list */
+{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy438;}
break;
- case 142: /* create_table_list ::= create_from_stable */
+ case 143: /* create_table_list ::= create_from_stable */
{
SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql));
pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
- taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy432);
+ taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy152);
pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
- yylhsminor.yy158 = pCreateTable;
+ yylhsminor.yy438 = pCreateTable;
}
- yymsp[0].minor.yy158 = yylhsminor.yy158;
+ yymsp[0].minor.yy438 = yylhsminor.yy438;
break;
- case 143: /* create_table_list ::= create_table_list create_from_stable */
+ case 144: /* create_table_list ::= create_table_list create_from_stable */
{
- taosArrayPush(yymsp[-1].minor.yy158->childTableInfo, &yymsp[0].minor.yy432);
- yylhsminor.yy158 = yymsp[-1].minor.yy158;
+ taosArrayPush(yymsp[-1].minor.yy438->childTableInfo, &yymsp[0].minor.yy152);
+ yylhsminor.yy438 = yymsp[-1].minor.yy438;
}
- yymsp[-1].minor.yy158 = yylhsminor.yy158;
+ yymsp[-1].minor.yy438 = yylhsminor.yy438;
break;
- case 144: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+ case 145: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
{
- yylhsminor.yy158 = tSetCreateTableInfo(yymsp[-1].minor.yy525, NULL, NULL, TSQL_CREATE_TABLE);
- setSqlInfo(pInfo, yylhsminor.yy158, NULL, TSDB_SQL_CREATE_TABLE);
+ yylhsminor.yy438 = tSetCreateTableInfo(yymsp[-1].minor.yy421, NULL, NULL, TSQL_CREATE_TABLE);
+ setSqlInfo(pInfo, yylhsminor.yy438, 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.yy158 = yylhsminor.yy158;
+ yymsp[-5].minor.yy438 = yylhsminor.yy438;
break;
- case 145: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+ case 146: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
{
- yylhsminor.yy158 = tSetCreateTableInfo(yymsp[-5].minor.yy525, yymsp[-1].minor.yy525, NULL, TSQL_CREATE_STABLE);
- setSqlInfo(pInfo, yylhsminor.yy158, NULL, TSDB_SQL_CREATE_TABLE);
+ yylhsminor.yy438 = tSetCreateTableInfo(yymsp[-5].minor.yy421, yymsp[-1].minor.yy421, NULL, TSQL_CREATE_STABLE);
+ setSqlInfo(pInfo, yylhsminor.yy438, 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.yy158 = yylhsminor.yy158;
+ yymsp[-9].minor.yy438 = yylhsminor.yy438;
break;
- case 146: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+ case 147: /* 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.yy432 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy525, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+ yylhsminor.yy152 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy421, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
}
- yymsp[-9].minor.yy432 = yylhsminor.yy432;
+ yymsp[-9].minor.yy152 = yylhsminor.yy152;
break;
- case 147: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+ case 148: /* 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.yy432 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy525, yymsp[-1].minor.yy525, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
+ yylhsminor.yy152 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy421, yymsp[-1].minor.yy421, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
}
- yymsp[-12].minor.yy432 = yylhsminor.yy432;
+ yymsp[-12].minor.yy152 = yylhsminor.yy152;
break;
- case 148: /* tagNamelist ::= tagNamelist COMMA ids */
-{taosArrayPush(yymsp[-2].minor.yy525, &yymsp[0].minor.yy0); yylhsminor.yy525 = yymsp[-2].minor.yy525; }
- yymsp[-2].minor.yy525 = yylhsminor.yy525;
+ case 149: /* tagNamelist ::= tagNamelist COMMA ids */
+{taosArrayPush(yymsp[-2].minor.yy421, &yymsp[0].minor.yy0); yylhsminor.yy421 = yymsp[-2].minor.yy421; }
+ yymsp[-2].minor.yy421 = yylhsminor.yy421;
break;
- case 149: /* tagNamelist ::= ids */
-{yylhsminor.yy525 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy525, &yymsp[0].minor.yy0);}
- yymsp[0].minor.yy525 = yylhsminor.yy525;
+ case 150: /* tagNamelist ::= ids */
+{yylhsminor.yy421 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy421, &yymsp[0].minor.yy0);}
+ yymsp[0].minor.yy421 = yylhsminor.yy421;
break;
- case 150: /* create_table_args ::= ifnotexists ids cpxName AS select */
+ case 151: /* create_table_args ::= ifnotexists ids cpxName AS select */
{
- yylhsminor.yy158 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy464, TSQL_CREATE_STREAM);
- setSqlInfo(pInfo, yylhsminor.yy158, NULL, TSDB_SQL_CREATE_TABLE);
+ yylhsminor.yy438 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy56, TSQL_CREATE_STREAM);
+ setSqlInfo(pInfo, yylhsminor.yy438, 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.yy158 = yylhsminor.yy158;
+ yymsp[-4].minor.yy438 = yylhsminor.yy438;
break;
- case 151: /* columnlist ::= columnlist COMMA column */
-{taosArrayPush(yymsp[-2].minor.yy525, &yymsp[0].minor.yy31); yylhsminor.yy525 = yymsp[-2].minor.yy525; }
- yymsp[-2].minor.yy525 = yylhsminor.yy525;
+ case 152: /* columnlist ::= columnlist COMMA column */
+{taosArrayPush(yymsp[-2].minor.yy421, &yymsp[0].minor.yy183); yylhsminor.yy421 = yymsp[-2].minor.yy421; }
+ yymsp[-2].minor.yy421 = yylhsminor.yy421;
break;
- case 152: /* columnlist ::= column */
-{yylhsminor.yy525 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy525, &yymsp[0].minor.yy31);}
- yymsp[0].minor.yy525 = yylhsminor.yy525;
+ case 153: /* columnlist ::= column */
+{yylhsminor.yy421 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy421, &yymsp[0].minor.yy183);}
+ yymsp[0].minor.yy421 = yylhsminor.yy421;
break;
- case 153: /* column ::= ids typename */
+ case 154: /* column ::= ids typename */
{
- tSetColumnInfo(&yylhsminor.yy31, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy31);
+ tSetColumnInfo(&yylhsminor.yy183, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy183);
}
- yymsp[-1].minor.yy31 = yylhsminor.yy31;
+ yymsp[-1].minor.yy183 = yylhsminor.yy183;
break;
- case 160: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy506 = yylhsminor.yy506;
+ case 161: /* tagitem ::= NULL */
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy430, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy430 = yylhsminor.yy430;
break;
- case 161: /* tagitem ::= NOW */
-{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0);}
- yymsp[0].minor.yy506 = yylhsminor.yy506;
+ case 162: /* tagitem ::= NOW */
+{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreate(&yylhsminor.yy430, &yymsp[0].minor.yy0);}
+ yymsp[0].minor.yy430 = yylhsminor.yy430;
break;
- case 162: /* tagitem ::= MINUS INTEGER */
- case 163: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==163);
- case 164: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==164);
- case 165: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==165);
+ case 163: /* tagitem ::= MINUS INTEGER */
+ case 164: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==164);
+ case 165: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==165);
+ case 166: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==166);
{
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.yy506, &yymsp[-1].minor.yy0);
+ tVariantCreate(&yylhsminor.yy430, &yymsp[-1].minor.yy0);
}
- yymsp[-1].minor.yy506 = yylhsminor.yy506;
+ yymsp[-1].minor.yy430 = yylhsminor.yy430;
break;
- case 166: /* select ::= SELECT selcollist from where_opt interval_opt sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+ case 167: /* select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
{
- yylhsminor.yy464 = tSetQuerySqlNode(&yymsp[-13].minor.yy0, yymsp[-12].minor.yy525, yymsp[-11].minor.yy412, yymsp[-10].minor.yy370, yymsp[-4].minor.yy525, yymsp[-2].minor.yy525, &yymsp[-9].minor.yy520, &yymsp[-7].minor.yy259, &yymsp[-6].minor.yy144, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy525, &yymsp[0].minor.yy126, &yymsp[-1].minor.yy126, yymsp[-3].minor.yy370);
+ yylhsminor.yy56 = tSetQuerySqlNode(&yymsp[-13].minor.yy0, yymsp[-12].minor.yy421, yymsp[-11].minor.yy8, yymsp[-10].minor.yy439, yymsp[-4].minor.yy421, yymsp[-2].minor.yy421, &yymsp[-9].minor.yy400, &yymsp[-7].minor.yy147, &yymsp[-6].minor.yy40, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy421, &yymsp[0].minor.yy166, &yymsp[-1].minor.yy166, yymsp[-3].minor.yy439);
}
- yymsp[-13].minor.yy464 = yylhsminor.yy464;
+ yymsp[-13].minor.yy56 = yylhsminor.yy56;
break;
- case 167: /* select ::= LP select RP */
-{yymsp[-2].minor.yy464 = yymsp[-1].minor.yy464;}
+ case 168: /* select ::= LP select RP */
+{yymsp[-2].minor.yy56 = yymsp[-1].minor.yy56;}
break;
- case 168: /* union ::= select */
-{ yylhsminor.yy525 = setSubclause(NULL, yymsp[0].minor.yy464); }
- yymsp[0].minor.yy525 = yylhsminor.yy525;
+ case 169: /* union ::= select */
+{ yylhsminor.yy421 = setSubclause(NULL, yymsp[0].minor.yy56); }
+ yymsp[0].minor.yy421 = yylhsminor.yy421;
break;
- case 169: /* union ::= union UNION ALL select */
-{ yylhsminor.yy525 = appendSelectClause(yymsp[-3].minor.yy525, yymsp[0].minor.yy464); }
- yymsp[-3].minor.yy525 = yylhsminor.yy525;
+ case 170: /* union ::= union UNION ALL select */
+{ yylhsminor.yy421 = appendSelectClause(yymsp[-3].minor.yy421, yymsp[0].minor.yy56); }
+ yymsp[-3].minor.yy421 = yylhsminor.yy421;
break;
- case 170: /* cmd ::= union */
-{ setSqlInfo(pInfo, yymsp[0].minor.yy525, NULL, TSDB_SQL_SELECT); }
+ case 171: /* cmd ::= union */
+{ setSqlInfo(pInfo, yymsp[0].minor.yy421, NULL, TSDB_SQL_SELECT); }
break;
- case 171: /* select ::= SELECT selcollist */
+ case 172: /* select ::= SELECT selcollist */
{
- yylhsminor.yy464 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy525, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+ yylhsminor.yy56 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy421, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
}
- yymsp[-1].minor.yy464 = yylhsminor.yy464;
+ yymsp[-1].minor.yy56 = yylhsminor.yy56;
break;
- case 172: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy525 = yymsp[-1].minor.yy525;}
- yymsp[-1].minor.yy525 = yylhsminor.yy525;
+ case 173: /* sclp ::= selcollist COMMA */
+{yylhsminor.yy421 = yymsp[-1].minor.yy421;}
+ yymsp[-1].minor.yy421 = yylhsminor.yy421;
break;
- case 173: /* sclp ::= */
- case 203: /* orderby_opt ::= */ yytestcase(yyruleno==203);
-{yymsp[1].minor.yy525 = 0;}
+ case 174: /* sclp ::= */
+ case 206: /* orderby_opt ::= */ yytestcase(yyruleno==206);
+{yymsp[1].minor.yy421 = 0;}
break;
- case 174: /* selcollist ::= sclp distinct expr as */
+ case 175: /* selcollist ::= sclp distinct expr as */
{
- yylhsminor.yy525 = tSqlExprListAppend(yymsp[-3].minor.yy525, yymsp[-1].minor.yy370, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+ yylhsminor.yy421 = tSqlExprListAppend(yymsp[-3].minor.yy421, yymsp[-1].minor.yy439, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
}
- yymsp[-3].minor.yy525 = yylhsminor.yy525;
+ yymsp[-3].minor.yy421 = yylhsminor.yy421;
break;
- case 175: /* selcollist ::= sclp STAR */
+ case 176: /* selcollist ::= sclp STAR */
{
tSqlExpr *pNode = tSqlExprCreateIdValue(NULL, TK_ALL);
- yylhsminor.yy525 = tSqlExprListAppend(yymsp[-1].minor.yy525, pNode, 0, 0);
+ yylhsminor.yy421 = tSqlExprListAppend(yymsp[-1].minor.yy421, pNode, 0, 0);
}
- yymsp[-1].minor.yy525 = yylhsminor.yy525;
+ yymsp[-1].minor.yy421 = yylhsminor.yy421;
break;
- case 176: /* as ::= AS ids */
+ case 177: /* as ::= AS ids */
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
- case 177: /* as ::= ids */
+ case 178: /* as ::= ids */
{ yylhsminor.yy0 = yymsp[0].minor.yy0; }
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
- case 178: /* as ::= */
+ case 179: /* as ::= */
{ yymsp[1].minor.yy0.n = 0; }
break;
- case 179: /* distinct ::= DISTINCT */
+ case 180: /* distinct ::= DISTINCT */
{ yylhsminor.yy0 = yymsp[0].minor.yy0; }
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
- case 181: /* from ::= FROM tablelist */
- case 182: /* from ::= FROM sub */ yytestcase(yyruleno==182);
-{yymsp[-1].minor.yy412 = yymsp[0].minor.yy412;}
+ case 182: /* from ::= FROM tablelist */
+ case 183: /* from ::= FROM sub */ yytestcase(yyruleno==183);
+{yymsp[-1].minor.yy8 = yymsp[0].minor.yy8;}
break;
- case 183: /* sub ::= LP union RP */
-{yymsp[-2].minor.yy412 = addSubqueryElem(NULL, yymsp[-1].minor.yy525, NULL);}
+ case 184: /* sub ::= LP union RP */
+{yymsp[-2].minor.yy8 = addSubqueryElem(NULL, yymsp[-1].minor.yy421, NULL);}
break;
- case 184: /* sub ::= LP union RP ids */
-{yymsp[-3].minor.yy412 = addSubqueryElem(NULL, yymsp[-2].minor.yy525, &yymsp[0].minor.yy0);}
+ case 185: /* sub ::= LP union RP ids */
+{yymsp[-3].minor.yy8 = addSubqueryElem(NULL, yymsp[-2].minor.yy421, &yymsp[0].minor.yy0);}
break;
- case 185: /* sub ::= sub COMMA LP union RP ids */
-{yylhsminor.yy412 = addSubqueryElem(yymsp[-5].minor.yy412, yymsp[-2].minor.yy525, &yymsp[0].minor.yy0);}
- yymsp[-5].minor.yy412 = yylhsminor.yy412;
+ case 186: /* sub ::= sub COMMA LP union RP ids */
+{yylhsminor.yy8 = addSubqueryElem(yymsp[-5].minor.yy8, yymsp[-2].minor.yy421, &yymsp[0].minor.yy0);}
+ yymsp[-5].minor.yy8 = yylhsminor.yy8;
break;
- case 186: /* tablelist ::= ids cpxName */
+ case 187: /* tablelist ::= ids cpxName */
{
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
- yylhsminor.yy412 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
+ yylhsminor.yy8 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
}
- yymsp[-1].minor.yy412 = yylhsminor.yy412;
+ yymsp[-1].minor.yy8 = yylhsminor.yy8;
break;
- case 187: /* tablelist ::= ids cpxName ids */
+ case 188: /* tablelist ::= ids cpxName ids */
{
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
- yylhsminor.yy412 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+ yylhsminor.yy8 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
}
- yymsp[-2].minor.yy412 = yylhsminor.yy412;
+ yymsp[-2].minor.yy8 = yylhsminor.yy8;
break;
- case 188: /* tablelist ::= tablelist COMMA ids cpxName */
+ case 189: /* tablelist ::= tablelist COMMA ids cpxName */
{
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
- yylhsminor.yy412 = setTableNameList(yymsp[-3].minor.yy412, &yymsp[-1].minor.yy0, NULL);
+ yylhsminor.yy8 = setTableNameList(yymsp[-3].minor.yy8, &yymsp[-1].minor.yy0, NULL);
}
- yymsp[-3].minor.yy412 = yylhsminor.yy412;
+ yymsp[-3].minor.yy8 = yylhsminor.yy8;
break;
- case 189: /* tablelist ::= tablelist COMMA ids cpxName ids */
+ case 190: /* tablelist ::= tablelist COMMA ids cpxName ids */
{
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
- yylhsminor.yy412 = setTableNameList(yymsp[-4].minor.yy412, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+ yylhsminor.yy8 = setTableNameList(yymsp[-4].minor.yy8, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
}
- yymsp[-4].minor.yy412 = yylhsminor.yy412;
+ yymsp[-4].minor.yy8 = yylhsminor.yy8;
break;
- case 190: /* tmvar ::= VARIABLE */
+ case 191: /* tmvar ::= VARIABLE */
{yylhsminor.yy0 = yymsp[0].minor.yy0;}
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
- case 191: /* interval_opt ::= INTERVAL LP tmvar RP */
-{yymsp[-3].minor.yy520.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy520.offset.n = 0;}
+ case 192: /* interval_option ::= intervalKey LP tmvar RP */
+{yylhsminor.yy400.interval = yymsp[-1].minor.yy0; yylhsminor.yy400.offset.n = 0; yylhsminor.yy400.token = yymsp[-3].minor.yy104;}
+ yymsp[-3].minor.yy400 = yylhsminor.yy400;
+ break;
+ case 193: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
+{yylhsminor.yy400.interval = yymsp[-3].minor.yy0; yylhsminor.yy400.offset = yymsp[-1].minor.yy0; yylhsminor.yy400.token = yymsp[-5].minor.yy104;}
+ yymsp[-5].minor.yy400 = yylhsminor.yy400;
+ break;
+ case 194: /* interval_option ::= */
+{memset(&yymsp[1].minor.yy400, 0, sizeof(yymsp[1].minor.yy400));}
break;
- case 192: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-{yymsp[-5].minor.yy520.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy520.offset = yymsp[-1].minor.yy0;}
+ case 195: /* intervalKey ::= INTERVAL */
+{yymsp[0].minor.yy104 = TK_INTERVAL;}
break;
- case 193: /* interval_opt ::= */
-{memset(&yymsp[1].minor.yy520, 0, sizeof(yymsp[1].minor.yy520));}
+ case 196: /* intervalKey ::= EVERY */
+{yymsp[0].minor.yy104 = TK_EVERY; }
break;
- case 194: /* session_option ::= */
-{yymsp[1].minor.yy259.col.n = 0; yymsp[1].minor.yy259.gap.n = 0;}
+ case 197: /* session_option ::= */
+{yymsp[1].minor.yy147.col.n = 0; yymsp[1].minor.yy147.gap.n = 0;}
break;
- case 195: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+ case 198: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- yymsp[-6].minor.yy259.col = yymsp[-4].minor.yy0;
- yymsp[-6].minor.yy259.gap = yymsp[-1].minor.yy0;
+ yymsp[-6].minor.yy147.col = yymsp[-4].minor.yy0;
+ yymsp[-6].minor.yy147.gap = yymsp[-1].minor.yy0;
}
break;
- case 196: /* windowstate_option ::= */
-{ yymsp[1].minor.yy144.col.n = 0; yymsp[1].minor.yy144.col.z = NULL;}
+ case 199: /* windowstate_option ::= */
+{ yymsp[1].minor.yy40.col.n = 0; yymsp[1].minor.yy40.col.z = NULL;}
break;
- case 197: /* windowstate_option ::= STATE_WINDOW LP ids RP */
-{ yymsp[-3].minor.yy144.col = yymsp[-1].minor.yy0; }
+ case 200: /* windowstate_option ::= STATE_WINDOW LP ids RP */
+{ yymsp[-3].minor.yy40.col = yymsp[-1].minor.yy0; }
break;
- case 198: /* fill_opt ::= */
-{ yymsp[1].minor.yy525 = 0; }
+ case 201: /* fill_opt ::= */
+{ yymsp[1].minor.yy421 = 0; }
break;
- case 199: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+ case 202: /* 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.yy525, &A, -1, 0);
- yymsp[-5].minor.yy525 = yymsp[-1].minor.yy525;
+ tVariantListInsert(yymsp[-1].minor.yy421, &A, -1, 0);
+ yymsp[-5].minor.yy421 = yymsp[-1].minor.yy421;
}
break;
- case 200: /* fill_opt ::= FILL LP ID RP */
+ case 203: /* fill_opt ::= FILL LP ID RP */
{
toTSDBType(yymsp[-1].minor.yy0.type);
- yymsp[-3].minor.yy525 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+ yymsp[-3].minor.yy421 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
}
break;
- case 201: /* sliding_opt ::= SLIDING LP tmvar RP */
+ case 204: /* sliding_opt ::= SLIDING LP tmvar RP */
{yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0; }
break;
- case 202: /* sliding_opt ::= */
+ case 205: /* sliding_opt ::= */
{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0; }
break;
- case 204: /* orderby_opt ::= ORDER BY sortlist */
-{yymsp[-2].minor.yy525 = yymsp[0].minor.yy525;}
+ case 207: /* orderby_opt ::= ORDER BY sortlist */
+{yymsp[-2].minor.yy421 = yymsp[0].minor.yy421;}
break;
- case 205: /* sortlist ::= sortlist COMMA item sortorder */
+ case 208: /* sortlist ::= sortlist COMMA item sortorder */
{
- yylhsminor.yy525 = tVariantListAppend(yymsp[-3].minor.yy525, &yymsp[-1].minor.yy506, yymsp[0].minor.yy52);
+ yylhsminor.yy421 = tVariantListAppend(yymsp[-3].minor.yy421, &yymsp[-1].minor.yy430, yymsp[0].minor.yy96);
}
- yymsp[-3].minor.yy525 = yylhsminor.yy525;
+ yymsp[-3].minor.yy421 = yylhsminor.yy421;
break;
- case 206: /* sortlist ::= item sortorder */
+ case 209: /* sortlist ::= item sortorder */
{
- yylhsminor.yy525 = tVariantListAppend(NULL, &yymsp[-1].minor.yy506, yymsp[0].minor.yy52);
+ yylhsminor.yy421 = tVariantListAppend(NULL, &yymsp[-1].minor.yy430, yymsp[0].minor.yy96);
}
- yymsp[-1].minor.yy525 = yylhsminor.yy525;
+ yymsp[-1].minor.yy421 = yylhsminor.yy421;
break;
- case 207: /* item ::= ids cpxName */
+ case 210: /* item ::= ids cpxName */
{
toTSDBType(yymsp[-1].minor.yy0.type);
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
- tVariantCreate(&yylhsminor.yy506, &yymsp[-1].minor.yy0);
+ tVariantCreate(&yylhsminor.yy430, &yymsp[-1].minor.yy0);
}
- yymsp[-1].minor.yy506 = yylhsminor.yy506;
+ yymsp[-1].minor.yy430 = yylhsminor.yy430;
break;
- case 208: /* sortorder ::= ASC */
-{ yymsp[0].minor.yy52 = TSDB_ORDER_ASC; }
+ case 211: /* sortorder ::= ASC */
+{ yymsp[0].minor.yy96 = TSDB_ORDER_ASC; }
break;
- case 209: /* sortorder ::= DESC */
-{ yymsp[0].minor.yy52 = TSDB_ORDER_DESC;}
+ case 212: /* sortorder ::= DESC */
+{ yymsp[0].minor.yy96 = TSDB_ORDER_DESC;}
break;
- case 210: /* sortorder ::= */
-{ yymsp[1].minor.yy52 = TSDB_ORDER_ASC; }
+ case 213: /* sortorder ::= */
+{ yymsp[1].minor.yy96 = TSDB_ORDER_ASC; }
break;
- case 211: /* groupby_opt ::= */
-{ yymsp[1].minor.yy525 = 0;}
+ case 214: /* groupby_opt ::= */
+{ yymsp[1].minor.yy421 = 0;}
break;
- case 212: /* groupby_opt ::= GROUP BY grouplist */
-{ yymsp[-2].minor.yy525 = yymsp[0].minor.yy525;}
+ case 215: /* groupby_opt ::= GROUP BY grouplist */
+{ yymsp[-2].minor.yy421 = yymsp[0].minor.yy421;}
break;
- case 213: /* grouplist ::= grouplist COMMA item */
+ case 216: /* grouplist ::= grouplist COMMA item */
{
- yylhsminor.yy525 = tVariantListAppend(yymsp[-2].minor.yy525, &yymsp[0].minor.yy506, -1);
+ yylhsminor.yy421 = tVariantListAppend(yymsp[-2].minor.yy421, &yymsp[0].minor.yy430, -1);
}
- yymsp[-2].minor.yy525 = yylhsminor.yy525;
+ yymsp[-2].minor.yy421 = yylhsminor.yy421;
break;
- case 214: /* grouplist ::= item */
+ case 217: /* grouplist ::= item */
{
- yylhsminor.yy525 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1);
+ yylhsminor.yy421 = tVariantListAppend(NULL, &yymsp[0].minor.yy430, -1);
}
- yymsp[0].minor.yy525 = yylhsminor.yy525;
+ yymsp[0].minor.yy421 = yylhsminor.yy421;
break;
- case 215: /* having_opt ::= */
- case 225: /* where_opt ::= */ yytestcase(yyruleno==225);
- case 267: /* expritem ::= */ yytestcase(yyruleno==267);
-{yymsp[1].minor.yy370 = 0;}
+ case 218: /* having_opt ::= */
+ case 228: /* where_opt ::= */ yytestcase(yyruleno==228);
+ case 270: /* expritem ::= */ yytestcase(yyruleno==270);
+{yymsp[1].minor.yy439 = 0;}
break;
- case 216: /* having_opt ::= HAVING expr */
- case 226: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==226);
-{yymsp[-1].minor.yy370 = yymsp[0].minor.yy370;}
+ case 219: /* having_opt ::= HAVING expr */
+ case 229: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==229);
+{yymsp[-1].minor.yy439 = yymsp[0].minor.yy439;}
break;
- case 217: /* limit_opt ::= */
- case 221: /* slimit_opt ::= */ yytestcase(yyruleno==221);
-{yymsp[1].minor.yy126.limit = -1; yymsp[1].minor.yy126.offset = 0;}
+ case 220: /* limit_opt ::= */
+ case 224: /* slimit_opt ::= */ yytestcase(yyruleno==224);
+{yymsp[1].minor.yy166.limit = -1; yymsp[1].minor.yy166.offset = 0;}
break;
- case 218: /* limit_opt ::= LIMIT signed */
- case 222: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==222);
-{yymsp[-1].minor.yy126.limit = yymsp[0].minor.yy501; yymsp[-1].minor.yy126.offset = 0;}
+ case 221: /* limit_opt ::= LIMIT signed */
+ case 225: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==225);
+{yymsp[-1].minor.yy166.limit = yymsp[0].minor.yy325; yymsp[-1].minor.yy166.offset = 0;}
break;
- case 219: /* limit_opt ::= LIMIT signed OFFSET signed */
-{ yymsp[-3].minor.yy126.limit = yymsp[-2].minor.yy501; yymsp[-3].minor.yy126.offset = yymsp[0].minor.yy501;}
+ case 222: /* limit_opt ::= LIMIT signed OFFSET signed */
+{ yymsp[-3].minor.yy166.limit = yymsp[-2].minor.yy325; yymsp[-3].minor.yy166.offset = yymsp[0].minor.yy325;}
break;
- case 220: /* limit_opt ::= LIMIT signed COMMA signed */
-{ yymsp[-3].minor.yy126.limit = yymsp[0].minor.yy501; yymsp[-3].minor.yy126.offset = yymsp[-2].minor.yy501;}
+ case 223: /* limit_opt ::= LIMIT signed COMMA signed */
+{ yymsp[-3].minor.yy166.limit = yymsp[0].minor.yy325; yymsp[-3].minor.yy166.offset = yymsp[-2].minor.yy325;}
break;
- case 223: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
-{yymsp[-3].minor.yy126.limit = yymsp[-2].minor.yy501; yymsp[-3].minor.yy126.offset = yymsp[0].minor.yy501;}
+ case 226: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
+{yymsp[-3].minor.yy166.limit = yymsp[-2].minor.yy325; yymsp[-3].minor.yy166.offset = yymsp[0].minor.yy325;}
break;
- case 224: /* slimit_opt ::= SLIMIT signed COMMA signed */
-{yymsp[-3].minor.yy126.limit = yymsp[0].minor.yy501; yymsp[-3].minor.yy126.offset = yymsp[-2].minor.yy501;}
+ case 227: /* slimit_opt ::= SLIMIT signed COMMA signed */
+{yymsp[-3].minor.yy166.limit = yymsp[0].minor.yy325; yymsp[-3].minor.yy166.offset = yymsp[-2].minor.yy325;}
break;
- case 227: /* expr ::= LP expr RP */
-{yylhsminor.yy370 = yymsp[-1].minor.yy370; yylhsminor.yy370->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy370->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 230: /* expr ::= LP expr RP */
+{yylhsminor.yy439 = yymsp[-1].minor.yy439; yylhsminor.yy439->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy439->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 228: /* expr ::= ID */
-{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);}
- yymsp[0].minor.yy370 = yylhsminor.yy370;
+ case 231: /* expr ::= ID */
+{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);}
+ yymsp[0].minor.yy439 = yylhsminor.yy439;
break;
- case 229: /* expr ::= ID DOT ID */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 232: /* expr ::= ID DOT ID */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 230: /* expr ::= ID DOT STAR */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 233: /* expr ::= ID DOT STAR */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 231: /* expr ::= INTEGER */
-{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);}
- yymsp[0].minor.yy370 = yylhsminor.yy370;
+ case 234: /* expr ::= INTEGER */
+{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);}
+ yymsp[0].minor.yy439 = yylhsminor.yy439;
break;
- case 232: /* expr ::= MINUS INTEGER */
- case 233: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==233);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);}
- yymsp[-1].minor.yy370 = yylhsminor.yy370;
+ case 235: /* expr ::= MINUS INTEGER */
+ case 236: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==236);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);}
+ yymsp[-1].minor.yy439 = yylhsminor.yy439;
break;
- case 234: /* expr ::= FLOAT */
-{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);}
- yymsp[0].minor.yy370 = yylhsminor.yy370;
+ case 237: /* expr ::= FLOAT */
+{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);}
+ yymsp[0].minor.yy439 = yylhsminor.yy439;
break;
- case 235: /* expr ::= MINUS FLOAT */
- case 236: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==236);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);}
- yymsp[-1].minor.yy370 = yylhsminor.yy370;
+ case 238: /* expr ::= MINUS FLOAT */
+ case 239: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==239);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);}
+ yymsp[-1].minor.yy439 = yylhsminor.yy439;
break;
- case 237: /* expr ::= STRING */
-{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);}
- yymsp[0].minor.yy370 = yylhsminor.yy370;
+ case 240: /* expr ::= STRING */
+{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);}
+ yymsp[0].minor.yy439 = yylhsminor.yy439;
break;
- case 238: /* expr ::= NOW */
-{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); }
- yymsp[0].minor.yy370 = yylhsminor.yy370;
+ case 241: /* expr ::= NOW */
+{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); }
+ yymsp[0].minor.yy439 = yylhsminor.yy439;
break;
- case 239: /* expr ::= VARIABLE */
-{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);}
- yymsp[0].minor.yy370 = yylhsminor.yy370;
+ case 242: /* expr ::= VARIABLE */
+{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);}
+ yymsp[0].minor.yy439 = yylhsminor.yy439;
break;
- case 240: /* expr ::= PLUS VARIABLE */
- case 241: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==241);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);}
- yymsp[-1].minor.yy370 = yylhsminor.yy370;
+ case 243: /* expr ::= PLUS VARIABLE */
+ case 244: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==244);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);}
+ yymsp[-1].minor.yy439 = yylhsminor.yy439;
break;
- case 242: /* expr ::= BOOL */
-{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);}
- yymsp[0].minor.yy370 = yylhsminor.yy370;
+ case 245: /* expr ::= BOOL */
+{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);}
+ yymsp[0].minor.yy439 = yylhsminor.yy439;
break;
- case 243: /* expr ::= NULL */
-{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);}
- yymsp[0].minor.yy370 = yylhsminor.yy370;
+ case 246: /* expr ::= NULL */
+{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);}
+ yymsp[0].minor.yy439 = yylhsminor.yy439;
break;
- case 244: /* expr ::= ID LP exprlist RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy370 = tSqlExprCreateFunction(yymsp[-1].minor.yy525, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
- yymsp[-3].minor.yy370 = yylhsminor.yy370;
+ case 247: /* expr ::= ID LP exprlist RP */
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy439 = tSqlExprCreateFunction(yymsp[-1].minor.yy421, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+ yymsp[-3].minor.yy439 = yylhsminor.yy439;
break;
- case 245: /* expr ::= ID LP STAR RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy370 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
- yymsp[-3].minor.yy370 = yylhsminor.yy370;
+ case 248: /* expr ::= ID LP STAR RP */
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy439 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+ yymsp[-3].minor.yy439 = yylhsminor.yy439;
break;
- case 246: /* expr ::= expr IS NULL */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, NULL, TK_ISNULL);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 249: /* expr ::= expr IS NULL */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, NULL, TK_ISNULL);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 247: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-3].minor.yy370, NULL, TK_NOTNULL);}
- yymsp[-3].minor.yy370 = yylhsminor.yy370;
+ case 250: /* expr ::= expr IS NOT NULL */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-3].minor.yy439, NULL, TK_NOTNULL);}
+ yymsp[-3].minor.yy439 = yylhsminor.yy439;
break;
- case 248: /* expr ::= expr LT expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_LT);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 251: /* expr ::= expr LT expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_LT);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 249: /* expr ::= expr GT expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_GT);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 252: /* expr ::= expr GT expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_GT);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 250: /* expr ::= expr LE expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_LE);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 253: /* expr ::= expr LE expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_LE);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 251: /* expr ::= expr GE expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_GE);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 254: /* expr ::= expr GE expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_GE);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 252: /* expr ::= expr NE expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_NE);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 255: /* expr ::= expr NE expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_NE);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 253: /* expr ::= expr EQ expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_EQ);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 256: /* expr ::= expr EQ expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_EQ);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 254: /* expr ::= expr BETWEEN expr AND expr */
-{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy370); yylhsminor.yy370 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy370, yymsp[-2].minor.yy370, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy370, TK_LE), TK_AND);}
- yymsp[-4].minor.yy370 = yylhsminor.yy370;
+ case 257: /* expr ::= expr BETWEEN expr AND expr */
+{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy439); yylhsminor.yy439 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy439, yymsp[-2].minor.yy439, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy439, TK_LE), TK_AND);}
+ yymsp[-4].minor.yy439 = yylhsminor.yy439;
break;
- case 255: /* expr ::= expr AND expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_AND);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 258: /* expr ::= expr AND expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_AND);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 256: /* expr ::= expr OR expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_OR); }
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 259: /* expr ::= expr OR expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_OR); }
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 257: /* expr ::= expr PLUS expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_PLUS); }
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 260: /* expr ::= expr PLUS expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_PLUS); }
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 258: /* expr ::= expr MINUS expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_MINUS); }
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 261: /* expr ::= expr MINUS expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_MINUS); }
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 259: /* expr ::= expr STAR expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_STAR); }
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 262: /* expr ::= expr STAR expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_STAR); }
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 260: /* expr ::= expr SLASH expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_DIVIDE);}
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 263: /* expr ::= expr SLASH expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_DIVIDE);}
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 261: /* expr ::= expr REM expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_REM); }
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 264: /* expr ::= expr REM expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_REM); }
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 262: /* expr ::= expr LIKE expr */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_LIKE); }
- yymsp[-2].minor.yy370 = yylhsminor.yy370;
+ case 265: /* expr ::= expr LIKE expr */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_LIKE); }
+ yymsp[-2].minor.yy439 = yylhsminor.yy439;
break;
- case 263: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy370 = tSqlExprCreate(yymsp[-4].minor.yy370, (tSqlExpr*)yymsp[-1].minor.yy525, TK_IN); }
- yymsp[-4].minor.yy370 = yylhsminor.yy370;
+ case 266: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy439 = tSqlExprCreate(yymsp[-4].minor.yy439, (tSqlExpr*)yymsp[-1].minor.yy421, TK_IN); }
+ yymsp[-4].minor.yy439 = yylhsminor.yy439;
break;
- case 264: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy525 = tSqlExprListAppend(yymsp[-2].minor.yy525,yymsp[0].minor.yy370,0, 0);}
- yymsp[-2].minor.yy525 = yylhsminor.yy525;
+ case 267: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy421 = tSqlExprListAppend(yymsp[-2].minor.yy421,yymsp[0].minor.yy439,0, 0);}
+ yymsp[-2].minor.yy421 = yylhsminor.yy421;
break;
- case 265: /* exprlist ::= expritem */
-{yylhsminor.yy525 = tSqlExprListAppend(0,yymsp[0].minor.yy370,0, 0);}
- yymsp[0].minor.yy525 = yylhsminor.yy525;
+ case 268: /* exprlist ::= expritem */
+{yylhsminor.yy421 = tSqlExprListAppend(0,yymsp[0].minor.yy439,0, 0);}
+ yymsp[0].minor.yy421 = yylhsminor.yy421;
break;
- case 266: /* expritem ::= expr */
-{yylhsminor.yy370 = yymsp[0].minor.yy370;}
- yymsp[0].minor.yy370 = yylhsminor.yy370;
+ case 269: /* expritem ::= expr */
+{yylhsminor.yy439 = yymsp[0].minor.yy439;}
+ yymsp[0].minor.yy439 = yylhsminor.yy439;
break;
- case 268: /* cmd ::= RESET QUERY CACHE */
+ case 271: /* cmd ::= RESET QUERY CACHE */
{ setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
break;
- case 269: /* cmd ::= SYNCDB ids REPLICA */
+ case 272: /* cmd ::= SYNCDB ids REPLICA */
{ setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);}
break;
- case 270: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+ case 273: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
+ SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 271: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+ case 274: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
@@ -3135,21 +3155,21 @@ static void yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 272: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+ case 275: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
+ SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 273: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+ case 276: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
+ SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 274: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+ case 277: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
@@ -3160,7 +3180,7 @@ static void yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 275: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+ case 278: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
{
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
@@ -3174,33 +3194,33 @@ static void yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 276: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+ case 279: /* 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.yy506, -1);
+ A = tVariantListAppend(A, &yymsp[0].minor.yy430, -1);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 277: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+ case 280: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
+ SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 278: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+ case 281: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
+ SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 279: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+ case 282: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
@@ -3211,21 +3231,21 @@ static void yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 280: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+ case 283: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
+ SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 281: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+ case 284: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+ SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 282: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+ case 285: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
@@ -3236,7 +3256,7 @@ static void yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 283: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+ case 286: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
{
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
@@ -3250,32 +3270,32 @@ static void yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 284: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+ case 287: /* cmd ::= ALTER STABLE 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.yy506, -1);
+ A = tVariantListAppend(A, &yymsp[0].minor.yy430, -1);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 285: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+ case 288: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
+ SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 286: /* cmd ::= KILL CONNECTION INTEGER */
+ case 289: /* cmd ::= KILL CONNECTION INTEGER */
{setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
break;
- case 287: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+ case 290: /* 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 288: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+ case 291: /* 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/tsdb/inc/tsdbFS.h b/src/tsdb/inc/tsdbFS.h
index d63aeb14ac6ca6cd6f59654cf74f11d8e33d6ce4..55db8d56ff5d17312237e3acd8b47e8923d0e4d8 100644
--- a/src/tsdb/inc/tsdbFS.h
+++ b/src/tsdb/inc/tsdbFS.h
@@ -18,6 +18,9 @@
#define TSDB_FS_VERSION 0
+// ================== TSDB global config
+extern bool tsdbForceKeepFile;
+
// ================== CURRENT file header info
typedef struct {
uint32_t version; // Current file system version (relating to code)
@@ -109,4 +112,4 @@ static FORCE_INLINE int tsdbUnLockFS(STsdbFS* pFs) {
return 0;
}
-#endif /* _TD_TSDB_FS_H_ */
\ No newline at end of file
+#endif /* _TD_TSDB_FS_H_ */
diff --git a/src/tsdb/src/tsdbFS.c b/src/tsdb/src/tsdbFS.c
index 68450301d8f0c8536327e593d87030920f27ff49..70a52621383ec5e1099a815dceefb0b4493c1f9e 100644
--- a/src/tsdb/src/tsdbFS.c
+++ b/src/tsdb/src/tsdbFS.c
@@ -38,7 +38,6 @@ static int tsdbProcessExpiredFS(STsdbRepo *pRepo);
static int tsdbCreateMeta(STsdbRepo *pRepo);
// For backward compatibility
-bool tsdbForceKeepFile = false;
// ================== CURRENT file header info
static int tsdbEncodeFSHeader(void **buf, SFSHeader *pHeader) {
int tlen = 0;
@@ -1354,4 +1353,4 @@ static void tsdbScanAndTryFixDFilesHeader(STsdbRepo *pRepo, int32_t *nExpired) {
tsdbCloseDFileSet(&fset);
}
-}
\ No newline at end of file
+}
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index 96e86a6d99ce05624d72a557f112fa1aa0919e1f..8407a0519a5595b750e0fd45cc82dcd9d1f6b5b1 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -1250,8 +1250,14 @@ static int tsdbEncodeTable(void **buf, STable *pTable) {
tlen += taosEncodeFixedU64(buf, TABLE_SUID(pTable));
tlen += tdEncodeKVRow(buf, pTable->tagVal);
} else {
- tlen += taosEncodeFixedU8(buf, (uint8_t)taosArrayGetSize(pTable->schema));
- for (int i = 0; i < taosArrayGetSize(pTable->schema); i++) {
+ uint32_t arraySize = (uint32_t)taosArrayGetSize(pTable->schema);
+ if(arraySize > UINT8_MAX) {
+ tlen += taosEncodeFixedU8(buf, 0);
+ tlen += taosEncodeFixedU32(buf, arraySize);
+ } else {
+ tlen += taosEncodeFixedU8(buf, (uint8_t)arraySize);
+ }
+ for (uint32_t i = 0; i < arraySize; i++) {
STSchema *pSchema = taosArrayGetP(pTable->schema, i);
tlen += tdEncodeSchema(buf, pSchema);
}
@@ -1284,8 +1290,11 @@ static void *tsdbDecodeTable(void *buf, STable **pRTable) {
buf = taosDecodeFixedU64(buf, &TABLE_SUID(pTable));
buf = tdDecodeKVRow(buf, &(pTable->tagVal));
} else {
- uint8_t nSchemas;
- buf = taosDecodeFixedU8(buf, &nSchemas);
+ uint32_t nSchemas = 0;
+ buf = taosDecodeFixedU8(buf, (uint8_t *)&nSchemas);
+ if(nSchemas == 0) {
+ buf = taosDecodeFixedU32(buf, &nSchemas);
+ }
for (int i = 0; i < nSchemas; i++) {
STSchema *pSchema;
buf = tdDecodeSchema(buf, &pSchema);
@@ -1485,4 +1494,4 @@ static void tsdbFreeTableSchema(STable *pTable) {
taosArrayDestroy(pTable->schema);
}
-}
\ No newline at end of file
+}
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 524ab065d693b9a80643c1085402a6d9b1740824..e3ad254bbb1a4ce0a3c504e9a799a109b7e1159a 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -1572,7 +1572,7 @@ static void mergeTwoRowFromMem(STsdbQueryHandle* pQueryHandle, int32_t capacity,
int32_t numOfColsOfRow1 = 0;
if (pSchema1 == NULL) {
- pSchema1 = tsdbGetTableSchemaByVersion(pTable, dataRowVersion(row1));
+ pSchema1 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row1));
}
if(isRow1DataRow) {
numOfColsOfRow1 = schemaNCols(pSchema1);
@@ -1584,7 +1584,7 @@ static void mergeTwoRowFromMem(STsdbQueryHandle* pQueryHandle, int32_t capacity,
if(row2) {
isRow2DataRow = isDataRow(row2);
if (pSchema2 == NULL) {
- pSchema2 = tsdbGetTableSchemaByVersion(pTable, dataRowVersion(row2));
+ pSchema2 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row2));
}
if(isRow2DataRow) {
numOfColsOfRow2 = schemaNCols(pSchema2);
@@ -2460,7 +2460,7 @@ int32_t tsdbGetFileBlocksDistInfo(TsdbQueryHandleT* queryHandle, STableBlockDist
// current file are not overlapped with query time window, ignore remain files
if ((ASCENDING_TRAVERSE(pQueryHandle->order) && win.skey > pQueryHandle->window.ekey) ||
- (!ASCENDING_TRAVERSE(pQueryHandle->order) && win.ekey < pQueryHandle->window.ekey)) {
+ (!ASCENDING_TRAVERSE(pQueryHandle->order) && win.ekey < pQueryHandle->window.ekey)) {
tsdbUnLockFS(REPO_FS(pQueryHandle->pTsdb));
tsdbDebug("%p remain files are not qualified for qrange:%" PRId64 "-%" PRId64 ", ignore, 0x%"PRIx64, pQueryHandle,
pQueryHandle->window.skey, pQueryHandle->window.ekey, pQueryHandle->qId);
@@ -3474,19 +3474,19 @@ void filterPrepare(void* expr, void* param) {
if (pInfo->optr == TSDB_RELATION_IN) {
int dummy = -1;
- SHashObj *pObj = NULL;
+ SHashObj *pObj = NULL;
if (pInfo->sch.colId == TSDB_TBNAME_COLUMN_INDEX) {
pObj = taosHashInit(256, taosGetDefaultHashFunction(pInfo->sch.type), true, false);
SArray *arr = (SArray *)(pCond->arr);
for (size_t i = 0; i < taosArrayGetSize(arr); i++) {
char* p = taosArrayGetP(arr, i);
- strtolower(varDataVal(p), varDataVal(p));
- taosHashPut(pObj, varDataVal(p),varDataLen(p), &dummy, sizeof(dummy));
+ strntolower_s(varDataVal(p), varDataVal(p), varDataLen(p));
+ taosHashPut(pObj, varDataVal(p), varDataLen(p), &dummy, sizeof(dummy));
}
} else {
buildFilterSetFromBinary((void **)&pObj, pCond->pz, pCond->nLen);
}
- pInfo->q = (char *)pObj;
+ pInfo->q = (char *)pObj;
} else if (pCond != NULL) {
uint32_t size = pCond->nLen * TSDB_NCHAR_SIZE;
if (size < (uint32_t)pSchema->bytes) {
diff --git a/src/util/inc/tcompare.h b/src/util/inc/tcompare.h
index 612ce7ede0976764843a16002c7770cfa2a6bbb7..84346cc79cc08aca123f61adfa0f21b4ad41798b 100644
--- a/src/util/inc/tcompare.h
+++ b/src/util/inc/tcompare.h
@@ -22,10 +22,10 @@ extern "C" {
#include "os.h"
-#define TSDB_PATTERN_MATCH 0
-#define TSDB_PATTERN_NOMATCH 1
-#define TSDB_PATTERN_NOWILDCARDMATCH 2
-#define TSDB_PATTERN_STRING_MAX_LEN 20
+#define TSDB_PATTERN_MATCH 0
+#define TSDB_PATTERN_NOMATCH 1
+#define TSDB_PATTERN_NOWILDCARDMATCH 2
+#define TSDB_PATTERN_STRING_DEFAULT_LEN 100
#define FLT_COMPAR_TOL_FACTOR 4
#define FLT_EQUAL(_x, _y) (fabs((_x) - (_y)) <= (FLT_COMPAR_TOL_FACTOR * FLT_EPSILON))
@@ -47,7 +47,7 @@ int WCSPatternMatch(const wchar_t *pattern, const wchar_t *str, size_t size, con
int32_t doCompare(const char* a, const char* b, int32_t type, size_t size);
-__compar_fn_t getKeyComparFunc(int32_t keyType);
+__compar_fn_t getKeyComparFunc(int32_t keyType, int32_t order);
__compar_fn_t getComparFunc(int32_t type, int32_t optr);
diff --git a/src/util/inc/tnettest.h b/src/util/inc/tnettest.h
index b7585bd7155421d1f22e5f989dc7d1ae6f8be491..8a03b67628ffd460a4aa95ad4de8110b71472496 100644
--- a/src/util/inc/tnettest.h
+++ b/src/util/inc/tnettest.h
@@ -20,7 +20,7 @@
extern "C" {
#endif
-void taosNetTest(char *role, char *host, int port, int pkgLen);
+void taosNetTest(char *role, char *host, int32_t port, int32_t pkgLen, int32_t pkgNum, char *pkgType);
#ifdef __cplusplus
}
diff --git a/src/util/inc/tstrbuild.h b/src/util/inc/tstrbuild.h
index 68d1914be3c216a05a03fe6b80490ca1ee7bea4f..6b0573c3287ab81e9c29f4479692cb5e92292fb8 100644
--- a/src/util/inc/tstrbuild.h
+++ b/src/util/inc/tstrbuild.h
@@ -43,6 +43,7 @@ void taosStringBuilderAppendStringLen(SStringBuilder* sb, const char* str, size_
void taosStringBuilderAppendString(SStringBuilder* sb, const char* str);
void taosStringBuilderAppendNull(SStringBuilder* sb);
void taosStringBuilderAppendInteger(SStringBuilder* sb, int64_t v);
+void taosStringBuilderAppendUnsignedInteger(SStringBuilder* sb, uint64_t v);
void taosStringBuilderAppendDouble(SStringBuilder* sb, double v);
#ifdef __cplusplus
diff --git a/src/util/inc/tutil.h b/src/util/inc/tutil.h
index 7c8fd2ed8353a086ec9f145aaaa30f4db57113cb..6bcfb5de295c5719032b81c23d16ec2b1476349e 100644
--- a/src/util/inc/tutil.h
+++ b/src/util/inc/tutil.h
@@ -32,6 +32,7 @@ char * strnchr(char *haystack, char needle, int32_t len, bool skipquote);
char ** strsplit(char *src, const char *delim, int32_t *num);
char * strtolower(char *dst, const char *src);
char * strntolower(char *dst, const char *src, int32_t n);
+char * strntolower_s(char *dst, const char *src, int32_t n);
int64_t strnatoi(char *num, int32_t len);
char * strbetween(char *string, char *begin, char *end);
char * paGetToken(char *src, char **token, int32_t *tokenLen);
diff --git a/src/util/src/tcompare.c b/src/util/src/tcompare.c
index e953f4c4649b6f906b8517a7165600d246da2176..1b980a4a1dc864da142f8ccdeb4104b5d06fde46 100644
--- a/src/util/src/tcompare.c
+++ b/src/util/src/tcompare.c
@@ -16,58 +16,101 @@
#include "os.h"
#include "ttype.h"
#include "tcompare.h"
-#include "tarray.h"
#include "hash.h"
-int32_t compareInt32Val(const void *pLeft, const void *pRight) {
- int32_t left = GET_INT32_VAL(pLeft), right = GET_INT32_VAL(pRight);
+int32_t setCompareBytes1(const void *pLeft, const void *pRight) {
+ return NULL != taosHashGet((SHashObj *)pRight, pLeft, 1) ? 1 : 0;
+}
+
+int32_t setCompareBytes2(const void *pLeft, const void *pRight) {
+ return NULL != taosHashGet((SHashObj *)pRight, pLeft, 2) ? 1 : 0;
+}
+
+int32_t setCompareBytes4(const void *pLeft, const void *pRight) {
+ return NULL != taosHashGet((SHashObj *)pRight, pLeft, 4) ? 1 : 0;
+}
+
+int32_t setCompareBytes8(const void *pLeft, const void *pRight) {
+ return NULL != taosHashGet((SHashObj *)pRight, pLeft, 8) ? 1 : 0;
+}
+
+int32_t compareInt8Val(const void *pLeft, const void *pRight) {
+ int8_t left = GET_INT8_VAL(pLeft), right = GET_INT8_VAL(pRight);
if (left > right) return 1;
if (left < right) return -1;
return 0;
}
-int32_t compareInt64Val(const void *pLeft, const void *pRight) {
- int64_t left = GET_INT64_VAL(pLeft), right = GET_INT64_VAL(pRight);
+int32_t compareInt8ValDesc(const void *pLeft, const void *pRight) {
+ return compareInt8Val(pRight, pLeft);
+}
+
+int32_t compareInt16Val(const void *pLeft, const void *pRight) {
+ int16_t left = GET_INT16_VAL(pLeft), right = GET_INT16_VAL(pRight);
if (left > right) return 1;
if (left < right) return -1;
return 0;
}
-int32_t compareInt16Val(const void *pLeft, const void *pRight) {
- int16_t left = GET_INT16_VAL(pLeft), right = GET_INT16_VAL(pRight);
+int32_t compareInt16ValDesc(const void* pLeft, const void* pRight) {
+ return compareInt16Val(pRight, pLeft);
+}
+
+int32_t compareInt32Val(const void *pLeft, const void *pRight) {
+ int32_t left = GET_INT32_VAL(pLeft), right = GET_INT32_VAL(pRight);
if (left > right) return 1;
if (left < right) return -1;
return 0;
}
-int32_t compareInt8Val(const void *pLeft, const void *pRight) {
- int8_t left = GET_INT8_VAL(pLeft), right = GET_INT8_VAL(pRight);
+int32_t compareInt32ValDesc(const void* pLeft, const void* pRight) {
+ return compareInt32Val(pRight, pLeft);
+}
+
+int32_t compareInt64Val(const void *pLeft, const void *pRight) {
+ int64_t left = GET_INT64_VAL(pLeft), right = GET_INT64_VAL(pRight);
if (left > right) return 1;
if (left < right) return -1;
return 0;
}
+int32_t compareInt64ValDesc(const void* pLeft, const void* pRight) {
+ return compareInt64Val(pRight, pLeft);
+}
+
int32_t compareUint32Val(const void *pLeft, const void *pRight) {
- int32_t left = GET_UINT32_VAL(pLeft), right = GET_UINT32_VAL(pRight);
+ uint32_t left = GET_UINT32_VAL(pLeft), right = GET_UINT32_VAL(pRight);
if (left > right) return 1;
if (left < right) return -1;
return 0;
}
+int32_t compareUint32ValDesc(const void* pLeft, const void* pRight) {
+ return compareUint32Val(pRight, pLeft);
+}
+
int32_t compareUint64Val(const void *pLeft, const void *pRight) {
- int64_t left = GET_UINT64_VAL(pLeft), right = GET_UINT64_VAL(pRight);
+ uint64_t left = GET_UINT64_VAL(pLeft), right = GET_UINT64_VAL(pRight);
if (left > right) return 1;
if (left < right) return -1;
return 0;
}
+int32_t compareUint64ValDesc(const void* pLeft, const void* pRight) {
+ return compareUint64Val(pRight, pLeft);
+}
+
int32_t compareUint16Val(const void *pLeft, const void *pRight) {
- int16_t left = GET_UINT16_VAL(pLeft), right = GET_UINT16_VAL(pRight);
+ uint16_t left = GET_UINT16_VAL(pLeft), right = GET_UINT16_VAL(pRight);
if (left > right) return 1;
if (left < right) return -1;
return 0;
}
+int32_t compareUint16ValDesc(const void* pLeft, const void* pRight) {
+ return compareUint16Val(pRight, pLeft);
+}
+
int32_t compareUint8Val(const void* pLeft, const void* pRight) {
uint8_t left = GET_UINT8_VAL(pLeft), right = GET_UINT8_VAL(pRight);
if (left > right) return 1;
@@ -75,6 +118,10 @@ int32_t compareUint8Val(const void* pLeft, const void* pRight) {
return 0;
}
+int32_t compareUint8ValDesc(const void* pLeft, const void* pRight) {
+ return compareUint8Val(pRight, pLeft);
+}
+
int32_t compareFloatVal(const void *pLeft, const void *pRight) {
float p1 = GET_FLOAT_VAL(pLeft);
float p2 = GET_FLOAT_VAL(pRight);
@@ -92,8 +139,12 @@ int32_t compareFloatVal(const void *pLeft, const void *pRight) {
}
if (FLT_EQUAL(p1, p2)) {
return 0;
- }
- return FLT_GREATER(p1, p2) ? 1: -1;
+ }
+ return FLT_GREATER(p1, p2) ? 1: -1;
+}
+
+int32_t compareFloatValDesc(const void* pLeft, const void* pRight) {
+ return compareFloatVal(pRight, pLeft);
}
int32_t compareDoubleVal(const void *pLeft, const void *pRight) {
@@ -113,14 +164,18 @@ int32_t compareDoubleVal(const void *pLeft, const void *pRight) {
}
if (FLT_EQUAL(p1, p2)) {
return 0;
- }
- return FLT_GREATER(p1, p2) ? 1: -1;
+ }
+ return FLT_GREATER(p1, p2) ? 1: -1;
+}
+
+int32_t compareDoubleValDesc(const void* pLeft, const void* pRight) {
+ return compareDoubleVal(pRight, pLeft);
}
int32_t compareLenPrefixedStr(const void *pLeft, const void *pRight) {
int32_t len1 = varDataLen(pLeft);
int32_t len2 = varDataLen(pRight);
-
+
if (len1 != len2) {
return len1 > len2? 1:-1;
} else {
@@ -133,14 +188,18 @@ int32_t compareLenPrefixedStr(const void *pLeft, const void *pRight) {
}
}
+int32_t compareLenPrefixedStrDesc(const void* pLeft, const void* pRight) {
+ return compareLenPrefixedStr(pRight, pLeft);
+}
+
int32_t compareLenPrefixedWStr(const void *pLeft, const void *pRight) {
int32_t len1 = varDataLen(pLeft);
int32_t len2 = varDataLen(pRight);
-
+
if (len1 != len2) {
return len1 > len2? 1:-1;
} else {
- int32_t ret = wcsncmp(varDataVal(pLeft), varDataVal(pRight), len1/TSDB_NCHAR_SIZE);
+ int32_t ret = memcmp((wchar_t*) pLeft, (wchar_t*) pRight, len1);
if (ret == 0) {
return 0;
} else {
@@ -149,6 +208,10 @@ int32_t compareLenPrefixedWStr(const void *pLeft, const void *pRight) {
}
}
+int32_t compareLenPrefixedWStrDesc(const void* pLeft, const void* pRight) {
+ return compareLenPrefixedWStr(pRight, pLeft);
+}
+
/*
* Compare two strings
* TSDB_MATCH: Match
@@ -161,33 +224,33 @@ int32_t compareLenPrefixedWStr(const void *pLeft, const void *pRight) {
*/
int patternMatch(const char *patterStr, const char *str, size_t size, const SPatternCompareInfo *pInfo) {
char c, c1;
-
+
int32_t i = 0;
int32_t j = 0;
-
+
while ((c = patterStr[i++]) != 0) {
if (c == pInfo->matchAll) { /* Match "*" */
-
+
while ((c = patterStr[i++]) == pInfo->matchAll || c == pInfo->matchOne) {
if (c == pInfo->matchOne && (j > size || str[j++] == 0)) {
// empty string, return not match
return TSDB_PATTERN_NOWILDCARDMATCH;
}
}
-
+
if (c == 0) {
return TSDB_PATTERN_MATCH; /* "*" at the end of the pattern matches */
}
-
+
char next[3] = {toupper(c), tolower(c), 0};
while (1) {
size_t n = strcspn(str, next);
str += n;
-
+
if (str[0] == 0 || (n >= size)) {
break;
}
-
+
int32_t ret = patternMatch(&patterStr[i], ++str, size - n - 1, pInfo);
if (ret != TSDB_PATTERN_NOMATCH) {
return ret;
@@ -195,18 +258,18 @@ int patternMatch(const char *patterStr, const char *str, size_t size, const SPat
}
return TSDB_PATTERN_NOWILDCARDMATCH;
}
-
+
c1 = str[j++];
-
+
if (j <= size) {
if (c == c1 || tolower(c) == tolower(c1) || (c == pInfo->matchOne && c1 != 0)) {
continue;
}
}
-
+
return TSDB_PATTERN_NOMATCH;
}
-
+
return (str[j] == 0 || j >= size) ? TSDB_PATTERN_MATCH : TSDB_PATTERN_NOMATCH;
}
@@ -214,13 +277,13 @@ int WCSPatternMatch(const wchar_t *patterStr, const wchar_t *str, size_t size, c
wchar_t c, c1;
wchar_t matchOne = L'_'; // "_"
wchar_t matchAll = L'%'; // "%"
-
+
int32_t i = 0;
int32_t j = 0;
-
+
while ((c = patterStr[i++]) != 0) {
if (c == matchAll) { /* Match "%" */
-
+
while ((c = patterStr[i++]) == matchAll || c == matchOne) {
if (c == matchOne && (j > size || str[j++] == 0)) {
return TSDB_PATTERN_NOWILDCARDMATCH;
@@ -229,87 +292,108 @@ int WCSPatternMatch(const wchar_t *patterStr, const wchar_t *str, size_t size, c
if (c == 0) {
return TSDB_PATTERN_MATCH;
}
-
+
wchar_t accept[3] = {towupper(c), towlower(c), 0};
while (1) {
size_t n = wcscspn(str, accept);
-
+
str += n;
if (str[0] == 0 || (n >= size)) {
break;
}
-
+
int32_t ret = WCSPatternMatch(&patterStr[i], ++str, size - n - 1, pInfo);
if (ret != TSDB_PATTERN_NOMATCH) {
return ret;
}
}
-
+
return TSDB_PATTERN_NOWILDCARDMATCH;
}
-
+
c1 = str[j++];
-
+
if (j <= size) {
if (c == c1 || towlower(c) == towlower(c1) || (c == matchOne && c1 != 0)) {
continue;
}
}
-
+
return TSDB_PATTERN_NOMATCH;
}
return (str[j] == 0 || j >= size) ? TSDB_PATTERN_MATCH : TSDB_PATTERN_NOMATCH;
}
-static int32_t compareStrPatternComp(const void* pLeft, const void* pRight) {
+int32_t compareStrPatternComp(const void* pLeft, const void* pRight) {
SPatternCompareInfo pInfo = {'%', '_'};
-
- char pattern[128] = {0};
+
+ assert(varDataLen(pRight) <= TSDB_MAX_FIELD_LEN);
+ char *pattern = calloc(varDataLen(pRight) + 1, sizeof(char));
memcpy(pattern, varDataVal(pRight), varDataLen(pRight));
- assert(varDataLen(pRight) < 128);
size_t sz = varDataLen(pLeft);
- char *buf = malloc(sz + 1);
- memcpy(buf, varDataVal(pLeft), sz);
+ char *buf = malloc(sz + 1);
+ memcpy(buf, varDataVal(pLeft), sz);
buf[sz] = 0;
int32_t ret = patternMatch(pattern, buf, sz, &pInfo);
free(buf);
+ free(pattern);
return (ret == TSDB_PATTERN_MATCH) ? 0 : 1;
}
int32_t taosArrayCompareString(const void* a, const void* b) {
const char* x = *(const char**)a;
const char* y = *(const char**)b;
-
+
return compareLenPrefixedStr(x, y);
}
-//static int32_t compareFindStrInArray(const void* pLeft, const void* pRight) {
-// const SArray* arr = (const SArray*) pRight;
-// return taosArraySearchString(arr, pLeft, taosArrayCompareString, TD_EQ) == NULL ? 0 : 1;
-//}
-static int32_t compareFindItemInSet(const void *pLeft, const void* pRight) {
- return NULL != taosHashGet((SHashObj *)pRight, varDataVal(pLeft), varDataLen(pLeft)) ? 1 : 0;
+int32_t compareFindItemInSet(const void *pLeft, const void* pRight) {
+ return NULL != taosHashGet((SHashObj *)pRight, varDataVal(pLeft), varDataLen(pLeft)) ? 1 : 0;
}
-static int32_t compareWStrPatternComp(const void* pLeft, const void* pRight) {
+int32_t compareWStrPatternComp(const void* pLeft, const void* pRight) {
SPatternCompareInfo pInfo = {'%', '_'};
- wchar_t pattern[128] = {0};
- assert(TSDB_PATTERN_STRING_MAX_LEN < 128);
+ assert(varDataLen(pRight) <= TSDB_MAX_FIELD_LEN * TSDB_NCHAR_SIZE);
+ wchar_t *pattern = calloc(varDataLen(pRight) + 1, sizeof(wchar_t));
memcpy(pattern, varDataVal(pRight), varDataLen(pRight));
- assert(varDataLen(pRight) < 128);
-
+
int32_t ret = WCSPatternMatch(pattern, varDataVal(pLeft), varDataLen(pLeft)/TSDB_NCHAR_SIZE, &pInfo);
+ free(pattern);
+
return (ret == TSDB_PATTERN_MATCH) ? 0 : 1;
}
__compar_fn_t getComparFunc(int32_t type, int32_t optr) {
__compar_fn_t comparFn = NULL;
-
+
+ if (optr == TSDB_RELATION_IN && (type != TSDB_DATA_TYPE_BINARY && type != TSDB_DATA_TYPE_NCHAR)) {
+ switch (type) {
+ case TSDB_DATA_TYPE_BOOL:
+ case TSDB_DATA_TYPE_TINYINT:
+ case TSDB_DATA_TYPE_UTINYINT:
+ return setCompareBytes1;
+ case TSDB_DATA_TYPE_SMALLINT:
+ case TSDB_DATA_TYPE_USMALLINT:
+ return setCompareBytes2;
+ case TSDB_DATA_TYPE_INT:
+ case TSDB_DATA_TYPE_UINT:
+ case TSDB_DATA_TYPE_FLOAT:
+ return setCompareBytes4;
+ case TSDB_DATA_TYPE_BIGINT:
+ case TSDB_DATA_TYPE_UBIGINT:
+ case TSDB_DATA_TYPE_DOUBLE:
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ return setCompareBytes8;
+ default:
+ assert(0);
+ }
+ }
+
switch (type) {
case TSDB_DATA_TYPE_BOOL:
case TSDB_DATA_TYPE_TINYINT: comparFn = compareInt8Val; break;
@@ -327,13 +411,15 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
} else { /* normal relational comparFn */
comparFn = compareLenPrefixedStr;
}
-
+
break;
}
-
+
case TSDB_DATA_TYPE_NCHAR: {
if (optr == TSDB_RELATION_LIKE) {
comparFn = compareWStrPatternComp;
+ } else if (optr == TSDB_RELATION_IN) {
+ comparFn = compareFindItemInSet;
} else {
comparFn = compareLenPrefixedWStr;
}
@@ -349,57 +435,57 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
comparFn = compareInt32Val;
break;
}
-
+
return comparFn;
}
-__compar_fn_t getKeyComparFunc(int32_t keyType) {
+__compar_fn_t getKeyComparFunc(int32_t keyType, int32_t order) {
__compar_fn_t comparFn = NULL;
-
+
switch (keyType) {
case TSDB_DATA_TYPE_TINYINT:
case TSDB_DATA_TYPE_BOOL:
- comparFn = compareInt8Val;
+ comparFn = (order == TSDB_ORDER_ASC)? compareInt8Val:compareInt8ValDesc;
break;
case TSDB_DATA_TYPE_SMALLINT:
- comparFn = compareInt16Val;
+ comparFn = (order == TSDB_ORDER_ASC)? compareInt16Val:compareInt16ValDesc;
break;
case TSDB_DATA_TYPE_INT:
- comparFn = compareInt32Val;
+ comparFn = (order == TSDB_ORDER_ASC)? compareInt32Val:compareInt32ValDesc;
break;
case TSDB_DATA_TYPE_BIGINT:
case TSDB_DATA_TYPE_TIMESTAMP:
- comparFn = compareInt64Val;
+ comparFn = (order == TSDB_ORDER_ASC)? compareInt64Val:compareInt64ValDesc;
break;
case TSDB_DATA_TYPE_FLOAT:
- comparFn = compareFloatVal;
+ comparFn = (order == TSDB_ORDER_ASC)? compareFloatVal:compareFloatValDesc;
break;
case TSDB_DATA_TYPE_DOUBLE:
- comparFn = compareDoubleVal;
+ comparFn = (order == TSDB_ORDER_ASC)? compareDoubleVal:compareDoubleValDesc;
break;
case TSDB_DATA_TYPE_UTINYINT:
- comparFn = compareUint8Val;
+ comparFn = (order == TSDB_ORDER_ASC)? compareUint8Val:compareUint8ValDesc;
break;
case TSDB_DATA_TYPE_USMALLINT:
- comparFn = compareUint16Val;
+ comparFn = (order == TSDB_ORDER_ASC)? compareUint16Val:compareUint16ValDesc;
break;
case TSDB_DATA_TYPE_UINT:
- comparFn = compareUint32Val;
+ comparFn = (order == TSDB_ORDER_ASC)? compareUint32Val:compareUint32ValDesc;
break;
case TSDB_DATA_TYPE_UBIGINT:
- comparFn = compareUint64Val;
+ comparFn = (order == TSDB_ORDER_ASC)? compareUint64Val:compareUint64ValDesc;
break;
case TSDB_DATA_TYPE_BINARY:
- comparFn = compareLenPrefixedStr;
+ comparFn = (order == TSDB_ORDER_ASC)? compareLenPrefixedStr:compareLenPrefixedStrDesc;
break;
case TSDB_DATA_TYPE_NCHAR:
- comparFn = compareLenPrefixedWStr;
+ comparFn = (order == TSDB_ORDER_ASC)? compareLenPrefixedWStr:compareLenPrefixedWStrDesc;
break;
default:
- comparFn = compareInt32Val;
+ comparFn = (order == TSDB_ORDER_ASC)? compareInt32Val:compareInt32ValDesc;
break;
}
-
+
return comparFn;
}
@@ -423,8 +509,7 @@ int32_t doCompare(const char* f1, const char* f2, int32_t type, size_t size) {
if (t1->len != t2->len) {
return t1->len > t2->len? 1:-1;
}
-
- int32_t ret = wcsncmp((wchar_t*) t1->data, (wchar_t*) t2->data, t2->len/TSDB_NCHAR_SIZE);
+ int32_t ret = memcmp((wchar_t*) t1, (wchar_t*) t2, t2->len);
if (ret == 0) {
return ret;
}
@@ -433,7 +518,7 @@ int32_t doCompare(const char* f1, const char* f2, int32_t type, size_t size) {
default: { // todo refactor
tstr* t1 = (tstr*) f1;
tstr* t2 = (tstr*) f2;
-
+
if (t1->len != t2->len) {
return t1->len > t2->len? 1:-1;
} else {
diff --git a/src/util/src/terror.c b/src/util/src/terror.c
index 42fc76e6c94227b6d8b5fb886239c42e19fc064d..0b9a76004b3e445abe1bbffe593d8061803d1b1b 100644
--- a/src/util/src/terror.c
+++ b/src/util/src/terror.c
@@ -112,6 +112,9 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TSC_EXCEED_SQL_LIMIT, "SQL statement too lon
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_FILE_EMPTY, "File is empty")
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_LINE_SYNTAX_ERROR, "Syntax error in Line")
TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NO_META_CACHED, "No table meta cached")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DUP_COL_NAMES, "duplicated column names")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TAG_LENGTH, "Invalid tag length")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_COLUMN_LENGTH, "Invalid column length")
// mnode
TAOS_DEFINE_ERROR(TSDB_CODE_MND_MSG_NOT_PROCESSED, "Message not processed")
@@ -194,6 +197,9 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_FUNC_ALREADY_EXIST, "Func already exists")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC, "Invalid func")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_BUFSIZE, "Invalid func bufSize")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TAG_LENGTH, "invalid tag length")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_COLUMN_LENGTH, "invalid column length")
+
TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_SELECTED, "Database not specified or available")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_ALREADY_EXIST, "Database already exists")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION, "Invalid database options")
diff --git a/src/util/src/tnettest.c b/src/util/src/tnettest.c
index 0bab7b7e6623ebaa5de6d6511fa1c43719372ef5..ed91f95180d8ce4a03e0cce02e64b324bcee59d9 100644
--- a/src/util/src/tnettest.c
+++ b/src/util/src/tnettest.c
@@ -27,6 +27,10 @@
#include "syncMsg.h"
#define MAX_PKG_LEN (64 * 1000)
+#define MAX_SPEED_PKG_LEN (1024 * 1024 * 1024)
+#define MIN_SPEED_PKG_LEN 1024
+#define MAX_SPEED_PKG_NUM 10000
+#define MIN_SPEED_PKG_NUM 1
#define BUFFER_SIZE (MAX_PKG_LEN + 1024)
extern int32_t tsRpcMaxUdpSize;
@@ -466,6 +470,7 @@ static void taosNetTestRpc(char *host, int32_t startPort, int32_t pkgLen) {
sendpkgLen = pkgLen;
}
+ tsRpcForceTcp = 1;
int32_t ret = taosNetCheckRpc(host, port, sendpkgLen, spi, NULL);
if (ret < 0) {
printf("failed to test TCP port:%d\n", port);
@@ -479,6 +484,7 @@ static void taosNetTestRpc(char *host, int32_t startPort, int32_t pkgLen) {
sendpkgLen = pkgLen;
}
+ tsRpcForceTcp = 0;
ret = taosNetCheckRpc(host, port, pkgLen, spi, NULL);
if (ret < 0) {
printf("failed to test UDP port:%d\n", port);
@@ -542,12 +548,110 @@ static void taosNetTestServer(char *host, int32_t startPort, int32_t pkgLen) {
}
}
-void taosNetTest(char *role, char *host, int32_t port, int32_t pkgLen) {
+static void taosNetTestFqdn(char *host) {
+ int code = 0;
+ uint64_t startTime = taosGetTimestampUs();
+ uint32_t ip = taosGetIpv4FromFqdn(host);
+ if (ip == 0xffffffff) {
+ uError("failed to get IP address from %s since %s", host, strerror(errno));
+ code = -1;
+ }
+ uint64_t endTime = taosGetTimestampUs();
+ uint64_t el = endTime - startTime;
+ printf("check convert fqdn spend, status: %d\tcost: %" PRIu64 " us\n", code, el);
+ return;
+}
+
+static void taosNetCheckSpeed(char *host, int32_t port, int32_t pkgLen,
+ int32_t pkgNum, char *pkgType) {
+ // record config
+ int32_t compressTmp = tsCompressMsgSize;
+ int32_t maxUdpSize = tsRpcMaxUdpSize;
+ int32_t forceTcp = tsRpcForceTcp;
+
+ if (0 == strcmp("tcp", pkgType)){
+ tsRpcForceTcp = 1;
+ tsRpcMaxUdpSize = 0; // force tcp
+ } else {
+ tsRpcForceTcp = 0;
+ tsRpcMaxUdpSize = INT_MAX;
+ }
+ tsCompressMsgSize = -1;
+
+ SRpcEpSet epSet;
+ SRpcMsg reqMsg;
+ SRpcMsg rspMsg;
+ void * pRpcConn;
+ char secretEncrypt[32] = {0};
+ char spi = 0;
+ pRpcConn = taosNetInitRpc(secretEncrypt, spi);
+ if (NULL == pRpcConn) {
+ uError("failed to init client rpc");
+ return;
+ }
+ printf("check net spend, host:%s port:%d pkgLen:%d pkgNum:%d pkgType:%s\n\n", host, port, pkgLen, pkgNum, pkgType);
+ int32_t totalSucc = 0;
+ uint64_t startT = taosGetTimestampUs();
+ for (int32_t i = 1; i <= pkgNum; i++) {
+ uint64_t startTime = taosGetTimestampUs();
+
+ memset(&epSet, 0, sizeof(SRpcEpSet));
+ epSet.inUse = 0;
+ epSet.numOfEps = 1;
+ epSet.port[0] = port;
+ strcpy(epSet.fqdn[0], host);
+
+ reqMsg.msgType = TSDB_MSG_TYPE_NETWORK_TEST;
+ reqMsg.pCont = rpcMallocCont(pkgLen);
+ reqMsg.contLen = pkgLen;
+ reqMsg.code = 0;
+ reqMsg.handle = NULL; // rpc handle returned to app
+ reqMsg.ahandle = NULL; // app handle set by client
+ strcpy(reqMsg.pCont, "nettest speed");
+
+ rpcSendRecv(pRpcConn, &epSet, &reqMsg, &rspMsg);
+
+ int code = 0;
+ if ((rspMsg.code != 0) || (rspMsg.msgType != TSDB_MSG_TYPE_NETWORK_TEST + 1)) {
+ uError("ret code 0x%x %s", rspMsg.code, tstrerror(rspMsg.code));
+ code = -1;
+ }else{
+ totalSucc ++;
+ }
+
+ rpcFreeCont(rspMsg.pCont);
+
+ uint64_t endTime = taosGetTimestampUs();
+ uint64_t el = endTime - startTime;
+ printf("progress:%5d/%d\tstatus:%d\tcost:%8.2lf ms\tspeed:%8.2lf MB/s\n", i, pkgNum, code, el/1000.0, pkgLen/(el/1000000.0)/1024.0/1024.0);
+ }
+ int64_t endT = taosGetTimestampUs();
+ uint64_t elT = endT - startT;
+ printf("\ntotal succ:%5d/%d\tcost:%8.2lf ms\tspeed:%8.2lf MB/s\n", totalSucc, pkgNum, elT/1000.0, pkgLen/(elT/1000000.0)/1024.0/1024.0*totalSucc);
+
+ rpcClose(pRpcConn);
+
+ // return config
+ tsCompressMsgSize = compressTmp;
+ tsRpcMaxUdpSize = maxUdpSize;
+ tsRpcForceTcp = forceTcp;
+ return;
+}
+
+void taosNetTest(char *role, char *host, int32_t port, int32_t pkgLen,
+ int32_t pkgNum, char *pkgType) {
tscEmbedded = 1;
if (host == NULL) host = tsLocalFqdn;
if (port == 0) port = tsServerPort;
- if (pkgLen <= 10) pkgLen = 1000;
- if (pkgLen > MAX_PKG_LEN) pkgLen = MAX_PKG_LEN;
+ if (0 == strcmp("speed", role)){
+ if (pkgLen <= MIN_SPEED_PKG_LEN) pkgLen = MIN_SPEED_PKG_LEN;
+ if (pkgLen > MAX_SPEED_PKG_LEN) pkgLen = MAX_SPEED_PKG_LEN;
+ if (pkgNum <= MIN_SPEED_PKG_NUM) pkgNum = MIN_SPEED_PKG_NUM;
+ if (pkgNum > MAX_SPEED_PKG_NUM) pkgNum = MAX_SPEED_PKG_NUM;
+ }else{
+ if (pkgLen <= 10) pkgLen = 1000;
+ if (pkgLen > MAX_PKG_LEN) pkgLen = MAX_PKG_LEN;
+ }
if (0 == strcmp("client", role)) {
taosNetTestClient(host, port, pkgLen);
@@ -560,6 +664,12 @@ void taosNetTest(char *role, char *host, int32_t port, int32_t pkgLen) {
taosNetCheckSync(host, port);
} else if (0 == strcmp("startup", role)) {
taosNetTestStartup(host, port);
+ } else if (0 == strcmp("speed", role)) {
+ tscEmbedded = 0;
+ char type[10] = {0};
+ taosNetCheckSpeed(host, port, pkgLen, pkgNum, strtolower(type, pkgType));
+ }else if (0 == strcmp("fqdn", role)) {
+ taosNetTestFqdn(host);
} else {
taosNetTestStartup(host, port);
}
diff --git a/src/util/src/tskiplist.c b/src/util/src/tskiplist.c
index b464519ba66776ba13ce2964070d19a2a4430bfb..98fd9c094cba3e779c9f203fdacc548a3bda5ef4 100644
--- a/src/util/src/tskiplist.c
+++ b/src/util/src/tskiplist.c
@@ -54,7 +54,7 @@ SSkipList *tSkipListCreate(uint8_t maxLevel, uint8_t keyType, uint16_t keyLen, _
pSkipList->keyFn = fn;
pSkipList->seed = rand();
if (comparFn == NULL) {
- pSkipList->comparFn = getKeyComparFunc(keyType);
+ pSkipList->comparFn = getKeyComparFunc(keyType, TSDB_ORDER_ASC);
} else {
pSkipList->comparFn = comparFn;
}
diff --git a/src/util/src/tstrbuild.c b/src/util/src/tstrbuild.c
index eec21d18354a4141be92530cda1a953e5efd89a8..e3d31595355351c7c4861166201ca65659f09a3a 100644
--- a/src/util/src/tstrbuild.c
+++ b/src/util/src/tstrbuild.c
@@ -73,6 +73,12 @@ void taosStringBuilderAppendInteger(SStringBuilder* sb, int64_t v) {
taosStringBuilderAppendStringLen(sb, buf, MIN(len, sizeof(buf)));
}
+void taosStringBuilderAppendUnsignedInteger(SStringBuilder* sb, uint64_t v) {
+ char buf[64];
+ size_t len = snprintf(buf, sizeof(buf), "%" PRId64, v);
+ taosStringBuilderAppendStringLen(sb, buf, MIN(len, sizeof(buf)));
+}
+
void taosStringBuilderAppendDouble(SStringBuilder* sb, double v) {
char buf[512];
size_t len = snprintf(buf, sizeof(buf), "%.9lf", v);
diff --git a/src/util/src/ttokenizer.c b/src/util/src/ttokenizer.c
index c4d05b2d5a851ee4c2a8232095dd6ea5567213ab..9bc336d9e8bb41e76268641af7ca8c979ebb1c94 100644
--- a/src/util/src/ttokenizer.c
+++ b/src/util/src/ttokenizer.c
@@ -140,6 +140,7 @@ static SKeyword keywordTable[] = {
{"FROM", TK_FROM},
{"VARIABLE", TK_VARIABLE},
{"INTERVAL", TK_INTERVAL},
+ {"EVERY", TK_EVERY},
{"SESSION", TK_SESSION},
{"STATE_WINDOW", TK_STATE_WINDOW},
{"FILL", TK_FILL},
@@ -608,7 +609,7 @@ SStrToken tStrGetToken(char* str, int32_t* i, bool isPrevOptr) {
int32_t numOfComma = 0;
char t = str[*i];
- while (t == ' ' || t == '\n' || t == '\r' || t == '\t' || t == '\f' || t == ',') {
+ while (isspace(t) || t == ',') {
if (t == ',' && (++numOfComma > 1)) { // comma only allowed once
t0.n = 0;
return t0;
diff --git a/src/util/src/tutil.c b/src/util/src/tutil.c
index 1a73991ade1ea4617fc4d3dab3904652ff46d691..f8a97ff7cd04ac6888806f69f53dbc0188aaa8cd 100644
--- a/src/util/src/tutil.c
+++ b/src/util/src/tutil.c
@@ -197,7 +197,7 @@ char* strntolower(char *dst, const char *src, int32_t n) {
if (n == 0) {
*p = 0;
return dst;
- }
+ }
for (c = *src++; n-- > 0; c = *src++) {
if (esc) {
esc = 0;
@@ -219,6 +219,26 @@ char* strntolower(char *dst, const char *src, int32_t n) {
return dst;
}
+char* strntolower_s(char *dst, const char *src, int32_t n) {
+ char *p = dst, c;
+
+ assert(dst != NULL);
+ if (n == 0) {
+ return NULL;
+ }
+
+ while (n-- > 0) {
+ c = *src;
+ if (c >= 'A' && c <= 'Z') {
+ c -= 'A' - 'a';
+ }
+ *p++ = c;
+ src++;
+ }
+
+ return dst;
+}
+
char *paGetToken(char *string, char **token, int32_t *tokenLen) {
char quote = 0;
diff --git a/src/util/tests/skiplistTest.cpp b/src/util/tests/skiplistTest.cpp
index dfbe0f67167ad12cedc0239fc310614ef747b080..df4c5af5e2ab62efab287f3dd00650fc29805c98 100644
--- a/src/util/tests/skiplistTest.cpp
+++ b/src/util/tests/skiplistTest.cpp
@@ -70,7 +70,7 @@ void doubleSkipListTest() {
}
void randKeyTest() {
- SSkipList* pSkipList = tSkipListCreate(10, TSDB_DATA_TYPE_INT, sizeof(int32_t), getKeyComparFunc(TSDB_DATA_TYPE_INT),
+ SSkipList* pSkipList = tSkipListCreate(10, TSDB_DATA_TYPE_INT, sizeof(int32_t), getKeyComparFunc(TSDB_DATA_TYPE_INT, TSDB_ORDER_ASC),
false, getkey);
int32_t size = 200000;
diff --git a/src/wal/src/walWrite.c b/src/wal/src/walWrite.c
index 47749987994a3af3234b0149d00f5b89c75700ff..e991bf02aa68c92d7cf4dfdb09982ebaa6541bdc 100644
--- a/src/wal/src/walWrite.c
+++ b/src/wal/src/walWrite.c
@@ -17,6 +17,7 @@
#define TAOS_RANDOM_FILE_FAIL_TEST
#include "os.h"
#include "taoserror.h"
+#include "taosmsg.h"
#include "tchecksum.h"
#include "tfile.h"
#include "twal.h"
@@ -114,7 +115,7 @@ void walRemoveAllOldFiles(void *handle) {
#if defined(WAL_CHECKSUM_WHOLE)
static void walUpdateChecksum(SWalHead *pHead) {
- pHead->sver = 1;
+ pHead->sver = 2;
pHead->cksum = 0;
pHead->cksum = taosCalcChecksum(0, (uint8_t *)pHead, sizeof(*pHead) + pHead->len);
}
@@ -122,7 +123,7 @@ static void walUpdateChecksum(SWalHead *pHead) {
static int walValidateChecksum(SWalHead *pHead) {
if (pHead->sver == 0) { // for compatible with wal before sver 1
return taosCheckChecksumWhole((uint8_t *)pHead, sizeof(*pHead));
- } else if (pHead->sver == 1) {
+ } else if (pHead->sver >= 1) {
uint32_t cksum = pHead->cksum;
pHead->cksum = 0;
return taosCheckChecksum((uint8_t *)pHead, sizeof(*pHead) + pHead->len, cksum);
@@ -281,7 +282,7 @@ static int32_t walSkipCorruptedRecord(SWal *pWal, SWalHead *pHead, int64_t tfd,
return TSDB_CODE_SUCCESS;
}
- if (pHead->sver == 1) {
+ if (pHead->sver >= 1) {
if (tfRead(tfd, pHead->cont, pHead->len) < pHead->len) {
wError("vgId:%d, read to end of corrupted wal file, offset:%" PRId64, pWal->vgId, pos);
return TSDB_CODE_WAL_FILE_CORRUPTED;
@@ -306,7 +307,115 @@ static int32_t walSkipCorruptedRecord(SWal *pWal, SWalHead *pHead, int64_t tfd,
return TSDB_CODE_WAL_FILE_CORRUPTED;
}
+// Add SMemRowType ahead of SDataRow
+static void expandSubmitBlk(SSubmitBlk *pDest, SSubmitBlk *pSrc, int32_t *lenExpand) {
+ // copy the header firstly
+ memcpy(pDest, pSrc, sizeof(SSubmitBlk));
+ int32_t nRows = htons(pDest->numOfRows);
+ int32_t dataLen = htonl(pDest->dataLen);
+
+ if ((nRows <= 0) || (dataLen <= 0)) {
+ return;
+ }
+
+ char *pDestData = pDest->data;
+ char *pSrcData = pSrc->data;
+ for (int32_t i = 0; i < nRows; ++i) {
+ memRowSetType(pDestData, SMEM_ROW_DATA);
+ memcpy(memRowDataBody(pDestData), pSrcData, dataRowLen(pSrcData));
+ pDestData = POINTER_SHIFT(pDestData, memRowTLen(pDestData));
+ pSrcData = POINTER_SHIFT(pSrcData, dataRowLen(pSrcData));
+ ++(*lenExpand);
+ }
+ pDest->dataLen = htonl(dataLen + nRows * sizeof(uint8_t));
+}
+
+// Check SDataRow by comparing the SDataRow len and SSubmitBlk dataLen
+static bool walIsSDataRow(void *pBlkData, int nRows, int32_t dataLen) {
+ if ((nRows <= 0) || (dataLen <= 0)) {
+ return true;
+ }
+ int32_t len = 0, kvLen = 0;
+ for (int i = 0; i < nRows; ++i) {
+ len += dataRowLen(pBlkData);
+ if (len > dataLen) {
+ return false;
+ }
+
+ /**
+ * For SDataRow between version [2.1.5.0 and 2.1.6.X], it would never conflict.
+ * For SKVRow between version [2.1.5.0 and 2.1.6.X], it may conflict in below scenario
+ * - with 1st type byte 0x01 and sversion 0x0101(257), thus do further check
+ */
+ if (dataRowLen(pBlkData) == 257) {
+ SMemRow memRow = pBlkData;
+ SKVRow kvRow = memRowKvBody(memRow);
+ int nCols = kvRowNCols(kvRow);
+ uint16_t calcTsOffset = (uint16_t)(TD_KV_ROW_HEAD_SIZE + sizeof(SColIdx) * nCols);
+ uint16_t realTsOffset = (kvRowColIdx(kvRow))->offset;
+ if (calcTsOffset == realTsOffset) {
+ kvLen += memRowKvTLen(memRow);
+ }
+ }
+ pBlkData = POINTER_SHIFT(pBlkData, dataRowLen(pBlkData));
+ }
+ if (len != dataLen) {
+ return false;
+ }
+ if (kvLen == dataLen) {
+ return false;
+ }
+ return true;
+}
+// for WAL SMemRow/SDataRow compatibility
+static int walSMemRowCheck(SWalHead *pHead) {
+ if ((pHead->sver < 2) && (pHead->msgType == TSDB_MSG_TYPE_SUBMIT)) {
+ SSubmitMsg *pMsg = (SSubmitMsg *)pHead->cont;
+ int32_t numOfBlocks = htonl(pMsg->numOfBlocks);
+ if (numOfBlocks <= 0) {
+ return 0;
+ }
+
+ int32_t nTotalRows = 0;
+ SSubmitBlk *pBlk = (SSubmitBlk *)pMsg->blocks;
+ for (int32_t i = 0; i < numOfBlocks; ++i) {
+ int32_t dataLen = htonl(pBlk->dataLen);
+ int32_t nRows = htons(pBlk->numOfRows);
+ nTotalRows += nRows;
+ if (!walIsSDataRow(pBlk->data, nRows, dataLen)) {
+ return 0;
+ }
+ pBlk = (SSubmitBlk *)POINTER_SHIFT(pBlk, sizeof(SSubmitBlk) + dataLen);
+ }
+ ASSERT(nTotalRows >= 0);
+ SWalHead *pWalHead = (SWalHead *)calloc(sizeof(SWalHead) + pHead->len + nTotalRows * sizeof(uint8_t), 1);
+ if (pWalHead == NULL) {
+ return -1;
+ }
+
+ memcpy(pWalHead, pHead, sizeof(SWalHead) + sizeof(SSubmitMsg));
+
+ SSubmitMsg *pDestMsg = (SSubmitMsg *)pWalHead->cont;
+ SSubmitBlk *pDestBlks = (SSubmitBlk *)pDestMsg->blocks;
+ SSubmitBlk *pSrcBlks = (SSubmitBlk *)pMsg->blocks;
+ int32_t lenExpand = 0;
+ for (int32_t i = 0; i < numOfBlocks; ++i) {
+ expandSubmitBlk(pDestBlks, pSrcBlks, &lenExpand);
+ pDestBlks = POINTER_SHIFT(pDestBlks, htonl(pDestBlks->dataLen) + sizeof(SSubmitBlk));
+ pSrcBlks = POINTER_SHIFT(pSrcBlks, htonl(pSrcBlks->dataLen) + sizeof(SSubmitBlk));
+ }
+ if (lenExpand > 0) {
+ pDestMsg->header.contLen = htonl(pDestMsg->length) + lenExpand;
+ pDestMsg->length = htonl(pDestMsg->header.contLen);
+ pWalHead->len = pWalHead->len + lenExpand;
+ }
+
+ memcpy(pHead, pWalHead, sizeof(SWalHead) + pWalHead->len);
+ tfree(pWalHead);
+ }
+ return 0;
+}
static int32_t walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp, char *name, int64_t fileId) {
int32_t size = WAL_MAX_SIZE;
@@ -346,7 +455,7 @@ static int32_t walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp, ch
}
#if defined(WAL_CHECKSUM_WHOLE)
- if ((pHead->sver == 0 && !walValidateChecksum(pHead)) || pHead->sver < 0 || pHead->sver > 1) {
+ if ((pHead->sver == 0 && !walValidateChecksum(pHead)) || pHead->sver < 0 || pHead->sver > 2) {
wError("vgId:%d, file:%s, wal head cksum is messed up, hver:%" PRIu64 " len:%d offset:%" PRId64, pWal->vgId, name,
pHead->version, pHead->len, offset);
code = walSkipCorruptedRecord(pWal, pHead, tfd, &offset);
@@ -379,7 +488,7 @@ static int32_t walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp, ch
continue;
}
- if (pHead->sver == 1 && !walValidateChecksum(pHead)) {
+ if ((pHead->sver >= 1) && !walValidateChecksum(pHead)) {
wError("vgId:%d, file:%s, wal whole cksum is messed up, hver:%" PRIu64 " len:%d offset:%" PRId64, pWal->vgId, name,
pHead->version, pHead->len, offset);
code = walSkipCorruptedRecord(pWal, pHead, tfd, &offset);
@@ -431,7 +540,14 @@ static int32_t walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp, ch
pWal->version = pHead->version;
- //wInfo("writeFp: %ld", offset);
+ // wInfo("writeFp: %ld", offset);
+ if (0 != walSMemRowCheck(pHead)) {
+ wError("vgId:%d, restore wal, fileId:%" PRId64 " hver:%" PRIu64 " wver:%" PRIu64 " len:%d offset:%" PRId64,
+ pWal->vgId, fileId, pHead->version, pWal->version, pHead->len, offset);
+ tfClose(tfd);
+ tfree(buffer);
+ return TAOS_SYSTEM_ERROR(errno);
+ }
(*writeFp)(pVnode, pHead, TAOS_QTYPE_WAL, NULL);
}
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 01169715f3e8b5b9d6e212b4b317ecca5fa4dbcd..e6b5e84d084b52f6e2097f1b89e8fd79fc229394 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -8,7 +8,7 @@
#include
static void prepare_data(TAOS* taos) {
- TAOS_RES *result;
+ TAOS_RES* result;
result = taos_query(taos, "drop database if exists test;");
taos_free_result(result);
usleep(100000);
@@ -41,24 +41,25 @@ static void prepare_data(TAOS* taos) {
result = taos_query(taos, "create table t9 using meters tags(9);");
taos_free_result(result);
- result = taos_query(taos, "insert into t0 values('2020-01-01 00:00:00.000', 0)"
- " ('2020-01-01 00:01:00.000', 0)"
- " ('2020-01-01 00:02:00.000', 0)"
- " t1 values('2020-01-01 00:00:00.000', 0)"
- " ('2020-01-01 00:01:00.000', 0)"
- " ('2020-01-01 00:02:00.000', 0)"
- " ('2020-01-01 00:03:00.000', 0)"
- " t2 values('2020-01-01 00:00:00.000', 0)"
- " ('2020-01-01 00:01:00.000', 0)"
- " ('2020-01-01 00:01:01.000', 0)"
- " ('2020-01-01 00:01:02.000', 0)"
- " t3 values('2020-01-01 00:01:02.000', 0)"
- " t4 values('2020-01-01 00:01:02.000', 0)"
- " t5 values('2020-01-01 00:01:02.000', 0)"
- " t6 values('2020-01-01 00:01:02.000', 0)"
- " t7 values('2020-01-01 00:01:02.000', 0)"
- " t8 values('2020-01-01 00:01:02.000', 0)"
- " t9 values('2020-01-01 00:01:02.000', 0)");
+ result = taos_query(taos,
+ "insert into t0 values('2020-01-01 00:00:00.000', 0)"
+ " ('2020-01-01 00:01:00.000', 0)"
+ " ('2020-01-01 00:02:00.000', 0)"
+ " t1 values('2020-01-01 00:00:00.000', 0)"
+ " ('2020-01-01 00:01:00.000', 0)"
+ " ('2020-01-01 00:02:00.000', 0)"
+ " ('2020-01-01 00:03:00.000', 0)"
+ " t2 values('2020-01-01 00:00:00.000', 0)"
+ " ('2020-01-01 00:01:00.000', 0)"
+ " ('2020-01-01 00:01:01.000', 0)"
+ " ('2020-01-01 00:01:02.000', 0)"
+ " t3 values('2020-01-01 00:01:02.000', 0)"
+ " t4 values('2020-01-01 00:01:02.000', 0)"
+ " t5 values('2020-01-01 00:01:02.000', 0)"
+ " t6 values('2020-01-01 00:01:02.000', 0)"
+ " t7 values('2020-01-01 00:01:02.000', 0)"
+ " t8 values('2020-01-01 00:01:02.000', 0)"
+ " t9 values('2020-01-01 00:01:02.000', 0)");
int affected = taos_affected_rows(result);
if (affected != 18) {
printf("\033[31m%d rows affected by last insert statement, but it should be 18\033[0m\n", affected);
@@ -77,7 +78,7 @@ static int print_result(TAOS_RES* res, int blockFetch) {
if (blockFetch) {
int rows = 0;
while ((rows = taos_fetch_block(res, &row))) {
- //for (int i = 0; i < rows; i++) {
+ // for (int i = 0; i < rows; i++) {
// char temp[256];
// taos_print_row(temp, row + i, fields, num_fields);
// puts(temp);
@@ -126,9 +127,9 @@ static void verify_query(TAOS* taos) {
TAOS_RES* res = taos_query(taos, "select * from meters");
check_row_count(__LINE__, res, 18);
- printf("result precision is: %d\n", taos_result_precision(res));
+ printf("result precision is: %d\n", taos_result_precision(res));
int c = taos_field_count(res);
- printf("field count is: %d\n", c);
+ printf("field count is: %d\n", c);
int* lengths = taos_fetch_lengths(res);
for (int i = 0; i < c; i++) {
printf("length of column %d is %d\n", i, lengths[i]);
@@ -149,7 +150,7 @@ static void verify_query(TAOS* taos) {
taos_free_result(res);
}
-void subscribe_callback(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
+void subscribe_callback(TAOS_SUB* tsub, TAOS_RES* res, void* param, int code) {
int rows = print_result(res, *(int*)param);
printf("%d rows consumed in subscribe_callback\n", rows);
}
@@ -164,7 +165,7 @@ static void verify_subscribe(TAOS* taos) {
res = taos_consume(tsub);
check_row_count(__LINE__, res, 0);
- TAOS_RES *result;
+ TAOS_RES* result;
result = taos_query(taos, "insert into t0 values('2020-01-01 00:02:00.001', 0);");
taos_free_result(result);
result = taos_query(taos, "insert into t8 values('2020-01-01 00:01:03.000', 0);");
@@ -230,666 +231,7 @@ static void verify_subscribe(TAOS* taos) {
taos_unsubscribe(tsub, 0);
}
-void verify_prepare(TAOS* taos) {
- TAOS_RES* result = taos_query(taos, "drop database if exists test;");
- taos_free_result(result);
-
- usleep(100000);
- result = taos_query(taos, "create database test;");
-
- int code = taos_errno(result);
- if (code != 0) {
- printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
- taos_free_result(result);
- return;
- }
-
- taos_free_result(result);
-
- usleep(100000);
- taos_select_db(taos, "test");
-
- // create table
- const char* sql = "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10))";
- result = taos_query(taos, sql);
- code = taos_errno(result);
- if (code != 0) {
- printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
- taos_free_result(result);
- return;
- }
- taos_free_result(result);
-
- // insert 10 records
- struct {
- int64_t ts;
- int8_t b;
- int8_t v1;
- int16_t v2;
- int32_t v4;
- int64_t v8;
- float f4;
- double f8;
- char bin[40];
- char blob[80];
- } v = {0};
-
- TAOS_STMT* stmt = taos_stmt_init(taos);
- TAOS_BIND params[10];
- params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
- params[0].buffer_length = sizeof(v.ts);
- params[0].buffer = &v.ts;
- params[0].length = ¶ms[0].buffer_length;
- params[0].is_null = NULL;
-
- params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
- params[1].buffer_length = sizeof(v.b);
- params[1].buffer = &v.b;
- params[1].length = ¶ms[1].buffer_length;
- params[1].is_null = NULL;
-
- params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
- params[2].buffer_length = sizeof(v.v1);
- params[2].buffer = &v.v1;
- params[2].length = ¶ms[2].buffer_length;
- params[2].is_null = NULL;
-
- params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
- params[3].buffer_length = sizeof(v.v2);
- params[3].buffer = &v.v2;
- params[3].length = ¶ms[3].buffer_length;
- params[3].is_null = NULL;
-
- params[4].buffer_type = TSDB_DATA_TYPE_INT;
- params[4].buffer_length = sizeof(v.v4);
- params[4].buffer = &v.v4;
- params[4].length = ¶ms[4].buffer_length;
- params[4].is_null = NULL;
-
- params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
- params[5].buffer_length = sizeof(v.v8);
- params[5].buffer = &v.v8;
- params[5].length = ¶ms[5].buffer_length;
- params[5].is_null = NULL;
-
- params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
- params[6].buffer_length = sizeof(v.f4);
- params[6].buffer = &v.f4;
- params[6].length = ¶ms[6].buffer_length;
- params[6].is_null = NULL;
-
- params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
- params[7].buffer_length = sizeof(v.f8);
- params[7].buffer = &v.f8;
- params[7].length = ¶ms[7].buffer_length;
- params[7].is_null = NULL;
-
- params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
- params[8].buffer_length = sizeof(v.bin);
- params[8].buffer = v.bin;
- params[8].length = ¶ms[8].buffer_length;
- params[8].is_null = NULL;
-
- strcpy(v.blob, "一二三四五六七八九十");
- params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
- params[9].buffer_length = strlen(v.blob);
- params[9].buffer = v.blob;
- params[9].length = ¶ms[9].buffer_length;
- params[9].is_null = NULL;
-
- int is_null = 1;
-
- sql = "insert into m1 values(?,?,?,?,?,?,?,?,?,?)";
- code = taos_stmt_prepare(stmt, sql, 0);
- if (code != 0){
- printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
- v.ts = 1591060628000;
- for (int i = 0; i < 10; ++i) {
- v.ts += 1;
- for (int j = 1; j < 10; ++j) {
- params[j].is_null = ((i == j) ? &is_null : 0);
- }
- v.b = (int8_t)i % 2;
- v.v1 = (int8_t)i;
- v.v2 = (int16_t)(i * 2);
- v.v4 = (int32_t)(i * 4);
- v.v8 = (int64_t)(i * 8);
- v.f4 = (float)(i * 40);
- v.f8 = (double)(i * 80);
- for (int j = 0; j < sizeof(v.bin); ++j) {
- v.bin[j] = (char)(i + '0');
- }
-
- taos_stmt_bind_param(stmt, params);
- taos_stmt_add_batch(stmt);
- }
- if (taos_stmt_execute(stmt) != 0) {
- printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
- taos_stmt_close(stmt);
-
- // query the records
- stmt = taos_stmt_init(taos);
- taos_stmt_prepare(stmt, "SELECT * FROM m1 WHERE v1 > ? AND v2 < ?", 0);
- v.v1 = 5;
- v.v2 = 15;
- taos_stmt_bind_param(stmt, params + 2);
- if (taos_stmt_execute(stmt) != 0) {
- printf("\033[31mfailed to execute select statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
-
- result = taos_stmt_use_result(stmt);
-
- TAOS_ROW row;
- int rows = 0;
- int num_fields = taos_num_fields(result);
- TAOS_FIELD *fields = taos_fetch_fields(result);
-
- // fetch the records row by row
- while ((row = taos_fetch_row(result))) {
- char temp[256] = {0};
- rows++;
- taos_print_row(temp, row, fields, num_fields);
- printf("%s\n", temp);
- }
-
- taos_free_result(result);
- taos_stmt_close(stmt);
-}
-
-void verify_prepare2(TAOS* taos) {
- TAOS_RES* result = taos_query(taos, "drop database if exists test;");
- taos_free_result(result);
- usleep(100000);
- result = taos_query(taos, "create database test;");
-
- int code = taos_errno(result);
- if (code != 0) {
- printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
- taos_free_result(result);
- return;
- }
- taos_free_result(result);
-
- usleep(100000);
- taos_select_db(taos, "test");
-
- // create table
- const char* sql = "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10))";
- result = taos_query(taos, sql);
- code = taos_errno(result);
- if (code != 0) {
- printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
- taos_free_result(result);
- return;
- }
- taos_free_result(result);
-
- // insert 10 records
- struct {
- int64_t ts[10];
- int8_t b[10];
- int8_t v1[10];
- int16_t v2[10];
- int32_t v4[10];
- int64_t v8[10];
- float f4[10];
- double f8[10];
- char bin[10][40];
- char blob[10][80];
- } v;
-
- int32_t *t8_len = malloc(sizeof(int32_t) * 10);
- int32_t *t16_len = malloc(sizeof(int32_t) * 10);
- int32_t *t32_len = malloc(sizeof(int32_t) * 10);
- int32_t *t64_len = malloc(sizeof(int32_t) * 10);
- int32_t *float_len = malloc(sizeof(int32_t) * 10);
- int32_t *double_len = malloc(sizeof(int32_t) * 10);
- int32_t *bin_len = malloc(sizeof(int32_t) * 10);
- int32_t *blob_len = malloc(sizeof(int32_t) * 10);
-
- TAOS_STMT* stmt = taos_stmt_init(taos);
- TAOS_MULTI_BIND params[10];
- char is_null[10] = {0};
-
- params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
- params[0].buffer_length = sizeof(v.ts[0]);
- params[0].buffer = v.ts;
- params[0].length = t64_len;
- params[0].is_null = is_null;
- params[0].num = 10;
-
- params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
- params[1].buffer_length = sizeof(v.b[0]);
- params[1].buffer = v.b;
- params[1].length = t8_len;
- params[1].is_null = is_null;
- params[1].num = 10;
-
- params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
- params[2].buffer_length = sizeof(v.v1[0]);
- params[2].buffer = v.v1;
- params[2].length = t8_len;
- params[2].is_null = is_null;
- params[2].num = 10;
-
- params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
- params[3].buffer_length = sizeof(v.v2[0]);
- params[3].buffer = v.v2;
- params[3].length = t16_len;
- params[3].is_null = is_null;
- params[3].num = 10;
-
- params[4].buffer_type = TSDB_DATA_TYPE_INT;
- params[4].buffer_length = sizeof(v.v4[0]);
- params[4].buffer = v.v4;
- params[4].length = t32_len;
- params[4].is_null = is_null;
- params[4].num = 10;
-
- params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
- params[5].buffer_length = sizeof(v.v8[0]);
- params[5].buffer = v.v8;
- params[5].length = t64_len;
- params[5].is_null = is_null;
- params[5].num = 10;
-
- params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
- params[6].buffer_length = sizeof(v.f4[0]);
- params[6].buffer = v.f4;
- params[6].length = float_len;
- params[6].is_null = is_null;
- params[6].num = 10;
-
- params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
- params[7].buffer_length = sizeof(v.f8[0]);
- params[7].buffer = v.f8;
- params[7].length = double_len;
- params[7].is_null = is_null;
- params[7].num = 10;
-
- params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
- params[8].buffer_length = sizeof(v.bin[0]);
- params[8].buffer = v.bin;
- params[8].length = bin_len;
- params[8].is_null = is_null;
- params[8].num = 10;
-
- params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
- params[9].buffer_length = sizeof(v.blob[0]);
- params[9].buffer = v.blob;
- params[9].length = blob_len;
- params[9].is_null = is_null;
- params[9].num = 10;
-
- sql = "insert into ? (ts, b, v1, v2, v4, v8, f4, f8, bin, blob) values(?,?,?,?,?,?,?,?,?,?)";
- code = taos_stmt_prepare(stmt, sql, 0);
- if (code != 0) {
- printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
-
- code = taos_stmt_set_tbname(stmt, "m1");
- if (code != 0){
- printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
-
- int64_t ts = 1591060628000;
- for (int i = 0; i < 10; ++i) {
- v.ts[i] = ts++;
- is_null[i] = 0;
-
- v.b[i] = (int8_t)i % 2;
- v.v1[i] = (int8_t)i;
- v.v2[i] = (int16_t)(i * 2);
- v.v4[i] = (int32_t)(i * 4);
- v.v8[i] = (int64_t)(i * 8);
- v.f4[i] = (float)(i * 40);
- v.f8[i] = (double)(i * 80);
- for (int j = 0; j < sizeof(v.bin[0]); ++j) {
- v.bin[i][j] = (char)(i + '0');
- }
- strcpy(v.blob[i], "一二三四五六七八九十");
-
- t8_len[i] = sizeof(int8_t);
- t16_len[i] = sizeof(int16_t);
- t32_len[i] = sizeof(int32_t);
- t64_len[i] = sizeof(int64_t);
- float_len[i] = sizeof(float);
- double_len[i] = sizeof(double);
- bin_len[i] = sizeof(v.bin[0]);
- blob_len[i] = (int32_t)strlen(v.blob[i]);
- }
-
- taos_stmt_bind_param_batch(stmt, params);
- taos_stmt_add_batch(stmt);
-
- if (taos_stmt_execute(stmt) != 0) {
- printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
-
- taos_stmt_close(stmt);
-
- // query the records
- stmt = taos_stmt_init(taos);
- taos_stmt_prepare(stmt, "SELECT * FROM m1 WHERE v1 > ? AND v2 < ?", 0);
- TAOS_BIND qparams[2];
-
- int8_t v1 = 5;
- int16_t v2 = 15;
- qparams[0].buffer_type = TSDB_DATA_TYPE_TINYINT;
- qparams[0].buffer_length = sizeof(v1);
- qparams[0].buffer = &v1;
- qparams[0].length = &qparams[0].buffer_length;
- qparams[0].is_null = NULL;
-
- qparams[1].buffer_type = TSDB_DATA_TYPE_SMALLINT;
- qparams[1].buffer_length = sizeof(v2);
- qparams[1].buffer = &v2;
- qparams[1].length = &qparams[1].buffer_length;
- qparams[1].is_null = NULL;
-
- taos_stmt_bind_param(stmt, qparams);
- if (taos_stmt_execute(stmt) != 0) {
- printf("\033[31mfailed to execute select statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
-
- result = taos_stmt_use_result(stmt);
-
- TAOS_ROW row;
- int rows = 0;
- int num_fields = taos_num_fields(result);
- TAOS_FIELD *fields = taos_fetch_fields(result);
-
- // fetch the records row by row
- while ((row = taos_fetch_row(result))) {
- char temp[256] = {0};
- rows++;
- taos_print_row(temp, row, fields, num_fields);
- printf("%s\n", temp);
- }
-
- taos_free_result(result);
- taos_stmt_close(stmt);
-
- free(t8_len);
- free(t16_len);
- free(t32_len);
- free(t64_len);
- free(float_len);
- free(double_len);
- free(bin_len);
- free(blob_len);
-}
-
-void verify_prepare3(TAOS* taos) {
- TAOS_RES* result = taos_query(taos, "drop database if exists test;");
- taos_free_result(result);
- usleep(100000);
- result = taos_query(taos, "create database test;");
-
- int code = taos_errno(result);
- if (code != 0) {
- printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
- taos_free_result(result);
- return;
- }
- taos_free_result(result);
-
- usleep(100000);
- taos_select_db(taos, "test");
-
- // create table
- const char* sql = "create stable st1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10)) tags (id1 int, id2 binary(40))";
- result = taos_query(taos, sql);
- code = taos_errno(result);
- if (code != 0) {
- printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
- taos_free_result(result);
- return;
- }
- taos_free_result(result);
-
- TAOS_BIND tags[2];
-
- int32_t id1 = 1;
- char id2[40] = "abcdefghijklmnopqrstuvwxyz0123456789";
- uintptr_t id2_len = strlen(id2);
-
- tags[0].buffer_type = TSDB_DATA_TYPE_INT;
- tags[0].buffer_length = sizeof(int);
- tags[0].buffer = &id1;
- tags[0].length = NULL;
- tags[0].is_null = NULL;
-
- tags[1].buffer_type = TSDB_DATA_TYPE_BINARY;
- tags[1].buffer_length = sizeof(id2);
- tags[1].buffer = id2;
- tags[1].length = &id2_len;
- tags[1].is_null = NULL;
-
-
- // insert 10 records
- struct {
- int64_t ts[10];
- int8_t b[10];
- int8_t v1[10];
- int16_t v2[10];
- int32_t v4[10];
- int64_t v8[10];
- float f4[10];
- double f8[10];
- char bin[10][40];
- char blob[10][80];
- } v;
-
- int32_t *t8_len = malloc(sizeof(int32_t) * 10);
- int32_t *t16_len = malloc(sizeof(int32_t) * 10);
- int32_t *t32_len = malloc(sizeof(int32_t) * 10);
- int32_t *t64_len = malloc(sizeof(int32_t) * 10);
- int32_t *float_len = malloc(sizeof(int32_t) * 10);
- int32_t *double_len = malloc(sizeof(int32_t) * 10);
- int32_t *bin_len = malloc(sizeof(int32_t) * 10);
- int32_t *blob_len = malloc(sizeof(int32_t) * 10);
-
- TAOS_STMT* stmt = taos_stmt_init(taos);
- TAOS_MULTI_BIND params[10];
- char is_null[10] = {0};
-
- params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
- params[0].buffer_length = sizeof(v.ts[0]);
- params[0].buffer = v.ts;
- params[0].length = t64_len;
- params[0].is_null = is_null;
- params[0].num = 10;
-
- params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
- params[1].buffer_length = sizeof(v.b[0]);
- params[1].buffer = v.b;
- params[1].length = t8_len;
- params[1].is_null = is_null;
- params[1].num = 10;
-
- params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
- params[2].buffer_length = sizeof(v.v1[0]);
- params[2].buffer = v.v1;
- params[2].length = t8_len;
- params[2].is_null = is_null;
- params[2].num = 10;
-
- params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
- params[3].buffer_length = sizeof(v.v2[0]);
- params[3].buffer = v.v2;
- params[3].length = t16_len;
- params[3].is_null = is_null;
- params[3].num = 10;
-
- params[4].buffer_type = TSDB_DATA_TYPE_INT;
- params[4].buffer_length = sizeof(v.v4[0]);
- params[4].buffer = v.v4;
- params[4].length = t32_len;
- params[4].is_null = is_null;
- params[4].num = 10;
-
- params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
- params[5].buffer_length = sizeof(v.v8[0]);
- params[5].buffer = v.v8;
- params[5].length = t64_len;
- params[5].is_null = is_null;
- params[5].num = 10;
-
- params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
- params[6].buffer_length = sizeof(v.f4[0]);
- params[6].buffer = v.f4;
- params[6].length = float_len;
- params[6].is_null = is_null;
- params[6].num = 10;
-
- params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
- params[7].buffer_length = sizeof(v.f8[0]);
- params[7].buffer = v.f8;
- params[7].length = double_len;
- params[7].is_null = is_null;
- params[7].num = 10;
-
- params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
- params[8].buffer_length = sizeof(v.bin[0]);
- params[8].buffer = v.bin;
- params[8].length = bin_len;
- params[8].is_null = is_null;
- params[8].num = 10;
-
- params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
- params[9].buffer_length = sizeof(v.blob[0]);
- params[9].buffer = v.blob;
- params[9].length = blob_len;
- params[9].is_null = is_null;
- params[9].num = 10;
-
-
- sql = "insert into ? using st1 tags(?,?) values(?,?,?,?,?,?,?,?,?,?)";
- code = taos_stmt_prepare(stmt, sql, 0);
- if (code != 0){
- printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
-
- code = taos_stmt_set_tbname_tags(stmt, "m1", tags);
- if (code != 0){
- printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
-
- int64_t ts = 1591060628000;
- for (int i = 0; i < 10; ++i) {
- v.ts[i] = ts++;
- is_null[i] = 0;
-
- v.b[i] = (int8_t)i % 2;
- v.v1[i] = (int8_t)i;
- v.v2[i] = (int16_t)(i * 2);
- v.v4[i] = (int32_t)(i * 4);
- v.v8[i] = (int64_t)(i * 8);
- v.f4[i] = (float)(i * 40);
- v.f8[i] = (double)(i * 80);
- for (int j = 0; j < sizeof(v.bin[0]); ++j) {
- v.bin[i][j] = (char)(i + '0');
- }
- strcpy(v.blob[i], "一二三四五六七八九十");
-
- t8_len[i] = sizeof(int8_t);
- t16_len[i] = sizeof(int16_t);
- t32_len[i] = sizeof(int32_t);
- t64_len[i] = sizeof(int64_t);
- float_len[i] = sizeof(float);
- double_len[i] = sizeof(double);
- bin_len[i] = sizeof(v.bin[0]);
- blob_len[i] = (int32_t)strlen(v.blob[i]);
- }
-
- taos_stmt_bind_param_batch(stmt, params);
- taos_stmt_add_batch(stmt);
-
- if (taos_stmt_execute(stmt) != 0) {
- printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
- taos_stmt_close(stmt);
-
- // query the records
- stmt = taos_stmt_init(taos);
- taos_stmt_prepare(stmt, "SELECT * FROM m1 WHERE v1 > ? AND v2 < ?", 0);
-
- TAOS_BIND qparams[2];
-
- int8_t v1 = 5;
- int16_t v2 = 15;
- qparams[0].buffer_type = TSDB_DATA_TYPE_TINYINT;
- qparams[0].buffer_length = sizeof(v1);
- qparams[0].buffer = &v1;
- qparams[0].length = &qparams[0].buffer_length;
- qparams[0].is_null = NULL;
-
- qparams[1].buffer_type = TSDB_DATA_TYPE_SMALLINT;
- qparams[1].buffer_length = sizeof(v2);
- qparams[1].buffer = &v2;
- qparams[1].length = &qparams[1].buffer_length;
- qparams[1].is_null = NULL;
-
- taos_stmt_bind_param(stmt, qparams);
- if (taos_stmt_execute(stmt) != 0) {
- printf("\033[31mfailed to execute select statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
- taos_stmt_close(stmt);
- return;
- }
-
- result = taos_stmt_use_result(stmt);
-
- TAOS_ROW row;
- int rows = 0;
- int num_fields = taos_num_fields(result);
- TAOS_FIELD *fields = taos_fetch_fields(result);
-
- // fetch the records row by row
- while ((row = taos_fetch_row(result))) {
- char temp[256] = {0};
- rows++;
- taos_print_row(temp, row, fields, num_fields);
- printf("%s\n", temp);
- }
-
- taos_free_result(result);
- taos_stmt_close(stmt);
-
- free(t8_len);
- free(t16_len);
- free(t32_len);
- free(t64_len);
- free(float_len);
- free(double_len);
- free(bin_len);
- free(blob_len);
-}
-
-void retrieve_callback(void *param, TAOS_RES *tres, int numOfRows)
-{
+void retrieve_callback(void* param, TAOS_RES* tres, int numOfRows) {
if (numOfRows > 0) {
printf("%d rows async retrieved\n", numOfRows);
taos_fetch_rows_a(tres, retrieve_callback, param);
@@ -903,8 +245,7 @@ void retrieve_callback(void *param, TAOS_RES *tres, int numOfRows)
}
}
-void select_callback(void *param, TAOS_RES *tres, int code)
-{
+void select_callback(void* param, TAOS_RES* tres, int code) {
if (code == 0 && tres) {
taos_fetch_rows_a(tres, retrieve_callback, param);
} else {
@@ -918,11 +259,11 @@ void verify_async(TAOS* taos) {
usleep(1000000);
}
-void stream_callback(void *param, TAOS_RES *res, TAOS_ROW row) {
+void stream_callback(void* param, TAOS_RES* res, TAOS_ROW row) {
if (res == NULL || row == NULL) {
return;
}
-
+
int num_fields = taos_num_fields(res);
TAOS_FIELD* fields = taos_fetch_fields(res);
@@ -934,14 +275,9 @@ void stream_callback(void *param, TAOS_RES *res, TAOS_ROW row) {
void verify_stream(TAOS* taos) {
prepare_data(taos);
- TAOS_STREAM* strm = taos_open_stream(
- taos,
- "select count(*) from meters interval(1m)",
- stream_callback,
- 0,
- NULL,
- NULL);
- printf("waiting for stream data\n");
+ TAOS_STREAM* strm =
+ taos_open_stream(taos, "select count(*) from meters interval(1m)", stream_callback, 0, NULL, NULL);
+ printf("waiting for stream data\n");
usleep(100000);
TAOS_RES* result = taos_query(taos, "insert into t0 values(now, 0)(now+5s,1)(now+10s, 2);");
taos_free_result(result);
@@ -950,7 +286,7 @@ void verify_stream(TAOS* taos) {
}
int32_t verify_schema_less(TAOS* taos) {
- TAOS_RES *result;
+ TAOS_RES* result;
result = taos_query(taos, "drop database if exists test;");
taos_free_result(result);
usleep(100000);
@@ -972,49 +308,51 @@ int32_t verify_schema_less(TAOS* taos) {
"st,t1=4i64,t2=5f64,t3=\"t4\" c1=3i64,c3=L\"passitagain\",c2=true,c4=5f64 1626006833642000000ns",
"ste,t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532ns",
"ste,t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32i8,c6=64i16,c7=32i32,c8=88.88f32 1626056812843316532ns",
- "st,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns",
- "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns",
- "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641000000ns"
- };
+ "st,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 "
+ "1626006933640000000ns",
+ "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 "
+ "1626006933640000000ns",
+ "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 "
+ "1626006933641000000ns"};
- code = taos_insert_lines(taos, lines , sizeof(lines)/sizeof(char*));
+ code = taos_insert_lines(taos, lines, sizeof(lines) / sizeof(char*));
char* lines2[] = {
"stg,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
- "stg,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns"
- };
+ "stg,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns"};
code = taos_insert_lines(taos, &lines2[0], 1);
code = taos_insert_lines(taos, &lines2[1], 1);
char* lines3[] = {
- "sth,t1=4i64,t2=5f64,t4=5f64,ID=\"childtable\" c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641ms",
- "sth,t1=4i64,t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933654ms"
- };
+ "sth,t1=4i64,t2=5f64,t4=5f64,ID=\"childtable\" c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 "
+ "1626006933641ms",
+ "sth,t1=4i64,t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933654ms"};
code = taos_insert_lines(taos, lines3, 2);
- char* lines4[] = {
- "st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
- "dgtyqodr,t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"
- };
+ char* lines4[] = {"st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
+ "dgtyqodr,t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"};
code = taos_insert_lines(taos, lines4, 2);
char* lines5[] = {
- "zqlbgs,id=\"zqlbgs_39302_21680\",t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"binaryTagValue\",t8=L\"ncharTagValue\" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"binaryColValue\",c8=L\"ncharColValue\",c9=7u64 1626006833639000000ns",
- "zqlbgs,t9=f,id=\"zqlbgs_39302_21680\",t0=f,t1=127i8,t11=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"binaryTagValue\",t8=L\"ncharTagValue\",t10=L\"ncharTagValue\" c10=f,c0=f,c1=127i8,c12=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"binaryColValue\",c8=L\"ncharColValue\",c9=7u64,c11=L\"ncharColValue\" 1626006833639000000ns"
- };
+ "zqlbgs,id=\"zqlbgs_39302_21680\",t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11."
+ "12345f32,t6=22.123456789f64,t7=\"binaryTagValue\",t8=L\"ncharTagValue\" "
+ "c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="
+ "\"binaryColValue\",c8=L\"ncharColValue\",c9=7u64 1626006833639000000ns",
+ "zqlbgs,t9=f,id=\"zqlbgs_39302_21680\",t0=f,t1=127i8,t11=127i8,t2=32767i16,t3=2147483647i32,t4="
+ "9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"binaryTagValue\",t8=L\"ncharTagValue\",t10="
+ "L\"ncharTagValue\" "
+ "c10=f,c0=f,c1=127i8,c12=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22."
+ "123456789f64,c7=\"binaryColValue\",c8=L\"ncharColValue\",c9=7u64,c11=L\"ncharColValue\" 1626006833639000000ns"};
code = taos_insert_lines(taos, &lines5[0], 1);
code = taos_insert_lines(taos, &lines5[1], 1);
-
- char* lines6[] = {
- "st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
- "dgtyqodr,t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"
- };
+ char* lines6[] = {"st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
+ "dgtyqodr,t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"};
code = taos_insert_lines(taos, lines6, 2);
return (code);
}
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
const char* host = "127.0.0.1";
const char* user = "root";
const char* passwd = "taosdata";
@@ -1034,7 +372,6 @@ int main(int argc, char *argv[]) {
printf("************ verify schema-less *************\n");
verify_schema_less(taos);
-
printf("************ verify query *************\n");
verify_query(taos);
@@ -1044,16 +381,8 @@ int main(int argc, char *argv[]) {
printf("*********** verify subscribe ************\n");
verify_subscribe(taos);
- printf("************ verify prepare *************\n");
- verify_prepare(taos);
-
- printf("************ verify prepare2 *************\n");
- verify_prepare2(taos);
- printf("************ verify prepare3 *************\n");
- verify_prepare3(taos);
-
printf("************ verify stream *************\n");
- verify_stream(taos);
+ // verify_stream(taos);
printf("done\n");
taos_close(taos);
taos_cleanup();
diff --git a/tests/examples/c/asyncdemo.c b/tests/examples/c/asyncdemo.c
index f2a96dd8256782960f9ad114229cd47714c9d1d9..78e41ddf5cad70ddb430dfdd5832e92d2800d030 100644
--- a/tests/examples/c/asyncdemo.c
+++ b/tests/examples/c/asyncdemo.c
@@ -20,9 +20,9 @@
#include
#include
+#include
#include
#include
-#include
#include
@@ -33,14 +33,14 @@ int tablesSelectProcessed = 0;
int64_t st, et;
typedef struct {
- int id;
- TAOS *taos;
- char name[16];
- time_t timeStamp;
- int value;
- int rowsInserted;
- int rowsTried;
- int rowsRetrieved;
+ int id;
+ TAOS * taos;
+ char name[16];
+ time_t timeStamp;
+ int value;
+ int rowsInserted;
+ int rowsTried;
+ int rowsRetrieved;
} STable;
void taos_insert_call_back(void *param, TAOS_RES *tres, int code);
@@ -48,7 +48,7 @@ void taos_select_call_back(void *param, TAOS_RES *tres, int code);
void taos_error(TAOS *taos);
static void queryDB(TAOS *taos, char *command) {
- int i;
+ int i;
TAOS_RES *pSql = NULL;
int32_t code = -1;
@@ -57,12 +57,12 @@ static void queryDB(TAOS *taos, char *command) {
taos_free_result(pSql);
pSql = NULL;
}
-
+
pSql = taos_query(taos, command);
code = taos_errno(pSql);
if (0 == code) {
break;
- }
+ }
}
if (code != 0) {
@@ -76,15 +76,14 @@ static void queryDB(TAOS *taos, char *command) {
taos_free_result(pSql);
}
-int main(int argc, char *argv[])
-{
- TAOS *taos;
- struct timeval systemTime;
- int i;
- char sql[1024] = { 0 };
- char prefix[20] = { 0 };
- char db[128] = { 0 };
- STable *tableList;
+int main(int argc, char *argv[]) {
+ TAOS * taos;
+ struct timeval systemTime;
+ int i;
+ char sql[1024] = {0};
+ char prefix[20] = {0};
+ char db[128] = {0};
+ STable * tableList;
if (argc != 5) {
printf("usage: %s server-ip dbname rowsPerTable numOfTables\n", argv[0]);
@@ -101,8 +100,7 @@ int main(int argc, char *argv[])
memset(tableList, 0, size);
taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
- if (taos == NULL)
- taos_error(taos);
+ if (taos == NULL) taos_error(taos);
printf("success to connect to server\n");
@@ -122,7 +120,7 @@ int main(int argc, char *argv[])
sprintf(tableList[i].name, "%s%d", prefix, i);
sprintf(sql, "create table %s%d (ts timestamp, volume bigint)", prefix, i);
queryDB(taos, sql);
- }
+ }
gettimeofday(&systemTime, NULL);
for (i = 0; i < numOfTables; ++i)
@@ -138,7 +136,7 @@ int main(int argc, char *argv[])
tablesInsertProcessed = 0;
tablesSelectProcessed = 0;
- for (i = 0; irowsTried++;
- if (code < 0) {
+ if (code < 0) {
printf("%s insert failed, code:%d, rows:%d\n", pTable->name, code, pTable->rowsTried);
- }
- else if (code == 0) {
+ } else if (code == 0) {
printf("%s not inserted\n", pTable->name);
- }
- else {
+ } else {
pTable->rowsInserted++;
}
if (pTable->rowsTried < points) {
// for this demo, insert another record
- sprintf(sql, "insert into %s values(%ld, %d)", pTable->name, 1546300800000+pTable->rowsTried*1000, pTable->rowsTried);
+ sprintf(sql, "insert into %s values(%ld, %d)", pTable->name, 1546300800000 + pTable->rowsTried * 1000,
+ pTable->rowsTried);
taos_query_a(pTable->taos, sql, taos_insert_call_back, (void *)pTable);
- }
- else {
+ } else {
printf("%d rows data are inserted into %s\n", points, pTable->name);
tablesInsertProcessed++;
if (tablesInsertProcessed >= numOfTables) {
gettimeofday(&systemTime, NULL);
et = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
- printf("%lld mseconds to insert %d data points\n", (et - st) / 1000, points*numOfTables);
+ printf("%lld mseconds to insert %d data points\n", (et - st) / 1000, points * numOfTables);
}
}
-
+
taos_free_result(tres);
}
-void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows)
-{
- STable *pTable = (STable *)param;
+void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows) {
+ STable * pTable = (STable *)param;
struct timeval systemTime;
if (numOfRows > 0) {
-
- for (int i = 0; iname, numOfRows);
+ } else {
+ if (numOfRows < 0) printf("%s retrieve failed, code:%d\n", pTable->name, numOfRows);
- //taos_free_result(tres);
+ // taos_free_result(tres);
printf("%d rows data retrieved from %s\n", pTable->rowsRetrieved, pTable->name);
tablesSelectProcessed++;
@@ -272,19 +261,15 @@ void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows)
taos_free_result(tres);
}
-
-
}
-void taos_select_call_back(void *param, TAOS_RES *tres, int code)
-{
+void taos_select_call_back(void *param, TAOS_RES *tres, int code) {
STable *pTable = (STable *)param;
if (code == 0 && tres) {
// asynchronous API to fetch a batch of records
taos_fetch_rows_a(tres, taos_retrieve_call_back, pTable);
- }
- else {
+ } else {
printf("%s select failed, code:%d\n", pTable->name, code);
taos_free_result(tres);
taos_cleanup();
diff --git a/tests/examples/c/demo.c b/tests/examples/c/demo.c
index f8c69d0043591afa8f5e32e80bd35e9413e60e76..55d962888871c2ba175daef85f1084a1e28a0da1 100644
--- a/tests/examples/c/demo.c
+++ b/tests/examples/c/demo.c
@@ -16,14 +16,14 @@
// TAOS standard API example. The same syntax as MySQL, but only a subset
// to compile: gcc -o demo demo.c -ltaos
+#include
#include
#include
#include
-#include
#include // TAOS header file
static void queryDB(TAOS *taos, char *command) {
- int i;
+ int i;
TAOS_RES *pSql = NULL;
int32_t code = -1;
@@ -32,12 +32,12 @@ static void queryDB(TAOS *taos, char *command) {
taos_free_result(pSql);
pSql = NULL;
}
-
+
pSql = taos_query(taos, command);
code = taos_errno(pSql);
if (0 == code) {
break;
- }
+ }
}
if (code != 0) {
@@ -53,7 +53,7 @@ static void queryDB(TAOS *taos, char *command) {
void Test(TAOS *taos, char *qstr, int i);
int main(int argc, char *argv[]) {
- char qstr[1024];
+ char qstr[1024];
// connect to server
if (argc < 2) {
@@ -63,7 +63,7 @@ int main(int argc, char *argv[]) {
TAOS *taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
if (taos == NULL) {
- printf("failed to connect to server, reason:%s\n", "null taos"/*taos_errstr(taos)*/);
+ printf("failed to connect to server, reason:%s\n", "null taos" /*taos_errstr(taos)*/);
exit(1);
}
for (int i = 0; i < 100; i++) {
@@ -72,28 +72,30 @@ int main(int argc, char *argv[]) {
taos_close(taos);
taos_cleanup();
}
-void Test(TAOS *taos, char *qstr, int index) {
+void Test(TAOS *taos, char *qstr, int index) {
printf("==================test at %d\n================================", index);
queryDB(taos, "drop database if exists demo");
queryDB(taos, "create database demo");
TAOS_RES *result;
queryDB(taos, "use demo");
- queryDB(taos, "create table m1 (ts timestamp, ti tinyint, si smallint, i int, bi bigint, f float, d double, b binary(10))");
+ queryDB(taos,
+ "create table m1 (ts timestamp, ti tinyint, si smallint, i int, bi bigint, f float, d double, b binary(10))");
printf("success to create table\n");
int i = 0;
for (i = 0; i < 10; ++i) {
- sprintf(qstr, "insert into m1 values (%" PRId64 ", %d, %d, %d, %d, %f, %lf, '%s')", (uint64_t)(1546300800000 + i * 1000), i, i, i, i*10000000, i*1.0, i*2.0, "hello");
+ sprintf(qstr, "insert into m1 values (%" PRId64 ", %d, %d, %d, %d, %f, %lf, '%s')",
+ (uint64_t)(1546300800000 + i * 1000), i, i, i, i * 10000000, i * 1.0, i * 2.0, "hello");
printf("qstr: %s\n", qstr);
-
+
// note: how do you wanna do if taos_query returns non-NULL
// if (taos_query(taos, qstr)) {
// printf("insert row: %i, reason:%s\n", i, taos_errstr(taos));
// }
TAOS_RES *result1 = taos_query(taos, qstr);
if (result1 == NULL || taos_errno(result1) != 0) {
- printf("failed to insert row, reason:%s\n", taos_errstr(result1));
+ printf("failed to insert row, reason:%s\n", taos_errstr(result1));
taos_free_result(result1);
exit(1);
} else {
@@ -107,7 +109,7 @@ void Test(TAOS *taos, char *qstr, int index) {
sprintf(qstr, "SELECT * FROM m1");
result = taos_query(taos, qstr);
if (result == NULL || taos_errno(result) != 0) {
- printf("failed to select, reason:%s\n", taos_errstr(result));
+ printf("failed to select, reason:%s\n", taos_errstr(result));
taos_free_result(result);
exit(1);
}
@@ -130,4 +132,3 @@ void Test(TAOS *taos, char *qstr, int index) {
taos_free_result(result);
printf("====demo end====\n\n");
}
-
diff --git a/tests/examples/c/epoll.c b/tests/examples/c/epoll.c
index 284268ac4328b5bc814ab8d30931ec92c5c11523..0fb8754de666d7067ef3dcbf9b7797592ca5b61b 100644
--- a/tests/examples/c/epoll.c
+++ b/tests/examples/c/epoll.c
@@ -21,103 +21,101 @@
#ifdef __APPLE__
#include "osEok.h"
-#else // __APPLE__
+#else // __APPLE__
#include
-#endif // __APPLE__
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
+#endif // __APPLE__
#include
-#include
#include
-#include
-#include
+#include
#include
#include
#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
#define D(fmt, ...) fprintf(stderr, "%s[%d]%s(): " fmt "\n", basename(__FILE__), __LINE__, __func__, ##__VA_ARGS__)
-#define A(statement, fmt, ...) do { \
- if (statement) break; \
- fprintf(stderr, "%s[%d]%s(): assert [%s] failed: %d[%s]: " fmt "\n", \
- basename(__FILE__), __LINE__, __func__, \
- #statement, errno, strerror(errno), \
- ##__VA_ARGS__); \
- abort(); \
-} while (0)
+#define A(statement, fmt, ...) \
+ do { \
+ if (statement) break; \
+ fprintf(stderr, "%s[%d]%s(): assert [%s] failed: %d[%s]: " fmt "\n", basename(__FILE__), __LINE__, __func__, \
+ #statement, errno, strerror(errno), ##__VA_ARGS__); \
+ abort(); \
+ } while (0)
-#define E(fmt, ...) do { \
- fprintf(stderr, "%s[%d]%s(): %d[%s]: " fmt "\n", \
- basename(__FILE__), __LINE__, __func__, \
- errno, strerror(errno), \
- ##__VA_ARGS__); \
-} while (0)
+#define E(fmt, ...) \
+ do { \
+ fprintf(stderr, "%s[%d]%s(): %d[%s]: " fmt "\n", basename(__FILE__), __LINE__, __func__, errno, strerror(errno), \
+ ##__VA_ARGS__); \
+ } while (0)
#include "os.h"
-typedef struct ep_s ep_t;
+typedef struct ep_s ep_t;
struct ep_s {
- int ep;
+ int ep;
- pthread_mutex_t lock;
- int sv[2]; // 0 for read, 1 for write;
- pthread_t thread;
+ pthread_mutex_t lock;
+ int sv[2]; // 0 for read, 1 for write;
+ pthread_t thread;
- volatile unsigned int stopping:1;
- volatile unsigned int waiting:1;
- volatile unsigned int wakenup:1;
+ volatile unsigned int stopping : 1;
+ volatile unsigned int waiting : 1;
+ volatile unsigned int wakenup : 1;
};
static int ep_dummy = 0;
-static ep_t* ep_create(void);
+static ep_t *ep_create(void);
static void ep_destroy(ep_t *ep);
-static void* routine(void* arg);
-static int open_listen(unsigned short port);
+static void *routine(void *arg);
+static int open_listen(unsigned short port);
-typedef struct fde_s fde_t;
+typedef struct fde_s fde_t;
struct fde_s {
- int skt;
+ int skt;
void (*on_event)(ep_t *ep, struct epoll_event *events, fde_t *client);
};
static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client);
static void null_event(ep_t *ep, struct epoll_event *ev, fde_t *client);
-#define usage(arg0, fmt, ...) do { \
- if (fmt[0]) { \
- fprintf(stderr, "" fmt "\n", ##__VA_ARGS__); \
- } \
- fprintf(stderr, "usage:\n"); \
- fprintf(stderr, " %s -l : specify listenning port\n", arg0); \
-} while (0)
+#define usage(arg0, fmt, ...) \
+ do { \
+ if (fmt[0]) { \
+ fprintf(stderr, "" fmt "\n", ##__VA_ARGS__); \
+ } \
+ fprintf(stderr, "usage:\n"); \
+ fprintf(stderr, " %s -l : specify listenning port\n", arg0); \
+ } while (0)
int main(int argc, char *argv[]) {
char *prg = basename(argv[0]);
- if (argc==1) {
+ if (argc == 1) {
usage(prg, "");
return 0;
}
- ep_t* ep = ep_create();
+ ep_t *ep = ep_create();
A(ep, "failed");
- for (int i=1; i=argc) {
+ if (i >= argc) {
usage(prg, "expecting after -l, but got nothing");
- return 1; // confirmed potential leakage
+ return 1; // confirmed potential leakage
}
arg = argv[i];
int port = atoi(arg);
int skt = open_listen(port);
- if (skt==-1) continue;
- fde_t *client = (fde_t*)calloc(1, sizeof(*client));
+ if (skt == -1) continue;
+ fde_t *client = (fde_t *)calloc(1, sizeof(*client));
if (!client) {
E("out of memory");
close(skt);
@@ -126,32 +124,32 @@ int main(int argc, char *argv[]) {
client->skt = skt;
client->on_event = listen_event;
struct epoll_event ev = {0};
- ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
+ ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
ev.data.ptr = client;
- A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ev), "");
+ A(0 == epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ev), "");
continue;
}
usage(prg, "unknown argument: [%s]", arg);
return 1;
}
- char *line = NULL;
- size_t linecap = 0;
+ char * line = NULL;
+ size_t linecap = 0;
ssize_t linelen;
while ((linelen = getline(&line, &linecap, stdin)) > 0) {
- line[strlen(line)-1] = '\0';
- if (0==strcmp(line, "exit")) break;
- if (0==strcmp(line, "quit")) break;
- if (line==strstr(line, "close")) {
+ line[strlen(line) - 1] = '\0';
+ if (0 == strcmp(line, "exit")) break;
+ if (0 == strcmp(line, "quit")) break;
+ if (line == strstr(line, "close")) {
int fd = 0;
sscanf(line, "close %d", &fd);
- if (fd<=2) {
+ if (fd <= 2) {
fprintf(stderr, "fd [%d] invalid\n", fd);
continue;
}
- A(0==epoll_ctl(ep->ep, EPOLL_CTL_DEL, fd, NULL), "");
+ A(0 == epoll_ctl(ep->ep, EPOLL_CTL_DEL, fd, NULL), "");
continue;
}
- if (strlen(line)==0) continue;
+ if (strlen(line) == 0) continue;
fprintf(stderr, "unknown cmd:[%s]\n", line);
}
ep_destroy(ep);
@@ -159,69 +157,69 @@ int main(int argc, char *argv[]) {
return 0;
}
-ep_t* ep_create(void) {
- ep_t *ep = (ep_t*)calloc(1, sizeof(*ep));
+ep_t *ep_create(void) {
+ ep_t *ep = (ep_t *)calloc(1, sizeof(*ep));
A(ep, "out of memory");
- A(-1!=(ep->ep = epoll_create(1)), "");
+ A(-1 != (ep->ep = epoll_create(1)), "");
ep->sv[0] = -1;
ep->sv[1] = -1;
- A(0==socketpair(AF_LOCAL, SOCK_STREAM, 0, ep->sv), "");
- A(0==pthread_mutex_init(&ep->lock, NULL), "");
- A(0==pthread_mutex_lock(&ep->lock), "");
+ A(0 == socketpair(AF_LOCAL, SOCK_STREAM, 0, ep->sv), "");
+ A(0 == pthread_mutex_init(&ep->lock, NULL), "");
+ A(0 == pthread_mutex_lock(&ep->lock), "");
struct epoll_event ev = {0};
- ev.events = EPOLLIN;
+ ev.events = EPOLLIN;
ev.data.ptr = &ep_dummy;
- A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, ep->sv[0], &ev), "");
- A(0==pthread_create(&ep->thread, NULL, routine, ep), "");
- A(0==pthread_mutex_unlock(&ep->lock), "");
+ A(0 == epoll_ctl(ep->ep, EPOLL_CTL_ADD, ep->sv[0], &ev), "");
+ A(0 == pthread_create(&ep->thread, NULL, routine, ep), "");
+ A(0 == pthread_mutex_unlock(&ep->lock), "");
return ep;
}
static void ep_destroy(ep_t *ep) {
A(ep, "invalid argument");
ep->stopping = 1;
- A(1==send(ep->sv[1], "1", 1, 0), "");
- A(0==pthread_join(ep->thread, NULL), "");
- A(0==pthread_mutex_destroy(&ep->lock), "");
- A(0==close(ep->sv[0]), "");
- A(0==close(ep->sv[1]), "");
- A(0==close(ep->ep), "");
+ A(1 == send(ep->sv[1], "1", 1, 0), "");
+ A(0 == pthread_join(ep->thread, NULL), "");
+ A(0 == pthread_mutex_destroy(&ep->lock), "");
+ A(0 == close(ep->sv[0]), "");
+ A(0 == close(ep->sv[1]), "");
+ A(0 == close(ep->ep), "");
free(ep);
}
-static void* routine(void* arg) {
+static void *routine(void *arg) {
A(arg, "invalid argument");
- ep_t *ep = (ep_t*)arg;
+ ep_t *ep = (ep_t *)arg;
while (!ep->stopping) {
struct epoll_event evs[10];
memset(evs, 0, sizeof(evs));
- A(0==pthread_mutex_lock(&ep->lock), "");
- A(ep->waiting==0, "internal logic error");
+ A(0 == pthread_mutex_lock(&ep->lock), "");
+ A(ep->waiting == 0, "internal logic error");
ep->waiting = 1;
- A(0==pthread_mutex_unlock(&ep->lock), "");
+ A(0 == pthread_mutex_unlock(&ep->lock), "");
- int r = epoll_wait(ep->ep, evs, sizeof(evs)/sizeof(evs[0]), -1);
- A(r>0, "indefinite epoll_wait shall not timeout:[%d]", r);
+ int r = epoll_wait(ep->ep, evs, sizeof(evs) / sizeof(evs[0]), -1);
+ A(r > 0, "indefinite epoll_wait shall not timeout:[%d]", r);
- A(0==pthread_mutex_lock(&ep->lock), "");
- A(ep->waiting==1, "internal logic error");
+ A(0 == pthread_mutex_lock(&ep->lock), "");
+ A(ep->waiting == 1, "internal logic error");
ep->waiting = 0;
- A(0==pthread_mutex_unlock(&ep->lock), "");
+ A(0 == pthread_mutex_unlock(&ep->lock), "");
- for (int i=0; idata.ptr == &ep_dummy) {
char c = '\0';
- A(1==recv(ep->sv[0], &c, 1, 0), "internal logic error");
- A(0==pthread_mutex_lock(&ep->lock), "");
+ A(1 == recv(ep->sv[0], &c, 1, 0), "internal logic error");
+ A(0 == pthread_mutex_lock(&ep->lock), "");
ep->wakenup = 0;
- A(0==pthread_mutex_unlock(&ep->lock), "");
+ A(0 == pthread_mutex_unlock(&ep->lock), "");
continue;
}
A(ev->data.ptr, "internal logic error");
- fde_t *client = (fde_t*)ev->data.ptr;
+ fde_t *client = (fde_t *)ev->data.ptr;
client->on_event(ep, ev, client);
continue;
}
@@ -232,7 +230,7 @@ static void* routine(void* arg) {
static int open_listen(unsigned short port) {
int r = 0;
int skt = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
- if (skt==-1) {
+ if (skt == -1) {
E("socket() failed");
return -1;
}
@@ -241,7 +239,7 @@ static int open_listen(unsigned short port) {
si.sin_family = AF_INET;
si.sin_addr.s_addr = inet_addr("0.0.0.0");
si.sin_port = htons(port);
- r = bind(skt, (struct sockaddr*)&si, sizeof(si));
+ r = bind(skt, (struct sockaddr *)&si, sizeof(si));
if (r) {
E("bind(%u) failed", port);
break;
@@ -257,7 +255,7 @@ static int open_listen(unsigned short port) {
if (r) {
E("getsockname() failed");
}
- A(len==sizeof(si), "internal logic error");
+ A(len == sizeof(si), "internal logic error");
D("listenning at: %d", ntohs(si.sin_port));
return skt;
} while (0);
@@ -268,10 +266,10 @@ static int open_listen(unsigned short port) {
static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
A(ev->events & EPOLLIN, "internal logic error");
struct sockaddr_in si = {0};
- socklen_t silen = sizeof(si);
- int skt = accept(client->skt, (struct sockaddr*)&si, &silen);
- A(skt!=-1, "internal logic error");
- fde_t *server = (fde_t*)calloc(1, sizeof(*server));
+ socklen_t silen = sizeof(si);
+ int skt = accept(client->skt, (struct sockaddr *)&si, &silen);
+ A(skt != -1, "internal logic error");
+ fde_t *server = (fde_t *)calloc(1, sizeof(*server));
if (!server) {
close(skt);
return;
@@ -279,26 +277,25 @@ static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
server->skt = skt;
server->on_event = null_event;
struct epoll_event ee = {0};
- ee.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
+ ee.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
ee.data.ptr = server;
- A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ee), "");
+ A(0 == epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ee), "");
}
static void null_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
if (ev->events & EPOLLIN) {
char buf[8192];
- int n = recv(client->skt, buf, sizeof(buf), 0);
- A(n>=0 && n<=sizeof(buf), "internal logic error:[%d]", n);
- A(n==fwrite(buf, 1, n, stdout), "internal logic error");
+ int n = recv(client->skt, buf, sizeof(buf), 0);
+ A(n >= 0 && n <= sizeof(buf), "internal logic error:[%d]", n);
+ A(n == fwrite(buf, 1, n, stdout), "internal logic error");
}
if (ev->events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
- A(0==pthread_mutex_lock(&ep->lock), "");
- A(0==epoll_ctl(ep->ep, EPOLL_CTL_DEL, client->skt, NULL), "");
- A(0==pthread_mutex_unlock(&ep->lock), "");
+ A(0 == pthread_mutex_lock(&ep->lock), "");
+ A(0 == epoll_ctl(ep->ep, EPOLL_CTL_DEL, client->skt, NULL), "");
+ A(0 == pthread_mutex_unlock(&ep->lock), "");
close(client->skt);
client->skt = -1;
client->on_event = NULL;
free(client);
}
}
-
diff --git a/tests/examples/c/makefile b/tests/examples/c/makefile
index 304623c27af27cd23a301af134647fb3b9746d64..bc10caa57681987b6ce682931011f38ed6ec8f95 100644
--- a/tests/examples/c/makefile
+++ b/tests/examples/c/makefile
@@ -7,6 +7,7 @@ LFLAGS = '-Wl,-rpath,/usr/local/taos/driver/' -ltaos -lpthread -lm -lrt
CFLAGS = -O3 -g -Wall -Wno-deprecated -fPIC -Wno-unused-result -Wconversion \
-Wno-char-subscripts -D_REENTRANT -Wno-format -D_REENTRANT -DLINUX \
-Wno-unused-function -D_M_X64 -I/usr/local/taos/include -std=gnu99
+ -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment
all: $(TARGET)
@@ -19,10 +20,9 @@ exe:
gcc $(CFLAGS) ./apitest.c -o $(ROOT)apitest $(LFLAGS)
clean:
- rm $(ROOT)asyncdemo
- rm $(ROOT)demo
- rm $(ROOT)prepare
- rm $(ROOT)batchprepare
- rm $(ROOT)stream
- rm $(ROOT)subscribe
- rm $(ROOT)apitest
+ rm -f $(ROOT)asyncdemo
+ rm -f $(ROOT)demo
+ rm -f $(ROOT)prepare
+ rm -f $(ROOT)stream
+ rm -f $(ROOT)subscribe
+ rm -f $(ROOT)apitest
diff --git a/tests/examples/c/prepare.c b/tests/examples/c/prepare.c
index 723b340a923c0bf326599e8090f8c6142a249053..de92032c18cc8acc9cbb4e06b7abfee8673b8203 100644
--- a/tests/examples/c/prepare.c
+++ b/tests/examples/c/prepare.c
@@ -1,78 +1,66 @@
-// TAOS standard API example. The same syntax as MySQL, but only a subet
+// TAOS standard API example. The same syntax as MySQL, but only a subet
// to compile: gcc -o prepare prepare.c -ltaos
#include
#include
#include
-#include "taos.h"
-
+#include
+#include
void taosMsleep(int mseconds);
-int main(int argc, char *argv[])
-{
- TAOS *taos;
- TAOS_RES *result;
- int code;
- TAOS_STMT *stmt;
-
- // connect to server
- if (argc < 2) {
- printf("please input server ip \n");
- return 0;
- }
-
- taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
- if (taos == NULL) {
- printf("failed to connect to db, reason:%s\n", taos_errstr(taos));
- exit(1);
- }
-
- result = taos_query(taos, "drop database demo");
+void verify_prepare(TAOS* taos) {
+ TAOS_RES* result = taos_query(taos, "drop database if exists test;");
taos_free_result(result);
- result = taos_query(taos, "create database demo");
- code = taos_errno(result);
+ usleep(100000);
+ result = taos_query(taos, "create database test;");
+
+ int code = taos_errno(result);
if (code != 0) {
- printf("failed to create database, reason:%s\n", taos_errstr(result));
+ printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
taos_free_result(result);
- exit(1);
+ exit(EXIT_FAILURE);
}
- taos_free_result(result);
- result = taos_query(taos, "use demo");
taos_free_result(result);
+ usleep(100000);
+ taos_select_db(taos, "test");
+
// create table
- const char* sql = "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10))";
+ const char* sql =
+ "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin "
+ "binary(40), blob nchar(10), u1 tinyint unsigned, u2 smallint unsigned, u4 int unsigned, u8 bigint unsigned)";
result = taos_query(taos, sql);
code = taos_errno(result);
if (code != 0) {
- printf("failed to create table, reason:%s\n", taos_errstr(result));
+ printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
taos_free_result(result);
- exit(1);
+ exit(EXIT_FAILURE);
}
taos_free_result(result);
- // sleep for one second to make sure table is created on data node
- // taosMsleep(1000);
-
// insert 10 records
struct {
- int64_t ts;
- int8_t b;
- int8_t v1;
- int16_t v2;
- int32_t v4;
- int64_t v8;
- float f4;
- double f8;
- char bin[40];
- char blob[80];
+ int64_t ts;
+ int8_t b;
+ int8_t v1;
+ int16_t v2;
+ int32_t v4;
+ int64_t v8;
+ float f4;
+ double f8;
+ char bin[40];
+ char blob[80];
+ uint8_t u1;
+ uint16_t u2;
+ uint32_t u4;
+ uint64_t u8;
} v = {0};
- stmt = taos_stmt_init(taos);
- TAOS_BIND params[10];
+ TAOS_STMT* stmt = taos_stmt_init(taos);
+ TAOS_BIND params[14];
params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
params[0].buffer_length = sizeof(v.ts);
params[0].buffer = &v.ts;
@@ -134,12 +122,38 @@ int main(int argc, char *argv[])
params[9].length = ¶ms[9].buffer_length;
params[9].is_null = NULL;
+ params[10].buffer_type = TSDB_DATA_TYPE_UTINYINT;
+ params[10].buffer_length = sizeof(v.u1);
+ params[10].buffer = &v.u1;
+ params[10].length = ¶ms[10].buffer_length;
+ params[10].is_null = NULL;
+
+ params[11].buffer_type = TSDB_DATA_TYPE_USMALLINT;
+ params[11].buffer_length = sizeof(v.u2);
+ params[11].buffer = &v.u2;
+ params[11].length = ¶ms[11].buffer_length;
+ params[11].is_null = NULL;
+
+ params[12].buffer_type = TSDB_DATA_TYPE_UINT;
+ params[12].buffer_length = sizeof(v.u4);
+ params[12].buffer = &v.u4;
+ params[12].length = ¶ms[12].buffer_length;
+ params[12].is_null = NULL;
+
+ params[13].buffer_type = TSDB_DATA_TYPE_UBIGINT;
+ params[13].buffer_length = sizeof(v.u8);
+ params[13].buffer = &v.u8;
+ params[13].length = ¶ms[13].buffer_length;
+ params[13].is_null = NULL;
+
int is_null = 1;
- sql = "insert into m1 values(?,?,?,?,?,?,?,?,?,?)";
+ sql = "insert into m1 values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
code = taos_stmt_prepare(stmt, sql, 0);
- if (code != 0){
- printf("failed to execute taos_stmt_prepare. code:0x%x\n", code);
+ if (code != 0) {
+ printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
}
v.ts = 1591060628000;
for (int i = 0; i < 10; ++i) {
@@ -154,16 +168,21 @@ int main(int argc, char *argv[])
v.v8 = (int64_t)(i * 8);
v.f4 = (float)(i * 40);
v.f8 = (double)(i * 80);
- for (int j = 0; j < sizeof(v.bin) - 1; ++j) {
+ for (int j = 0; j < sizeof(v.bin); ++j) {
v.bin[j] = (char)(i + '0');
}
+ v.u1 = (uint8_t)i;
+ v.u2 = (uint16_t)(i * 2);
+ v.u4 = (uint32_t)(i * 4);
+ v.u8 = (uint64_t)(i * 8);
taos_stmt_bind_param(stmt, params);
taos_stmt_add_batch(stmt);
}
if (taos_stmt_execute(stmt) != 0) {
- printf("failed to execute insert statement.\n");
- exit(1);
+ printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
}
taos_stmt_close(stmt);
@@ -174,8 +193,239 @@ int main(int argc, char *argv[])
v.v2 = 15;
taos_stmt_bind_param(stmt, params + 2);
if (taos_stmt_execute(stmt) != 0) {
- printf("failed to execute select statement.\n");
- exit(1);
+ printf("\033[31mfailed to execute select statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
+ }
+
+ result = taos_stmt_use_result(stmt);
+
+ TAOS_ROW row;
+ int rows = 0;
+ int num_fields = taos_num_fields(result);
+ TAOS_FIELD* fields = taos_fetch_fields(result);
+
+ // fetch the records row by row
+ while ((row = taos_fetch_row(result))) {
+ char temp[256] = {0};
+ rows++;
+ taos_print_row(temp, row, fields, num_fields);
+ printf("%s\n", temp);
+ }
+
+ taos_free_result(result);
+ taos_stmt_close(stmt);
+}
+
+void verify_prepare2(TAOS* taos) {
+ TAOS_RES* result = taos_query(taos, "drop database if exists test;");
+ taos_free_result(result);
+ usleep(100000);
+ result = taos_query(taos, "create database test;");
+
+ int code = taos_errno(result);
+ if (code != 0) {
+ printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
+ taos_free_result(result);
+ exit(EXIT_FAILURE);
+ }
+ taos_free_result(result);
+
+ usleep(100000);
+ taos_select_db(taos, "test");
+
+ // create table
+ const char* sql =
+ "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin "
+ "binary(40), blob nchar(10), u1 tinyint unsigned, u2 smallint unsigned, u4 int unsigned, u8 bigint unsigned)";
+ result = taos_query(taos, sql);
+ code = taos_errno(result);
+ if (code != 0) {
+ printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
+ taos_free_result(result);
+ exit(EXIT_FAILURE);
+ }
+ taos_free_result(result);
+
+ // insert 10 records
+ struct {
+ int64_t ts;
+ int8_t b;
+ int8_t v1;
+ int16_t v2;
+ int32_t v4;
+ int64_t v8;
+ float f4;
+ double f8;
+ char bin[40];
+ char blob[80];
+ uint8_t u1;
+ uint16_t u2;
+ uint32_t u4;
+ uint64_t u8;
+ } v = {0};
+
+ TAOS_STMT* stmt = taos_stmt_init(taos);
+ TAOS_BIND params[14];
+ params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+ params[0].buffer_length = sizeof(v.ts);
+ params[0].buffer = &v.ts;
+ params[0].length = ¶ms[0].buffer_length;
+ params[0].is_null = NULL;
+
+ params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
+ params[1].buffer_length = sizeof(v.b);
+ params[1].buffer = &v.b;
+ params[1].length = ¶ms[1].buffer_length;
+ params[1].is_null = NULL;
+
+ params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
+ params[2].buffer_length = sizeof(v.v1);
+ params[2].buffer = &v.v1;
+ params[2].length = ¶ms[2].buffer_length;
+ params[2].is_null = NULL;
+
+ params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
+ params[3].buffer_length = sizeof(v.v2);
+ params[3].buffer = &v.v2;
+ params[3].length = ¶ms[3].buffer_length;
+ params[3].is_null = NULL;
+
+ params[4].buffer_type = TSDB_DATA_TYPE_INT;
+ params[4].buffer_length = sizeof(v.v4);
+ params[4].buffer = &v.v4;
+ params[4].length = ¶ms[4].buffer_length;
+ params[4].is_null = NULL;
+
+ params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
+ params[5].buffer_length = sizeof(v.v8);
+ params[5].buffer = &v.v8;
+ params[5].length = ¶ms[5].buffer_length;
+ params[5].is_null = NULL;
+
+ params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
+ params[6].buffer_length = sizeof(v.f4);
+ params[6].buffer = &v.f4;
+ params[6].length = ¶ms[6].buffer_length;
+ params[6].is_null = NULL;
+
+ params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
+ params[7].buffer_length = sizeof(v.f8);
+ params[7].buffer = &v.f8;
+ params[7].length = ¶ms[7].buffer_length;
+ params[7].is_null = NULL;
+
+ params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
+ params[8].buffer_length = sizeof(v.bin);
+ params[8].buffer = v.bin;
+ params[8].length = ¶ms[8].buffer_length;
+ params[8].is_null = NULL;
+
+ strcpy(v.blob, "一二三四五六七八九十");
+ params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
+ params[9].buffer_length = strlen(v.blob);
+ params[9].buffer = v.blob;
+ params[9].length = ¶ms[9].buffer_length;
+ params[9].is_null = NULL;
+
+ params[10].buffer_type = TSDB_DATA_TYPE_UTINYINT;
+ params[10].buffer_length = sizeof(v.u1);
+ params[10].buffer = &v.u1;
+ params[10].length = ¶ms[10].buffer_length;
+ params[10].is_null = NULL;
+
+ params[11].buffer_type = TSDB_DATA_TYPE_USMALLINT;
+ params[11].buffer_length = sizeof(v.u2);
+ params[11].buffer = &v.u2;
+ params[11].length = ¶ms[11].buffer_length;
+ params[11].is_null = NULL;
+
+ params[12].buffer_type = TSDB_DATA_TYPE_UINT;
+ params[12].buffer_length = sizeof(v.u4);
+ params[12].buffer = &v.u4;
+ params[12].length = ¶ms[12].buffer_length;
+ params[12].is_null = NULL;
+
+ params[13].buffer_type = TSDB_DATA_TYPE_UBIGINT;
+ params[13].buffer_length = sizeof(v.u8);
+ params[13].buffer = &v.u8;
+ params[13].length = ¶ms[13].buffer_length;
+ params[13].is_null = NULL;
+
+ sql = "insert into ? values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
+ code = taos_stmt_prepare(stmt, sql, 0);
+ if (code != 0) {
+ printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
+ }
+
+ code = taos_stmt_set_tbname(stmt, "m1");
+ if (code != 0) {
+ printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
+ }
+
+ int is_null = 1;
+
+ v.ts = 1591060628000;
+ for (int i = 0; i < 10; ++i) {
+ v.ts += 1;
+ for (int j = 1; j < 10; ++j) {
+ params[j].is_null = ((i == j) ? &is_null : 0);
+ }
+ v.b = (int8_t)i % 2;
+ v.v1 = (int8_t)i;
+ v.v2 = (int16_t)(i * 2);
+ v.v4 = (int32_t)(i * 4);
+ v.v8 = (int64_t)(i * 8);
+ v.f4 = (float)(i * 40);
+ v.f8 = (double)(i * 80);
+ for (int j = 0; j < sizeof(v.bin); ++j) {
+ v.bin[j] = (char)(i + '0');
+ }
+ v.u1 = (uint8_t)i;
+ v.u2 = (uint16_t)(i * 2);
+ v.u4 = (uint32_t)(i * 4);
+ v.u8 = (uint64_t)(i * 8);
+
+ taos_stmt_bind_param(stmt, params);
+ taos_stmt_add_batch(stmt);
+ }
+
+ if (taos_stmt_execute(stmt) != 0) {
+ printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
+ }
+
+ taos_stmt_close(stmt);
+
+ // query the records
+ stmt = taos_stmt_init(taos);
+ taos_stmt_prepare(stmt, "SELECT * FROM m1 WHERE v1 > ? AND v2 < ?", 0);
+ TAOS_BIND qparams[2];
+
+ int8_t v1 = 5;
+ int16_t v2 = 15;
+ qparams[0].buffer_type = TSDB_DATA_TYPE_TINYINT;
+ qparams[0].buffer_length = sizeof(v1);
+ qparams[0].buffer = &v1;
+ qparams[0].length = &qparams[0].buffer_length;
+ qparams[0].is_null = NULL;
+
+ qparams[1].buffer_type = TSDB_DATA_TYPE_SMALLINT;
+ qparams[1].buffer_length = sizeof(v2);
+ qparams[1].buffer = &v2;
+ qparams[1].length = &qparams[1].buffer_length;
+ qparams[1].is_null = NULL;
+
+ taos_stmt_bind_param(stmt, qparams);
+ if (taos_stmt_execute(stmt) != 0) {
+ printf("\033[31mfailed to execute select statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
}
result = taos_stmt_use_result(stmt);
@@ -183,7 +433,7 @@ int main(int argc, char *argv[])
TAOS_ROW row;
int rows = 0;
int num_fields = taos_num_fields(result);
- TAOS_FIELD *fields = taos_fetch_fields(result);
+ TAOS_FIELD* fields = taos_fetch_fields(result);
// fetch the records row by row
while ((row = taos_fetch_row(result))) {
@@ -192,15 +442,427 @@ int main(int argc, char *argv[])
taos_print_row(temp, row, fields, num_fields);
printf("%s\n", temp);
}
- if (rows == 2) {
- printf("two rows are fetched as expectation\n");
- } else {
- printf("expect two rows, but %d rows are fetched\n", rows);
+
+ taos_free_result(result);
+ taos_stmt_close(stmt);
+}
+
+void verify_prepare3(TAOS* taos) {
+ TAOS_RES* result = taos_query(taos, "drop database if exists test;");
+ taos_free_result(result);
+ usleep(100000);
+ result = taos_query(taos, "create database test;");
+
+ int code = taos_errno(result);
+ if (code != 0) {
+ printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
+ taos_free_result(result);
+ exit(EXIT_FAILURE);
+ }
+ taos_free_result(result);
+
+ usleep(100000);
+ taos_select_db(taos, "test");
+
+ // create table
+ const char* sql =
+ "create stable st1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin "
+ "binary(40), blob nchar(10), u1 tinyint unsigned, u2 smallint unsigned, u4 int unsigned, u8 bigint unsigned) "
+ "tags "
+ "(b_tag bool, v1_tag tinyint, v2_tag smallint, v4_tag int, v8_tag bigint, f4_tag float, f8_tag double, bin_tag "
+ "binary(40), blob_tag nchar(10), u1_tag tinyint unsigned, u2_tag smallint unsigned, u4_tag int unsigned, u8_tag "
+ "bigint "
+ "unsigned)";
+ result = taos_query(taos, sql);
+ code = taos_errno(result);
+ if (code != 0) {
+ printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
+ taos_free_result(result);
+ exit(EXIT_FAILURE);
+ }
+ taos_free_result(result);
+
+ TAOS_BIND tags[13];
+
+ struct {
+ int8_t b;
+ int8_t v1;
+ int16_t v2;
+ int32_t v4;
+ int64_t v8;
+ float f4;
+ double f8;
+ char bin[40];
+ char blob[80];
+ uint8_t u1;
+ uint16_t u2;
+ uint32_t u4;
+ uint64_t u8;
+ } id = {0};
+
+ id.b = (int8_t)1;
+ id.v1 = (int8_t)1;
+ id.v2 = (int16_t)2;
+ id.v4 = (int32_t)4;
+ id.v8 = (int64_t)8;
+ id.f4 = (float)40;
+ id.f8 = (double)80;
+ for (int j = 0; j < sizeof(id.bin); ++j) {
+ id.bin[j] = (char)('1' + '0');
+ }
+ strcpy(id.blob, "一二三四五六七八九十");
+ id.u1 = (uint8_t)1;
+ id.u2 = (uint16_t)2;
+ id.u4 = (uint32_t)4;
+ id.u8 = (uint64_t)8;
+
+ tags[0].buffer_type = TSDB_DATA_TYPE_BOOL;
+ tags[0].buffer_length = sizeof(id.b);
+ tags[0].buffer = &id.b;
+ tags[0].length = &tags[0].buffer_length;
+ tags[0].is_null = NULL;
+
+ tags[1].buffer_type = TSDB_DATA_TYPE_TINYINT;
+ tags[1].buffer_length = sizeof(id.v1);
+ tags[1].buffer = &id.v1;
+ tags[1].length = &tags[1].buffer_length;
+ tags[1].is_null = NULL;
+
+ tags[2].buffer_type = TSDB_DATA_TYPE_SMALLINT;
+ tags[2].buffer_length = sizeof(id.v2);
+ tags[2].buffer = &id.v2;
+ tags[2].length = &tags[2].buffer_length;
+ tags[2].is_null = NULL;
+
+ tags[3].buffer_type = TSDB_DATA_TYPE_INT;
+ tags[3].buffer_length = sizeof(id.v4);
+ tags[3].buffer = &id.v4;
+ tags[3].length = &tags[3].buffer_length;
+ tags[3].is_null = NULL;
+
+ tags[4].buffer_type = TSDB_DATA_TYPE_BIGINT;
+ tags[4].buffer_length = sizeof(id.v8);
+ tags[4].buffer = &id.v8;
+ tags[4].length = &tags[4].buffer_length;
+ tags[4].is_null = NULL;
+
+ tags[5].buffer_type = TSDB_DATA_TYPE_FLOAT;
+ tags[5].buffer_length = sizeof(id.f4);
+ tags[5].buffer = &id.f4;
+ tags[5].length = &tags[5].buffer_length;
+ tags[5].is_null = NULL;
+
+ tags[6].buffer_type = TSDB_DATA_TYPE_DOUBLE;
+ tags[6].buffer_length = sizeof(id.f8);
+ tags[6].buffer = &id.f8;
+ tags[6].length = &tags[6].buffer_length;
+ tags[6].is_null = NULL;
+
+ tags[7].buffer_type = TSDB_DATA_TYPE_BINARY;
+ tags[7].buffer_length = sizeof(id.bin);
+ tags[7].buffer = &id.bin;
+ tags[7].length = &tags[7].buffer_length;
+ tags[7].is_null = NULL;
+
+ tags[8].buffer_type = TSDB_DATA_TYPE_NCHAR;
+ tags[8].buffer_length = strlen(id.blob);
+ tags[8].buffer = &id.blob;
+ tags[8].length = &tags[8].buffer_length;
+ tags[8].is_null = NULL;
+
+ tags[9].buffer_type = TSDB_DATA_TYPE_UTINYINT;
+ tags[9].buffer_length = sizeof(id.u1);
+ tags[9].buffer = &id.u1;
+ tags[9].length = &tags[9].buffer_length;
+ tags[9].is_null = NULL;
+
+ tags[10].buffer_type = TSDB_DATA_TYPE_USMALLINT;
+ tags[10].buffer_length = sizeof(id.u2);
+ tags[10].buffer = &id.u2;
+ tags[10].length = &tags[10].buffer_length;
+ tags[10].is_null = NULL;
+
+ tags[11].buffer_type = TSDB_DATA_TYPE_UINT;
+ tags[11].buffer_length = sizeof(id.u4);
+ tags[11].buffer = &id.u4;
+ tags[11].length = &tags[11].buffer_length;
+ tags[11].is_null = NULL;
+
+ tags[12].buffer_type = TSDB_DATA_TYPE_UBIGINT;
+ tags[12].buffer_length = sizeof(id.u8);
+ tags[12].buffer = &id.u8;
+ tags[12].length = &tags[12].buffer_length;
+ tags[12].is_null = NULL;
+ // insert 10 records
+ struct {
+ int64_t ts[10];
+ int8_t b[10];
+ int8_t v1[10];
+ int16_t v2[10];
+ int32_t v4[10];
+ int64_t v8[10];
+ float f4[10];
+ double f8[10];
+ char bin[10][40];
+ char blob[10][80];
+ uint8_t u1[10];
+ uint16_t u2[10];
+ uint32_t u4[10];
+ uint64_t u8[10];
+ } v;
+
+ int32_t* t8_len = malloc(sizeof(int32_t) * 10);
+ int32_t* t16_len = malloc(sizeof(int32_t) * 10);
+ int32_t* t32_len = malloc(sizeof(int32_t) * 10);
+ int32_t* t64_len = malloc(sizeof(int32_t) * 10);
+ int32_t* float_len = malloc(sizeof(int32_t) * 10);
+ int32_t* double_len = malloc(sizeof(int32_t) * 10);
+ int32_t* bin_len = malloc(sizeof(int32_t) * 10);
+ int32_t* blob_len = malloc(sizeof(int32_t) * 10);
+ int32_t* u8_len = malloc(sizeof(int32_t) * 10);
+ int32_t* u16_len = malloc(sizeof(int32_t) * 10);
+ int32_t* u32_len = malloc(sizeof(int32_t) * 10);
+ int32_t* u64_len = malloc(sizeof(int32_t) * 10);
+
+ TAOS_STMT* stmt = taos_stmt_init(taos);
+ TAOS_MULTI_BIND params[14];
+ char is_null[10] = {0};
+
+ params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+ params[0].buffer_length = sizeof(v.ts[0]);
+ params[0].buffer = v.ts;
+ params[0].length = t64_len;
+ params[0].is_null = is_null;
+ params[0].num = 10;
+
+ params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
+ params[1].buffer_length = sizeof(v.b[0]);
+ params[1].buffer = v.b;
+ params[1].length = t8_len;
+ params[1].is_null = is_null;
+ params[1].num = 10;
+
+ params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
+ params[2].buffer_length = sizeof(v.v1[0]);
+ params[2].buffer = v.v1;
+ params[2].length = t8_len;
+ params[2].is_null = is_null;
+ params[2].num = 10;
+
+ params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
+ params[3].buffer_length = sizeof(v.v2[0]);
+ params[3].buffer = v.v2;
+ params[3].length = t16_len;
+ params[3].is_null = is_null;
+ params[3].num = 10;
+
+ params[4].buffer_type = TSDB_DATA_TYPE_INT;
+ params[4].buffer_length = sizeof(v.v4[0]);
+ params[4].buffer = v.v4;
+ params[4].length = t32_len;
+ params[4].is_null = is_null;
+ params[4].num = 10;
+
+ params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
+ params[5].buffer_length = sizeof(v.v8[0]);
+ params[5].buffer = v.v8;
+ params[5].length = t64_len;
+ params[5].is_null = is_null;
+ params[5].num = 10;
+
+ params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
+ params[6].buffer_length = sizeof(v.f4[0]);
+ params[6].buffer = v.f4;
+ params[6].length = float_len;
+ params[6].is_null = is_null;
+ params[6].num = 10;
+
+ params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
+ params[7].buffer_length = sizeof(v.f8[0]);
+ params[7].buffer = v.f8;
+ params[7].length = double_len;
+ params[7].is_null = is_null;
+ params[7].num = 10;
+
+ params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
+ params[8].buffer_length = sizeof(v.bin[0]);
+ params[8].buffer = v.bin;
+ params[8].length = bin_len;
+ params[8].is_null = is_null;
+ params[8].num = 10;
+
+ params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
+ params[9].buffer_length = sizeof(v.blob[0]);
+ params[9].buffer = v.blob;
+ params[9].length = blob_len;
+ params[9].is_null = is_null;
+ params[9].num = 10;
+
+ params[10].buffer_type = TSDB_DATA_TYPE_UTINYINT;
+ params[10].buffer_length = sizeof(v.u1[0]);
+ params[10].buffer = v.u1;
+ params[10].length = u8_len;
+ params[10].is_null = is_null;
+ params[10].num = 10;
+
+ params[11].buffer_type = TSDB_DATA_TYPE_USMALLINT;
+ params[11].buffer_length = sizeof(v.u2[0]);
+ params[11].buffer = v.u2;
+ params[11].length = u16_len;
+ params[11].is_null = is_null;
+ params[11].num = 10;
+
+ params[12].buffer_type = TSDB_DATA_TYPE_UINT;
+ params[12].buffer_length = sizeof(v.u4[0]);
+ params[12].buffer = v.u4;
+ params[12].length = u32_len;
+ params[12].is_null = is_null;
+ params[12].num = 10;
+
+ params[13].buffer_type = TSDB_DATA_TYPE_UBIGINT;
+ params[13].buffer_length = sizeof(v.u8[0]);
+ params[13].buffer = v.u8;
+ params[13].length = u64_len;
+ params[13].is_null = is_null;
+ params[13].num = 10;
+
+ sql = "insert into ? using st1 tags(?,?,?,?,?,?,?,?,?,?,?,?,?) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
+ code = taos_stmt_prepare(stmt, sql, 0);
+ if (code != 0) {
+ printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
+ }
+
+ code = taos_stmt_set_tbname_tags(stmt, "m1", tags);
+ if (code != 0) {
+ printf("\033[31mfailed to execute taos_stmt_set_tbname_tags. error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
+ }
+
+ int64_t ts = 1591060628000;
+ for (int i = 0; i < 10; ++i) {
+ v.ts[i] = ts++;
+ is_null[i] = 0;
+
+ v.b[i] = (int8_t)i % 2;
+ v.v1[i] = (int8_t)i;
+ v.v2[i] = (int16_t)(i * 2);
+ v.v4[i] = (int32_t)(i * 4);
+ v.v8[i] = (int64_t)(i * 8);
+ v.f4[i] = (float)(i * 40);
+ v.f8[i] = (double)(i * 80);
+ for (int j = 0; j < sizeof(v.bin[0]); ++j) {
+ v.bin[i][j] = (char)(i + '0');
+ }
+ strcpy(v.blob[i], "一二三四五六七八九十");
+ v.u1[i] = (uint8_t)i;
+ v.u2[i] = (uint16_t)(i * 2);
+ v.u4[i] = (uint32_t)(i * 4);
+ v.u8[i] = (uint64_t)(i * 8);
+
+ t8_len[i] = sizeof(int8_t);
+ t16_len[i] = sizeof(int16_t);
+ t32_len[i] = sizeof(int32_t);
+ t64_len[i] = sizeof(int64_t);
+ float_len[i] = sizeof(float);
+ double_len[i] = sizeof(double);
+ bin_len[i] = sizeof(v.bin[0]);
+ blob_len[i] = (int32_t)strlen(v.blob[i]);
+ u8_len[i] = sizeof(uint8_t);
+ u16_len[i] = sizeof(uint16_t);
+ u32_len[i] = sizeof(uint32_t);
+ u64_len[i] = sizeof(uint64_t);
+ }
+
+ taos_stmt_bind_param_batch(stmt, params);
+ taos_stmt_add_batch(stmt);
+
+ if (taos_stmt_execute(stmt) != 0) {
+ printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
+ }
+ taos_stmt_close(stmt);
+
+ // query the records
+ stmt = taos_stmt_init(taos);
+ taos_stmt_prepare(stmt, "SELECT * FROM m1 WHERE v1 > ? AND v2 < ?", 0);
+
+ TAOS_BIND qparams[2];
+
+ int8_t v1 = 5;
+ int16_t v2 = 15;
+ qparams[0].buffer_type = TSDB_DATA_TYPE_TINYINT;
+ qparams[0].buffer_length = sizeof(v1);
+ qparams[0].buffer = &v1;
+ qparams[0].length = &qparams[0].buffer_length;
+ qparams[0].is_null = NULL;
+
+ qparams[1].buffer_type = TSDB_DATA_TYPE_SMALLINT;
+ qparams[1].buffer_length = sizeof(v2);
+ qparams[1].buffer = &v2;
+ qparams[1].length = &qparams[1].buffer_length;
+ qparams[1].is_null = NULL;
+
+ taos_stmt_bind_param(stmt, qparams);
+ if (taos_stmt_execute(stmt) != 0) {
+ printf("\033[31mfailed to execute select statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
+ taos_stmt_close(stmt);
+ exit(EXIT_FAILURE);
+ }
+
+ result = taos_stmt_use_result(stmt);
+
+ TAOS_ROW row;
+ int rows = 0;
+ int num_fields = taos_num_fields(result);
+ TAOS_FIELD* fields = taos_fetch_fields(result);
+
+ // fetch the records row by row
+ while ((row = taos_fetch_row(result))) {
+ char temp[256] = {0};
+ rows++;
+ taos_print_row(temp, row, fields, num_fields);
+ printf("%s\n", temp);
}
taos_free_result(result);
taos_stmt_close(stmt);
- return 0;
+ free(t8_len);
+ free(t16_len);
+ free(t32_len);
+ free(t64_len);
+ free(float_len);
+ free(double_len);
+ free(bin_len);
+ free(blob_len);
}
+int main(int argc, char* argv[]) {
+ const char* host = "127.0.0.1";
+ const char* user = "root";
+ const char* passwd = "taosdata";
+
+ taos_options(TSDB_OPTION_TIMEZONE, "GMT-8");
+ TAOS* taos = taos_connect(host, user, passwd, "", 0);
+ if (taos == NULL) {
+ printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos));
+ exit(1);
+ }
+
+ char* info = taos_get_server_info(taos);
+ printf("server info: %s\n", info);
+ info = taos_get_client_info(taos);
+ printf("client info: %s\n", info);
+ printf("************ verify prepare *************\n");
+ verify_prepare(taos);
+ printf("************ verify prepare2 *************\n");
+ verify_prepare2(taos);
+ printf("************ verify prepare3 *************\n");
+ verify_prepare3(taos);
+ printf("************ verify prepare4 *************\n");
+ exit(EXIT_SUCCESS);
+}
diff --git a/tests/examples/c/schemaless.c b/tests/examples/c/schemaless.c
index 3ea199c9144950526e4bbf59b9356753e2a88da6..43e9e1697810968dbeef195343924555caf8a986 100644
--- a/tests/examples/c/schemaless.c
+++ b/tests/examples/c/schemaless.c
@@ -1,6 +1,6 @@
+#include "os.h"
#include "taos.h"
#include "taoserror.h"
-#include "os.h"
#include
#include
@@ -8,33 +8,58 @@
#include
#include
+int numThreads = 8;
int numSuperTables = 8;
-int numChildTables = 4;
+int numChildTables = 4; // per thread, per super table
int numRowsPerChildTable = 2048;
-void shuffle(char**lines, size_t n)
-{
- if (n > 1)
- {
+void shuffle(char** lines, size_t n) {
+ if (n > 1) {
size_t i;
- for (i = 0; i < n - 1; i++)
- {
+ for (i = 0; i < n - 1; i++) {
size_t j = i + rand() / (RAND_MAX / (n - i) + 1);
- char* t = lines[j];
+ char* t = lines[j];
lines[j] = lines[i];
lines[i] = t;
}
}
}
+void printThreadId(pthread_t id, char* buf)
+{
+ size_t i;
+ for (i = sizeof(i); i; --i)
+ sprintf(buf + strlen(buf), "%02x", *(((unsigned char*) &id) + i - 1));
+}
+
static int64_t getTimeInUs() {
struct timeval systemTime;
gettimeofday(&systemTime, NULL);
return (int64_t)systemTime.tv_sec * 1000000L + (int64_t)systemTime.tv_usec;
}
+typedef struct {
+ TAOS* taos;
+ char** lines;
+ int numLines;
+ int64_t costTime;
+} SThreadInsertArgs;
+
+static void* insertLines(void* args) {
+ SThreadInsertArgs* insertArgs = (SThreadInsertArgs*) args;
+ char tidBuf[32] = {0};
+ printThreadId(pthread_self(), tidBuf);
+ printf("%s, thread: 0x%s\n", "begin taos_insert_lines", tidBuf);
+ int64_t begin = getTimeInUs();
+ int32_t code = taos_insert_lines(insertArgs->taos, insertArgs->lines, insertArgs->numLines);
+ int64_t end = getTimeInUs();
+ insertArgs->costTime = end-begin;
+ printf("code: %d, %s. time used:%"PRId64", thread: 0x%s\n", code, tstrerror(code), end - begin, tidBuf);
+ return NULL;
+}
+
int main(int argc, char* argv[]) {
- TAOS_RES *result;
+ TAOS_RES* result;
const char* host = "127.0.0.1";
const char* user = "root";
const char* passwd = "taosdata";
@@ -59,143 +84,92 @@ int main(int argc, char* argv[]) {
(void)taos_select_db(taos, "db");
- time_t ct = time(0);
+ time_t ct = time(0);
int64_t ts = ct * 1000;
- char* lineFormat = "sta%d,t0=true,t1=127i8,t2=32767i16,t3=%di32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" %lldms";
-
- char** lines = calloc(numSuperTables * numChildTables * numRowsPerChildTable, sizeof(char*));
- int l = 0;
- for (int i = 0; i < numSuperTables; ++i) {
- for (int j = 0; j < numChildTables; ++j) {
- for (int k = 0; k < numRowsPerChildTable; ++k) {
- char* line = calloc(512, 1);
- snprintf(line, 512, lineFormat, i, j, ts + 10 * l);
- lines[l] = line;
- ++l;
- }
- }
- }
- shuffle(lines, numSuperTables * numChildTables * numRowsPerChildTable);
-
- printf("%s\n", "begin taos_insert_lines");
- int64_t begin = getTimeInUs();
- int32_t code = taos_insert_lines(taos, lines, numSuperTables * numChildTables * numRowsPerChildTable);
- int64_t end = getTimeInUs();
- printf("code: %d, %s. time used: %"PRId64"\n", code, tstrerror(code), end-begin);
-
- char* lines_000_0[] = {
- "sta1,id=sta1_1,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=255u8,t6=32770u16,t7=2147483699u32,t8=9223372036854775899u64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639000us"
- };
-
- code = taos_insert_lines(taos, lines_000_0 , sizeof(lines_000_0)/sizeof(char*));
- if (0 == code) {
- printf("taos_insert_lines() lines_000_0 should return error\n");
- return -1;
- }
-
- char* lines_000_1[] = {
- "sta2,id=\"sta2_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=255u8,t6=32770u16,t7=2147483699u32,t8=9223372036854775899u64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639001"
- };
+ char* lineFormat = "sta%d,t0=true,t1=127i8,t2=32767i16,t3=%di32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=254u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" %lldms";
- code = taos_insert_lines(taos, lines_000_1 , sizeof(lines_000_1)/sizeof(char*));
- if (0 == code) {
- printf("taos_insert_lines() lines_000_1 should return error\n");
- return -1;
- }
-
- char* lines_000_2[] = {
- "sta3,id=\"sta3_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=255u8,c6=32770u16,c7=2147483699u32,c8=9223372036854775899u64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 0"
- };
-
- code = taos_insert_lines(taos, lines_000_2 , sizeof(lines_000_2)/sizeof(char*));
- if (0 != code) {
- printf("taos_insert_lines() lines_000_2 return code:%d (%s)\n", code, (char*)tstrerror(code));
- return -1;
+ {
+ char** linesStb = calloc(numSuperTables, sizeof(char*));
+ for (int i = 0; i < numSuperTables; i++) {
+ char* lineStb = calloc(512, 1);
+ snprintf(lineStb, 512, lineFormat, i,
+ numThreads * numSuperTables * numChildTables,
+ ts + numThreads * numSuperTables * numChildTables * numRowsPerChildTable);
+ linesStb[i] = lineStb;
+ }
+ SThreadInsertArgs args = {0};
+ args.taos = taos;
+ args.lines = linesStb;
+ args.numLines = numSuperTables;
+ insertLines(&args);
+ for (int i = 0; i < numSuperTables; ++i) {
+ free(linesStb[i]);
+ }
+ free(linesStb);
}
- char* lines_001_0[] = {
- "sta4,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639000us",
-
- };
-
- code = taos_insert_lines(taos, lines_001_0 , sizeof(lines_001_0)/sizeof(char*));
- if (0 != code) {
- printf("taos_insert_lines() lines_001_0 return code:%d (%s)\n", code, (char*)tstrerror(code));
- return -1;
+ printf("generate lines...\n");
+ char*** linesThread = calloc(numThreads, sizeof(char**));
+ for (int i = 0; i < numThreads; ++i) {
+ char** lines = calloc(numSuperTables * numChildTables * numRowsPerChildTable, sizeof(char*));
+ linesThread[i] = lines;
}
- char* lines_001_1[] = {
- "sta5,id=\"sta5_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639001"
- };
-
- code = taos_insert_lines(taos, lines_001_1 , sizeof(lines_001_1)/sizeof(char*));
- if (0 != code) {
- printf("taos_insert_lines() lines_001_1 return code:%d (%s)\n", code, (char*)tstrerror(code));
- return -1;
+ for (int t = 0; t < numThreads; ++t) {
+ int l = 0;
+ char** lines = linesThread[t];
+ for (int i = 0; i < numSuperTables; ++i) {
+ for (int j = 0; j < numChildTables; ++j) {
+ for (int k = 0; k < numRowsPerChildTable; ++k) {
+ int stIdx = i;
+ int ctIdx = t*numSuperTables*numChildTables + j;
+ char* line = calloc(512, 1);
+ snprintf(line, 512, lineFormat, stIdx, ctIdx, ts + 10 * l);
+ lines[l] = line;
+ ++l;
+ }
+ }
+ }
}
- char* lines_001_2[] = {
- "sta6,id=\"sta6_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t9=11.12345f32,t10=22.123456789f64,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c0=true,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c9=11.12345f32,c10=22.123456789f64,c11=\"binaryValue\",c12=L\"ncharValue\" 0"
- };
-
- code = taos_insert_lines(taos, lines_001_2 , sizeof(lines_001_2)/sizeof(char*));
- if (0 != code) {
- printf("taos_insert_lines() lines_001_2 return code:%d (%s)\n", code, (char*)tstrerror(code));
- return -1;
+ printf("shuffle lines...\n");
+ for (int t = 0; t < numThreads; ++t) {
+ shuffle(linesThread[t], numSuperTables * numChildTables * numRowsPerChildTable);
}
- char* lines_002[] = {
- "stb,id=\"stb_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639000000ns",
- "stc,id=\"stc_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833639019us",
- "stc,id=\"stc_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006833640ms",
- "stc,id=\"stc_1\",t20=t,t21=T,t22=true,t23=True,t24=TRUE,t25=f,t26=F,t27=false,t28=False,t29=FALSE,t10=33.12345,t11=\"binaryTagValue\",t12=L\"ncharTagValue\" c20=t,c21=T,c22=true,c23=True,c24=TRUE,c25=f,c26=F,c27=false,c28=False,c29=FALSE,c10=33.12345,c11=\"binaryValue\",c12=L\"ncharValue\" 1626006834s"
- };
-
- code = taos_insert_lines(taos, lines_002 , sizeof(lines_002)/sizeof(char*));
- if (0 != code) {
- printf("taos_insert_lines() lines_002 return code:%d (%s)\n", code, (char*)tstrerror(code));
- return -1;
+ printf("begin multi-thread insertion...\n");
+ int64_t begin = taosGetTimestampUs();
+ pthread_t* tids = calloc(numThreads, sizeof(pthread_t));
+ SThreadInsertArgs* argsThread = calloc(numThreads, sizeof(SThreadInsertArgs));
+ for (int i=0; i < numThreads; ++i) {
+ argsThread[i].lines = linesThread[i];
+ argsThread[i].taos = taos;
+ argsThread[i].numLines = numSuperTables * numChildTables * numRowsPerChildTable;
+ pthread_create(tids+i, NULL, insertLines, argsThread+i);
}
- //Duplicate key check;
- char* lines_003_1[] = {
- "std,id=\"std_3_1\",t1=4i64,Id=\"std\",t2=true c1=true 1626006834s"
- };
-
- code = taos_insert_lines(taos, lines_003_1 , sizeof(lines_003_1)/sizeof(char*));
- if (0 == code) {
- printf("taos_insert_lines() lines_003_1 return code:%d (%s)\n", code, (char*)tstrerror(code));
- return -1;
+ for (int i = 0; i < numThreads; ++i) {
+ pthread_join(tids[i], NULL);
}
-
- char* lines_003_2[] = {
- "std,id=\"std_3_2\",tag1=4i64,Tag2=true,tAg3=2,TaG2=\"dup!\" c1=true 1626006834s"
- };
-
- code = taos_insert_lines(taos, lines_003_2 , sizeof(lines_003_2)/sizeof(char*));
- if (0 == code) {
- printf("taos_insert_lines() lines_003_2 return code:%d (%s)\n", code, (char*)tstrerror(code));
- return -1;
+ int64_t end = taosGetTimestampUs();
+
+ int totalLines = numThreads*numSuperTables*numChildTables*numRowsPerChildTable;
+ printf("TOTAL LINES: %d\n", totalLines);
+ printf("THREADS: %d\n", numThreads);
+ int64_t sumTime = 0;
+ for (int i=0; i.
*/
+#include
#include
#include
#include
-#include
-#include
#include // include TDengine header file
+#include
typedef struct {
- char server_ip[64];
- char db_name[64];
- char tbl_name[64];
+ char server_ip[64];
+ char db_name[64];
+ char tbl_name[64];
} param;
-int g_thread_exit_flag = 0;
-void* insert_rows(void *sarg);
+int g_thread_exit_flag = 0;
+void *insert_rows(void *sarg);
-void streamCallBack(void *param, TAOS_RES *res, TAOS_ROW row)
-{
+void streamCallBack(void *param, TAOS_RES *res, TAOS_ROW row) {
// in this simple demo, it just print out the result
char temp[128];
@@ -42,85 +41,81 @@ void streamCallBack(void *param, TAOS_RES *res, TAOS_ROW row)
printf("\n%s\n", temp);
}
-int main(int argc, char *argv[])
-{
- TAOS *taos;
- char db_name[64];
- char tbl_name[64];
- char sql[1024] = { 0 };
+int main(int argc, char *argv[]) {
+ TAOS *taos;
+ char db_name[64];
+ char tbl_name[64];
+ char sql[1024] = {0};
if (argc != 4) {
printf("usage: %s server-ip dbname tblname\n", argv[0]);
exit(0);
- }
+ }
strcpy(db_name, argv[2]);
strcpy(tbl_name, argv[3]);
-
+
// create pthread to insert into row per second for stream calc
param *t_param = (param *)malloc(sizeof(param));
- if (NULL == t_param)
- {
+ if (NULL == t_param) {
printf("failed to malloc\n");
exit(1);
}
- memset(t_param, 0, sizeof(param));
+ memset(t_param, 0, sizeof(param));
strcpy(t_param->server_ip, argv[1]);
strcpy(t_param->db_name, db_name);
strcpy(t_param->tbl_name, tbl_name);
pthread_t pid;
- pthread_create(&pid, NULL, (void * (*)(void *))insert_rows, t_param);
+ pthread_create(&pid, NULL, (void *(*)(void *))insert_rows, t_param);
- sleep(3); // waiting for database is created.
+ sleep(3); // waiting for database is created.
// open connection to database
taos = taos_connect(argv[1], "root", "taosdata", db_name, 0);
if (taos == NULL) {
printf("failed to connet to server:%s\n", argv[1]);
- free(t_param);
+ free(t_param);
exit(1);
}
- // starting stream calc,
+ // starting stream calc,
printf("please input stream SQL:[e.g., select count(*) from tblname interval(5s) sliding(2s);]\n");
fgets(sql, sizeof(sql), stdin);
if (sql[0] == 0) {
- printf("input NULL stream SQL, so exit!\n");
+ printf("input NULL stream SQL, so exit!\n");
free(t_param);
exit(1);
}
- // param is set to NULL in this demo, it shall be set to the pointer to app context
+ // param is set to NULL in this demo, it shall be set to the pointer to app context
TAOS_STREAM *pStream = taos_open_stream(taos, sql, streamCallBack, 0, NULL, NULL);
if (NULL == pStream) {
- printf("failed to create stream\n");
+ printf("failed to create stream\n");
free(t_param);
exit(1);
}
-
+
printf("presss any key to exit\n");
getchar();
taos_close_stream(pStream);
-
- g_thread_exit_flag = 1;
+
+ g_thread_exit_flag = 1;
pthread_join(pid, NULL);
taos_close(taos);
- free(t_param);
+ free(t_param);
return 0;
}
+void *insert_rows(void *sarg) {
+ TAOS * taos;
+ char command[1024] = {0};
+ param *winfo = (param *)sarg;
-void* insert_rows(void *sarg)
-{
- TAOS *taos;
- char command[1024] = { 0 };
- param *winfo = (param * )sarg;
-
- if (NULL == winfo){
- printf("para is null!\n");
+ if (NULL == winfo) {
+ printf("para is null!\n");
exit(1);
}
@@ -129,7 +124,7 @@ void* insert_rows(void *sarg)
printf("failed to connet to server:%s\n", winfo->server_ip);
exit(1);
}
-
+
// drop database
sprintf(command, "drop database %s;", winfo->db_name);
if (taos_query(taos, command) != 0) {
@@ -160,19 +155,18 @@ void* insert_rows(void *sarg)
// insert data
int64_t begin = (int64_t)time(NULL);
- int index = 0;
+ int index = 0;
while (1) {
if (g_thread_exit_flag) break;
-
+
index++;
sprintf(command, "insert into %s values (%ld, %d)", winfo->tbl_name, (begin + index) * 1000, index);
if (taos_query(taos, command)) {
printf("failed to insert row [%s], reason:%s\n", command, taos_errstr(taos));
}
sleep(1);
- }
+ }
taos_close(taos);
return 0;
}
-
diff --git a/tests/examples/c/subscribe.c b/tests/examples/c/subscribe.c
index ad12f0e7a55b0f471f249f92f30cf659c94586a5..d8b76c008f24a4ff1e7827e5b1cb167f013c81c5 100644
--- a/tests/examples/c/subscribe.c
+++ b/tests/examples/c/subscribe.c
@@ -14,10 +14,10 @@ void print_result(TAOS_RES* res, int blockFetch) {
int num_fields = taos_num_fields(res);
TAOS_FIELD* fields = taos_fetch_fields(res);
int nRows = 0;
-
+
if (blockFetch) {
nRows = taos_fetch_block(res, &row);
- //for (int i = 0; i < nRows; i++) {
+ // for (int i = 0; i < nRows; i++) {
// taos_print_row(buf, row + i, fields, num_fields);
// puts(buf);
//}
@@ -34,15 +34,11 @@ void print_result(TAOS_RES* res, int blockFetch) {
printf("%d rows consumed.\n", nRows);
}
-
-void subscribe_callback(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
- print_result(res, *(int*)param);
-}
-
+void subscribe_callback(TAOS_SUB* tsub, TAOS_RES* res, void* param, int code) { print_result(res, *(int*)param); }
void check_row_count(int line, TAOS_RES* res, int expected) {
- int actual = 0;
- TAOS_ROW row;
+ int actual = 0;
+ TAOS_ROW row;
while ((row = taos_fetch_row(res))) {
actual++;
}
@@ -53,16 +49,14 @@ void check_row_count(int line, TAOS_RES* res, int expected) {
}
}
-
void do_query(TAOS* taos, const char* sql) {
TAOS_RES* res = taos_query(taos, sql);
taos_free_result(res);
}
-
void run_test(TAOS* taos) {
do_query(taos, "drop database if exists test;");
-
+
usleep(100000);
do_query(taos, "create database test;");
usleep(100000);
@@ -161,14 +155,13 @@ void run_test(TAOS* taos) {
taos_unsubscribe(tsub, 0);
}
-
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
const char* host = "127.0.0.1";
const char* user = "root";
const char* passwd = "taosdata";
const char* sql = "select * from meters;";
const char* topic = "test-multiple";
- int async = 1, restart = 0, keep = 1, test = 0, blockFetch = 0;
+ int async = 1, restart = 0, keep = 1, test = 0, blockFetch = 0;
for (int i = 1; i < argc; i++) {
if (strncmp(argv[i], "-h=", 3) == 0) {
@@ -240,20 +233,21 @@ int main(int argc, char *argv[]) {
if (tsub == NULL) {
printf("failed to create subscription.\n");
exit(0);
- }
+ }
if (async) {
getchar();
- } else while(1) {
- TAOS_RES* res = taos_consume(tsub);
- if (res == NULL) {
- printf("failed to consume data.");
- break;
- } else {
- print_result(res, blockFetch);
- getchar();
+ } else
+ while (1) {
+ TAOS_RES* res = taos_consume(tsub);
+ if (res == NULL) {
+ printf("failed to consume data.");
+ break;
+ } else {
+ print_result(res, blockFetch);
+ getchar();
+ }
}
- }
printf("total rows consumed: %d\n", nTotalRows);
taos_unsubscribe(tsub, keep);
diff --git a/tests/gotest/case001/case001.sh b/tests/gotest/case001/case001.sh
index 831e9f83ac482c0a2c668e2ad0d16c4bf59f19aa..94e5bb44e03a1f7d2704752fcf9c080abcb4f23f 100644
--- a/tests/gotest/case001/case001.sh
+++ b/tests/gotest/case001/case001.sh
@@ -15,7 +15,8 @@ script_dir="$(dirname $(readlink -f $0))"
###### step 3: start build
cd $script_dir
rm -f go.*
-go mod init demotest
-go build
+go mod init demotest > /dev/null 2>&1
+go mod tidy > /dev/null 2>&1
+go build > /dev/null 2>&1
sleep 1s
./demotest -h $1 -p $2
diff --git a/tests/nettest/FQDNnettest.sh b/tests/nettest/FQDNnettest.sh
new file mode 100755
index 0000000000000000000000000000000000000000..f4ee5d56bce9842537ea9cea224c22dee28e2a7e
--- /dev/null
+++ b/tests/nettest/FQDNnettest.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+taos -n fqdn
diff --git a/tests/nettest/TCPUDP.sh b/tests/nettest/TCPUDP.sh
new file mode 100755
index 0000000000000000000000000000000000000000..3a4b5d77a4f26862b03194488380c8dad172bb42
--- /dev/null
+++ b/tests/nettest/TCPUDP.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+for N in -1 0 1 10000 10001
+do
+ for l in 1023 1024 1073741824 1073741825
+ do
+ for S in udp tcp
+ do
+ taos -n speed -h BCC-2 -P 6030 -N $N -l $l -S $S 2>&1 | tee -a result.txt
+ done
+ done
+done
diff --git a/tests/perftest-scripts/perftest-query.sh b/tests/perftest-scripts/perftest-query.sh
index d4853c082599151ed5764674d9be5965f7e6a0f4..68b64fd4e0c4f09ff0b8e96d7802b954b774fbc5 100755
--- a/tests/perftest-scripts/perftest-query.sh
+++ b/tests/perftest-scripts/perftest-query.sh
@@ -105,10 +105,10 @@ function runQueryPerfTest {
python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type | tee -a $PERFORMANCE_TEST_REPORT
echo "=========== taosdemo performance: 400 int columns, 400 double columns, 200 binary(128) columns, 10000 tables, 1000 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
- python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 400 -D 400 -B 200 -t 10000 -r 1000 | tee -a $PERFORMANCE_TEST_REPORT
+ python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 400 -D 400 -B 200 -t 10000 -r 100 | tee -a $PERFORMANCE_TEST_REPORT
echo "=========== taosdemo performance: 1900 int columns, 1900 double columns, 200 binary(128) columns, 10000 tables, 1000 recoreds per table ===========" | tee -a $PERFORMANCE_TEST_REPORT
- python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 1900 -D 1900 -B 200 -t 10000 -r 1000 | tee -a $PERFORMANCE_TEST_REPORT
+ python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT -b $branch -T $type -i 1900 -D 1900 -B 200 -t 10000 -r 100 | tee -a $PERFORMANCE_TEST_REPORT
}
diff --git a/tests/pytest/alter/alter_table.py b/tests/pytest/alter/alter_table.py
index a5acb7a73e0844ac2235590cbc8b7793ef40746c..33e0aec72756418fca41ef72d48e442da5aa135d 100644
--- a/tests/pytest/alter/alter_table.py
+++ b/tests/pytest/alter/alter_table.py
@@ -102,6 +102,20 @@ class TDTestCase:
print("check2: i=%d colIdx=%d" % (i, colIdx))
tdSql.checkData(0, i, self.rowNum * (colIdx - i + 3))
+ def alter_table_255_times(self): # add case for TD-6207
+ for i in range(255):
+ tdLog.info("alter table st add column cb%d int"%i)
+ tdSql.execute("alter table st add column cb%d int"%i)
+ tdSql.execute("insert into t0 (ts,c1) values(now,1)")
+ tdSql.execute("reset query cache")
+ tdSql.query("select * from st")
+ tdSql.execute("create table mt(ts timestamp, i int)")
+ tdSql.execute("insert into mt values(now,11)")
+ tdSql.query("select * from mt")
+ tdDnodes.stop(1)
+ tdDnodes.start(1)
+ tdSql.query("describe db.st")
+
def run(self):
# Setup params
db = "db"
@@ -131,12 +145,14 @@ class TDTestCase:
tdSql.checkData(0, i, self.rowNum * (size - i))
- tdSql.execute("create table st(ts timestamp, c1 int) tags(t1 float)")
- tdSql.execute("create table t0 using st tags(null)")
+ tdSql.execute("create table st(ts timestamp, c1 int) tags(t1 float,t2 int,t3 double)")
+ tdSql.execute("create table t0 using st tags(null,1,2.3)")
tdSql.execute("alter table t0 set tag t1=2.1")
tdSql.query("show tables")
tdSql.checkRows(2)
+ self.alter_table_255_times()
+
def stop(self):
tdSql.close()
diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index 9ebfe92e40b31413b7a4457732eb49752d61fd83..61e82789ea665a9880f45566253e3916bd40163a 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -28,6 +28,7 @@ python3 ./test.py -f insert/insertDynamicColBeforeVal.py
python3 ./test.py -f insert/in_function.py
python3 ./test.py -f insert/modify_column.py
python3 ./test.py -f insert/line_insert.py
+python3 ./test.py -f insert/specialSql.py
#table
python3 ./test.py -f table/alter_wal0.py
@@ -76,6 +77,7 @@ python3 ./test.py -f tag_lite/set.py
python3 ./test.py -f tag_lite/smallint.py
python3 ./test.py -f tag_lite/tinyint.py
python3 ./test.py -f tag_lite/timestamp.py
+python3 ./test.py -f tag_lite/TestModifyTag.py
#python3 ./test.py -f dbmgmt/database-name-boundary.py
python3 test.py -f dbmgmt/nanoSecondCheck.py
@@ -151,6 +153,7 @@ python3 ./test.py -f import_merge/importCSV.py
python3 ./test.py -f import_merge/import_update_0.py
python3 ./test.py -f import_merge/import_update_1.py
python3 ./test.py -f import_merge/import_update_2.py
+python3 ./test.py -f update/merge_commit_data.py
#======================p1-end===============
#======================p2-start===============
# tools
@@ -166,6 +169,10 @@ python3 test.py -f tools/taosdemoTestSampleData.py
python3 test.py -f tools/taosdemoTestInterlace.py
python3 test.py -f tools/taosdemoTestQuery.py
+# restful test for python
+python3 test.py -f restful/restful_bind_db1.py
+python3 test.py -f restful/restful_bind_db2.py
+
# nano support
python3 test.py -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoInsert.py
python3 test.py -f tools/taosdemoAllTest/NanoTestCase/taosdemoTestSupportNanoQuery.py
@@ -179,7 +186,7 @@ python3 ./test.py -f update/allow_update-0.py
python3 ./test.py -f update/append_commit_data.py
python3 ./test.py -f update/append_commit_last-0.py
python3 ./test.py -f update/append_commit_last.py
-python3 ./test.py -f update/merge_commit_data.py
+
python3 ./test.py -f update/merge_commit_data2.py
python3 ./test.py -f update/merge_commit_data2_update0.py
@@ -253,7 +260,7 @@ python3 ./test.py -f query/queryTsisNull.py
python3 ./test.py -f query/subqueryFilter.py
python3 ./test.py -f query/nestedQuery/queryInterval.py
python3 ./test.py -f query/queryStateWindow.py
-python3 ./test.py -f query/nestedQuery/queryWithOrderLimit.py
+# python3 ./test.py -f query/nestedQuery/queryWithOrderLimit.py
python3 ./test.py -f query/nestquery_last_row.py
python3 ./test.py -f query/queryCnameDisplay.py
python3 ./test.py -f query/operator_cost.py
@@ -381,8 +388,10 @@ python3 ./test.py -f query/querySession.py
python3 test.py -f alter/alter_create_exception.py
python3 ./test.py -f insert/flushwhiledrop.py
python3 ./test.py -f insert/schemalessInsert.py
-python3 ./test.py -f alter/alterColMultiTimes.py
-python3 ./test.py -f query/queryTbnameUpperLower.py
+python3 ./test.py -f alter/alterColMultiTimes.py
+python3 ./test.py -f query/queryWildcardLength.py
+python3 ./test.py -f query/queryTbnameUpperLower.py
+python3 ./test.py -f query/queryGroupTbname.py
#======================p4-end===============
diff --git a/tests/pytest/functions/function_bottom.py b/tests/pytest/functions/function_bottom.py
index abb9ac48e70ac876741c3da2a9f223d537c8644b..e9e5003f6f96a9d04bb70b3a867c3cba239d8bff 100644
--- a/tests/pytest/functions/function_bottom.py
+++ b/tests/pytest/functions/function_bottom.py
@@ -104,6 +104,21 @@ class TDTestCase:
tdSql.checkRows(2)
tdSql.checkData(0, 1, 1)
tdSql.checkData(1, 1, 2)
+
+ tdSql.query("select ts,bottom(col1, 2),ts from test1")
+ tdSql.checkRows(2)
+ tdSql.checkData(0, 0, "2018-09-17 09:00:00.000")
+ tdSql.checkData(0, 1, "2018-09-17 09:00:00.000")
+ tdSql.checkData(1, 0, "2018-09-17 09:00:00.001")
+ tdSql.checkData(1, 3, "2018-09-17 09:00:00.001")
+
+
+ tdSql.query("select ts,bottom(col1, 2),ts from test group by tbname")
+ tdSql.checkRows(2)
+ tdSql.checkData(0, 0, "2018-09-17 09:00:00.000")
+ tdSql.checkData(0, 1, "2018-09-17 09:00:00.000")
+ tdSql.checkData(1, 0, "2018-09-17 09:00:00.001")
+ tdSql.checkData(1, 3, "2018-09-17 09:00:00.001")
#TD-2457 bottom + interval + order by
tdSql.error('select top(col2,1) from test interval(1y) order by col2;')
diff --git a/tests/pytest/functions/function_derivative.py b/tests/pytest/functions/function_derivative.py
index 9d60129672b5516d83e696f67b5c8d5a17630afd..d4d8ab80a6b9587df900890ef18b8c4b1e3906bd 100644
--- a/tests/pytest/functions/function_derivative.py
+++ b/tests/pytest/functions/function_derivative.py
@@ -54,6 +54,28 @@ class TDTestCase:
tdSql.query("select derivative(col, 10s, 0) from stb group by tbname")
tdSql.checkRows(10)
+ tdSql.query("select ts,derivative(col, 10s, 1),ts from stb group by tbname")
+ tdSql.checkRows(4)
+ tdSql.checkData(0, 0, "2018-09-17 09:00:10.000")
+ tdSql.checkData(0, 1, "2018-09-17 09:00:10.000")
+ tdSql.checkData(0, 3, "2018-09-17 09:00:10.000")
+ tdSql.checkData(3, 0, "2018-09-17 09:01:20.000")
+ tdSql.checkData(3, 1, "2018-09-17 09:01:20.000")
+ tdSql.checkData(3, 3, "2018-09-17 09:01:20.000")
+
+ tdSql.query("select ts,derivative(col, 10s, 1),ts from tb1")
+ tdSql.checkRows(2)
+ tdSql.checkData(0, 0, "2018-09-17 09:00:10.000")
+ tdSql.checkData(0, 1, "2018-09-17 09:00:10.000")
+ tdSql.checkData(0, 3, "2018-09-17 09:00:10.000")
+ tdSql.checkData(1, 0, "2018-09-17 09:00:20.009")
+ tdSql.checkData(1, 1, "2018-09-17 09:00:20.009")
+ tdSql.checkData(1, 3, "2018-09-17 09:00:20.009")
+
+ tdSql.query("select ts from(select ts,derivative(col, 10s, 0) from stb group by tbname)")
+
+ tdSql.checkData(0, 0, "2018-09-17 09:00:10.000")
+
tdSql.error("select derivative(col, 10s, 0) from tb1 group by tbname")
tdSql.query("select derivative(col, 10s, 1) from tb1")
diff --git a/tests/pytest/functions/function_diff.py b/tests/pytest/functions/function_diff.py
index fba3b4c0d4bd16533ab9f67b42b3643449288cac..cd5894c165c9676ae67fdd315d467c2168f84a90 100644
--- a/tests/pytest/functions/function_diff.py
+++ b/tests/pytest/functions/function_diff.py
@@ -94,6 +94,23 @@ class TDTestCase:
tdSql.error("select diff(col13) from test")
tdSql.error("select diff(col14) from test")
+ tdSql.query("select ts,diff(col1),ts from test1")
+ tdSql.checkRows(10)
+ tdSql.checkData(0, 0, "2018-09-17 09:00:00.000")
+ tdSql.checkData(0, 1, "2018-09-17 09:00:00.000")
+ tdSql.checkData(0, 3, "2018-09-17 09:00:00.000")
+ tdSql.checkData(9, 0, "2018-09-17 09:00:00.009")
+ tdSql.checkData(9, 1, "2018-09-17 09:00:00.009")
+ tdSql.checkData(9, 3, "2018-09-17 09:00:00.009")
+
+ tdSql.query("select ts,diff(col1),ts from test group by tbname")
+ tdSql.checkRows(10)
+ tdSql.checkData(0, 0, "2018-09-17 09:00:00.000")
+ tdSql.checkData(0, 1, "2018-09-17 09:00:00.000")
+ tdSql.checkData(0, 3, "2018-09-17 09:00:00.000")
+ tdSql.checkData(9, 0, "2018-09-17 09:00:00.009")
+ tdSql.checkData(9, 1, "2018-09-17 09:00:00.009")
+ tdSql.checkData(9, 3, "2018-09-17 09:00:00.009")
tdSql.query("select diff(col1) from test1")
tdSql.checkRows(10)
diff --git a/tests/pytest/functions/function_interp.py b/tests/pytest/functions/function_interp.py
index 810c90279cd2b7410f97e5eff51be4e9865b6555..87d001d9e586fdfccb28e6fe9c8a04510d6f3fb1 100644
--- a/tests/pytest/functions/function_interp.py
+++ b/tests/pytest/functions/function_interp.py
@@ -26,18 +26,70 @@ class TDTestCase:
self.rowNum = 10
self.ts = 1537146000000
-
+
def run(self):
tdSql.prepare()
- tdSql.execute("create table t(ts timestamp, k int)")
- tdSql.execute("insert into t values('2021-1-1 1:1:1', 12);")
-
- tdSql.query("select interp(*) from t where ts='2021-1-1 1:1:1'")
- tdSql.checkRows(1)
- tdSql.checkData(0, 1, 12)
-
- tdSql.error("select interp(*) from t where ts >'2021-1-1 1:1:1' and ts < now interval(1s) fill(next)")
-
+ tdSql.execute("create table ap1 (ts timestamp, pav float)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.119', 2.90799)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.317', 3.07399)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.517', 0.58117)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.717', 0.16150)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:54.918', 1.47885)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:56.569', 1.76472)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:57.381', 2.13722)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:57.574', 4.10256)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:57.776', 3.55345)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:57.976', 1.46624)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.187', 0.17943)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.372', 2.04101)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.573', 3.20924)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.768', 1.71807)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:58.964', 4.60900)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.155', 4.33907)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.359', 0.76940)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.553', 0.06458)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.742', 4.59857)")
+ tdSql.execute("insert into ap1 values ('2021-07-25 02:19:59.938', 1.55081)")
+
+ tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (PREV)")
+ tdSql.checkRows(0)
+ tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (NEXT)")
+ tdSql.checkRows(0)
+ tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (LINEAR)")
+ tdSql.checkRows(0)
+ tdSql.query("select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' every(1000a) FILL (LINEAR)")
+ tdSql.checkRows(6)
+ tdSql.query("select interp(pav) from ap1 where ts>= '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' every(1000a) FILL (NEXT)")
+ tdSql.checkRows(6)
+ tdSql.checkData(0,1,2.90799)
+ tdSql.query("select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts <= '2021-07-25 02:20:00' every(1000a) FILL (PREV)")
+ tdSql.checkRows(7)
+ tdSql.checkData(1,1,1.47885)
+ tdSql.query("select interp(pav) from ap1 where ts>= '2021-07-25 02:19:54' and ts <= '2021-07-25 02:20:00' every(1000a) FILL (LINEAR)")
+ tdSql.checkRows(7)
+
+ # check desc order
+ tdSql.error("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (PREV) order by ts desc")
+ tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (NEXT) order by ts desc")
+ tdSql.checkRows(0)
+ tdSql.query("select interp(pav) from ap1 where ts = '2021-07-25 02:19:54' FILL (LINEAR) order by ts desc")
+ tdSql.checkRows(0)
+ tdSql.query("select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' every(1000a) FILL (LINEAR) order by ts desc")
+ tdSql.checkRows(6)
+ tdSql.query("select interp(pav) from ap1 where ts>= '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' every(1000a) FILL (NEXT) order by ts desc")
+ tdSql.checkRows(6)
+ tdSql.checkData(0,1,4.60900)
+ tdSql.error("select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts <= '2021-07-25 02:20:00' every(1000a) FILL (PREV) order by ts desc")
+ tdSql.query("select interp(pav) from ap1 where ts>= '2021-07-25 02:19:54' and ts <= '2021-07-25 02:20:00' every(1000a) FILL (LINEAR) order by ts desc")
+ tdSql.checkRows(7)
+
+ # check exception
+ tdSql.error("select interp(*) from ap1")
+ tdSql.error("select interp(*) from ap1 FILL(NEXT)")
+ tdSql.error("select interp(*) from ap1 ts >= '2021-07-25 02:19:54' FILL(NEXT)")
+ tdSql.error("select interp(*) from ap1 ts <= '2021-07-25 02:19:54' FILL(NEXT)")
+ tdSql.error("select interp(*) from ap1 where ts >'2021-07-25 02:19:59.938' and ts < now every(1s) fill(next)")
+
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/pytest/functions/function_top.py b/tests/pytest/functions/function_top.py
index f8318402b57ab4f362bd4fab8de3c04bbdcf3a5d..9824afc19fb996c18d12690a001cd030b0cc69c7 100644
--- a/tests/pytest/functions/function_top.py
+++ b/tests/pytest/functions/function_top.py
@@ -117,6 +117,21 @@ class TDTestCase:
tdSql.checkRows(2)
tdSql.checkData(0, 1, 8.1)
tdSql.checkData(1, 1, 9.1)
+
+ tdSql.query("select ts,top(col1, 2),ts from test1")
+ tdSql.checkRows(2)
+ tdSql.checkData(0, 0, "2018-09-17 09:00:00.008")
+ tdSql.checkData(0, 1, "2018-09-17 09:00:00.008")
+ tdSql.checkData(1, 0, "2018-09-17 09:00:00.009")
+ tdSql.checkData(1, 3, "2018-09-17 09:00:00.009")
+
+
+ tdSql.query("select ts,top(col1, 2),ts from test group by tbname")
+ tdSql.checkRows(2)
+ tdSql.checkData(0, 0, "2018-09-17 09:00:00.008")
+ tdSql.checkData(0, 1, "2018-09-17 09:00:00.008")
+ tdSql.checkData(1, 0, "2018-09-17 09:00:00.009")
+ tdSql.checkData(1, 3, "2018-09-17 09:00:00.009")
#TD-2563 top + super_table + interval
tdSql.execute("create table meters(ts timestamp, c int) tags (d int)")
diff --git a/tests/pytest/functions/queryTestCases.py b/tests/pytest/functions/queryTestCases.py
index b7480fdbd555f97f17d71b5583296d49ffcd4061..e69cb8f4682b130d6c2182b005544afaf41c16c5 100644
--- a/tests/pytest/functions/queryTestCases.py
+++ b/tests/pytest/functions/queryTestCases.py
@@ -13,6 +13,9 @@
import sys
import subprocess
+import random
+import math
+import numpy as np
from util.log import *
from util.cases import *
@@ -55,16 +58,33 @@ class TDTestCase:
def td3690(self):
tdLog.printNoPrefix("==========TD-3690==========")
+
+ tdSql.prepare()
+
+ tdSql.execute("show variables")
+ res_off = tdSql.cursor.fetchall()
+ resList = np.array(res_off)
+ index = np.where(resList == "offlineThreshold")
+ index_value = np.dstack((index[0])).squeeze()
tdSql.query("show variables")
- tdSql.checkData(51, 1, 864000)
+ tdSql.checkData(index_value, 1, 864000)
def td4082(self):
tdLog.printNoPrefix("==========TD-4082==========")
+
+ tdSql.prepare()
+
cfgfile = self.getCfgFile()
max_compressMsgSize = 100000000
+ tdSql.execute("show variables")
+ res_com = tdSql.cursor.fetchall()
+ rescomlist = np.array(res_com)
+ cpms_index = np.where(rescomlist == "compressMsgSize")
+ index_value = np.dstack((cpms_index[0])).squeeze()
+
tdSql.query("show variables")
- tdSql.checkData(26, 1, -1)
+ tdSql.checkData(index_value, 1, -1)
tdSql.query("show dnodes")
index = tdSql.getData(0, 0)
@@ -78,7 +98,7 @@ class TDTestCase:
tdDnodes.start(index)
tdSql.query("show variables")
- tdSql.checkData(26, 1, 100000000)
+ tdSql.checkData(index_value, 1, 100000000)
tdDnodes.stop(index)
cmd = f"sed -i '$s/{max_compressMsgSize}/{max_compressMsgSize+10}/g' {cfgfile} "
@@ -89,7 +109,7 @@ class TDTestCase:
tdDnodes.start(index)
tdSql.query("show variables")
- tdSql.checkData(26, 1, -1)
+ tdSql.checkData(index_value, 1, -1)
tdDnodes.stop(index)
cmd = f"sed -i '$d' {cfgfile}"
@@ -102,10 +122,17 @@ class TDTestCase:
def td4097(self):
tdLog.printNoPrefix("==========TD-4097==========")
+
tdSql.execute("drop database if exists db")
tdSql.execute("drop database if exists db1")
+ tdDnodes.stop(1)
+ tdDnodes.start(1)
+
tdSql.execute("create database if not exists db keep 3650")
tdSql.execute("create database if not exists db1 keep 3650")
+ tdSql.execute("create database if not exists new keep 3650")
+ tdSql.execute("create database if not exists private keep 3650")
+ tdSql.execute("create database if not exists db2 keep 3650")
tdSql.execute("create stable db.stb1 (ts timestamp, c1 int) tags(t1 int)")
tdSql.execute("create stable db.stb2 (ts timestamp, c1 int) tags(t1 int)")
@@ -122,6 +149,14 @@ class TDTestCase:
# p1 不进入指定数据库
tdSql.query("show create database db")
tdSql.checkRows(1)
+ tdSql.query("show create database db1")
+ tdSql.checkRows(1)
+ tdSql.query("show create database db2")
+ tdSql.checkRows(1)
+ tdSql.query("show create database new")
+ tdSql.checkRows(1)
+ tdSql.query("show create database private")
+ tdSql.checkRows(1)
tdSql.error("show create database ")
tdSql.error("show create databases db ")
tdSql.error("show create database db.stb1")
@@ -254,10 +289,22 @@ class TDTestCase:
# keep ~ [days,365000]
tdSql.execute("drop database if exists db")
tdSql.execute("create database if not exists db")
+
+ tdSql.execute("show variables")
+ res_kp = tdSql.cursor.fetchall()
+ resList = np.array(res_kp)
+ keep_index = np.where(resList == "keep")
+ index_value = np.dstack((keep_index[0])).squeeze()
+
tdSql.query("show variables")
- tdSql.checkData(36, 1, 3650)
+ tdSql.checkData(index_value, 1, 3650)
+
tdSql.query("show databases")
- tdSql.checkData(0,7,"3650,3650,3650")
+ selfPath = os.path.dirname(os.path.realpath(__file__))
+ if ("community" in selfPath):
+ tdSql.checkData(0, 7, "3650,3650,3650")
+ else:
+ tdSql.checkData(0, 7, 3650)
days = tdSql.getData(0, 6)
tdSql.error("alter database db keep 3650001")
@@ -276,14 +323,22 @@ class TDTestCase:
tdSql.execute("alter database db keep 36500")
tdSql.query("show databases")
- tdSql.checkData(0, 7, "3650,3650,36500")
+ if ("community" in selfPath):
+ tdSql.checkData(0, 7, "36500,36500,36500")
+ else:
+ tdSql.checkData(0, 7, 36500)
+
tdSql.execute("drop database if exists db")
tdSql.execute("create database if not exists db1")
tdSql.query("show databases")
- tdSql.checkData(0, 7, "3650,3650,3650")
+ if ("community" in selfPath):
+ tdSql.checkData(0, 7, "3650,3650,3650")
+ else:
+ tdSql.checkData(0, 7, 3650)
+
tdSql.query("show variables")
- tdSql.checkData(36, 1, 3650)
+ tdSql.checkData(index_value, 1, 3650)
tdSql.execute("alter database db1 keep 365")
tdSql.execute("drop database if exists db1")
@@ -340,17 +395,749 @@ class TDTestCase:
pass
+ def td4889(self):
+ tdLog.printNoPrefix("==========TD-4889==========")
+ tdSql.execute("drop database if exists db")
+ tdSql.execute("create database if not exists db keep 3650")
+
+ tdSql.execute("use db")
+ tdSql.execute("create stable db.stb1 (ts timestamp, c1 int) tags(t1 int)")
+
+ for i in range(1000):
+ tdSql.execute(f"create table db.t1{i} using db.stb1 tags({i})")
+ for j in range(100):
+ tdSql.execute(f"insert into db.t1{i} values (now-100d, {i+j})")
+
+ tdSql.query("show vgroups")
+ index = tdSql.getData(0,0)
+ tdSql.checkData(0, 6, 0)
+ tdSql.execute(f"compact vnodes in({index})")
+ for i in range(3):
+ tdSql.query("show vgroups")
+ if tdSql.getData(0, 6) == 1:
+ tdLog.printNoPrefix("show vgroups row:0 col:6 data:1 == expect:1")
+ break
+ if i == 3:
+ tdLog.exit("compacting not occured")
+ time.sleep(0.5)
+
+ pass
+
+ def td5168insert(self):
+ tdSql.execute("drop database if exists db")
+ tdSql.execute("create database if not exists db keep 3650")
+
+ tdSql.execute("use db")
+ tdSql.execute("create stable db.stb1 (ts timestamp, c1 float, c2 float, c3 double, c4 double) tags(t1 int)")
+ tdSql.execute("create table db.t1 using db.stb1 tags(1)")
+
+ for i in range(5):
+ c1 = 1001.11 + i*0.1
+ c2 = 1001.11 + i*0.1 + 1*0.01
+ c3 = 1001.11 + i*0.1 + 2*0.01
+ c4 = 1001.11 + i*0.1 + 3*0.01
+ tdSql.execute(f"insert into db.t1 values ('2021-07-01 08:00:0{i}.000', {c1}, {c2}, {c3}, {c4})")
+
+ # tdSql.execute("insert into db.t1 values ('2021-07-01 08:00:00.000', 1001.11, 1001.12, 1001.13, 1001.14)")
+ # tdSql.execute("insert into db.t1 values ('2021-07-01 08:00:01.000', 1001.21, 1001.22, 1001.23, 1001.24)")
+ # tdSql.execute("insert into db.t1 values ('2021-07-01 08:00:02.000', 1001.31, 1001.32, 1001.33, 1001.34)")
+ # tdSql.execute("insert into db.t1 values ('2021-07-01 08:00:03.000', 1001.41, 1001.42, 1001.43, 1001.44)")
+ # tdSql.execute("insert into db.t1 values ('2021-07-01 08:00:04.000', 1001.51, 1001.52, 1001.53, 1001.54)")
+
+ # for i in range(1000000):
+ for i in range(1000000):
+ random1 = random.uniform(1000,1001)
+ random2 = random.uniform(1000,1001)
+ random3 = random.uniform(1000,1001)
+ random4 = random.uniform(1000,1001)
+ tdSql.execute(f"insert into db.t1 values (now+{i}a, {random1}, {random2},{random3}, {random4})")
+
+ pass
+
+ def td5168(self):
+ tdLog.printNoPrefix("==========TD-5168==========")
+ # 插入小范围内的随机数
+ tdLog.printNoPrefix("=====step0: 默认情况下插入数据========")
+ self.td5168insert()
+
+ # 获取五个时间点的数据作为基准数值,未压缩情况下精准匹配
+ for i in range(5):
+ tdSql.query(f"select * from db.t1 where ts='2021-07-01 08:00:0{i}.000' ")
+ # c1, c2, c3, c4 = tdSql.getData(0, 1), tdSql.getData(0, 2), tdSql.getData(0, 3), tdSql.getData(0, 4)
+ for j in range(4):
+ locals()["f" + str(j) + str(i)] = tdSql.getData(0, j+1)
+ print(f"f{j}{i}:", locals()["f" + str(j) + str(i)])
+ tdSql.checkData(0, j+1, locals()["f" + str(j) + str(i)])
+
+ # tdSql.query("select * from db.t1 limit 100,1")
+ # f10, f11, f12, f13 = tdSql.getData(0,1), tdSql.getData(0,2), tdSql.getData(0,3), tdSql.getData(0,4)
+ #
+ # tdSql.query("select * from db.t1 limit 1000,1")
+ # f20, f21, f22, f23 = tdSql.getData(0,1), tdSql.getData(0,2), tdSql.getData(0,3), tdSql.getData(0,4)
+ #
+ # tdSql.query("select * from db.t1 limit 10000,1")
+ # f30, f31, f32, f33 = tdSql.getData(0,1), tdSql.getData(0,2), tdSql.getData(0,3), tdSql.getData(0,4)
+ #
+ # tdSql.query("select * from db.t1 limit 100000,1")
+ # f40, f41, f42, f43 = tdSql.getData(0,1), tdSql.getData(0,2), tdSql.getData(0,3), tdSql.getData(0,4)
+ #
+ # tdSql.query("select * from db.t1 limit 1000000,1")
+ # f50, f51, f52, f53 = tdSql.getData(0,1), tdSql.getData(0,2), tdSql.getData(0,3), tdSql.getData(0,4)
+
+ # 关闭服务并获取未开启压缩情况下的数据容量
+ tdSql.query("show dnodes")
+ index = tdSql.getData(0, 0)
+ tdDnodes.stop(index)
+
+ cfgdir = self.getCfgDir()
+ cfgfile = self.getCfgFile()
+
+ lossy_cfg_cmd=f"grep lossyColumns {cfgfile}|awk '{{print $2}}'"
+ data_size_cmd = f"du -s {cfgdir}/../data/vnode/ | awk '{{print $1}}'"
+ dsize_init = int(subprocess.check_output(data_size_cmd,shell=True).decode("utf-8"))
+ lossy_args = subprocess.check_output(lossy_cfg_cmd, shell=True).decode("utf-8")
+ tdLog.printNoPrefix(f"close the lossyColumns，data size is: {dsize_init};the lossyColumns line is: {lossy_args}")
+
+ ###################################################
+ float_lossy = "float"
+ double_lossy = "double"
+ float_double_lossy = "float|double"
+ no_loosy = ""
+
+ double_precision_cmd = f"sed -i '$a dPrecision 0.000001' {cfgfile}"
+ _ = subprocess.check_output(double_precision_cmd, shell=True).decode("utf-8")
+
+ lossy_float_cmd = f"sed -i '$a lossyColumns {float_lossy}' {cfgfile} "
+ lossy_double_cmd = f"sed -i '$d' {cfgfile} && sed -i '$a lossyColumns {double_lossy}' {cfgfile} "
+ lossy_float_double_cmd = f"sed -i '$d' {cfgfile} && sed -i '$a lossyColumns {float_double_lossy}' {cfgfile} "
+ lossy_no_cmd = f"sed -i '$a lossyColumns {no_loosy}' {cfgfile} "
+
+ ###################################################
+
+ # 开启有损压缩，参数float，并启动服务插入数据
+ tdLog.printNoPrefix("=====step1: lossyColumns设置为float========")
+ lossy_float = subprocess.check_output(lossy_float_cmd, shell=True).decode("utf-8")
+ tdDnodes.start(index)
+ self.td5168insert()
+
+ # 查询前面所述5个时间数据并与基准数值进行比较
+ for i in range(5):
+ tdSql.query(f"select * from db.t1 where ts='2021-07-01 08:00:0{i}.000' ")
+ # c1, c2, c3, c4 = tdSql.getData(0, 1), tdSql.getData(0, 2), tdSql.getData(0, 3), tdSql.getData(0, 4)
+ for j in range(4):
+ # locals()["f" + str(j) + str(i)] = tdSql.getData(0, j+1)
+ # print(f"f{j}{i}:", locals()["f" + str(j) + str(i)])
+ tdSql.checkData(0, j+1, locals()["f" + str(j) + str(i)])
+
+ # 关闭服务并获取压缩参数为float情况下的数据容量
+ tdDnodes.stop(index)
+ dsize_float = int(subprocess.check_output(data_size_cmd,shell=True).decode("utf-8"))
+ lossy_args = subprocess.check_output(lossy_cfg_cmd, shell=True).decode("utf-8")
+ tdLog.printNoPrefix(f"open the lossyColumns， data size is：{dsize_float};the lossyColumns line is: {lossy_args}")
+
+ # 修改有损压缩，参数double，并启动服务
+ tdLog.printNoPrefix("=====step2: lossyColumns设置为double========")
+ lossy_double = subprocess.check_output(lossy_double_cmd, shell=True).decode("utf-8")
+ tdDnodes.start(index)
+ self.td5168insert()
+
+ # 查询前面所述5个时间数据并与基准数值进行比较
+ for i in range(5):
+ tdSql.query(f"select * from db.t1 where ts='2021-07-01 08:00:0{i}.000' ")
+ for j in range(4):
+ tdSql.checkData(0, j+1, locals()["f" + str(j) + str(i)])
+
+ # 关闭服务并获取压缩参数为double情况下的数据容量
+ tdDnodes.stop(index)
+ dsize_double = int(subprocess.check_output(data_size_cmd, shell=True).decode("utf-8"))
+ lossy_args = subprocess.check_output(lossy_cfg_cmd, shell=True).decode("utf-8")
+ tdLog.printNoPrefix(f"open the lossyColumns, data size is：{dsize_double};the lossyColumns line is: {lossy_args}")
+
+ # 修改有损压缩，参数 float&&double ，并启动服务
+ tdLog.printNoPrefix("=====step3: lossyColumns设置为 float&&double ========")
+ lossy_float_double = subprocess.check_output(lossy_float_double_cmd, shell=True).decode("utf-8")
+ tdDnodes.start(index)
+ self.td5168insert()
+
+ # 查询前面所述5个时间数据并与基准数值进行比较
+ for i in range(5):
+ tdSql.query(f"select * from db.t1 where ts='2021-07-01 08:00:0{i}.000' ")
+ for j in range(4):
+ tdSql.checkData(0, j+1, locals()["f" + str(j) + str(i)])
+
+ # 关闭服务并获取压缩参数为 float&&double 情况下的数据容量
+ tdDnodes.stop(index)
+ dsize_float_double = int(subprocess.check_output(data_size_cmd, shell=True).decode("utf-8"))
+ lossy_args = subprocess.check_output(lossy_cfg_cmd, shell=True).decode("utf-8")
+ tdLog.printNoPrefix(f"open the lossyColumns， data size is：{dsize_float_double};the lossyColumns line is: {lossy_args}")
+
+ if not ((dsize_float_double < dsize_init) and (dsize_double < dsize_init) and (dsize_float < dsize_init)) :
+ tdLog.printNoPrefix(f"When lossyColumns value is float, data size is: {dsize_float}")
+ tdLog.printNoPrefix(f"When lossyColumns value is double, data size is: {dsize_double}")
+ tdLog.printNoPrefix(f"When lossyColumns value is float and double, data size is: {dsize_float_double}")
+ tdLog.printNoPrefix(f"When lossyColumns is closed, data size is: {dsize_init}")
+ tdLog.exit("压缩未生效")
+ else:
+ tdLog.printNoPrefix(f"When lossyColumns value is float, data size is: {dsize_float}")
+ tdLog.printNoPrefix(f"When lossyColumns value is double, data size is: {dsize_double}")
+ tdLog.printNoPrefix(f"When lossyColumns value is float and double, data size is: {dsize_float_double}")
+ tdLog.printNoPrefix(f"When lossyColumns is closed, data size is: {dsize_init}")
+ tdLog.printNoPrefix("压缩生效")
+
+ pass
+
+ def td5433(self):
+ tdLog.printNoPrefix("==========TD-5433==========")
+ tdSql.execute("drop database if exists db")
+ tdSql.execute("create database if not exists db keep 3650")
+
+ tdSql.execute("use db")
+ tdSql.execute("create stable db.stb1 (ts timestamp, c1 int) tags(t0 tinyint, t1 int)")
+ tdSql.execute("create stable db.stb2 (ts timestamp, c1 int) tags(t0 binary(16), t1 binary(16))")
+ numtab=2000000
+ for i in range(numtab):
+ sql = f"create table db.t{i} using db.stb1 tags({i%128}, {100+i})"
+ tdSql.execute(sql)
+ tdSql.execute(f"insert into db.t{i} values (now-10d, {i})")
+ tdSql.execute(f"insert into db.t{i} values (now-9d, {i*2})")
+ tdSql.execute(f"insert into db.t{i} values (now-8d, {i*3})")
+
+ tdSql.execute("create table db.t01 using db.stb2 tags('1', '100')")
+ tdSql.execute("create table db.t02 using db.stb2 tags('2', '200')")
+ tdSql.execute("create table db.t03 using db.stb2 tags('3', '300')")
+ tdSql.execute("create table db.t04 using db.stb2 tags('4', '400')")
+ tdSql.execute("create table db.t05 using db.stb2 tags('5', '500')")
+
+ tdSql.query("select distinct t1 from stb1 where t1 != '150'")
+ tdSql.checkRows(numtab-1)
+ tdSql.query("select distinct t1 from stb1 where t1 != 150")
+ tdSql.checkRows(numtab-1)
+ tdSql.query("select distinct t1 from stb1 where t1 = 150")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t1 from stb1 where t1 = '150'")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t1 from stb1")
+ tdSql.checkRows(numtab)
+
+ tdSql.query("select distinct t0 from stb1 where t0 != '2'")
+ tdSql.checkRows(127)
+ tdSql.query("select distinct t0 from stb1 where t0 != 2")
+ tdSql.checkRows(127)
+ tdSql.query("select distinct t0 from stb1 where t0 = 2")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t0 from stb1 where t0 = '2'")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t0 from stb1")
+ tdSql.checkRows(128)
+
+ tdSql.query("select distinct t1 from stb2 where t1 != '200'")
+ tdSql.checkRows(4)
+ tdSql.query("select distinct t1 from stb2 where t1 != 200")
+ tdSql.checkRows(4)
+ tdSql.query("select distinct t1 from stb2 where t1 = 200")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t1 from stb2 where t1 = '200'")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t1 from stb2")
+ tdSql.checkRows(5)
+
+ tdSql.query("select distinct t0 from stb2 where t0 != '2'")
+ tdSql.checkRows(4)
+ tdSql.query("select distinct t0 from stb2 where t0 != 2")
+ tdSql.checkRows(4)
+ tdSql.query("select distinct t0 from stb2 where t0 = 2")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t0 from stb2 where t0 = '2'")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t0 from stb2")
+ tdSql.checkRows(5)
+
+ pass
+
+ def td5798(self):
+ tdLog.printNoPrefix("==========TD-5798 + TD-5810==========")
+ tdSql.execute("drop database if exists db")
+ tdSql.execute("create database if not exists db keep 3650")
+
+ tdSql.execute("use db")
+ tdSql.execute("create stable db.stb1 (ts timestamp, c1 int, c2 int) tags(t0 tinyint, t1 int, t2 int)")
+ tdSql.execute("create stable db.stb2 (ts timestamp, c2 int, c3 binary(16)) tags(t2 binary(16), t3 binary(16), t4 int)")
+ maxRemainderNum=7
+ tbnum=101
+ for i in range(tbnum-1):
+ sql = f"create table db.t{i} using db.stb1 tags({i%maxRemainderNum}, {(i-1)%maxRemainderNum}, {i%2})"
+ tdSql.execute(sql)
+ tdSql.execute(f"insert into db.t{i} values (now-10d, {i}, {i%3})")
+ tdSql.execute(f"insert into db.t{i} values (now-9d, {i}, {(i-1)%3})")
+ tdSql.execute(f"insert into db.t{i} values (now-8d, {i}, {(i-2)%3})")
+ tdSql.execute(f"insert into db.t{i} (ts )values (now-7d)")
+
+ tdSql.execute(f"create table db.t0{i} using db.stb2 tags('{i%maxRemainderNum}', '{(i-1)%maxRemainderNum}', {i%3})")
+ tdSql.execute(f"insert into db.t0{i} values (now-10d, {i}, '{(i+1)%3}')")
+ tdSql.execute(f"insert into db.t0{i} values (now-9d, {i}, '{(i+2)%3}')")
+ tdSql.execute(f"insert into db.t0{i} values (now-8d, {i}, '{(i)%3}')")
+ tdSql.execute(f"insert into db.t0{i} (ts )values (now-7d)")
+ tdSql.execute("create table db.t100num using db.stb1 tags(null, null, null)")
+ tdSql.execute("create table db.t0100num using db.stb2 tags(null, null, null)")
+ tdSql.execute(f"insert into db.t100num values (now-10d, {tbnum-1}, 1)")
+ tdSql.execute(f"insert into db.t100num values (now-9d, {tbnum-1}, 0)")
+ tdSql.execute(f"insert into db.t100num values (now-8d, {tbnum-1}, 2)")
+ tdSql.execute(f"insert into db.t100num (ts )values (now-7d)")
+ tdSql.execute(f"insert into db.t0100num values (now-10d, {tbnum-1}, 1)")
+ tdSql.execute(f"insert into db.t0100num values (now-9d, {tbnum-1}, 0)")
+ tdSql.execute(f"insert into db.t0100num values (now-8d, {tbnum-1}, 2)")
+ tdSql.execute(f"insert into db.t0100num (ts )values (now-7d)")
+
+ #========== TD-5810 suport distinct multi-data-coloumn ==========
+ tdSql.query(f"select distinct c1 from stb1 where c1 <{tbnum}")
+ tdSql.checkRows(tbnum)
+ tdSql.query(f"select distinct c2 from stb1")
+ tdSql.checkRows(4)
+ tdSql.query(f"select distinct c1,c2 from stb1 where c1 <{tbnum}")
+ tdSql.checkRows(tbnum*3)
+ tdSql.query(f"select distinct c1,c1 from stb1 where c1 <{tbnum}")
+ tdSql.checkRows(tbnum)
+ tdSql.query(f"select distinct c1,c2 from stb1 where c1 <{tbnum} limit 3")
+ tdSql.checkRows(3)
+ tdSql.query(f"select distinct c1,c2 from stb1 where c1 <{tbnum} limit 3 offset {tbnum*3-2}")
+ tdSql.checkRows(2)
+
+ tdSql.query(f"select distinct c1 from t1 where c1 <{tbnum}")
+ tdSql.checkRows(1)
+ tdSql.query(f"select distinct c2 from t1")
+ tdSql.checkRows(4)
+ tdSql.query(f"select distinct c1,c2 from t1 where c1 <{tbnum}")
+ tdSql.checkRows(3)
+ tdSql.query(f"select distinct c1,c1 from t1 ")
+ tdSql.checkRows(2)
+ tdSql.query(f"select distinct c1,c1 from t1 where c1 <{tbnum}")
+ tdSql.checkRows(1)
+ tdSql.query(f"select distinct c1,c2 from t1 where c1 <{tbnum} limit 3")
+ tdSql.checkRows(3)
+ tdSql.query(f"select distinct c1,c2 from t1 where c1 <{tbnum} limit 3 offset 2")
+ tdSql.checkRows(1)
+
+ tdSql.query(f"select distinct c3 from stb2 where c2 <{tbnum} ")
+ tdSql.checkRows(3)
+ tdSql.query(f"select distinct c3, c2 from stb2 where c2 <{tbnum} limit 2")
+ tdSql.checkRows(2)
+
+ tdSql.error("select distinct c5 from stb1")
+ tdSql.error("select distinct c5 from t1")
+ tdSql.error("select distinct c1 from db.*")
+ tdSql.error("select c2, distinct c1 from stb1")
+ tdSql.error("select c2, distinct c1 from t1")
+ tdSql.error("select distinct c2 from ")
+ tdSql.error("distinct c2 from stb1")
+ tdSql.error("distinct c2 from t1")
+ tdSql.error("select distinct c1, c2, c3 from stb1")
+ tdSql.error("select distinct c1, c2, c3 from t1")
+ tdSql.error("select distinct stb1.c1, stb1.c2, stb2.c2, stb2.c3 from stb1")
+ tdSql.error("select distinct stb1.c1, stb1.c2, stb2.c2, stb2.c3 from t1")
+ tdSql.error("select distinct t1.c1, t1.c2, t2.c1, t2.c2 from t1")
+ tdSql.query(f"select distinct c1 c2, c2 c3 from stb1 where c1 <{tbnum}")
+ tdSql.checkRows(tbnum*3)
+ tdSql.query(f"select distinct c1 c2, c2 c3 from t1 where c1 <{tbnum}")
+ tdSql.checkRows(3)
+ tdSql.error("select distinct c1, c2 from stb1 order by ts")
+ tdSql.error("select distinct c1, c2 from t1 order by ts")
+ tdSql.error("select distinct c1, ts from stb1 group by c2")
+ tdSql.error("select distinct c1, ts from t1 group by c2")
+ tdSql.error("select distinct c1, max(c2) from stb1 ")
+ tdSql.error("select distinct c1, max(c2) from t1 ")
+ tdSql.error("select max(c2), distinct c1 from stb1 ")
+ tdSql.error("select max(c2), distinct c1 from t1 ")
+ tdSql.error("select distinct c1, c2 from stb1 where c1 > 3 group by t0")
+ tdSql.error("select distinct c1, c2 from t1 where c1 > 3 group by t0")
+ tdSql.error("select distinct c1, c2 from stb1 where c1 > 3 interval(1d) ")
+ tdSql.error("select distinct c1, c2 from t1 where c1 > 3 interval(1d) ")
+ tdSql.error("select distinct c1, c2 from stb1 where c1 > 3 interval(1d) fill(next)")
+ tdSql.error("select distinct c1, c2 from t1 where c1 > 3 interval(1d) fill(next)")
+ tdSql.error("select distinct c1, c2 from stb1 where ts > now-10d and ts < now interval(1d) fill(next)")
+ tdSql.error("select distinct c1, c2 from t1 where ts > now-10d and ts < now interval(1d) fill(next)")
+ tdSql.error("select distinct c1, c2 from stb1 where c1 > 3 slimit 1")
+ tdSql.error("select distinct c1, c2 from t1 where c1 > 3 slimit 1")
+ tdSql.query(f"select distinct c1, c2 from stb1 where c1 between {tbnum-2} and {tbnum} ")
+ tdSql.checkRows(6)
+ tdSql.query("select distinct c1, c2 from stb1 where c1 in (1,2,3,4,5)")
+ tdSql.checkRows(15)
+ tdSql.query("select distinct c1, c2 from stb1 where c1 in (100,1000,10000)")
+ tdSql.checkRows(3)
+
+ tdSql.query(f"select distinct c1,c2 from (select * from stb1 where c1 > {tbnum-2}) ")
+ tdSql.checkRows(3)
+ tdSql.query(f"select distinct c1,c2 from (select * from t1 where c1 < {tbnum}) ")
+ tdSql.checkRows(3)
+ tdSql.query(f"select distinct c1,c2 from (select * from stb1 where t2 !=0 and t2 != 1) ")
+ tdSql.checkRows(4)
+ tdSql.error("select distinct c1, c2 from (select distinct c1, c2 from stb1 where t0 > 2 and t1 < 3) ")
+ tdSql.error("select c1, c2 from (select distinct c1, c2 from stb1 where t0 > 2 and t1 < 3) ")
+ tdSql.query("select distinct c1, c2 from (select c2, c1 from stb1 where c1 > 2 ) where c1 < 4")
+ tdSql.checkRows(3)
+ tdSql.error("select distinct c1, c2 from (select c1 from stb1 where t0 > 2 ) where t1 < 3")
+ tdSql.error("select distinct c1, c2 from (select c2, c1 from stb1 where c1 > 2 order by ts)")
+ # tdSql.error("select distinct c1, c2 from (select c2, c1 from t1 where c1 > 2 order by ts)")
+ tdSql.error("select distinct c1, c2 from (select c2, c1 from stb1 where c1 > 2 group by c1)")
+ # tdSql.error("select distinct c1, c2 from (select max(c1) c1, max(c2) c2 from stb1 group by c1)")
+ # tdSql.error("select distinct c1, c2 from (select max(c1) c1, max(c2) c2 from t1 group by c1)")
+ tdSql.query("select distinct c1, c2 from (select max(c1) c1, max(c2) c2 from stb1 )")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct c1, c2 from (select max(c1) c1, max(c2) c2 from t1 )")
+ tdSql.checkRows(1)
+ tdSql.error("select distinct stb1.c1, stb1.c2 from stb1 , stb2 where stb1.ts=stb2.ts and stb1.t2=stb2.t4")
+ tdSql.error("select distinct t1.c1, t1.c2 from t1 , t2 where t1.ts=t2.ts ")
+
+ # tdSql.error("select distinct c1, c2 from (select count(c1) c1, count(c2) c2 from stb1 group by ts)")
+ # tdSql.error("select distinct c1, c2 from (select count(c1) c1, count(c2) c2 from t1 group by ts)")
+
+
+
+ #========== TD-5798 suport distinct multi-tags-coloumn ==========
+ tdSql.query("select distinct t1 from stb1")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t0, t1 from stb1")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t1, t0 from stb1")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t1, t2 from stb1")
+ tdSql.checkRows(maxRemainderNum*2+1)
+ tdSql.query("select distinct t0, t1, t2 from stb1")
+ tdSql.checkRows(maxRemainderNum*2+1)
+ tdSql.query("select distinct t0 t1, t1 t2 from stb1")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t0, t0, t0 from stb1")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t0, t1 from t1")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t0, t1 from t100num")
+ tdSql.checkRows(1)
+
+ tdSql.query("select distinct t3 from stb2")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t2, t3 from stb2")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t3, t2 from stb2")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t4, t2 from stb2")
+ tdSql.checkRows(maxRemainderNum*3+1)
+ tdSql.query("select distinct t2, t3, t4 from stb2")
+ tdSql.checkRows(maxRemainderNum*3+1)
+ tdSql.query("select distinct t2 t1, t3 t2 from stb2")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t3, t3, t3 from stb2")
+ tdSql.checkRows(maxRemainderNum+1)
+ tdSql.query("select distinct t2, t3 from t01")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t3, t4 from t0100num")
+ tdSql.checkRows(1)
+
+
+ ########## should be error #########
+ tdSql.error("select distinct from stb1")
+ tdSql.error("select distinct t3 from stb1")
+ tdSql.error("select distinct t1 from db.*")
+ tdSql.error("select distinct t2 from ")
+ tdSql.error("distinct t2 from stb1")
+ tdSql.error("select distinct stb1")
+ tdSql.error("select distinct t0, t1, t2, t3 from stb1")
+ tdSql.error("select distinct stb1.t0, stb1.t1, stb2.t2, stb2.t3 from stb1")
+
+ tdSql.error("select dist t0 from stb1")
+ tdSql.error("select distinct stb2.t2, stb2.t3 from stb1")
+ tdSql.error("select distinct stb2.t2 t1, stb2.t3 t2 from stb1")
+
+ tdSql.error("select distinct t0, t1 from t1 where t0 < 7")
+
+ ########## add where condition ##########
+ tdSql.query("select distinct t0, t1 from stb1 where t1 > 3")
+ tdSql.checkRows(3)
+ tdSql.query("select distinct t0, t1 from stb1 where t1 > 3 limit 2")
+ tdSql.checkRows(2)
+ tdSql.query("select distinct t0, t1 from stb1 where t1 > 3 limit 2 offset 2")
+ tdSql.checkRows(1)
+ tdSql.query("select distinct t0, t1 from stb1 where t1 > 3 slimit 2")
+ tdSql.checkRows(3)
+ tdSql.error("select distinct t0, t1 from stb1 where c1 > 2")
+ tdSql.query("select distinct t0, t1 from stb1 where t1 > 3 and t1 < 5")
+ tdSql.checkRows(1)
+ tdSql.error("select distinct stb1.t0, stb1.t1 from stb1, stb2 where stb1.t2=stb2.t4")
+ tdSql.error("select distinct t0, t1 from stb1 where stb2.t4 > 2")
+ tdSql.error("select distinct t0, t1 from stb1 where t1 > 3 group by t0")
+ tdSql.error("select distinct t0, t1 from stb1 where t1 > 3 interval(1d) ")
+ tdSql.error("select distinct t0, t1 from stb1 where t1 > 3 interval(1d) fill(next)")
+ tdSql.error("select distinct t0, t1 from stb1 where ts > now-10d and ts < now interval(1d) fill(next)")
+
+ tdSql.error("select max(c1), distinct t0 from stb1 where t0 > 2")
+ tdSql.error("select distinct t0, max(c1) from stb1 where t0 > 2")
+ tdSql.error("select distinct t0 from stb1 where t0 in (select t0 from stb1 where t0 > 2)")
+ tdSql.query("select distinct t0, t1 from stb1 where t0 in (1,2,3,4,5)")
+ tdSql.checkRows(5)
+ tdSql.query("select distinct t1 from (select t0, t1 from stb1 where t0 > 2) ")
+ tdSql.checkRows(4)
+ tdSql.error("select distinct t1 from (select distinct t0, t1 from stb1 where t0 > 2 and t1 < 3) ")
+ tdSql.error("select distinct t1 from (select distinct t0, t1 from stb1 where t0 > 2 ) where t1 < 3")
+ tdSql.query("select distinct t1 from (select t0, t1 from stb1 where t0 > 2 ) where t1 < 3")
+ tdSql.checkRows(1)
+ tdSql.error("select distinct t1, t0 from (select t1 from stb1 where t0 > 2 ) where t1 < 3")
+ tdSql.error("select distinct t1, t0 from (select max(t1) t1, max(t0) t0 from stb1 group by t1)")
+ tdSql.error("select distinct t1, t0 from (select max(t1) t1, max(t0) t0 from stb1)")
+ tdSql.query("select distinct t1, t0 from (select t1,t0 from stb1 where t0 > 2 ) where t1 < 3")
+ tdSql.checkRows(1)
+ tdSql.error(" select distinct t1, t0 from (select t1,t0 from stb1 where t0 > 2 order by ts) where t1 < 3")
+ tdSql.error("select t1, t0 from (select distinct t1,t0 from stb1 where t0 > 2 ) where t1 < 3")
+ tdSql.error(" select distinct t1, t0 from (select t1,t0 from stb1 where t0 > 2 group by ts) where t1 < 3")
+ tdSql.error("select distinct stb1.t1, stb1.t2 from stb1 , stb2 where stb1.ts=stb2.ts and stb1.t2=stb2.t4")
+ tdSql.error("select distinct t1.t1, t1.t2 from t1 , t2 where t1.ts=t2.ts ")
+
+ pass
+
+ def td5935(self):
+ tdLog.printNoPrefix("==========TD-5935==========")
+ tdSql.execute("drop database if exists db")
+ tdSql.execute("create database if not exists db keep 3650")
+
+ tdSql.execute("use db")
+ tdSql.execute("create stable db.stb1 (ts timestamp, c1 int, c2 float) tags(t1 int, t2 int)")
+ nowtime=int(round((time.time()*1000)))
+ for i in range(100):
+ sql = f"create table db.t{i} using db.stb1 tags({i % 7}, {i % 2})"
+ tdSql.execute(sql)
+ for j in range(1000):
+ tdSql.execute(f"insert into db.t{i} values ({nowtime-j*10}, {1000-j}, {round(random.random()*j,3)})")
+ tdSql.execute(f"insert into db.t{i} (ts) values ({nowtime-10000}) ")
+
+ ########### TD-5933 verify the bug of "function stddev with interval return 0 rows" is fixed ##########
+ stddevAndIntervalSql=f"select last(*) from t0 where ts>={nowtime-10000} interval(10a) limit 10"
+ tdSql.query(stddevAndIntervalSql)
+ tdSql.checkRows(10)
+
+ ########## TD-5978 verify the bug of "when start row is null, result by fill(next) is 0 " is fixed ##########
+ fillsql=f"select last(*) from t0 where ts>={nowtime-10000} and ts<{nowtime} interval(10a) fill(next) limit 10"
+ tdSql.query(fillsql)
+ fillResult=False
+ if (tdSql.getData(0,2) != 0) and (tdSql.getData(0, 2) is not None):
+ fillResult=True
+ if fillResult:
+ tdLog.success(f"sql is :{fillsql}, fill(next) is correct")
+ else:
+ tdLog.exit("fill(next) is wrong")
+
+ pass
+
+ def td6068(self):
+ tdLog.printNoPrefix("==========TD-6068==========")
+ tdSql.execute("drop database if exists db")
+ tdSql.execute("create database if not exists db keep 3650")
+ tdSql.execute("use db")
+
+ tdSql.execute("create stable db.stb1 (ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool) tags(t1 int)")
+
+ for i in range(100):
+ sql = f"create table db.t{i} using db.stb1 tags({i})"
+ tdSql.execute(sql)
+ tdSql.execute(f"insert into db.t{i} values (now-10h, {i}, {i+random.random()}, now-10h, 'a_{i}', '{i-random.random()}', True)")
+ tdSql.execute(f"insert into db.t{i} values (now-9h, {i+random.randint(1,10)}, {i+random.random()}, now-9h, 'a_{i}', '{i-random.random()}', FALSE )")
+ tdSql.execute(f"insert into db.t{i} values (now-8h, {i+random.randint(1,10)}, {i+random.random()}, now-8h, 'b_{i}', '{i-random.random()}', True)")
+ tdSql.execute(f"insert into db.t{i} values (now-7h, {i+random.randint(1,10)}, {i+random.random()}, now-7h, 'b_{i}', '{i-random.random()}', FALSE )")
+ tdSql.execute(f"insert into db.t{i} values (now-6h, {i+random.randint(1,10)}, {i+random.random()}, now-6h, 'c_{i}', '{i-random.random()}', True)")
+ tdSql.execute(f"insert into db.t{i} values (now-5h, {i+random.randint(1,10)}, {i+random.random()}, now-5h, 'c_{i}', '{i-random.random()}', FALSE )")
+ tdSql.execute(f"insert into db.t{i} (ts)values (now-4h)")
+ tdSql.execute(f"insert into db.t{i} (ts)values (now-11h)")
+ tdSql.execute(f"insert into db.t{i} (ts)values (now-450m)")
+
+ tdSql.query("select ts as t,derivative(c1, 10m, 0) from t1")
+ tdSql.checkRows(5)
+ tdSql.checkCols(3)
+ for i in range(5):
+ data=tdSql.getData(i, 0)
+ tdSql.checkData(i, 1, data)
+ tdSql.query("select ts as t, derivative(c1, 1h, 0) from stb1 group by tbname")
+ tdSql.checkRows(500)
+ tdSql.checkCols(4)
+ tdSql.query("select ts as t, derivative(c1, 1s, 0) from t1")
+ tdSql.query("select ts as t, derivative(c1, 1d, 0) from t1")
+ tdSql.error("select ts as t, derivative(c1, 1h, 0) from stb1")
+ tdSql.query("select ts as t, derivative(c2, 1h, 0) from t1")
+ tdSql.checkRows(5)
+ tdSql.error("select ts as t, derivative(c3, 1h, 0) from t1")
+ tdSql.error("select ts as t, derivative(c4, 1h, 0) from t1")
+ tdSql.query("select ts as t, derivative(c5, 1h, 0) from t1")
+ tdSql.checkRows(5)
+ tdSql.error("select ts as t, derivative(c6, 1h, 0) from t1")
+ tdSql.error("select ts as t, derivative(t1, 1h, 0) from t1")
+
+ tdSql.query("select ts as t, diff(c1) from t1")
+ tdSql.checkRows(5)
+ tdSql.checkCols(3)
+ for i in range(5):
+ data=tdSql.getData(i, 0)
+ tdSql.checkData(i, 1, data)
+ tdSql.query("select ts as t, diff(c1) from stb1 group by tbname")
+ tdSql.checkRows(500)
+ tdSql.checkCols(4)
+ tdSql.query("select ts as t, diff(c1) from t1")
+ tdSql.query("select ts as t, diff(c1) from t1")
+ tdSql.error("select ts as t, diff(c1) from stb1")
+ tdSql.query("select ts as t, diff(c2) from t1")
+ tdSql.checkRows(5)
+ tdSql.error("select ts as t, diff(c3) from t1")
+ tdSql.error("select ts as t, diff(c4) from t1")
+ tdSql.query("select ts as t, diff(c5) from t1")
+ tdSql.checkRows(5)
+ tdSql.error("select ts as t, diff(c6) from t1")
+ tdSql.error("select ts as t, diff(t1) from t1")
+ tdSql.error("select ts as t, diff(c1, c2) from t1")
+
+ tdSql.error("select ts as t, bottom(c1, 0) from t1")
+ tdSql.query("select ts as t, bottom(c1, 5) from t1")
+ tdSql.checkRows(5)
+ tdSql.checkCols(3)
+ for i in range(5):
+ data=tdSql.getData(i, 0)
+ tdSql.checkData(i, 1, data)
+ tdSql.query("select ts as t, bottom(c1, 5) from stb1")
+ tdSql.checkRows(5)
+ tdSql.query("select ts as t, bottom(c1, 5) from stb1 group by tbname")
+ tdSql.checkRows(500)
+ tdSql.query("select ts as t, bottom(c1, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.query("select ts as t, bottom(c2, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.error("select ts as t, bottom(c3, 5) from t1")
+ tdSql.error("select ts as t, bottom(c4, 5) from t1")
+ tdSql.query("select ts as t, bottom(c5, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.error("select ts as t, bottom(c6, 5) from t1")
+ tdSql.error("select ts as t, bottom(c5, 8) as b from t1 order by b")
+ tdSql.error("select ts as t, bottom(t1, 1) from t1")
+ tdSql.error("select ts as t, bottom(t1, 1) from stb1")
+ tdSql.error("select ts as t, bottom(t1, 3) from stb1 order by c3")
+ tdSql.error("select ts as t, bottom(t1, 3) from t1 order by c3")
+
+
+ tdSql.error("select ts as t, top(c1, 0) from t1")
+ tdSql.query("select ts as t, top(c1, 5) from t1")
+ tdSql.checkRows(5)
+ tdSql.checkCols(3)
+ for i in range(5):
+ data=tdSql.getData(i, 0)
+ tdSql.checkData(i, 1, data)
+ tdSql.query("select ts as t, top(c1, 5) from stb1")
+ tdSql.checkRows(5)
+ tdSql.query("select ts as t, top(c1, 5) from stb1 group by tbname")
+ tdSql.checkRows(500)
+ tdSql.query("select ts as t, top(c1, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.query("select ts as t, top(c2, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.error("select ts as t, top(c3, 5) from t1")
+ tdSql.error("select ts as t, top(c4, 5) from t1")
+ tdSql.query("select ts as t, top(c5, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.error("select ts as t, top(c6, 5) from t1")
+ tdSql.error("select ts as t, top(c5, 8) as b from t1 order by b")
+ tdSql.error("select ts as t, top(t1, 1) from t1")
+ tdSql.error("select ts as t, top(t1, 1) from stb1")
+ tdSql.error("select ts as t, top(t1, 3) from stb1 order by c3")
+ tdSql.error("select ts as t, top(t1, 3) from t1 order by c3")
+
+ tdDnodes.stop(1)
+ tdDnodes.start(1)
+
+ tdSql.query("select ts as t, diff(c1) from t1")
+ tdSql.checkRows(5)
+ tdSql.checkCols(3)
+ for i in range(5):
+ data=tdSql.getData(i, 0)
+ tdSql.checkData(i, 1, data)
+ tdSql.query("select ts as t, diff(c1) from stb1 group by tbname")
+ tdSql.checkRows(500)
+ tdSql.checkCols(4)
+ tdSql.query("select ts as t, diff(c1) from t1")
+ tdSql.query("select ts as t, diff(c1) from t1")
+ tdSql.error("select ts as t, diff(c1) from stb1")
+ tdSql.query("select ts as t, diff(c2) from t1")
+ tdSql.checkRows(5)
+ tdSql.error("select ts as t, diff(c3) from t1")
+ tdSql.error("select ts as t, diff(c4) from t1")
+ tdSql.query("select ts as t, diff(c5) from t1")
+ tdSql.checkRows(5)
+ tdSql.error("select ts as t, diff(c6) from t1")
+ tdSql.error("select ts as t, diff(t1) from t1")
+ tdSql.error("select ts as t, diff(c1, c2) from t1")
+
+ tdSql.error("select ts as t, bottom(c1, 0) from t1")
+ tdSql.query("select ts as t, bottom(c1, 5) from t1")
+ tdSql.checkRows(5)
+ tdSql.checkCols(3)
+ for i in range(5):
+ data=tdSql.getData(i, 0)
+ tdSql.checkData(i, 1, data)
+ tdSql.query("select ts as t, bottom(c1, 5) from stb1")
+ tdSql.checkRows(5)
+ tdSql.query("select ts as t, bottom(c1, 5) from stb1 group by tbname")
+ tdSql.checkRows(500)
+ tdSql.query("select ts as t, bottom(c1, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.query("select ts as t, bottom(c2, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.error("select ts as t, bottom(c3, 5) from t1")
+ tdSql.error("select ts as t, bottom(c4, 5) from t1")
+ tdSql.query("select ts as t, bottom(c5, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.error("select ts as t, bottom(c6, 5) from t1")
+ tdSql.error("select ts as t, bottom(c5, 8) as b from t1 order by b")
+ tdSql.error("select ts as t, bottom(t1, 1) from t1")
+ tdSql.error("select ts as t, bottom(t1, 1) from stb1")
+ tdSql.error("select ts as t, bottom(t1, 3) from stb1 order by c3")
+ tdSql.error("select ts as t, bottom(t1, 3) from t1 order by c3")
+
+
+ tdSql.error("select ts as t, top(c1, 0) from t1")
+ tdSql.query("select ts as t, top(c1, 5) from t1")
+ tdSql.checkRows(5)
+ tdSql.checkCols(3)
+ for i in range(5):
+ data=tdSql.getData(i, 0)
+ tdSql.checkData(i, 1, data)
+ tdSql.query("select ts as t, top(c1, 5) from stb1")
+ tdSql.checkRows(5)
+ tdSql.query("select ts as t, top(c1, 5) from stb1 group by tbname")
+ tdSql.checkRows(500)
+ tdSql.query("select ts as t, top(c1, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.query("select ts as t, top(c2, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.error("select ts as t, top(c3, 5) from t1")
+ tdSql.error("select ts as t, top(c4, 5) from t1")
+ tdSql.query("select ts as t, top(c5, 8) from t1")
+ tdSql.checkRows(6)
+ tdSql.error("select ts as t, top(c6, 5) from t1")
+ tdSql.error("select ts as t, top(c5, 8) as b from t1 order by b")
+ tdSql.error("select ts as t, top(t1, 1) from t1")
+ tdSql.error("select ts as t, top(t1, 1) from stb1")
+ tdSql.error("select ts as t, top(t1, 3) from stb1 order by c3")
+ tdSql.error("select ts as t, top(t1, 3) from t1 order by c3")
+
+ pass
+
+
def run(self):
# master branch
- # self.td3690()
- # self.td4082()
- # self.td4288()
- self.td4724()
+ self.td3690()
+ self.td4082()
+ self.td4288()
+ # self.td4724()
+ # self.td5798()
+ # self.td5935()
+ self.td6068()
# develop branch
# self.td4097()
-
+ # self.td4889()
+ # self.td5168()
+ # self.td5433()
def stop(self):
tdSql.close()
diff --git a/tests/pytest/functions/showOfflineThresholdIs864000.py b/tests/pytest/functions/showOfflineThresholdIs864000.py
index a7a1c2bf3f7d998b1ec0b0cd0e0747381e9bf4fa..7462d4cd72f600674fcb82aa1224019787d23fd5 100644
--- a/tests/pytest/functions/showOfflineThresholdIs864000.py
+++ b/tests/pytest/functions/showOfflineThresholdIs864000.py
@@ -12,6 +12,8 @@
# -*- coding: utf-8 -*-
import sys
+import numpy as np
+
from util.log import *
from util.cases import *
from util.sql import *
@@ -24,8 +26,17 @@ class TDTestCase:
tdSql.init(conn.cursor(), logSql)
def run(self):
+ # tdSql.query("show variables")
+ # tdSql.checkData(54, 1, 864000)
+ tdSql.execute("show variables")
+ res = tdSql.cursor.fetchall()
+ resList = np.array(res)
+ index = np.where(resList == "offlineThreshold")
+ index_value = np.dstack((index[0])).squeeze()
tdSql.query("show variables")
- tdSql.checkData(53, 1, 864000)
+ tdSql.checkData(index_value, 1, 864000)
+ pass
+
def stop(self):
tdSql.close()
diff --git a/tests/pytest/insert/insertFromCSVPerformance.py b/tests/pytest/insert/insertFromCSVPerformance.py
index f3b9c2734d321fb8c9d374ee16fd7ee99388bc36..487497631a368778c857ce71234a4574837390c1 100644
--- a/tests/pytest/insert/insertFromCSVPerformance.py
+++ b/tests/pytest/insert/insertFromCSVPerformance.py
@@ -28,7 +28,7 @@ class insertFromCSVPerformace:
self.tbName = tbName
self.branchName = branchName
self.type = buildType
- self.ts = 1500074556514
+ self.ts = 1500000000000
self.host = "127.0.0.1"
self.user = "root"
self.password = "taosdata"
@@ -46,13 +46,20 @@ class insertFromCSVPerformace:
config = self.config)
def writeCSV(self):
- with open('test3.csv','w', encoding='utf-8', newline='') as csvFile:
+ tsset = set()
+ rows = 0
+ with open('test4.csv','w', encoding='utf-8', newline='') as csvFile:
writer = csv.writer(csvFile, dialect='excel')
- for i in range(1000000):
- newTimestamp = self.ts + random.randint(10000000, 10000000000) + random.randint(1000, 10000000) + random.randint(1, 1000)
- d = datetime.datetime.fromtimestamp(newTimestamp / 1000)
- dt = str(d.strftime("%Y-%m-%d %H:%M:%S.%f"))
- writer.writerow(["'%s'" % dt, random.randint(1, 100), random.uniform(1, 100), random.randint(1, 100), random.randint(1, 100)])
+ while True:
+ newTimestamp = self.ts + random.randint(1, 10) * 10000000000 + random.randint(1, 10) * 1000000000 + random.randint(1, 10) * 100000000 + random.randint(1, 10) * 10000000 + random.randint(1, 10) * 1000000 + random.randint(1, 10) * 100000 + random.randint(1, 10) * 10000 + random.randint(1, 10) * 1000 + random.randint(1, 10) * 100 + random.randint(1, 10) * 10 + random.randint(1, 10)
+ if newTimestamp not in tsset:
+ tsset.add(newTimestamp)
+ d = datetime.datetime.fromtimestamp(newTimestamp / 1000)
+ dt = str(d.strftime("%Y-%m-%d %H:%M:%S.%f"))
+ writer.writerow(["'%s'" % dt, random.randint(1, 100), random.uniform(1, 100), random.randint(1, 100), random.randint(1, 100)])
+ rows += 1
+ if rows == 2000000:
+ break
def removCSVHeader(self):
data = pd.read_csv("ordered.csv")
@@ -71,7 +78,9 @@ class insertFromCSVPerformace:
cursor.execute("create table if not exists t1(ts timestamp, c1 int, c2 float, c3 int, c4 int)")
startTime = time.time()
cursor.execute("insert into t1 file 'outoforder.csv'")
- totalTime += time.time() - startTime
+ totalTime += time.time() - startTime
+ time.sleep(1)
+
out_of_order_time = (float) (totalTime / 10)
print("Out of Order - Insert time: %f" % out_of_order_time)
@@ -81,7 +90,8 @@ class insertFromCSVPerformace:
cursor.execute("create table if not exists t2(ts timestamp, c1 int, c2 float, c3 int, c4 int)")
startTime = time.time()
cursor.execute("insert into t2 file 'ordered.csv'")
- totalTime += time.time() - startTime
+ totalTime += time.time() - startTime
+ time.sleep(1)
in_order_time = (float) (totalTime / 10)
print("In order - Insert time: %f" % in_order_time)
diff --git a/tests/pytest/insert/line_insert.py b/tests/pytest/insert/line_insert.py
index 53eaa55aa50a1369b4aff9c49421263788205038..92fdd0f28e612994df414ea1b560152a3f2001a8 100644
--- a/tests/pytest/insert/line_insert.py
+++ b/tests/pytest/insert/line_insert.py
@@ -42,18 +42,18 @@ class TDTestCase:
"stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641000000ns"
]
- code = self._conn.insertLines(lines)
- print("insertLines result {}".format(code))
+ code = self._conn.insert_lines(lines)
+ print("insert_lines result {}".format(code))
lines2 = [ "stg,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
"stg,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns"
]
- code = self._conn.insertLines([ lines2[0] ])
- print("insertLines result {}".format(code))
+ code = self._conn.insert_lines([ lines2[0] ])
+ print("insert_lines result {}".format(code))
- self._conn.insertLines([ lines2[1] ])
- print("insertLines result {}".format(code))
+ self._conn.insert_lines([ lines2[1] ])
+ print("insert_lines result {}".format(code))
tdSql.query("select * from st")
tdSql.checkRows(4)
@@ -73,7 +73,7 @@ class TDTestCase:
tdSql.query("describe stf")
tdSql.checkData(2, 2, 14)
- self._conn.insertLines([
+ self._conn.insert_lines([
"sth,t1=4i64,t2=5f64,t4=5f64,ID=\"childtable\" c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641ms",
"sth,t1=4i64,t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933654ms"
])
diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py
index 88abea477a9f1b458dc17c93c27d68934f5af03f..8f1e01acd41b912de46520e109808d4677db6d9d 100644
--- a/tests/pytest/insert/schemalessInsert.py
+++ b/tests/pytest/insert/schemalessInsert.py
@@ -11,8 +11,10 @@
# -*- coding: utf-8 -*-
+import traceback
import random
import string
+from taos.error import LinesError
import time
from copy import deepcopy
import numpy as np
@@ -292,7 +294,7 @@ class TDTestCase:
def resCmp(self, input_sql, stb_name, query_sql="select * from", condition="", ts=None, id=True, none_check_tag=None):
expect_list = self.inputHandle(input_sql)
- self._conn.insertLines([input_sql])
+ self._conn.insert_lines([input_sql])
query_sql = f"{query_sql} {stb_name} {condition}"
res_row_list, res_field_list_without_ts, res_type_list = self.resHandle(query_sql, True)
if ts == 0:
@@ -312,7 +314,9 @@ class TDTestCase:
expect_list[0].pop(j)
tdSql.checkEqual(res_row_list[0], expect_list[0])
tdSql.checkEqual(res_field_list_without_ts, expect_list[1])
- tdSql.checkEqual(res_type_list, expect_list[2])
+ for i in range(len(res_type_list)):
+ tdSql.checkEqual(res_type_list[i], expect_list[2][i])
+ # tdSql.checkEqual(res_type_list, expect_list[2])
def cleanStb(self):
query_sql = "show stables"
@@ -405,13 +409,14 @@ class TDTestCase:
"""
for input_sql in [self.genLongSql(128, 1)[0], self.genLongSql(1, 4094)[0]]:
self.cleanStb()
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
for input_sql in [self.genLongSql(129, 1)[0], self.genLongSql(1, 4095)[0]]:
self.cleanStb()
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
-
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
+
def idIllegalNameCheckCase(self):
"""
test illegal id name
@@ -421,8 +426,10 @@ class TDTestCase:
rstr = list("`~!@#$¥%^&*()-+={}|[]、「」【】\:;《》<>?")
for i in rstr:
input_sql = self.genFullTypeSql(tb_name=f"\"aaa{i}bbb\"")[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
def idStartWithNumCheckCase(self):
"""
@@ -430,8 +437,10 @@ class TDTestCase:
"""
self.cleanStb()
input_sql = self.genFullTypeSql(tb_name=f"\"1aaabbb\"")[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
def nowTsCheckCase(self):
"""
@@ -439,8 +448,10 @@ class TDTestCase:
"""
self.cleanStb()
input_sql = self.genFullTypeSql(ts="now")[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
def dateFormatTsCheckCase(self):
"""
@@ -448,8 +459,10 @@ class TDTestCase:
"""
self.cleanStb()
input_sql = self.genFullTypeSql(ts="2021-07-21\ 19:01:46.920")[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
def illegalTsCheckCase(self):
"""
@@ -457,8 +470,10 @@ class TDTestCase:
"""
self.cleanStb()
input_sql = self.genFullTypeSql(ts="16260068336390us19")[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
def tagValueLengthCheckCase(self):
"""
@@ -471,8 +486,10 @@ class TDTestCase:
self.resCmp(input_sql, stb_name)
for t1 in ["-128i8", "128i8"]:
input_sql = self.genFullTypeSql(t1=t1)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
#i16
for t2 in ["-32767i16", "32767i16"]:
@@ -480,8 +497,10 @@ class TDTestCase:
self.resCmp(input_sql, stb_name)
for t2 in ["-32768i16", "32768i16"]:
input_sql = self.genFullTypeSql(t2=t2)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
#i32
for t3 in ["-2147483647i32", "2147483647i32"]:
@@ -489,8 +508,10 @@ class TDTestCase:
self.resCmp(input_sql, stb_name)
for t3 in ["-2147483648i32", "2147483648i32"]:
input_sql = self.genFullTypeSql(t3=t3)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
#i64
for t4 in ["-9223372036854775807i64", "9223372036854775807i64"]:
@@ -498,8 +519,10 @@ class TDTestCase:
self.resCmp(input_sql, stb_name)
for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]:
input_sql = self.genFullTypeSql(t4=t4)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ except LinesError:
+ pass
# f32
for t5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]:
@@ -508,8 +531,12 @@ class TDTestCase:
# * limit set to 4028234664*(10**38)
for t5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]:
input_sql = self.genFullTypeSql(t5=t5)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
+
# f64
for t6 in [f'{-1.79769*(10**308)}f64', f'{-1.79769*(10**308)}f64']:
@@ -518,27 +545,36 @@ class TDTestCase:
# * limit set to 1.797693134862316*(10**308)
for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']:
input_sql = self.genFullTypeSql(c6=c6)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# binary
stb_name = self.getLongName(7, "letters")
input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}" c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
+
input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16375, "letters")}" c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ pass
# nchar
# * legal nchar could not be larger than 16374/4
stb_name = self.getLongName(7, "letters")
input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}" c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
+
input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4094, "letters")}" c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
def colValueLengthCheckCase(self):
"""
@@ -552,16 +588,22 @@ class TDTestCase:
for c1 in ["-128i8", "128i8"]:
input_sql = self.genFullTypeSql(c1=c1)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# i16
for c2 in ["-32767i16"]:
input_sql, stb_name = self.genFullTypeSql(c2=c2)
self.resCmp(input_sql, stb_name)
for c2 in ["-32768i16", "32768i16"]:
input_sql = self.genFullTypeSql(c2=c2)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# i32
for c3 in ["-2147483647i32"]:
@@ -569,8 +611,11 @@ class TDTestCase:
self.resCmp(input_sql, stb_name)
for c3 in ["-2147483648i32", "2147483648i32"]:
input_sql = self.genFullTypeSql(c3=c3)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# i64
for c4 in ["-9223372036854775807i64"]:
@@ -578,8 +623,11 @@ class TDTestCase:
self.resCmp(input_sql, stb_name)
for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]:
input_sql = self.genFullTypeSql(c4=c4)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# f32
for c5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]:
@@ -588,8 +636,11 @@ class TDTestCase:
# * limit set to 4028234664*(10**38)
for c5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]:
input_sql = self.genFullTypeSql(c5=c5)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# f64
for c6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']:
@@ -598,27 +649,36 @@ class TDTestCase:
# * limit set to 1.797693134862316*(10**308)
for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']:
input_sql = self.genFullTypeSql(c6=c6)[0]
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# # binary
stb_name = self.getLongName(7, "letters")
input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}" 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
+
input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16375, "letters")}" 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# nchar
# * legal nchar could not be larger than 16374/4
stb_name = self.getLongName(7, "letters")
input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
+
input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4094, "letters")}" 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
def tagColIllegalValueCheckCase(self):
@@ -629,11 +689,17 @@ class TDTestCase:
# bool
for i in ["TrUe", "tRue", "trUe", "truE", "FalsE", "fAlse", "faLse", "falSe", "falsE"]:
input_sql1 = self.genFullTypeSql(t0=i)[0]
- code = self._conn.insertLines([input_sql1])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql1])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
input_sql2 = self.genFullTypeSql(c0=i)[0]
- code = self._conn.insertLines([input_sql2])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql2])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# i8 i16 i32 i64 f32 f64
for input_sql in [
@@ -651,8 +717,11 @@ class TDTestCase:
self.genFullTypeSql(c6="11.1s45f64")[0],
self.genFullTypeSql(c9="1s1u64")[0]
]:
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# check binary and nchar blank
stb_name = self.getLongName(7, "letters")
@@ -661,18 +730,19 @@ class TDTestCase:
input_sql3 = f'{stb_name},t0=t,t1="abc aaa" c0=f 1626006833639000000ns'
input_sql4 = f'{stb_name},t0=t,t1=L"abc aaa" c0=f 1626006833639000000ns'
for input_sql in [input_sql1, input_sql2, input_sql3, input_sql4]:
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
# check accepted binary and nchar symbols
# # * ~!@#$¥%^&*()-+={}|[]、「」:;
for symbol in list('~!@#$¥%^&*()-+={}|[]、「」:;'):
input_sql1 = f'{stb_name},t0=t c0=f,c1="abc{symbol}aaa" 1626006833639000000ns'
input_sql2 = f'{stb_name},t0=t,t1="abc{symbol}aaa" c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql1])
- tdSql.checkEqual(code, 0)
- code = self._conn.insertLines([input_sql2])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql1])
+ self._conn.insert_lines([input_sql2])
def duplicateIdTagColInsertCheckCase(self):
@@ -681,23 +751,35 @@ class TDTestCase:
"""
self.cleanStb()
input_sql_id = self.genFullTypeSql(id_double_tag=True)[0]
- code = self._conn.insertLines([input_sql_id])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql_id])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
input_sql = self.genFullTypeSql()[0]
input_sql_tag = input_sql.replace("t5", "t6")
- code = self._conn.insertLines([input_sql_tag])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql_tag])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
input_sql = self.genFullTypeSql()[0]
input_sql_col = input_sql.replace("c5", "c6")
- code = self._conn.insertLines([input_sql_col])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql_col])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
input_sql = self.genFullTypeSql()[0]
input_sql_col = input_sql.replace("c5", "C6")
- code = self._conn.insertLines([input_sql_col])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql_col])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
##### stb exist #####
def noIdStbExistCheckCase(self):
@@ -720,8 +802,7 @@ class TDTestCase:
self.cleanStb()
input_sql, stb_name = self.genFullTypeSql()
self.resCmp(input_sql, stb_name)
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
self.resCmp(input_sql, stb_name)
def tagColBinaryNcharLengthCheckCase(self):
@@ -788,7 +869,7 @@ class TDTestCase:
tdSql.checkRows(1)
tdSql.checkEqual(tb_name1, tb_name2)
input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", c0="f", id_noexist_tag=True, ct_add_tag=True)
- self._conn.insertLines([input_sql])
+ self._conn.insert_lines([input_sql])
tb_name3 = self.getNoIdTbName(stb_name)
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(2)
@@ -803,29 +884,35 @@ class TDTestCase:
stb_name = self.getLongName(7, "letters")
tb_name = f'{stb_name}_1'
input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
+ self._conn.insert_lines([input_sql])
# * every binary and nchar must be length+2, so here is two tag, max length could not larger than 16384-2*2
input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(5, "letters")}" c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
+
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(2)
input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(6, "letters")}" c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError:
+ pass
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(2)
# # * check col，col+ts max in describe ---> 16143
input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(12, "letters")}" 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
+
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(3)
input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(13, "letters")}" 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(3)
@@ -838,28 +925,32 @@ class TDTestCase:
stb_name = self.getLongName(7, "letters")
tb_name = f'{stb_name}_1'
input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
+ code = self._conn.insert_lines([input_sql])
# * legal nchar could not be larger than 16374/4
input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(1, "letters")}" c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(2)
input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(2, "letters")}" c0=f 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(2)
input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}",c2=L"{self.getLongName(4093, "letters")}",c3=L"{self.getLongName(4093, "letters")}",c4=L"{self.getLongName(4, "letters")}" 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines([input_sql])
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(3)
input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}",c2=L"{self.getLongName(4093, "letters")}",c3=L"{self.getLongName(4093, "letters")}",c4=L"{self.getLongName(5, "letters")}" 1626006833639000000ns'
- code = self._conn.insertLines([input_sql])
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines([input_sql])
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(3)
@@ -880,8 +971,7 @@ class TDTestCase:
"st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns",
"st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641000000ns"
]
- code = self._conn.insertLines(lines)
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines(lines)
def multiInsertCheckCase(self, count):
"""
@@ -894,8 +984,7 @@ class TDTestCase:
for i in range(count):
input_sql = self.genFullTypeSql(stb_name=stb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', id_noexist_tag=True)[0]
sql_list.append(input_sql)
- code = self._conn.insertLines(sql_list)
- tdSql.checkEqual(code, 0)
+ self._conn.insert_lines(sql_list)
def batchErrorInsertCheckCase(self):
"""
@@ -905,8 +994,11 @@ class TDTestCase:
stb_name = self.getLongName(8, "letters")
lines = ["st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
f"{stb_name},t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"]
- code = self._conn.insertLines(lines)
- tdSql.checkNotEqual(code, 0)
+ try:
+ self._conn.insert_lines(lines)
+ raise Exception("should not reach here")
+ except LinesError as err:
+ tdSql.checkNotEqual(err.errno, 0)
def genSqlList(self, count=5, stb_name="", tb_name=""):
"""
@@ -957,7 +1049,7 @@ class TDTestCase:
def genMultiThreadSeq(self, sql_list):
tlist = list()
for insert_sql in sql_list:
- t = threading.Thread(target=self._conn.insertLines,args=([insert_sql[0]],))
+ t = threading.Thread(target=self._conn.insert_lines,args=([insert_sql[0]],))
tlist.append(t)
return tlist
@@ -1053,7 +1145,7 @@ class TDTestCase:
s_stb_d_tb_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[5]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_col_m_tag_list))
tdSql.query(f"show tables;")
- tdSql.checkRows(6)
+ tdSql.checkRows(3)
def sStbDtbDdataAtMcInsertMultiThreadCheckCase(self):
"""
@@ -1123,7 +1215,7 @@ class TDTestCase:
tdSql.checkRows(5)
for t in ["t10", "t11"]:
tdSql.query(f"select * from {stb_name} where {t} is not NULL;")
- tdSql.checkRows(6)
+ tdSql.checkRows(0)
def sStbDtbDdataDtsInsertMultiThreadCheckCase(self):
"""
@@ -1150,21 +1242,23 @@ class TDTestCase:
s_stb_d_tb_d_ts_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[11]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_d_ts_a_col_m_tag_list))
tdSql.query(f"show tables;")
- tdSql.checkRows(6)
+ tdSql.checkRows(3)
def test(self):
input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 1626006933640000000ns"
input_sql2 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64 c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64 1626006933640000000ns"
- code = self._conn.insertLines([input_sql1])
- code = self._conn.insertLines([input_sql2])
- print(code)
- # self._conn.insertLines([input_sql2])
+ try:
+ self._conn.insert_lines([input_sql1])
+ self._conn.insert_lines([input_sql2])
+ except LinesError as err:
+ print(err.errno)
+ # self._conn.insert_lines([input_sql2])
# input_sql3 = f'abcd,id="cc¥Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0'
# print(input_sql3)
# input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0'
- # code = self._conn.insertLines([input_sql3])
+ # code = self._conn.insert_lines([input_sql3])
# print(code)
- # self._conn.insertLines([input_sql4])
+ # self._conn.insert_lines([input_sql4])
def runAll(self):
self.initCheckCase()
@@ -1203,26 +1297,30 @@ class TDTestCase:
self.sStbDtbDdataInsertMultiThreadCheckCase()
# # ! concurrency conflict
- # self.sStbDtbDdataAcMtInsertMultiThreadCheckCase()
- # self.sStbDtbDdataAtMcInsertMultiThreadCheckCase()
+ self.sStbDtbDdataAcMtInsertMultiThreadCheckCase()
+ self.sStbDtbDdataAtMcInsertMultiThreadCheckCase()
self.sStbStbDdataDtsInsertMultiThreadCheckCase()
# # ! concurrency conflict
- # self.sStbStbDdataDtsAcMtInsertMultiThreadCheckCase()
- # self.sStbStbDdataDtsAtMcInsertMultiThreadCheckCase()
+ self.sStbStbDdataDtsAcMtInsertMultiThreadCheckCase()
+ self.sStbStbDdataDtsAtMcInsertMultiThreadCheckCase()
self.sStbDtbDdataDtsInsertMultiThreadCheckCase()
# ! concurrency conflict
- # self.sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase()
+ self.sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase()
def run(self):
print("running {}".format(__file__))
self.createDb()
- self.runAll()
+ try:
+ self.runAll()
+ except Exception as err:
+ print(''.join(traceback.format_exception(None, err, err.__traceback__)))
+ raise err
# self.tagColIllegalValueCheckCase()
# self.test()
diff --git a/tests/pytest/insert/specialSql.py b/tests/pytest/insert/specialSql.py
new file mode 100644
index 0000000000000000000000000000000000000000..908c14ead9d9d600221ecb662d226495e370e582
--- /dev/null
+++ b/tests/pytest/insert/specialSql.py
@@ -0,0 +1,48 @@
+###################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ def run(self):
+ tdSql.prepare()
+
+ tdLog.info("=============== step1")
+ tdSql.execute(
+ 'create stable properties_asch5snuykd (ts timestamp, create_time timestamp, number_value double, value int) tags (device_id nchar(8), property nchar(8))'
+ )
+ tdSql.execute(
+ "insert into\n\t\t \n\t\t\tdb.properties_b86ca7d11556e0fdd43fd12ac08651f9 using db.properties_asch5snuykd\n\t\t\t(\n\t\t\t \n\t\t\t\tdevice_id\n\t\t\t , \n\t\t\t\tproperty\n\t\t\t \n\t\t\t)\n\t\t\ttags\n\t\t\t(\n\t\t\t \n\t\t\t\t'dev1'\n\t\t\t , \n\t\t\t\t'pres'\n\t\t\t \n\t\t\t)\n\t\t\t(\n\t\t\t \n\t\t\t\tts\n\t\t\t , \n\t\t\t\tcreate_time\n\t\t\t , \n\t\t\t\tnumber_value\n\t\t\t , \n\t\t\t\tvalue\n\t\t\t \n\t\t\t)\n\t\t\tvalues\n\t\t\t \n\t\t\t\t(\n\t\t\t\t \n\t\t\t\t\t1629443494659\n\t\t\t\t , \n\t\t\t\t\t1629443494660\n\t\t\t\t , \n\t\t\t\t\t-1000.0\n\t\t\t\t , \n\t\t\t\t\t'-1000'\n\t\t\t\t \n\t\t\t\t)\n;"
+ )
+
+ tdSql.query(
+ "select * from db.properties_b86ca7d11556e0fdd43fd12ac08651f9")
+ tdSql.checkRows(1)
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/query/filterNoKeyword.py b/tests/pytest/query/filterNoKeyword.py
new file mode 100644
index 0000000000000000000000000000000000000000..34d74efd8200dbfae13ec24c9cd8b6792b009a6b
--- /dev/null
+++ b/tests/pytest/query/filterNoKeyword.py
@@ -0,0 +1,83 @@
+###################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor())
+
+ self.ts = 1537146000000
+
+ def run(self):
+ tdSql.prepare()
+
+ print("======= Verify filter for bool, nchar and binary type =========")
+ tdLog.debug(
+ "create table st(ts timestamp, tbcol1 bool, tbcol2 binary(10), tbcol3 nchar(20), tbcol4 tinyint, tbcol5 smallint, tbcol6 int, tbcol7 bigint, tbcol8 float, tbcol9 double) tags(tagcol1 bool, tagcol2 binary(10), tagcol3 nchar(10))")
+ tdSql.execute(
+ "create table st(ts timestamp, tbcol1 bool, tbcol2 binary(10), tbcol3 nchar(20), tbcol4 tinyint, tbcol5 smallint, tbcol6 int, tbcol7 bigint, tbcol8 float, tbcol9 double) tags(tagcol1 bool, tagcol2 binary(10), tagcol3 nchar(10))")
+
+ tdSql.execute("create table st1 using st tags(true, 'table1', '水表')")
+ for i in range(1, 6):
+ tdSql.execute(
+ "insert into st1 values(%d, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d, %f, %f)" %
+ (self.ts + i, i %
+ 2, i, i,
+ i, i, i, i, 1.0, 1.0))
+
+ # =============Data type keywords cannot be used in filter====================
+ # timestamp
+ tdSql.error("select * from st where timestamp = 1629417600")
+
+ # bool
+ tdSql.error("select * from st where bool = false")
+
+ #binary
+ tdSql.error("select * from st where binary = 'taosdata'")
+
+ # nchar
+ tdSql.error("select * from st where nchar = '涛思数据'")
+
+ # tinyint
+ tdSql.error("select * from st where tinyint = 127")
+
+ # smallint
+ tdSql.error("select * from st where smallint = 32767")
+
+ # int
+ tdSql.error("select * from st where INTEGER = 2147483647")
+ tdSql.error("select * from st where int = 2147483647")
+
+ # bigint
+ tdSql.error("select * from st where bigint = 2147483647")
+
+ # float
+ tdSql.error("select * from st where float = 3.4E38")
+
+ # double
+ tdSql.error("select * from st where double = 1.7E308")
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/query/filterWithinMultiNchar.py b/tests/pytest/query/filterWithinMultiNchar.py
new file mode 100644
index 0000000000000000000000000000000000000000..15fcf4e24ba8c1d84bd1e11ef2aa43febf71ac79
--- /dev/null
+++ b/tests/pytest/query/filterWithinMultiNchar.py
@@ -0,0 +1,51 @@
+###################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ def run(self):
+ tdSql.prepare()
+
+ print("==============step1")
+ tdSql.execute(
+ "create stable t6 (ts timestamp,val int,flow nchar(36)) tags(dev nchar(36),dev1 nchar(36),dev2 nchar(36))")
+ tdSql.execute("insert into t6004 using t6 (dev,dev1,dev2) tags ('b50c79bc-b102-48e6-bda1-4212263e46d0','b50c79bc-b102-48e6-bda1-4212263e46d0', 'b50c79bc-b102-48e6-bda1-4212263e46d0') values(now,1,'b50c79bc-b102-48e6-bda1-4212263e46d0')")
+
+
+ print("==============step2")
+ tdSql.query("select * from t6 where dev='b50c79bc-b102-48e6-bda1-4212263e46d0'")
+ tdSql.checkRows(1)
+
+ tdSql.query("select * from t6 where dev1='b50c79bc-b102-48e6-bda1-4212263e46d0'")
+ tdSql.checkRows(1)
+
+ tdSql.query("select * from t6 where dev2='b50c79bc-b102-48e6-bda1-4212263e46d0'")
+ tdSql.checkRows(1)
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/query/last_row_cache.py b/tests/pytest/query/last_row_cache.py
index 83153841496b9ef4e0b7d919b44cf0a9e05b02c6..0e11e3d60c08362c0114166dcf071990893689f8 100644
--- a/tests/pytest/query/last_row_cache.py
+++ b/tests/pytest/query/last_row_cache.py
@@ -25,7 +25,7 @@ class TDTestCase:
self.tables = 10
self.rows = 20
- self.columns = 5
+ self.columns = 100
self.perfix = 't'
self.ts = 1601481600000
@@ -33,8 +33,8 @@ class TDTestCase:
print("==============step1")
sql = "create table st(ts timestamp, "
for i in range(self.columns - 1):
- sql += "c%d int, " % (i + 1)
- sql += "c5 int) tags(t1 int)"
+ sql += "c%d bigint, " % (i + 1)
+ sql += "c100 bigint) tags(t1 int)"
tdSql.execute(sql)
for i in range(self.tables):
diff --git a/tests/pytest/query/query.py b/tests/pytest/query/query.py
index 8cec38780e5e873cb07d8ade45ef56b5d4ee43f7..eaec42721a8d78d8469e788732f4277e2d321939 100644
--- a/tests/pytest/query/query.py
+++ b/tests/pytest/query/query.py
@@ -1,132 +1,139 @@
-###################################################################
-# Copyright (c) 2016 by TAOS Technologies, Inc.
-# All rights reserved.
-#
-# This file is proprietary and confidential to TAOS Technologies.
-# No part of this file may be reproduced, stored, transmitted,
-# disclosed or used in any form or by any means other than as
-# expressly provided by the written permission from Jianhui Tao
-#
-###################################################################
-
-# -*- coding: utf-8 -*-
-
-import sys
-import taos
-from util.log import tdLog
-from util.cases import tdCases
-from util.sql import tdSql
-from util.dnodes import tdDnodes
-
-class TDTestCase:
- def init(self, conn, logSql):
- tdLog.debug("start to execute %s" % __file__)
- tdSql.init(conn.cursor(), logSql)
-
- self.ts = 1538548685000
-
- def run(self):
- tdSql.prepare()
-
- print("==============step1")
- tdSql.execute(
- "create table if not exists st (ts timestamp, tagtype int) tags(dev nchar(50))")
- tdSql.execute(
- 'CREATE TABLE if not exists dev_001 using st tags("dev_01")')
- tdSql.execute(
- 'CREATE TABLE if not exists dev_002 using st tags("dev_02")')
-
- print("==============step2")
-
- tdSql.execute(
- """INSERT INTO dev_001(ts, tagtype) VALUES('2020-05-13 10:00:00.000', 1),
- ('2020-05-13 10:00:00.001', 1)
- dev_002 VALUES('2020-05-13 10:00:00.001', 1)""")
-
- tdSql.query("select * from db.st where ts='2020-05-13 10:00:00.000'")
- tdSql.checkRows(1)
-
- tdSql.query("select tbname, dev from dev_001")
- tdSql.checkRows(1)
- tdSql.checkData(0, 0, 'dev_001')
- tdSql.checkData(0, 1, 'dev_01')
-
- tdSql.query("select tbname, dev, tagtype from dev_001")
- tdSql.checkRows(2)
- tdSql.checkData(0, 0, 'dev_001')
- tdSql.checkData(0, 1, 'dev_01')
- tdSql.checkData(0, 2, 1)
- tdSql.checkData(1, 0, 'dev_001')
- tdSql.checkData(1, 1, 'dev_01')
- tdSql.checkData(1, 2, 1)
-
- ## test case for https://jira.taosdata.com:18080/browse/TD-2488
- tdSql.execute("create table m1(ts timestamp, k int) tags(a int)")
- tdSql.execute("create table t1 using m1 tags(1)")
- tdSql.execute("create table t2 using m1 tags(2)")
- tdSql.execute("insert into t1 values('2020-1-1 1:1:1', 1)")
- tdSql.execute("insert into t1 values('2020-1-1 1:10:1', 2)")
- tdSql.execute("insert into t2 values('2020-1-1 1:5:1', 99)")
-
- tdSql.query("select count(*) from m1 where ts = '2020-1-1 1:5:1' ")
- tdSql.checkRows(1)
- tdSql.checkData(0, 0, 1)
-
- tdDnodes.stop(1)
- tdDnodes.start(1)
-
- tdSql.query("select count(*) from m1 where ts = '2020-1-1 1:5:1' ")
- tdSql.checkRows(1)
- tdSql.checkData(0, 0, 1)
-
- ## test case for https://jira.taosdata.com:18080/browse/TD-1930
- tdSql.execute("create table tb(ts timestamp, c1 int, c2 binary(10), c3 nchar(10), c4 float, c5 bool)")
- for i in range(10):
- tdSql.execute("insert into tb values(%d, %d, 'binary%d', 'nchar%d', %f, %d)" % (self.ts + i, i, i, i, i + 0.1, i % 2))
-
- tdSql.error("select * from tb where c2 = binary2")
- tdSql.error("select * from tb where c3 = nchar2")
-
- tdSql.query("select * from tb where c2 = 'binary2' ")
- tdSql.checkRows(1)
-
- tdSql.query("select * from tb where c3 = 'nchar2' ")
- tdSql.checkRows(1)
-
- tdSql.query("select * from tb where c1 = '2' ")
- tdSql.checkRows(1)
-
- tdSql.query("select * from tb where c1 = 2 ")
- tdSql.checkRows(1)
-
- tdSql.query("select * from tb where c4 = '0.1' ")
- tdSql.checkRows(1)
-
- tdSql.query("select * from tb where c4 = 0.1 ")
- tdSql.checkRows(1)
-
- tdSql.query("select * from tb where c5 = true ")
- tdSql.checkRows(5)
-
- tdSql.query("select * from tb where c5 = 'true' ")
- tdSql.checkRows(5)
-
- # For jira: https://jira.taosdata.com:18080/browse/TD-2850
- tdSql.execute("create database 'Test' ")
- tdSql.execute("use 'Test' ")
- tdSql.execute("create table 'TB'(ts timestamp, 'Col1' int) tags('Tag1' int)")
- tdSql.execute("insert into 'Tb0' using tb tags(1) values(now, 1)")
- tdSql.query("select * from tb")
- tdSql.checkRows(1)
-
- tdSql.query("select * from tb0")
- tdSql.checkRows(1)
-
-
- def stop(self):
- tdSql.close()
- tdLog.success("%s successfully executed" % __file__)
-
-
-tdCases.addWindows(__file__, TDTestCase())
-tdCases.addLinux(__file__, TDTestCase())
+###################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+from util.dnodes import tdDnodes
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ self.ts = 1538548685000
+
+ def run(self):
+ tdSql.prepare()
+
+ print("==============step1")
+ tdSql.execute(
+ "create table if not exists st (ts timestamp, tagtype int) tags(dev nchar(50))")
+ tdSql.execute(
+ 'CREATE TABLE if not exists dev_001 using st tags("dev_01")')
+ tdSql.execute(
+ 'CREATE TABLE if not exists dev_002 using st tags("dev_02")')
+
+ print("==============step2")
+
+ tdSql.execute(
+ """INSERT INTO dev_001(ts, tagtype) VALUES('2020-05-13 10:00:00.000', 1),
+ ('2020-05-13 10:00:00.001', 1)
+ dev_002 VALUES('2020-05-13 10:00:00.001', 1)""")
+
+ tdSql.query("select * from db.st where ts='2020-05-13 10:00:00.000'")
+ tdSql.checkRows(1)
+
+ tdSql.query("select tbname, dev from dev_001")
+ tdSql.checkRows(1)
+ tdSql.checkData(0, 0, 'dev_001')
+ tdSql.checkData(0, 1, 'dev_01')
+
+ tdSql.query("select tbname, dev, tagtype from dev_001")
+ tdSql.checkRows(2)
+ tdSql.checkData(0, 0, 'dev_001')
+ tdSql.checkData(0, 1, 'dev_01')
+ tdSql.checkData(0, 2, 1)
+ tdSql.checkData(1, 0, 'dev_001')
+ tdSql.checkData(1, 1, 'dev_01')
+ tdSql.checkData(1, 2, 1)
+
+ ## test case for https://jira.taosdata.com:18080/browse/TD-2488
+ tdSql.execute("create table m1(ts timestamp, k int) tags(a int)")
+ tdSql.execute("create table t1 using m1 tags(1)")
+ tdSql.execute("create table t2 using m1 tags(2)")
+ tdSql.execute("insert into t1 values('2020-1-1 1:1:1', 1)")
+ tdSql.execute("insert into t1 values('2020-1-1 1:10:1', 2)")
+ tdSql.execute("insert into t2 values('2020-1-1 1:5:1', 99)")
+
+ tdSql.query("select count(*) from m1 where ts = '2020-1-1 1:5:1' ")
+ tdSql.checkRows(1)
+ tdSql.checkData(0, 0, 1)
+
+ tdDnodes.stop(1)
+ tdDnodes.start(1)
+
+ tdSql.query("select count(*) from m1 where ts = '2020-1-1 1:5:1' ")
+ tdSql.checkRows(1)
+ tdSql.checkData(0, 0, 1)
+
+ ## test case for https://jira.taosdata.com:18080/browse/TD-1930
+ tdSql.execute("create table tb(ts timestamp, c1 int, c2 binary(10), c3 nchar(10), c4 float, c5 bool)")
+ for i in range(10):
+ tdSql.execute(
+ "insert into tb values(%d, %d, 'binary%d', 'nchar%d', %f, %d)" % (self.ts + i, i, i, i, i + 0.1, i % 2))
+
+ tdSql.error("select * from tb where c2 = binary2")
+ tdSql.error("select * from tb where c3 = nchar2")
+
+ tdSql.query("select * from tb where c2 = 'binary2' ")
+ tdSql.checkRows(1)
+
+ tdSql.query("select * from tb where c3 = 'nchar2' ")
+ tdSql.checkRows(1)
+
+ tdSql.query("select * from tb where c1 = '2' ")
+ tdSql.checkRows(1)
+
+ tdSql.query("select * from tb where c1 = 2 ")
+ tdSql.checkRows(1)
+
+ tdSql.query("select * from tb where c4 = '0.1' ")
+ tdSql.checkRows(1)
+
+ tdSql.query("select * from tb where c4 = 0.1 ")
+ tdSql.checkRows(1)
+
+ tdSql.query("select * from tb where c5 = true ")
+ tdSql.checkRows(5)
+
+ tdSql.query("select * from tb where c5 = 'true' ")
+ tdSql.checkRows(5)
+
+ # For jira: https://jira.taosdata.com:18080/browse/TD-2850
+ tdSql.execute("create database 'Test' ")
+ tdSql.execute("use 'Test' ")
+ tdSql.execute("create table 'TB'(ts timestamp, 'Col1' int) tags('Tag1' int)")
+ tdSql.execute("insert into 'Tb0' using tb tags(1) values(now, 1)")
+ tdSql.query("select * from tb")
+ tdSql.checkRows(1)
+
+ # For jira:https://jira.taosdata.com:18080/browse/TD-6314
+ tdSql.execute("use db")
+ tdSql.execute("create stable stb_001(ts timestamp,v int) tags(c0 int)")
+ tdSql.query("select _block_dist() from stb_001")
+ tdSql.checkRows(1)
+
+ tdSql.query("select * from tb0")
+ tdSql.checkRows(1)
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/query/queryDiffColsOr.py b/tests/pytest/query/queryDiffColsOr.py
new file mode 100644
index 0000000000000000000000000000000000000000..feeab84a7ec577c9b48f19416400bcc7b348d543
--- /dev/null
+++ b/tests/pytest/query/queryDiffColsOr.py
@@ -0,0 +1,545 @@
+###################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+from copy import deepcopy
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+from util.common import tdCom
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ def insertData(self, tb_name):
+ insert_sql_list = [f'insert into {tb_name} values ("2021-01-01 12:00:00", 1, 1, 1, 3, 1.1, 1.1, "binary", "nchar", true, 1)',
+ f'insert into {tb_name} values ("2021-01-05 12:00:00", 2, 2, 1, 3, 1.1, 1.1, "binary", "nchar", true, 2)',
+ f'insert into {tb_name} values ("2021-01-07 12:00:00", 1, 3, 1, 2, 1.1, 1.1, "binary", "nchar", true, 3)',
+ f'insert into {tb_name} values ("2021-01-09 12:00:00", 1, 2, 4, 3, 1.1, 1.1, "binary", "nchar", true, 4)',
+ f'insert into {tb_name} values ("2021-01-11 12:00:00", 1, 2, 5, 5, 1.1, 1.1, "binary", "nchar", true, 5)',
+ f'insert into {tb_name} values ("2021-01-13 12:00:00", 1, 2, 1, 3, 6.6, 1.1, "binary", "nchar", true, 6)',
+ f'insert into {tb_name} values ("2021-01-15 12:00:00", 1, 2, 1, 3, 1.1, 7.7, "binary", "nchar", true, 7)',
+ f'insert into {tb_name} values ("2021-01-17 12:00:00", 1, 2, 1, 3, 1.1, 1.1, "binary8", "nchar", true, 8)',
+ f'insert into {tb_name} values ("2021-01-19 12:00:00", 1, 2, 1, 3, 1.1, 1.1, "binary", "nchar9", true, 9)',
+ f'insert into {tb_name} values ("2021-01-21 12:00:00", 1, 2, 1, 3, 1.1, 1.1, "binary", "nchar", false, 10)',
+ f'insert into {tb_name} values ("2021-01-23 12:00:00", 1, 3, 1, 3, 1.1, 1.1, Null, Null, false, 11)'
+ ]
+ for sql in insert_sql_list:
+ tdSql.execute(sql)
+
+ def initTb(self):
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(8, "letters")
+ tdSql.execute(
+ f"CREATE TABLE {tb_name} (ts timestamp, c1 tinyint, c2 smallint, c3 int, c4 bigint, c5 float, c6 double, c7 binary(100), c8 nchar(200), c9 bool, c10 int)")
+ self.insertData(tb_name)
+ return tb_name
+
+ def initStb(self):
+ tdCom.cleanTb()
+ tb_name = tdCom.getLongName(8, "letters")
+ tdSql.execute(
+ f"CREATE TABLE {tb_name} (ts timestamp, c1 tinyint, c2 smallint, c3 int, c4 bigint, c5 float, c6 double, c7 binary(100), c8 nchar(200), c9 bool, c10 int) tags (t1 tinyint, t2 smallint, t3 int, t4 bigint, t5 float, t6 double, t7 binary(100), t8 nchar(200), t9 bool, t10 int)")
+ tdSql.execute(
+ f'CREATE TABLE {tb_name}_sub using {tb_name} tags (1, 1, 1, 3, 1.1, 1.1, "binary", "nchar", true, 1)')
+ self.insertData(f'{tb_name}_sub')
+ return tb_name
+
+ def queryLastC10(self, query_sql, multi=False):
+ if multi:
+ res = tdSql.query(query_sql.replace('c10', 'last(*)'), True)
+ else:
+ res = tdSql.query(query_sql.replace('*', 'last(*)'), True)
+ return int(res[0][-1])
+
+ def queryFullColType(self, tb_name):
+ ## ts
+ query_sql = f'select * from {tb_name} where ts > "2021-01-11 12:00:00" or ts < "2021-01-13 12:00:00"'
+ tdSql.query(query_sql)
+ tdSql.checkRows(11)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## != or
+ query_sql = f'select * from {tb_name} where c1 != 1 or c2 = 3'
+ tdSql.query(query_sql)
+ tdSql.checkRows(3)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## <> or
+ query_sql = f'select * from {tb_name} where c1 <> 1 or c3 = 3'
+ tdSql.query(query_sql)
+ tdSql.checkRows(1)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 2)
+
+ ## >= or
+ query_sql = f'select * from {tb_name} where c1 >= 2 or c3 = 4'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 4)
+
+ ## <= or
+ query_sql = f'select * from {tb_name} where c1 <= 1 or c3 = 4'
+ tdSql.query(query_sql)
+ tdSql.checkRows(10)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## <> or is Null
+ query_sql = f'select * from {tb_name} where c1 <> 1 or c7 is Null'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## > or is not Null
+ query_sql = f'select * from {tb_name} where c2 > 2 or c8 is not Null'
+ tdSql.query(query_sql)
+ tdSql.checkRows(11)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## > or < or >= or <= or != or <> or = Null
+ query_sql = f'select * from {tb_name} where c1 > 1 or c2 < 2 or c3 >= 4 or c4 <= 2 or c5 != 1.1 or c6 <> 1.1 or c7 is Null'
+ tdSql.query(query_sql)
+ tdSql.checkRows(8)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## tiny small int big or
+ query_sql = f'select * from {tb_name} where c1 = 2 or c2 = 3 or c3 = 4 or c4 = 5'
+ tdSql.query(query_sql)
+ tdSql.checkRows(5)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## float double binary nchar bool or
+ query_sql = f'select * from {tb_name} where c5=6.6 or c6=7.7 or c7="binary8" or c8="nchar9" or c9=false'
+ tdSql.query(query_sql)
+ tdSql.checkRows(6)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## all types or
+ query_sql = f'select * from {tb_name} where c1=2 or c2=3 or c3=4 or c4=5 or c5=6.6 or c6=7.7 or c7="binary8" or c8="nchar9" or c9=false'
+ tdSql.query(query_sql)
+ tdSql.checkRows(10)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ def queryMultiExpression(self, tb_name):
+ ## condition_A and condition_B or condition_C (> < >=)
+ query_sql = f'select * from {tb_name} where c1 > 2 and c2 < 4 or c3 >= 4'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 5)
+
+ ## (condition_A and condition_B) or condition_C (<= != <>)
+ query_sql = f'select * from {tb_name} where (c1 <= 1 and c2 != 2) or c4 <> 3'
+ tdSql.query(query_sql)
+ tdSql.checkRows(4)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## condition_A and (condition_B or condition_C) (Null not Null)
+ query_sql = f'select * from {tb_name} where c1 is not Null and (c6 = 7.7 or c8 is Null)'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## condition_A or condition_B and condition_C (> < >=)
+ query_sql = f'select * from {tb_name} where c1 > 2 or c2 < 4 and c3 >= 4'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 5)
+
+ ## (condition_A or condition_B) and condition_C (<= != <>)
+ query_sql = f'select * from {tb_name} where (c1 <= 1 or c2 != 2) and c4 <> 3'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 5)
+
+ ## condition_A or (condition_B and condition_C) (Null not Null)
+ query_sql = f'select * from {tb_name} where c6 >= 7.7 or (c1 is not Null and c3 =5)'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 7)
+
+ ## condition_A or (condition_B and condition_C) or condition_D (> != < Null)
+ query_sql = f'select * from {tb_name} where c1 != 1 or (c2 >2 and c3 < 1) or c7 is Null'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## condition_A and (condition_B or condition_C) and condition_D (>= = <= not Null)
+ query_sql = f'select * from {tb_name} where c4 >= 4 and (c1 = 2 or c5 <= 1.1) and c7 is not Null'
+ tdSql.query(query_sql)
+ tdSql.checkRows(1)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 5)
+
+ ## (condition_A and condition_B) or (condition_C or condition_D) (Null >= > =)
+ query_sql = f'select * from {tb_name} where (c8 is Null and c1 >= 1) or (c3 > 3 or c4 =2)'
+ tdSql.query(query_sql)
+ tdSql.checkRows(4)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## (condition_A or condition_B) or condition_C or (condition_D and condition_E) (>= <= = not Null <>)
+ query_sql = f'select * from {tb_name} where (c1 >= 2 or c2 <= 1) or c3 = 4 or (c7 is not Null and c6 <> 1.1)'
+ tdSql.query(query_sql)
+ tdSql.checkRows(4)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 7)
+
+ ## condition_A or (condition_B and condition_C) or (condition_D and condition_E) and condition_F
+ query_sql = f'select * from {tb_name} where c1 != 1 or (c2 <= 1 and c3 <4) or (c3 >= 4 or c7 is not Null) and c9 <> true'
+ tdSql.query(query_sql)
+ tdSql.checkRows(3)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 10)
+
+ ## (condition_A or (condition_B and condition_C) or (condition_D and condition_E)) and condition_F
+ query_sql = f'select * from {tb_name} where (c1 != 1 or (c2 <= 2 and c3 >= 4) or (c3 >= 4 or c7 is not Null)) and c9 != false'
+ tdSql.query(query_sql)
+ tdSql.checkRows(9)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 9)
+
+ ## (condition_A or condition_B) or (condition_C or condition_D) and (condition_E or condition_F or condition_G)
+ query_sql = f'select * from {tb_name} where c1 != 1 or (c2 <= 3 and c3 > 4) and c3 <= 5 and (c7 is not Null and c9 != false)'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 5)
+
+ def queryMultiIn(self, tb_name):
+ ## in and in
+ query_sql = f'select * from {tb_name} where c7 in ("binary") and c8 in ("nchar")'
+ tdSql.query(query_sql)
+ tdSql.checkRows(8)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 10)
+
+ ## in or in
+ query_sql = f'select * from {tb_name} where c1 in (2, 4) or c2 in (1, 4)'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 2)
+
+ ## in and in or condition_A
+ query_sql = f'select * from {tb_name} where c7 in ("binary") and c8 in ("nchar") or c10 != 10'
+ tdSql.query(query_sql)
+ tdSql.checkRows(11)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## in or in and condition_A
+ query_sql = f'select * from {tb_name} where c7 in ("binary") or c8 in ("nchar") and c10 != 10'
+ tdSql.query(query_sql)
+ tdSql.checkRows(10)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 10)
+
+ ## in or in or condition_A
+ query_sql = f'select * from {tb_name} where c1 in (2, 4) or c2 in (3, 4) or c9 != true'
+ tdSql.query(query_sql)
+ tdSql.checkRows(4)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## in or in or in or in
+ query_sql = f'select * from {tb_name} where c1 in (2, 4) or c2 in (3, 4) or c9 in (false) or c10 in (5, 6 ,22)'
+ tdSql.query(query_sql)
+ tdSql.checkRows(6)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## in or in and in or in
+ query_sql = f'select * from {tb_name} where c1 in (2, 4) or c2 in (3, 4) and c9 in (false) or c10 in (5, 6 ,22)'
+ tdSql.query(query_sql)
+ tdSql.checkRows(4)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## condition_A or in or condition_B and in
+ query_sql = f'select * from {tb_name} where c1 = 2 or c2 in (2, 4) and c9 = false or c10 in (6 ,22)'
+ tdSql.query(query_sql)
+ tdSql.checkRows(3)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 10)
+
+ ## in and condition_A or in and in and condition_B
+ query_sql = f'select * from {tb_name} where c1 in (2, 3) and c2 <> 3 or c10 <= 4 and c10 in (4 ,22) and c9 != false'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 4)
+
+ ## (in and condition_A or in) and in and condition_B
+ query_sql = f'select * from {tb_name} where (c1 in (2, 3) and c2 <> 3 or c10 <= 4) and c10 in (4 ,22) and c9 != false'
+ tdSql.query(query_sql)
+ tdSql.checkRows(1)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 4)
+
+ def queryMultiLike(self, tb_name):
+ ## like and like
+ query_sql = f'select * from {tb_name} where c7 like "bi%" and c8 like ("ncha_")'
+ tdSql.query(query_sql)
+ tdSql.checkRows(9)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 10)
+
+ ## like or like
+ query_sql = f'select * from {tb_name} where c7 like "binar12345" or c8 like "nchar_"'
+ tdSql.query(query_sql)
+ tdSql.checkRows(1)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 9)
+
+ ## like and like or condition_A
+ query_sql = f'select * from {tb_name} where c7 like "binary_" and c8 like "ncha_" or c1 != 1'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 8)
+
+ ## like or like and condition_A
+ query_sql = f'select * from {tb_name} where c7 like ("binar_") or c8 like ("nchar_") and c10 != 8'
+ tdSql.query(query_sql)
+ tdSql.checkRows(9)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 10)
+
+ ## like or like or condition_A
+ query_sql = f'select * from {tb_name} where c7 like ("binary_") or c8 like ("nchar_") or c10 = 6'
+ tdSql.query(query_sql)
+ tdSql.checkRows(3)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 9)
+
+ ## like or like or like or like
+ query_sql = f'select * from {tb_name} where c7 like ("binary_") or c8 like ("nchar_") or c10 = 6 or c7 is Null'
+ tdSql.query(query_sql)
+ tdSql.checkRows(4)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 11)
+
+ ## like or like and like or like
+ query_sql = f'select * from {tb_name} where c7 like ("binary_") or c8 like ("ncha_") and c10 = 6 or c10 = 9'
+ tdSql.query(query_sql)
+ tdSql.checkRows(3)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 9)
+
+ ## condition_A or like or condition_B and like
+ query_sql = f'select * from {tb_name} where c1 = 2 or c7 like "binary_" or c10 = 3 and c8 like "ncha%"'
+ tdSql.query(query_sql)
+ tdSql.checkRows(3)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 8)
+
+ ## like and condition_A or like and like and condition_B
+ query_sql = f'select * from {tb_name} where c7 like "bin%" and c2 = 3 or c10 <= 4 and c7 like "binar_" and c8 like "ncha_"'
+ tdSql.query(query_sql)
+ tdSql.checkRows(4)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 4)
+
+ ## (like and condition_A or like) and like and condition_B
+ query_sql = f'select * from {tb_name} where (c7 like "bin%" and c2 = 3 or c8 like "nchar_") and c7 like "binar_" and c9 != false'
+ tdSql.query(query_sql)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(self.queryLastC10(query_sql), 9)
+
+ def queryPreCal(self, tb_name):
+ ## avg sum condition_A or condition_B
+ query_sql = f'select avg(c3), sum(c3) from {tb_name} where c10 = 5 or c8 is Null'
+ res = tdSql.query(query_sql, True)[0]
+ tdSql.checkEqual(int(res[0]), 3)
+ tdSql.checkEqual(int(res[1]), 6)
+
+ ## avg sum condition_A or condition_B or condition_C
+ query_sql = f'select avg(c3), sum(c3) from {tb_name} where c10 = 4 or c8 is Null or c9 = false '
+ res = tdSql.query(query_sql, True)[0]
+ tdSql.checkEqual(int(res[0]), 2)
+ tdSql.checkEqual(int(res[1]), 6)
+
+ ## count avg sum condition_A or condition_B or condition_C interval
+ query_sql = f'select count(*), avg(c3), sum(c3) from {tb_name} where c10 = 4 or c8 is Null or c9 = false interval(16d)'
+ res = tdSql.query(query_sql, True)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(int(res[0][1]), 1)
+ tdSql.checkEqual(int(res[0][2]), 4)
+ tdSql.checkEqual(int(res[0][3]), 4)
+ tdSql.checkEqual(int(res[1][1]), 2)
+ tdSql.checkEqual(int(res[1][2]), 1)
+ tdSql.checkEqual(int(res[1][3]), 2)
+
+ ## count avg sum condition_A or condition_B or in and like or condition_C interval
+ query_sql = f'select count(*), sum(c3) from {tb_name} where c10 = 4 or c8 is Null or c2 in (1, 2) and c7 like "binary_" or c1 <> 1 interval(16d)'
+ res = tdSql.query(query_sql, True)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(int(res[0][1]), 2)
+ tdSql.checkEqual(int(res[0][2]), 5)
+ tdSql.checkEqual(int(res[1][1]), 2)
+ tdSql.checkEqual(int(res[1][2]), 2)
+
+ def queryMultiTb(self, tb_name):
+ ## select from (condition_A or condition_B)
+ query_sql = f'select c10 from (select * from {tb_name} where c1 >1 or c2 >=3)'
+ res = tdSql.query(query_sql, True)
+ tdSql.checkRows(3)
+ tdSql.checkEqual(int(res[2][0]), 11)
+
+ ## select from (condition_A or condition_B) where condition_A or condition_B
+ query_sql = f'select c10 from (select * from {tb_name} where c1 >1 or c2 >=3) where c1 =2 or c4 = 2'
+ res = tdSql.query(query_sql, True)
+ tdSql.checkRows(2)
+ tdSql.checkEqual(int(res[1][0]), 3)
+
+ ## select from (condition_A or condition_B and like and in) where condition_A or condition_B or like and in
+ query_sql = f'select c10 from (select * from {tb_name} where c1 >1 or c2 = 2 and c7 like "binar_" and c4 in (3, 5)) where c1 != 2 or c3 = 1 or c8 like "ncha_" and c9 in (true)'
+ res = tdSql.query(query_sql, True)
+ tdSql.checkRows(7)
+ tdSql.checkEqual(int(res[6][0]), 10)
+
+ ## select count avg sum from (condition_A or condition_B and like and in) where condition_A or condition_B or like and in interval
+ query_sql = f'select count(*), avg(c6), sum(c3) from (select * from {tb_name} where c1 >1 or c2 = 2 and c7 like "binar_" and c4 in (3, 5)) where c1 != 2 or c3 = 1 or c8 like "ncha_" and c9 in (true) interval(8d)'
+ res = tdSql.query(query_sql, True)
+ tdSql.checkRows(3)
+ tdSql.checkEqual(int(res[0][1]), 3)
+ tdSql.checkEqual(int(res[0][2]), 1)
+ tdSql.checkEqual(int(res[0][3]), 10)
+ tdSql.checkEqual(int(res[1][1]), 3)
+ tdSql.checkEqual(int(res[1][2]), 3)
+ tdSql.checkEqual(int(res[1][3]), 3)
+ tdSql.checkEqual(int(res[2][1]), 1)
+ tdSql.checkEqual(int(res[2][2]), 1)
+ tdSql.checkEqual(int(res[2][3]), 1)
+
+ ## cname
+ query_sql = f'select c10 from (select * from {tb_name} where c1 >1 or c2 = 2 and c7 like "binar_" and c4 in (3, 5)) a where a.c1 != 2 or a.c3 = 1 or a.c8 like "ncha_" and a.c9 in (true)'
+ res = tdSql.query(query_sql, True)
+ tdSql.checkRows(7)
+ tdSql.checkEqual(int(res[6][0]), 10)
+
+ ## multi cname
+ query_sql = f'select b.c10 from (select * from {tb_name} where c9 = true or c2 = 2) a, (select * from {tb_name} where c7 like "binar_" or c4 in (3, 5)) b where a.ts = b.ts'
+ res = tdSql.query(query_sql, True)
+ tdSql.checkRows(10)
+ tdSql.checkEqual(int(res[9][0]), 10)
+
+ def checkTbColTypeOperator(self):
+ '''
+ Ordinary table full column type and operator
+ '''
+ tb_name = self.initTb()
+ self.queryFullColType(tb_name)
+
+ def checkStbColTypeOperator(self):
+ '''
+ Super table full column type and operator
+ '''
+ tb_name = self.initStb()
+ self.queryFullColType(tb_name)
+
+ def checkTbMultiExpression(self):
+ '''
+ Ordinary table multiExpression
+ '''
+ tb_name = self.initTb()
+ self.queryMultiExpression(tb_name)
+
+ def checkStbMultiExpression(self):
+ '''
+ Super table multiExpression
+ '''
+ tb_name = self.initStb()
+ self.queryMultiExpression(tb_name)
+
+ def checkTbMultiIn(self):
+ '''
+ Ordinary table multiIn
+ '''
+ tb_name = self.initTb()
+ self.queryMultiIn(tb_name)
+
+ def checkStbMultiIn(self):
+ '''
+ Super table multiIn
+ '''
+ tb_name = self.initStb()
+ self.queryMultiIn(tb_name)
+
+ def checkTbMultiLike(self):
+ '''
+ Ordinary table multiLike
+ '''
+ tb_name = self.initTb()
+ self.queryMultiLike(tb_name)
+
+ def checkStbMultiLike(self):
+ '''
+ Super table multiLike
+ '''
+ tb_name = self.initStb()
+ self.queryMultiLike(tb_name)
+
+ def checkTbPreCal(self):
+ '''
+ Ordinary table precal
+ '''
+ tb_name = self.initTb()
+ self.queryPreCal(tb_name)
+
+ def checkStbPreCal(self):
+ '''
+ Super table precal
+ '''
+ tb_name = self.initStb()
+ self.queryPreCal(tb_name)
+
+ def checkMultiTb(self):
+ '''
+ test "or" in multi ordinary table
+ '''
+ tb_name = self.initTb()
+ self.queryMultiTb(tb_name)
+
+ def checkMultiStb(self):
+ '''
+ test "or" in multi super table
+ '''
+ tb_name = self.initStb()
+ self.queryMultiTb(tb_name)
+
+
+ # tb_name1 = tdCom.getLongName(8, "letters")
+ # tb_name2 = tdCom.getLongName(8, "letters")
+ # tb_name3 = tdCom.getLongName(8, "letters")
+ # tdSql.execute(
+ # f"CREATE TABLE {tb_name1} (ts timestamp, c1 tinyint, c2 smallint, c3 int)")
+ # tdSql.execute(
+ # f"CREATE TABLE {tb_name2} (ts timestamp, c1 tinyint, c2 smallint, c3 int)")
+ # tdSql.execute(
+ # f"CREATE TABLE {tb_name3} (ts timestamp, c1 tinyint, c2 smallint, c3 int)")
+ # insert_sql_list = [f'insert into {tb_name1} values ("2021-01-01 12:00:00", 1, 5, 1)',
+ # f'insert into {tb_name1} values ("2021-01-03 12:00:00", 2, 4, 1)',
+ # f'insert into {tb_name1} values ("2021-01-05 12:00:00", 3, 2, 1)',
+ # f'insert into {tb_name2} values ("2021-01-01 12:00:00", 4, 2, 1)',
+ # f'insert into {tb_name2} values ("2021-01-02 12:00:00", 5, 1, 1)',
+ # f'insert into {tb_name2} values ("2021-01-04 12:00:00", 1, 2, 1)',
+ # f'insert into {tb_name3} values ("2021-01-02 12:00:00", 4, 2, 1)',
+ # f'insert into {tb_name3} values ("2021-01-06 12:00:00", 5, 1, 1)',
+ # f'insert into {tb_name3} values ("2021-01-07 12:00:00", 1, 2, 1)',
+ # ]
+ # for sql in insert_sql_list:
+ # tdSql.execute(sql)
+ # tdSql.query(
+ # f'select * from {tb_name1} t1, {tb_name2}, {tb_name3} t3 t2 where (t1.ts=t2.ts or t2.ts=t3.ts)')
+ # tdSql.checkRows(4)
+
+
+ def run(self):
+ tdSql.prepare()
+ self.checkTbColTypeOperator()
+ self.checkStbColTypeOperator()
+ self.checkTbMultiExpression()
+ self.checkStbMultiExpression()
+ self.checkTbMultiIn()
+ self.checkStbMultiIn()
+ self.checkTbMultiLike()
+ self.checkStbMultiLike()
+ self.checkTbPreCal()
+ self.checkStbPreCal()
+ self.checkMultiTb()
+ self.checkMultiStb()
+
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/query/queryError.py b/tests/pytest/query/queryError.py
index ac78c0518f36a847652499aaa5722d4585e42d44..e5c468600ba56a251057f204971084fe2844a85e 100644
--- a/tests/pytest/query/queryError.py
+++ b/tests/pytest/query/queryError.py
@@ -65,6 +65,10 @@ class TDTestCase:
# TD-2208
tdSql.error("select diff(tagtype),top(tagtype,1) from dev_001")
+ # TD-6006
+ tdSql.error("select * from dev_001 where 'name' is not null")
+ tdSql.error("select * from dev_001 where \"name\" = 'first'")
+
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
diff --git a/tests/pytest/query/queryGroupTbname.py b/tests/pytest/query/queryGroupTbname.py
new file mode 100644
index 0000000000000000000000000000000000000000..095feed52fa7c44e2dd1b98a5f15c7034165b95e
--- /dev/null
+++ b/tests/pytest/query/queryGroupTbname.py
@@ -0,0 +1,60 @@
+###################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+from util.common import tdCom
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ def queryGroupTbname(self):
+ '''
+ select a1,a2...a10 from stb where tbname in (t1,t2,...t10) and ts...
+ '''
+ tdCom.cleanTb()
+ table_name = tdCom.getLongName(8, "letters_mixed")
+ tbname_list = list(map(lambda x: f'table_name_sub{x}', range(1, 11)))
+ tb_str = ""
+
+ for tbname in tbname_list:
+ globals()[tbname] = tdCom.getLongName(8, "letters_mixed")
+ tdSql.execute(f'CREATE TABLE {table_name} (ts timestamp, {table_name_sub1} tinyint, \
+ {table_name_sub2} smallint, {table_name_sub3} int, {table_name_sub4} bigint, \
+ {table_name_sub5} float, {table_name_sub6} double, {table_name_sub7} binary(20),\
+ {table_name_sub8} nchar(20), {table_name_sub9} bool) tags ({table_name_sub10} binary(20))')
+
+ for tbname in tbname_list:
+ tb_str += tbname
+ tdSql.execute(f'create table {globals()[tbname]} using {table_name} tags ("{globals()[tbname]}")')
+
+ for i in range(10):
+ for tbname in tbname_list:
+ tdSql.execute(f'insert into {globals()[tbname]} values (now, 1, 2, 3, 4, 1.1, 2.2, "{globals()[tbname]}", "{globals()[tbname]}", True)')
+
+ for i in range(100):
+ tdSql.query(f'select {table_name_sub1},{table_name_sub2},{table_name_sub3},{table_name_sub4},{table_name_sub5},{table_name_sub6},{table_name_sub7},{table_name_sub8},{table_name_sub9} from {table_name} where tbname in ("{table_name_sub1}","{table_name_sub2}","{table_name_sub3}","{table_name_sub4}","{table_name_sub5}","{table_name_sub6}","{table_name_sub7}","{table_name_sub8}","{table_name_sub9}") and ts >= "1980-01-01 00:00:00.000"')
+ tdSql.checkRows(90)
+
+ def run(self):
+ tdSql.prepare()
+ self.queryGroupTbname()
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file
diff --git a/tests/pytest/query/queryPerformance.py b/tests/pytest/query/queryPerformance.py
index 81103252d8794032ee17b143f814276e171863f2..29e5cb19b75b0943c24382d268e81daebed01cdf 100644
--- a/tests/pytest/query/queryPerformance.py
+++ b/tests/pytest/query/queryPerformance.py
@@ -17,6 +17,7 @@ import os
import taos
import time
import argparse
+import json
class taosdemoQueryPerformace:
@@ -48,7 +49,7 @@ class taosdemoQueryPerformace:
cursor2 = self.conn2.cursor()
cursor2.execute("create database if not exists %s" % self.dbName)
cursor2.execute("use %s" % self.dbName)
- cursor2.execute("create table if not exists %s(ts timestamp, query_time float, commit_id binary(50), branch binary(50), type binary(20)) tags(query_id int, query_sql binary(300))" % self.stbName)
+ cursor2.execute("create table if not exists %s(ts timestamp, query_time_avg float, query_time_max float, query_time_min float, commit_id binary(50), branch binary(50), type binary(20)) tags(query_id int, query_sql binary(300))" % self.stbName)
sql = "select count(*) from test.meters"
tableid = 1
@@ -74,7 +75,7 @@ class taosdemoQueryPerformace:
tableid = 6
cursor2.execute("create table if not exists %s%d using %s tags(%d, '%s')" % (self.tbPerfix, tableid, self.stbName, tableid, sql))
- sql = "select * from meters"
+ sql = "select * from meters limit 10000"
tableid = 7
cursor2.execute("create table if not exists %s%d using %s tags(%d, '%s')" % (self.tbPerfix, tableid, self.stbName, tableid, sql))
@@ -87,37 +88,96 @@ class taosdemoQueryPerformace:
cursor2.execute("create table if not exists %s%d using %s tags(%d, '%s')" % (self.tbPerfix, tableid, self.stbName, tableid, sql))
cursor2.close()
+
+ def generateQueryJson(self):
+
+ sqls = []
+ cursor2 = self.conn2.cursor()
+ cursor2.execute("select query_id, query_sql from %s.%s" % (self.dbName, self.stbName))
+ i = 0
+ for data in cursor2:
+ sql = {
+ "sql": data[1],
+ "result_mode": "onlyformat",
+ "result_file": "./query_sql_res%d.txt" % i
+ }
+ sqls.append(sql)
+ i += 1
+
+ query_data = {
+ "filetype": "query",
+ "cfgdir": "/etc/perf",
+ "host": "127.0.0.1",
+ "port": 6030,
+ "user": "root",
+ "password": "taosdata",
+ "databases": "test",
+ "specified_table_query": {
+ "query_times": 100,
+ "concurrent": 1,
+ "sqls": sqls
+ }
+ }
+
+ query_json_file = f"/tmp/query.json"
+
+ with open(query_json_file, 'w') as f:
+ json.dump(query_data, f)
+ return query_json_file
+
+ def getBuildPath(self):
+ selfPath = os.path.dirname(os.path.realpath(__file__))
+
+ if ("community" in selfPath):
+ projPath = selfPath[:selfPath.find("community")]
+ else:
+ projPath = selfPath[:selfPath.find("tests")]
+
+ for root, dirs, files in os.walk(projPath):
+ if ("taosdemo" in files):
+ rootRealPath = os.path.dirname(os.path.realpath(root))
+ if ("packaging" not in rootRealPath):
+ buildPath = root[:len(root) - len("/build/bin")]
+ break
+ return buildPath
+
+ def getCMDOutput(self, cmd):
+ cmd = os.popen(cmd)
+ output = cmd.read()
+ cmd.close()
+ return output
def query(self):
- cursor = self.conn.cursor()
- print("==================== query performance ====================")
+ buildPath = self.getBuildPath()
+ if (buildPath == ""):
+ print("taosdemo not found!")
+ sys.exit(1)
+
+ binPath = buildPath + "/build/bin/"
+ os.system(
+ "%sperfMonitor -f %s > query_res.txt" %
+ (binPath, self.generateQueryJson()))
+ cursor = self.conn2.cursor()
+ print("==================== query performance ====================")
cursor.execute("use %s" % self.dbName)
- cursor.execute("select tbname, query_id, query_sql from %s" % self.stbName)
+ cursor.execute("select tbname, query_sql from %s" % self.stbName)
+ i = 0
for data in cursor:
table_name = data[0]
- query_id = data[1]
- sql = data[2]
+ sql = data[1]
+
+ self.avgDelay = self.getCMDOutput("grep 'avgDelay' query_res.txt | awk 'NR==%d{print $2}'" % (i + 1))
+ self.maxDelay = self.getCMDOutput("grep 'avgDelay' query_res.txt | awk 'NR==%d{print $5}'" % (i + 1))
+ self.minDelay = self.getCMDOutput("grep 'avgDelay' query_res.txt | awk 'NR==%d{print $8}'" % (i + 1))
+ i += 1
+
+ print("query time for: %s %f seconds" % (sql, float(self.avgDelay)))
+ c = self.conn2.cursor()
+ c.execute("insert into %s.%s values(now, %f, %f, %f, '%s', '%s', '%s')" % (self.dbName, table_name, float(self.avgDelay), float(self.maxDelay), float(self.minDelay), self.commitID, self.branch, self.type))
- totalTime = 0
- cursor2 = self.conn.cursor()
- cursor2.execute("use test")
- for i in range(100):
- if(self.clearCache == True):
- # root permission is required
- os.system("echo 3 > /proc/sys/vm/drop_caches")
-
- startTime = time.time()
- cursor2.execute(sql)
- totalTime += time.time() - startTime
- cursor2.close()
- print("query time for: %s %f seconds" % (sql, totalTime / 100))
-
- cursor3 = self.conn2.cursor()
- cursor3.execute("insert into %s.%s values(now, %f, '%s', '%s', '%s')" % (self.dbName, table_name, totalTime / 100, self.commitID, self.branch, self.type))
-
- cursor3.close()
+ c.close()
cursor.close()
if __name__ == '__main__':
@@ -174,4 +234,4 @@ if __name__ == '__main__':
args = parser.parse_args()
perftest = taosdemoQueryPerformace(args.remove_cache, args.commit_id, args.database_name, args.stable_name, args.table_perfix, args.git_branch, args.build_type)
perftest.createPerfTables()
- perftest.query()
+ perftest.query()
\ No newline at end of file
diff --git a/tests/pytest/query/queryWildcardLength.py b/tests/pytest/query/queryWildcardLength.py
new file mode 100644
index 0000000000000000000000000000000000000000..1fc46fe7d643d40c2768faf505102b9f579dd2d6
--- /dev/null
+++ b/tests/pytest/query/queryWildcardLength.py
@@ -0,0 +1,207 @@
+###################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+from copy import deepcopy
+import string
+import random
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ def cleanTb(self):
+ query_sql = "show stables"
+ res_row_list = tdSql.query(query_sql, True)
+ stb_list = map(lambda x: x[0], res_row_list)
+ for stb in stb_list:
+ tdSql.execute(f'drop table if exists {stb}')
+
+ query_sql = "show tables"
+ res_row_list = tdSql.query(query_sql, True)
+ tb_list = map(lambda x: x[0], res_row_list)
+ for tb in tb_list:
+ tdSql.execute(f'drop table if exists {tb}')
+
+ def getLongWildcardStr(self, len=None):
+ """
+ generate long wildcard str
+ """
+ maxWildCardsLength = int(tdSql.getVariable('maxWildCardsLength')[0])
+ if len:
+ chars = ''.join(random.choice(string.ascii_letters.lower()) for i in range(len))
+ else:
+ chars = ''.join(random.choice(string.ascii_letters.lower()) for i in range(maxWildCardsLength+1))
+ return chars
+
+ def genTableName(self):
+ '''
+ generate table name
+ hp_name--->'%str'
+ lp_name--->'str%'
+ ul_name--->'st_r'
+ '''
+ table_name = self.getLongWildcardStr()
+ table_name_list = list(table_name)
+ table_name_list.pop(-1)
+
+ if len(table_name_list) > 1:
+ lp_name = deepcopy(table_name_list)
+ lp_name[-1] = '%'
+ lp_name = ''.join(lp_name)
+
+ ul_name = list(lp_name)
+ ul_name[int(len(ul_name)/2)] = '_'
+ ul_name = ''.join(ul_name)
+
+ table_name_list = list(table_name)
+ hp_name = deepcopy(table_name_list)
+ hp_name.pop(1)
+ hp_name[0] = '%'
+ hp_name = ''.join(hp_name)
+ else:
+ hp_name = '%'
+ lp_name = '%'
+ ul_name = '_'
+ return table_name, hp_name, lp_name, ul_name
+
+ def checkRegularTableWildcardLength(self):
+ '''
+ check regular table wildcard length with % and _
+ '''
+ self.cleanTb()
+ table_name, hp_name, lp_name, ul_name = self.genTableName()
+ tdSql.execute(f"CREATE TABLE {table_name} (ts timestamp, a1 int)")
+ sql_list = [f'show tables like "{hp_name}"', f'show tables like "{lp_name}"', f'show tables like "{ul_name}"']
+ for sql in sql_list:
+ tdSql.query(sql)
+ if len(table_name) >= 1:
+ tdSql.checkRows(1)
+ else:
+ tdSql.error(sql)
+
+ exceed_sql_list = [f'show tables like "%{hp_name}"', f'show tables like "{lp_name}%"', f'show tables like "{ul_name}%"']
+ for sql in exceed_sql_list:
+ tdSql.error(sql)
+
+ def checkSuperTableWildcardLength(self):
+ '''
+ check super table wildcard length with % and _
+ '''
+ self.cleanTb()
+ table_name, hp_name, lp_name, ul_name = self.genTableName()
+ tdSql.execute(f"CREATE TABLE {table_name} (ts timestamp, c1 int) tags (t1 int)")
+ sql_list = [f'show stables like "{hp_name}"', f'show stables like "{lp_name}"', f'show stables like "{ul_name}"']
+ for sql in sql_list:
+ tdSql.query(sql)
+ if len(table_name) >= 1:
+ tdSql.checkRows(1)
+ else:
+ tdSql.error(sql)
+
+ exceed_sql_list = [f'show stables like "%{hp_name}"', f'show stables like "{lp_name}%"', f'show stables like "{ul_name}%"']
+ for sql in exceed_sql_list:
+ tdSql.error(sql)
+
+ def checkRegularWildcardSelectLength(self):
+ '''
+ check regular table wildcard select length with % and _
+ '''
+ self.cleanTb()
+ table_name, hp_name, lp_name, ul_name = self.genTableName()
+ tdSql.execute(f"CREATE TABLE {table_name} (ts timestamp, bi1 binary(200), nc1 nchar(200))")
+ tdSql.execute(f'insert into {table_name} values (now, "{table_name}", "{table_name}")')
+ sql_list = [f'select * from {table_name} where bi1 like "{hp_name}"',
+ f'select * from {table_name} where bi1 like "{lp_name}"',
+ f'select * from {table_name} where bi1 like "{ul_name}"',
+ f'select * from {table_name} where nc1 like "{hp_name}"',
+ f'select * from {table_name} where nc1 like "{lp_name}"',
+ f'select * from {table_name} where nc1 like "{ul_name}"']
+ for sql in sql_list:
+ tdSql.query(sql)
+ if len(table_name) >= 1:
+ tdSql.checkRows(1)
+ else:
+ tdSql.error(sql)
+
+ exceed_sql_list = [f'select * from {table_name} where bi1 like "%{hp_name}"',
+ f'select * from {table_name} where bi1 like "{lp_name}%"',
+ f'select * from {table_name} where bi1 like "{ul_name}%"',
+ f'select * from {table_name} where nc1 like "%{hp_name}"',
+ f'select * from {table_name} where nc1 like "{lp_name}%"',
+ f'select * from {table_name} where nc1 like "{ul_name}%"']
+ for sql in exceed_sql_list:
+ tdSql.error(sql)
+
+ def checkStbWildcardSelectLength(self):
+ '''
+ check stb wildcard select length with % and _
+ '''
+ self.cleanTb()
+ table_name, hp_name, lp_name, ul_name = self.genTableName()
+
+ tdSql.execute(f'CREATE TABLE {table_name} (ts timestamp, bi1 binary(200), nc1 nchar(200)) tags (si1 binary(200), sc1 nchar(200))')
+ tdSql.execute(f'create table {table_name}_sub1 using {table_name} tags ("{table_name}", "{table_name}")')
+ tdSql.execute(f'insert into {table_name}_sub1 values (now, "{table_name}", "{table_name}");')
+
+ sql_list = [f'select * from {table_name} where bi1 like "{hp_name}"',
+ f'select * from {table_name} where bi1 like "{lp_name}"',
+ f'select * from {table_name} where bi1 like "{ul_name}"',
+ f'select * from {table_name} where nc1 like "{hp_name}"',
+ f'select * from {table_name} where nc1 like "{lp_name}"',
+ f'select * from {table_name} where nc1 like "{ul_name}"',
+ f'select * from {table_name} where si1 like "{hp_name}"',
+ f'select * from {table_name} where si1 like "{lp_name}"',
+ f'select * from {table_name} where si1 like "{ul_name}"',
+ f'select * from {table_name} where sc1 like "{hp_name}"',
+ f'select * from {table_name} where sc1 like "{lp_name}"',
+ f'select * from {table_name} where sc1 like "{ul_name}"']
+
+ for sql in sql_list:
+ tdSql.query(sql)
+ if len(table_name) >= 1:
+ tdSql.checkRows(1)
+ else:
+ tdSql.error(sql)
+ exceed_sql_list = [f'select * from {table_name} where bi1 like "%{hp_name}"',
+ f'select * from {table_name} where bi1 like "{lp_name}%"',
+ f'select * from {table_name} where bi1 like "{ul_name}%"',
+ f'select * from {table_name} where nc1 like "%{hp_name}"',
+ f'select * from {table_name} where nc1 like "{lp_name}%"',
+ f'select * from {table_name} where nc1 like "{ul_name}%"',
+ f'select * from {table_name} where si1 like "%{hp_name}"',
+ f'select * from {table_name} where si1 like "{lp_name}%"',
+ f'select * from {table_name} where si1 like "{ul_name}%"',
+ f'select * from {table_name} where sc1 like "%{hp_name}"',
+ f'select * from {table_name} where sc1 like "{lp_name}%"',
+ f'select * from {table_name} where sc1 like "{ul_name}%"']
+ for sql in exceed_sql_list:
+ tdSql.error(sql)
+
+ def run(self):
+ tdSql.prepare()
+ self.checkRegularTableWildcardLength()
+ self.checkSuperTableWildcardLength()
+ self.checkRegularWildcardSelectLength()
+ self.checkStbWildcardSelectLength()
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
+
diff --git a/tests/pytest/restful/restful_bind_db1.py b/tests/pytest/restful/restful_bind_db1.py
new file mode 100644
index 0000000000000000000000000000000000000000..9620535fd7c9388d08d0ebae9237b243fc0a099c
--- /dev/null
+++ b/tests/pytest/restful/restful_bind_db1.py
@@ -0,0 +1,123 @@
+# #################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+
+# #################################################################
+
+# -*- coding: utf-8 -*-
+
+# TODO: after TD-4518 and TD-4510 is resolved, add the exception test case for these situations
+
+from distutils.log import error
+import sys
+
+from requests.api import head
+from requests.models import Response
+from util.log import *
+from util.cases import *
+from util.sql import *
+import time, datetime
+import requests, json
+import threading
+import string
+import random
+
+
+def check_unbind_db(url, data, header):
+ resp = requests.post(url, data, headers = header )
+ resp.encoding='utf-8'
+ resp = eval(resp.text)
+ status = resp['status']
+ desc = resp['desc']
+ sqls = data
+ if status=="error" and desc == "invalid url format":
+ print(" %s : check pass" %sqls)
+ else:
+ printf(" error occured , ")
+ sys.exit()
+
+def check_bind_db(url, data, header):
+ resp = requests.post(url, data, headers = header )
+ resp.encoding='utf-8'
+ resp_dict = eval(resp.text)
+ status = resp_dict['status']
+ if status =="succ":
+ print("%s run success!"%data)
+ # print(resp.text)
+ else :
+ print("%s run failed !"%data)
+ print(resp.text)
+ sys.exit()
+
+class TDTestCase():
+ updatecfgDict={'httpDbNameMandatory':1}
+
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ def run(self):
+ tdSql.prepare()
+ tdSql.execute('reset query cache')
+ tdSql.execute('drop database if exists test')
+ tdSql.execute('drop database if exists db')
+ tdSql.execute('drop database if exists des')
+ tdSql.execute('create database test')
+ tdSql.execute('create database des')
+
+ header = {'Authorization': 'Basic cm9vdDp0YW9zZGF0YQ=='}
+ url = "http://127.0.0.1:6041/rest/sql/"
+
+ # test with no bind databases
+
+ sqls = ["show databases;",
+ "use test",
+ "show tables;",
+ "show dnodes;",
+ "show vgroups;",
+ "create database db;",
+ "drop database db;",
+ "select client_version();" ,
+ "use test",
+ "ALTER DATABASE test COMP 2;",
+ "create table tb (ts timestamp, id int , data double)",
+ "insert into tb values (now , 1, 1.0) ",
+ "select * from tb",
+ "show test.tables",
+ "show tables",
+ "insert into tb values (now , 2, 2.0) ",
+ "create table test.tb (ts timestamp, id int , data double)",
+ "insert into test.tb values (now , 2, 2.0) ",
+ "select * from tb",
+ "select * from test.tb"]
+
+ for sql in sqls:
+ print("===================")
+ check_unbind_db(url,sql,header)
+
+ print("==================="*5)
+ print(" check bind db about restful ")
+ print("==================="*5)
+ url = "http://127.0.0.1:6041/rest/sql/des"
+ for sql in sqls:
+ print("===================")
+ check_bind_db(url,sql,header)
+ # check data
+ tdSql.query("select * from test.tb")
+ tdSql.checkRows(1)
+ tdSql.query("select * from des.tb")
+ tdSql.checkRows(2)
+
+ os.system('sudo timedatectl set-ntp on')
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/restful/restful_bind_db2.py b/tests/pytest/restful/restful_bind_db2.py
new file mode 100644
index 0000000000000000000000000000000000000000..35aa1408a7690798d66bc0303e64fe4843dab0d8
--- /dev/null
+++ b/tests/pytest/restful/restful_bind_db2.py
@@ -0,0 +1,133 @@
+# #################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+
+# #################################################################
+
+# -*- coding: utf-8 -*-
+
+# TODO: after TD-4518 and TD-4510 is resolved, add the exception test case for these situations
+
+from distutils.log import error
+import sys
+
+from requests.api import head
+from requests.models import Response
+from util.log import *
+from util.cases import *
+from util.sql import *
+import time, datetime
+import requests, json
+import threading
+import string
+import random
+
+def check_res(url, data, header):
+ resp = requests.post(url, data, headers = header )
+ resp.encoding='utf-8'
+ resp_dict = eval(resp.text)
+ status = resp_dict['status']
+ if status =="succ":
+ print("%s run success!"%data)
+ # print(resp.text)
+ else :
+ print("%s run failed !"%data)
+ print(resp.text)
+ sys.exit()
+
+class TDTestCase():
+ # updatecfgDict={'httpDbNameMandatory':0}
+
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ def run(self):
+ tdSql.prepare()
+ tdSql.execute('reset query cache')
+ tdSql.execute('drop database if exists test')
+ tdSql.execute('drop database if exists db')
+ tdSql.execute('drop database if exists des')
+ tdSql.execute('create database test')
+ tdSql.execute('create database des')
+ header = {'Authorization': 'Basic cm9vdDp0YW9zZGF0YQ=='}
+ url = "http://127.0.0.1:6041/rest/sql/"
+
+ # test with no bind databases
+
+ sqls = ["show databases;",
+ "use test",
+ "show tables;",
+ "show dnodes;",
+ "show vgroups;",
+ "create database db;",
+ "drop database db;",
+ "select client_version();" ,
+ "use test",
+ "ALTER DATABASE test COMP 2;",
+ "create table tb (ts timestamp, id int , data double)",
+ "insert into tb values (now , 1, 1.0) ",
+ "select * from tb",
+ "show test.tables",
+ "show tables",
+ "insert into tb values (now , 2, 2.0) ",
+ "create table test.tb (ts timestamp, id int , data double)",
+ "insert into test.tb values (now , 3, 3.0) ",
+ "select * from tb",
+ "select * from test.tb",
+ "create table des.tb (ts timestamp, id int , data double)",
+ "insert into des.tb values (now , 3, 3.0)"]
+ for sql in sqls:
+ print("===================")
+ if sql == "create table test.tb (ts timestamp, id int , data double)":
+ resp = requests.post(url, sql, headers = header )
+ print(resp.text)
+ print ("%s run occur error as expect ,check pass!" %(sql))
+ else:
+ check_res(url,sql,header)
+
+ tdSql.query("select * from test.tb")
+ tdSql.checkRows(3)
+ tdSql.query("select * from des.tb")
+ tdSql.checkRows(1)
+
+ print("==================="*5)
+ print(" check bind db about restful ")
+ print("==================="*5)
+
+ tdSql.execute('reset query cache')
+ tdSql.execute('drop database if exists test')
+ tdSql.execute('drop database if exists db')
+ tdSql.execute('drop database if exists des')
+ tdSql.execute('create database test')
+ tdSql.execute('create database des')
+
+ url = "http://127.0.0.1:6041/rest/sql/des"
+ for sql in sqls:
+ print("===================")
+ if sql in ["create table des.tb (ts timestamp, id int , data double)"]:
+ resp = requests.post(url, sql, headers = header )
+ print(resp.text)
+ print ("%s run occur error as expect ,check pass!" %(sql))
+ else:
+ check_res(url,sql,header)
+ # check data
+ tdSql.query("select * from test.tb")
+ tdSql.checkRows(1)
+ tdSql.query("select * from des.tb")
+ tdSql.checkRows(3)
+
+ os.system('sudo timedatectl set-ntp on')
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/tag_lite/TestModifyTag.py b/tests/pytest/tag_lite/TestModifyTag.py
new file mode 100644
index 0000000000000000000000000000000000000000..acf63695f6dcc52d2ae9df8cdead96802cd1f4b3
--- /dev/null
+++ b/tests/pytest/tag_lite/TestModifyTag.py
@@ -0,0 +1,125 @@
+###################################################################
+# Copyright (c) 2016 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import os
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+
+ self.ts = 1625068800000000000 # this is timestamp "2021-07-01 00:00:00"
+ self.numberOfTables = 10
+ self.numberOfRecords = 100
+
+ def checkCommunity(self):
+ selfPath = os.path.dirname(os.path.realpath(__file__))
+ if ("community" in selfPath):
+ return False
+ else:
+ return True
+
+ def getBuildPath(self):
+ selfPath = os.path.dirname(os.path.realpath(__file__))
+
+ if ("community" in selfPath):
+ projPath = selfPath[:selfPath.find("community")]
+ else:
+ projPath = selfPath[:selfPath.find("tests")]
+
+ for root, dirs, files in os.walk(projPath):
+ if ("taosdump" in files):
+ rootRealPath = os.path.dirname(os.path.realpath(root))
+ if ("packaging" not in rootRealPath):
+ buildPath = root[:len(root) - len("/build/bin")]
+ break
+ return buildPath
+
+
+
+ def run(self):
+
+ buildPath = self.getBuildPath()
+ if (buildPath == ""):
+ tdLog.exit("taosdump not found!")
+ else:
+ tdLog.info("taosdump found in %s" % buildPath)
+ binPath = buildPath + "/build/bin/"
+
+ # basic test for alter tags
+ tdSql.execute("create database tagdb ")
+ tdSql.execute(" use tagdb")
+ tdSql.execute("create table st (ts timestamp , a int) tags (tg1 binary(20), tg2 binary(20), tg3 binary(20))")
+ tdSql.execute("insert into t using st (tg3, tg2, tg1) tags ('tg3', 'tg2', 'tg1') values (now, 1)")
+ tdSql.execute("alter table t set tag tg1='newtg1'")
+ res = tdSql.getResult("select tg1,tg2,tg3 from t")
+
+ if res == [('newtg1', 'tg2', 'tg3')]:
+ tdLog.info(" alter tag check has pass!")
+ else:
+ tdLog.info(" alter tag failed , please check !")
+
+ tdSql.error("alter stable st modify tag tg2 binary(2)")
+ tdSql.execute("alter stable st modify tag tg2 binary(30) ")
+ tdSql.execute("alter table t set tag tg2 = 'abcdefghijklmnopqrstuvwxyz1234'")
+ res = tdSql.getResult("select tg1,tg2,tg3 from t")
+ if res == [('newtg1', 'abcdefghijklmnopqrstuvwxyz1234', 'tg3')]:
+ tdLog.info(" alter tag check has pass!")
+ else:
+ tdLog.info(" alter tag failed , please check !")
+
+ # test boundary about tags
+ tdSql.execute("create stable stb1 (ts timestamp , a int) tags (tg1 binary(16374))")
+ tdSql.error("create stable stb1 (ts timestamp , a int) tags (tg1 binary(16375))")
+ bound_sql = "create stable stb2 (ts timestamp , a int) tags (tg1 binary(10),"
+ for i in range(127):
+ bound_sql+="tag"+str(i)+" binary(10),"
+ sql1 = bound_sql[:-1]+")"
+ tdSql.execute(sql1)
+ sql2 = bound_sql[:-1]+"tag127 binary(10))"
+ tdSql.error(sql2)
+ tdSql.execute("create stable stb3 (ts timestamp , a int) tags (tg1 nchar(4093))")
+ tdSql.error("create stable stb3 (ts timestamp , a int) tags (tg1 nchar(4094))")
+ tdSql.execute("create stable stb4 (ts timestamp , a int) tags (tg1 nchar(4093),tag2 binary(8))")
+ tdSql.error("create stable stb4 (ts timestamp , a int) tags (tg1 nchar(4093),tag2 binary(9))")
+ tdSql.execute("create stable stb5 (ts timestamp , a int) tags (tg1 nchar(4093),tag2 binary(4),tag3 binary(2))")
+ tdSql.error("create stable stb5 (ts timestamp , a int) tags (tg1 nchar(4093),tag2 binary(4),tag3 binary(3))")
+
+ tdSql.execute("create table stt (ts timestamp , a binary(100)) tags (tg1 binary(20), tg2 binary(20), tg3 binary(20))")
+ tdSql.execute("insert into tt using stt (tg3, tg2, tg1) tags ('tg3', 'tg2', 'tg1') values (now, 1)")
+ tags = "t"*16337
+ sql3 = "alter table tt set tag tg1=" +"'"+tags+"'"
+ tdSql.error(sql3)
+ tdSql.execute("alter stable stt modify tag tg1 binary(16337)")
+ tdSql.execute(sql3)
+ res = tdSql.getResult("select tg1,tg2,tg3 from tt")
+ if res == [(tags, 'tg2', 'tg3')]:
+ tdLog.info(" alter tag check has pass!")
+ else:
+ tdLog.info(" alter tag failed , please check !")
+
+ os.system("rm -rf ./tag_lite/TestModifyTag.py.sql")
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file
diff --git a/tests/pytest/test.py b/tests/pytest/test.py
index 65abd3ef93555b6747f022595b20c5989aa851cb..97dca6be1811ee87a31661e018616f469d5fd4ca 100644
--- a/tests/pytest/test.py
+++ b/tests/pytest/test.py
@@ -87,7 +87,7 @@ if __name__ == "__main__":
else:
toBeKilled = "valgrind.bin"
- killCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}' | xargs kill -HUP > /dev/null 2>&1" % toBeKilled
+ killCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}' | xargs kill -TERM > /dev/null 2>&1" % toBeKilled
psCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}'" % toBeKilled
processID = subprocess.check_output(psCmd, shell=True)
@@ -110,7 +110,6 @@ if __name__ == "__main__":
time.sleep(2)
tdLog.info('stop All dnodes')
- sys.exit(0)
tdDnodes.init(deployPath)
tdDnodes.setTestCluster(testCluster)
diff --git a/tests/pytest/tools/schemalessInsertPerformance.py b/tests/pytest/tools/schemalessInsertPerformance.py
new file mode 100644
index 0000000000000000000000000000000000000000..14a9a21081dd96b8a48a5010f24abfcccec03b57
--- /dev/null
+++ b/tests/pytest/tools/schemalessInsertPerformance.py
@@ -0,0 +1,269 @@
+###################################################################
+# Copyright (c) 2021 by TAOS Technologies, Inc.
+# All rights reserved.
+#
+# This file is proprietary and confidential to TAOS Technologies.
+# No part of this file may be reproduced, stored, transmitted,
+# disclosed or used in any form or by any means other than as
+# expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import random
+import time
+from copy import deepcopy
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.common import tdCom
+import threading
+import itertools
+class TDTestCase:
+ def init(self, conn, logSql):
+ tdLog.debug("start to execute %s" % __file__)
+ tdSql.init(conn.cursor(), logSql)
+ self._conn = conn
+ self.lock = threading.Lock()
+
+ def genMultiColStr(self, int_count=4, double_count=0, binary_count=0):
+ '''
+ related to self.getPerfSql()
+ :count = 4 ---> 4 int
+ :count = 1000 ---> 400 int 400 double 200 binary(128)
+ :count = 4000 ---> 1900 int 1900 double 200 binary(128)
+ '''
+ col_str = ""
+ if double_count == 0 and binary_count == 0:
+ for i in range(0, int_count):
+ if i < (int_count-1):
+ col_str += f'c{i}={random.randint(0, 255)}i32,'
+ else:
+ col_str += f'c{i}={random.randint(0, 255)}i32 '
+ elif double_count > 0 and binary_count == 0:
+ for i in range(0, int_count):
+ col_str += f'c{i}={random.randint(0, 255)}i32,'
+ for i in range(0, double_count):
+ if i < (double_count-1):
+ col_str += f'c{i+int_count}={random.randint(1, 255)}.{i}f64,'
+ else:
+ col_str += f'c{i+int_count}={random.randint(1, 255)}.{i}f64 '
+ elif double_count == 0 and binary_count > 0:
+ for i in range(0, int_count):
+ col_str += f'c{i}={random.randint(0, 255)}i32,'
+ for i in range(0, binary_count):
+ if i < (binary_count-1):
+ col_str += f'c{i+int_count}=\"{tdCom.getLongName(5, "letters")}\",'
+ else:
+ col_str += f'c{i+int_count}=\"{tdCom.getLongName(5, "letters")}\" '
+ elif double_count > 0 and binary_count > 0:
+ for i in range(0, int_count):
+ col_str += f'c{i}={random.randint(0, 255)}i32,'
+ for i in range(0, double_count):
+ col_str += f'c{i+int_count}={random.randint(1, 255)}.{i}f64,'
+ for i in range(0, binary_count):
+ if i < (binary_count-1):
+ col_str += f'c{i+int_count+double_count}=\"{tdCom.getLongName(5, "letters")}\",'
+ else:
+ col_str += f'c{i+int_count+double_count}=\"{tdCom.getLongName(5, "letters")}\" '
+ return col_str
+
+ def genLongSql(self, int_count=4, double_count=0, binary_count=0, init=False):
+ '''
+ :init ---> stb insert line
+ '''
+ if init:
+ tag_str = f'id="init",t0={random.randint(0, 65535)}i32,t1=\"{tdCom.getLongName(10, "letters")}\"'
+ else:
+ tag_str = f'id="sub_{tdCom.getLongName(5, "letters")}_{tdCom.getLongName(5, "letters")}",t0={random.randint(0, 65535)}i32,t1=\"{tdCom.getLongName(10, "letters")}\"'
+ col_str = self.genMultiColStr(int_count=int_count, double_count=double_count, binary_count=binary_count)
+ long_sql = 'stb' + ',' + tag_str + ' ' + col_str + '0'
+ return long_sql
+
+ def getPerfSql(self, count=4, init=False):
+ '''
+ :count = 4 ---> 4 int
+ :count = 1000 ---> 400 int 400 double 200 binary(128)
+ :count = 4000 ---> 1900 int 1900 double 200 binary(128)
+ '''
+ if count == 4:
+ input_sql = self.genLongSql(init=init)
+ elif count == 1000:
+ input_sql = self.genLongSql(400, 400, 200, init=init)
+ elif count == 4000:
+ input_sql = self.genLongSql(1900, 1900, 200, init=init)
+ return input_sql
+
+ def replaceLastStr(self, str, new):
+ '''
+ replace last element of str to new element
+ '''
+ list_ori = list(str)
+ list_ori[-1] = new
+ return ''.join(list_ori)
+
+ def createStb(self, count=4):
+ '''
+ create 1 stb
+ '''
+ input_sql = self.getPerfSql(count=count, init=True)
+ print(threading.current_thread().name, "create stb line:", input_sql)
+ self._conn.insert_lines([input_sql])
+ print(threading.current_thread().name, "create stb end")
+
+ def batchCreateTable(self, batch_list):
+ '''
+ schemaless insert api
+ '''
+ print(threading.current_thread().name, "length=", len(batch_list))
+ print(threading.current_thread().name, 'firstline', batch_list[0][0:50], '...', batch_list[0][-50:-1])
+ print(threading.current_thread().name, 'lastline:', batch_list[-1][0:50], '...', batch_list[-1][-50:-1])
+ begin = time.time_ns();
+ self._conn.insert_lines(batch_list)
+ end = time.time_ns();
+ print(threading.current_thread().name, 'end time:', (end-begin)/10**9)
+
+ def splitGenerator(self, table_list, thread_count):
+ '''
+ split a list to n piece of sub_list
+ [a, b, c, d] ---> [[a, b], [c, d]]
+ yield type ---> generator
+ '''
+ sub_list_len = int(len(table_list)/thread_count)
+ for i in range(0, len(table_list), sub_list_len):
+ yield table_list[i:i + sub_list_len]
+
+ def genTbListGenerator(self, table_list, thread_count):
+ '''
+ split table_list, after split
+ '''
+ table_list_generator = self.splitGenerator(table_list, thread_count)
+ return table_list_generator
+
+ def genTableList(self, count=4, table_count=10000):
+ '''
+ gen len(table_count) table_list
+ '''
+ table_list = list()
+ for i in range(table_count):
+ table_list.append(self.getPerfSql(count=count))
+ return table_list
+
+ def threadCreateTables(self, table_list_generator, thread_count=10):
+ '''
+ thread create tables
+ '''
+ threads = list()
+ for i in range(thread_count):
+ t = threading.Thread(target=self.batchCreateTable, args=(next(table_list_generator),))
+ threads.append(t)
+ return threads
+
+ def batchInsertRows(self, table_list, rows_count):
+ '''
+ add rows in each table ---> count=rows_count
+ '''
+ for input_sql in table_list:
+ ts = int(time.time())
+ input_sql_list = list()
+ for i in range(rows_count-1):
+ ts -= 1
+ elm_new = self.replaceLastStr(input_sql, str(ts)) + 's'
+ input_sql_list.append(elm_new)
+ self.batchCreateTable(input_sql_list)
+
+ def threadsInsertRows(self, rows_generator, rows_count=1000, thread_count=10):
+ '''
+ multi insert rows in each table
+ '''
+ threads = list()
+ for i in range(thread_count):
+ self.lock.acquire()
+ t = threading.Thread(target=self.batchInsertRows, args=(next(rows_generator), rows_count,))
+ threads.append(t)
+ self.lock.release()
+ return threads
+
+ def multiThreadRun(self, threads):
+ '''
+ multi run threads
+ '''
+ for t in threads:
+ t.start()
+ for t in threads:
+ t.join()
+
+ def createTables(self, count, table_count=10000, thread_count=10):
+ '''
+ create stb and tb
+ '''
+ table_list = self.genTableList(count=count, table_count=table_count)
+ create_tables_start_time = time.time()
+ self.createStb(count=count)
+ table_list_generator = self.genTbListGenerator(table_list, thread_count)
+ create_tables_generator, insert_rows_generator = itertools.tee(table_list_generator, 2)
+ self.multiThreadRun(self.threadCreateTables(table_list_generator=create_tables_generator, thread_count=thread_count))
+ create_tables_end_time = time.time()
+ create_tables_time = int(create_tables_end_time - create_tables_start_time)
+ return_str = f'create tables\' time of {count} columns ---> {create_tables_time}s'
+ return insert_rows_generator, create_tables_time, return_str
+
+ def insertRows(self, count, rows_generator, rows_count=1000, thread_count=10):
+ '''
+ insert rows
+ '''
+ insert_rows_start_time = time.time()
+ self.multiThreadRun(self.threadsInsertRows(rows_generator=rows_generator, rows_count=rows_count, thread_count=thread_count))
+ insert_rows_end_time = time.time()
+ insert_rows_time = int(insert_rows_end_time - insert_rows_start_time)
+ return_str = f'insert rows\' time of {count} columns ---> {insert_rows_time}s'
+ return insert_rows_time, return_str
+
+ def schemalessPerfTest(self, count, table_count=10000, thread_count=10, rows_count=1000):
+ '''
+ get performance
+ '''
+ insert_rows_generator = self.createTables(count=count, table_count=table_count, thread_count=thread_count)[0]
+ return self.insertRows(count=count, rows_generator=insert_rows_generator, rows_count=rows_count, thread_count=thread_count)
+
+ def getPerfResults(self, test_times=3, table_count=10000, thread_count=10):
+ col4_time = 0
+ col1000_time = 0
+ col4000_time = 0
+
+ for i in range(test_times):
+ tdCom.cleanTb()
+ time_used = self.schemalessPerfTest(count=4, table_count=table_count, thread_count=thread_count)[0]
+ col4_time += time_used
+ col4_time /= test_times
+ print(col4_time)
+
+ # for i in range(test_times):
+ # tdCom.cleanTb()
+ # time_used = self.schemalessPerfTest(count=1000, table_count=table_count, thread_count=thread_count)[0]
+ # col1000_time += time_used
+ # col1000_time /= test_times
+ # print(col1000_time)
+
+ # for i in range(test_times):
+ # tdCom.cleanTb()
+ # time_used = self.schemalessPerfTest(count=4000, table_count=table_count, thread_count=thread_count)[0]
+ # col4000_time += time_used
+ # col4000_time /= test_times
+ # print(col4000_time)
+
+ return col4_time, col1000_time, col4000_time
+
+ def run(self):
+ print("running {}".format(__file__))
+ tdSql.prepare()
+ result = self.getPerfResults(test_times=1, table_count=1000, thread_count=10)
+ print(result)
+
+ def stop(self):
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
diff --git a/tests/pytest/tools/taosdemoPerformance.py b/tests/pytest/tools/taosdemoPerformance.py
index 4a5abd49d86ff8af3881965c05a72746b262a1c8..51b064a08e5cd55401f9cf803a8683653f722679 100644
--- a/tests/pytest/tools/taosdemoPerformance.py
+++ b/tests/pytest/tools/taosdemoPerformance.py
@@ -49,24 +49,18 @@ class taosdemoPerformace:
def generateJson(self):
db = {
"name": "%s" % self.insertDB,
- "drop": "yes",
- "replica": 1
+ "drop": "yes"
}
stb = {
"name": "meters",
- "child_table_exists": "no",
"childtable_count": self.numOfTables,
"childtable_prefix": "stb_",
- "auto_create_table": "no",
- "data_source": "rand",
"batch_create_tbl_num": 10,
- "insert_mode": "taosc",
+ "insert_mode": "rand",
"insert_rows": self.numOfRows,
- "interlace_rows": 0,
- "max_sql_len": 1024000,
- "disorder_ratio": 0,
- "disorder_range": 1000,
+ "batch_rows": 1000000,
+ "max_sql_len": 1048576,
"timestamp_step": 1,
"start_timestamp": "2020-10-01 00:00:00.000",
"sample_format": "csv",
@@ -100,11 +94,8 @@ class taosdemoPerformace:
"user": "root",
"password": "taosdata",
"thread_count": 10,
- "thread_count_create_tbl": 10,
+ "thread_count_create_tbl": 4,
"result_file": "./insert_res.txt",
- "confirm_parameter_prompt": "no",
- "insert_interval": 0,
- "num_of_records_per_req": 30000,
"databases": [db]
}
@@ -145,26 +136,26 @@ class taosdemoPerformace:
binPath = buildPath + "/build/bin/"
os.system(
- "%staosdemo -f %s > taosdemoperf.txt 2>&1" %
+ "%sperfMonitor -f %s > /dev/null 2>&1" %
(binPath, self.generateJson()))
self.createTableTime = self.getCMDOutput(
- "grep 'Spent' taosdemoperf.txt | awk 'NR==1{print $2}'")
+ "grep 'Spent' insert_res.txt | awk 'NR==1{print $2}'")
self.insertRecordsTime = self.getCMDOutput(
- "grep 'Spent' taosdemoperf.txt | awk 'NR==2{print $2}'")
+ "grep 'Spent' insert_res.txt | awk 'NR==2{print $2}'")
self.recordsPerSecond = self.getCMDOutput(
- "grep 'Spent' taosdemoperf.txt | awk 'NR==2{print $16}'")
+ "grep 'Spent' insert_res.txt | awk 'NR==2{print $16}'")
self.commitID = self.getCMDOutput("git rev-parse --short HEAD")
delay = self.getCMDOutput(
- "grep 'delay' taosdemoperf.txt | awk '{print $4}'")
+ "grep 'delay' insert_res.txt | awk '{print $4}'")
self.avgDelay = delay[:-4]
delay = self.getCMDOutput(
- "grep 'delay' taosdemoperf.txt | awk '{print $6}'")
+ "grep 'delay' insert_res.txt | awk '{print $6}'")
self.maxDelay = delay[:-4]
delay = self.getCMDOutput(
- "grep 'delay' taosdemoperf.txt | awk '{print $8}'")
+ "grep 'delay' insert_res.txt | awk '{print $8}'")
self.minDelay = delay[:-3]
- os.system("[ -f taosdemoperf.txt ] && rm taosdemoperf.txt")
+ os.system("[ -f insert_res.txt ] && rm insert_res.txt")
def createTablesAndStoreData(self):
cursor = self.conn2.cursor()
@@ -185,7 +176,7 @@ class taosdemoPerformace:
cursor.close()
cursor1 = self.conn.cursor()
- # cursor1.execute("drop database if exists %s" % self.insertDB)
+ cursor1.execute("drop database if exists %s" % self.insertDB)
cursor1.close()
if __name__ == '__main__':
diff --git a/tests/pytest/util/common.py b/tests/pytest/util/common.py
index 1c7d94a8a4c8cd454d41c6d4d4d89b8377ec88b7..35abc4802f9de2080a6b6a166daf833c9cf04578 100644
--- a/tests/pytest/util/common.py
+++ b/tests/pytest/util/common.py
@@ -1,4 +1,4 @@
-###################################################################
+###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved.
#
@@ -50,4 +50,4 @@ class TDCom:
def close(self):
self.cursor.close()
-tdCom = TDCom()
\ No newline at end of file
+tdCom = TDCom()
diff --git a/tests/pytest/util/dnodes.py b/tests/pytest/util/dnodes.py
index ae4ba97eb3d6c9d9530d9f218bf05dd25aff3b02..cd720ab62d4d71661a214ef24df8df81164fd71b 100644
--- a/tests/pytest/util/dnodes.py
+++ b/tests/pytest/util/dnodes.py
@@ -125,7 +125,7 @@ class TDDnode:
"charset":"UTF-8",
"asyncLog":"0",
"anyIp":"0",
- "tsEnableTelemetryReporting":"0",
+ "telemetryReporting":"0",
"dDebugFlag":"135",
"tsdbDebugFlag":"135",
"mDebugFlag":"135",
@@ -436,7 +436,7 @@ class TDDnodes:
psCmd = "ps -ef|grep -w taosd| grep -v grep| grep -v defunct | awk '{print $2}'"
processID = subprocess.check_output(psCmd, shell=True).decode("utf-8")
while(processID):
- killCmd = "kill -TERM %s > /dev/null 2>&1" % processID
+ killCmd = "kill -9 %s > /dev/null 2>&1" % processID
os.system(killCmd)
time.sleep(1)
processID = subprocess.check_output(
@@ -445,7 +445,7 @@ class TDDnodes:
psCmd = "ps -ef|grep -w valgrind.bin| grep -v grep | awk '{print $2}'"
processID = subprocess.check_output(psCmd, shell=True).decode("utf-8")
while(processID):
- killCmd = "kill -TERM %s > /dev/null 2>&1" % processID
+ killCmd = "kill -9 %s > /dev/null 2>&1" % processID
os.system(killCmd)
time.sleep(1)
processID = subprocess.check_output(
@@ -556,7 +556,7 @@ class TDDnodes:
psCmd = "ps -ef|grep -w taosd| grep -v grep| grep -v defunct | awk '{print $2}'"
processID = subprocess.check_output(psCmd, shell=True).decode("utf-8")
while(processID):
- killCmd = "kill -TERM %s > /dev/null 2>&1" % processID
+ killCmd = "kill -9 %s > /dev/null 2>&1" % processID
os.system(killCmd)
time.sleep(1)
processID = subprocess.check_output(
diff --git a/tests/pytest/util/sql.py b/tests/pytest/util/sql.py
index b42af27d063aa9c8b08ac58374878a7153912142..2b654a379369c67cf906be0dde2f0cc4a309e1ea 100644
--- a/tests/pytest/util/sql.py
+++ b/tests/pytest/util/sql.py
@@ -21,7 +21,15 @@ import shutil
import pandas as pd
from util.log import *
-
+def _parse_datetime(timestr):
+ try:
+ return datetime.datetime.strptime(timestr, '%Y-%m-%d %H:%M:%S.%f')
+ except ValueError:
+ pass
+ try:
+ return datetime.datetime.strptime(timestr, '%Y-%m-%d %H:%M:%S')
+ except ValueError:
+ pass
class TDSql:
def __init__(self):
@@ -81,6 +89,22 @@ class TDSql:
return self.queryResult
return self.queryRows
+ def getVariable(self, search_attr):
+ '''
+ get variable of search_attr access "show variables"
+ '''
+ try:
+ sql = 'show variables'
+ param_list = self.query(sql, row_tag=True)
+ for param in param_list:
+ if param[0] == search_attr:
+ return param[1], param_list
+ except Exception as e:
+ caller = inspect.getframeinfo(inspect.stack()[1][0])
+ args = (caller.filename, caller.lineno, sql, repr(e))
+ tdLog.notice("%s(%d) failed: sql:%s, %s" % args)
+ raise Exception(repr(e))
+
def getColNameList(self, sql, col_tag=None):
self.sql = sql
try:
@@ -165,7 +189,7 @@ class TDSql:
tdLog.info("sql:%s, row:%d col:%d data:%d == expect:%s" %
(self.sql, row, col, self.queryResult[row][col], data))
else:
- if self.queryResult[row][col] == datetime.datetime.fromisoformat(data):
+ if self.queryResult[row][col] == _parse_datetime(data):
tdLog.info("sql:%s, row:%d col:%d data:%s == expect:%s" %
(self.sql, row, col, self.queryResult[row][col], data))
return
diff --git a/tests/pytest/util/sub.py b/tests/pytest/util/sub.py
index 2e3c2a96b7312c176c25bd35e109e146e5c4593f..664d830b86290e81e8ac1726f92193380d8c7715 100644
--- a/tests/pytest/util/sub.py
+++ b/tests/pytest/util/sub.py
@@ -29,9 +29,10 @@ class TDSub:
self.sub.close(keepProgress)
def consume(self):
- self.data = self.sub.consume()
- self.consumedRows = len(self.data)
- self.consumedCols = len(self.sub.fields)
+ self.result = self.sub.consume()
+ self.result.fetch_all()
+ self.consumedRows = self.result.row_count
+ self.consumedCols = self.result.field_count
return self.consumedRows
def checkRows(self, expectRows):
diff --git a/tests/script/api/makefile b/tests/script/api/makefile
index 7595594cbf2572623dd18648c8c4fa8e65dd966a..0357b284549558e5ea27ff7c3296c37285d92cd5 100644
--- a/tests/script/api/makefile
+++ b/tests/script/api/makefile
@@ -6,7 +6,8 @@ TARGET=exe
LFLAGS = '-Wl,-rpath,/usr/local/taos/driver/' -ltaos -lpthread -lm -lrt
CFLAGS = -O0 -g -Wall -Wno-deprecated -fPIC -Wno-unused-result -Wconversion \
-Wno-char-subscripts -D_REENTRANT -Wno-format -D_REENTRANT -DLINUX \
- -Wno-unused-function -D_M_X64 -I/usr/local/taos/include -std=gnu99
+ -Wno-unused-function -D_M_X64 -I/usr/local/taos/include -std=gnu99 \
+ -fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment
all: $(TARGET)
@@ -14,8 +15,10 @@ exe:
gcc $(CFLAGS) ./batchprepare.c -o $(ROOT)batchprepare $(LFLAGS)
gcc $(CFLAGS) ./stmtBatchTest.c -o $(ROOT)stmtBatchTest $(LFLAGS)
gcc $(CFLAGS) ./stmtTest.c -o $(ROOT)stmtTest $(LFLAGS)
+ gcc $(CFLAGS) ./stmt.c -o $(ROOT)stmt $(LFLAGS)
clean:
rm $(ROOT)batchprepare
rm $(ROOT)stmtBatchTest
rm $(ROOT)stmtTest
+ rm $(ROOT)stmt
diff --git a/tests/script/api/stmt.c b/tests/script/api/stmt.c
new file mode 100644
index 0000000000000000000000000000000000000000..baf40c1421df1de4afcc8570288f642df067130a
--- /dev/null
+++ b/tests/script/api/stmt.c
@@ -0,0 +1,545 @@
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include "taos.h"
+
+void execute_simple_sql(void *taos, char *sql) {
+ TAOS_RES *result = taos_query(taos, sql);
+ if (result == NULL || taos_errno(result) != 0) {
+ printf("failed to %s, Reason: %s\n", sql, taos_errstr(result));
+ taos_free_result(result);
+ exit(EXIT_FAILURE);
+ }
+ taos_free_result(result);
+}
+
+void print_result(TAOS_RES *res) {
+ if (res == NULL) {
+ exit(EXIT_FAILURE);
+ }
+ TAOS_ROW row = NULL;
+ int num_fields = taos_num_fields(res);
+ TAOS_FIELD *fields = taos_fetch_fields(res);
+ while ((row = taos_fetch_row(res))) {
+ char temp[256] = {0};
+ taos_print_row(temp, row, fields, num_fields);
+ printf("get result: %s\n", temp);
+ }
+}
+
+void taos_stmt_init_test() {
+ printf("start taos_stmt_init test \n");
+ void * taos = NULL;
+ TAOS_STMT *stmt = NULL;
+ stmt = taos_stmt_init(taos);
+ assert(stmt == NULL);
+ // ASM ERROR
+ assert(taos_stmt_close(stmt) != 0);
+ taos = taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+ if (taos == NULL) {
+ printf("Cannot connect to tdengine server\n");
+ exit(EXIT_FAILURE);
+ }
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ assert(taos_stmt_close(stmt) == 0);
+ printf("finish taos_stmt_init test\n");
+}
+void taos_stmt_preprare_test() {
+ printf("start taos_stmt_prepare test\n");
+ char * stmt_sql = calloc(1, 1048576);
+ TAOS_STMT *stmt = NULL;
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) != 0);
+ void *taos = NULL;
+ taos = taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+ if (taos == NULL) {
+ printf("Cannot connect to tdengine server\n");
+ exit(EXIT_FAILURE);
+ }
+ execute_simple_sql(taos, "drop database if exists stmt_test");
+ execute_simple_sql(taos, "create database stmt_test");
+ execute_simple_sql(taos, "use stmt_test");
+ execute_simple_sql(taos,
+ "create table super(ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 binary(8), c6 "
+ "smallint, c7 tinyint, c8 bool, c9 nchar(8), c10 timestamp) tags (t1 int, t2 bigint, t3 float, t4 "
+ "double, t5 binary(8), t6 smallint, t7 tinyint, t8 bool, t9 nchar(8))");
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ // below will make client dead lock
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+
+ assert(taos_stmt_close(stmt) == 0);
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ sprintf(stmt_sql, "select from ?");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ assert(taos_stmt_close(stmt) == 0);
+
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ sprintf(stmt_sql, "insert into ? values (?,?,?,?,?,?,?,?,?,?,?)");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ assert(taos_stmt_close(stmt) == 0);
+
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ sprintf(stmt_sql, "insert into super values (?,?,?,?,?,?,?,?,?,?,?)");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) != 0);
+ assert(taos_stmt_close(stmt) == 0);
+
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ sprintf(stmt_sql, "insert into ? values (?,?,?,?,?,?,?,?,1,?,?,?)");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ assert(taos_stmt_close(stmt) == 0);
+
+ free(stmt_sql);
+ printf("finish taos_stmt_prepare test\n");
+}
+
+void taos_stmt_set_tbname_test() {
+ printf("start taos_stmt_set_tbname test\n");
+ TAOS_STMT *stmt = NULL;
+ char * name = calloc(1, 200);
+ // ASM ERROR
+ assert(taos_stmt_set_tbname(stmt, name) != 0);
+ void *taos = taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+ if (taos == NULL) {
+ printf("Cannot connect to tdengine server\n");
+ exit(EXIT_FAILURE);
+ }
+ execute_simple_sql(taos, "drop database if exists stmt_test");
+ execute_simple_sql(taos, "create database stmt_test");
+ execute_simple_sql(taos, "use stmt_test");
+ execute_simple_sql(taos, "create table super(ts timestamp, c1 int)");
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ assert(taos_stmt_set_tbname(stmt, name) != 0);
+ char *stmt_sql = calloc(1, 1000);
+ sprintf(stmt_sql, "insert into ? values (?,?)");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ sprintf(name, "super");
+ assert(stmt != NULL);
+ assert(taos_stmt_set_tbname(stmt, name) == 0);
+ free(name);
+ free(stmt_sql);
+ taos_stmt_close(stmt);
+ printf("finish taos_stmt_set_tbname test\n");
+}
+
+void taos_stmt_set_tbname_tags_test() {
+ printf("start taos_stmt_set_tbname_tags test\n");
+ TAOS_STMT *stmt = NULL;
+ char * name = calloc(1, 20);
+ TAOS_BIND *tags = calloc(1, sizeof(TAOS_BIND));
+ // ASM ERROR
+ assert(taos_stmt_set_tbname_tags(stmt, name, tags) != 0);
+ void *taos = taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+ if (taos == NULL) {
+ printf("Cannot connect to tdengine server\n");
+ exit(EXIT_FAILURE);
+ }
+ execute_simple_sql(taos, "drop database if exists stmt_test");
+ execute_simple_sql(taos, "create database stmt_test");
+ execute_simple_sql(taos, "use stmt_test");
+ execute_simple_sql(taos, "create stable super(ts timestamp, c1 int) tags (id int)");
+ execute_simple_sql(taos, "create table tb using super tags (1)");
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ char *stmt_sql = calloc(1, 1000);
+ sprintf(stmt_sql, "insert into ? using super tags (?) values (?,?)");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ assert(taos_stmt_set_tbname_tags(stmt, name, tags) != 0);
+ sprintf(name, "tb");
+ assert(taos_stmt_set_tbname_tags(stmt, name, tags) != 0);
+ int t = 1;
+ tags->buffer_length = TSDB_DATA_TYPE_INT;
+ tags->buffer_length = sizeof(uint32_t);
+ tags->buffer = &t;
+ tags->length = &tags->buffer_length;
+ tags->is_null = NULL;
+ assert(taos_stmt_set_tbname_tags(stmt, name, tags) == 0);
+ free(stmt_sql);
+ free(name);
+ free(tags);
+ taos_stmt_close(stmt);
+ printf("finish taos_stmt_set_tbname_tags test\n");
+}
+
+void taos_stmt_set_sub_tbname_test() {
+ printf("start taos_stmt_set_sub_tbname test\n");
+ TAOS_STMT *stmt = NULL;
+ char * name = calloc(1, 200);
+ // ASM ERROR
+ assert(taos_stmt_set_sub_tbname(stmt, name) != 0);
+ void *taos = taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+ if (taos == NULL) {
+ printf("Cannot connect to tdengine server\n");
+ exit(EXIT_FAILURE);
+ }
+ execute_simple_sql(taos, "drop database if exists stmt_test");
+ execute_simple_sql(taos, "create database stmt_test");
+ execute_simple_sql(taos, "use stmt_test");
+ execute_simple_sql(taos, "create stable super(ts timestamp, c1 int) tags (id int)");
+ execute_simple_sql(taos, "create table tb using super tags (1)");
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ char *stmt_sql = calloc(1, 1000);
+ sprintf(stmt_sql, "insert into ? values (?,?)");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ assert(taos_stmt_set_sub_tbname(stmt, name) != 0);
+ sprintf(name, "tb");
+ assert(taos_stmt_set_sub_tbname(stmt, name) == 0);
+ assert(taos_load_table_info(taos, "super, tb") == 0);
+ assert(taos_stmt_set_sub_tbname(stmt, name) == 0);
+ free(name);
+ free(stmt_sql);
+ assert(taos_stmt_close(stmt) == 0);
+ printf("finish taos_stmt_set_sub_tbname test\n");
+}
+
+void taos_stmt_bind_param_test() {
+ printf("start taos_stmt_bind_param test\n");
+ TAOS_STMT *stmt = NULL;
+ TAOS_BIND *binds = NULL;
+ assert(taos_stmt_bind_param(stmt, binds) != 0);
+ void *taos = taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+ if (taos == NULL) {
+ printf("Cannot connect to tdengine server\n");
+ exit(EXIT_FAILURE);
+ }
+ execute_simple_sql(taos, "drop database if exists stmt_test");
+ execute_simple_sql(taos, "create database stmt_test");
+ execute_simple_sql(taos, "use stmt_test");
+ execute_simple_sql(taos, "create table super(ts timestamp, c1 int)");
+ stmt = taos_stmt_init(taos);
+ char *stmt_sql = calloc(1, 1000);
+ sprintf(stmt_sql, "insert into ? values (?,?)");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ assert(taos_stmt_bind_param(stmt, binds) != 0);
+ free(binds);
+ TAOS_BIND *params = calloc(2, sizeof(TAOS_BIND));
+ int64_t ts = (int64_t)1591060628000;
+ params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+ params[0].buffer_length = sizeof(uint64_t);
+ params[0].buffer = &ts;
+ params[0].length = ¶ms[0].buffer_length;
+ params[0].is_null = NULL;
+ int32_t i = (int32_t)21474;
+ params[1].buffer_type = TSDB_DATA_TYPE_INT;
+ params[1].buffer_length = sizeof(int32_t);
+ params[1].buffer = &i;
+ params[1].length = ¶ms[1].buffer_length;
+ params[1].is_null = NULL;
+ assert(taos_stmt_bind_param(stmt, params) != 0);
+ assert(taos_stmt_set_tbname(stmt, "super") == 0);
+ assert(taos_stmt_bind_param(stmt, params) == 0);
+ free(params);
+ free(stmt_sql);
+ taos_stmt_close(stmt);
+ printf("finish taos_stmt_bind_param test\n");
+}
+
+void taos_stmt_bind_single_param_batch_test() {
+ printf("start taos_stmt_bind_single_param_batch test\n");
+ TAOS_STMT * stmt = NULL;
+ TAOS_MULTI_BIND *bind = NULL;
+ assert(taos_stmt_bind_single_param_batch(stmt, bind, 0) != 0);
+ printf("finish taos_stmt_bind_single_param_batch test\n");
+}
+
+void taos_stmt_bind_param_batch_test() {
+ printf("start taos_stmt_bind_param_batch test\n");
+ TAOS_STMT * stmt = NULL;
+ TAOS_MULTI_BIND *bind = NULL;
+ assert(taos_stmt_bind_param_batch(stmt, bind) != 0);
+ printf("finish taos_stmt_bind_param_batch test\n");
+}
+
+void taos_stmt_add_batch_test() {
+ printf("start taos_stmt_add_batch test\n");
+ TAOS_STMT *stmt = NULL;
+ assert(taos_stmt_add_batch(stmt) != 0);
+ void *taos = taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+ if (taos == NULL) {
+ printf("Cannot connect to tdengine server\n");
+ exit(EXIT_FAILURE);
+ }
+ execute_simple_sql(taos, "drop database if exists stmt_test");
+ execute_simple_sql(taos, "create database stmt_test");
+ execute_simple_sql(taos, "use stmt_test");
+ execute_simple_sql(taos, "create table super(ts timestamp, c1 int)");
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ char *stmt_sql = calloc(1, 1000);
+ sprintf(stmt_sql, "insert into ? values (?,?)");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ assert(taos_stmt_add_batch(stmt) != 0);
+ TAOS_BIND *params = calloc(2, sizeof(TAOS_BIND));
+ int64_t ts = (int64_t)1591060628000;
+ params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+ params[0].buffer_length = sizeof(uint64_t);
+ params[0].buffer = &ts;
+ params[0].length = ¶ms[0].buffer_length;
+ params[0].is_null = NULL;
+ int32_t i = (int32_t)21474;
+ params[1].buffer_type = TSDB_DATA_TYPE_INT;
+ params[1].buffer_length = sizeof(int32_t);
+ params[1].buffer = &i;
+ params[1].length = ¶ms[1].buffer_length;
+ params[1].is_null = NULL;
+ assert(taos_stmt_set_tbname(stmt, "super") == 0);
+ assert(taos_stmt_bind_param(stmt, params) == 0);
+ assert(taos_stmt_add_batch(stmt) == 0);
+ free(params);
+ free(stmt_sql);
+ assert(taos_stmt_close(stmt) == 0);
+ printf("finish taos_stmt_add_batch test\n");
+}
+
+void taos_stmt_execute_test() {
+ printf("start taos_stmt_execute test\n");
+ TAOS_STMT *stmt = NULL;
+ assert(taos_stmt_execute(stmt) != 0);
+ void *taos = taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+ if (taos == NULL) {
+ printf("Cannot connect to tdengine server\n");
+ exit(EXIT_FAILURE);
+ }
+ execute_simple_sql(taos, "drop database if exists stmt_test");
+ execute_simple_sql(taos, "create database stmt_test");
+ execute_simple_sql(taos, "use stmt_test");
+ execute_simple_sql(taos, "create table super(ts timestamp, c1 int)");
+ stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ assert(taos_stmt_execute(stmt) != 0);
+ char *stmt_sql = calloc(1, 1000);
+ sprintf(stmt_sql, "insert into ? values (?,?)");
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ assert(taos_stmt_execute(stmt) != 0);
+ TAOS_BIND *params = calloc(2, sizeof(TAOS_BIND));
+ int64_t ts = (int64_t)1591060628000;
+ params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+ params[0].buffer_length = sizeof(uint64_t);
+ params[0].buffer = &ts;
+ params[0].length = ¶ms[0].buffer_length;
+ params[0].is_null = NULL;
+ int32_t i = (int32_t)21474;
+ params[1].buffer_type = TSDB_DATA_TYPE_INT;
+ params[1].buffer_length = sizeof(int32_t);
+ params[1].buffer = &i;
+ params[1].length = ¶ms[1].buffer_length;
+ params[1].is_null = NULL;
+ assert(taos_stmt_set_tbname(stmt, "super") == 0);
+ assert(taos_stmt_execute(stmt) != 0);
+ assert(taos_stmt_bind_param(stmt, params) == 0);
+ assert(taos_stmt_execute(stmt) != 0);
+ assert(taos_stmt_add_batch(stmt) == 0);
+ assert(taos_stmt_execute(stmt) == 0);
+ free(params);
+ free(stmt_sql);
+ assert(taos_stmt_close(stmt) == 0);
+ printf("finish taos_stmt_execute test\n");
+}
+
+void taos_stmt_use_result_query(void *taos, char *col, int type) {
+ TAOS_STMT *stmt = taos_stmt_init(taos);
+ assert(stmt != NULL);
+ char *stmt_sql = calloc(1, 1024);
+ struct {
+ int64_t long_value;
+ int64_t ts_value;
+ uint64_t ulong_value;
+ int32_t int_value;
+ uint32_t uint_value;
+ int16_t small_value;
+ uint16_t usmall_value;
+ int8_t tiny_value;
+ uint8_t utiny_value;
+ float float_value;
+ double double_value;
+ char binary_value[10];
+ char nchar_value[32];
+ } v = {0};
+ v.ts_value = (int64_t)1591060628000;
+ v.long_value = (int64_t)1;
+ v.int_value = (int32_t)1;
+ v.small_value = (int16_t)1;
+ v.tiny_value = (int8_t)1;
+ v.ulong_value = (uint64_t)1;
+ v.uint_value = (uint32_t)1;
+ v.usmall_value = (uint16_t)1;
+ v.utiny_value = (uint8_t)1;
+ v.float_value = (float)1;
+ v.double_value = (double)1;
+ strcpy(v.binary_value, "abcdefgh");
+ strcpy(v.nchar_value, "一二三四五六七八");
+ uintptr_t nchar_value_len = strlen(v.nchar_value);
+ sprintf(stmt_sql, "select * from stmt_test.t1 where %s = ?", col);
+ printf("stmt_sql: %s\n", stmt_sql);
+ assert(taos_stmt_prepare(stmt, stmt_sql, 0) == 0);
+ TAOS_BIND *params = calloc(1, sizeof(TAOS_BIND));
+ params->buffer_type = type;
+ params->is_null = NULL;
+ switch (type) {
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ params->buffer_length = sizeof(v.ts_value);
+ params->buffer = &v.ts_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_INT:
+ params->buffer_length = sizeof(v.int_value);
+ params->buffer = &v.int_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_BIGINT:
+ params->buffer_length = sizeof(v.long_value);
+ params->buffer = &v.long_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_FLOAT:
+ params->buffer_length = sizeof(v.float_value);
+ params->buffer = &v.float_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_DOUBLE:
+ params->buffer_length = sizeof(v.double_value);
+ params->buffer = &v.double_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_BINARY:
+ params->buffer_length = sizeof(v.binary_value);
+ params->buffer = &v.binary_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_SMALLINT:
+ params->buffer_length = sizeof(v.small_value);
+ params->buffer = &v.small_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_TINYINT:
+ params->buffer_length = sizeof(v.tiny_value);
+ params->buffer = &v.tiny_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_BOOL:
+ params->buffer_length = sizeof(v.tiny_value);
+ params->buffer = &v.tiny_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_NCHAR:
+ params->buffer_length = sizeof(v.nchar_value);
+ params->buffer = &v.nchar_value;
+ params->length = &nchar_value_len;
+ break;
+ case TSDB_DATA_TYPE_UINT:
+ params->buffer_length = sizeof(v.uint_value);
+ params->buffer = &v.uint_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_UBIGINT:
+ params->buffer_length = sizeof(v.ulong_value);
+ params->buffer = &v.ulong_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_USMALLINT:
+ params->buffer_length = sizeof(v.usmall_value);
+ params->buffer = &v.usmall_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ case TSDB_DATA_TYPE_UTINYINT:
+ params->buffer_length = sizeof(v.utiny_value);
+ params->buffer = &v.utiny_value;
+ params->length = ¶ms->buffer_length;
+ break;
+ default:
+ printf("Cannnot find type: %d\n", type);
+ break;
+ }
+ assert(taos_stmt_bind_param(stmt, params) == 0);
+ assert(taos_stmt_execute(stmt) == 0);
+ TAOS_RES *result = taos_stmt_use_result(stmt);
+ assert(result != NULL);
+ print_result(result);
+ taos_free_result(result);
+ assert(taos_stmt_close(stmt) == 0);
+ free(params);
+ free(stmt_sql);
+}
+
+void taos_stmt_use_result_test() {
+ printf("start taos_stmt_use_result test\n");
+ void *taos = taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+ if (taos == NULL) {
+ printf("Cannot connect to tdengine server\n");
+ exit(EXIT_FAILURE);
+ }
+ execute_simple_sql(taos, "drop database if exists stmt_test");
+ execute_simple_sql(taos, "create database stmt_test");
+ execute_simple_sql(taos, "use stmt_test");
+ execute_simple_sql(
+ taos,
+ "create table super(ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 binary(8), c6 smallint, c7 tinyint, "
+ "c8 bool, c9 nchar(8), c10 timestamp, c11 int unsigned, c12 bigint unsigned, c13 smallint unsigned, c14 tinyint "
+ "unsigned) tags (t1 int, t2 bigint, t3 float, t4 double, t5 binary(8), t6 smallint, t7 tinyint, t8 bool, t9 "
+ "nchar(8), t10 int unsigned, t11 bigint unsigned, t12 smallint unsigned, t13 tinyint unsigned)");
+ execute_simple_sql(taos,
+ "create table t1 using super tags (1, 1, 1, 1, 'abcdefgh',1,1,1,'一二三四五六七八', 1, 1, 1, 1)");
+ execute_simple_sql(
+ taos, "insert into t1 values (1591060628000, 1, 1, 1, 1, 'abcdefgh',1,1,1,'一二三四五六七八', now, 1, 1, 1, 1)");
+ execute_simple_sql(
+ taos, "insert into t1 values (1591060628001, 1, 1, 1, 1, 'abcdefgh',1,1,1,'一二三四五六七八', now, 1, 1, 1, 1)");
+
+ taos_stmt_use_result_query(taos, "ts", TSDB_DATA_TYPE_TIMESTAMP);
+ taos_stmt_use_result_query(taos, "c1", TSDB_DATA_TYPE_INT);
+ taos_stmt_use_result_query(taos, "c2", TSDB_DATA_TYPE_BIGINT);
+ taos_stmt_use_result_query(taos, "c3", TSDB_DATA_TYPE_FLOAT);
+ taos_stmt_use_result_query(taos, "c4", TSDB_DATA_TYPE_DOUBLE);
+ taos_stmt_use_result_query(taos, "c5", TSDB_DATA_TYPE_BINARY);
+ taos_stmt_use_result_query(taos, "c6", TSDB_DATA_TYPE_SMALLINT);
+ taos_stmt_use_result_query(taos, "c7", TSDB_DATA_TYPE_TINYINT);
+ taos_stmt_use_result_query(taos, "c8", TSDB_DATA_TYPE_BOOL);
+ taos_stmt_use_result_query(taos, "c9", TSDB_DATA_TYPE_NCHAR);
+ taos_stmt_use_result_query(taos, "c10", TSDB_DATA_TYPE_TIMESTAMP);
+ taos_stmt_use_result_query(taos, "c11", TSDB_DATA_TYPE_UINT);
+ taos_stmt_use_result_query(taos, "c12", TSDB_DATA_TYPE_UBIGINT);
+ taos_stmt_use_result_query(taos, "c13", TSDB_DATA_TYPE_USMALLINT);
+ taos_stmt_use_result_query(taos, "c14", TSDB_DATA_TYPE_UTINYINT);
+
+ printf("finish taos_stmt_use_result test\n");
+}
+
+void taos_stmt_close_test() {
+ printf("start taos_stmt_close test\n");
+ // ASM ERROR
+ TAOS_STMT *stmt = NULL;
+ assert(taos_stmt_close(stmt) != 0);
+ printf("finish taos_stmt_close test\n");
+}
+
+void test_api_reliability() {
+ // ASM catch memory leak
+ taos_stmt_init_test();
+ taos_stmt_preprare_test();
+ taos_stmt_set_tbname_test();
+ taos_stmt_set_tbname_tags_test();
+ taos_stmt_set_sub_tbname_test();
+ taos_stmt_bind_param_test();
+ taos_stmt_bind_single_param_batch_test();
+ taos_stmt_bind_param_batch_test();
+ taos_stmt_add_batch_test();
+ taos_stmt_execute_test();
+ taos_stmt_close_test();
+}
+
+void test_query() { taos_stmt_use_result_test(); }
+
+int main(int argc, char *argv[]) {
+ test_api_reliability();
+ test_query();
+ return 0;
+}
\ No newline at end of file
diff --git a/tests/script/general/compute/block_dist.sim b/tests/script/general/compute/block_dist.sim
index 51cf903654fe6173a5f78cdfdbd9c63b301cfa07..5343c1db286d41c6f1d588617a1123f4993ccf29 100644
--- a/tests/script/general/compute/block_dist.sim
+++ b/tests/script/general/compute/block_dist.sim
@@ -84,6 +84,10 @@ if $rows != 1 then
return -1
endi
+print ============== TD-5998
+sql_error select _block_dist() from (select * from $nt)
+sql_error select _block_dist() from (select * from $mt)
+
print =============== clear
sql drop database $db
sql show databases
@@ -91,4 +95,4 @@ if $rows != 0 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/parser/function.sim b/tests/script/general/parser/function.sim
index 0c93fe919a8f8d934017135ecf1d3cff4515a3e1..48e52cc7d7f946a18c366fc1ba667daf3fcf55eb 100644
--- a/tests/script/general/parser/function.sim
+++ b/tests/script/general/parser/function.sim
@@ -313,6 +313,12 @@ if $rows != 6 then
return -1
endi
+print =============================> TD-6086
+sql create stable td6086st(ts timestamp, d double) tags(t nchar(50));
+sql create table td6086ct1 using td6086st tags("ct1");
+sql create table td6086ct2 using td6086st tags("ct2");
+sql SELECT LAST(d),t FROM td6086st WHERE tbname in ('td6086ct1', 'td6086ct2') and ts>="2019-07-30 00:00:00" and ts<="2021-08-31 00:00:00" interval(1800s) fill(prev) GROUP BY tbname;
+
print ==================> td-2624
sql create table tm2(ts timestamp, k int, b binary(12));
sql insert into tm2 values('2011-01-02 18:42:45.326', -1,'abc');
@@ -935,6 +941,17 @@ if $data32 != 0.000144445 then
return -1
endi
+sql insert into t1 values('2015-09-18 00:30:00', 3.0);
+sql select irate(k) from t1
+if $rows != 1 then
+ return -1
+endi
+
+if $data00 != 0.000000354 then
+ return -1
+endi
+
+
print ===========================> derivative
sql drop table t1
sql drop table tx;
@@ -1149,9 +1166,11 @@ endi
sql select derivative(test_column_alias_name, 1s, 0) from (select avg(k) test_column_alias_name from t1 interval(1s));
-sql create table smeters (ts timestamp, current float, voltage int);
-sql insert into smeters values ('2021-08-08 10:10:10', 10, 1);
-sql insert into smeters values ('2021-08-08 10:10:12', 10, 2);
+sql create table smeters (ts timestamp, current float, voltage int) tags (t1 int);
+sql create table smeter1 using smeters tags (1);
+sql insert into smeter1 values ('2021-08-08 10:10:10', 10, 2);
+sql insert into smeter1 values ('2021-08-08 10:10:12', 10, 2);
+sql insert into smeter1 values ('2021-08-08 10:10:14', 20, 1);
sql select stddev(voltage) from smeters where ts>='2021-08-08 10:10:10.000' and ts < '2021-08-08 10:10:20.000' and current=10 interval(1000a);
if $rows != 2 then
@@ -1160,9 +1179,21 @@ endi
if $data00 != @21-08-08 10:10:10.000@ then
return -1
endi
+if $data01 != 0.000000000 then
+ return -1
+endi
if $data10 != @21-08-08 10:10:12.000@ then
return -1
endi
+if $data11 != 0.000000000 then
+ return -1
+endi
-
+sql select stddev(voltage) from smeters where ts>='2021-08-08 10:10:10.000' and ts < '2021-08-08 10:10:20.000' and current=10;
+if $rows != 1 then
+ return -1
+endi
+if $data00 != 0.000000000 then
+ return -1
+endi
diff --git a/tests/script/general/parser/interp_test.sim b/tests/script/general/parser/interp_test.sim
index 845afb0173685bf609897646eb188d689be6df10..8eac8a41d391508737232a3f068c477922bf77aa 100644
--- a/tests/script/general/parser/interp_test.sim
+++ b/tests/script/general/parser/interp_test.sim
@@ -23,562 +23,563 @@ sql use $db
##### select interp from table
print ====== select intp from table
$tb = $tbPrefix . 0
- ## interp(*) from tb
- sql select interp(*) from $tb where ts = $ts0
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:00.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != 0 then
- return -1
- endi
-
- ## interp + limit offset
- sql select interp(*) from $tb where ts = $ts0 limit 5 offset 1
- if $rows != 0 then
- return -1
- endi
-
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:00.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != 0 then
- return -1
- endi
- if $data03 != 0.00000 then
- return -1
- endi
- if $data04 != 0.000000000 then
- return -1
- endi
- if $data05 != 0 then
- return -1
- endi
- if $data06 != 0 then
- return -1
- endi
- if $data07 != 1 then
- return -1
- endi
- if $data08 != binary0 then
- return -1
- endi
- if $data09 != nchar0 then
- return -1
- endi
-
- ## intp + aggregation functions
- #$t = $ts0 + $delta
- #$t = $t + $delta
- #sql_error select interp(ts), max(c1), min(c2), count(c3), sum(c4), avg(c5), stddev(c6), first(c7), last(c8), interp(c9) from $tb where ts = $t
-
- ### illegal queries on a table
- sql_error select interp(ts), c1 from $tb where ts = $ts0
- sql_error select interp(ts) from $tb where ts >= $ts0
- sql_error select interp(ts), max(c1), min(c2), count(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(NULL)
-
- ### interp from tb + fill
- $t = $ts0 + 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t
- if $rows != 0 then
- return -1
- endi
-
- ## fill(none)
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(none)
- if $rows != 0 then
- return -1
- endi
- $t = $tsu + 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(none)
- if $rows != 0 then
- return -1
- endi
-
- ## fill(NULL)
- $t = $tsu - 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(value, NULL) order by ts asc
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-11-25 19:29:59.000@ then
- return -1
- endi
- if $data01 != NULL then
- print expect NULL, actual $data01
- return -1
- endi
- if $data02 != NULL then
- return -1
- endi
- if $data03 != NULL then
- return -1
- endi
- if $data04 != NULL then
- return -1
- endi
- if $data05 != NULL then
- return -1
- endi
- if $data06 != NULL then
- return -1
- endi
- if $data07 != NULL then
- return -1
- endi
- if $data08 != NULL then
- return -1
- endi
- if $data09 != NULL then
- return -1
- endi
-
- $t = $tsu + 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(none)
- if $rows != 0 then
- return -1
- endi
-
- ## fill(prev)
- $t = $ts0 + 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(prev)
- if $rows != 1 then
- return -1
- endi
-
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(prev)
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:00.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != 0 then
- return -1
- endi
- if $data03 != 0.00000 then
- return -1
- endi
- if $data04 != 0.000000000 then
- return -1
- endi
- if $data05 != 0 then
- return -1
- endi
- if $data06 != 0 then
- return -1
- endi
- if $data07 != 1 then
- return -1
- endi
- if $data08 != binary0 then
- return -1
- endi
- if $data09 != nchar0 then
- return -1
- endi
-
- $t = $ts0 - 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(prev)
- if $rows != 0 then
- return -1
- endi
-
- $t = $ts0 + 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $t fill(prev)
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:01.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != NULL then
- return -1
- endi
- if $data03 != 0.00000 then
- print expect 0.00000, actual:$data03
- return -1
- endi
+## interp(*) from tb
+sql select interp(*) from $tb where ts = $ts0
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:00.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != 0 then
+ return -1
+endi
+
+## interp + limit offset
+sql select interp(*) from $tb where ts = $ts0 limit 5 offset 1
+if $rows != 0 then
+ return -1
+endi
+
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:00.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != 0 then
+ return -1
+endi
+if $data03 != 0.00000 then
+ return -1
+endi
+if $data04 != 0.000000000 then
+ return -1
+endi
+if $data05 != 0 then
+ return -1
+endi
+if $data06 != 0 then
+ return -1
+endi
+if $data07 != 1 then
+ return -1
+endi
+if $data08 != binary0 then
+ return -1
+endi
+if $data09 != nchar0 then
+ return -1
+endi
+
+## intp + aggregation functions
+$t = $ts0 + $delta
+$t = $t + $delta
+sql_error select interp(ts), max(c1), min(c2), count(c3), sum(c4), avg(c5), stddev(c6), first(c7), last(c8), interp(c9) from $tb where ts = $t
+sql_error select interp(ts) from $tb where ts=$ts0 interval(1s)
+
+### illegal queries on a table
+sql_error select interp(ts), c1 from $tb where ts = $ts0
+sql_error select interp(ts) from $tb where ts >= $ts0
+sql_error select interp(ts), max(c1), min(c2), count(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(NULL)
+
+### interp from tb + fill
+$t = $ts0 + 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t
+if $rows != 0 then
+ return -1
+endi
+
+## fill(none)
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(none)
+if $rows != 0 then
+ return -1
+endi
+$t = $tsu + 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(none)
+if $rows != 0 then
+ return -1
+endi
+
+## fill(NULL)
+$t = $tsu - 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(value, NULL) order by ts asc
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-11-25 19:29:59.000@ then
+ return -1
+endi
+if $data01 != NULL then
+ print expect NULL, actual $data01
+ return -1
+endi
+if $data02 != NULL then
+ return -1
+endi
+if $data03 != NULL then
+ return -1
+endi
+if $data04 != NULL then
+ return -1
+endi
+if $data05 != NULL then
+ return -1
+endi
+if $data06 != NULL then
+ return -1
+endi
+if $data07 != NULL then
+ return -1
+endi
+if $data08 != NULL then
+ return -1
+endi
+if $data09 != NULL then
+ return -1
+endi
+
+$t = $tsu + 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(none)
+if $rows != 0 then
+ return -1
+endi
+
+## fill(prev)
+$t = $ts0 + 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(prev)
+if $rows != 1 then
+ return -1
+endi
+
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(prev)
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:00.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != 0 then
+ return -1
+endi
+if $data03 != 0.00000 then
+ return -1
+endi
+if $data04 != 0.000000000 then
+ return -1
+endi
+if $data05 != 0 then
+ return -1
+endi
+if $data06 != 0 then
+ return -1
+endi
+if $data07 != 1 then
+ return -1
+endi
+if $data08 != binary0 then
+ return -1
+endi
+if $data09 != nchar0 then
+ return -1
+endi
+
+$t = $ts0 - 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(prev)
+if $rows != 0 then
+ return -1
+endi
+
+$t = $ts0 + 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $t fill(prev)
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:01.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != NULL then
+ return -1
+endi
+if $data03 != 0.00000 then
+ print expect 0.00000, actual:$data03
+ return -1
+endi
# if $data04 != NULL then
# return -1
# endi
- $t = $tsu + 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(prev)
- if $rows != 0 then
- return -1
- endi
-
- ## fill(linear)
- $t = $ts0 + 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
- print ====== 0:$data00, 1:$data01, 2:$data02, 3:$data03, 4:$data04, 5:$data05, 6:$data06, 7:$data07, 8:$data08, 9:$data09
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:01.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != 0 then
- return -1
- endi
- print $data03
- if $data03 != 0.00167 then
- return -1
- endi
- if $data04 != 0.001666667 then
- return -1
- endi
- if $data05 != 0 then
- return -1
- endi
- if $data06 != 0 then
- return -1
- endi
- if $data07 != NULL then
- return -1
- endi
- if $data08 != NULL then
- return -1
- endi
- if $data09 != NULL then
- return -1
- endi
- # columns contain NULL values
- $t = $ts0 + 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $t fill(linear)
- print ====== 0:$data00, 1:$data01, 2:$data02, 3:$data03, 4:$data04, 5:$data05, 6:$data06, 7:$data07, 8:$data08, 9:$data09
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:01.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != NULL then
- return -1
- endi
- if $data03 != 0.00167 then
- return -1
- endi
- if $data04 != NULL then
- return -1
- endi
- if $data05 != 0 then
- return -1
- endi
- if $data06 != 0 then
- return -1
- endi
- if $data07 != NULL then
- return -1
- endi
- if $data08 != NULL then
- return -1
- endi
- if $data09 != NULL then
- return -1
- endi
-
- print select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(linear)
-
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(linear)
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:00.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != 0 then
- return -1
- endi
- if $data03 != 0.00000 then
- return -1
- endi
- if $data04 != 0.000000000 then
- return -1
- endi
- if $data05 != 0 then
- return -1
- endi
- if $data06 != 0 then
- return -1
- endi
- if $data07 != 1 then
- return -1
- endi
- if $data08 != binary0 then
- return -1
- endi
- if $data09 != nchar0 then
- return -1
- endi
- # columns contain NULL values
-
- print select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $ts0 fill(linear)
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $ts0 fill(linear)
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:00.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != NULL then
- return -1
- endi
- if $data03 != 0.00000 then
- return -1
- endi
- if $data04 != NULL then
- return -1
- endi
- if $data05 != 0 then
- return -1
- endi
- if $data06 != 0 then
- return -1
- endi
- if $data07 != 1 then
- return -1
- endi
- if $data08 != binary0 then
- return -1
- endi
- if $data09 != nchar0 then
- return -1
- endi
-
- $t = $ts0 - 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
- if $rows != 0 then
- return -1
- endi
-
- $t = $tsu + 1000
- print select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
- if $rows != 0 then
- return -1
- endi
+$t = $tsu + 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(prev)
+if $rows != 0 then
+ return -1
+endi
+
+## fill(linear)
+$t = $ts0 + 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
+print ====== 0:$data00, 1:$data01, 2:$data02, 3:$data03, 4:$data04, 5:$data05, 6:$data06, 7:$data07, 8:$data08, 9:$data09
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:01.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != 0 then
+ return -1
+endi
+print $data03
+if $data03 != 0.00167 then
+ return -1
+endi
+if $data04 != 0.001666667 then
+ return -1
+endi
+if $data05 != 0 then
+ return -1
+endi
+if $data06 != 0 then
+ return -1
+endi
+if $data07 != NULL then
+ return -1
+endi
+if $data08 != NULL then
+ return -1
+endi
+if $data09 != NULL then
+ return -1
+endi
+# columns contain NULL values
+$t = $ts0 + 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $t fill(linear)
+print ====== 0:$data00, 1:$data01, 2:$data02, 3:$data03, 4:$data04, 5:$data05, 6:$data06, 7:$data07, 8:$data08, 9:$data09
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:01.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != NULL then
+ return -1
+endi
+if $data03 != 0.00167 then
+ return -1
+endi
+if $data04 != NULL then
+ return -1
+endi
+if $data05 != 0 then
+ return -1
+endi
+if $data06 != 0 then
+ return -1
+endi
+if $data07 != NULL then
+ return -1
+endi
+if $data08 != NULL then
+ return -1
+endi
+if $data09 != NULL then
+ return -1
+endi
+
+print select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(linear)
+
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(linear)
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:00.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != 0 then
+ return -1
+endi
+if $data03 != 0.00000 then
+ return -1
+endi
+if $data04 != 0.000000000 then
+ return -1
+endi
+if $data05 != 0 then
+ return -1
+endi
+if $data06 != 0 then
+ return -1
+endi
+if $data07 != 1 then
+ return -1
+endi
+if $data08 != binary0 then
+ return -1
+endi
+if $data09 != nchar0 then
+ return -1
+endi
+# columns contain NULL values
+
+print select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $ts0 fill(linear)
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $ts0 fill(linear)
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:00.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != NULL then
+ return -1
+endi
+if $data03 != 0.00000 then
+ return -1
+endi
+if $data04 != NULL then
+ return -1
+endi
+if $data05 != 0 then
+ return -1
+endi
+if $data06 != 0 then
+ return -1
+endi
+if $data07 != 1 then
+ return -1
+endi
+if $data08 != binary0 then
+ return -1
+endi
+if $data09 != nchar0 then
+ return -1
+endi
+
+$t = $ts0 - 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
+if $rows != 0 then
+ return -1
+endi
+
+$t = $tsu + 1000
+print select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
+if $rows != 0 then
+ return -1
+endi
+
+## fill(value)
+$t = $ts0 + 1000
+print 91
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(value, -1, -2)
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:01.000@ then
+ return -1
+endi
+if $data01 != -2 then
+ return -1
+endi
+if $data02 != -2 then
+ return -1
+endi
+if $data03 != -2.00000 then
+ return -1
+endi
+if $data04 != -2.000000000 then
+ return -1
+endi
+if $data05 != -2 then
+ return -1
+endi
+if $data06 != -2 then
+ return -1
+endi
+if $data07 != 1 then
+ return -1
+endi
+if $data08 != NULL then
+ return -1
+endi
+if $data09 != NULL then
+ return -1
+endi
+
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(value, -1, -2, -3)
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:00.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != 0 then
+ return -1
+endi
+if $data03 != 0.00000 then
+ return -1
+endi
+if $data04 != 0.000000000 then
+ return -1
+endi
+if $data05 != 0 then
+ return -1
+endi
+if $data06 != 0 then
+ return -1
+endi
+if $data07 != 1 then
+ return -1
+endi
+if $data08 != binary0 then
+ return -1
+endi
+if $data09 != nchar0 then
+ return -1
+endi
+
+# table has NULL columns
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $ts0 fill(value, -1, -2, -3)
+if $rows != 1 then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:00.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != NULL then
+ return -1
+endi
+if $data03 != 0.00000 then
+ return -1
+endi
+if $data04 != NULL then
+ return -1
+endi
+
+$t = $ts0 - 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(value, -1, -2)
+if $rows != 0 then
+ return -1
+endi
+
+$t = $tsu + 1000
+sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(value, -1, -2)
+if $rows != 0 then
+ return -1
+endi
-## fill(value)
- $t = $ts0 + 1000
- print 91
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(value, -1, -2)
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:01.000@ then
- return -1
- endi
- if $data01 != -2 then
- return -1
- endi
- if $data02 != -2 then
- return -1
- endi
- if $data03 != -2.00000 then
- return -1
- endi
- if $data04 != -2.000000000 then
- return -1
- endi
- if $data05 != -2 then
- return -1
- endi
- if $data06 != -2 then
- return -1
- endi
- if $data07 != 1 then
- return -1
- endi
- if $data08 != NULL then
- return -1
- endi
- if $data09 != NULL then
- return -1
- endi
-
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(value, -1, -2, -3)
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:00.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != 0 then
- return -1
- endi
- if $data03 != 0.00000 then
- return -1
- endi
- if $data04 != 0.000000000 then
- return -1
- endi
- if $data05 != 0 then
- return -1
- endi
- if $data06 != 0 then
- return -1
- endi
- if $data07 != 1 then
- return -1
- endi
- if $data08 != binary0 then
- return -1
- endi
- if $data09 != nchar0 then
- return -1
- endi
-
- # table has NULL columns
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $ts0 fill(value, -1, -2, -3)
- if $rows != 1 then
- return -1
- endi
- if $data00 != @18-09-17 09:00:00.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != NULL then
- return -1
- endi
- if $data03 != 0.00000 then
- return -1
- endi
- if $data04 != NULL then
- return -1
- endi
-
- $t = $ts0 - 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(value, -1, -2)
- if $rows != 0 then
- return -1
- endi
-
- $t = $tsu + 1000
- sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(value, -1, -2)
- if $rows != 0 then
- return -1
- endi
-
-##### select interp from stable
- ## interp(*) from stb
- print select interp(*) from $stb where ts = $ts0
- sql select interp(*) from $stb where ts = $ts0
- if $rows != 1 then
- return -1
- endi
- $t = $ts0 + 1000
- print 92
-
- sql select interp(*) from $stb where ts = $t
- if $rows != 0 then
- return -1
- endi
- ## interp(*) from stb + group by
- sql select interp(ts, c1, c2, c3, c4, c5, c7, c9) from $stb where ts = $ts0 group by tbname order by tbname asc
- print ====== select interp(ts, c1, c2, c3, c4, c5, c7, c9) from $stb where ts = $ts0 group by tbname order by tbname asc
- print ====== 0:$data00, 1:$data01, 2:$data02, 3:$data03, 4:$data04, 5:$data05, 6:$data06, 7:$data07, 8:$data08, 9:$data09
- print ====== 0:$data20, 1:$data21, 2:$data22, 3:$data23, 4:$data24, 5:$data25, 6:$data26, 7:$data27, 8:$data28, 9:$data29
- if $rows != $tbNum then
- return -1
- endi
- if $data00 != @18-09-17 09:00:00.000@ then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != 0 then
- return -1
- endi
- if $data04 != 0.000000000 then
- return -1
- endi
- if $data08 != intp_tb0 then
- return -1
- endi
- if $data22 != NULL then
- return -1
- endi
- if $data24 != NULL then
- return -1
- endi
- if $data28 != intp_tb2 then
- return -1
- endi
-
- ## interp(*) from stb + group by + limit offset
- sql select interp(*) from $stb where ts = $ts0 group by tbname limit 0
- if $rows != 0 then
- return -1
- endi
- sql select interp(*) from $stb where ts = $ts0 group by tbname limit 0 offset 1
-
- ## interp(*) from stb + group by + fill(none)
- $t = $ts0 + 1000
- sql select interp(*) from $stb where ts = $t fill(none) group by tbname
- if $rows != 0 then
- return -1
- endi
-
- sql select interp(*) from $stb where ts = $ts0 fill(none) group by tbname
- if $rows != 4 then
- return -1
- endi
- if $data01 != 0 then
- return -1
- endi
- if $data02 != 0 then
- return -1
- endi
- if $data21 != 0 then
- return -1
- endi
- if $data22 != NULL then
- return -1
- endi
- if $data24 != NULL then
- return -1
- endi
-
- ## interp(*) from stb + group by + fill(none)
- $t = $ts0 + 1000
+### select interp from stable
+## interp(*) from stb
+print select interp(*) from $stb where ts = $ts0
+sql select interp(*) from $stb where ts = $ts0
+if $rows != 1 then
+ return -1
+endi
+$t = $ts0 + 1000
+print 92
+
+sql select interp(*) from $stb where ts = $t
+if $rows != 0 then
+ return -1
+endi
+## interp(*) from stb + group by
+sql select interp(ts, c1, c2, c3, c4, c5, c7, c9) from $stb where ts = $ts0 group by tbname order by tbname asc
+print ====== select interp(ts, c1, c2, c3, c4, c5, c7, c9) from $stb where ts = $ts0 group by tbname order by tbname asc
+print ====== 0:$data00, 1:$data01, 2:$data02, 3:$data03, 4:$data04, 5:$data05, 6:$data06, 7:$data07, 8:$data08, 9:$data09
+print ====== 0:$data20, 1:$data21, 2:$data22, 3:$data23, 4:$data24, 5:$data25, 6:$data26, 7:$data27, 8:$data28, 9:$data29
+if $rows != $tbNum then
+ return -1
+endi
+if $data00 != @18-09-17 09:00:00.000@ then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != 0 then
+ return -1
+endi
+if $data04 != 0.000000000 then
+ return -1
+endi
+if $data08 != intp_tb0 then
+ return -1
+endi
+if $data22 != NULL then
+ return -1
+endi
+if $data24 != NULL then
+ return -1
+endi
+if $data28 != intp_tb2 then
+ return -1
+endi
+
+## interp(*) from stb + group by + limit offset
+sql select interp(*) from $stb where ts = $ts0 group by tbname limit 0
+if $rows != 0 then
+ return -1
+endi
+sql select interp(*) from $stb where ts = $ts0 group by tbname limit 0 offset 1
+
+## interp(*) from stb + group by + fill(none)
+$t = $ts0 + 1000
+sql select interp(*) from $stb where ts = $t fill(none) group by tbname
+if $rows != 0 then
+ return -1
+endi
+
+sql select interp(*) from $stb where ts = $ts0 fill(none) group by tbname
+if $rows != 4 then
+ return -1
+endi
+if $data01 != 0 then
+ return -1
+endi
+if $data02 != 0 then
+ return -1
+endi
+if $data21 != 0 then
+ return -1
+endi
+if $data22 != NULL then
+ return -1
+endi
+if $data24 != NULL then
+ return -1
+endi
+
+## interp(*) from stb + group by + fill(none)
+$t = $ts0 + 1000
sql select interp(*) from $stb where ts = $t fill(NULL) group by tbname
if $rows != $tbNum then
return -1
@@ -846,12 +847,12 @@ if $data29 != NULL then
endi
sql_error select interp(ts,c1) from intp_tb0 where ts>'2018-11-25 19:19:00' and ts<'2018-11-25 19:19:12';
-sql select interp(ts,c1) from intp_tb0 where ts>'2018-11-25 19:19:00' and ts<'2018-11-25 19:19:12' interval(1s) fill(linear);
+sql select interp(ts,c1) from intp_tb0 where ts>'2018-11-25 19:19:00' and ts<'2018-11-25 19:19:12' every(1s) fill(linear);
if $rows != 0 then
return -1
endi
-sql select interp(c1) from intp_tb0 where ts>'2018-11-25 18:09:00' and ts<'2018-11-25 19:20:12' interval(18m);
+sql select interp(c1) from intp_tb0 where ts>'2018-11-25 18:09:00' and ts<'2018-11-25 19:20:12' every(18m);
if $rows != 1 then
return -1
endi
@@ -864,7 +865,7 @@ if $data01 != 3 then
return -1
endi
-sql select interp(c1,c3,c4,ts) from intp_tb0 where ts>'2018-11-25 18:09:00' and ts<'2018-11-25 19:20:12' interval(18m) fill(linear)
+sql select interp(c1,c3,c4,ts) from intp_tb0 where ts>'2018-11-25 18:09:00' and ts<'2018-11-25 19:20:12' every(18m) fill(linear)
if $rows != 5 then
return -1
endi
@@ -930,12 +931,258 @@ if $data44 != @18-11-25 19:06:00.000@ then
endi
+sql select interp(c1) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:42:00.000' every(1m) fill(linear);
+if $rows != 8 then
+ return -1
+endi
+if $data00 != @18-09-17 20:35:00.000@ then
+ return -1
+endi
+if $data01 != NULL then
+ return -1
+endi
+if $data10 != @18-09-17 20:36:00.000@ then
+ return -1
+endi
+if $data11 != NULL then
+ return -1
+endi
+if $data20 != @18-09-17 20:37:00.000@ then
+ return -1
+endi
+if $data21 != NULL then
+ return -1
+endi
+if $data30 != @18-09-17 20:38:00.000@ then
+ return -1
+endi
+if $data31 != NULL then
+ return -1
+endi
+if $data40 != @18-09-17 20:39:00.000@ then
+ return -1
+endi
+if $data41 != NULL then
+ return -1
+endi
+if $data50 != @18-09-17 20:40:00.000@ then
+ return -1
+endi
+if $data51 != 0 then
+ return -1
+endi
+if $data60 != @18-09-17 20:41:00.000@ then
+ return -1
+endi
+if $data61 != NULL then
+ return -1
+endi
+if $data70 != @18-09-17 20:42:00.000@ then
+ return -1
+endi
+if $data71 != NULL then
+ return -1
+endi
+
+
+sql select interp(c1) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:42:00.000' every(1m) fill(linear) order by ts desc;
+if $rows != 8 then
+ return -1
+endi
+if $data00 != @18-09-17 20:42:00.000@ then
+ return -1
+endi
+if $data01 != NULL then
+ return -1
+endi
+if $data10 != @18-09-17 20:41:00.000@ then
+ return -1
+endi
+if $data11 != NULL then
+ return -1
+endi
+if $data20 != @18-09-17 20:40:00.000@ then
+ return -1
+endi
+if $data21 != 0 then
+ return -1
+endi
+if $data30 != @18-09-17 20:39:00.000@ then
+ return -1
+endi
+if $data31 != NULL then
+ return -1
+endi
+if $data40 != @18-09-17 20:38:00.000@ then
+ return -1
+endi
+if $data41 != NULL then
+ return -1
+endi
+if $data50 != @18-09-17 20:37:00.000@ then
+ return -1
+endi
+if $data51 != NULL then
+ return -1
+endi
+if $data60 != @18-09-17 20:36:00.000@ then
+ return -1
+endi
+if $data61 != NULL then
+ return -1
+endi
+if $data70 != @18-09-17 20:35:00.000@ then
+ return -1
+endi
+if $data71 != NULL then
+ return -1
+endi
+
+sql select interp(c3) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:50:00.000' every(2m) fill(linear) order by ts;
+if $rows != 9 then
+ return -1
+endi
+if $data00 != @18-09-17 20:34:00.000@ then
+ return -1
+endi
+if $data01 != NULL then
+ return -1
+endi
+if $data10 != @18-09-17 20:36:00.000@ then
+ return -1
+endi
+if $data11 != NULL then
+ return -1
+endi
+if $data20 != @18-09-17 20:38:00.000@ then
+ return -1
+endi
+if $data21 != NULL then
+ return -1
+endi
+if $data30 != @18-09-17 20:40:00.000@ then
+ return -1
+endi
+if $data31 != 0.00000 then
+ return -1
+endi
+if $data40 != @18-09-17 20:42:00.000@ then
+ return -1
+endi
+if $data41 != 0.20000 then
+ return -1
+endi
+if $data50 != @18-09-17 20:44:00.000@ then
+ return -1
+endi
+if $data51 != 0.40000 then
+ return -1
+endi
+if $data60 != @18-09-17 20:46:00.000@ then
+ return -1
+endi
+if $data61 != 0.60000 then
+ return -1
+endi
+if $data70 != @18-09-17 20:48:00.000@ then
+ return -1
+endi
+if $data71 != 0.80000 then
+ return -1
+endi
+if $data80 != @18-09-17 20:50:00.000@ then
+ return -1
+endi
+if $data81 != 1.00000 then
+ return -1
+endi
+
+sql select interp(c3) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:50:00.000' every(3m) fill(linear) order by ts;
+if $rows != 6 then
+ return -1
+endi
+if $data00 != @18-09-17 20:33:00.000@ then
+ return -1
+endi
+if $data01 != NULL then
+ return -1
+endi
+if $data10 != @18-09-17 20:36:00.000@ then
+ return -1
+endi
+if $data11 != NULL then
+ return -1
+endi
+if $data20 != @18-09-17 20:39:00.000@ then
+ return -1
+endi
+if $data21 != NULL then
+ return -1
+endi
+if $data30 != @18-09-17 20:42:00.000@ then
+ return -1
+endi
+if $data31 != 0.20000 then
+ return -1
+endi
+if $data40 != @18-09-17 20:45:00.000@ then
+ return -1
+endi
+if $data41 != 0.50000 then
+ return -1
+endi
+if $data50 != @18-09-17 20:48:00.000@ then
+ return -1
+endi
+if $data51 != 0.80000 then
+ return -1
+endi
+sql select interp(c3) from intp_stb0 where ts >= '2018-09-17 20:35:00.000' and ts <= '2018-09-17 20:50:00.000' every(3m) fill(linear) order by ts desc;
+if $rows != 6 then
+ return -1
+endi
+if $data00 != @18-09-17 20:48:00.000@ then
+ return -1
+endi
+if $data01 != 0.80000 then
+ return -1
+endi
+if $data10 != @18-09-17 20:45:00.000@ then
+ return -1
+endi
+if $data11 != 0.50000 then
+ return -1
+endi
+if $data20 != @18-09-17 20:42:00.000@ then
+ return -1
+endi
+if $data21 != 0.20000 then
+ return -1
+endi
+if $data30 != @18-09-17 20:39:00.000@ then
+ return -1
+endi
+if $data31 != NULL then
+ return -1
+endi
+if $data40 != @18-09-17 20:36:00.000@ then
+ return -1
+endi
+if $data41 != NULL then
+ return -1
+endi
+if $data50 != @18-09-17 20:33:00.000@ then
+ return -1
+endi
+if $data51 != NULL then
+ return -1
+endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' interval(1s) fill(linear);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' every(1s) fill(linear);
if $rows != 6 then
return -1
endi
@@ -976,7 +1223,7 @@ if $data51 != 9.87500 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' interval(1s) fill(value, 1);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' every(1s) fill(value, 1);
if $rows != 6 then
return -1
endi
@@ -1017,7 +1264,7 @@ if $data51 != 1.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' interval(1s) fill(NULL);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' every(1s) fill(NULL);
if $rows != 6 then
return -1
endi
@@ -1058,7 +1305,7 @@ if $data51 != NULL then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' interval(1s) fill(prev);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' every(1s) fill(prev);
if $rows != 6 then
return -1
endi
@@ -1099,7 +1346,7 @@ if $data51 != 9.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' interval(1s) fill(next);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:00' every(1s) fill(next);
if $rows != 6 then
return -1
endi
@@ -1141,11 +1388,11 @@ if $data51 != 10.00000 then
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:56' interval(1s) fill(linear);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:56' every(1s) fill(linear);
if $rows != 0 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:56' interval(1s) fill(prev);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:56' every(1s) fill(prev);
if $rows != 2 then
return -1
endi
@@ -1162,7 +1409,7 @@ if $data11 != 3.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:56' interval(1s) fill(next);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:56' every(1s) fill(next);
if $rows != 2 then
return -1
endi
@@ -1179,7 +1426,7 @@ if $data11 != NULL then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:57' interval(1s) fill(linear);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:57' every(1s) fill(linear);
if $rows != 3 then
return -1
endi
@@ -1202,7 +1449,7 @@ if $data21 != 3.77273 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:57' interval(1s) fill(prev);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:57' every(1s) fill(prev);
if $rows != 3 then
return -1
endi
@@ -1225,7 +1472,7 @@ if $data21 != 3.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:57' interval(1s) fill(next);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:19:57' every(1s) fill(next);
if $rows != 3 then
return -1
endi
@@ -1248,7 +1495,7 @@ if $data21 != 4.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:03' interval(1s) fill(linear);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:03' every(1s) fill(linear);
if $rows != 10 then
return -1
endi
@@ -1313,7 +1560,7 @@ if $data91 != NULL then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:03' interval(1s) fill(prev);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:03' every(1s) fill(prev);
if $rows != 10 then
return -1
endi
@@ -1378,7 +1625,7 @@ if $data91 != 14.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:03' interval(1s) fill(next);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:03' every(1s) fill(next);
if $rows != 10 then
return -1
endi
@@ -1443,7 +1690,7 @@ if $data91 != NULL then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:05' interval(1s) fill(linear);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:05' every(1s) fill(linear);
if $rows != 12 then
return -1
endi
@@ -1496,7 +1743,7 @@ if $data71 != 15.29412 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:05' interval(1s) fill(prev);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:05' every(1s) fill(prev);
if $rows != 12 then
return -1
endi
@@ -1561,7 +1808,7 @@ if $data91 != 14.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:05' interval(1s) fill(next);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:05' every(1s) fill(next);
if $rows != 12 then
return -1
endi
@@ -1626,7 +1873,7 @@ if $data91 != 20.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:20:02' and ts<='2021-07-25 02:20:05' interval(1s) fill(value, 1);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:20:02' and ts<='2021-07-25 02:20:05' every(1s) fill(value, 1);
if $rows != 4 then
return -1
endi
@@ -1655,7 +1902,7 @@ if $data31 != 20.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:20:02' and ts<='2021-07-25 02:20:05' interval(1s) fill(null);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:20:02' and ts<='2021-07-25 02:20:05' every(1s) fill(null);
if $rows != 4 then
return -1
endi
@@ -1685,7 +1932,7 @@ if $data31 != 20.00000 then
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:25' interval(1s) fill(linear);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:25' every(1s) fill(linear);
if $rows != 32 then
return -1
endi
@@ -1738,7 +1985,7 @@ if $data71 != 15.29412 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:25' interval(1s) fill(prev);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:25' every(1s) fill(prev);
if $rows != 32 then
return -1
endi
@@ -1803,7 +2050,7 @@ if $data91 != 14.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:25' interval(1s) fill(next);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:20:25' every(1s) fill(next);
if $rows != 32 then
return -1
endi
@@ -1869,7 +2116,7 @@ if $data91 != 20.00000 then
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:25:00' interval(1s) fill(linear);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:25:00' every(1s) fill(linear);
if $rows != 307 then
return -1
endi
@@ -1922,7 +2169,7 @@ if $data71 != 15.29412 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:25:00' interval(1s) fill(prev);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:25:00' every(1s) fill(prev);
if $rows != 307 then
return -1
endi
@@ -1987,7 +2234,7 @@ if $data91 != 14.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:25:00' interval(1s) fill(next);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 02:25:00' every(1s) fill(next);
if $rows != 307 then
return -1
endi
@@ -2052,7 +2299,7 @@ if $data91 != 20.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 03:25:00' interval(1s) fill(linear);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 03:25:00' every(1s) fill(linear);
if $rows != 3907 then
return -1
endi
@@ -2106,7 +2353,7 @@ if $data71 != 15.29412 then
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 03:25:00' interval(1s) fill(prev);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 03:25:00' every(1s) fill(prev);
if $rows != 3907 then
return -1
endi
@@ -2171,7 +2418,7 @@ if $data91 != 14.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 03:25:00' interval(1s) fill(next);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<='2021-07-25 03:25:00' every(1s) fill(next);
if $rows != 3907 then
return -1
endi
@@ -2236,7 +2483,7 @@ if $data91 != 20.00000 then
return -1
endi
-sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:07' interval(1s);
+sql select interp(pav) from ap1 where ts> '2021-07-25 02:19:54' and ts<'2021-07-25 02:20:07' every(1s);
if $rows != 1 then
return -1
endi
diff --git a/tests/script/general/parser/limit.sim b/tests/script/general/parser/limit.sim
index 23b85095c54c9bb439c0766e379b8950778f8d90..3af2cb301854b27bc1b9c33bf8b06cbd17e87fd3 100644
--- a/tests/script/general/parser/limit.sim
+++ b/tests/script/general/parser/limit.sim
@@ -75,4 +75,9 @@ sleep 100
run general/parser/limit_tb.sim
run general/parser/limit_stb.sim
+print ========> TD-6017
+sql use $db
+sql select * from (select ts, top(c1, 5) from $tb where ts >= $ts0 order by ts desc limit 3 offset 1)
+sql select * from (select ts, top(c1, 5) from $stb where ts >= $ts0 order by ts desc limit 3 offset 1)
+
system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file
diff --git a/tests/script/general/parser/limit_tb.sim b/tests/script/general/parser/limit_tb.sim
index 0c987d88c99c898ef57e19c2f9cabee4b712e12d..4a93797d40fb65a7df9ad8d18c60292bed83dfe4 100644
--- a/tests/script/general/parser/limit_tb.sim
+++ b/tests/script/general/parser/limit_tb.sim
@@ -355,6 +355,10 @@ sql select top(c1, 1) from $tb where ts >= $ts0 and ts <= $tsu limit 5 offset 1
if $rows != 0 then
return -1
endi
+
+print ========> TD-6017
+sql select * from (select ts, top(c1, 5) from $tb where ts >= $ts0 and ts <= $tsu order by ts desc limit 3 offset 1)
+
sql select top(c1, 5) from $tb where ts >= $ts0 and ts <= $tsu order by ts desc limit 3 offset 1
print select top(c1, 5) from $tb where ts >= $ts0 and ts <= $tsu order by ts desc limit 3 offset 1
print $data00 $data01
diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index 6ad6a74eed76765a11e3cc875b7ff1ae51be648b..b4aad278d8836388990f4b11313db985e8ee05e6 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -90,6 +90,14 @@ cd ../../../debug; make
./test.sh -f general/parser/function.sim
./test.sh -f unique/cluster/vgroup100.sim
+./test.sh -f unique/http/admin.sim
+./test.sh -f unique/http/opentsdb.sim
+
+./test.sh -f unique/import/replica2.sim
+./test.sh -f unique/import/replica3.sim
+
+./test.sh -f general/alter/cached_schema_after_alter.sim
+
#======================b1-end===============
#======================b2-start===============
@@ -198,13 +206,7 @@ cd ../../../debug; make
#======================b3-end===============
#======================b4-start===============
-./test.sh -f unique/http/admin.sim
-./test.sh -f unique/http/opentsdb.sim
-./test.sh -f unique/import/replica2.sim
-./test.sh -f unique/import/replica3.sim
-
-./test.sh -f general/alter/cached_schema_after_alter.sim
./test.sh -f general/alter/count.sim
./test.sh -f general/alter/dnode.sim
./test.sh -f general/alter/import.sim
diff --git a/tests/test-all.sh b/tests/test-all.sh
index 6e7963e787ca8a3593418be1af31bdbca58d6fd3..29e96b3fc6e6f84157d57f607a3fc33eccad0f65 100755
--- a/tests/test-all.sh
+++ b/tests/test-all.sh
@@ -12,7 +12,7 @@ IN_TDINTERNAL="community"
function stopTaosd {
echo "Stop taosd"
- sudo systemctl stop taosd
+ sudo systemctl stop taosd || echo 'no sudo or systemctl or stop fail '
PID=`ps -ef|grep -w taosd | grep -v grep | awk '{print $2}'`
while [ -n "$PID" ]
do
@@ -24,9 +24,9 @@ function stopTaosd {
function dohavecore(){
corefile=`find $corepath -mmin 1`
- core_file=`echo $corefile|cut -d " " -f2`
- proc=`echo $corefile|cut -d "_" -f3`
if [ -n "$corefile" ];then
+ core_file=`echo $corefile|cut -d " " -f2`
+ proc=`file $core_file|awk -F "execfn:" '/execfn:/{print $2}'|tr -d \' |awk '{print $1}'|tr -d \,`
echo 'taosd or taos has generated core'
rm case.log
if [[ "$tests_dir" == *"$IN_TDINTERNAL"* ]] && [[ $1 == 1 ]]; then
@@ -46,7 +46,7 @@ function dohavecore(){
fi
fi
if [[ $1 == 1 ]];then
- echo '\n'|gdb /usr/local/taos/bin/$proc $core_file -ex "bt 10" -ex quit
+ echo '\n'|gdb $proc $core_file -ex "bt 10" -ex quit
exit 8
fi
fi
@@ -179,6 +179,9 @@ function runPyCaseOneByOnefq() {
start_time=`date +%s`
date +%F\ %T | tee -a pytest-out.log
echo -n $case
+ if [[ $1 =~ full ]] ; then
+ line=$line" -s"
+ fi
$line > case.log 2>&1 && \
echo -e "${GREEN} success${NC}" | tee -a pytest-out.log || \
echo -e "${RED} failed${NC}" | tee -a pytest-out.log
@@ -494,7 +497,7 @@ if [ "$2" != "sim" ] && [ "$2" != "python" ] && [ "$2" != "jdbc" ] && [ "$2" !=
totalExamplePass=`expr $totalExamplePass + 1`
fi
- ./prepare 127.0.0.1 > /dev/null 2>&1
+ ./prepare > /dev/null 2>&1
if [ $? != "0" ]; then
echo "prepare failed"
totalExampleFailed=`expr $totalExampleFailed + 1`