diff --git a/cmake/version.inc b/cmake/version.inc
index 52d62fca65..aa8a4b6463 100644
--- a/cmake/version.inc
+++ b/cmake/version.inc
@@ -4,7 +4,7 @@ PROJECT(TDengine)
IF (DEFINED VERNUMBER)
SET(TD_VER_NUMBER ${VERNUMBER})
ELSE ()
- SET(TD_VER_NUMBER "2.0.3.0")
+ SET(TD_VER_NUMBER "2.0.4.0")
ENDIF ()
IF (DEFINED VERCOMPATIBLE)
diff --git a/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md b/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
index 3c7f6987c7..e0acaee137 100644
--- a/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
+++ b/documentation20/webdocs/markdowndocs/TAOS SQL-ch.md
@@ -1019,5 +1019,5 @@ SELECT AVG(current),MAX(current),LEASTSQUARES(current, start_val, step_val), PER
- 表名最大长度为193，每行数据最大长度16k个字符
- 列名最大长度为65，最多允许1024列，最少需要2列，第一列必须是时间戳
- 标签最多允许128个，可以0个，标签总长度不超过16k个字符
-- SQL语句最大长度65480个字符，但可通过系统配置参数maxSQLLength修改，最长可配置为8M
+- SQL语句最大长度65480个字符，但可通过系统配置参数maxSQLLength修改，最长可配置为1M
- 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制
diff --git a/documentation20/webdocs/markdowndocs/architecture-ch.md b/documentation20/webdocs/markdowndocs/architecture-ch.md
index a279875649..460e655f5f 100644
--- a/documentation20/webdocs/markdowndocs/architecture-ch.md
+++ b/documentation20/webdocs/markdowndocs/architecture-ch.md
@@ -67,7 +67,7 @@ TDengine 分布式架构的逻辑结构图如下：
图 1 TDengine架构示意图
一个完整的 TDengine 系统是运行在一到多个物理节点上的，逻辑上，它包含数据节点(dnode)、TDengine客户端(taosc)以及应用(app)。系统中存在一到多个数据节点，这些数据节点组成一个集群(cluster)。应用通过taosc的API与TDengine集群进行互动。下面对每个逻辑单元进行简要介绍。
-**物理节点(pnode):** pnode是一独立运行、拥有自己的计算、存储和网络能力的计算机，可以是安装有OS的物理机、虚拟机或容器。物理节点由其配置的 FQDN(Fully Qualified Domain Name)来标识。
+**物理节点(pnode):** pnode是一独立运行、拥有自己的计算、存储和网络能力的计算机，可以是安装有OS的物理机、虚拟机或容器。物理节点由其配置的 FQDN(Fully Qualified Domain Name)来标识。TDengine完全依赖FQDN来进行网络通讯，如果不了解FQDN，请看博文《[一篇文章说清楚TDengine的FQDN](https://www.taosdata.com/blog/2020/09/11/1824.html)》。
**数据节点(dnode):** dnode 是 TDengine 服务器侧执行代码 taosd 在物理节点上的一个运行实例，一个工作的系统必须有至少一个数据节点。dnode包含零到多个逻辑的虚拟节点(VNODE)，零或者至多一个逻辑的管理节点(mnode)。dnode在系统中的唯一标识由实例的End Point (EP )决定。EP是dnode所在物理节点的FQDN (Fully Qualified Domain Name)和系统所配置的网络端口号(Port)的组合。通过配置不同的端口，一个物理节点(一台物理机、虚拟机或容器）可以运行多个实例，或有多个数据节点。
diff --git a/documentation20/webdocs/markdowndocs/cluster-ch.md b/documentation20/webdocs/markdowndocs/cluster-ch.md
index 24592d4114..c36819e5c7 100644
--- a/documentation20/webdocs/markdowndocs/cluster-ch.md
+++ b/documentation20/webdocs/markdowndocs/cluster-ch.md
@@ -22,7 +22,7 @@ TDengine的集群管理极其简单，除添加和删除节点需要人工干预
1. 每个物理节点上执行命令`hostname -f`，查看和确认所有节点的hostname是不相同的(应用驱动所在节点无需做此项检查)；
2. 每个物理节点上执行`ping host`, 其中host是其他物理节点的hostname, 看能否ping通其它物理节点; 如果不能ping通，需要检查网络设置, 或/etc/hosts文件(Windows系统默认路径为C:\Windows\system32\drivers\etc\hosts)，或DNS的配置。如果无法ping通，是无法组成集群的；
-3. 从应用运行的物理节点，ping taosd运行的数据节点，如果无法平通，应用是无法连接taosd的，请检查应用所在物理节点的DNS设置或hosts文件；
+3. 从应用运行的物理节点，ping taosd运行的数据节点，如果无法ping通，应用是无法连接taosd的，请检查应用所在物理节点的DNS设置或hosts文件；
4. 每个数据节点的End Point就是输出的hostname外加端口号，比如h1.taosdata.com:6030
**第五步**：修改TDengine的配置文件（所有节点的文件/etc/taos/taos.cfg都需要修改）。假设准备启动的第一个数据节点End Point为 h1.taosdata.com:6030, 其与集群配置相关参数如下：
@@ -31,8 +31,8 @@ TDengine的集群管理极其简单，除添加和删除节点需要人工干预
// firstEp 是每个数据节点首次启动后连接的第一个数据节点
firstEp h1.taosdata.com:6030
-// 配置本数据节点的FQDN，如果本机只有一个hostname, 无需配置
-fqdn h1.taosdata.com
+// 必须配置为本数据节点的FQDN，如果本机只有一个hostname, 可注释掉本配置
+fqdn h1.taosdata.com
// 配置本数据节点的端口号，缺省是6030
serverPort 6030
@@ -41,7 +41,7 @@ serverPort 6030
arbitrator ha.taosdata.com:6042
```
-一定要修改的参数是firstEp和fqdn, 其他参数可不做任何修改，除非你很清楚为什么要修改。
+一定要修改的参数是firstEp和fqdn。在每个数据节点，firstEp需全部配置成一样，**但fqdn一定要配置成其所在数据节点的值**。其他参数可不做任何修改，除非你很清楚为什么要修改。
**加入到集群中的数据节点dnode，涉及集群相关的下表11项参数必须完全相同，否则不能成功加入到集群中。**
diff --git a/documentation20/webdocs/markdowndocs/insert-ch.md b/documentation20/webdocs/markdowndocs/insert-ch.md
index 5e4532dfd0..a84b577622 100644
--- a/documentation20/webdocs/markdowndocs/insert-ch.md
+++ b/documentation20/webdocs/markdowndocs/insert-ch.md
@@ -25,6 +25,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过16K，一条SQL语句总长度不能超过64K（可通过参数maxSQLLength配置，最大可配置为8M）。
- TDengine支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开20个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程切频繁切换，带来额外开销。
- 对同一张表，如果新插入记录的时间戳已经存在，新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。
+- 写入的数据的时间戳必须大于当前时间减去配置参数keep的时间。如果keep配置为3650天，那么无法写入比3650天还老的数据。写入数据的时间戳也不能大于当前时间加配置参数days。如果days配置为2，那么无法写入比当前时间还晚2天的数据。
## Prometheus直接写入
[Prometheus](https://www.prometheus.io/)作为Cloud Native Computing Fundation毕业的项目，在性能监控以及K8S性能监控领域有着非常广泛的应用。TDengine提供一个小工具[Bailongma](https://github.com/taosdata/Bailongma)，只需在Prometheus做简单配置，无需任何代码，就可将Prometheus采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文[用Docker容器快速搭建一个Devops监控Demo](https://www.taosdata.com/blog/2020/02/03/1189.html)即是采用bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。
diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index c4fba06426..0323434a99 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -191,6 +191,7 @@ SColumn* tscColumnListInsert(SArray* pColList, SColumnIndex* colIndex);
SArray* tscColumnListClone(const SArray* src, int16_t tableIndex);
void tscColumnListDestroy(SArray* pColList);
+void tscDequoteAndTrimToken(SStrToken* pToken);
int32_t tscValidateName(SStrToken* pToken);
void tscIncStreamExecutionCount(void* pStream);
@@ -257,6 +258,8 @@ void tscDoQuery(SSqlObj* pSql);
*/
SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cmd);
+void registerSqlObj(SSqlObj* pSql);
+
SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void* param, int32_t cmd, SSqlObj* pPrevSql);
void addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClauseIndex, int32_t tableIndex);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 27e2ee8c76..ea42b0f6a3 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -89,7 +89,7 @@ typedef struct STableComInfo {
typedef struct SCMCorVgroupInfo {
int32_t version;
- int8_t inUse;
+ int8_t inUse;
int8_t numOfEps;
SEpAddr epAddr[TSDB_MAX_REPLICA];
} SCMCorVgroupInfo;
@@ -99,6 +99,7 @@ typedef struct STableMeta {
uint8_t tableType;
int16_t sversion;
int16_t tversion;
+ char sTableId[TSDB_TABLE_FNAME_LEN];
SCMVgroupInfo vgroupInfo;
SCMCorVgroupInfo corVgroupInfo;
STableId id;
@@ -106,7 +107,7 @@ typedef struct STableMeta {
} STableMeta;
typedef struct STableMetaInfo {
- STableMeta * pTableMeta; // table meta, cached in client side and acquired by name
+ STableMeta *pTableMeta; // table meta, cached in client side and acquired by name
SVgroupsInfo *vgroupList;
SArray *pVgroupTables; // SArray
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 09610575f6..c5d622e245 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -51,10 +51,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const
pSql->fp = fp;
pSql->fetchFp = fp;
- uint64_t handle = (uint64_t) pSql;
- pSql->self = taosCachePut(tscObjCache, &handle, sizeof(uint64_t), &pSql, sizeof(uint64_t), 2*3600*1000);
-
- T_REF_INC(pSql->pTscObj);
+ registerSqlObj(pSql);
pSql->sqlstr = calloc(1, sqlLen + 1);
if (pSql->sqlstr == NULL) {
diff --git a/src/client/src/tscFunctionImpl.c b/src/client/src/tscFunctionImpl.c
index d8ac0d3109..be38a7af71 100644
--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
@@ -326,7 +326,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
} else if (functionId == TSDB_FUNC_LAST_ROW) {
*type = (int16_t)dataType;
*bytes = (int16_t)dataBytes;
- *interBytes = dataBytes + sizeof(SLastrowInfo);
+ *interBytes = dataBytes;
} else {
return TSDB_CODE_TSC_INVALID_SQL;
}
@@ -1843,8 +1843,10 @@ static void last_row_function(SQLFunctionCtx *pCtx) {
pInfo1->hasResult = DATA_SET_FLAG;
DO_UPDATE_TAG_COLUMNS(pCtx, pInfo1->ts);
+ } else {
+ DO_UPDATE_TAG_COLUMNS(pCtx, pCtx->ptsList[pCtx->size - 1]);
}
-
+
SET_VAL(pCtx, pCtx->size, 1);
}
diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index 50f82ae662..030b033653 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -23,7 +23,30 @@
#include "tscUtil.h"
#include "tschemautil.h"
#include "tsclient.h"
+#include "taos.h"
+#include "tscSubquery.h"
+#define STR_NOCASE_EQUAL(str1, len1, str2, len2) ((len1 == len2) && 0 == strncasecmp(str1, str2, len1))
+
+typedef enum BuildType {
+ SCREATE_BUILD_TABLE = 1,
+ SCREATE_BUILD_DB = 2,
+} BuildType;
+
+typedef enum Stage {
+ SCREATE_CALLBACK_QUERY = 1,
+ SCREATE_CALLBACK_RETRIEVE = 2,
+} Stage;
+
+// support 'show create table'
+typedef struct SCreateBuilder {
+ char sTableName[TSDB_TABLE_FNAME_LEN];
+ char buf[TSDB_TABLE_FNAME_LEN];
+ SSqlObj *pParentSql;
+ SSqlObj *pInterSql;
+ int32_t (*fp)(void *para, char* result);
+ Stage callStage;
+} SCreateBuilder;
static void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnName, int16_t type, size_t valueLength);
static int32_t getToStringLength(const char *pData, int32_t length, int32_t type) {
@@ -272,14 +295,511 @@ static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
tscFieldInfoUpdateOffset(pQueryInfo);
return tscSetValueToResObj(pSql, rowLen);
}
+static int32_t tscGetNthFieldResult(TAOS_ROW row, TAOS_FIELD* fields, int *lengths, int idx, char *result) {
+ const char *val = row[idx];
+ if (val == NULL) {
+ sprintf(result, "%s", TSDB_DATA_NULL_STR);
+ return -1;
+ }
+ uint8_t type = fields[idx].type;
+ int32_t length = lengths[idx];
+ switch (type) {
+ case TSDB_DATA_TYPE_BOOL:
+ sprintf(result, "%s", ((((int)(*((char *)val))) == 1) ? "true" : "false"));
+ break;
+ case TSDB_DATA_TYPE_TINYINT:
+ sprintf(result, "%d", (int)(*((char *)val)));
+ break;
+ case TSDB_DATA_TYPE_SMALLINT:
+ sprintf(result, "%d", (int)(*((short *)val)));
+ break;
+ case TSDB_DATA_TYPE_INT:
+ sprintf(result, "%d", *((int *)val));
+ break;
+ case TSDB_DATA_TYPE_BIGINT:
+ sprintf(result, "%"PRId64, *((int64_t *)val));
+ break;
+ case TSDB_DATA_TYPE_FLOAT:
+ sprintf(result, "%f", GET_FLOAT_VAL(val));
+ break;
+ case TSDB_DATA_TYPE_DOUBLE:
+ sprintf(result, "%f", GET_DOUBLE_VAL(val));
+ break;
+ case TSDB_DATA_TYPE_NCHAR:
+ case TSDB_DATA_TYPE_BINARY:
+ memcpy(result, val, length);
+ break;
+ case TSDB_DATA_TYPE_TIMESTAMP:
+ ///formatTimestamp(buf, *(int64_t*)val, TSDB_TIME_PRECISION_MICRO);
+ //memcpy(result, val, strlen(buf));
+ sprintf(result, "%"PRId64, *((int64_t *)val));
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+void tscSCreateCallBack(void *param, TAOS_RES *tres, int code) {
+ if (param == NULL || tres == NULL) {
+ return;
+ }
+ SCreateBuilder *builder = (SCreateBuilder *)(param);
+ SSqlObj *pParentSql = builder->pParentSql;
+ SSqlObj *pSql = (SSqlObj *)tres;
+
+ SSqlRes *pRes = &pParentSql->res;
+ pRes->code = taos_errno(pSql);
+ if (pRes->code != TSDB_CODE_SUCCESS) {
+ taos_free_result(pSql);
+ free(builder);
+ tscQueueAsyncRes(pParentSql);
+ return;
+ }
+
+ if (builder->callStage == SCREATE_CALLBACK_QUERY) {
+ taos_fetch_rows_a(tres, tscSCreateCallBack, param);
+ builder->callStage = SCREATE_CALLBACK_RETRIEVE;
+ } else {
+ char *result = calloc(1, TSDB_MAX_BINARY_LEN);
+ pRes->code = builder->fp(builder, result);
+
+ taos_free_result(pSql);
+ free(builder);
+ free(result);
+
+ if (pRes->code == TSDB_CODE_SUCCESS) {
+ (*pParentSql->fp)(pParentSql->param, pParentSql, code);
+ } else {
+ tscQueueAsyncRes(pParentSql);
+ }
+ }
+}
+
+TAOS_ROW tscFetchRow(void *param) {
+ SCreateBuilder *builder = (SCreateBuilder *)param;
+ if (builder == NULL) {
+ return NULL;
+ }
+ SSqlObj *pSql = builder->pInterSql;
+ if (pSql == NULL || pSql->signature != pSql) {
+ terrno = TSDB_CODE_TSC_DISCONNECTED;
+ return NULL;
+ }
+
+ SSqlCmd *pCmd = &pSql->cmd;
+ SSqlRes *pRes = &pSql->res;
+
+ if (pRes->qhandle == 0 ||
+ pCmd->command == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
+ pCmd->command == TSDB_SQL_INSERT) {
+ return NULL;
+ }
+
+ // set the sql object owner
+ tscSetSqlOwner(pSql);
+
+ // current data set are exhausted, fetch more data from node
+ if (pRes->row >= pRes->numOfRows && (pRes->completed != true || hasMoreVnodesToTry(pSql) || hasMoreClauseToTry(pSql)) &&
+ (pCmd->command == TSDB_SQL_RETRIEVE ||
+ pCmd->command == TSDB_SQL_RETRIEVE_LOCALMERGE ||
+ pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE ||
+ pCmd->command == TSDB_SQL_FETCH ||
+ pCmd->command == TSDB_SQL_SHOW ||
+ pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE ||
+ pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE ||
+ pCmd->command == TSDB_SQL_SELECT ||
+ pCmd->command == TSDB_SQL_DESCRIBE_TABLE ||
+ pCmd->command == TSDB_SQL_SERV_STATUS ||
+ pCmd->command == TSDB_SQL_CURRENT_DB ||
+ pCmd->command == TSDB_SQL_SERV_VERSION ||
+ pCmd->command == TSDB_SQL_CLI_VERSION ||
+ pCmd->command == TSDB_SQL_CURRENT_USER )) {
+ taos_fetch_rows_a(pSql, tscSCreateCallBack, param);
+ return NULL;
+ }
+
+ void* data = doSetResultRowData(pSql, true);
+
+ tscClearSqlOwner(pSql);
+ return data;
+}
+static int32_t tscGetTableTagValue(SCreateBuilder *builder, char *result) {
+ TAOS_ROW row = tscFetchRow(builder);
+ SSqlObj* pSql = builder->pInterSql;
+
+ if (row == NULL) {
+ return TSDB_CODE_MND_INVALID_TABLE_NAME;
+ }
+
+ int32_t* lengths = taos_fetch_lengths(pSql);
+ int num_fields = taos_num_fields(pSql);
+ TAOS_FIELD *fields = taos_fetch_fields(pSql);
+
+ char buf[TSDB_COL_NAME_LEN + 16];
+ for (int i = 0; i < num_fields; i++) {
+ memset(buf, 0, sizeof(buf));
+ int32_t ret = tscGetNthFieldResult(row, fields, lengths, i, buf);
+
+ if (i == 0) {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s", "(");
+ }
+ if ((fields[i].type == TSDB_DATA_TYPE_NCHAR
+ || fields[i].type == TSDB_DATA_TYPE_BINARY
+ || fields[i].type == TSDB_DATA_TYPE_TIMESTAMP) && 0 == ret) {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "\"%s\",", buf);
+ } else {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s,", buf);
+ }
+ if (i == num_fields - 1) {
+ sprintf(result + strlen(result) - 1, "%s", ")");
+ }
+ }
+
+ if (0 == strlen(result)) {
+ return TSDB_CODE_MND_INVALID_TABLE_NAME;
+ }
+ return TSDB_CODE_SUCCESS;
+}
+
+
+// build 'show create table/database' result fields
+static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const char *ddl) {
+ int32_t rowLen = 0;
+ int16_t ddlLen = (int16_t)strlen(ddl);
+ SColumnIndex index = {0};
+ pSql->cmd.numOfCols = 2;
+
+ SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+ pQueryInfo->order.order = TSDB_ORDER_ASC;
+
+ TAOS_FIELD f;
+ if (type == SCREATE_BUILD_TABLE) {
+ f.type = TSDB_DATA_TYPE_BINARY;
+ f.bytes = (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE;
+ tstrncpy(f.name, "Table", sizeof(f.name));
+ } else {
+ f.type = TSDB_DATA_TYPE_BINARY;
+ f.bytes = (TSDB_DB_NAME_LEN - 1) + VARSTR_HEADER_SIZE;
+ tstrncpy(f.name, "Database", sizeof(f.name));
+ }
+
+ SFieldSupInfo* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
+ pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
+ f.bytes, f.bytes - VARSTR_HEADER_SIZE, false);
+
+ rowLen += f.bytes;
+
+ f.bytes = (int16_t)(ddlLen + VARSTR_HEADER_SIZE);
+ f.type = TSDB_DATA_TYPE_BINARY;
+ if (type == SCREATE_BUILD_TABLE) {
+ tstrncpy(f.name, "Create Table", sizeof(f.name));
+ } else {
+ tstrncpy(f.name, "Create Database", sizeof(f.name));
+ }
+
+ pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
+ pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
+ (int16_t)(ddlLen + VARSTR_HEADER_SIZE), ddlLen, false);
+
+ rowLen += ddlLen + VARSTR_HEADER_SIZE;
+
+ return rowLen;
+}
+static int32_t tscSCreateSetValueToResObj(SSqlObj *pSql, int32_t rowLen, const char *tableName, const char *ddl) {
+ SSqlRes *pRes = &pSql->res;
+
+ SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+ int32_t numOfRows = 1;
+ if (strlen(ddl) == 0) {
+
+ }
+ tscInitResObjForLocalQuery(pSql, numOfRows, rowLen);
+
+ TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, 0);
+ char* dst = pRes->data + tscFieldInfoGetOffset(pQueryInfo, 0) * numOfRows;
+ STR_WITH_MAXSIZE_TO_VARSTR(dst, tableName, pField->bytes);
+
+ pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, 1);
+ dst = pRes->data + tscFieldInfoGetOffset(pQueryInfo, 1) * numOfRows;
+ STR_WITH_MAXSIZE_TO_VARSTR(dst, ddl, pField->bytes);
+ return 0;
+}
+static int32_t tscSCreateBuildResult(SSqlObj *pSql, BuildType type, const char *str, const char *result) {
+ SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+ int32_t rowLen = tscSCreateBuildResultFields(pSql, type, result);
+
+ tscFieldInfoUpdateOffset(pQueryInfo);
+ return tscSCreateSetValueToResObj(pSql, rowLen, str, result);
+}
+int32_t tscRebuildCreateTableStatement(void *param,char *result) {
+ SCreateBuilder *builder = (SCreateBuilder *)param;
+ int32_t code = TSDB_CODE_SUCCESS;
+
+ char *buf = calloc(1,TSDB_MAX_BINARY_LEN);
+ if (buf == NULL) {
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+
+ code = tscGetTableTagValue(builder, buf);
+ if (code == TSDB_CODE_SUCCESS) {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "CREATE TABLE %s USING %s TAGS %s", builder->buf, builder->sTableName, buf);
+ code = tscSCreateBuildResult(builder->pParentSql, SCREATE_BUILD_TABLE, builder->buf, result);
+ }
+ free(buf);
+ return code;
+}
+
+static int32_t tscGetDBInfo(SCreateBuilder *builder, char *result) {
+ TAOS_ROW row = tscFetchRow(builder);
+ if (row == NULL) {
+ return TSDB_CODE_MND_DB_NOT_SELECTED;
+ }
+ const char *showColumns[] = {"REPLICA", "QUORUM", "DAYS", "KEEP", "BLOCKS", NULL};
+
+ SSqlObj *pSql = builder->pInterSql;
+ TAOS_FIELD *fields = taos_fetch_fields(pSql);
+ int num_fields = taos_num_fields(pSql);
+
+ char buf[TSDB_DB_NAME_LEN + 64] = {0};
+ do {
+ int32_t* lengths = taos_fetch_lengths(pSql);
+ int32_t ret = tscGetNthFieldResult(row, fields, lengths, 0, buf);
+ if (0 == ret && STR_NOCASE_EQUAL(buf, strlen(buf), builder->buf, strlen(builder->buf))) {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "CREATE DATABASE %s", buf);
+ for (int i = 1; i < num_fields; i++) {
+ for (int j = 0; showColumns[j] != NULL; j++) {
+ if (STR_NOCASE_EQUAL(fields[i].name, strlen(fields[i].name), showColumns[j], strlen(showColumns[j]))) {
+ memset(buf, 0, sizeof(buf));
+ ret = tscGetNthFieldResult(row, fields, lengths, i, buf);
+ if (ret == 0) {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), " %s %s", showColumns[j], buf);
+ }
+ }
+ }
+ }
+ break;
+ }
+
+ row = tscFetchRow(builder);
+ } while (row != NULL);
+
+ if (0 == strlen(result)) {
+ return TSDB_CODE_MND_DB_NOT_SELECTED;
+ }
+
+ return TSDB_CODE_SUCCESS;
+}
+int32_t tscRebuildCreateDBStatement(void *param,char *result) {
+ SCreateBuilder *builder = (SCreateBuilder *)param;
+ int32_t code = TSDB_CODE_SUCCESS;
+
+ char *buf = calloc(1, TSDB_MAX_BINARY_LEN);
+ if (buf == NULL) {
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+ code = tscGetDBInfo(param, buf);
+ if (code == TSDB_CODE_SUCCESS) {
+ code = tscSCreateBuildResult(builder->pParentSql, SCREATE_BUILD_DB, builder->buf, buf);
+ }
+ free(buf);
+ return code;
+}
+
+static int32_t tscGetTableTagColumnName(SSqlObj *pSql, char **result) {
+ char *buf = (char *)malloc(TSDB_MAX_BINARY_LEN);
+ if (buf == NULL) {
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+ buf[0] = 0;
+
+ STableMeta *pMeta = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0)->pTableMeta;
+ if (pMeta->tableType == TSDB_SUPER_TABLE || pMeta->tableType == TSDB_NORMAL_TABLE ||
+ pMeta->tableType == TSDB_STREAM_TABLE) {
+ free(buf);
+ return TSDB_CODE_TSC_INVALID_VALUE;
+ }
+
+ SSchema *pTagsSchema = tscGetTableTagSchema(pMeta);
+ int32_t numOfTags = tscGetNumOfTags(pMeta);
+ for (int32_t i = 0; i < numOfTags; i++) {
+ if (i != numOfTags - 1) {
+ snprintf(buf + strlen(buf), TSDB_MAX_BINARY_LEN - strlen(buf), "%s,", pTagsSchema[i].name);
+ } else {
+ snprintf(buf + strlen(buf), TSDB_MAX_BINARY_LEN - strlen(buf), "%s", pTagsSchema[i].name);
+ }
+ }
+
+ *result = buf;
+ return TSDB_CODE_SUCCESS;
+}
+static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, char *ddl) {
+ SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+
+ STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+ STableMeta * pMeta = pTableMetaInfo->pTableMeta;
+
+ SSqlObj *pInterSql = (SSqlObj *)calloc(1, sizeof(SSqlObj));
+ if (pInterSql == NULL) {
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+
+ SCreateBuilder *param = (SCreateBuilder *)malloc(sizeof(SCreateBuilder));
+ if (param == NULL) {
+ free(pInterSql);
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+
+ char fullName[TSDB_TABLE_FNAME_LEN] = {0};
+ extractDBName(pTableMetaInfo->name, fullName);
+ extractTableName(pMeta->sTableId, param->sTableName);
+ snprintf(fullName + strlen(fullName), TSDB_TABLE_FNAME_LEN - strlen(fullName), ".%s", param->sTableName);
+ extractTableName(pTableMetaInfo->name, param->buf);
+
+ param->pParentSql = pSql;
+ param->pInterSql = pInterSql;
+ param->fp = tscRebuildCreateTableStatement;
+ param->callStage = SCREATE_CALLBACK_QUERY;
+
+ char *query = (char *)calloc(1, TSDB_MAX_BINARY_LEN);
+ if (query == NULL) {
+ free(param);
+ free(pInterSql);
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+
+ char *columns = NULL;
+ int32_t code = tscGetTableTagColumnName(pSql, &columns) ;
+ if (code != TSDB_CODE_SUCCESS) {
+ free(param);
+ free(pInterSql);
+ free(query);
+ return code;
+ }
+
+ snprintf(query + strlen(query), TSDB_MAX_BINARY_LEN - strlen(query), "SELECT %s FROM %s WHERE TBNAME IN(\'%s\')", columns, fullName, param->buf);
+ doAsyncQuery(pSql->pTscObj, pInterSql, tscSCreateCallBack, param, query, strlen(query));
+ free(query);
+ free(columns);
+
+ return TSDB_CODE_TSC_ACTION_IN_PROGRESS;
+}
+static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName, char *ddl) {
+ SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+ STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+ STableMeta * pMeta = pTableMetaInfo->pTableMeta;
+
+ int32_t numOfRows = tscGetNumOfColumns(pMeta);
+ SSchema *pSchema = tscGetTableSchema(pMeta);
+
+ char *result = ddl;
+ sprintf(result, "create table %s (", tableName);
+ for (int32_t i = 0; i < numOfRows; ++i) {
+ uint8_t type = pSchema[i].type;
+ if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+ } else {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[pSchema[i].type].aName);
+ }
+ }
+ sprintf(result + strlen(result) - 1, "%s", ")");
+
+ return TSDB_CODE_SUCCESS;
+}
+static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName, char *ddl) {
+ char *result = ddl;
+ SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+ STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+ STableMeta * pMeta = pTableMetaInfo->pTableMeta;
+
+ int32_t numOfRows = tscGetNumOfColumns(pMeta);
+ int32_t totalRows = numOfRows + tscGetNumOfTags(pMeta);
+ SSchema *pSchema = tscGetTableSchema(pMeta);
+
+ sprintf(result, "create table %s (", tableName);
+ for (int32_t i = 0; i < numOfRows; ++i) {
+ uint8_t type = pSchema[i].type;
+ if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result),"%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+ } else {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName);
+ }
+ }
+ snprintf(result + strlen(result) - 1, TSDB_MAX_BINARY_LEN - strlen(result), "%s %s", ")", "TAGS (");
+
+ for (int32_t i = numOfRows; i < totalRows; i++) {
+ uint8_t type = pSchema[i].type;
+ if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+ } else {
+ snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName);
+ }
+ }
+ sprintf(result + strlen(result) - 1, "%s", ")");
+
+ return TSDB_CODE_SUCCESS;
+}
+
+static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
+ SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+ STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+ assert(pTableMetaInfo->pTableMeta != NULL);
+
+ char tableName[TSDB_TABLE_NAME_LEN] = {0};
+ extractTableName(pTableMetaInfo->name, tableName);
+
+ char *result = (char *)calloc(1, TSDB_MAX_BINARY_LEN);
+ int32_t code = TSDB_CODE_SUCCESS;
+ if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+ code = tscRebuildDDLForSuperTable(pSql, tableName, result);
+ } else if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
+ code = tscRebuildDDLForNormalTable(pSql, tableName, result);
+ } else if (UTIL_TABLE_IS_CHILD_TABLE(pTableMetaInfo)) {
+ code = tscRebuildDDLForSubTable(pSql, tableName, result);
+ } else {
+ code = TSDB_CODE_TSC_INVALID_VALUE;
+ }
+
+ if (code == TSDB_CODE_SUCCESS) {
+ code = tscSCreateBuildResult(pSql, SCREATE_BUILD_TABLE, tableName, result);
+ }
+ free(result);
+ return code;
+}
+
+static int32_t tscProcessShowCreateDatabase(SSqlObj *pSql) {
+ SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+
+ STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
+ SSqlObj *pInterSql = (SSqlObj *)calloc(1, sizeof(SSqlObj));
+ if (pInterSql == NULL) {
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+
+ SCreateBuilder *param = (SCreateBuilder *)malloc(sizeof(SCreateBuilder));
+ if (param == NULL) {
+ free(pInterSql);
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
+ }
+ extractTableName(pTableMetaInfo->name, param->buf);
+ param->pParentSql = pSql;
+ param->pInterSql = pInterSql;
+ param->fp = tscRebuildCreateDBStatement;
+ param->callStage = SCREATE_CALLBACK_QUERY;
+
+ const char *query = "show databases";
+ doAsyncQuery(pSql->pTscObj, pInterSql, tscSCreateCallBack, param, query, strlen(query));
+ return TSDB_CODE_TSC_ACTION_IN_PROGRESS;
+}
static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
-
+
SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
pExpr->resBytes = TSDB_USER_LEN + TSDB_DATA_TYPE_BINARY;
pExpr->resType = TSDB_DATA_TYPE_BINARY;
-
+
char* vx = calloc(1, pExpr->resBytes);
if (vx == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -287,7 +807,7 @@ static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
size_t size = sizeof(pSql->pTscObj->user);
STR_WITH_MAXSIZE_TO_VARSTR(vx, pSql->pTscObj->user, size);
-
+
tscSetLocalQueryResult(pSql, vx, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
free(vx);
@@ -297,15 +817,15 @@ static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
char db[TSDB_DB_NAME_LEN] = {0};
extractDBName(pSql->pTscObj->db, db);
-
+
SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
-
+
SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
pExpr->resType = TSDB_DATA_TYPE_BINARY;
-
+
size_t t = strlen(db);
pExpr->resBytes = TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE;
-
+
char* vx = calloc(1, pExpr->resBytes);
if (vx == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -316,7 +836,7 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
} else {
STR_WITH_SIZE_TO_VARSTR(vx, db, (VarDataLenT)t);
}
-
+
tscSetLocalQueryResult(pSql, vx, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
free(vx);
@@ -326,49 +846,53 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
static int32_t tscProcessServerVer(SSqlObj *pSql) {
const char* v = pSql->pTscObj->sversion;
SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
-
+
SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
pExpr->resType = TSDB_DATA_TYPE_BINARY;
-
+
size_t t = strlen(v);
pExpr->resBytes = (int16_t)(t + VARSTR_HEADER_SIZE);
-
+
char* vx = calloc(1, pExpr->resBytes);
if (vx == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
+
}
STR_WITH_SIZE_TO_VARSTR(vx, v, (VarDataLenT)t);
tscSetLocalQueryResult(pSql, vx, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
-
+
free(vx);
return TSDB_CODE_SUCCESS;
+
}
static int32_t tscProcessClientVer(SSqlObj *pSql) {
SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
-
+
SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
pExpr->resType = TSDB_DATA_TYPE_BINARY;
-
+
size_t t = strlen(version);
pExpr->resBytes = (int16_t)(t + VARSTR_HEADER_SIZE);
-
+
char* v = calloc(1, pExpr->resBytes);
if (v == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
+
}
STR_WITH_SIZE_TO_VARSTR(v, version, (VarDataLenT)t);
tscSetLocalQueryResult(pSql, v, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
-
+
free(v);
return TSDB_CODE_SUCCESS;
+
}
static int32_t tscProcessServStatus(SSqlObj *pSql) {
STscObj* pObj = pSql->pTscObj;
-
+
if (pObj->pHb != NULL) {
if (pObj->pHb->res.code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
pSql->res.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
@@ -379,9 +903,9 @@ static int32_t tscProcessServStatus(SSqlObj *pSql) {
return pSql->res.code;
}
}
-
+
SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
-
+
SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
int32_t val = 1;
tscSetLocalQueryResult(pSql, (char*) &val, pExpr->aliasName, TSDB_DATA_TYPE_INT, sizeof(int32_t));
@@ -393,23 +917,23 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa
SSqlRes *pRes = &pSql->res;
pCmd->numOfCols = 1;
-
+
SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
pQueryInfo->order.order = TSDB_ORDER_ASC;
-
+
tscFieldInfoClear(&pQueryInfo->fieldsInfo);
pQueryInfo->fieldsInfo.pFields = taosArrayInit(1, sizeof(TAOS_FIELD));
pQueryInfo->fieldsInfo.pSupportInfo = taosArrayInit(1, sizeof(SFieldSupInfo));
-
+
TAOS_FIELD f = tscCreateField((int8_t)type, columnName, (int16_t)valueLength);
tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-
+
tscInitResObjForLocalQuery(pSql, 1, (int32_t)valueLength);
TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, 0);
SFieldSupInfo* pInfo = tscFieldInfoGetSupp(&pQueryInfo->fieldsInfo, 0);
pInfo->pSqlExpr = taosArrayGetP(pQueryInfo->exprList, 0);
-
+
memcpy(pRes->data, val, pField->bytes);
}
@@ -428,6 +952,10 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
*/
pRes->qhandle = 0x1;
pRes->numOfRows = 0;
+ } else if (pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE) {
+ pRes->code = tscProcessShowCreateTable(pSql);
+ } else if (pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE) {
+ pRes->code = tscProcessShowCreateDatabase(pSql);
} else if (pCmd->command == TSDB_SQL_RESET_CACHE) {
taosCacheEmpty(tscMetaCache);
pRes->code = TSDB_CODE_SUCCESS;
@@ -447,12 +975,13 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
}
// keep the code in local variable in order to avoid invalid read in case of async query
+
int32_t code = pRes->code;
if (code == TSDB_CODE_SUCCESS) {
(*pSql->fp)(pSql->param, pSql, code);
+ } else if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS){
} else {
tscQueueAsyncRes(pSql);
}
-
return code;
}
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 327aac22d1..6fd97c09e9 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -1192,8 +1192,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
str += index;
if (TK_STRING == sToken.type) {
- strdequote(sToken.z);
- sToken.n = (uint32_t)strtrim(sToken.z);
+ tscDequoteAndTrimToken(&sToken);
}
if (sToken.type == TK_RP) {
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 620e8ea57a..cdbd8685df 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -545,7 +545,9 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
pSql->cmd.numOfParams = 0;
pSql->cmd.batchSize = 0;
-
+
+ registerSqlObj(pSql);
+
int32_t code = tsParseSql(pSql, true);
if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
// wait for the callback function to post the semaphore
@@ -574,7 +576,7 @@ int taos_stmt_close(TAOS_STMT* stmt) {
free(normal->sql);
}
- tscFreeSqlObj(pStmt->pSql);
+ taos_free_result(pStmt->pSql);
free(pStmt);
return TSDB_CODE_SUCCESS;
}
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index cceb876a06..b9d4cc13d1 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -368,7 +368,40 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
return tscGetTableMeta(pSql, pTableMetaInfo);
}
+ case TSDB_SQL_SHOW_CREATE_TABLE: {
+ SStrToken* pToken = &pInfo->pDCLInfo->a[0];
+ const char* msg1 = "invalid table name";
+ const char* msg2 = "table name is too long";
+ if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+ }
+
+ if (!tscValidateTableNameLength(pToken->n)) {
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ }
+
+ if (tscSetTableFullName(pTableMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ }
+ return tscGetTableMeta(pSql, pTableMetaInfo);
+ }
+ case TSDB_SQL_SHOW_CREATE_DATABASE: {
+ const char* msg1 = "invalid database name";
+ const char* msg2 = "table name is too long";
+ SStrToken* pToken = &pInfo->pDCLInfo->a[0];
+
+ if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+ }
+ if (pToken->n > TSDB_DB_NAME_LEN) {
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+ }
+ if (tscSetTableFullName(pTableMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
+ return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+ }
+ return TSDB_CODE_SUCCESS;
+ }
case TSDB_SQL_CFG_DNODE: {
const char* msg2 = "invalid configure options or values, such as resetlog / debugFlag 135 / balance 'vnode:2-dnode:2' / monitor 1 ";
const char* msg3 = "invalid dnode ep";
@@ -4873,6 +4906,7 @@ int32_t validateDNodeConfig(tDCLSQL* pOptions) {
{"cDebugFlag", 10}, {"httpDebugFlag", 13}, {"qDebugflag", 10}, {"sdbDebugFlag", 12},
{"uDebugFlag", 10}, {"tsdbDebugFlag", 13}, {"sDebugflag", 10}, {"rpcDebugFlag", 12},
{"dDebugFlag", 10}, {"mqttDebugFlag", 13}, {"wDebugFlag", 10}, {"tmrDebugFlag", 12},
+ {"cqDebugFlag", 11},
};
SStrToken* pOptionToken = &pOptions->a[1];
@@ -5286,9 +5320,12 @@ void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex) {
static void doUpdateSqlFunctionForTagPrj(SQueryInfo* pQueryInfo) {
int32_t tagLength = 0;
-
size_t size = taosArrayGetSize(pQueryInfo->exprList);
-
+
+//todo is 0??
+ STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+ bool isSTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo);
+
for (int32_t i = 0; i < size; ++i) {
SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
if (pExpr->functionId == TSDB_FUNC_TAGPRJ || pExpr->functionId == TSDB_FUNC_TAG) {
@@ -5300,8 +5337,7 @@ static void doUpdateSqlFunctionForTagPrj(SQueryInfo* pQueryInfo) {
}
}
- STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
- SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
+ SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
for (int32_t i = 0; i < size; ++i) {
SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
@@ -5309,7 +5345,7 @@ static void doUpdateSqlFunctionForTagPrj(SQueryInfo* pQueryInfo) {
!(pExpr->functionId == TSDB_FUNC_PRJ && TSDB_COL_IS_UD_COL(pExpr->colInfo.flag))) {
SSchema* pColSchema = &pSchema[pExpr->colInfo.colIndex];
getResultDataInfo(pColSchema->type, pColSchema->bytes, pExpr->functionId, (int32_t)pExpr->param[0].i64Key, &pExpr->resType,
- &pExpr->resBytes, &pExpr->interBytes, tagLength, true);
+ &pExpr->resBytes, &pExpr->interBytes, tagLength, isSTable);
}
}
}
@@ -5320,7 +5356,7 @@ static int32_t doUpdateSqlFunctionForColPrj(SQueryInfo* pQueryInfo) {
for (int32_t i = 0; i < size; ++i) {
SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
- if (pExpr->functionId == TSDB_FUNC_PRJ && (!TSDB_COL_IS_UD_COL(pExpr->colInfo.flag))) {
+ if (pExpr->functionId == TSDB_FUNC_PRJ && (!TSDB_COL_IS_UD_COL(pExpr->colInfo.flag) && (pExpr->colInfo.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX))) {
bool qualifiedCol = false;
for (int32_t j = 0; j < pQueryInfo->groupbyExpr.numOfGroupCols; ++j) {
SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, j);
@@ -5418,13 +5454,6 @@ static int32_t checkUpdateTagPrjFunctions(SQueryInfo* pQueryInfo, SSqlCmd* pCmd)
int16_t numOfSelectivity = 0;
int16_t numOfAggregation = 0;
- // todo is 0??
- STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
- bool isSTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo);
- if (!isSTable) {
- return TSDB_CODE_SUCCESS;
- }
-
size_t numOfExprs = taosArrayGetSize(pQueryInfo->exprList);
for (int32_t i = 0; i < numOfExprs; ++i) {
SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, i);
@@ -5726,7 +5755,7 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCMCreateDbMsg* pCreate) {
char msg[512] = {0};
if (pCreate->walLevel != -1 && (pCreate->walLevel < TSDB_MIN_WAL_LEVEL || pCreate->walLevel > TSDB_MAX_WAL_LEVEL)) {
- snprintf(msg, tListLen(msg), "invalid db option walLevel: %d, only 0-2 allowed", pCreate->walLevel);
+ snprintf(msg, tListLen(msg), "invalid db option walLevel: %d, only 1-2 allowed", pCreate->walLevel);
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
}
diff --git a/src/client/src/tscSchemaUtil.c b/src/client/src/tscSchemaUtil.c
index 244bb81164..1e841c68fd 100644
--- a/src/client/src/tscSchemaUtil.c
+++ b/src/client/src/tscSchemaUtil.c
@@ -170,6 +170,7 @@ STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size
pTableMeta->sversion = pTableMetaMsg->sversion;
pTableMeta->tversion = pTableMetaMsg->tversion;
+ tstrncpy(pTableMeta->sTableId, pTableMetaMsg->sTableId, TSDB_TABLE_FNAME_LEN);
memcpy(pTableMeta->schema, pTableMetaMsg->schema, schemaSize);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index c6e9cbafd7..3cbb0d936e 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -128,6 +128,7 @@ static void tscUpdateVgroupInfo(SSqlObj *pObj, SRpcEpSet *pEpSet) {
tscDebug("after: EndPoint in use: %d", pVgroupInfo->inUse);
taosCorEndWrite(&pVgroupInfo->version);
}
+
void tscPrintMgmtEp() {
SRpcEpSet dump;
tscDumpMgmtEpSet(&dump);
@@ -188,8 +189,8 @@ void tscProcessActivityTimer(void *handle, void *tmrId) {
if (tscShouldFreeHeartBeat(pHB)) {
tscDebug("%p free HB object and release connection", pHB);
- tscFreeSqlObj(pHB);
- tscCloseTscObj(pObj);
+ pObj->pHb = 0;
+ taos_free_result(pHB);
} else {
int32_t code = tscProcessSql(pHB);
if (code != TSDB_CODE_SUCCESS) {
@@ -745,7 +746,6 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
- /* column id is not valid according to the cached table meta, the table meta is expired */
tscError("%p table schema is not matched with parsed sql", pSql);
return TSDB_CODE_TSC_INVALID_SQL;
}
@@ -1959,6 +1959,7 @@ int tscProcessShowRsp(SSqlObj *pSql) {
return 0;
}
+// TODO multithread problem
static void createHBObj(STscObj* pObj) {
if (pObj->pHb != NULL) {
return;
@@ -1986,12 +1987,11 @@ static void createHBObj(STscObj* pObj) {
pSql->param = pObj;
pSql->pTscObj = pObj;
pSql->signature = pSql;
+
+ registerSqlObj(pSql);
+ tscDebug("%p HB is allocated, pObj:%p", pSql, pObj);
+
pObj->pHb = pSql;
- T_REF_INC(pObj);
-
- tscAddSubqueryInfo(&pObj->pHb->cmd);
-
- tscDebug("%p HB is allocated, pObj:%p", pObj->pHb, pObj);
}
int tscProcessConnectRsp(SSqlObj *pSql) {
@@ -2017,8 +2017,7 @@ int tscProcessConnectRsp(SSqlObj *pSql) {
pObj->connId = htonl(pConnect->connId);
createHBObj(pObj);
-
-// taosTmrReset(tscProcessActivityTimer, tsShellActivityTimer * 500, pObj, tscTmr, &pObj->pTimer);
+ taosTmrReset(tscProcessActivityTimer, tsShellActivityTimer * 500, pObj, tscTmr, &pObj->pTimer);
return 0;
}
@@ -2090,6 +2089,9 @@ int tscProcessAlterDbMsgRsp(SSqlObj *pSql) {
UNUSED(pSql);
return 0;
}
+int tscProcessShowCreateRsp(SSqlObj *pSql) {
+ return tscLocalResultCommonBuilder(pSql, 1);
+}
int tscProcessQueryRsp(SSqlObj *pSql) {
SSqlRes *pRes = &pSql->res;
@@ -2164,11 +2166,7 @@ static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInf
pNew->signature = pNew;
pNew->cmd.command = TSDB_SQL_META;
- T_REF_INC(pNew->pTscObj);
-
- // TODO add test case on x86 platform
- uint64_t adr = (uint64_t) pNew;
- pNew->self = taosCachePut(tscObjCache, &adr, sizeof(uint64_t), &pNew, sizeof(uint64_t), 2*60*1000);
+ registerSqlObj(pNew);
tscAddSubqueryInfo(&pNew->cmd);
@@ -2295,10 +2293,8 @@ int tscGetSTableVgroupInfo(SSqlObj *pSql, int32_t clauseIndex) {
}
pNewQueryInfo->numOfTables = pQueryInfo->numOfTables;
- T_REF_INC(pNew->pTscObj);
+ registerSqlObj(pNew);
- uint64_t p = (uint64_t) pNew;
- pNew->self = taosCachePut(tscObjCache, &p, sizeof(uint64_t), &pNew, sizeof(uint64_t), 2 * 600 * 1000);
tscDebug("%p new sqlObj:%p to get vgroupInfo, numOfTables:%d", pSql, pNew, pNewQueryInfo->numOfTables);
pNew->fp = tscTableMetaCallBack;
@@ -2376,6 +2372,10 @@ void tscInitMsgsFp() {
tscProcessMsgRsp[TSDB_SQL_ALTER_TABLE] = tscProcessAlterTableMsgRsp;
tscProcessMsgRsp[TSDB_SQL_ALTER_DB] = tscProcessAlterDbMsgRsp;
+ tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_TABLE] = tscProcessShowCreateRsp;
+ tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp;
+
+
tscKeepConn[TSDB_SQL_SHOW] = 1;
tscKeepConn[TSDB_SQL_RETRIEVE] = 1;
tscKeepConn[TSDB_SQL_SELECT] = 1;
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 69bc69cd4a..430a762321 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -156,10 +156,7 @@ SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con
*taos = pObj;
}
- T_REF_INC(pSql->pTscObj);
-
- uint64_t key = (uint64_t) pSql;
- pSql->self = taosCachePut(tscObjCache, &key, sizeof(uint64_t), &pSql, sizeof(uint64_t), 2*3600*1000);
+ registerSqlObj(pSql);
tsInsertHeadSize = sizeof(SMsgDesc) + sizeof(SSubmitMsg);
return pSql;
@@ -236,13 +233,21 @@ TAOS *taos_connect_c(const char *ip, uint8_t ipLen, const char *user, uint8_t us
return taos_connect(ipBuf, userBuf, passBuf, dbBuf, port);
}
+static void asyncConnCallback(void *param, TAOS_RES *tres, int code) {
+ SSqlObj *pSql = (SSqlObj *) tres;
+ assert(pSql != NULL);
+
+ pSql->fetchFp(pSql->param, tres, code);
+}
+
TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
void *param, void **taos) {
- SSqlObj* pSql = taosConnectImpl(ip, user, pass, NULL, db, port, fp, param, taos);
+ SSqlObj* pSql = taosConnectImpl(ip, user, pass, NULL, db, port, asyncConnCallback, param, taos);
if (pSql == NULL) {
return NULL;
}
+ pSql->fetchFp = fp;
pSql->res.code = tscProcessSql(pSql);
tscDebug("%p DB async connection is opening", taos);
return taos;
@@ -255,33 +260,17 @@ void taos_close(TAOS *taos) {
return;
}
- if (pObj->pHb != NULL) {
- if (pObj->pHb->pRpcCtx != NULL) { // wait for rsp from dnode
- rpcCancelRequest(pObj->pHb->pRpcCtx);
+ SSqlObj* pHb = pObj->pHb;
+ if (pHb != NULL && atomic_val_compare_exchange_ptr(&pObj->pHb, pHb, 0) == pHb) {
+ if (pHb->pRpcCtx != NULL) { // wait for rsp from dnode
+ rpcCancelRequest(pHb->pRpcCtx);
+ pHb->pRpcCtx = NULL;
}
- tscSetFreeHeatBeat(pObj);
- tscFreeSqlObj(pObj->pHb);
+ tscDebug("%p HB is freed", pHb);
+ taos_free_result(pHb);
}
- // free all sqlObjs created by using this connect before free the STscObj
-// while(1) {
-// pthread_mutex_lock(&pObj->mutex);
-// void* p = pObj->sqlList;
-// pthread_mutex_unlock(&pObj->mutex);
-//
-// if (p == NULL) {
-// break;
-// }
-//
-// tscDebug("%p waiting for sqlObj to be freed, %p", pObj, p);
-// taosMsleep(100);
-//
-// // todo fix me!! two threads call taos_free_result will cause problem.
-// tscDebug("%p free :%p", pObj, p);
-// taos_free_result(p);
-// }
-
int32_t ref = T_REF_DEC(pObj);
assert(ref >= 0);
@@ -485,6 +474,8 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE ||
pCmd->command == TSDB_SQL_FETCH ||
pCmd->command == TSDB_SQL_SHOW ||
+ pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE ||
+ pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE ||
pCmd->command == TSDB_SQL_SELECT ||
pCmd->command == TSDB_SQL_DESCRIBE_TABLE ||
pCmd->command == TSDB_SQL_SERV_STATUS ||
@@ -795,14 +786,17 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
}
SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
+
pSql->pTscObj = taos;
pSql->signature = pSql;
+
SSqlRes *pRes = &pSql->res;
SSqlCmd *pCmd = &pSql->cmd;
pRes->numOfTotal = 0;
pRes->numOfClauseTotal = 0;
+
tscDebug("%p Valid SQL: %s pObj:%p", pSql, sql, pObj);
int32_t sqlLen = (int32_t)strlen(sql);
@@ -838,11 +832,12 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
tsem_wait(&pSql->rspSem);
code = pSql->res.code;
}
+
if (code != TSDB_CODE_SUCCESS) {
tscDebug("%p Valid SQL result:%d, %s pObj:%p", pSql, code, taos_errstr(taos), pObj);
}
- taos_free_result(pSql);
+ taos_free_result(pSql);
return code;
}
@@ -941,34 +936,32 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
pSql->pTscObj = taos;
pSql->signature = pSql;
+
SSqlRes *pRes = &pSql->res;
+ pRes->code = 0;
pRes->numOfTotal = 0; // the number of getting table meta from server
pRes->numOfClauseTotal = 0;
- pRes->code = 0;
-
assert(pSql->fp == NULL);
tscDebug("%p tableNameList: %s pObj:%p", pSql, tableNameList, pObj);
int32_t tblListLen = (int32_t)strlen(tableNameList);
if (tblListLen > MAX_TABLE_NAME_LENGTH) {
tscError("%p tableNameList too long, length:%d, maximum allowed:%d", pSql, tblListLen, MAX_TABLE_NAME_LENGTH);
- pRes->code = TSDB_CODE_TSC_INVALID_SQL;
- taosTFree(pSql);
- return pRes->code;
+ tscFreeSqlObj(pSql);
+ return TSDB_CODE_TSC_INVALID_SQL;
}
char *str = calloc(1, tblListLen + 1);
if (str == NULL) {
- pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
tscError("%p failed to malloc sql string buffer", pSql);
- taosTFree(pSql);
- return pRes->code;
+ tscFreeSqlObj(pSql);
+ return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
strtolower(str, tableNameList);
- pRes->code = (uint8_t)tscParseTblNameList(pSql, str, tblListLen);
+ int32_t code = (uint8_t) tscParseTblNameList(pSql, str, tblListLen);
/*
* set the qhandle to 0 before return in order to erase the qhandle value assigned in the previous successful query.
@@ -978,17 +971,17 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
pRes->qhandle = 0;
free(str);
- if (pRes->code != TSDB_CODE_SUCCESS) {
+ if (code != TSDB_CODE_SUCCESS) {
tscFreeSqlObj(pSql);
- return pRes->code;
+ return code;
}
tscDoQuery(pSql);
- tscDebug("%p load multi metermeta result:%d %s pObj:%p", pSql, pRes->code, taos_errstr(taos), pObj);
- if (pRes->code != TSDB_CODE_SUCCESS) {
- tscPartiallyFreeSqlObj(pSql);
+ tscDebug("%p load multi table meta result:%d %s pObj:%p", pSql, pRes->code, taos_errstr(taos), pObj);
+ if ((code = pRes->code) != TSDB_CODE_SUCCESS) {
+ tscFreeSqlObj(pSql);
}
- return pRes->code;
+ return code;
}
diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index 4a1f4d9d87..81b8cf7359 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -136,7 +136,6 @@ static void tscProcessStreamTimer(void *handle, void *tmrId) {
etime = pStream->stime + (etime - pStream->stime) / pStream->interval.interval * pStream->interval.interval;
} else {
etime = taosTimeTruncate(etime, &pStream->interval, pStream->precision);
- //etime = taosGetIntervalStartTimestamp(etime, pStream->interval.sliding, pStream->interval.sliding, pStream->interval.slidingUnit, pStream->precision);
}
pQueryInfo->window.ekey = etime;
if (pQueryInfo->window.skey >= pQueryInfo->window.ekey) {
@@ -454,17 +453,11 @@ static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, in
}
} else { // timewindow based aggregation stream
if (stime == 0) { // no data in meter till now
- stime = pQueryInfo->window.skey;
- if (stime == INT64_MIN) {
- stime = (int64_t)taosGetTimestamp(pStream->precision);
- stime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
- stime = taosTimeTruncate(stime - 1, &pStream->interval, pStream->precision);
- //stime = taosGetIntervalStartTimestamp(stime, pStream->interval.interval, pStream->interval.interval, pStream->interval.intervalUnit, pStream->precision);
- //stime = taosGetIntervalStartTimestamp(stime - 1, pStream->interval.interval, pStream->interval.interval, pStream->interval.intervalUnit, pStream->precision);
- tscWarn("%p stream:%p, last timestamp:0, reset to:%" PRId64, pSql, pStream, stime);
+ if (pQueryInfo->window.skey != INT64_MIN) {
+ stime = pQueryInfo->window.skey;
}
+ stime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
} else {
- //int64_t newStime = taosGetIntervalStartTimestamp(stime, pStream->interval.interval, pStream->interval.interval, pStream->interval.intervalUnit, pStream->precision);
int64_t newStime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
if (newStime != stime) {
tscWarn("%p stream:%p, last timestamp:%" PRId64 ", reset to:%" PRId64, pSql, pStream, stime, newStime);
@@ -477,8 +470,10 @@ static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, in
}
static int64_t tscGetLaunchTimestamp(const SSqlStream *pStream) {
- int64_t timer = pStream->stime - taosGetTimestamp(pStream->precision);
- if (timer < 0) timer = 0;
+ int64_t timer = 0, now = taosGetTimestamp(pStream->precision);
+ if (pStream->stime > now) {
+ timer = pStream->stime - now;
+ }
int64_t startDelay =
(pStream->precision == TSDB_TIME_PRECISION_MICRO) ? tsStreamCompStartDelay * 1000L : tsStreamCompStartDelay;
@@ -515,6 +510,8 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
return;
}
+ registerSqlObj(pSql);
+
SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
@@ -568,6 +565,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
pStream->pSql = pSql;
pSql->pStream = pStream;
pSql->param = pStream;
+ pSql->maxRetry = TSDB_MAX_REPLICA;
pSql->sqlstr = calloc(1, strlen(sqlstr) + 1);
if (pSql->sqlstr == NULL) {
@@ -575,6 +573,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
tscFreeSqlObj(pSql);
return NULL;
}
+
strtolower(pSql->sqlstr, sqlstr);
tscDebugL("%p SQL: %s", pSql, pSql->sqlstr);
@@ -615,10 +614,9 @@ void taos_close_stream(TAOS_STREAM *handle) {
tscDebug("%p stream:%p is closed", pSql, pStream);
// notify CQ to release the pStream object
pStream->fp(pStream->param, NULL, NULL);
-
- tscFreeSqlObj(pSql);
pStream->pSql = NULL;
+ taos_free_result(pSql);
taosTFree(pStream);
}
}
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index 76bce19668..2c81bd7c7c 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -105,6 +105,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
code = TAOS_SYSTEM_ERROR(errno);
goto fail;
}
+
tstrncpy(pSub->topic, topic, sizeof(pSub->topic));
pSub->progress = taosArrayInit(32, sizeof(SSubscriptionProgress));
if (pSub->progress == NULL) {
@@ -119,6 +120,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
code = TSDB_CODE_TSC_OUT_OF_MEMORY;
goto fail;
}
+
pSql->signature = pSql;
pSql->pTscObj = pObj;
pSql->pSubscription = pSub;
@@ -142,6 +144,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
code = TSDB_CODE_TSC_OUT_OF_MEMORY;
goto fail;
}
+
strtolower(pSql->sqlstr, pSql->sqlstr);
pRes->qhandle = 0;
pRes->numOfRows = 1;
@@ -152,11 +155,14 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
goto fail;
}
+ registerSqlObj(pSql);
+
code = tsParseSql(pSql, false);
if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
tsem_wait(&pSub->sem);
code = pSql->res.code;
}
+
if (code != TSDB_CODE_SUCCESS) {
line = __LINE__;
goto fail;
@@ -173,9 +179,15 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
fail:
tscError("tscCreateSubscription failed at line %d, reason: %s", line, tstrerror(code));
if (pSql != NULL) {
- tscFreeSqlObj(pSql);
+ if (pSql->self != NULL) {
+ taos_free_result(pSql);
+ } else {
+ tscFreeSqlObj(pSql);
+ }
+
pSql = NULL;
}
+
if (pSub != NULL) {
taosArrayDestroy(pSub->progress);
tsem_destroy(&pSub->sem);
@@ -494,6 +506,10 @@ void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress) {
}
}
+ if (pSub->pSql != NULL) {
+ taos_free_result(pSub->pSql);
+ }
+
tscFreeSqlObj(pSub->pSql);
taosArrayDestroy(pSub->progress);
tsem_destroy(&pSub->sem);
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index f9bb180810..390c3ca92d 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -23,6 +23,7 @@
#include "tscSubquery.h"
#include "tschemautil.h"
#include "tsclient.h"
+#include "tscSubquery.h"
typedef struct SInsertSupporter {
SSubqueryState* pState;
@@ -278,7 +279,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
tscDebug("%p subIndex: %d, no need to launch query, ignore it", pSql, i);
tscDestroyJoinSupporter(pSupporter);
- tscFreeSqlObj(pPrevSub);
+ taos_free_result(pPrevSub);
pSql->pSubs[i] = NULL;
continue;
@@ -1383,7 +1384,7 @@ static void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs, SSubqueryState
taosTFree(pSupport->localBuffer);
taosTFree(pSupport);
- tscFreeSqlObj(pSub);
+ taos_free_result(pSub);
}
free(pState);
diff --git a/src/client/src/tscSystem.c b/src/client/src/tscSystem.c
index 82ce1d3679..620fe13a9f 100644
--- a/src/client/src/tscSystem.c
+++ b/src/client/src/tscSystem.c
@@ -122,11 +122,8 @@ void taos_init_imp(void) {
tscInitMsgsFp();
int queueSize = tsMaxConnections*2;
- if (tscEmbedded == 0) {
- tscNumOfThreads = (int)(tsNumOfCores * tsNumOfThreadsPerCore / 2.0);
- } else {
- tscNumOfThreads = (int)(tsNumOfCores * tsNumOfThreadsPerCore / 4.0);
- }
+ double factor = (tscEmbedded == 0)? 2.0:4.0;
+ tscNumOfThreads = (int)(tsNumOfCores * tsNumOfThreadsPerCore / factor);
if (tscNumOfThreads < 2) tscNumOfThreads = 2;
@@ -140,11 +137,8 @@ void taos_init_imp(void) {
if(0 == tscEmbedded){
taosTmrReset(tscCheckDiskUsage, 10, NULL, tscTmr, &tscCheckDiskUsageTmr);
}
-
- int64_t refreshTime = tsTableMetaKeepTimer;
- refreshTime = refreshTime > 10 ? 10 : refreshTime;
- refreshTime = refreshTime < 10 ? 10 : refreshTime;
+ int64_t refreshTime = 10; // 10 seconds by default
if (tscMetaCache == NULL) {
tscMetaCache = taosCacheInit(TSDB_DATA_TYPE_BINARY, refreshTime, false, NULL, "tableMeta");
tscObjCache = taosCacheInit(TSDB_DATA_TYPE_BIGINT, refreshTime/2, false, tscFreeSqlObjInCache, "sqlObj");
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 38fb63f18e..33362409cf 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -391,10 +391,21 @@ static UNUSED_FUNC void tscFreeSubobj(SSqlObj* pSql) {
*/
void tscFreeSqlObjInCache(void *pSql) {
assert(pSql != NULL);
+
SSqlObj** p = (SSqlObj**)pSql;
+ STscObj* pTscObj = (*p)->pTscObj;
assert((*p)->self != 0 && (*p)->self == (p));
tscFreeSqlObj(*p);
+
+ int32_t ref = T_REF_DEC(pTscObj);
+ assert(ref >= 0);
+
+ tscDebug("%p free sqlObj completed, tscObj:%p ref:%d", *p, pTscObj, ref);
+ if (ref == 0) {
+ tscDebug("%p all sqlObj freed, free tscObj:%p", *p, pTscObj);
+ tscCloseTscObj(pTscObj);
+ }
}
void tscFreeSqlObj(SSqlObj* pSql) {
@@ -403,7 +414,6 @@ void tscFreeSqlObj(SSqlObj* pSql) {
}
tscDebug("%p start to free sqlObj", pSql);
- STscObj* pTscObj = pSql->pTscObj;
tscFreeSubobj(pSql);
tscPartiallyFreeSqlObj(pSql);
@@ -421,14 +431,6 @@ void tscFreeSqlObj(SSqlObj* pSql) {
tsem_destroy(&pSql->rspSem);
free(pSql);
- tscDebug("%p free sqlObj completed", pSql);
-
- int32_t ref = T_REF_DEC(pTscObj);
- assert(ref >= 0);
-
- if (ref == 0) {
- tscCloseTscObj(pTscObj);
- }
}
void tscDestroyDataBlock(STableDataBlocks* pDataBlock) {
@@ -1265,6 +1267,51 @@ static int32_t validateQuoteToken(SStrToken* pToken) {
return TSDB_CODE_SUCCESS;
}
+void tscDequoteAndTrimToken(SStrToken* pToken) {
+ assert(pToken->type == TK_STRING);
+
+ uint32_t first = 0, last = pToken->n;
+
+ // trim leading spaces
+ while (first < last) {
+ char c = pToken->z[first];
+ if (c != ' ' && c != '\t') {
+ break;
+ }
+ first++;
+ }
+
+ // trim ending spaces
+ while (first < last) {
+ char c = pToken->z[last - 1];
+ if (c != ' ' && c != '\t') {
+ break;
+ }
+ last--;
+ }
+
+ // there are still at least two characters
+ if (first < last - 1) {
+ char c = pToken->z[first];
+ // dequote
+ if ((c == '\'' || c == '"') && c == pToken->z[last - 1]) {
+ first++;
+ last--;
+ }
+ }
+
+ // left shift the string and pad spaces
+ for (uint32_t i = 0; i + first < last; i++) {
+ pToken->z[i] = pToken->z[first + i];
+ }
+ for (uint32_t i = last - first; i < pToken->n; i++) {
+ pToken->z[i] = ' ';
+ }
+
+ // adjust token length
+ pToken->n = last - first;
+}
+
int32_t tscValidateName(SStrToken* pToken) {
if (pToken->type != TK_STRING && pToken->type != TK_ID) {
return TSDB_CODE_TSC_INVALID_SQL;
@@ -1735,6 +1782,16 @@ void tscResetForNextRetrieve(SSqlRes* pRes) {
pRes->numOfRows = 0;
}
+void registerSqlObj(SSqlObj* pSql) {
+ int32_t DEFAULT_LIFE_TIME = 2 * 600 * 1000; // 1200 sec
+
+ int32_t ref = T_REF_INC(pSql->pTscObj);
+ tscDebug("%p add to tscObj:%p, ref:%d", pSql, pSql->pTscObj, ref);
+
+ uint64_t p = (uint64_t) pSql;
+ pSql->self = taosCachePut(tscObjCache, &p, sizeof(uint64_t), &p, sizeof(uint64_t), DEFAULT_LIFE_TIME);
+}
+
SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cmd) {
SSqlObj* pNew = (SSqlObj*)calloc(1, sizeof(SSqlObj));
if (pNew == NULL) {
@@ -1743,13 +1800,12 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cm
}
pNew->pTscObj = pSql->pTscObj;
- T_REF_INC(pNew->pTscObj);
-
pNew->signature = pNew;
SSqlCmd* pCmd = &pNew->cmd;
pCmd->command = cmd;
pCmd->parseFinished = 1;
+ pCmd->autoCreated = pSql->cmd.autoCreated;
if (tscAddSubqueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
tscFreeSqlObj(pNew);
@@ -1764,8 +1820,7 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cm
pNew->sqlstr = strdup(pSql->sqlstr);
if (pNew->sqlstr == NULL) {
tscError("%p new subquery failed", pSql);
-
- free(pNew);
+ tscFreeSqlObj(pNew);
return NULL;
}
@@ -1776,10 +1831,7 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cm
tscAddTableMetaInfo(pQueryInfo, pMasterTableMetaInfo->name, NULL, NULL, NULL);
- T_REF_INC(pNew->pTscObj);
-
- uint64_t p = (uint64_t) pNew;
- pNew->self = taosCachePut(tscObjCache, &p, sizeof(uint64_t), &pNew, sizeof(uint64_t), 2 * 600 * 1000);
+ registerSqlObj(pNew);
return pNew;
}
@@ -1869,7 +1921,6 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
pNew->pTscObj = pSql->pTscObj;
pNew->signature = pNew;
- T_REF_INC(pNew->pTscObj);
pNew->sqlstr = strdup(pSql->sqlstr);
if (pNew->sqlstr == NULL) {
@@ -2018,10 +2069,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
tscDebug("%p new sub insertion: %p, vnodeIdx:%d", pSql, pNew, pTableMetaInfo->vgroupIndex);
}
- T_REF_INC(pNew->pTscObj);
-
- uint64_t p = (uint64_t) pNew;
- pNew->self = taosCachePut(tscObjCache, &p, sizeof(uint64_t), &pNew, sizeof(uint64_t), 2 * 600 * 10);
+ registerSqlObj(pNew);
return pNew;
_error:
diff --git a/src/common/inc/tcmdtype.h b/src/common/inc/tcmdtype.h
index 90fb5bf478..69bbccd67e 100644
--- a/src/common/inc/tcmdtype.h
+++ b/src/common/inc/tcmdtype.h
@@ -78,6 +78,9 @@ enum {
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RETRIEVE_LOCALMERGE, "retrieve-localmerge" )
TSDB_DEFINE_SQL_TYPE( TSDB_SQL_TABLE_JOIN_RETRIEVE, "join-retrieve" )
+ TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW_CREATE_TABLE, "show-create-table")
+ TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW_CREATE_DATABASE, "show-create-database")
+
/*
* build empty result instead of accessing dnode to fetch result
* reset the client cache
diff --git a/src/common/inc/tglobal.h b/src/common/inc/tglobal.h
index 77e8b76456..798e265455 100644
--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -174,6 +174,7 @@ extern int32_t rpcDebugFlag;
extern int32_t odbcDebugFlag;
extern int32_t qDebugFlag;
extern int32_t wDebugFlag;
+extern int32_t cqDebugFlag;
extern int32_t debugFlag;
#define NEEDTO_COMPRESSS_MSG(size) (tsCompressMsgSize != -1 && (size) > tsCompressMsgSize)
diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c
index 7e46f58a93..a75e712f38 100644
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -131,7 +131,7 @@ uint16_t tsHttpPort = 6041; // only tcp, range tcp[6041]
int32_t tsHttpCacheSessions = 1000;
int32_t tsHttpSessionExpire = 36000;
int32_t tsHttpMaxThreads = 2;
-int32_t tsHttpEnableCompress = 0;
+int32_t tsHttpEnableCompress = 1;
int32_t tsHttpEnableRecordSql = 0;
int32_t tsTelegrafUseFieldNum = 0;
@@ -203,6 +203,7 @@ int32_t debugFlag = 0;
int32_t sDebugFlag = 135;
int32_t wDebugFlag = 135;
int32_t tsdbDebugFlag = 131;
+int32_t cqDebugFlag = 135;
int32_t (*monitorStartSystemFp)() = NULL;
void (*monitorStopSystemFp)() = NULL;
@@ -222,12 +223,13 @@ void taosSetAllDebugFlag() {
httpDebugFlag = debugFlag;
mqttDebugFlag = debugFlag;
monitorDebugFlag = debugFlag;
+ qDebugFlag = debugFlag;
rpcDebugFlag = debugFlag;
uDebugFlag = debugFlag;
sDebugFlag = debugFlag;
wDebugFlag = debugFlag;
tsdbDebugFlag = debugFlag;
- qDebugFlag = debugFlag;
+ cqDebugFlag = debugFlag;
uInfo("all debug flag are set to %d", debugFlag);
}
}
@@ -1209,6 +1211,16 @@ static void doInitGlobalConfig(void) {
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
+ cfg.option = "cqDebugFlag";
+ cfg.ptr = &cqDebugFlag;
+ cfg.valType = TAOS_CFG_VTYPE_INT32;
+ cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_LOG;
+ cfg.minValue = 0;
+ cfg.maxValue = 255;
+ cfg.ptrLength = 0;
+ cfg.unitType = TAOS_CFG_UTYPE_NONE;
+ taosInitConfigOption(cfg);
+
cfg.option = "tscEnableRecordSql";
cfg.ptr = &tsTscEnableRecordSql;
cfg.valType = TAOS_CFG_VTYPE_INT32;
diff --git a/src/connector/go b/src/connector/go
index 8c58c512b6..06ec30a0f1 160000
--- a/src/connector/go
+++ b/src/connector/go
@@ -1 +1 @@
-Subproject commit 8c58c512b6acda8bcdfa48fdc7140227b5221766
+Subproject commit 06ec30a0f1762e8169bf6b9045c82bcaa52bcdf0
diff --git a/src/connector/jdbc/deploy-pom.xml b/src/connector/jdbc/deploy-pom.xml
index 766a58f9ba..3f6ebeff03 100755
--- a/src/connector/jdbc/deploy-pom.xml
+++ b/src/connector/jdbc/deploy-pom.xml
@@ -5,10 +5,9 @@
com.taosdata.jdbc
taos-jdbcdriver
- 2.0.0-SNAPSHOT
+ 2.0.6
jar
-
JDBCDriver
https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc
TDengine JDBC Driver
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
index bc649a31e1..13be9d538d 100755
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
@@ -291,8 +291,8 @@ public class TSDBDriver implements java.sql.Driver {
return null;
}
- String lowerUrl = url.toLowerCase();
- if (!lowerUrl.startsWith(URL_PREFIX) && !lowerUrl.startsWith(URL_PREFIX1)) {
+// String lowerUrl = url.toLowerCase();
+ if (!url.startsWith(URL_PREFIX) && !url.startsWith(URL_PREFIX1)) {
return null;
}
diff --git a/src/cq/CMakeLists.txt b/src/cq/CMakeLists.txt
index db366639ef..e631397348 100644
--- a/src/cq/CMakeLists.txt
+++ b/src/cq/CMakeLists.txt
@@ -2,6 +2,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
PROJECT(TDengine)
INCLUDE_DIRECTORIES(inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/client/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc)
AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SRC)
IF (TD_LINUX)
diff --git a/src/cq/src/cqMain.c b/src/cq/src/cqMain.c
index d8f68f66a5..1a99a84b8e 100644
--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
@@ -21,6 +21,7 @@
#include
#include "taos.h"
+#include "tsclient.h"
#include "taosdef.h"
#include "taosmsg.h"
#include "ttimer.h"
@@ -65,8 +66,6 @@ typedef struct SCqObj {
SCqContext * pContext;
} SCqObj;
-int cqDebugFlag = 135;
-
static void cqProcessStreamRes(void *param, TAOS_RES *tres, TAOS_ROW row);
static void cqCreateStream(SCqContext *pContext, SCqObj *pObj);
@@ -238,24 +237,31 @@ void cqDrop(void *handle) {
pthread_mutex_unlock(&pContext->mutex);
}
+static void doCreateStream(void *param, TAOS_RES *result, int code) {
+ SCqObj* pObj = (SCqObj*)param;
+ SCqContext* pContext = pObj->pContext;
+ SSqlObj* pSql = (SSqlObj*)result;
+ pContext->dbConn = pSql->pTscObj;
+ cqCreateStream(pContext, pObj);
+}
+
static void cqProcessCreateTimer(void *param, void *tmrId) {
SCqObj* pObj = (SCqObj*)param;
SCqContext* pContext = pObj->pContext;
if (pContext->dbConn == NULL) {
- pContext->dbConn = taos_connect("localhost", pContext->user, pContext->pass, pContext->db, 0);
- if (pContext->dbConn == NULL) {
- cError("vgId:%d, failed to connect to TDengine(%s)", pContext->vgId, tstrerror(terrno));
- }
+ cDebug("vgId:%d, try connect to TDengine", pContext->vgId);
+ taos_connect_a(NULL, pContext->user, pContext->pass, pContext->db, 0, doCreateStream, param, NULL);
+ } else {
+ cqCreateStream(pContext, pObj);
}
-
- cqCreateStream(pContext, pObj);
}
static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) {
pObj->pContext = pContext;
if (pContext->dbConn == NULL) {
+ cDebug("vgId:%d, create dbConn after 1000 ms", pContext->vgId);
pObj->tmrId = taosTmrStart(cqProcessCreateTimer, 1000, pObj, pContext->tmrCtrl);
return;
}
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index e49e2caca1..50b31a86cc 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -673,6 +673,7 @@ typedef struct {
typedef struct STableMetaMsg {
int32_t contLen;
char tableId[TSDB_TABLE_FNAME_LEN]; // table id
+ char sTableId[TSDB_TABLE_FNAME_LEN];
uint8_t numOfTags;
uint8_t precision;
uint8_t tableType;
diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index c5831a9b8a..a94cdaad15 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -16,6 +16,7 @@
#ifndef TDENGINE_TTOKENDEF_H
#define TDENGINE_TTOKENDEF_H
+
#define TK_ID 1
#define TK_BOOL 2
#define TK_TINYINT 3
@@ -75,24 +76,24 @@
#define TK_VNODES 57
#define TK_IPTOKEN 58
#define TK_DOT 59
-#define TK_TABLES 60
-#define TK_STABLES 61
-#define TK_VGROUPS 62
-#define TK_DROP 63
-#define TK_TABLE 64
-#define TK_DATABASE 65
-#define TK_DNODE 66
-#define TK_USER 67
-#define TK_ACCOUNT 68
-#define TK_USE 69
-#define TK_DESCRIBE 70
-#define TK_ALTER 71
-#define TK_PASS 72
-#define TK_PRIVILEGE 73
-#define TK_LOCAL 74
-#define TK_IF 75
-#define TK_EXISTS 76
-#define TK_CREATE 77
+#define TK_CREATE 60
+#define TK_TABLE 61
+#define TK_DATABASE 62
+#define TK_TABLES 63
+#define TK_STABLES 64
+#define TK_VGROUPS 65
+#define TK_DROP 66
+#define TK_DNODE 67
+#define TK_USER 68
+#define TK_ACCOUNT 69
+#define TK_USE 70
+#define TK_DESCRIBE 71
+#define TK_ALTER 72
+#define TK_PASS 73
+#define TK_PRIVILEGE 74
+#define TK_LOCAL 75
+#define TK_IF 76
+#define TK_EXISTS 77
#define TK_PPS 78
#define TK_TSERIES 79
#define TK_DBS 80
@@ -222,7 +223,6 @@
#define TK_INTO 204
#define TK_VALUES 205
-
#define TK_SPACE 300
#define TK_COMMENT 301
#define TK_ILLEGAL 302
diff --git a/src/inc/twal.h b/src/inc/twal.h
index 4fdb7aa275..cf570aefdc 100644
--- a/src/inc/twal.h
+++ b/src/inc/twal.h
@@ -44,6 +44,7 @@ typedef void* twalh; // WAL HANDLE
typedef int (*FWalWrite)(void *ahandle, void *pHead, int type);
twalh walOpen(const char *path, const SWalCfg *pCfg);
+int walAlter(twalh pWal, const SWalCfg *pCfg);
void walClose(twalh);
int walRenew(twalh);
int walWrite(twalh, SWalHead *);
diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c
index 54c049d242..8558350950 100644
--- a/src/mnode/src/mnodeDb.c
+++ b/src/mnode/src/mnodeDb.c
@@ -910,13 +910,13 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
}
if (walLevel > 0 && walLevel != pDb->cfg.walLevel) {
- mError("db:%s, can't alter walLevel option", pDb->name);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+ mDebug("db:%s, walLevel:%d change to %d", pDb->name, pDb->cfg.walLevel, walLevel);
+ newCfg.walLevel = walLevel;
}
if (fsyncPeriod >= 0 && fsyncPeriod != pDb->cfg.fsyncPeriod) {
- mError("db:%s, can't alter fsyncPeriod option", pDb->name);
- terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+ mDebug("db:%s, fsyncPeriod:%d change to %d", pDb->name, pDb->cfg.fsyncPeriod, fsyncPeriod);
+ newCfg.fsyncPeriod = fsyncPeriod;
}
if (replications > 0 && replications != pDb->cfg.replications) {
diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c
index f66ef6b7a3..f2caf30564 100644
--- a/src/mnode/src/mnodeShow.c
+++ b/src/mnode/src/mnodeShow.c
@@ -65,7 +65,7 @@ int32_t mnodeInitShow() {
mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_CONNECT, mnodeProcessConnectMsg);
mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_USE_DB, mnodeProcessUseMsg);
- tsMnodeShowCache = taosCacheInit(TSDB_DATA_TYPE_BIGINT, 5, false, mnodeFreeShowObj, "show");
+ tsMnodeShowCache = taosCacheInit(TSDB_DATA_TYPE_BIGINT, 5, true, mnodeFreeShowObj, "show");
return 0;
}
@@ -389,10 +389,12 @@ static bool mnodeAccquireShowObj(SShowObj *pShow) {
}
static void* mnodePutShowObj(SShowObj *pShow) {
+ const int32_t DEFAULT_SHOWHANDLE_LIFE_SPAN = tsShellActivityTimer * 6 * 1000;
+
if (tsMnodeShowCache != NULL) {
pShow->index = atomic_add_fetch_32(&tsShowObjIndex, 1);
uint64_t handleVal = (uint64_t)pShow;
- SShowObj **ppShow = taosCachePut(tsMnodeShowCache, &handleVal, sizeof(int64_t), &pShow, sizeof(int64_t), 6000);
+ SShowObj **ppShow = taosCachePut(tsMnodeShowCache, &handleVal, sizeof(int64_t), &pShow, sizeof(int64_t), DEFAULT_SHOWHANDLE_LIFE_SPAN);
pShow->ppShow = (void**)ppShow;
mDebug("%p, show is put into cache, data:%p index:%d", pShow, ppShow, pShow->index);
return pShow;
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 4400927e9b..43b80f65c8 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1384,6 +1384,9 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
}
pShow->numOfReads += numOfRows;
+ const int32_t NUM_OF_COLUMNS = 5;
+
+ mnodeVacuumResult(data, NUM_OF_COLUMNS, numOfRows, rows, pShow);
mnodeDecDbRef(pDb);
return numOfRows;
@@ -2090,6 +2093,9 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
pMeta->precision = pDb->cfg.precision;
pMeta->tableType = pTable->info.type;
tstrncpy(pMeta->tableId, pTable->info.tableId, TSDB_TABLE_FNAME_LEN);
+ if (pTable->superTable) {
+ tstrncpy(pMeta->sTableId, pTable->superTable->info.tableId, TSDB_TABLE_FNAME_LEN);
+ }
if (pTable->info.type == TSDB_CHILD_TABLE) {
pMeta->sversion = htons(pTable->superTable->sversion);
@@ -2122,8 +2128,8 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
}
pMeta->vgroup.vgId = htonl(pMsg->pVgroup->vgId);
- mDebug("app:%p:%p, table:%s, uid:%" PRIu64 " table meta is retrieved", pMsg->rpcMsg.ahandle, pMsg,
- pTable->info.tableId, pTable->uid);
+ mDebug("app:%p:%p, table:%s, uid:%" PRIu64 " table meta is retrieved, vgId:%d sid:%d", pMsg->rpcMsg.ahandle, pMsg,
+ pTable->info.tableId, pTable->uid, pTable->vgId, pTable->sid);
return TSDB_CODE_SUCCESS;
}
diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
index aa6631ff83..9345bdae2c 100644
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -660,13 +660,13 @@ static int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *p
for (int32_t i = 0; i < pShow->maxReplica; ++i) {
pShow->bytes[cols] = 2;
pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
- strcpy(pSchema[cols].name, "dnode");
+ snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "dnode%d", i + 1);
pSchema[cols].bytes = htons(pShow->bytes[cols]);
cols++;
pShow->bytes[cols] = 9 + VARSTR_HEADER_SIZE;
pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
- strcpy(pSchema[cols].name, "vstatus");
+ snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "v%dstatus", i + 1);
pSchema[cols].bytes = htons(pShow->bytes[cols]);
cols++;
}
diff --git a/src/plugins/http/inc/httpJson.h b/src/plugins/http/inc/httpJson.h
index ac0a632137..fcb74253b9 100644
--- a/src/plugins/http/inc/httpJson.h
+++ b/src/plugins/http/inc/httpJson.h
@@ -19,7 +19,7 @@
#include
#include
-#define JSON_BUFFER_SIZE 10240
+#define JSON_BUFFER_SIZE 16384
struct HttpContext;
enum { JsonNumber, JsonString, JsonBoolean, JsonArray, JsonObject, JsonNull };
diff --git a/src/plugins/http/src/httpJson.c b/src/plugins/http/src/httpJson.c
index e9a8947df2..7600fb3e43 100644
--- a/src/plugins/http/src/httpJson.c
+++ b/src/plugins/http/src/httpJson.c
@@ -52,12 +52,12 @@ int32_t httpWriteBufByFd(struct HttpContext* pContext, const char* buf, int32_t
}
if (len < 0) {
- httpDebug("context:%p, fd:%d, socket write errno:%d, times:%d", pContext, pContext->fd, errno, countWait);
+ httpDebug("context:%p, fd:%d, socket write errno:%d:%s, times:%d", pContext, pContext->fd, errno, strerror(errno), countWait);
if (++countWait > HTTP_WRITE_RETRY_TIMES) break;
taosMsleep(HTTP_WRITE_WAIT_TIME_MS);
continue;
} else if (len == 0) {
- httpDebug("context:%p, fd:%d, socket write errno:%d, connect already closed", pContext, pContext->fd, errno);
+ httpDebug("context:%p, fd:%d, socket write errno:%d:%s, connect already closed", pContext, pContext->fd, errno, strerror(errno));
break;
} else {
countWait = 0;
@@ -131,14 +131,14 @@ int32_t httpWriteJsonBufBody(JsonBuf* buf, bool isTheLast) {
httpWriteBufNoTrace(buf->pContext, sLen, len);
remain = httpWriteBufNoTrace(buf->pContext, (const char*)compressBuf, compressBufLen);
} else {
- httpTrace("context:%p, fd:%d, last:%d, compress already dumped, response:\n%s", buf->pContext,
+ httpDebug("context:%p, fd:%d, last:%d, compress already dumped, response:\n%s", buf->pContext,
buf->pContext->fd, isTheLast, buf->buf);
- return 0; // there is no data to dump.
+ remain = 0; // there is no data to dump.
}
} else {
httpError("context:%p, fd:%d, failed to compress data, chunkSize:%" PRIu64 ", last:%d, error:%d, response:\n%s",
buf->pContext, buf->pContext->fd, srcLen, isTheLast, ret, buf->buf);
- return 0;
+ remain = 0;
}
}
diff --git a/src/plugins/http/src/httpSql.c b/src/plugins/http/src/httpSql.c
index 881fa55fb7..883fa574ff 100644
--- a/src/plugins/http/src/httpSql.c
+++ b/src/plugins/http/src/httpSql.c
@@ -257,20 +257,20 @@ void httpProcessSingleSqlCallBackImp(void *param, TAOS_RES *result, int unUsedCo
HttpEncodeMethod *encode = pContext->encodeMethod;
if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
- httpError("context:%p, fd:%d, user:%s, query error, taos:%p, code:%s:inprogress, sqlObj:%p", pContext, pContext->fd,
- pContext->user, pContext->session->taos, tstrerror(code), (SSqlObj *)result);
+ httpError("context:%p, fd:%d, user:%s, query error, code:%s:inprogress, sqlObj:%p", pContext, pContext->fd,
+ pContext->user, tstrerror(code), (SSqlObj *)result);
return;
}
if (code < 0) {
SSqlObj *pObj = (SSqlObj *)result;
if (code == TSDB_CODE_TSC_INVALID_SQL) {
- httpError("context:%p, fd:%d, user:%s, query error, taos:%p, code:%s, sqlObj:%p, error:%s", pContext,
- pContext->fd, pContext->user, pContext->session->taos, tstrerror(code), pObj, pObj->cmd.payload);
+ httpError("context:%p, fd:%d, user:%s, query error, code:%s, sqlObj:%p, error:%s", pContext,
+ pContext->fd, pContext->user, tstrerror(code), pObj, pObj->cmd.payload);
httpSendTaosdInvalidSqlErrorResp(pContext, pObj->cmd.payload);
} else {
- httpError("context:%p, fd:%d, user:%s, query error, taos:%p, code:%s, sqlObj:%p", pContext, pContext->fd,
- pContext->user, pContext->session->taos, tstrerror(code), pObj);
+ httpError("context:%p, fd:%d, user:%s, query error, code:%s, sqlObj:%p", pContext, pContext->fd,
+ pContext->user, tstrerror(code), pObj);
httpSendErrorResp(pContext, code);
}
taos_free_result(result);
diff --git a/src/plugins/http/src/httpUtil.c b/src/plugins/http/src/httpUtil.c
index 2c8879f880..39168ee96d 100644
--- a/src/plugins/http/src/httpUtil.c
+++ b/src/plugins/http/src/httpUtil.c
@@ -406,15 +406,21 @@ int32_t httpGzipCompressInit(HttpContext *pContext) {
int32_t httpGzipCompress(HttpContext *pContext, char *srcData, int32_t nSrcData, char *destData, int32_t *nDestData, bool isTheLast) {
int32_t err = 0;
+ int32_t lastTotalLen = (int32_t) (pContext->gzipStream.total_out);
pContext->gzipStream.next_in = (Bytef *) srcData;
pContext->gzipStream.avail_in = (uLong) nSrcData;
pContext->gzipStream.next_out = (Bytef *) destData;
pContext->gzipStream.avail_out = (uLong) (*nDestData);
- while (pContext->gzipStream.avail_in != 0 && pContext->gzipStream.total_out < (uLong) (*nDestData)) {
+ while (pContext->gzipStream.avail_in != 0) {
if (deflate(&pContext->gzipStream, Z_FULL_FLUSH) != Z_OK) {
return -1;
}
+
+ int32_t cacheLen = pContext->gzipStream.total_out - lastTotalLen;
+ if (cacheLen >= *nDestData) {
+ return -2;
+ }
}
if (pContext->gzipStream.avail_in != 0) {
@@ -427,16 +433,16 @@ int32_t httpGzipCompress(HttpContext *pContext, char *srcData, int32_t nSrcData,
break;
}
if (err != Z_OK) {
- return -2;
+ return -3;
}
}
if (deflateEnd(&pContext->gzipStream) != Z_OK) {
- return -3;
+ return -4;
}
}
- *nDestData = (int32_t) (pContext->gzipStream.total_out);
+ *nDestData = (int32_t) (pContext->gzipStream.total_out) - lastTotalLen;
return 0;
}
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index 8a5b9d61e2..e5d1185330 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -80,6 +80,7 @@ cmd ::= SHOW GRANTS. { setShowOptions(pInfo, TSDB_MGMT_TABLE_GRANTS, 0, 0);
cmd ::= SHOW VNODES. { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, 0, 0); }
cmd ::= SHOW VNODES IPTOKEN(X). { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, &X, 0); }
+
%type dbPrefix {SStrToken}
dbPrefix(A) ::=. {A.n = 0; A.type = 0;}
dbPrefix(A) ::= ids(X) DOT. {A = X; }
@@ -88,6 +89,15 @@ dbPrefix(A) ::= ids(X) DOT. {A = X; }
cpxName(A) ::= . {A.n = 0; }
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 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);
}
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index d3f44cdcc7..f2d324e376 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -2120,7 +2120,7 @@ static bool needToLoadDataBlock(SQueryRuntimeEnv* pRuntimeEnv, SDataStatis *pDat
}
}
- // no statistics data
+ // no statistics data, load the true data block
if (index == -1) {
return true;
}
@@ -2130,8 +2130,17 @@ static bool needToLoadDataBlock(SQueryRuntimeEnv* pRuntimeEnv, SDataStatis *pDat
return true;
}
- // all points in current column are NULL, no need to check its boundary value
+ // all data in current column are NULL, no need to check its boundary value
if (pDataStatis[index].numOfNull == numOfRows) {
+
+ // if isNULL query exists, load the null data column
+ for (int32_t j = 0; j < pFilterInfo->numOfFilters; ++j) {
+ SColumnFilterElem *pFilterElem = &pFilterInfo->pFilters[j];
+ if (pFilterElem->fp == isNull_filter) {
+ return true;
+ }
+ }
+
continue;
}
@@ -2957,11 +2966,10 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) {
STableQueryInfo *item = taosArrayGetP(pGroup, i);
SIDList list = getDataBufPagesIdList(pRuntimeEnv->pResultBuf, TSDB_TABLEID(item->pTable)->tid);
- pageList = list;
- tid = TSDB_TABLEID(item->pTable)->tid;
-
if (taosArrayGetSize(list) > 0 && item->windowResInfo.size > 0) {
pTableList[numOfTables++] = item;
+ tid = TSDB_TABLEID(item->pTable)->tid;
+ pageList = list;
}
}
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 3145f39a5e..a18efdeb74 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -23,7 +23,6 @@
** input grammar file:
*/
#include
-#include
/************ Begin %include sections from the grammar ************************/
#include
@@ -77,10 +76,8 @@
** zero the stack is dynamically sized using realloc()
** ParseARG_SDECL A static variable declaration for the %extra_argument
** ParseARG_PDECL A parameter declaration for the %extra_argument
-** ParseARG_PARAM Code to pass %extra_argument as a subroutine parameter
** ParseARG_STORE Code to store %extra_argument into yypParser
** ParseARG_FETCH Code to extract %extra_argument from yypParser
-** ParseCTX_* As ParseARG_ except for %extra_context
** YYERRORSYMBOL is the code number of the error symbol. If not
** defined, then do no error processing.
** YYNSTATE the combined number of states.
@@ -100,56 +97,48 @@
#endif
/************* Begin control #defines *****************************************/
#define YYCODETYPE unsigned short int
-#define YYNOCODE 270
+#define YYNOCODE 272
#define YYACTIONTYPE unsigned short int
#define ParseTOKENTYPE SStrToken
typedef union {
int yyinit;
ParseTOKENTYPE yy0;
- int yy112;
- SCreateDBInfo yy118;
- tVariantList* yy156;
- tSQLExprList* yy158;
- tSQLExpr* yy190;
- SSubclauseInfo* yy333;
- SIntervalVal yy340;
- TAOS_FIELD yy343;
- int64_t yy369;
- SCreateTableSQL* yy398;
- SLimitVal yy414;
- SQuerySQL* yy444;
- SCreateAcctSQL yy479;
- tVariant yy506;
- tFieldList* yy511;
+ SSubclauseInfo* yy25;
+ tSQLExpr* yy66;
+ SCreateAcctSQL yy73;
+ int yy82;
+ SQuerySQL* yy150;
+ SCreateDBInfo yy158;
+ TAOS_FIELD yy181;
+ SLimitVal yy188;
+ tSQLExprList* yy224;
+ int64_t yy271;
+ tVariant yy312;
+ SIntervalVal yy314;
+ SCreateTableSQL* yy374;
+ tFieldList* yy449;
+ tVariantList* yy494;
} YYMINORTYPE;
#ifndef YYSTACKDEPTH
#define YYSTACKDEPTH 100
#endif
#define ParseARG_SDECL SSqlInfo* pInfo;
#define ParseARG_PDECL ,SSqlInfo* pInfo
-#define ParseARG_PARAM ,pInfo
-#define ParseARG_FETCH SSqlInfo* pInfo=yypParser->pInfo;
-#define ParseARG_STORE yypParser->pInfo=pInfo;
-#define ParseCTX_SDECL
-#define ParseCTX_PDECL
-#define ParseCTX_PARAM
-#define ParseCTX_FETCH
-#define ParseCTX_STORE
+#define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
+#define ParseARG_STORE yypParser->pInfo = pInfo
#define YYFALLBACK 1
-#define YYNSTATE 248
-#define YYNRULE 228
-#define YYNRULE_WITH_ACTION 228
+#define YYNSTATE 252
+#define YYNRULE 230
#define YYNTOKEN 206
-#define YY_MAX_SHIFT 247
-#define YY_MIN_SHIFTREDUCE 410
-#define YY_MAX_SHIFTREDUCE 637
-#define YY_ERROR_ACTION 638
-#define YY_ACCEPT_ACTION 639
-#define YY_NO_ACTION 640
-#define YY_MIN_REDUCE 641
-#define YY_MAX_REDUCE 868
+#define YY_MAX_SHIFT 251
+#define YY_MIN_SHIFTREDUCE 416
+#define YY_MAX_SHIFTREDUCE 645
+#define YY_ERROR_ACTION 646
+#define YY_ACCEPT_ACTION 647
+#define YY_NO_ACTION 648
+#define YY_MIN_REDUCE 649
+#define YY_MAX_REDUCE 878
/************* End control #defines *******************************************/
-#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
/* Define the yytestcase() macro to be a no-op if is not already defined
** otherwise.
@@ -214,219 +203,223 @@ typedef union {
** yy_default[] Default action for each state.
**
*********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (560)
+#define YY_ACTTAB_COUNT (566)
static const YYACTIONTYPE yy_action[] = {
- /* 0 */ 741, 451, 11, 739, 740, 639, 247, 451, 742, 452,
- /* 10 */ 744, 745, 743, 35, 36, 452, 37, 38, 156, 245,
- /* 20 */ 167, 29, 138, 137, 202, 41, 39, 43, 40, 106,
- /* 30 */ 517, 162, 856, 34, 33, 782, 138, 32, 31, 30,
- /* 40 */ 35, 36, 771, 37, 38, 161, 856, 167, 29, 771,
- /* 50 */ 106, 202, 41, 39, 43, 40, 187, 159, 223, 222,
- /* 60 */ 34, 33, 138, 157, 32, 31, 30, 35, 36, 451,
- /* 70 */ 37, 38, 855, 142, 167, 29, 760, 452, 202, 41,
- /* 80 */ 39, 43, 40, 199, 78, 60, 779, 34, 33, 234,
- /* 90 */ 234, 32, 31, 30, 21, 41, 39, 43, 40, 32,
- /* 100 */ 31, 30, 56, 34, 33, 852, 808, 32, 31, 30,
- /* 110 */ 21, 21, 106, 411, 412, 413, 414, 415, 416, 417,
- /* 120 */ 418, 419, 420, 421, 422, 246, 591, 171, 36, 757,
- /* 130 */ 37, 38, 225, 50, 167, 29, 21, 62, 202, 41,
- /* 140 */ 39, 43, 40, 172, 221, 757, 757, 34, 33, 27,
- /* 150 */ 51, 32, 31, 30, 8, 37, 38, 63, 116, 167,
- /* 160 */ 29, 101, 758, 202, 41, 39, 43, 40, 809, 226,
- /* 170 */ 197, 757, 34, 33, 170, 851, 32, 31, 30, 16,
- /* 180 */ 214, 240, 239, 213, 212, 211, 238, 210, 237, 236,
- /* 190 */ 235, 209, 737, 760, 725, 726, 727, 728, 729, 730,
- /* 200 */ 731, 732, 733, 734, 735, 736, 166, 604, 12, 241,
- /* 210 */ 595, 17, 598, 190, 601, 559, 166, 604, 26, 103,
- /* 220 */ 595, 597, 598, 600, 601, 34, 33, 151, 760, 32,
- /* 230 */ 31, 30, 21, 90, 89, 145, 572, 573, 163, 164,
- /* 240 */ 173, 150, 201, 76, 80, 85, 88, 79, 163, 164,
- /* 250 */ 166, 604, 549, 82, 595, 106, 598, 100, 601, 244,
- /* 260 */ 243, 97, 17, 16, 26, 240, 239, 756, 680, 26,
- /* 270 */ 238, 129, 237, 236, 235, 119, 120, 70, 66, 69,
- /* 280 */ 203, 165, 163, 164, 689, 533, 180, 129, 530, 186,
- /* 290 */ 531, 850, 532, 184, 183, 596, 153, 599, 133, 131,
- /* 300 */ 93, 92, 91, 42, 174, 546, 681, 220, 219, 129,
- /* 310 */ 18, 61, 541, 42, 603, 593, 175, 176, 563, 189,
- /* 320 */ 3, 47, 46, 537, 603, 538, 564, 623, 605, 602,
- /* 330 */ 14, 13, 13, 154, 523, 75, 74, 522, 46, 602,
- /* 340 */ 48, 22, 207, 535, 155, 536, 22, 42, 10, 9,
- /* 350 */ 140, 594, 87, 86, 141, 143, 144, 148, 603, 149,
- /* 360 */ 147, 136, 146, 139, 865, 759, 819, 818, 168, 607,
- /* 370 */ 815, 814, 169, 602, 751, 224, 781, 773, 786, 788,
- /* 380 */ 102, 801, 117, 800, 115, 118, 26, 534, 188, 691,
- /* 390 */ 208, 134, 24, 217, 688, 218, 864, 72, 863, 861,
- /* 400 */ 121, 95, 709, 25, 23, 135, 678, 81, 558, 676,
- /* 410 */ 83, 191, 84, 674, 158, 673, 195, 177, 130, 671,
- /* 420 */ 52, 670, 770, 669, 49, 44, 668, 107, 108, 200,
- /* 430 */ 667, 194, 659, 132, 665, 663, 198, 196, 192, 661,
- /* 440 */ 28, 57, 58, 802, 216, 77, 227, 228, 229, 230,
- /* 450 */ 231, 232, 205, 233, 242, 53, 637, 178, 179, 636,
- /* 460 */ 152, 64, 67, 182, 181, 672, 635, 628, 94, 96,
- /* 470 */ 185, 666, 124, 55, 123, 710, 122, 125, 126, 128,
- /* 480 */ 127, 1, 2, 189, 755, 543, 59, 560, 111, 109,
- /* 490 */ 112, 110, 104, 113, 114, 160, 19, 193, 5, 565,
- /* 500 */ 105, 6, 606, 4, 20, 15, 204, 7, 608, 65,
- /* 510 */ 206, 492, 488, 486, 485, 484, 481, 455, 215, 68,
- /* 520 */ 45, 71, 22, 519, 73, 518, 516, 54, 476, 474,
- /* 530 */ 466, 472, 468, 470, 464, 462, 491, 490, 489, 487,
- /* 540 */ 483, 482, 46, 453, 426, 424, 641, 640, 640, 640,
- /* 550 */ 640, 640, 640, 640, 640, 640, 640, 640, 98, 99,
+ /* 0 */ 751, 459, 11, 749, 750, 647, 251, 459, 752, 460,
+ /* 10 */ 754, 755, 753, 35, 36, 460, 37, 38, 159, 249,
+ /* 20 */ 170, 29, 141, 459, 206, 41, 39, 43, 40, 140,
+ /* 30 */ 145, 460, 865, 34, 33, 862, 141, 32, 31, 30,
+ /* 40 */ 35, 36, 781, 37, 38, 165, 866, 170, 29, 141,
+ /* 50 */ 62, 206, 41, 39, 43, 40, 191, 525, 164, 866,
+ /* 60 */ 34, 33, 27, 21, 32, 31, 30, 417, 418, 419,
+ /* 70 */ 420, 421, 422, 423, 424, 425, 426, 427, 428, 250,
+ /* 80 */ 35, 36, 181, 37, 38, 227, 226, 170, 29, 781,
+ /* 90 */ 176, 206, 41, 39, 43, 40, 174, 162, 767, 792,
+ /* 100 */ 34, 33, 56, 160, 32, 31, 30, 21, 36, 8,
+ /* 110 */ 37, 38, 63, 118, 170, 29, 770, 108, 206, 41,
+ /* 120 */ 39, 43, 40, 32, 31, 30, 599, 34, 33, 78,
+ /* 130 */ 875, 32, 31, 30, 238, 37, 38, 108, 238, 170,
+ /* 140 */ 29, 184, 766, 206, 41, 39, 43, 40, 188, 187,
+ /* 150 */ 789, 177, 34, 33, 224, 223, 32, 31, 30, 16,
+ /* 160 */ 218, 244, 243, 217, 216, 215, 242, 214, 241, 240,
+ /* 170 */ 239, 213, 747, 818, 735, 736, 737, 738, 739, 740,
+ /* 180 */ 741, 742, 743, 744, 745, 746, 169, 612, 103, 12,
+ /* 190 */ 603, 17, 606, 819, 609, 201, 169, 612, 26, 108,
+ /* 200 */ 603, 108, 606, 861, 609, 153, 169, 612, 173, 567,
+ /* 210 */ 603, 154, 606, 105, 609, 90, 89, 148, 166, 167,
+ /* 220 */ 34, 33, 205, 102, 32, 31, 30, 770, 166, 167,
+ /* 230 */ 26, 21, 557, 41, 39, 43, 40, 549, 166, 167,
+ /* 240 */ 194, 34, 33, 17, 193, 32, 31, 30, 860, 16,
+ /* 250 */ 26, 244, 243, 203, 21, 60, 242, 61, 241, 240,
+ /* 260 */ 239, 248, 247, 96, 175, 229, 767, 76, 80, 245,
+ /* 270 */ 190, 554, 21, 85, 88, 79, 18, 156, 121, 122,
+ /* 280 */ 605, 82, 608, 42, 70, 66, 69, 225, 770, 767,
+ /* 290 */ 135, 133, 601, 42, 611, 768, 93, 92, 91, 690,
+ /* 300 */ 168, 207, 131, 42, 611, 230, 545, 767, 546, 610,
+ /* 310 */ 699, 157, 691, 131, 611, 131, 604, 541, 607, 610,
+ /* 320 */ 538, 571, 539, 47, 540, 46, 580, 581, 602, 610,
+ /* 330 */ 572, 631, 613, 50, 14, 13, 13, 531, 543, 3,
+ /* 340 */ 544, 46, 48, 530, 75, 74, 811, 22, 178, 179,
+ /* 350 */ 51, 211, 10, 9, 829, 22, 87, 86, 101, 99,
+ /* 360 */ 158, 143, 144, 146, 147, 151, 152, 150, 139, 149,
+ /* 370 */ 769, 142, 828, 171, 825, 824, 172, 791, 761, 796,
+ /* 380 */ 228, 783, 798, 104, 810, 119, 120, 701, 117, 212,
+ /* 390 */ 615, 137, 24, 221, 698, 26, 222, 192, 874, 72,
+ /* 400 */ 873, 871, 123, 719, 25, 100, 23, 138, 566, 688,
+ /* 410 */ 81, 686, 83, 84, 684, 195, 780, 683, 161, 542,
+ /* 420 */ 180, 199, 132, 681, 680, 679, 52, 49, 678, 677,
+ /* 430 */ 109, 134, 44, 675, 204, 673, 671, 669, 667, 202,
+ /* 440 */ 200, 198, 196, 28, 136, 220, 57, 58, 812, 77,
+ /* 450 */ 231, 232, 233, 234, 235, 236, 237, 246, 209, 645,
+ /* 460 */ 53, 182, 183, 644, 110, 64, 67, 155, 186, 185,
+ /* 470 */ 682, 643, 94, 636, 676, 189, 126, 125, 720, 124,
+ /* 480 */ 127, 128, 130, 129, 95, 668, 1, 551, 193, 765,
+ /* 490 */ 2, 55, 113, 111, 114, 112, 115, 116, 59, 568,
+ /* 500 */ 163, 106, 197, 5, 573, 107, 6, 65, 614, 19,
+ /* 510 */ 4, 20, 15, 208, 616, 7, 210, 500, 496, 494,
+ /* 520 */ 493, 492, 489, 463, 219, 68, 45, 71, 73, 22,
+ /* 530 */ 527, 526, 524, 54, 484, 482, 474, 480, 476, 478,
+ /* 540 */ 472, 470, 499, 498, 497, 495, 491, 490, 46, 461,
+ /* 550 */ 432, 430, 649, 648, 648, 648, 648, 648, 648, 648,
+ /* 560 */ 648, 648, 648, 648, 97, 98,
};
static const YYCODETYPE yy_lookahead[] = {
- /* 0 */ 225, 1, 259, 228, 229, 206, 207, 1, 233, 9,
- /* 10 */ 235, 236, 237, 13, 14, 9, 16, 17, 208, 209,
- /* 20 */ 20, 21, 259, 259, 24, 25, 26, 27, 28, 209,
- /* 30 */ 5, 268, 269, 33, 34, 209, 259, 37, 38, 39,
- /* 40 */ 13, 14, 243, 16, 17, 268, 269, 20, 21, 243,
- /* 50 */ 209, 24, 25, 26, 27, 28, 257, 226, 33, 34,
- /* 60 */ 33, 34, 259, 257, 37, 38, 39, 13, 14, 1,
- /* 70 */ 16, 17, 269, 259, 20, 21, 245, 9, 24, 25,
- /* 80 */ 26, 27, 28, 263, 72, 265, 260, 33, 34, 78,
- /* 90 */ 78, 37, 38, 39, 209, 25, 26, 27, 28, 37,
- /* 100 */ 38, 39, 102, 33, 34, 259, 265, 37, 38, 39,
- /* 110 */ 209, 209, 209, 45, 46, 47, 48, 49, 50, 51,
- /* 120 */ 52, 53, 54, 55, 56, 57, 99, 242, 14, 244,
- /* 130 */ 16, 17, 209, 103, 20, 21, 209, 246, 24, 25,
- /* 140 */ 26, 27, 28, 242, 242, 244, 244, 33, 34, 258,
- /* 150 */ 120, 37, 38, 39, 98, 16, 17, 101, 102, 20,
- /* 160 */ 21, 209, 239, 24, 25, 26, 27, 28, 265, 242,
- /* 170 */ 267, 244, 33, 34, 226, 259, 37, 38, 39, 85,
- /* 180 */ 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
- /* 190 */ 96, 97, 225, 245, 227, 228, 229, 230, 231, 232,
- /* 200 */ 233, 234, 235, 236, 237, 238, 1, 2, 44, 226,
- /* 210 */ 5, 98, 7, 261, 9, 99, 1, 2, 105, 103,
- /* 220 */ 5, 5, 7, 7, 9, 33, 34, 63, 245, 37,
- /* 230 */ 38, 39, 209, 69, 70, 71, 115, 116, 33, 34,
- /* 240 */ 63, 77, 37, 64, 65, 66, 67, 68, 33, 34,
- /* 250 */ 1, 2, 37, 74, 5, 209, 7, 98, 9, 60,
- /* 260 */ 61, 62, 98, 85, 105, 87, 88, 244, 213, 105,
- /* 270 */ 92, 216, 94, 95, 96, 64, 65, 66, 67, 68,
- /* 280 */ 15, 59, 33, 34, 213, 2, 126, 216, 5, 125,
- /* 290 */ 7, 259, 9, 133, 134, 5, 132, 7, 64, 65,
- /* 300 */ 66, 67, 68, 98, 127, 103, 213, 130, 131, 216,
- /* 310 */ 108, 265, 99, 98, 109, 1, 33, 34, 99, 106,
- /* 320 */ 98, 103, 103, 5, 109, 7, 99, 99, 99, 124,
- /* 330 */ 103, 103, 103, 259, 99, 128, 129, 99, 103, 124,
- /* 340 */ 122, 103, 99, 5, 259, 7, 103, 98, 128, 129,
- /* 350 */ 259, 37, 72, 73, 259, 259, 259, 259, 109, 259,
- /* 360 */ 259, 259, 259, 259, 245, 245, 240, 240, 240, 104,
- /* 370 */ 240, 240, 240, 124, 241, 240, 209, 243, 209, 209,
- /* 380 */ 209, 266, 209, 266, 247, 209, 105, 104, 243, 209,
- /* 390 */ 209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
- /* 400 */ 209, 59, 209, 209, 209, 209, 209, 209, 109, 209,
- /* 410 */ 209, 262, 209, 209, 262, 209, 262, 209, 209, 209,
- /* 420 */ 119, 209, 256, 209, 121, 118, 209, 255, 254, 113,
- /* 430 */ 209, 111, 209, 209, 209, 209, 117, 112, 110, 209,
- /* 440 */ 123, 210, 210, 210, 75, 84, 83, 49, 80, 82,
- /* 450 */ 53, 81, 210, 79, 75, 210, 5, 135, 5, 5,
- /* 460 */ 210, 214, 214, 5, 135, 210, 5, 86, 211, 211,
- /* 470 */ 126, 210, 218, 107, 222, 224, 223, 221, 219, 217,
- /* 480 */ 220, 215, 212, 106, 243, 99, 103, 99, 251, 253,
- /* 490 */ 250, 252, 98, 249, 248, 1, 103, 98, 114, 99,
- /* 500 */ 98, 114, 99, 98, 103, 98, 100, 98, 104, 72,
- /* 510 */ 100, 9, 5, 5, 5, 5, 5, 76, 15, 72,
- /* 520 */ 16, 129, 103, 5, 129, 5, 99, 98, 5, 5,
- /* 530 */ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- /* 540 */ 5, 5, 103, 76, 59, 58, 0, 270, 270, 270,
- /* 550 */ 270, 270, 270, 270, 270, 270, 270, 270, 21, 21,
- /* 560 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 570 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 580 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 590 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 600 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 610 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 620 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 630 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 640 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 650 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 660 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 670 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 680 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 690 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 700 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 710 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 720 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 730 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 740 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 750 */ 270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
- /* 760 */ 270, 270, 270, 270, 270, 270,
+ /* 0 */ 226, 1, 260, 229, 230, 207, 208, 1, 234, 9,
+ /* 10 */ 236, 237, 238, 13, 14, 9, 16, 17, 209, 210,
+ /* 20 */ 20, 21, 260, 1, 24, 25, 26, 27, 28, 260,
+ /* 30 */ 260, 9, 270, 33, 34, 260, 260, 37, 38, 39,
+ /* 40 */ 13, 14, 244, 16, 17, 269, 270, 20, 21, 260,
+ /* 50 */ 247, 24, 25, 26, 27, 28, 258, 5, 269, 270,
+ /* 60 */ 33, 34, 259, 210, 37, 38, 39, 45, 46, 47,
+ /* 70 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+ /* 80 */ 13, 14, 60, 16, 17, 33, 34, 20, 21, 244,
+ /* 90 */ 66, 24, 25, 26, 27, 28, 243, 227, 245, 210,
+ /* 100 */ 33, 34, 102, 258, 37, 38, 39, 210, 14, 98,
+ /* 110 */ 16, 17, 101, 102, 20, 21, 246, 210, 24, 25,
+ /* 120 */ 26, 27, 28, 37, 38, 39, 99, 33, 34, 73,
+ /* 130 */ 246, 37, 38, 39, 78, 16, 17, 210, 78, 20,
+ /* 140 */ 21, 126, 245, 24, 25, 26, 27, 28, 133, 134,
+ /* 150 */ 261, 127, 33, 34, 130, 131, 37, 38, 39, 85,
+ /* 160 */ 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+ /* 170 */ 96, 97, 226, 266, 228, 229, 230, 231, 232, 233,
+ /* 180 */ 234, 235, 236, 237, 238, 239, 1, 2, 210, 44,
+ /* 190 */ 5, 98, 7, 266, 9, 268, 1, 2, 105, 210,
+ /* 200 */ 5, 210, 7, 260, 9, 60, 1, 2, 227, 99,
+ /* 210 */ 5, 66, 7, 103, 9, 70, 71, 72, 33, 34,
+ /* 220 */ 33, 34, 37, 98, 37, 38, 39, 246, 33, 34,
+ /* 230 */ 105, 210, 37, 25, 26, 27, 28, 99, 33, 34,
+ /* 240 */ 262, 33, 34, 98, 106, 37, 38, 39, 260, 85,
+ /* 250 */ 105, 87, 88, 264, 210, 266, 92, 266, 94, 95,
+ /* 260 */ 96, 63, 64, 65, 243, 210, 245, 61, 62, 227,
+ /* 270 */ 125, 103, 210, 67, 68, 69, 108, 132, 61, 62,
+ /* 280 */ 5, 75, 7, 98, 67, 68, 69, 243, 246, 245,
+ /* 290 */ 61, 62, 1, 98, 109, 240, 67, 68, 69, 214,
+ /* 300 */ 59, 15, 217, 98, 109, 243, 5, 245, 7, 124,
+ /* 310 */ 214, 260, 214, 217, 109, 217, 5, 2, 7, 124,
+ /* 320 */ 5, 99, 7, 103, 9, 103, 115, 116, 37, 124,
+ /* 330 */ 99, 99, 99, 103, 103, 103, 103, 99, 5, 98,
+ /* 340 */ 7, 103, 122, 99, 128, 129, 267, 103, 33, 34,
+ /* 350 */ 120, 99, 128, 129, 241, 103, 73, 74, 61, 62,
+ /* 360 */ 260, 260, 260, 260, 260, 260, 260, 260, 260, 260,
+ /* 370 */ 246, 260, 241, 241, 241, 241, 241, 210, 242, 210,
+ /* 380 */ 241, 244, 210, 210, 267, 210, 210, 210, 248, 210,
+ /* 390 */ 104, 210, 210, 210, 210, 105, 210, 244, 210, 210,
+ /* 400 */ 210, 210, 210, 210, 210, 59, 210, 210, 109, 210,
+ /* 410 */ 210, 210, 210, 210, 210, 263, 257, 210, 263, 104,
+ /* 420 */ 210, 263, 210, 210, 210, 210, 119, 121, 210, 210,
+ /* 430 */ 256, 210, 118, 210, 113, 210, 210, 210, 210, 117,
+ /* 440 */ 112, 111, 110, 123, 210, 76, 211, 211, 211, 84,
+ /* 450 */ 83, 49, 80, 82, 53, 81, 79, 76, 211, 5,
+ /* 460 */ 211, 135, 5, 5, 255, 215, 215, 211, 5, 135,
+ /* 470 */ 211, 5, 212, 86, 211, 126, 219, 223, 225, 224,
+ /* 480 */ 222, 220, 218, 221, 212, 211, 216, 99, 106, 244,
+ /* 490 */ 213, 107, 252, 254, 251, 253, 250, 249, 103, 99,
+ /* 500 */ 1, 98, 98, 114, 99, 98, 114, 73, 99, 103,
+ /* 510 */ 98, 103, 98, 100, 104, 98, 100, 9, 5, 5,
+ /* 520 */ 5, 5, 5, 77, 15, 73, 16, 129, 129, 103,
+ /* 530 */ 5, 5, 99, 98, 5, 5, 5, 5, 5, 5,
+ /* 540 */ 5, 5, 5, 5, 5, 5, 5, 5, 103, 77,
+ /* 550 */ 59, 58, 0, 271, 271, 271, 271, 271, 271, 271,
+ /* 560 */ 271, 271, 271, 271, 21, 21, 271, 271, 271, 271,
+ /* 570 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 580 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 590 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 600 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 610 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 620 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 630 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 640 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 650 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 660 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 670 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 680 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 690 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 700 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 710 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 720 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 730 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 740 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 750 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 760 */ 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
+ /* 770 */ 271, 271,
};
-#define YY_SHIFT_COUNT (247)
+#define YY_SHIFT_COUNT (251)
#define YY_SHIFT_MIN (0)
-#define YY_SHIFT_MAX (546)
+#define YY_SHIFT_MAX (552)
static const unsigned short int yy_shift_ofst[] = {
- /* 0 */ 164, 94, 178, 205, 249, 6, 6, 6, 6, 6,
- /* 10 */ 6, 0, 68, 249, 283, 283, 283, 113, 6, 6,
- /* 20 */ 6, 6, 6, 12, 11, 11, 560, 215, 249, 249,
- /* 30 */ 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
- /* 40 */ 249, 249, 249, 249, 249, 283, 283, 25, 25, 25,
- /* 50 */ 25, 25, 25, 56, 25, 159, 6, 6, 6, 6,
- /* 60 */ 121, 121, 202, 6, 6, 6, 6, 6, 6, 6,
+ /* 0 */ 145, 74, 164, 185, 205, 6, 6, 6, 6, 6,
+ /* 10 */ 6, 0, 22, 205, 315, 315, 315, 93, 6, 6,
+ /* 20 */ 6, 6, 6, 56, 60, 60, 566, 195, 205, 205,
+ /* 30 */ 205, 205, 205, 205, 205, 205, 205, 205, 205, 205,
+ /* 40 */ 205, 205, 205, 205, 205, 315, 315, 52, 52, 52,
+ /* 50 */ 52, 52, 52, 11, 52, 125, 6, 6, 6, 6,
+ /* 60 */ 211, 211, 168, 6, 6, 6, 6, 6, 6, 6,
/* 70 */ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
/* 80 */ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
/* 90 */ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- /* 100 */ 281, 342, 342, 299, 299, 299, 342, 301, 303, 307,
- /* 110 */ 316, 319, 325, 320, 328, 317, 281, 342, 342, 369,
- /* 120 */ 369, 342, 361, 363, 398, 368, 367, 397, 370, 374,
- /* 130 */ 342, 379, 342, 379, 560, 560, 27, 54, 54, 54,
- /* 140 */ 114, 139, 70, 70, 70, 179, 192, 192, 192, 192,
- /* 150 */ 211, 234, 177, 160, 62, 62, 199, 213, 116, 219,
- /* 160 */ 227, 228, 229, 216, 290, 314, 222, 265, 218, 30,
- /* 170 */ 235, 238, 243, 207, 220, 318, 338, 280, 451, 322,
- /* 180 */ 453, 454, 329, 458, 461, 381, 344, 377, 386, 366,
- /* 190 */ 383, 388, 394, 494, 399, 400, 402, 393, 384, 401,
- /* 200 */ 387, 403, 405, 404, 407, 406, 409, 410, 437, 502,
- /* 210 */ 507, 508, 509, 510, 511, 441, 503, 447, 504, 392,
- /* 220 */ 395, 419, 518, 520, 427, 429, 419, 523, 524, 525,
- /* 230 */ 526, 527, 528, 529, 530, 531, 532, 533, 534, 535,
- /* 240 */ 536, 439, 467, 537, 538, 485, 487, 546,
+ /* 100 */ 6, 6, 290, 346, 346, 299, 299, 299, 346, 307,
+ /* 110 */ 306, 314, 321, 322, 328, 330, 332, 320, 290, 346,
+ /* 120 */ 346, 369, 369, 346, 365, 367, 402, 372, 371, 401,
+ /* 130 */ 374, 377, 346, 381, 346, 381, 346, 566, 566, 27,
+ /* 140 */ 67, 67, 67, 94, 119, 208, 208, 208, 206, 187,
+ /* 150 */ 187, 187, 187, 217, 229, 24, 15, 86, 86, 198,
+ /* 160 */ 138, 110, 222, 231, 232, 233, 275, 311, 291, 241,
+ /* 170 */ 286, 220, 230, 238, 244, 252, 216, 224, 301, 333,
+ /* 180 */ 283, 297, 454, 326, 457, 458, 334, 463, 466, 387,
+ /* 190 */ 349, 382, 388, 384, 395, 400, 403, 499, 404, 405,
+ /* 200 */ 407, 406, 389, 408, 392, 409, 412, 410, 414, 413,
+ /* 210 */ 417, 416, 434, 508, 513, 514, 515, 516, 517, 446,
+ /* 220 */ 509, 452, 510, 398, 399, 426, 525, 526, 433, 435,
+ /* 230 */ 426, 529, 530, 531, 532, 533, 534, 535, 536, 537,
+ /* 240 */ 538, 539, 540, 541, 542, 445, 472, 543, 544, 491,
+ /* 250 */ 493, 552,
};
-#define YY_REDUCE_COUNT (135)
-#define YY_REDUCE_MIN (-257)
-#define YY_REDUCE_MAX (270)
+#define YY_REDUCE_COUNT (138)
+#define YY_REDUCE_MIN (-258)
+#define YY_REDUCE_MAX (277)
static const short yy_reduce_ofst[] = {
- /* 0 */ -201, -33, -225, -237, -223, -97, -180, -115, -99, -98,
- /* 10 */ -73, -174, -190, -197, -169, -52, -17, -194, -48, -159,
- /* 20 */ 46, -77, 23, 55, 71, 93, -109, -257, -236, -186,
- /* 30 */ -154, -84, 32, 74, 85, 91, 95, 96, 97, 98,
- /* 40 */ 100, 101, 102, 103, 104, 119, 120, 126, 127, 128,
- /* 50 */ 130, 131, 132, 133, 135, 134, 167, 169, 170, 171,
- /* 60 */ 115, 117, 137, 173, 176, 180, 181, 182, 183, 184,
- /* 70 */ 185, 186, 187, 188, 189, 190, 191, 193, 194, 195,
- /* 80 */ 196, 197, 198, 200, 201, 203, 204, 206, 208, 209,
- /* 90 */ 210, 212, 214, 217, 221, 223, 224, 225, 226, 230,
- /* 100 */ 145, 231, 232, 149, 152, 154, 233, 166, 172, 174,
- /* 110 */ 236, 239, 237, 240, 244, 246, 241, 242, 245, 247,
- /* 120 */ 248, 250, 251, 253, 252, 254, 256, 259, 260, 262,
- /* 130 */ 255, 257, 261, 258, 266, 270,
+ /* 0 */ -202, -54, -226, -224, -211, -73, -11, -147, 21, 44,
+ /* 10 */ 62, -111, -191, -238, -130, -19, 42, -155, -22, -93,
+ /* 20 */ -9, 55, -103, 85, 96, 98, -197, -258, -231, -230,
+ /* 30 */ -225, -57, -12, 51, 100, 101, 102, 103, 104, 105,
+ /* 40 */ 106, 107, 108, 109, 111, -116, 124, 113, 131, 132,
+ /* 50 */ 133, 134, 135, 136, 139, 137, 167, 169, 172, 173,
+ /* 60 */ 79, 117, 140, 175, 176, 177, 179, 181, 182, 183,
+ /* 70 */ 184, 186, 188, 189, 190, 191, 192, 193, 194, 196,
+ /* 80 */ 197, 199, 200, 201, 202, 203, 204, 207, 210, 212,
+ /* 90 */ 213, 214, 215, 218, 219, 221, 223, 225, 226, 227,
+ /* 100 */ 228, 234, 153, 235, 236, 152, 155, 158, 237, 159,
+ /* 110 */ 174, 209, 239, 242, 240, 243, 246, 248, 245, 247,
+ /* 120 */ 249, 250, 251, 256, 253, 255, 254, 257, 258, 261,
+ /* 130 */ 262, 264, 259, 260, 263, 272, 274, 270, 277,
};
static const YYACTIONTYPE yy_default[] = {
- /* 0 */ 638, 690, 679, 858, 858, 638, 638, 638, 638, 638,
- /* 10 */ 638, 783, 656, 858, 638, 638, 638, 638, 638, 638,
- /* 20 */ 638, 638, 638, 692, 692, 692, 778, 638, 638, 638,
- /* 30 */ 638, 638, 638, 638, 638, 638, 638, 638, 638, 638,
- /* 40 */ 638, 638, 638, 638, 638, 638, 638, 638, 638, 638,
- /* 50 */ 638, 638, 638, 638, 638, 638, 638, 785, 787, 638,
- /* 60 */ 805, 805, 776, 638, 638, 638, 638, 638, 638, 638,
- /* 70 */ 638, 638, 638, 638, 638, 638, 638, 638, 638, 638,
- /* 80 */ 638, 677, 638, 675, 638, 638, 638, 638, 638, 638,
- /* 90 */ 638, 638, 638, 638, 638, 638, 638, 664, 638, 638,
- /* 100 */ 638, 658, 658, 638, 638, 638, 658, 812, 816, 810,
- /* 110 */ 798, 806, 797, 793, 792, 820, 638, 658, 658, 687,
- /* 120 */ 687, 658, 708, 706, 704, 696, 702, 698, 700, 694,
- /* 130 */ 658, 685, 658, 685, 724, 738, 638, 821, 857, 811,
- /* 140 */ 847, 846, 853, 845, 844, 638, 840, 841, 843, 842,
- /* 150 */ 638, 638, 638, 638, 849, 848, 638, 638, 638, 638,
- /* 160 */ 638, 638, 638, 638, 638, 638, 823, 638, 817, 813,
- /* 170 */ 638, 638, 638, 638, 638, 638, 638, 638, 638, 638,
- /* 180 */ 638, 638, 638, 638, 638, 638, 638, 775, 638, 638,
- /* 190 */ 784, 638, 638, 638, 638, 638, 638, 807, 638, 799,
- /* 200 */ 638, 638, 638, 638, 638, 638, 638, 752, 638, 638,
- /* 210 */ 638, 638, 638, 638, 638, 638, 638, 638, 638, 638,
- /* 220 */ 638, 862, 638, 638, 638, 746, 860, 638, 638, 638,
- /* 230 */ 638, 638, 638, 638, 638, 638, 638, 638, 638, 638,
- /* 240 */ 638, 711, 638, 662, 660, 638, 654, 638,
+ /* 0 */ 646, 700, 689, 868, 868, 646, 646, 646, 646, 646,
+ /* 10 */ 646, 793, 664, 868, 646, 646, 646, 646, 646, 646,
+ /* 20 */ 646, 646, 646, 702, 702, 702, 788, 646, 646, 646,
+ /* 30 */ 646, 646, 646, 646, 646, 646, 646, 646, 646, 646,
+ /* 40 */ 646, 646, 646, 646, 646, 646, 646, 646, 646, 646,
+ /* 50 */ 646, 646, 646, 646, 646, 646, 646, 795, 797, 646,
+ /* 60 */ 815, 815, 786, 646, 646, 646, 646, 646, 646, 646,
+ /* 70 */ 646, 646, 646, 646, 646, 646, 646, 646, 646, 646,
+ /* 80 */ 646, 687, 646, 685, 646, 646, 646, 646, 646, 646,
+ /* 90 */ 646, 646, 646, 646, 646, 646, 674, 646, 646, 646,
+ /* 100 */ 646, 646, 646, 666, 666, 646, 646, 646, 666, 822,
+ /* 110 */ 826, 820, 808, 816, 807, 803, 802, 830, 646, 666,
+ /* 120 */ 666, 697, 697, 666, 718, 716, 714, 706, 712, 708,
+ /* 130 */ 710, 704, 666, 695, 666, 695, 666, 734, 748, 646,
+ /* 140 */ 831, 867, 821, 857, 856, 863, 855, 854, 646, 850,
+ /* 150 */ 851, 853, 852, 646, 646, 646, 646, 859, 858, 646,
+ /* 160 */ 646, 646, 646, 646, 646, 646, 646, 646, 646, 833,
+ /* 170 */ 646, 827, 823, 646, 646, 646, 646, 646, 646, 646,
+ /* 180 */ 646, 646, 646, 646, 646, 646, 646, 646, 646, 646,
+ /* 190 */ 646, 785, 646, 646, 794, 646, 646, 646, 646, 646,
+ /* 200 */ 646, 817, 646, 809, 646, 646, 646, 646, 646, 646,
+ /* 210 */ 646, 762, 646, 646, 646, 646, 646, 646, 646, 646,
+ /* 220 */ 646, 646, 646, 646, 646, 872, 646, 646, 646, 756,
+ /* 230 */ 870, 646, 646, 646, 646, 646, 646, 646, 646, 646,
+ /* 240 */ 646, 646, 646, 646, 646, 721, 646, 672, 670, 646,
+ /* 250 */ 662, 646,
};
/********** End of lemon-generated parsing tables *****************************/
@@ -506,12 +499,13 @@ static const YYCODETYPE yyFallback[] = {
0, /* VNODES => nothing */
1, /* IPTOKEN => ID */
0, /* DOT => nothing */
+ 0, /* CREATE => nothing */
+ 0, /* TABLE => nothing */
+ 1, /* DATABASE => ID */
0, /* TABLES => nothing */
0, /* STABLES => nothing */
0, /* VGROUPS => nothing */
0, /* DROP => nothing */
- 0, /* TABLE => nothing */
- 1, /* DATABASE => ID */
0, /* DNODE => nothing */
0, /* USER => nothing */
0, /* ACCOUNT => nothing */
@@ -523,7 +517,6 @@ static const YYCODETYPE yyFallback[] = {
0, /* LOCAL => nothing */
0, /* IF => nothing */
0, /* EXISTS => nothing */
- 0, /* CREATE => nothing */
0, /* PPS => nothing */
0, /* TSERIES => nothing */
0, /* DBS => nothing */
@@ -691,7 +684,6 @@ struct yyParser {
int yyerrcnt; /* Shifts left before out of the error */
#endif
ParseARG_SDECL /* A place to hold %extra_argument */
- ParseCTX_SDECL /* A place to hold %extra_context */
#if YYSTACKDEPTH<=0
int yystksz; /* Current side of the stack */
yyStackEntry *yystack; /* The parser's stack */
@@ -799,24 +791,24 @@ static const char *const yyTokenName[] = {
/* 57 */ "VNODES",
/* 58 */ "IPTOKEN",
/* 59 */ "DOT",
- /* 60 */ "TABLES",
- /* 61 */ "STABLES",
- /* 62 */ "VGROUPS",
- /* 63 */ "DROP",
- /* 64 */ "TABLE",
- /* 65 */ "DATABASE",
- /* 66 */ "DNODE",
- /* 67 */ "USER",
- /* 68 */ "ACCOUNT",
- /* 69 */ "USE",
- /* 70 */ "DESCRIBE",
- /* 71 */ "ALTER",
- /* 72 */ "PASS",
- /* 73 */ "PRIVILEGE",
- /* 74 */ "LOCAL",
- /* 75 */ "IF",
- /* 76 */ "EXISTS",
- /* 77 */ "CREATE",
+ /* 60 */ "CREATE",
+ /* 61 */ "TABLE",
+ /* 62 */ "DATABASE",
+ /* 63 */ "TABLES",
+ /* 64 */ "STABLES",
+ /* 65 */ "VGROUPS",
+ /* 66 */ "DROP",
+ /* 67 */ "DNODE",
+ /* 68 */ "USER",
+ /* 69 */ "ACCOUNT",
+ /* 70 */ "USE",
+ /* 71 */ "DESCRIBE",
+ /* 72 */ "ALTER",
+ /* 73 */ "PASS",
+ /* 74 */ "PRIVILEGE",
+ /* 75 */ "LOCAL",
+ /* 76 */ "IF",
+ /* 77 */ "EXISTS",
/* 78 */ "PPS",
/* 79 */ "TSERIES",
/* 80 */ "DBS",
@@ -945,70 +937,71 @@ static const char *const yyTokenName[] = {
/* 203 */ "INSERT",
/* 204 */ "INTO",
/* 205 */ "VALUES",
- /* 206 */ "program",
- /* 207 */ "cmd",
- /* 208 */ "dbPrefix",
- /* 209 */ "ids",
- /* 210 */ "cpxName",
- /* 211 */ "ifexists",
- /* 212 */ "alter_db_optr",
- /* 213 */ "acct_optr",
- /* 214 */ "ifnotexists",
- /* 215 */ "db_optr",
- /* 216 */ "pps",
- /* 217 */ "tseries",
- /* 218 */ "dbs",
- /* 219 */ "streams",
- /* 220 */ "storage",
- /* 221 */ "qtime",
- /* 222 */ "users",
- /* 223 */ "conns",
- /* 224 */ "state",
- /* 225 */ "keep",
- /* 226 */ "tagitemlist",
- /* 227 */ "cache",
- /* 228 */ "replica",
- /* 229 */ "quorum",
- /* 230 */ "days",
- /* 231 */ "minrows",
- /* 232 */ "maxrows",
- /* 233 */ "blocks",
- /* 234 */ "ctime",
- /* 235 */ "wal",
- /* 236 */ "fsync",
- /* 237 */ "comp",
- /* 238 */ "prec",
- /* 239 */ "typename",
- /* 240 */ "signed",
- /* 241 */ "create_table_args",
- /* 242 */ "columnlist",
- /* 243 */ "select",
- /* 244 */ "column",
- /* 245 */ "tagitem",
- /* 246 */ "selcollist",
- /* 247 */ "from",
- /* 248 */ "where_opt",
- /* 249 */ "interval_opt",
- /* 250 */ "fill_opt",
- /* 251 */ "sliding_opt",
- /* 252 */ "groupby_opt",
- /* 253 */ "orderby_opt",
- /* 254 */ "having_opt",
- /* 255 */ "slimit_opt",
- /* 256 */ "limit_opt",
- /* 257 */ "union",
- /* 258 */ "sclp",
- /* 259 */ "expr",
- /* 260 */ "as",
- /* 261 */ "tablelist",
- /* 262 */ "tmvar",
- /* 263 */ "sortlist",
- /* 264 */ "sortitem",
- /* 265 */ "item",
- /* 266 */ "sortorder",
- /* 267 */ "grouplist",
- /* 268 */ "exprlist",
- /* 269 */ "expritem",
+ /* 206 */ "error",
+ /* 207 */ "program",
+ /* 208 */ "cmd",
+ /* 209 */ "dbPrefix",
+ /* 210 */ "ids",
+ /* 211 */ "cpxName",
+ /* 212 */ "ifexists",
+ /* 213 */ "alter_db_optr",
+ /* 214 */ "acct_optr",
+ /* 215 */ "ifnotexists",
+ /* 216 */ "db_optr",
+ /* 217 */ "pps",
+ /* 218 */ "tseries",
+ /* 219 */ "dbs",
+ /* 220 */ "streams",
+ /* 221 */ "storage",
+ /* 222 */ "qtime",
+ /* 223 */ "users",
+ /* 224 */ "conns",
+ /* 225 */ "state",
+ /* 226 */ "keep",
+ /* 227 */ "tagitemlist",
+ /* 228 */ "cache",
+ /* 229 */ "replica",
+ /* 230 */ "quorum",
+ /* 231 */ "days",
+ /* 232 */ "minrows",
+ /* 233 */ "maxrows",
+ /* 234 */ "blocks",
+ /* 235 */ "ctime",
+ /* 236 */ "wal",
+ /* 237 */ "fsync",
+ /* 238 */ "comp",
+ /* 239 */ "prec",
+ /* 240 */ "typename",
+ /* 241 */ "signed",
+ /* 242 */ "create_table_args",
+ /* 243 */ "columnlist",
+ /* 244 */ "select",
+ /* 245 */ "column",
+ /* 246 */ "tagitem",
+ /* 247 */ "selcollist",
+ /* 248 */ "from",
+ /* 249 */ "where_opt",
+ /* 250 */ "interval_opt",
+ /* 251 */ "fill_opt",
+ /* 252 */ "sliding_opt",
+ /* 253 */ "groupby_opt",
+ /* 254 */ "orderby_opt",
+ /* 255 */ "having_opt",
+ /* 256 */ "slimit_opt",
+ /* 257 */ "limit_opt",
+ /* 258 */ "union",
+ /* 259 */ "sclp",
+ /* 260 */ "expr",
+ /* 261 */ "as",
+ /* 262 */ "tablelist",
+ /* 263 */ "tmvar",
+ /* 264 */ "sortlist",
+ /* 265 */ "sortitem",
+ /* 266 */ "item",
+ /* 267 */ "sortorder",
+ /* 268 */ "grouplist",
+ /* 269 */ "exprlist",
+ /* 270 */ "expritem",
};
#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
@@ -1035,215 +1028,217 @@ static const char *const yyRuleName[] = {
/* 16 */ "dbPrefix ::= ids DOT",
/* 17 */ "cpxName ::=",
/* 18 */ "cpxName ::= DOT ids",
- /* 19 */ "cmd ::= SHOW dbPrefix TABLES",
- /* 20 */ "cmd ::= SHOW dbPrefix TABLES LIKE ids",
- /* 21 */ "cmd ::= SHOW dbPrefix STABLES",
- /* 22 */ "cmd ::= SHOW dbPrefix STABLES LIKE ids",
- /* 23 */ "cmd ::= SHOW dbPrefix VGROUPS",
- /* 24 */ "cmd ::= SHOW dbPrefix VGROUPS ids",
- /* 25 */ "cmd ::= DROP TABLE ifexists ids cpxName",
- /* 26 */ "cmd ::= DROP DATABASE ifexists ids",
- /* 27 */ "cmd ::= DROP DNODE ids",
- /* 28 */ "cmd ::= DROP USER ids",
- /* 29 */ "cmd ::= DROP ACCOUNT ids",
- /* 30 */ "cmd ::= USE ids",
- /* 31 */ "cmd ::= DESCRIBE ids cpxName",
- /* 32 */ "cmd ::= ALTER USER ids PASS ids",
- /* 33 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
- /* 34 */ "cmd ::= ALTER DNODE ids ids",
- /* 35 */ "cmd ::= ALTER DNODE ids ids ids",
- /* 36 */ "cmd ::= ALTER LOCAL ids",
- /* 37 */ "cmd ::= ALTER LOCAL ids ids",
- /* 38 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
- /* 39 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
- /* 40 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
- /* 41 */ "ids ::= ID",
- /* 42 */ "ids ::= STRING",
- /* 43 */ "ifexists ::= IF EXISTS",
- /* 44 */ "ifexists ::=",
- /* 45 */ "ifnotexists ::= IF NOT EXISTS",
- /* 46 */ "ifnotexists ::=",
- /* 47 */ "cmd ::= CREATE DNODE ids",
- /* 48 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
- /* 49 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
- /* 50 */ "cmd ::= CREATE USER ids PASS ids",
- /* 51 */ "pps ::=",
- /* 52 */ "pps ::= PPS INTEGER",
- /* 53 */ "tseries ::=",
- /* 54 */ "tseries ::= TSERIES INTEGER",
- /* 55 */ "dbs ::=",
- /* 56 */ "dbs ::= DBS INTEGER",
- /* 57 */ "streams ::=",
- /* 58 */ "streams ::= STREAMS INTEGER",
- /* 59 */ "storage ::=",
- /* 60 */ "storage ::= STORAGE INTEGER",
- /* 61 */ "qtime ::=",
- /* 62 */ "qtime ::= QTIME INTEGER",
- /* 63 */ "users ::=",
- /* 64 */ "users ::= USERS INTEGER",
- /* 65 */ "conns ::=",
- /* 66 */ "conns ::= CONNS INTEGER",
- /* 67 */ "state ::=",
- /* 68 */ "state ::= STATE ids",
- /* 69 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
- /* 70 */ "keep ::= KEEP tagitemlist",
- /* 71 */ "cache ::= CACHE INTEGER",
- /* 72 */ "replica ::= REPLICA INTEGER",
- /* 73 */ "quorum ::= QUORUM INTEGER",
- /* 74 */ "days ::= DAYS INTEGER",
- /* 75 */ "minrows ::= MINROWS INTEGER",
- /* 76 */ "maxrows ::= MAXROWS INTEGER",
- /* 77 */ "blocks ::= BLOCKS INTEGER",
- /* 78 */ "ctime ::= CTIME INTEGER",
- /* 79 */ "wal ::= WAL INTEGER",
- /* 80 */ "fsync ::= FSYNC INTEGER",
- /* 81 */ "comp ::= COMP INTEGER",
- /* 82 */ "prec ::= PRECISION STRING",
- /* 83 */ "db_optr ::=",
- /* 84 */ "db_optr ::= db_optr cache",
- /* 85 */ "db_optr ::= db_optr replica",
- /* 86 */ "db_optr ::= db_optr quorum",
- /* 87 */ "db_optr ::= db_optr days",
- /* 88 */ "db_optr ::= db_optr minrows",
- /* 89 */ "db_optr ::= db_optr maxrows",
- /* 90 */ "db_optr ::= db_optr blocks",
- /* 91 */ "db_optr ::= db_optr ctime",
- /* 92 */ "db_optr ::= db_optr wal",
- /* 93 */ "db_optr ::= db_optr fsync",
- /* 94 */ "db_optr ::= db_optr comp",
- /* 95 */ "db_optr ::= db_optr prec",
- /* 96 */ "db_optr ::= db_optr keep",
- /* 97 */ "alter_db_optr ::=",
- /* 98 */ "alter_db_optr ::= alter_db_optr replica",
- /* 99 */ "alter_db_optr ::= alter_db_optr quorum",
- /* 100 */ "alter_db_optr ::= alter_db_optr keep",
- /* 101 */ "alter_db_optr ::= alter_db_optr blocks",
- /* 102 */ "alter_db_optr ::= alter_db_optr comp",
- /* 103 */ "alter_db_optr ::= alter_db_optr wal",
- /* 104 */ "alter_db_optr ::= alter_db_optr fsync",
- /* 105 */ "typename ::= ids",
- /* 106 */ "typename ::= ids LP signed RP",
- /* 107 */ "signed ::= INTEGER",
- /* 108 */ "signed ::= PLUS INTEGER",
- /* 109 */ "signed ::= MINUS INTEGER",
- /* 110 */ "cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args",
- /* 111 */ "create_table_args ::= LP columnlist RP",
- /* 112 */ "create_table_args ::= LP columnlist RP TAGS LP columnlist RP",
- /* 113 */ "create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP",
- /* 114 */ "create_table_args ::= AS select",
- /* 115 */ "columnlist ::= columnlist COMMA column",
- /* 116 */ "columnlist ::= column",
- /* 117 */ "column ::= ids typename",
- /* 118 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 119 */ "tagitemlist ::= tagitem",
- /* 120 */ "tagitem ::= INTEGER",
- /* 121 */ "tagitem ::= FLOAT",
- /* 122 */ "tagitem ::= STRING",
- /* 123 */ "tagitem ::= BOOL",
- /* 124 */ "tagitem ::= NULL",
- /* 125 */ "tagitem ::= MINUS INTEGER",
- /* 126 */ "tagitem ::= MINUS FLOAT",
- /* 127 */ "tagitem ::= PLUS INTEGER",
- /* 128 */ "tagitem ::= PLUS FLOAT",
- /* 129 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
- /* 130 */ "union ::= select",
- /* 131 */ "union ::= LP union RP",
- /* 132 */ "union ::= union UNION ALL select",
- /* 133 */ "union ::= union UNION ALL LP select RP",
- /* 134 */ "cmd ::= union",
- /* 135 */ "select ::= SELECT selcollist",
- /* 136 */ "sclp ::= selcollist COMMA",
- /* 137 */ "sclp ::=",
- /* 138 */ "selcollist ::= sclp expr as",
- /* 139 */ "selcollist ::= sclp STAR",
- /* 140 */ "as ::= AS ids",
- /* 141 */ "as ::= ids",
- /* 142 */ "as ::=",
- /* 143 */ "from ::= FROM tablelist",
- /* 144 */ "tablelist ::= ids cpxName",
- /* 145 */ "tablelist ::= ids cpxName ids",
- /* 146 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 147 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 148 */ "tmvar ::= VARIABLE",
- /* 149 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 150 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
- /* 151 */ "interval_opt ::=",
- /* 152 */ "fill_opt ::=",
- /* 153 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 154 */ "fill_opt ::= FILL LP ID RP",
- /* 155 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 156 */ "sliding_opt ::=",
- /* 157 */ "orderby_opt ::=",
- /* 158 */ "orderby_opt ::= ORDER BY sortlist",
- /* 159 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 160 */ "sortlist ::= item sortorder",
- /* 161 */ "item ::= ids cpxName",
- /* 162 */ "sortorder ::= ASC",
- /* 163 */ "sortorder ::= DESC",
- /* 164 */ "sortorder ::=",
- /* 165 */ "groupby_opt ::=",
- /* 166 */ "groupby_opt ::= GROUP BY grouplist",
- /* 167 */ "grouplist ::= grouplist COMMA item",
- /* 168 */ "grouplist ::= item",
- /* 169 */ "having_opt ::=",
- /* 170 */ "having_opt ::= HAVING expr",
- /* 171 */ "limit_opt ::=",
- /* 172 */ "limit_opt ::= LIMIT signed",
- /* 173 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 174 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 175 */ "slimit_opt ::=",
- /* 176 */ "slimit_opt ::= SLIMIT signed",
- /* 177 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 178 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 179 */ "where_opt ::=",
- /* 180 */ "where_opt ::= WHERE expr",
- /* 181 */ "expr ::= LP expr RP",
- /* 182 */ "expr ::= ID",
- /* 183 */ "expr ::= ID DOT ID",
- /* 184 */ "expr ::= ID DOT STAR",
- /* 185 */ "expr ::= INTEGER",
- /* 186 */ "expr ::= MINUS INTEGER",
- /* 187 */ "expr ::= PLUS INTEGER",
- /* 188 */ "expr ::= FLOAT",
- /* 189 */ "expr ::= MINUS FLOAT",
- /* 190 */ "expr ::= PLUS FLOAT",
- /* 191 */ "expr ::= STRING",
- /* 192 */ "expr ::= NOW",
- /* 193 */ "expr ::= VARIABLE",
- /* 194 */ "expr ::= BOOL",
- /* 195 */ "expr ::= ID LP exprlist RP",
- /* 196 */ "expr ::= ID LP STAR RP",
- /* 197 */ "expr ::= expr IS NULL",
- /* 198 */ "expr ::= expr IS NOT NULL",
- /* 199 */ "expr ::= expr LT expr",
- /* 200 */ "expr ::= expr GT expr",
- /* 201 */ "expr ::= expr LE expr",
- /* 202 */ "expr ::= expr GE expr",
- /* 203 */ "expr ::= expr NE expr",
- /* 204 */ "expr ::= expr EQ expr",
- /* 205 */ "expr ::= expr AND expr",
- /* 206 */ "expr ::= expr OR expr",
- /* 207 */ "expr ::= expr PLUS expr",
- /* 208 */ "expr ::= expr MINUS expr",
- /* 209 */ "expr ::= expr STAR expr",
- /* 210 */ "expr ::= expr SLASH expr",
- /* 211 */ "expr ::= expr REM expr",
- /* 212 */ "expr ::= expr LIKE expr",
- /* 213 */ "expr ::= expr IN LP exprlist RP",
- /* 214 */ "exprlist ::= exprlist COMMA expritem",
- /* 215 */ "exprlist ::= expritem",
- /* 216 */ "expritem ::= expr",
- /* 217 */ "expritem ::=",
- /* 218 */ "cmd ::= RESET QUERY CACHE",
- /* 219 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 220 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 221 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 222 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 223 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 224 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 225 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 226 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 227 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /* 19 */ "cmd ::= SHOW CREATE TABLE ids cpxName",
+ /* 20 */ "cmd ::= SHOW CREATE DATABASE ids",
+ /* 21 */ "cmd ::= SHOW dbPrefix TABLES",
+ /* 22 */ "cmd ::= SHOW dbPrefix TABLES LIKE ids",
+ /* 23 */ "cmd ::= SHOW dbPrefix STABLES",
+ /* 24 */ "cmd ::= SHOW dbPrefix STABLES LIKE ids",
+ /* 25 */ "cmd ::= SHOW dbPrefix VGROUPS",
+ /* 26 */ "cmd ::= SHOW dbPrefix VGROUPS ids",
+ /* 27 */ "cmd ::= DROP TABLE ifexists ids cpxName",
+ /* 28 */ "cmd ::= DROP DATABASE ifexists ids",
+ /* 29 */ "cmd ::= DROP DNODE ids",
+ /* 30 */ "cmd ::= DROP USER ids",
+ /* 31 */ "cmd ::= DROP ACCOUNT ids",
+ /* 32 */ "cmd ::= USE ids",
+ /* 33 */ "cmd ::= DESCRIBE ids cpxName",
+ /* 34 */ "cmd ::= ALTER USER ids PASS ids",
+ /* 35 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
+ /* 36 */ "cmd ::= ALTER DNODE ids ids",
+ /* 37 */ "cmd ::= ALTER DNODE ids ids ids",
+ /* 38 */ "cmd ::= ALTER LOCAL ids",
+ /* 39 */ "cmd ::= ALTER LOCAL ids ids",
+ /* 40 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
+ /* 41 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
+ /* 42 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
+ /* 43 */ "ids ::= ID",
+ /* 44 */ "ids ::= STRING",
+ /* 45 */ "ifexists ::= IF EXISTS",
+ /* 46 */ "ifexists ::=",
+ /* 47 */ "ifnotexists ::= IF NOT EXISTS",
+ /* 48 */ "ifnotexists ::=",
+ /* 49 */ "cmd ::= CREATE DNODE ids",
+ /* 50 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
+ /* 51 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
+ /* 52 */ "cmd ::= CREATE USER ids PASS ids",
+ /* 53 */ "pps ::=",
+ /* 54 */ "pps ::= PPS INTEGER",
+ /* 55 */ "tseries ::=",
+ /* 56 */ "tseries ::= TSERIES INTEGER",
+ /* 57 */ "dbs ::=",
+ /* 58 */ "dbs ::= DBS INTEGER",
+ /* 59 */ "streams ::=",
+ /* 60 */ "streams ::= STREAMS INTEGER",
+ /* 61 */ "storage ::=",
+ /* 62 */ "storage ::= STORAGE INTEGER",
+ /* 63 */ "qtime ::=",
+ /* 64 */ "qtime ::= QTIME INTEGER",
+ /* 65 */ "users ::=",
+ /* 66 */ "users ::= USERS INTEGER",
+ /* 67 */ "conns ::=",
+ /* 68 */ "conns ::= CONNS INTEGER",
+ /* 69 */ "state ::=",
+ /* 70 */ "state ::= STATE ids",
+ /* 71 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
+ /* 72 */ "keep ::= KEEP tagitemlist",
+ /* 73 */ "cache ::= CACHE INTEGER",
+ /* 74 */ "replica ::= REPLICA INTEGER",
+ /* 75 */ "quorum ::= QUORUM INTEGER",
+ /* 76 */ "days ::= DAYS INTEGER",
+ /* 77 */ "minrows ::= MINROWS INTEGER",
+ /* 78 */ "maxrows ::= MAXROWS INTEGER",
+ /* 79 */ "blocks ::= BLOCKS INTEGER",
+ /* 80 */ "ctime ::= CTIME INTEGER",
+ /* 81 */ "wal ::= WAL INTEGER",
+ /* 82 */ "fsync ::= FSYNC INTEGER",
+ /* 83 */ "comp ::= COMP INTEGER",
+ /* 84 */ "prec ::= PRECISION STRING",
+ /* 85 */ "db_optr ::=",
+ /* 86 */ "db_optr ::= db_optr cache",
+ /* 87 */ "db_optr ::= db_optr replica",
+ /* 88 */ "db_optr ::= db_optr quorum",
+ /* 89 */ "db_optr ::= db_optr days",
+ /* 90 */ "db_optr ::= db_optr minrows",
+ /* 91 */ "db_optr ::= db_optr maxrows",
+ /* 92 */ "db_optr ::= db_optr blocks",
+ /* 93 */ "db_optr ::= db_optr ctime",
+ /* 94 */ "db_optr ::= db_optr wal",
+ /* 95 */ "db_optr ::= db_optr fsync",
+ /* 96 */ "db_optr ::= db_optr comp",
+ /* 97 */ "db_optr ::= db_optr prec",
+ /* 98 */ "db_optr ::= db_optr keep",
+ /* 99 */ "alter_db_optr ::=",
+ /* 100 */ "alter_db_optr ::= alter_db_optr replica",
+ /* 101 */ "alter_db_optr ::= alter_db_optr quorum",
+ /* 102 */ "alter_db_optr ::= alter_db_optr keep",
+ /* 103 */ "alter_db_optr ::= alter_db_optr blocks",
+ /* 104 */ "alter_db_optr ::= alter_db_optr comp",
+ /* 105 */ "alter_db_optr ::= alter_db_optr wal",
+ /* 106 */ "alter_db_optr ::= alter_db_optr fsync",
+ /* 107 */ "typename ::= ids",
+ /* 108 */ "typename ::= ids LP signed RP",
+ /* 109 */ "signed ::= INTEGER",
+ /* 110 */ "signed ::= PLUS INTEGER",
+ /* 111 */ "signed ::= MINUS INTEGER",
+ /* 112 */ "cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args",
+ /* 113 */ "create_table_args ::= LP columnlist RP",
+ /* 114 */ "create_table_args ::= LP columnlist RP TAGS LP columnlist RP",
+ /* 115 */ "create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP",
+ /* 116 */ "create_table_args ::= AS select",
+ /* 117 */ "columnlist ::= columnlist COMMA column",
+ /* 118 */ "columnlist ::= column",
+ /* 119 */ "column ::= ids typename",
+ /* 120 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 121 */ "tagitemlist ::= tagitem",
+ /* 122 */ "tagitem ::= INTEGER",
+ /* 123 */ "tagitem ::= FLOAT",
+ /* 124 */ "tagitem ::= STRING",
+ /* 125 */ "tagitem ::= BOOL",
+ /* 126 */ "tagitem ::= NULL",
+ /* 127 */ "tagitem ::= MINUS INTEGER",
+ /* 128 */ "tagitem ::= MINUS FLOAT",
+ /* 129 */ "tagitem ::= PLUS INTEGER",
+ /* 130 */ "tagitem ::= PLUS FLOAT",
+ /* 131 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
+ /* 132 */ "union ::= select",
+ /* 133 */ "union ::= LP union RP",
+ /* 134 */ "union ::= union UNION ALL select",
+ /* 135 */ "union ::= union UNION ALL LP select RP",
+ /* 136 */ "cmd ::= union",
+ /* 137 */ "select ::= SELECT selcollist",
+ /* 138 */ "sclp ::= selcollist COMMA",
+ /* 139 */ "sclp ::=",
+ /* 140 */ "selcollist ::= sclp expr as",
+ /* 141 */ "selcollist ::= sclp STAR",
+ /* 142 */ "as ::= AS ids",
+ /* 143 */ "as ::= ids",
+ /* 144 */ "as ::=",
+ /* 145 */ "from ::= FROM tablelist",
+ /* 146 */ "tablelist ::= ids cpxName",
+ /* 147 */ "tablelist ::= ids cpxName ids",
+ /* 148 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 149 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 150 */ "tmvar ::= VARIABLE",
+ /* 151 */ "interval_opt ::= INTERVAL LP tmvar RP",
+ /* 152 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
+ /* 153 */ "interval_opt ::=",
+ /* 154 */ "fill_opt ::=",
+ /* 155 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 156 */ "fill_opt ::= FILL LP ID RP",
+ /* 157 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 158 */ "sliding_opt ::=",
+ /* 159 */ "orderby_opt ::=",
+ /* 160 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 161 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 162 */ "sortlist ::= item sortorder",
+ /* 163 */ "item ::= ids cpxName",
+ /* 164 */ "sortorder ::= ASC",
+ /* 165 */ "sortorder ::= DESC",
+ /* 166 */ "sortorder ::=",
+ /* 167 */ "groupby_opt ::=",
+ /* 168 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 169 */ "grouplist ::= grouplist COMMA item",
+ /* 170 */ "grouplist ::= item",
+ /* 171 */ "having_opt ::=",
+ /* 172 */ "having_opt ::= HAVING expr",
+ /* 173 */ "limit_opt ::=",
+ /* 174 */ "limit_opt ::= LIMIT signed",
+ /* 175 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 176 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 177 */ "slimit_opt ::=",
+ /* 178 */ "slimit_opt ::= SLIMIT signed",
+ /* 179 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 180 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 181 */ "where_opt ::=",
+ /* 182 */ "where_opt ::= WHERE expr",
+ /* 183 */ "expr ::= LP expr RP",
+ /* 184 */ "expr ::= ID",
+ /* 185 */ "expr ::= ID DOT ID",
+ /* 186 */ "expr ::= ID DOT STAR",
+ /* 187 */ "expr ::= INTEGER",
+ /* 188 */ "expr ::= MINUS INTEGER",
+ /* 189 */ "expr ::= PLUS INTEGER",
+ /* 190 */ "expr ::= FLOAT",
+ /* 191 */ "expr ::= MINUS FLOAT",
+ /* 192 */ "expr ::= PLUS FLOAT",
+ /* 193 */ "expr ::= STRING",
+ /* 194 */ "expr ::= NOW",
+ /* 195 */ "expr ::= VARIABLE",
+ /* 196 */ "expr ::= BOOL",
+ /* 197 */ "expr ::= ID LP exprlist RP",
+ /* 198 */ "expr ::= ID LP STAR RP",
+ /* 199 */ "expr ::= expr IS NULL",
+ /* 200 */ "expr ::= expr IS NOT NULL",
+ /* 201 */ "expr ::= expr LT expr",
+ /* 202 */ "expr ::= expr GT expr",
+ /* 203 */ "expr ::= expr LE expr",
+ /* 204 */ "expr ::= expr GE expr",
+ /* 205 */ "expr ::= expr NE expr",
+ /* 206 */ "expr ::= expr EQ expr",
+ /* 207 */ "expr ::= expr AND expr",
+ /* 208 */ "expr ::= expr OR expr",
+ /* 209 */ "expr ::= expr PLUS expr",
+ /* 210 */ "expr ::= expr MINUS expr",
+ /* 211 */ "expr ::= expr STAR expr",
+ /* 212 */ "expr ::= expr SLASH expr",
+ /* 213 */ "expr ::= expr REM expr",
+ /* 214 */ "expr ::= expr LIKE expr",
+ /* 215 */ "expr ::= expr IN LP exprlist RP",
+ /* 216 */ "exprlist ::= exprlist COMMA expritem",
+ /* 217 */ "exprlist ::= expritem",
+ /* 218 */ "expritem ::= expr",
+ /* 219 */ "expritem ::=",
+ /* 220 */ "cmd ::= RESET QUERY CACHE",
+ /* 221 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 222 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 223 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 224 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 225 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 226 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 227 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 228 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 229 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
};
#endif /* NDEBUG */
@@ -1292,29 +1287,28 @@ static int yyGrowStack(yyParser *p){
/* Initialize a new parser that has already been allocated.
*/
-void ParseInit(void *yypRawParser ParseCTX_PDECL){
- yyParser *yypParser = (yyParser*)yypRawParser;
- ParseCTX_STORE
+void ParseInit(void *yypParser){
+ yyParser *pParser = (yyParser*)yypParser;
#ifdef YYTRACKMAXSTACKDEPTH
- yypParser->yyhwm = 0;
+ pParser->yyhwm = 0;
#endif
#if YYSTACKDEPTH<=0
- yypParser->yytos = NULL;
- yypParser->yystack = NULL;
- yypParser->yystksz = 0;
- if( yyGrowStack(yypParser) ){
- yypParser->yystack = &yypParser->yystk0;
- yypParser->yystksz = 1;
+ pParser->yytos = NULL;
+ pParser->yystack = NULL;
+ pParser->yystksz = 0;
+ if( yyGrowStack(pParser) ){
+ pParser->yystack = &pParser->yystk0;
+ pParser->yystksz = 1;
}
#endif
#ifndef YYNOERRORRECOVERY
- yypParser->yyerrcnt = -1;
+ pParser->yyerrcnt = -1;
#endif
- yypParser->yytos = yypParser->yystack;
- yypParser->yystack[0].stateno = 0;
- yypParser->yystack[0].major = 0;
+ pParser->yytos = pParser->yystack;
+ pParser->yystack[0].stateno = 0;
+ pParser->yystack[0].major = 0;
#if YYSTACKDEPTH>0
- yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
+ pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1];
#endif
}
@@ -1331,14 +1325,11 @@ void ParseInit(void *yypRawParser ParseCTX_PDECL){
** A pointer to a parser. This pointer is used in subsequent calls
** to Parse and ParseFree.
*/
-void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) ParseCTX_PDECL){
- yyParser *yypParser;
- yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
- if( yypParser ){
- ParseCTX_STORE
- ParseInit(yypParser ParseCTX_PARAM);
- }
- return (void*)yypParser;
+void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){
+ yyParser *pParser;
+ pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
+ if( pParser ) ParseInit(pParser);
+ return pParser;
}
#endif /* Parse_ENGINEALWAYSONSTACK */
@@ -1355,8 +1346,7 @@ static void yy_destructor(
YYCODETYPE yymajor, /* Type code for object to destroy */
YYMINORTYPE *yypminor /* The object to be destroyed */
){
- ParseARG_FETCH
- ParseCTX_FETCH
+ ParseARG_FETCH;
switch( yymajor ){
/* Here is inserted the actions which take place when a
** terminal or non-terminal is destroyed. This can happen
@@ -1369,50 +1359,50 @@ static void yy_destructor(
** inside the C code.
*/
/********* Begin destructor definitions ***************************************/
- case 225: /* keep */
- case 226: /* tagitemlist */
- case 250: /* fill_opt */
- case 252: /* groupby_opt */
- case 253: /* orderby_opt */
- case 263: /* sortlist */
- case 267: /* grouplist */
+ case 226: /* keep */
+ case 227: /* tagitemlist */
+ case 251: /* fill_opt */
+ case 253: /* groupby_opt */
+ case 254: /* orderby_opt */
+ case 264: /* sortlist */
+ case 268: /* grouplist */
{
-tVariantListDestroy((yypminor->yy156));
+tVariantListDestroy((yypminor->yy494));
}
break;
- case 242: /* columnlist */
+ case 243: /* columnlist */
{
-tFieldListDestroy((yypminor->yy511));
+tFieldListDestroy((yypminor->yy449));
}
break;
- case 243: /* select */
+ case 244: /* select */
{
-doDestroyQuerySql((yypminor->yy444));
+doDestroyQuerySql((yypminor->yy150));
}
break;
- case 246: /* selcollist */
- case 258: /* sclp */
- case 268: /* exprlist */
+ case 247: /* selcollist */
+ case 259: /* sclp */
+ case 269: /* exprlist */
{
-tSQLExprListDestroy((yypminor->yy158));
+tSQLExprListDestroy((yypminor->yy224));
}
break;
- case 248: /* where_opt */
- case 254: /* having_opt */
- case 259: /* expr */
- case 269: /* expritem */
+ case 249: /* where_opt */
+ case 255: /* having_opt */
+ case 260: /* expr */
+ case 270: /* expritem */
{
-tSQLExprDestroy((yypminor->yy190));
+tSQLExprDestroy((yypminor->yy66));
}
break;
- case 257: /* union */
+ case 258: /* union */
{
-destroyAllSelectClause((yypminor->yy333));
+destroyAllSelectClause((yypminor->yy25));
}
break;
- case 264: /* sortitem */
+ case 265: /* sortitem */
{
-tVariantDestroy(&(yypminor->yy506));
+tVariantDestroy(&(yypminor->yy312));
}
break;
/********* End destructor definitions *****************************************/
@@ -1524,12 +1514,13 @@ int ParseCoverage(FILE *out){
** Find the appropriate action for a parser given the terminal
** look-ahead token iLookAhead.
*/
-static YYACTIONTYPE yy_find_shift_action(
- YYCODETYPE iLookAhead, /* The look-ahead token */
- YYACTIONTYPE stateno /* Current state number */
+static unsigned int yy_find_shift_action(
+ yyParser *pParser, /* The parser */
+ YYCODETYPE iLookAhead /* The look-ahead token */
){
int i;
-
+ int stateno = pParser->yytos->stateno;
+
if( stateno>YY_MAX_SHIFT ) return stateno;
assert( stateno <= YY_SHIFT_COUNT );
#if defined(YYCOVERAGE)
@@ -1537,19 +1528,15 @@ static YYACTIONTYPE yy_find_shift_action(
#endif
do{
i = yy_shift_ofst[stateno];
- assert( i>=0 );
- assert( i<=YY_ACTTAB_COUNT );
- assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
+ assert( i>=0 && i+YYNTOKEN<=sizeof(yy_lookahead)/sizeof(yy_lookahead[0]) );
assert( iLookAhead!=YYNOCODE );
assert( iLookAhead < YYNTOKEN );
i += iLookAhead;
- assert( i<(int)YY_NLOOKAHEAD );
if( yy_lookahead[i]!=iLookAhead ){
#ifdef YYFALLBACK
YYCODETYPE iFallback; /* Fallback token */
- assert( iLookAhead %s\n",
@@ -1564,8 +1551,15 @@ static YYACTIONTYPE yy_find_shift_action(
#ifdef YYWILDCARD
{
int j = i - iLookAhead + YYWILDCARD;
- assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
- if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
+ if(
+#if YY_SHIFT_MIN+YYWILDCARD<0
+ j>=0 &&
+#endif
+#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
+ j0
+ ){
#ifndef NDEBUG
if( yyTraceFILE ){
fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
@@ -1579,7 +1573,6 @@ static YYACTIONTYPE yy_find_shift_action(
#endif /* YYWILDCARD */
return yy_default[stateno];
}else{
- assert( i>=0 && iyytos;
- yytos->stateno = yyNewState;
- yytos->major = yyMajor;
+ yytos->stateno = (YYACTIONTYPE)yyNewState;
+ yytos->major = (YYCODETYPE)yyMajor;
yytos->minor.yy0 = yyMinor;
yyTraceShift(yypParser, yyNewState, "Shift");
}
-/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
-** of that rule */
-static const YYCODETYPE yyRuleInfoLhs[] = {
- 206, /* (0) program ::= cmd */
- 207, /* (1) cmd ::= SHOW DATABASES */
- 207, /* (2) cmd ::= SHOW MNODES */
- 207, /* (3) cmd ::= SHOW DNODES */
- 207, /* (4) cmd ::= SHOW ACCOUNTS */
- 207, /* (5) cmd ::= SHOW USERS */
- 207, /* (6) cmd ::= SHOW MODULES */
- 207, /* (7) cmd ::= SHOW QUERIES */
- 207, /* (8) cmd ::= SHOW CONNECTIONS */
- 207, /* (9) cmd ::= SHOW STREAMS */
- 207, /* (10) cmd ::= SHOW VARIABLES */
- 207, /* (11) cmd ::= SHOW SCORES */
- 207, /* (12) cmd ::= SHOW GRANTS */
- 207, /* (13) cmd ::= SHOW VNODES */
- 207, /* (14) cmd ::= SHOW VNODES IPTOKEN */
- 208, /* (15) dbPrefix ::= */
- 208, /* (16) dbPrefix ::= ids DOT */
- 210, /* (17) cpxName ::= */
- 210, /* (18) cpxName ::= DOT ids */
- 207, /* (19) cmd ::= SHOW dbPrefix TABLES */
- 207, /* (20) cmd ::= SHOW dbPrefix TABLES LIKE ids */
- 207, /* (21) cmd ::= SHOW dbPrefix STABLES */
- 207, /* (22) cmd ::= SHOW dbPrefix STABLES LIKE ids */
- 207, /* (23) cmd ::= SHOW dbPrefix VGROUPS */
- 207, /* (24) cmd ::= SHOW dbPrefix VGROUPS ids */
- 207, /* (25) cmd ::= DROP TABLE ifexists ids cpxName */
- 207, /* (26) cmd ::= DROP DATABASE ifexists ids */
- 207, /* (27) cmd ::= DROP DNODE ids */
- 207, /* (28) cmd ::= DROP USER ids */
- 207, /* (29) cmd ::= DROP ACCOUNT ids */
- 207, /* (30) cmd ::= USE ids */
- 207, /* (31) cmd ::= DESCRIBE ids cpxName */
- 207, /* (32) cmd ::= ALTER USER ids PASS ids */
- 207, /* (33) cmd ::= ALTER USER ids PRIVILEGE ids */
- 207, /* (34) cmd ::= ALTER DNODE ids ids */
- 207, /* (35) cmd ::= ALTER DNODE ids ids ids */
- 207, /* (36) cmd ::= ALTER LOCAL ids */
- 207, /* (37) cmd ::= ALTER LOCAL ids ids */
- 207, /* (38) cmd ::= ALTER DATABASE ids alter_db_optr */
- 207, /* (39) cmd ::= ALTER ACCOUNT ids acct_optr */
- 207, /* (40) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
- 209, /* (41) ids ::= ID */
- 209, /* (42) ids ::= STRING */
- 211, /* (43) ifexists ::= IF EXISTS */
- 211, /* (44) ifexists ::= */
- 214, /* (45) ifnotexists ::= IF NOT EXISTS */
- 214, /* (46) ifnotexists ::= */
- 207, /* (47) cmd ::= CREATE DNODE ids */
- 207, /* (48) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
- 207, /* (49) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
- 207, /* (50) cmd ::= CREATE USER ids PASS ids */
- 216, /* (51) pps ::= */
- 216, /* (52) pps ::= PPS INTEGER */
- 217, /* (53) tseries ::= */
- 217, /* (54) tseries ::= TSERIES INTEGER */
- 218, /* (55) dbs ::= */
- 218, /* (56) dbs ::= DBS INTEGER */
- 219, /* (57) streams ::= */
- 219, /* (58) streams ::= STREAMS INTEGER */
- 220, /* (59) storage ::= */
- 220, /* (60) storage ::= STORAGE INTEGER */
- 221, /* (61) qtime ::= */
- 221, /* (62) qtime ::= QTIME INTEGER */
- 222, /* (63) users ::= */
- 222, /* (64) users ::= USERS INTEGER */
- 223, /* (65) conns ::= */
- 223, /* (66) conns ::= CONNS INTEGER */
- 224, /* (67) state ::= */
- 224, /* (68) state ::= STATE ids */
- 213, /* (69) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
- 225, /* (70) keep ::= KEEP tagitemlist */
- 227, /* (71) cache ::= CACHE INTEGER */
- 228, /* (72) replica ::= REPLICA INTEGER */
- 229, /* (73) quorum ::= QUORUM INTEGER */
- 230, /* (74) days ::= DAYS INTEGER */
- 231, /* (75) minrows ::= MINROWS INTEGER */
- 232, /* (76) maxrows ::= MAXROWS INTEGER */
- 233, /* (77) blocks ::= BLOCKS INTEGER */
- 234, /* (78) ctime ::= CTIME INTEGER */
- 235, /* (79) wal ::= WAL INTEGER */
- 236, /* (80) fsync ::= FSYNC INTEGER */
- 237, /* (81) comp ::= COMP INTEGER */
- 238, /* (82) prec ::= PRECISION STRING */
- 215, /* (83) db_optr ::= */
- 215, /* (84) db_optr ::= db_optr cache */
- 215, /* (85) db_optr ::= db_optr replica */
- 215, /* (86) db_optr ::= db_optr quorum */
- 215, /* (87) db_optr ::= db_optr days */
- 215, /* (88) db_optr ::= db_optr minrows */
- 215, /* (89) db_optr ::= db_optr maxrows */
- 215, /* (90) db_optr ::= db_optr blocks */
- 215, /* (91) db_optr ::= db_optr ctime */
- 215, /* (92) db_optr ::= db_optr wal */
- 215, /* (93) db_optr ::= db_optr fsync */
- 215, /* (94) db_optr ::= db_optr comp */
- 215, /* (95) db_optr ::= db_optr prec */
- 215, /* (96) db_optr ::= db_optr keep */
- 212, /* (97) alter_db_optr ::= */
- 212, /* (98) alter_db_optr ::= alter_db_optr replica */
- 212, /* (99) alter_db_optr ::= alter_db_optr quorum */
- 212, /* (100) alter_db_optr ::= alter_db_optr keep */
- 212, /* (101) alter_db_optr ::= alter_db_optr blocks */
- 212, /* (102) alter_db_optr ::= alter_db_optr comp */
- 212, /* (103) alter_db_optr ::= alter_db_optr wal */
- 212, /* (104) alter_db_optr ::= alter_db_optr fsync */
- 239, /* (105) typename ::= ids */
- 239, /* (106) typename ::= ids LP signed RP */
- 240, /* (107) signed ::= INTEGER */
- 240, /* (108) signed ::= PLUS INTEGER */
- 240, /* (109) signed ::= MINUS INTEGER */
- 207, /* (110) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
- 241, /* (111) create_table_args ::= LP columnlist RP */
- 241, /* (112) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
- 241, /* (113) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
- 241, /* (114) create_table_args ::= AS select */
- 242, /* (115) columnlist ::= columnlist COMMA column */
- 242, /* (116) columnlist ::= column */
- 244, /* (117) column ::= ids typename */
- 226, /* (118) tagitemlist ::= tagitemlist COMMA tagitem */
- 226, /* (119) tagitemlist ::= tagitem */
- 245, /* (120) tagitem ::= INTEGER */
- 245, /* (121) tagitem ::= FLOAT */
- 245, /* (122) tagitem ::= STRING */
- 245, /* (123) tagitem ::= BOOL */
- 245, /* (124) tagitem ::= NULL */
- 245, /* (125) tagitem ::= MINUS INTEGER */
- 245, /* (126) tagitem ::= MINUS FLOAT */
- 245, /* (127) tagitem ::= PLUS INTEGER */
- 245, /* (128) tagitem ::= PLUS FLOAT */
- 243, /* (129) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
- 257, /* (130) union ::= select */
- 257, /* (131) union ::= LP union RP */
- 257, /* (132) union ::= union UNION ALL select */
- 257, /* (133) union ::= union UNION ALL LP select RP */
- 207, /* (134) cmd ::= union */
- 243, /* (135) select ::= SELECT selcollist */
- 258, /* (136) sclp ::= selcollist COMMA */
- 258, /* (137) sclp ::= */
- 246, /* (138) selcollist ::= sclp expr as */
- 246, /* (139) selcollist ::= sclp STAR */
- 260, /* (140) as ::= AS ids */
- 260, /* (141) as ::= ids */
- 260, /* (142) as ::= */
- 247, /* (143) from ::= FROM tablelist */
- 261, /* (144) tablelist ::= ids cpxName */
- 261, /* (145) tablelist ::= ids cpxName ids */
- 261, /* (146) tablelist ::= tablelist COMMA ids cpxName */
- 261, /* (147) tablelist ::= tablelist COMMA ids cpxName ids */
- 262, /* (148) tmvar ::= VARIABLE */
- 249, /* (149) interval_opt ::= INTERVAL LP tmvar RP */
- 249, /* (150) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
- 249, /* (151) interval_opt ::= */
- 250, /* (152) fill_opt ::= */
- 250, /* (153) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
- 250, /* (154) fill_opt ::= FILL LP ID RP */
- 251, /* (155) sliding_opt ::= SLIDING LP tmvar RP */
- 251, /* (156) sliding_opt ::= */
- 253, /* (157) orderby_opt ::= */
- 253, /* (158) orderby_opt ::= ORDER BY sortlist */
- 263, /* (159) sortlist ::= sortlist COMMA item sortorder */
- 263, /* (160) sortlist ::= item sortorder */
- 265, /* (161) item ::= ids cpxName */
- 266, /* (162) sortorder ::= ASC */
- 266, /* (163) sortorder ::= DESC */
- 266, /* (164) sortorder ::= */
- 252, /* (165) groupby_opt ::= */
- 252, /* (166) groupby_opt ::= GROUP BY grouplist */
- 267, /* (167) grouplist ::= grouplist COMMA item */
- 267, /* (168) grouplist ::= item */
- 254, /* (169) having_opt ::= */
- 254, /* (170) having_opt ::= HAVING expr */
- 256, /* (171) limit_opt ::= */
- 256, /* (172) limit_opt ::= LIMIT signed */
- 256, /* (173) limit_opt ::= LIMIT signed OFFSET signed */
- 256, /* (174) limit_opt ::= LIMIT signed COMMA signed */
- 255, /* (175) slimit_opt ::= */
- 255, /* (176) slimit_opt ::= SLIMIT signed */
- 255, /* (177) slimit_opt ::= SLIMIT signed SOFFSET signed */
- 255, /* (178) slimit_opt ::= SLIMIT signed COMMA signed */
- 248, /* (179) where_opt ::= */
- 248, /* (180) where_opt ::= WHERE expr */
- 259, /* (181) expr ::= LP expr RP */
- 259, /* (182) expr ::= ID */
- 259, /* (183) expr ::= ID DOT ID */
- 259, /* (184) expr ::= ID DOT STAR */
- 259, /* (185) expr ::= INTEGER */
- 259, /* (186) expr ::= MINUS INTEGER */
- 259, /* (187) expr ::= PLUS INTEGER */
- 259, /* (188) expr ::= FLOAT */
- 259, /* (189) expr ::= MINUS FLOAT */
- 259, /* (190) expr ::= PLUS FLOAT */
- 259, /* (191) expr ::= STRING */
- 259, /* (192) expr ::= NOW */
- 259, /* (193) expr ::= VARIABLE */
- 259, /* (194) expr ::= BOOL */
- 259, /* (195) expr ::= ID LP exprlist RP */
- 259, /* (196) expr ::= ID LP STAR RP */
- 259, /* (197) expr ::= expr IS NULL */
- 259, /* (198) expr ::= expr IS NOT NULL */
- 259, /* (199) expr ::= expr LT expr */
- 259, /* (200) expr ::= expr GT expr */
- 259, /* (201) expr ::= expr LE expr */
- 259, /* (202) expr ::= expr GE expr */
- 259, /* (203) expr ::= expr NE expr */
- 259, /* (204) expr ::= expr EQ expr */
- 259, /* (205) expr ::= expr AND expr */
- 259, /* (206) expr ::= expr OR expr */
- 259, /* (207) expr ::= expr PLUS expr */
- 259, /* (208) expr ::= expr MINUS expr */
- 259, /* (209) expr ::= expr STAR expr */
- 259, /* (210) expr ::= expr SLASH expr */
- 259, /* (211) expr ::= expr REM expr */
- 259, /* (212) expr ::= expr LIKE expr */
- 259, /* (213) expr ::= expr IN LP exprlist RP */
- 268, /* (214) exprlist ::= exprlist COMMA expritem */
- 268, /* (215) exprlist ::= expritem */
- 269, /* (216) expritem ::= expr */
- 269, /* (217) expritem ::= */
- 207, /* (218) cmd ::= RESET QUERY CACHE */
- 207, /* (219) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
- 207, /* (220) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
- 207, /* (221) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
- 207, /* (222) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
- 207, /* (223) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
- 207, /* (224) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
- 207, /* (225) cmd ::= KILL CONNECTION INTEGER */
- 207, /* (226) cmd ::= KILL STREAM INTEGER COLON INTEGER */
- 207, /* (227) cmd ::= KILL QUERY INTEGER COLON INTEGER */
-};
-
-/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
-** of symbols on the right-hand side of that rule. */
-static const signed char yyRuleInfoNRhs[] = {
- -1, /* (0) program ::= cmd */
- -2, /* (1) cmd ::= SHOW DATABASES */
- -2, /* (2) cmd ::= SHOW MNODES */
- -2, /* (3) cmd ::= SHOW DNODES */
- -2, /* (4) cmd ::= SHOW ACCOUNTS */
- -2, /* (5) cmd ::= SHOW USERS */
- -2, /* (6) cmd ::= SHOW MODULES */
- -2, /* (7) cmd ::= SHOW QUERIES */
- -2, /* (8) cmd ::= SHOW CONNECTIONS */
- -2, /* (9) cmd ::= SHOW STREAMS */
- -2, /* (10) cmd ::= SHOW VARIABLES */
- -2, /* (11) cmd ::= SHOW SCORES */
- -2, /* (12) cmd ::= SHOW GRANTS */
- -2, /* (13) cmd ::= SHOW VNODES */
- -3, /* (14) cmd ::= SHOW VNODES IPTOKEN */
- 0, /* (15) dbPrefix ::= */
- -2, /* (16) dbPrefix ::= ids DOT */
- 0, /* (17) cpxName ::= */
- -2, /* (18) cpxName ::= DOT ids */
- -3, /* (19) cmd ::= SHOW dbPrefix TABLES */
- -5, /* (20) cmd ::= SHOW dbPrefix TABLES LIKE ids */
- -3, /* (21) cmd ::= SHOW dbPrefix STABLES */
- -5, /* (22) cmd ::= SHOW dbPrefix STABLES LIKE ids */
- -3, /* (23) cmd ::= SHOW dbPrefix VGROUPS */
- -4, /* (24) cmd ::= SHOW dbPrefix VGROUPS ids */
- -5, /* (25) cmd ::= DROP TABLE ifexists ids cpxName */
- -4, /* (26) cmd ::= DROP DATABASE ifexists ids */
- -3, /* (27) cmd ::= DROP DNODE ids */
- -3, /* (28) cmd ::= DROP USER ids */
- -3, /* (29) cmd ::= DROP ACCOUNT ids */
- -2, /* (30) cmd ::= USE ids */
- -3, /* (31) cmd ::= DESCRIBE ids cpxName */
- -5, /* (32) cmd ::= ALTER USER ids PASS ids */
- -5, /* (33) cmd ::= ALTER USER ids PRIVILEGE ids */
- -4, /* (34) cmd ::= ALTER DNODE ids ids */
- -5, /* (35) cmd ::= ALTER DNODE ids ids ids */
- -3, /* (36) cmd ::= ALTER LOCAL ids */
- -4, /* (37) cmd ::= ALTER LOCAL ids ids */
- -4, /* (38) cmd ::= ALTER DATABASE ids alter_db_optr */
- -4, /* (39) cmd ::= ALTER ACCOUNT ids acct_optr */
- -6, /* (40) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
- -1, /* (41) ids ::= ID */
- -1, /* (42) ids ::= STRING */
- -2, /* (43) ifexists ::= IF EXISTS */
- 0, /* (44) ifexists ::= */
- -3, /* (45) ifnotexists ::= IF NOT EXISTS */
- 0, /* (46) ifnotexists ::= */
- -3, /* (47) cmd ::= CREATE DNODE ids */
- -6, /* (48) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
- -5, /* (49) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
- -5, /* (50) cmd ::= CREATE USER ids PASS ids */
- 0, /* (51) pps ::= */
- -2, /* (52) pps ::= PPS INTEGER */
- 0, /* (53) tseries ::= */
- -2, /* (54) tseries ::= TSERIES INTEGER */
- 0, /* (55) dbs ::= */
- -2, /* (56) dbs ::= DBS INTEGER */
- 0, /* (57) streams ::= */
- -2, /* (58) streams ::= STREAMS INTEGER */
- 0, /* (59) storage ::= */
- -2, /* (60) storage ::= STORAGE INTEGER */
- 0, /* (61) qtime ::= */
- -2, /* (62) qtime ::= QTIME INTEGER */
- 0, /* (63) users ::= */
- -2, /* (64) users ::= USERS INTEGER */
- 0, /* (65) conns ::= */
- -2, /* (66) conns ::= CONNS INTEGER */
- 0, /* (67) state ::= */
- -2, /* (68) state ::= STATE ids */
- -9, /* (69) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
- -2, /* (70) keep ::= KEEP tagitemlist */
- -2, /* (71) cache ::= CACHE INTEGER */
- -2, /* (72) replica ::= REPLICA INTEGER */
- -2, /* (73) quorum ::= QUORUM INTEGER */
- -2, /* (74) days ::= DAYS INTEGER */
- -2, /* (75) minrows ::= MINROWS INTEGER */
- -2, /* (76) maxrows ::= MAXROWS INTEGER */
- -2, /* (77) blocks ::= BLOCKS INTEGER */
- -2, /* (78) ctime ::= CTIME INTEGER */
- -2, /* (79) wal ::= WAL INTEGER */
- -2, /* (80) fsync ::= FSYNC INTEGER */
- -2, /* (81) comp ::= COMP INTEGER */
- -2, /* (82) prec ::= PRECISION STRING */
- 0, /* (83) db_optr ::= */
- -2, /* (84) db_optr ::= db_optr cache */
- -2, /* (85) db_optr ::= db_optr replica */
- -2, /* (86) db_optr ::= db_optr quorum */
- -2, /* (87) db_optr ::= db_optr days */
- -2, /* (88) db_optr ::= db_optr minrows */
- -2, /* (89) db_optr ::= db_optr maxrows */
- -2, /* (90) db_optr ::= db_optr blocks */
- -2, /* (91) db_optr ::= db_optr ctime */
- -2, /* (92) db_optr ::= db_optr wal */
- -2, /* (93) db_optr ::= db_optr fsync */
- -2, /* (94) db_optr ::= db_optr comp */
- -2, /* (95) db_optr ::= db_optr prec */
- -2, /* (96) db_optr ::= db_optr keep */
- 0, /* (97) alter_db_optr ::= */
- -2, /* (98) alter_db_optr ::= alter_db_optr replica */
- -2, /* (99) alter_db_optr ::= alter_db_optr quorum */
- -2, /* (100) alter_db_optr ::= alter_db_optr keep */
- -2, /* (101) alter_db_optr ::= alter_db_optr blocks */
- -2, /* (102) alter_db_optr ::= alter_db_optr comp */
- -2, /* (103) alter_db_optr ::= alter_db_optr wal */
- -2, /* (104) alter_db_optr ::= alter_db_optr fsync */
- -1, /* (105) typename ::= ids */
- -4, /* (106) typename ::= ids LP signed RP */
- -1, /* (107) signed ::= INTEGER */
- -2, /* (108) signed ::= PLUS INTEGER */
- -2, /* (109) signed ::= MINUS INTEGER */
- -6, /* (110) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
- -3, /* (111) create_table_args ::= LP columnlist RP */
- -7, /* (112) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
- -7, /* (113) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
- -2, /* (114) create_table_args ::= AS select */
- -3, /* (115) columnlist ::= columnlist COMMA column */
- -1, /* (116) columnlist ::= column */
- -2, /* (117) column ::= ids typename */
- -3, /* (118) tagitemlist ::= tagitemlist COMMA tagitem */
- -1, /* (119) tagitemlist ::= tagitem */
- -1, /* (120) tagitem ::= INTEGER */
- -1, /* (121) tagitem ::= FLOAT */
- -1, /* (122) tagitem ::= STRING */
- -1, /* (123) tagitem ::= BOOL */
- -1, /* (124) tagitem ::= NULL */
- -2, /* (125) tagitem ::= MINUS INTEGER */
- -2, /* (126) tagitem ::= MINUS FLOAT */
- -2, /* (127) tagitem ::= PLUS INTEGER */
- -2, /* (128) tagitem ::= PLUS FLOAT */
- -12, /* (129) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
- -1, /* (130) union ::= select */
- -3, /* (131) union ::= LP union RP */
- -4, /* (132) union ::= union UNION ALL select */
- -6, /* (133) union ::= union UNION ALL LP select RP */
- -1, /* (134) cmd ::= union */
- -2, /* (135) select ::= SELECT selcollist */
- -2, /* (136) sclp ::= selcollist COMMA */
- 0, /* (137) sclp ::= */
- -3, /* (138) selcollist ::= sclp expr as */
- -2, /* (139) selcollist ::= sclp STAR */
- -2, /* (140) as ::= AS ids */
- -1, /* (141) as ::= ids */
- 0, /* (142) as ::= */
- -2, /* (143) from ::= FROM tablelist */
- -2, /* (144) tablelist ::= ids cpxName */
- -3, /* (145) tablelist ::= ids cpxName ids */
- -4, /* (146) tablelist ::= tablelist COMMA ids cpxName */
- -5, /* (147) tablelist ::= tablelist COMMA ids cpxName ids */
- -1, /* (148) tmvar ::= VARIABLE */
- -4, /* (149) interval_opt ::= INTERVAL LP tmvar RP */
- -6, /* (150) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
- 0, /* (151) interval_opt ::= */
- 0, /* (152) fill_opt ::= */
- -6, /* (153) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
- -4, /* (154) fill_opt ::= FILL LP ID RP */
- -4, /* (155) sliding_opt ::= SLIDING LP tmvar RP */
- 0, /* (156) sliding_opt ::= */
- 0, /* (157) orderby_opt ::= */
- -3, /* (158) orderby_opt ::= ORDER BY sortlist */
- -4, /* (159) sortlist ::= sortlist COMMA item sortorder */
- -2, /* (160) sortlist ::= item sortorder */
- -2, /* (161) item ::= ids cpxName */
- -1, /* (162) sortorder ::= ASC */
- -1, /* (163) sortorder ::= DESC */
- 0, /* (164) sortorder ::= */
- 0, /* (165) groupby_opt ::= */
- -3, /* (166) groupby_opt ::= GROUP BY grouplist */
- -3, /* (167) grouplist ::= grouplist COMMA item */
- -1, /* (168) grouplist ::= item */
- 0, /* (169) having_opt ::= */
- -2, /* (170) having_opt ::= HAVING expr */
- 0, /* (171) limit_opt ::= */
- -2, /* (172) limit_opt ::= LIMIT signed */
- -4, /* (173) limit_opt ::= LIMIT signed OFFSET signed */
- -4, /* (174) limit_opt ::= LIMIT signed COMMA signed */
- 0, /* (175) slimit_opt ::= */
- -2, /* (176) slimit_opt ::= SLIMIT signed */
- -4, /* (177) slimit_opt ::= SLIMIT signed SOFFSET signed */
- -4, /* (178) slimit_opt ::= SLIMIT signed COMMA signed */
- 0, /* (179) where_opt ::= */
- -2, /* (180) where_opt ::= WHERE expr */
- -3, /* (181) expr ::= LP expr RP */
- -1, /* (182) expr ::= ID */
- -3, /* (183) expr ::= ID DOT ID */
- -3, /* (184) expr ::= ID DOT STAR */
- -1, /* (185) expr ::= INTEGER */
- -2, /* (186) expr ::= MINUS INTEGER */
- -2, /* (187) expr ::= PLUS INTEGER */
- -1, /* (188) expr ::= FLOAT */
- -2, /* (189) expr ::= MINUS FLOAT */
- -2, /* (190) expr ::= PLUS FLOAT */
- -1, /* (191) expr ::= STRING */
- -1, /* (192) expr ::= NOW */
- -1, /* (193) expr ::= VARIABLE */
- -1, /* (194) expr ::= BOOL */
- -4, /* (195) expr ::= ID LP exprlist RP */
- -4, /* (196) expr ::= ID LP STAR RP */
- -3, /* (197) expr ::= expr IS NULL */
- -4, /* (198) expr ::= expr IS NOT NULL */
- -3, /* (199) expr ::= expr LT expr */
- -3, /* (200) expr ::= expr GT expr */
- -3, /* (201) expr ::= expr LE expr */
- -3, /* (202) expr ::= expr GE expr */
- -3, /* (203) expr ::= expr NE expr */
- -3, /* (204) expr ::= expr EQ expr */
- -3, /* (205) expr ::= expr AND expr */
- -3, /* (206) expr ::= expr OR expr */
- -3, /* (207) expr ::= expr PLUS expr */
- -3, /* (208) expr ::= expr MINUS expr */
- -3, /* (209) expr ::= expr STAR expr */
- -3, /* (210) expr ::= expr SLASH expr */
- -3, /* (211) expr ::= expr REM expr */
- -3, /* (212) expr ::= expr LIKE expr */
- -5, /* (213) expr ::= expr IN LP exprlist RP */
- -3, /* (214) exprlist ::= exprlist COMMA expritem */
- -1, /* (215) exprlist ::= expritem */
- -1, /* (216) expritem ::= expr */
- 0, /* (217) expritem ::= */
- -3, /* (218) cmd ::= RESET QUERY CACHE */
- -7, /* (219) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
- -7, /* (220) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
- -7, /* (221) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
- -7, /* (222) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
- -8, /* (223) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
- -9, /* (224) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
- -3, /* (225) cmd ::= KILL CONNECTION INTEGER */
- -5, /* (226) cmd ::= KILL STREAM INTEGER COLON INTEGER */
- -5, /* (227) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+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[] = {
+ { 207, -1 }, /* (0) program ::= cmd */
+ { 208, -2 }, /* (1) cmd ::= SHOW DATABASES */
+ { 208, -2 }, /* (2) cmd ::= SHOW MNODES */
+ { 208, -2 }, /* (3) cmd ::= SHOW DNODES */
+ { 208, -2 }, /* (4) cmd ::= SHOW ACCOUNTS */
+ { 208, -2 }, /* (5) cmd ::= SHOW USERS */
+ { 208, -2 }, /* (6) cmd ::= SHOW MODULES */
+ { 208, -2 }, /* (7) cmd ::= SHOW QUERIES */
+ { 208, -2 }, /* (8) cmd ::= SHOW CONNECTIONS */
+ { 208, -2 }, /* (9) cmd ::= SHOW STREAMS */
+ { 208, -2 }, /* (10) cmd ::= SHOW VARIABLES */
+ { 208, -2 }, /* (11) cmd ::= SHOW SCORES */
+ { 208, -2 }, /* (12) cmd ::= SHOW GRANTS */
+ { 208, -2 }, /* (13) cmd ::= SHOW VNODES */
+ { 208, -3 }, /* (14) cmd ::= SHOW VNODES IPTOKEN */
+ { 209, 0 }, /* (15) dbPrefix ::= */
+ { 209, -2 }, /* (16) dbPrefix ::= ids DOT */
+ { 211, 0 }, /* (17) cpxName ::= */
+ { 211, -2 }, /* (18) cpxName ::= DOT ids */
+ { 208, -5 }, /* (19) cmd ::= SHOW CREATE TABLE ids cpxName */
+ { 208, -4 }, /* (20) cmd ::= SHOW CREATE DATABASE ids */
+ { 208, -3 }, /* (21) cmd ::= SHOW dbPrefix TABLES */
+ { 208, -5 }, /* (22) cmd ::= SHOW dbPrefix TABLES LIKE ids */
+ { 208, -3 }, /* (23) cmd ::= SHOW dbPrefix STABLES */
+ { 208, -5 }, /* (24) cmd ::= SHOW dbPrefix STABLES LIKE ids */
+ { 208, -3 }, /* (25) cmd ::= SHOW dbPrefix VGROUPS */
+ { 208, -4 }, /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */
+ { 208, -5 }, /* (27) cmd ::= DROP TABLE ifexists ids cpxName */
+ { 208, -4 }, /* (28) cmd ::= DROP DATABASE ifexists ids */
+ { 208, -3 }, /* (29) cmd ::= DROP DNODE ids */
+ { 208, -3 }, /* (30) cmd ::= DROP USER ids */
+ { 208, -3 }, /* (31) cmd ::= DROP ACCOUNT ids */
+ { 208, -2 }, /* (32) cmd ::= USE ids */
+ { 208, -3 }, /* (33) cmd ::= DESCRIBE ids cpxName */
+ { 208, -5 }, /* (34) cmd ::= ALTER USER ids PASS ids */
+ { 208, -5 }, /* (35) cmd ::= ALTER USER ids PRIVILEGE ids */
+ { 208, -4 }, /* (36) cmd ::= ALTER DNODE ids ids */
+ { 208, -5 }, /* (37) cmd ::= ALTER DNODE ids ids ids */
+ { 208, -3 }, /* (38) cmd ::= ALTER LOCAL ids */
+ { 208, -4 }, /* (39) cmd ::= ALTER LOCAL ids ids */
+ { 208, -4 }, /* (40) cmd ::= ALTER DATABASE ids alter_db_optr */
+ { 208, -4 }, /* (41) cmd ::= ALTER ACCOUNT ids acct_optr */
+ { 208, -6 }, /* (42) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+ { 210, -1 }, /* (43) ids ::= ID */
+ { 210, -1 }, /* (44) ids ::= STRING */
+ { 212, -2 }, /* (45) ifexists ::= IF EXISTS */
+ { 212, 0 }, /* (46) ifexists ::= */
+ { 215, -3 }, /* (47) ifnotexists ::= IF NOT EXISTS */
+ { 215, 0 }, /* (48) ifnotexists ::= */
+ { 208, -3 }, /* (49) cmd ::= CREATE DNODE ids */
+ { 208, -6 }, /* (50) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+ { 208, -5 }, /* (51) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+ { 208, -5 }, /* (52) cmd ::= CREATE USER ids PASS ids */
+ { 217, 0 }, /* (53) pps ::= */
+ { 217, -2 }, /* (54) pps ::= PPS INTEGER */
+ { 218, 0 }, /* (55) tseries ::= */
+ { 218, -2 }, /* (56) tseries ::= TSERIES INTEGER */
+ { 219, 0 }, /* (57) dbs ::= */
+ { 219, -2 }, /* (58) dbs ::= DBS INTEGER */
+ { 220, 0 }, /* (59) streams ::= */
+ { 220, -2 }, /* (60) streams ::= STREAMS INTEGER */
+ { 221, 0 }, /* (61) storage ::= */
+ { 221, -2 }, /* (62) storage ::= STORAGE INTEGER */
+ { 222, 0 }, /* (63) qtime ::= */
+ { 222, -2 }, /* (64) qtime ::= QTIME INTEGER */
+ { 223, 0 }, /* (65) users ::= */
+ { 223, -2 }, /* (66) users ::= USERS INTEGER */
+ { 224, 0 }, /* (67) conns ::= */
+ { 224, -2 }, /* (68) conns ::= CONNS INTEGER */
+ { 225, 0 }, /* (69) state ::= */
+ { 225, -2 }, /* (70) state ::= STATE ids */
+ { 214, -9 }, /* (71) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+ { 226, -2 }, /* (72) keep ::= KEEP tagitemlist */
+ { 228, -2 }, /* (73) cache ::= CACHE INTEGER */
+ { 229, -2 }, /* (74) replica ::= REPLICA INTEGER */
+ { 230, -2 }, /* (75) quorum ::= QUORUM INTEGER */
+ { 231, -2 }, /* (76) days ::= DAYS INTEGER */
+ { 232, -2 }, /* (77) minrows ::= MINROWS INTEGER */
+ { 233, -2 }, /* (78) maxrows ::= MAXROWS INTEGER */
+ { 234, -2 }, /* (79) blocks ::= BLOCKS INTEGER */
+ { 235, -2 }, /* (80) ctime ::= CTIME INTEGER */
+ { 236, -2 }, /* (81) wal ::= WAL INTEGER */
+ { 237, -2 }, /* (82) fsync ::= FSYNC INTEGER */
+ { 238, -2 }, /* (83) comp ::= COMP INTEGER */
+ { 239, -2 }, /* (84) prec ::= PRECISION STRING */
+ { 216, 0 }, /* (85) db_optr ::= */
+ { 216, -2 }, /* (86) db_optr ::= db_optr cache */
+ { 216, -2 }, /* (87) db_optr ::= db_optr replica */
+ { 216, -2 }, /* (88) db_optr ::= db_optr quorum */
+ { 216, -2 }, /* (89) db_optr ::= db_optr days */
+ { 216, -2 }, /* (90) db_optr ::= db_optr minrows */
+ { 216, -2 }, /* (91) db_optr ::= db_optr maxrows */
+ { 216, -2 }, /* (92) db_optr ::= db_optr blocks */
+ { 216, -2 }, /* (93) db_optr ::= db_optr ctime */
+ { 216, -2 }, /* (94) db_optr ::= db_optr wal */
+ { 216, -2 }, /* (95) db_optr ::= db_optr fsync */
+ { 216, -2 }, /* (96) db_optr ::= db_optr comp */
+ { 216, -2 }, /* (97) db_optr ::= db_optr prec */
+ { 216, -2 }, /* (98) db_optr ::= db_optr keep */
+ { 213, 0 }, /* (99) alter_db_optr ::= */
+ { 213, -2 }, /* (100) alter_db_optr ::= alter_db_optr replica */
+ { 213, -2 }, /* (101) alter_db_optr ::= alter_db_optr quorum */
+ { 213, -2 }, /* (102) alter_db_optr ::= alter_db_optr keep */
+ { 213, -2 }, /* (103) alter_db_optr ::= alter_db_optr blocks */
+ { 213, -2 }, /* (104) alter_db_optr ::= alter_db_optr comp */
+ { 213, -2 }, /* (105) alter_db_optr ::= alter_db_optr wal */
+ { 213, -2 }, /* (106) alter_db_optr ::= alter_db_optr fsync */
+ { 240, -1 }, /* (107) typename ::= ids */
+ { 240, -4 }, /* (108) typename ::= ids LP signed RP */
+ { 241, -1 }, /* (109) signed ::= INTEGER */
+ { 241, -2 }, /* (110) signed ::= PLUS INTEGER */
+ { 241, -2 }, /* (111) signed ::= MINUS INTEGER */
+ { 208, -6 }, /* (112) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
+ { 242, -3 }, /* (113) create_table_args ::= LP columnlist RP */
+ { 242, -7 }, /* (114) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
+ { 242, -7 }, /* (115) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
+ { 242, -2 }, /* (116) create_table_args ::= AS select */
+ { 243, -3 }, /* (117) columnlist ::= columnlist COMMA column */
+ { 243, -1 }, /* (118) columnlist ::= column */
+ { 245, -2 }, /* (119) column ::= ids typename */
+ { 227, -3 }, /* (120) tagitemlist ::= tagitemlist COMMA tagitem */
+ { 227, -1 }, /* (121) tagitemlist ::= tagitem */
+ { 246, -1 }, /* (122) tagitem ::= INTEGER */
+ { 246, -1 }, /* (123) tagitem ::= FLOAT */
+ { 246, -1 }, /* (124) tagitem ::= STRING */
+ { 246, -1 }, /* (125) tagitem ::= BOOL */
+ { 246, -1 }, /* (126) tagitem ::= NULL */
+ { 246, -2 }, /* (127) tagitem ::= MINUS INTEGER */
+ { 246, -2 }, /* (128) tagitem ::= MINUS FLOAT */
+ { 246, -2 }, /* (129) tagitem ::= PLUS INTEGER */
+ { 246, -2 }, /* (130) tagitem ::= PLUS FLOAT */
+ { 244, -12 }, /* (131) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+ { 258, -1 }, /* (132) union ::= select */
+ { 258, -3 }, /* (133) union ::= LP union RP */
+ { 258, -4 }, /* (134) union ::= union UNION ALL select */
+ { 258, -6 }, /* (135) union ::= union UNION ALL LP select RP */
+ { 208, -1 }, /* (136) cmd ::= union */
+ { 244, -2 }, /* (137) select ::= SELECT selcollist */
+ { 259, -2 }, /* (138) sclp ::= selcollist COMMA */
+ { 259, 0 }, /* (139) sclp ::= */
+ { 247, -3 }, /* (140) selcollist ::= sclp expr as */
+ { 247, -2 }, /* (141) selcollist ::= sclp STAR */
+ { 261, -2 }, /* (142) as ::= AS ids */
+ { 261, -1 }, /* (143) as ::= ids */
+ { 261, 0 }, /* (144) as ::= */
+ { 248, -2 }, /* (145) from ::= FROM tablelist */
+ { 262, -2 }, /* (146) tablelist ::= ids cpxName */
+ { 262, -3 }, /* (147) tablelist ::= ids cpxName ids */
+ { 262, -4 }, /* (148) tablelist ::= tablelist COMMA ids cpxName */
+ { 262, -5 }, /* (149) tablelist ::= tablelist COMMA ids cpxName ids */
+ { 263, -1 }, /* (150) tmvar ::= VARIABLE */
+ { 250, -4 }, /* (151) interval_opt ::= INTERVAL LP tmvar RP */
+ { 250, -6 }, /* (152) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+ { 250, 0 }, /* (153) interval_opt ::= */
+ { 251, 0 }, /* (154) fill_opt ::= */
+ { 251, -6 }, /* (155) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+ { 251, -4 }, /* (156) fill_opt ::= FILL LP ID RP */
+ { 252, -4 }, /* (157) sliding_opt ::= SLIDING LP tmvar RP */
+ { 252, 0 }, /* (158) sliding_opt ::= */
+ { 254, 0 }, /* (159) orderby_opt ::= */
+ { 254, -3 }, /* (160) orderby_opt ::= ORDER BY sortlist */
+ { 264, -4 }, /* (161) sortlist ::= sortlist COMMA item sortorder */
+ { 264, -2 }, /* (162) sortlist ::= item sortorder */
+ { 266, -2 }, /* (163) item ::= ids cpxName */
+ { 267, -1 }, /* (164) sortorder ::= ASC */
+ { 267, -1 }, /* (165) sortorder ::= DESC */
+ { 267, 0 }, /* (166) sortorder ::= */
+ { 253, 0 }, /* (167) groupby_opt ::= */
+ { 253, -3 }, /* (168) groupby_opt ::= GROUP BY grouplist */
+ { 268, -3 }, /* (169) grouplist ::= grouplist COMMA item */
+ { 268, -1 }, /* (170) grouplist ::= item */
+ { 255, 0 }, /* (171) having_opt ::= */
+ { 255, -2 }, /* (172) having_opt ::= HAVING expr */
+ { 257, 0 }, /* (173) limit_opt ::= */
+ { 257, -2 }, /* (174) limit_opt ::= LIMIT signed */
+ { 257, -4 }, /* (175) limit_opt ::= LIMIT signed OFFSET signed */
+ { 257, -4 }, /* (176) limit_opt ::= LIMIT signed COMMA signed */
+ { 256, 0 }, /* (177) slimit_opt ::= */
+ { 256, -2 }, /* (178) slimit_opt ::= SLIMIT signed */
+ { 256, -4 }, /* (179) slimit_opt ::= SLIMIT signed SOFFSET signed */
+ { 256, -4 }, /* (180) slimit_opt ::= SLIMIT signed COMMA signed */
+ { 249, 0 }, /* (181) where_opt ::= */
+ { 249, -2 }, /* (182) where_opt ::= WHERE expr */
+ { 260, -3 }, /* (183) expr ::= LP expr RP */
+ { 260, -1 }, /* (184) expr ::= ID */
+ { 260, -3 }, /* (185) expr ::= ID DOT ID */
+ { 260, -3 }, /* (186) expr ::= ID DOT STAR */
+ { 260, -1 }, /* (187) expr ::= INTEGER */
+ { 260, -2 }, /* (188) expr ::= MINUS INTEGER */
+ { 260, -2 }, /* (189) expr ::= PLUS INTEGER */
+ { 260, -1 }, /* (190) expr ::= FLOAT */
+ { 260, -2 }, /* (191) expr ::= MINUS FLOAT */
+ { 260, -2 }, /* (192) expr ::= PLUS FLOAT */
+ { 260, -1 }, /* (193) expr ::= STRING */
+ { 260, -1 }, /* (194) expr ::= NOW */
+ { 260, -1 }, /* (195) expr ::= VARIABLE */
+ { 260, -1 }, /* (196) expr ::= BOOL */
+ { 260, -4 }, /* (197) expr ::= ID LP exprlist RP */
+ { 260, -4 }, /* (198) expr ::= ID LP STAR RP */
+ { 260, -3 }, /* (199) expr ::= expr IS NULL */
+ { 260, -4 }, /* (200) expr ::= expr IS NOT NULL */
+ { 260, -3 }, /* (201) expr ::= expr LT expr */
+ { 260, -3 }, /* (202) expr ::= expr GT expr */
+ { 260, -3 }, /* (203) expr ::= expr LE expr */
+ { 260, -3 }, /* (204) expr ::= expr GE expr */
+ { 260, -3 }, /* (205) expr ::= expr NE expr */
+ { 260, -3 }, /* (206) expr ::= expr EQ expr */
+ { 260, -3 }, /* (207) expr ::= expr AND expr */
+ { 260, -3 }, /* (208) expr ::= expr OR expr */
+ { 260, -3 }, /* (209) expr ::= expr PLUS expr */
+ { 260, -3 }, /* (210) expr ::= expr MINUS expr */
+ { 260, -3 }, /* (211) expr ::= expr STAR expr */
+ { 260, -3 }, /* (212) expr ::= expr SLASH expr */
+ { 260, -3 }, /* (213) expr ::= expr REM expr */
+ { 260, -3 }, /* (214) expr ::= expr LIKE expr */
+ { 260, -5 }, /* (215) expr ::= expr IN LP exprlist RP */
+ { 269, -3 }, /* (216) exprlist ::= exprlist COMMA expritem */
+ { 269, -1 }, /* (217) exprlist ::= expritem */
+ { 270, -1 }, /* (218) expritem ::= expr */
+ { 270, 0 }, /* (219) expritem ::= */
+ { 208, -3 }, /* (220) cmd ::= RESET QUERY CACHE */
+ { 208, -7 }, /* (221) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+ { 208, -7 }, /* (222) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+ { 208, -7 }, /* (223) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+ { 208, -7 }, /* (224) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+ { 208, -8 }, /* (225) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+ { 208, -9 }, /* (226) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+ { 208, -3 }, /* (227) cmd ::= KILL CONNECTION INTEGER */
+ { 208, -5 }, /* (228) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+ { 208, -5 }, /* (229) cmd ::= KILL QUERY INTEGER COLON INTEGER */
};
static void yy_accept(yyParser*); /* Forward Declaration */
@@ -2176,34 +1940,30 @@ static void yy_accept(yyParser*); /* Forward Declaration */
** only called from one place, optimizing compilers will in-line it, which
** means that the extra parameters have no performance impact.
*/
-static YYACTIONTYPE yy_reduce(
+static void yy_reduce(
yyParser *yypParser, /* The parser */
unsigned int yyruleno, /* Number of the rule by which to reduce */
int yyLookahead, /* Lookahead token, or YYNOCODE if none */
ParseTOKENTYPE yyLookaheadToken /* Value of the lookahead token */
- ParseCTX_PDECL /* %extra_context */
){
int yygoto; /* The next state */
- YYACTIONTYPE yyact; /* The next action */
+ int yyact; /* The next action */
yyStackEntry *yymsp; /* The top of the parser's stack */
int yysize; /* Amount to pop the stack */
- ParseARG_FETCH
+ ParseARG_FETCH;
(void)yyLookahead;
(void)yyLookaheadToken;
yymsp = yypParser->yytos;
#ifndef NDEBUG
if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
- yysize = yyRuleInfoNRhs[yyruleno];
+ yysize = yyRuleInfo[yyruleno].nrhs;
if( yysize ){
- fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
+ fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n",
yyTracePrompt,
- yyruleno, yyRuleName[yyruleno],
- yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){
yypParser->yyhwm++;
@@ -2221,19 +1981,13 @@ static YYACTIONTYPE yy_reduce(
#if YYSTACKDEPTH>0
if( yypParser->yytos>=yypParser->yystackEnd ){
yyStackOverflow(yypParser);
- /* The call to yyStackOverflow() above pops the stack until it is
- ** empty, causing the main parser loop to exit. So the return value
- ** is never used and does not matter. */
- return 0;
+ return;
}
#else
if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
if( yyGrowStack(yypParser) ){
yyStackOverflow(yypParser);
- /* The call to yyStackOverflow() above pops the stack until it is
- ** empty, causing the main parser loop to exit. So the return value
- ** is never used and does not matter. */
- return 0;
+ return;
}
yymsp = yypParser->yytos;
}
@@ -2309,708 +2063,719 @@ static YYACTIONTYPE yy_reduce(
case 18: /* cpxName ::= DOT ids */
{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n += 1; }
break;
- case 19: /* cmd ::= SHOW dbPrefix TABLES */
+ case 19: /* cmd ::= SHOW CREATE TABLE ids cpxName */
+{
+ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
+ setDCLSQLElems(pInfo, TSDB_SQL_SHOW_CREATE_TABLE, 1, &yymsp[-1].minor.yy0);
+}
+ break;
+ case 20: /* cmd ::= SHOW CREATE DATABASE ids */
+{
+ setDCLSQLElems(pInfo, TSDB_SQL_SHOW_CREATE_DATABASE, 1, &yymsp[0].minor.yy0);
+}
+ break;
+ case 21: /* cmd ::= SHOW dbPrefix TABLES */
{
setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-1].minor.yy0, 0);
}
break;
- case 20: /* cmd ::= SHOW dbPrefix TABLES LIKE ids */
+ case 22: /* cmd ::= SHOW dbPrefix TABLES LIKE ids */
{
setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0);
}
break;
- case 21: /* cmd ::= SHOW dbPrefix STABLES */
+ case 23: /* cmd ::= SHOW dbPrefix STABLES */
{
setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &yymsp[-1].minor.yy0, 0);
}
break;
- case 22: /* cmd ::= SHOW dbPrefix STABLES LIKE ids */
+ case 24: /* cmd ::= SHOW dbPrefix STABLES LIKE ids */
{
SStrToken token;
setDBName(&token, &yymsp[-3].minor.yy0);
setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &token, &yymsp[0].minor.yy0);
}
break;
- case 23: /* cmd ::= SHOW dbPrefix VGROUPS */
+ case 25: /* cmd ::= SHOW dbPrefix VGROUPS */
{
SStrToken token;
setDBName(&token, &yymsp[-1].minor.yy0);
setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, 0);
}
break;
- case 24: /* cmd ::= SHOW dbPrefix VGROUPS ids */
+ case 26: /* cmd ::= SHOW dbPrefix VGROUPS ids */
{
SStrToken token;
setDBName(&token, &yymsp[-2].minor.yy0);
setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, &yymsp[0].minor.yy0);
}
break;
- case 25: /* cmd ::= DROP TABLE ifexists ids cpxName */
+ case 27: /* cmd ::= DROP TABLE ifexists ids cpxName */
{
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
setDropDBTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0);
}
break;
- case 26: /* cmd ::= DROP DATABASE ifexists ids */
+ case 28: /* cmd ::= DROP DATABASE ifexists ids */
{ setDropDBTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0); }
break;
- case 27: /* cmd ::= DROP DNODE ids */
+ case 29: /* cmd ::= DROP DNODE ids */
{ setDCLSQLElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &yymsp[0].minor.yy0); }
break;
- case 28: /* cmd ::= DROP USER ids */
+ case 30: /* cmd ::= DROP USER ids */
{ setDCLSQLElems(pInfo, TSDB_SQL_DROP_USER, 1, &yymsp[0].minor.yy0); }
break;
- case 29: /* cmd ::= DROP ACCOUNT ids */
+ case 31: /* cmd ::= DROP ACCOUNT ids */
{ setDCLSQLElems(pInfo, TSDB_SQL_DROP_ACCT, 1, &yymsp[0].minor.yy0); }
break;
- case 30: /* cmd ::= USE ids */
+ case 32: /* cmd ::= USE ids */
{ setDCLSQLElems(pInfo, TSDB_SQL_USE_DB, 1, &yymsp[0].minor.yy0);}
break;
- case 31: /* cmd ::= DESCRIBE ids cpxName */
+ case 33: /* cmd ::= DESCRIBE ids cpxName */
{
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
setDCLSQLElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &yymsp[-1].minor.yy0);
}
break;
- case 32: /* cmd ::= ALTER USER ids PASS ids */
+ case 34: /* cmd ::= ALTER USER ids PASS ids */
{ setAlterUserSQL(pInfo, TSDB_ALTER_USER_PASSWD, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, NULL); }
break;
- case 33: /* cmd ::= ALTER USER ids PRIVILEGE ids */
+ case 35: /* cmd ::= ALTER USER ids PRIVILEGE ids */
{ setAlterUserSQL(pInfo, TSDB_ALTER_USER_PRIVILEGES, &yymsp[-2].minor.yy0, NULL, &yymsp[0].minor.yy0);}
break;
- case 34: /* cmd ::= ALTER DNODE ids ids */
+ case 36: /* cmd ::= ALTER DNODE ids ids */
{ setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
break;
- case 35: /* cmd ::= ALTER DNODE ids ids ids */
+ case 37: /* 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 36: /* cmd ::= ALTER LOCAL ids */
+ case 38: /* cmd ::= ALTER LOCAL ids */
{ setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &yymsp[0].minor.yy0); }
break;
- case 37: /* cmd ::= ALTER LOCAL ids ids */
+ case 39: /* cmd ::= ALTER LOCAL ids ids */
{ setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
break;
- case 38: /* cmd ::= ALTER DATABASE ids alter_db_optr */
-{ SStrToken t = {0}; setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy118, &t);}
+ case 40: /* cmd ::= ALTER DATABASE ids alter_db_optr */
+{ SStrToken t = {0}; setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy158, &t);}
break;
- case 39: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy479);}
+ case 41: /* cmd ::= ALTER ACCOUNT ids acct_optr */
+{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy73);}
break;
- case 40: /* 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.yy479);}
+ case 42: /* 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.yy73);}
break;
- case 41: /* ids ::= ID */
- case 42: /* ids ::= STRING */ yytestcase(yyruleno==42);
+ case 43: /* ids ::= ID */
+ case 44: /* ids ::= STRING */ yytestcase(yyruleno==44);
{yylhsminor.yy0 = yymsp[0].minor.yy0; }
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
- case 43: /* ifexists ::= IF EXISTS */
+ case 45: /* ifexists ::= IF EXISTS */
{yymsp[-1].minor.yy0.n = 1;}
break;
- case 44: /* ifexists ::= */
- case 46: /* ifnotexists ::= */ yytestcase(yyruleno==46);
+ case 46: /* ifexists ::= */
+ case 48: /* ifnotexists ::= */ yytestcase(yyruleno==48);
{yymsp[1].minor.yy0.n = 0;}
break;
- case 45: /* ifnotexists ::= IF NOT EXISTS */
+ case 47: /* ifnotexists ::= IF NOT EXISTS */
{yymsp[-2].minor.yy0.n = 1;}
break;
- case 47: /* cmd ::= CREATE DNODE ids */
+ case 49: /* cmd ::= CREATE DNODE ids */
{ setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
break;
- case 48: /* 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.yy479);}
+ case 50: /* 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.yy73);}
break;
- case 49: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy118, &yymsp[-2].minor.yy0);}
+ case 51: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy158, &yymsp[-2].minor.yy0);}
break;
- case 50: /* cmd ::= CREATE USER ids PASS ids */
+ case 52: /* cmd ::= CREATE USER ids PASS ids */
{ setCreateUserSQL(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
break;
- case 51: /* pps ::= */
- case 53: /* tseries ::= */ yytestcase(yyruleno==53);
- case 55: /* dbs ::= */ yytestcase(yyruleno==55);
- case 57: /* streams ::= */ yytestcase(yyruleno==57);
- case 59: /* storage ::= */ yytestcase(yyruleno==59);
- case 61: /* qtime ::= */ yytestcase(yyruleno==61);
- case 63: /* users ::= */ yytestcase(yyruleno==63);
- case 65: /* conns ::= */ yytestcase(yyruleno==65);
- case 67: /* state ::= */ yytestcase(yyruleno==67);
+ case 53: /* pps ::= */
+ case 55: /* tseries ::= */ yytestcase(yyruleno==55);
+ case 57: /* dbs ::= */ yytestcase(yyruleno==57);
+ case 59: /* streams ::= */ yytestcase(yyruleno==59);
+ case 61: /* storage ::= */ yytestcase(yyruleno==61);
+ case 63: /* qtime ::= */ yytestcase(yyruleno==63);
+ case 65: /* users ::= */ yytestcase(yyruleno==65);
+ case 67: /* conns ::= */ yytestcase(yyruleno==67);
+ case 69: /* state ::= */ yytestcase(yyruleno==69);
{yymsp[1].minor.yy0.n = 0; }
break;
- case 52: /* pps ::= PPS INTEGER */
- case 54: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==54);
- case 56: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==56);
- case 58: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==58);
- case 60: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==60);
- case 62: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==62);
- case 64: /* users ::= USERS INTEGER */ yytestcase(yyruleno==64);
- case 66: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==66);
- case 68: /* state ::= STATE ids */ yytestcase(yyruleno==68);
+ case 54: /* pps ::= PPS INTEGER */
+ case 56: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==56);
+ case 58: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==58);
+ case 60: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==60);
+ case 62: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==62);
+ case 64: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==64);
+ case 66: /* users ::= USERS INTEGER */ yytestcase(yyruleno==66);
+ case 68: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==68);
+ case 70: /* state ::= STATE ids */ yytestcase(yyruleno==70);
{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
- case 69: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+ case 71: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
{
- yylhsminor.yy479.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
- yylhsminor.yy479.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
- yylhsminor.yy479.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
- yylhsminor.yy479.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
- yylhsminor.yy479.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
- yylhsminor.yy479.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
- yylhsminor.yy479.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
- yylhsminor.yy479.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
- yylhsminor.yy479.stat = yymsp[0].minor.yy0;
+ yylhsminor.yy73.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+ yylhsminor.yy73.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+ yylhsminor.yy73.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+ yylhsminor.yy73.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+ yylhsminor.yy73.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+ yylhsminor.yy73.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+ yylhsminor.yy73.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+ yylhsminor.yy73.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+ yylhsminor.yy73.stat = yymsp[0].minor.yy0;
}
- yymsp[-8].minor.yy479 = yylhsminor.yy479;
+ yymsp[-8].minor.yy73 = yylhsminor.yy73;
break;
- case 70: /* keep ::= KEEP tagitemlist */
-{ yymsp[-1].minor.yy156 = yymsp[0].minor.yy156; }
+ case 72: /* keep ::= KEEP tagitemlist */
+{ yymsp[-1].minor.yy494 = yymsp[0].minor.yy494; }
break;
- case 71: /* cache ::= CACHE INTEGER */
- case 72: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==72);
- case 73: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==73);
- case 74: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==74);
- case 75: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==75);
- case 76: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==76);
- case 77: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==77);
- case 78: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==78);
- case 79: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==79);
- case 80: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==80);
- case 81: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==81);
- case 82: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==82);
+ case 73: /* cache ::= CACHE INTEGER */
+ case 74: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==74);
+ case 75: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==75);
+ case 76: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==76);
+ case 77: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==77);
+ case 78: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==78);
+ case 79: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==79);
+ case 80: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==80);
+ case 81: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==81);
+ case 82: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==82);
+ case 83: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==83);
+ case 84: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==84);
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
- case 83: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy118);}
+ case 85: /* db_optr ::= */
+{setDefaultCreateDbOption(&yymsp[1].minor.yy158);}
break;
- case 84: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 86: /* db_optr ::= db_optr cache */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 85: /* db_optr ::= db_optr replica */
- case 98: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==98);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 87: /* db_optr ::= db_optr replica */
+ case 100: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==100);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 86: /* db_optr ::= db_optr quorum */
- case 99: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==99);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 88: /* db_optr ::= db_optr quorum */
+ case 101: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==101);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 87: /* db_optr ::= db_optr days */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 89: /* db_optr ::= db_optr days */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 88: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 90: /* db_optr ::= db_optr minrows */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 89: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 91: /* db_optr ::= db_optr maxrows */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 90: /* db_optr ::= db_optr blocks */
- case 101: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==101);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 92: /* db_optr ::= db_optr blocks */
+ case 103: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==103);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 91: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 93: /* db_optr ::= db_optr ctime */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 92: /* db_optr ::= db_optr wal */
- case 103: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==103);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 94: /* db_optr ::= db_optr wal */
+ case 105: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==105);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 93: /* db_optr ::= db_optr fsync */
- case 104: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==104);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 95: /* db_optr ::= db_optr fsync */
+ case 106: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==106);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 94: /* db_optr ::= db_optr comp */
- case 102: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==102);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 96: /* db_optr ::= db_optr comp */
+ case 104: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==104);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 95: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.precision = yymsp[0].minor.yy0; }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 97: /* db_optr ::= db_optr prec */
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.precision = yymsp[0].minor.yy0; }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 96: /* db_optr ::= db_optr keep */
- case 100: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==100);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.keep = yymsp[0].minor.yy156; }
- yymsp[-1].minor.yy118 = yylhsminor.yy118;
+ case 98: /* db_optr ::= db_optr keep */
+ case 102: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==102);
+{ yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.keep = yymsp[0].minor.yy494; }
+ yymsp[-1].minor.yy158 = yylhsminor.yy158;
break;
- case 97: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy118);}
+ case 99: /* alter_db_optr ::= */
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy158);}
break;
- case 105: /* typename ::= ids */
+ case 107: /* typename ::= ids */
{
yymsp[0].minor.yy0.type = 0;
- tSQLSetColumnType (&yylhsminor.yy343, &yymsp[0].minor.yy0);
+ tSQLSetColumnType (&yylhsminor.yy181, &yymsp[0].minor.yy0);
}
- yymsp[0].minor.yy343 = yylhsminor.yy343;
+ yymsp[0].minor.yy181 = yylhsminor.yy181;
break;
- case 106: /* typename ::= ids LP signed RP */
+ case 108: /* typename ::= ids LP signed RP */
{
- if (yymsp[-1].minor.yy369 <= 0) {
+ if (yymsp[-1].minor.yy271 <= 0) {
yymsp[-3].minor.yy0.type = 0;
- tSQLSetColumnType(&yylhsminor.yy343, &yymsp[-3].minor.yy0);
+ tSQLSetColumnType(&yylhsminor.yy181, &yymsp[-3].minor.yy0);
} else {
- yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy369; // negative value of name length
- tSQLSetColumnType(&yylhsminor.yy343, &yymsp[-3].minor.yy0);
+ yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy271; // negative value of name length
+ tSQLSetColumnType(&yylhsminor.yy181, &yymsp[-3].minor.yy0);
}
}
- yymsp[-3].minor.yy343 = yylhsminor.yy343;
+ yymsp[-3].minor.yy181 = yylhsminor.yy181;
break;
- case 107: /* signed ::= INTEGER */
-{ yylhsminor.yy369 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
- yymsp[0].minor.yy369 = yylhsminor.yy369;
+ case 109: /* signed ::= INTEGER */
+{ yylhsminor.yy271 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ yymsp[0].minor.yy271 = yylhsminor.yy271;
break;
- case 108: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy369 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+ case 110: /* signed ::= PLUS INTEGER */
+{ yymsp[-1].minor.yy271 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
break;
- case 109: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy369 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+ case 111: /* signed ::= MINUS INTEGER */
+{ yymsp[-1].minor.yy271 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
break;
- case 110: /* cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
+ case 112: /* cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
{
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
setCreatedTableName(pInfo, &yymsp[-2].minor.yy0, &yymsp[-3].minor.yy0);
}
break;
- case 111: /* create_table_args ::= LP columnlist RP */
+ case 113: /* create_table_args ::= LP columnlist RP */
{
- yymsp[-2].minor.yy398 = tSetCreateSQLElems(yymsp[-1].minor.yy511, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
- setSQLInfo(pInfo, yymsp[-2].minor.yy398, NULL, TSDB_SQL_CREATE_TABLE);
+ yymsp[-2].minor.yy374 = tSetCreateSQLElems(yymsp[-1].minor.yy449, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
+ setSQLInfo(pInfo, yymsp[-2].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
}
break;
- case 112: /* create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
+ case 114: /* create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
{
- yymsp[-6].minor.yy398 = tSetCreateSQLElems(yymsp[-5].minor.yy511, yymsp[-1].minor.yy511, NULL, NULL, NULL, TSQL_CREATE_STABLE);
- setSQLInfo(pInfo, yymsp[-6].minor.yy398, NULL, TSDB_SQL_CREATE_TABLE);
+ yymsp[-6].minor.yy374 = tSetCreateSQLElems(yymsp[-5].minor.yy449, yymsp[-1].minor.yy449, NULL, NULL, NULL, TSQL_CREATE_STABLE);
+ setSQLInfo(pInfo, yymsp[-6].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
}
break;
- case 113: /* create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
+ case 115: /* create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
{
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
- yymsp[-6].minor.yy398 = tSetCreateSQLElems(NULL, NULL, &yymsp[-5].minor.yy0, yymsp[-1].minor.yy156, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
- setSQLInfo(pInfo, yymsp[-6].minor.yy398, NULL, TSDB_SQL_CREATE_TABLE);
+ yymsp[-6].minor.yy374 = tSetCreateSQLElems(NULL, NULL, &yymsp[-5].minor.yy0, yymsp[-1].minor.yy494, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
+ setSQLInfo(pInfo, yymsp[-6].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
}
break;
- case 114: /* create_table_args ::= AS select */
+ case 116: /* create_table_args ::= AS select */
{
- yymsp[-1].minor.yy398 = tSetCreateSQLElems(NULL, NULL, NULL, NULL, yymsp[0].minor.yy444, TSQL_CREATE_STREAM);
- setSQLInfo(pInfo, yymsp[-1].minor.yy398, NULL, TSDB_SQL_CREATE_TABLE);
+ yymsp[-1].minor.yy374 = tSetCreateSQLElems(NULL, NULL, NULL, NULL, yymsp[0].minor.yy150, TSQL_CREATE_STREAM);
+ setSQLInfo(pInfo, yymsp[-1].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
}
break;
- case 115: /* columnlist ::= columnlist COMMA column */
-{yylhsminor.yy511 = tFieldListAppend(yymsp[-2].minor.yy511, &yymsp[0].minor.yy343); }
- yymsp[-2].minor.yy511 = yylhsminor.yy511;
+ case 117: /* columnlist ::= columnlist COMMA column */
+{yylhsminor.yy449 = tFieldListAppend(yymsp[-2].minor.yy449, &yymsp[0].minor.yy181); }
+ yymsp[-2].minor.yy449 = yylhsminor.yy449;
break;
- case 116: /* columnlist ::= column */
-{yylhsminor.yy511 = tFieldListAppend(NULL, &yymsp[0].minor.yy343);}
- yymsp[0].minor.yy511 = yylhsminor.yy511;
+ case 118: /* columnlist ::= column */
+{yylhsminor.yy449 = tFieldListAppend(NULL, &yymsp[0].minor.yy181);}
+ yymsp[0].minor.yy449 = yylhsminor.yy449;
break;
- case 117: /* column ::= ids typename */
+ case 119: /* column ::= ids typename */
{
- tSQLSetColumnInfo(&yylhsminor.yy343, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy343);
+ tSQLSetColumnInfo(&yylhsminor.yy181, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy181);
}
- yymsp[-1].minor.yy343 = yylhsminor.yy343;
+ yymsp[-1].minor.yy181 = yylhsminor.yy181;
break;
- case 118: /* tagitemlist ::= tagitemlist COMMA tagitem */
-{ yylhsminor.yy156 = tVariantListAppend(yymsp[-2].minor.yy156, &yymsp[0].minor.yy506, -1); }
- yymsp[-2].minor.yy156 = yylhsminor.yy156;
+ case 120: /* tagitemlist ::= tagitemlist COMMA tagitem */
+{ yylhsminor.yy494 = tVariantListAppend(yymsp[-2].minor.yy494, &yymsp[0].minor.yy312, -1); }
+ yymsp[-2].minor.yy494 = yylhsminor.yy494;
break;
- case 119: /* tagitemlist ::= tagitem */
-{ yylhsminor.yy156 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1); }
- yymsp[0].minor.yy156 = yylhsminor.yy156;
+ case 121: /* tagitemlist ::= tagitem */
+{ yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[0].minor.yy312, -1); }
+ yymsp[0].minor.yy494 = yylhsminor.yy494;
break;
- case 120: /* tagitem ::= INTEGER */
- case 121: /* tagitem ::= FLOAT */ yytestcase(yyruleno==121);
- case 122: /* tagitem ::= STRING */ yytestcase(yyruleno==122);
- case 123: /* tagitem ::= BOOL */ yytestcase(yyruleno==123);
-{toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy506 = yylhsminor.yy506;
+ case 122: /* tagitem ::= INTEGER */
+ case 123: /* tagitem ::= FLOAT */ yytestcase(yyruleno==123);
+ case 124: /* tagitem ::= STRING */ yytestcase(yyruleno==124);
+ case 125: /* tagitem ::= BOOL */ yytestcase(yyruleno==125);
+{toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy312, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy312 = yylhsminor.yy312;
break;
- case 124: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0); }
- yymsp[0].minor.yy506 = yylhsminor.yy506;
+ case 126: /* tagitem ::= NULL */
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy312, &yymsp[0].minor.yy0); }
+ yymsp[0].minor.yy312 = yylhsminor.yy312;
break;
- case 125: /* tagitem ::= MINUS INTEGER */
- case 126: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==126);
- case 127: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==127);
- case 128: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==128);
+ case 127: /* tagitem ::= MINUS INTEGER */
+ case 128: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==128);
+ case 129: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==129);
+ case 130: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==130);
{
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.yy312, &yymsp[-1].minor.yy0);
}
- yymsp[-1].minor.yy506 = yylhsminor.yy506;
+ yymsp[-1].minor.yy312 = yylhsminor.yy312;
break;
- case 129: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+ case 131: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
{
- yylhsminor.yy444 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy158, yymsp[-9].minor.yy156, yymsp[-8].minor.yy190, yymsp[-4].minor.yy156, yymsp[-3].minor.yy156, &yymsp[-7].minor.yy340, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy156, &yymsp[0].minor.yy414, &yymsp[-1].minor.yy414);
+ yylhsminor.yy150 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy224, yymsp[-9].minor.yy494, yymsp[-8].minor.yy66, yymsp[-4].minor.yy494, yymsp[-3].minor.yy494, &yymsp[-7].minor.yy314, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy494, &yymsp[0].minor.yy188, &yymsp[-1].minor.yy188);
}
- yymsp[-11].minor.yy444 = yylhsminor.yy444;
+ yymsp[-11].minor.yy150 = yylhsminor.yy150;
break;
- case 130: /* union ::= select */
-{ yylhsminor.yy333 = setSubclause(NULL, yymsp[0].minor.yy444); }
- yymsp[0].minor.yy333 = yylhsminor.yy333;
+ case 132: /* union ::= select */
+{ yylhsminor.yy25 = setSubclause(NULL, yymsp[0].minor.yy150); }
+ yymsp[0].minor.yy25 = yylhsminor.yy25;
break;
- case 131: /* union ::= LP union RP */
-{ yymsp[-2].minor.yy333 = yymsp[-1].minor.yy333; }
+ case 133: /* union ::= LP union RP */
+{ yymsp[-2].minor.yy25 = yymsp[-1].minor.yy25; }
break;
- case 132: /* union ::= union UNION ALL select */
-{ yylhsminor.yy333 = appendSelectClause(yymsp[-3].minor.yy333, yymsp[0].minor.yy444); }
- yymsp[-3].minor.yy333 = yylhsminor.yy333;
+ case 134: /* union ::= union UNION ALL select */
+{ yylhsminor.yy25 = appendSelectClause(yymsp[-3].minor.yy25, yymsp[0].minor.yy150); }
+ yymsp[-3].minor.yy25 = yylhsminor.yy25;
break;
- case 133: /* union ::= union UNION ALL LP select RP */
-{ yylhsminor.yy333 = appendSelectClause(yymsp[-5].minor.yy333, yymsp[-1].minor.yy444); }
- yymsp[-5].minor.yy333 = yylhsminor.yy333;
+ case 135: /* union ::= union UNION ALL LP select RP */
+{ yylhsminor.yy25 = appendSelectClause(yymsp[-5].minor.yy25, yymsp[-1].minor.yy150); }
+ yymsp[-5].minor.yy25 = yylhsminor.yy25;
break;
- case 134: /* cmd ::= union */
-{ setSQLInfo(pInfo, yymsp[0].minor.yy333, NULL, TSDB_SQL_SELECT); }
+ case 136: /* cmd ::= union */
+{ setSQLInfo(pInfo, yymsp[0].minor.yy25, NULL, TSDB_SQL_SELECT); }
break;
- case 135: /* select ::= SELECT selcollist */
+ case 137: /* select ::= SELECT selcollist */
{
- yylhsminor.yy444 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy158, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+ yylhsminor.yy150 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy224, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
}
- yymsp[-1].minor.yy444 = yylhsminor.yy444;
+ yymsp[-1].minor.yy150 = yylhsminor.yy150;
break;
- case 136: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy158 = yymsp[-1].minor.yy158;}
- yymsp[-1].minor.yy158 = yylhsminor.yy158;
+ case 138: /* sclp ::= selcollist COMMA */
+{yylhsminor.yy224 = yymsp[-1].minor.yy224;}
+ yymsp[-1].minor.yy224 = yylhsminor.yy224;
break;
- case 137: /* sclp ::= */
-{yymsp[1].minor.yy158 = 0;}
+ case 139: /* sclp ::= */
+{yymsp[1].minor.yy224 = 0;}
break;
- case 138: /* selcollist ::= sclp expr as */
+ case 140: /* selcollist ::= sclp expr as */
{
- yylhsminor.yy158 = tSQLExprListAppend(yymsp[-2].minor.yy158, yymsp[-1].minor.yy190, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+ yylhsminor.yy224 = tSQLExprListAppend(yymsp[-2].minor.yy224, yymsp[-1].minor.yy66, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
}
- yymsp[-2].minor.yy158 = yylhsminor.yy158;
+ yymsp[-2].minor.yy224 = yylhsminor.yy224;
break;
- case 139: /* selcollist ::= sclp STAR */
+ case 141: /* selcollist ::= sclp STAR */
{
tSQLExpr *pNode = tSQLExprIdValueCreate(NULL, TK_ALL);
- yylhsminor.yy158 = tSQLExprListAppend(yymsp[-1].minor.yy158, pNode, 0);
+ yylhsminor.yy224 = tSQLExprListAppend(yymsp[-1].minor.yy224, pNode, 0);
}
- yymsp[-1].minor.yy158 = yylhsminor.yy158;
+ yymsp[-1].minor.yy224 = yylhsminor.yy224;
break;
- case 140: /* as ::= AS ids */
+ case 142: /* as ::= AS ids */
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
- case 141: /* as ::= ids */
+ case 143: /* as ::= ids */
{ yylhsminor.yy0 = yymsp[0].minor.yy0; }
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
- case 142: /* as ::= */
+ case 144: /* as ::= */
{ yymsp[1].minor.yy0.n = 0; }
break;
- case 143: /* from ::= FROM tablelist */
-{yymsp[-1].minor.yy156 = yymsp[0].minor.yy156;}
+ case 145: /* from ::= FROM tablelist */
+{yymsp[-1].minor.yy494 = yymsp[0].minor.yy494;}
break;
- case 144: /* tablelist ::= ids cpxName */
+ case 146: /* tablelist ::= ids cpxName */
{
toTSDBType(yymsp[-1].minor.yy0.type);
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
- yylhsminor.yy156 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
- yylhsminor.yy156 = tVariantListAppendToken(yylhsminor.yy156, &yymsp[-1].minor.yy0, -1); // table alias name
+ yylhsminor.yy494 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+ yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[-1].minor.yy0, -1); // table alias name
}
- yymsp[-1].minor.yy156 = yylhsminor.yy156;
+ yymsp[-1].minor.yy494 = yylhsminor.yy494;
break;
- case 145: /* tablelist ::= ids cpxName ids */
+ case 147: /* tablelist ::= ids cpxName ids */
{
toTSDBType(yymsp[-2].minor.yy0.type);
toTSDBType(yymsp[0].minor.yy0.type);
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
- yylhsminor.yy156 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
- yylhsminor.yy156 = tVariantListAppendToken(yylhsminor.yy156, &yymsp[0].minor.yy0, -1);
+ yylhsminor.yy494 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
+ yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[0].minor.yy0, -1);
}
- yymsp[-2].minor.yy156 = yylhsminor.yy156;
+ yymsp[-2].minor.yy494 = yylhsminor.yy494;
break;
- case 146: /* tablelist ::= tablelist COMMA ids cpxName */
+ case 148: /* tablelist ::= tablelist COMMA ids cpxName */
{
toTSDBType(yymsp[-1].minor.yy0.type);
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
- yylhsminor.yy156 = tVariantListAppendToken(yymsp[-3].minor.yy156, &yymsp[-1].minor.yy0, -1);
- yylhsminor.yy156 = tVariantListAppendToken(yylhsminor.yy156, &yymsp[-1].minor.yy0, -1);
+ yylhsminor.yy494 = tVariantListAppendToken(yymsp[-3].minor.yy494, &yymsp[-1].minor.yy0, -1);
+ yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[-1].minor.yy0, -1);
}
- yymsp[-3].minor.yy156 = yylhsminor.yy156;
+ yymsp[-3].minor.yy494 = yylhsminor.yy494;
break;
- case 147: /* tablelist ::= tablelist COMMA ids cpxName ids */
+ case 149: /* tablelist ::= tablelist COMMA ids cpxName ids */
{
toTSDBType(yymsp[-2].minor.yy0.type);
toTSDBType(yymsp[0].minor.yy0.type);
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
- yylhsminor.yy156 = tVariantListAppendToken(yymsp[-4].minor.yy156, &yymsp[-2].minor.yy0, -1);
- yylhsminor.yy156 = tVariantListAppendToken(yylhsminor.yy156, &yymsp[0].minor.yy0, -1);
+ yylhsminor.yy494 = tVariantListAppendToken(yymsp[-4].minor.yy494, &yymsp[-2].minor.yy0, -1);
+ yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[0].minor.yy0, -1);
}
- yymsp[-4].minor.yy156 = yylhsminor.yy156;
+ yymsp[-4].minor.yy494 = yylhsminor.yy494;
break;
- case 148: /* tmvar ::= VARIABLE */
+ case 150: /* tmvar ::= VARIABLE */
{yylhsminor.yy0 = yymsp[0].minor.yy0;}
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
- case 149: /* interval_opt ::= INTERVAL LP tmvar RP */
-{yymsp[-3].minor.yy340.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy340.offset.n = 0; yymsp[-3].minor.yy340.offset.z = NULL; yymsp[-3].minor.yy340.offset.type = 0;}
+ case 151: /* interval_opt ::= INTERVAL LP tmvar RP */
+{yymsp[-3].minor.yy314.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy314.offset.n = 0; yymsp[-3].minor.yy314.offset.z = NULL; yymsp[-3].minor.yy314.offset.type = 0;}
break;
- case 150: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-{yymsp[-5].minor.yy340.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy340.offset = yymsp[-1].minor.yy0;}
+ case 152: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+{yymsp[-5].minor.yy314.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy314.offset = yymsp[-1].minor.yy0;}
break;
- case 151: /* interval_opt ::= */
-{memset(&yymsp[1].minor.yy340, 0, sizeof(yymsp[1].minor.yy340));}
+ case 153: /* interval_opt ::= */
+{memset(&yymsp[1].minor.yy314, 0, sizeof(yymsp[1].minor.yy314));}
break;
- case 152: /* fill_opt ::= */
-{yymsp[1].minor.yy156 = 0; }
+ case 154: /* fill_opt ::= */
+{yymsp[1].minor.yy494 = 0; }
break;
- case 153: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+ case 155: /* 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.yy156, &A, -1, 0);
- yymsp[-5].minor.yy156 = yymsp[-1].minor.yy156;
+ tVariantListInsert(yymsp[-1].minor.yy494, &A, -1, 0);
+ yymsp[-5].minor.yy494 = yymsp[-1].minor.yy494;
}
break;
- case 154: /* fill_opt ::= FILL LP ID RP */
+ case 156: /* fill_opt ::= FILL LP ID RP */
{
toTSDBType(yymsp[-1].minor.yy0.type);
- yymsp[-3].minor.yy156 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+ yymsp[-3].minor.yy494 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
}
break;
- case 155: /* sliding_opt ::= SLIDING LP tmvar RP */
+ case 157: /* sliding_opt ::= SLIDING LP tmvar RP */
{yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0; }
break;
- case 156: /* sliding_opt ::= */
+ case 158: /* sliding_opt ::= */
{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0; }
break;
- case 157: /* orderby_opt ::= */
- case 165: /* groupby_opt ::= */ yytestcase(yyruleno==165);
-{yymsp[1].minor.yy156 = 0;}
+ case 159: /* orderby_opt ::= */
+ case 167: /* groupby_opt ::= */ yytestcase(yyruleno==167);
+{yymsp[1].minor.yy494 = 0;}
break;
- case 158: /* orderby_opt ::= ORDER BY sortlist */
- case 166: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==166);
-{yymsp[-2].minor.yy156 = yymsp[0].minor.yy156;}
+ case 160: /* orderby_opt ::= ORDER BY sortlist */
+ case 168: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==168);
+{yymsp[-2].minor.yy494 = yymsp[0].minor.yy494;}
break;
- case 159: /* sortlist ::= sortlist COMMA item sortorder */
+ case 161: /* sortlist ::= sortlist COMMA item sortorder */
{
- yylhsminor.yy156 = tVariantListAppend(yymsp[-3].minor.yy156, &yymsp[-1].minor.yy506, yymsp[0].minor.yy112);
+ yylhsminor.yy494 = tVariantListAppend(yymsp[-3].minor.yy494, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
}
- yymsp[-3].minor.yy156 = yylhsminor.yy156;
+ yymsp[-3].minor.yy494 = yylhsminor.yy494;
break;
- case 160: /* sortlist ::= item sortorder */
+ case 162: /* sortlist ::= item sortorder */
{
- yylhsminor.yy156 = tVariantListAppend(NULL, &yymsp[-1].minor.yy506, yymsp[0].minor.yy112);
+ yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
}
- yymsp[-1].minor.yy156 = yylhsminor.yy156;
+ yymsp[-1].minor.yy494 = yylhsminor.yy494;
break;
- case 161: /* item ::= ids cpxName */
+ case 163: /* 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.yy312, &yymsp[-1].minor.yy0);
}
- yymsp[-1].minor.yy506 = yylhsminor.yy506;
+ yymsp[-1].minor.yy312 = yylhsminor.yy312;
break;
- case 162: /* sortorder ::= ASC */
-{yymsp[0].minor.yy112 = TSDB_ORDER_ASC; }
+ case 164: /* sortorder ::= ASC */
+{yymsp[0].minor.yy82 = TSDB_ORDER_ASC; }
break;
- case 163: /* sortorder ::= DESC */
-{yymsp[0].minor.yy112 = TSDB_ORDER_DESC;}
+ case 165: /* sortorder ::= DESC */
+{yymsp[0].minor.yy82 = TSDB_ORDER_DESC;}
break;
- case 164: /* sortorder ::= */
-{yymsp[1].minor.yy112 = TSDB_ORDER_ASC;}
+ case 166: /* sortorder ::= */
+{yymsp[1].minor.yy82 = TSDB_ORDER_ASC;}
break;
- case 167: /* grouplist ::= grouplist COMMA item */
+ case 169: /* grouplist ::= grouplist COMMA item */
{
- yylhsminor.yy156 = tVariantListAppend(yymsp[-2].minor.yy156, &yymsp[0].minor.yy506, -1);
+ yylhsminor.yy494 = tVariantListAppend(yymsp[-2].minor.yy494, &yymsp[0].minor.yy312, -1);
}
- yymsp[-2].minor.yy156 = yylhsminor.yy156;
+ yymsp[-2].minor.yy494 = yylhsminor.yy494;
break;
- case 168: /* grouplist ::= item */
+ case 170: /* grouplist ::= item */
{
- yylhsminor.yy156 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1);
+ yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[0].minor.yy312, -1);
}
- yymsp[0].minor.yy156 = yylhsminor.yy156;
+ yymsp[0].minor.yy494 = yylhsminor.yy494;
break;
- case 169: /* having_opt ::= */
- case 179: /* where_opt ::= */ yytestcase(yyruleno==179);
- case 217: /* expritem ::= */ yytestcase(yyruleno==217);
-{yymsp[1].minor.yy190 = 0;}
+ case 171: /* having_opt ::= */
+ case 181: /* where_opt ::= */ yytestcase(yyruleno==181);
+ case 219: /* expritem ::= */ yytestcase(yyruleno==219);
+{yymsp[1].minor.yy66 = 0;}
break;
- case 170: /* having_opt ::= HAVING expr */
- case 180: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==180);
-{yymsp[-1].minor.yy190 = yymsp[0].minor.yy190;}
+ case 172: /* having_opt ::= HAVING expr */
+ case 182: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==182);
+{yymsp[-1].minor.yy66 = yymsp[0].minor.yy66;}
break;
- case 171: /* limit_opt ::= */
- case 175: /* slimit_opt ::= */ yytestcase(yyruleno==175);
-{yymsp[1].minor.yy414.limit = -1; yymsp[1].minor.yy414.offset = 0;}
+ case 173: /* limit_opt ::= */
+ case 177: /* slimit_opt ::= */ yytestcase(yyruleno==177);
+{yymsp[1].minor.yy188.limit = -1; yymsp[1].minor.yy188.offset = 0;}
break;
- case 172: /* limit_opt ::= LIMIT signed */
- case 176: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==176);
-{yymsp[-1].minor.yy414.limit = yymsp[0].minor.yy369; yymsp[-1].minor.yy414.offset = 0;}
+ case 174: /* limit_opt ::= LIMIT signed */
+ case 178: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==178);
+{yymsp[-1].minor.yy188.limit = yymsp[0].minor.yy271; yymsp[-1].minor.yy188.offset = 0;}
break;
- case 173: /* limit_opt ::= LIMIT signed OFFSET signed */
- case 177: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ yytestcase(yyruleno==177);
-{yymsp[-3].minor.yy414.limit = yymsp[-2].minor.yy369; yymsp[-3].minor.yy414.offset = yymsp[0].minor.yy369;}
+ case 175: /* limit_opt ::= LIMIT signed OFFSET signed */
+ case 179: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ yytestcase(yyruleno==179);
+{yymsp[-3].minor.yy188.limit = yymsp[-2].minor.yy271; yymsp[-3].minor.yy188.offset = yymsp[0].minor.yy271;}
break;
- case 174: /* limit_opt ::= LIMIT signed COMMA signed */
- case 178: /* slimit_opt ::= SLIMIT signed COMMA signed */ yytestcase(yyruleno==178);
-{yymsp[-3].minor.yy414.limit = yymsp[0].minor.yy369; yymsp[-3].minor.yy414.offset = yymsp[-2].minor.yy369;}
+ case 176: /* limit_opt ::= LIMIT signed COMMA signed */
+ case 180: /* slimit_opt ::= SLIMIT signed COMMA signed */ yytestcase(yyruleno==180);
+{yymsp[-3].minor.yy188.limit = yymsp[0].minor.yy271; yymsp[-3].minor.yy188.offset = yymsp[-2].minor.yy271;}
break;
- case 181: /* expr ::= LP expr RP */
-{yymsp[-2].minor.yy190 = yymsp[-1].minor.yy190; }
+ case 183: /* expr ::= LP expr RP */
+{yymsp[-2].minor.yy66 = yymsp[-1].minor.yy66; }
break;
- case 182: /* expr ::= ID */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
- yymsp[0].minor.yy190 = yylhsminor.yy190;
+ case 184: /* expr ::= ID */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
+ yymsp[0].minor.yy66 = yylhsminor.yy66;
break;
- case 183: /* expr ::= ID DOT ID */
-{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 185: /* expr ::= ID DOT ID */
+{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 184: /* expr ::= ID DOT STAR */
-{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 186: /* expr ::= ID DOT STAR */
+{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 185: /* expr ::= INTEGER */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
- yymsp[0].minor.yy190 = yylhsminor.yy190;
+ case 187: /* expr ::= INTEGER */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
+ yymsp[0].minor.yy66 = yylhsminor.yy66;
break;
- case 186: /* expr ::= MINUS INTEGER */
- case 187: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==187);
-{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
- yymsp[-1].minor.yy190 = yylhsminor.yy190;
+ case 188: /* expr ::= MINUS INTEGER */
+ case 189: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==189);
+{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
+ yymsp[-1].minor.yy66 = yylhsminor.yy66;
break;
- case 188: /* expr ::= FLOAT */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
- yymsp[0].minor.yy190 = yylhsminor.yy190;
+ case 190: /* expr ::= FLOAT */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
+ yymsp[0].minor.yy66 = yylhsminor.yy66;
break;
- case 189: /* expr ::= MINUS FLOAT */
- case 190: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==190);
-{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
- yymsp[-1].minor.yy190 = yylhsminor.yy190;
+ case 191: /* expr ::= MINUS FLOAT */
+ case 192: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==192);
+{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
+ yymsp[-1].minor.yy66 = yylhsminor.yy66;
break;
- case 191: /* expr ::= STRING */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
- yymsp[0].minor.yy190 = yylhsminor.yy190;
+ case 193: /* expr ::= STRING */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
+ yymsp[0].minor.yy66 = yylhsminor.yy66;
break;
- case 192: /* expr ::= NOW */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
- yymsp[0].minor.yy190 = yylhsminor.yy190;
+ case 194: /* expr ::= NOW */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
+ yymsp[0].minor.yy66 = yylhsminor.yy66;
break;
- case 193: /* expr ::= VARIABLE */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
- yymsp[0].minor.yy190 = yylhsminor.yy190;
+ case 195: /* expr ::= VARIABLE */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
+ yymsp[0].minor.yy66 = yylhsminor.yy66;
break;
- case 194: /* expr ::= BOOL */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
- yymsp[0].minor.yy190 = yylhsminor.yy190;
+ case 196: /* expr ::= BOOL */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
+ yymsp[0].minor.yy66 = yylhsminor.yy66;
break;
- case 195: /* expr ::= ID LP exprlist RP */
-{ yylhsminor.yy190 = tSQLExprCreateFunction(yymsp[-1].minor.yy158, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
- yymsp[-3].minor.yy190 = yylhsminor.yy190;
+ case 197: /* expr ::= ID LP exprlist RP */
+{ yylhsminor.yy66 = tSQLExprCreateFunction(yymsp[-1].minor.yy224, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+ yymsp[-3].minor.yy66 = yylhsminor.yy66;
break;
- case 196: /* expr ::= ID LP STAR RP */
-{ yylhsminor.yy190 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
- yymsp[-3].minor.yy190 = yylhsminor.yy190;
+ case 198: /* expr ::= ID LP STAR RP */
+{ yylhsminor.yy66 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+ yymsp[-3].minor.yy66 = yylhsminor.yy66;
break;
- case 197: /* expr ::= expr IS NULL */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, NULL, TK_ISNULL);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 199: /* expr ::= expr IS NULL */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, NULL, TK_ISNULL);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 198: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-3].minor.yy190, NULL, TK_NOTNULL);}
- yymsp[-3].minor.yy190 = yylhsminor.yy190;
+ case 200: /* expr ::= expr IS NOT NULL */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-3].minor.yy66, NULL, TK_NOTNULL);}
+ yymsp[-3].minor.yy66 = yylhsminor.yy66;
break;
- case 199: /* expr ::= expr LT expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_LT);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 201: /* expr ::= expr LT expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LT);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 200: /* expr ::= expr GT expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_GT);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 202: /* expr ::= expr GT expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_GT);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 201: /* expr ::= expr LE expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_LE);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 203: /* expr ::= expr LE expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LE);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 202: /* expr ::= expr GE expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_GE);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 204: /* expr ::= expr GE expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_GE);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 203: /* expr ::= expr NE expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_NE);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 205: /* expr ::= expr NE expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_NE);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 204: /* expr ::= expr EQ expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_EQ);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 206: /* expr ::= expr EQ expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_EQ);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 205: /* expr ::= expr AND expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_AND);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 207: /* expr ::= expr AND expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_AND);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 206: /* expr ::= expr OR expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_OR); }
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 208: /* expr ::= expr OR expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_OR); }
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 207: /* expr ::= expr PLUS expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_PLUS); }
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 209: /* expr ::= expr PLUS expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_PLUS); }
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 208: /* expr ::= expr MINUS expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_MINUS); }
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 210: /* expr ::= expr MINUS expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_MINUS); }
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 209: /* expr ::= expr STAR expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_STAR); }
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 211: /* expr ::= expr STAR expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_STAR); }
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 210: /* expr ::= expr SLASH expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_DIVIDE);}
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 212: /* expr ::= expr SLASH expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_DIVIDE);}
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 211: /* expr ::= expr REM expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_REM); }
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 213: /* expr ::= expr REM expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_REM); }
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 212: /* expr ::= expr LIKE expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_LIKE); }
- yymsp[-2].minor.yy190 = yylhsminor.yy190;
+ case 214: /* expr ::= expr LIKE expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LIKE); }
+ yymsp[-2].minor.yy66 = yylhsminor.yy66;
break;
- case 213: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-4].minor.yy190, (tSQLExpr*)yymsp[-1].minor.yy158, TK_IN); }
- yymsp[-4].minor.yy190 = yylhsminor.yy190;
+ case 215: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-4].minor.yy66, (tSQLExpr*)yymsp[-1].minor.yy224, TK_IN); }
+ yymsp[-4].minor.yy66 = yylhsminor.yy66;
break;
- case 214: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy158 = tSQLExprListAppend(yymsp[-2].minor.yy158,yymsp[0].minor.yy190,0);}
- yymsp[-2].minor.yy158 = yylhsminor.yy158;
+ case 216: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy224 = tSQLExprListAppend(yymsp[-2].minor.yy224,yymsp[0].minor.yy66,0);}
+ yymsp[-2].minor.yy224 = yylhsminor.yy224;
break;
- case 215: /* exprlist ::= expritem */
-{yylhsminor.yy158 = tSQLExprListAppend(0,yymsp[0].minor.yy190,0);}
- yymsp[0].minor.yy158 = yylhsminor.yy158;
+ case 217: /* exprlist ::= expritem */
+{yylhsminor.yy224 = tSQLExprListAppend(0,yymsp[0].minor.yy66,0);}
+ yymsp[0].minor.yy224 = yylhsminor.yy224;
break;
- case 216: /* expritem ::= expr */
-{yylhsminor.yy190 = yymsp[0].minor.yy190;}
- yymsp[0].minor.yy190 = yylhsminor.yy190;
+ case 218: /* expritem ::= expr */
+{yylhsminor.yy66 = yymsp[0].minor.yy66;}
+ yymsp[0].minor.yy66 = yylhsminor.yy66;
break;
- case 218: /* cmd ::= RESET QUERY CACHE */
+ case 220: /* cmd ::= RESET QUERY CACHE */
{ setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
break;
- case 219: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+ case 221: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy511, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
+ SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy449, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 220: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+ case 222: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
@@ -3021,14 +2786,14 @@ static YYACTIONTYPE yy_reduce(
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 221: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+ case 223: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
- SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy511, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
+ SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy449, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 222: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+ case 224: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
@@ -3039,7 +2804,7 @@ static YYACTIONTYPE yy_reduce(
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 223: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+ case 225: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
{
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
@@ -3053,34 +2818,34 @@ static YYACTIONTYPE yy_reduce(
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 224: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+ case 226: /* 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);
tVariantList* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
- A = tVariantListAppend(A, &yymsp[0].minor.yy506, -1);
+ A = tVariantListAppend(A, &yymsp[0].minor.yy312, -1);
SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
- case 225: /* cmd ::= KILL CONNECTION INTEGER */
+ case 227: /* cmd ::= KILL CONNECTION INTEGER */
{setKillSQL(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
break;
- case 226: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+ case 228: /* 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 227: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+ case 229: /* 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:
break;
/********** End reduce actions ************************************************/
};
- assert( yyrulenostateno = (YYACTIONTYPE)yyact;
yymsp->major = (YYCODETYPE)yygoto;
yyTraceShift(yypParser, yyact, "... then shift");
- return yyact;
}
/*
@@ -3105,8 +2869,7 @@ static YYACTIONTYPE yy_reduce(
static void yy_parse_failed(
yyParser *yypParser /* The parser */
){
- ParseARG_FETCH
- ParseCTX_FETCH
+ ParseARG_FETCH;
#ifndef NDEBUG
if( yyTraceFILE ){
fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
@@ -3117,8 +2880,7 @@ static void yy_parse_failed(
** parser fails */
/************ Begin %parse_failure code ***************************************/
/************ End %parse_failure code *****************************************/
- ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
- ParseCTX_STORE
+ ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
}
#endif /* YYNOERRORRECOVERY */
@@ -3130,8 +2892,7 @@ static void yy_syntax_error(
int yymajor, /* The major type of the error token */
ParseTOKENTYPE yyminor /* The minor type of the error token */
){
- ParseARG_FETCH
- ParseCTX_FETCH
+ ParseARG_FETCH;
#define TOKEN yyminor
/************ Begin %syntax_error code ****************************************/
@@ -3157,8 +2918,7 @@ static void yy_syntax_error(
assert(len <= outputBufLen);
/************ End %syntax_error code ******************************************/
- ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
- ParseCTX_STORE
+ ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
}
/*
@@ -3167,8 +2927,7 @@ static void yy_syntax_error(
static void yy_accept(
yyParser *yypParser /* The parser */
){
- ParseARG_FETCH
- ParseCTX_FETCH
+ ParseARG_FETCH;
#ifndef NDEBUG
if( yyTraceFILE ){
fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
@@ -3183,8 +2942,7 @@ static void yy_accept(
/*********** Begin %parse_accept code *****************************************/
/*********** End %parse_accept code *******************************************/
- ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
- ParseCTX_STORE
+ ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
}
/* The main parser program.
@@ -3213,47 +2971,45 @@ void Parse(
ParseARG_PDECL /* Optional %extra_argument parameter */
){
YYMINORTYPE yyminorunion;
- YYACTIONTYPE yyact; /* The parser action. */
+ unsigned int yyact; /* The parser action. */
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
int yyendofinput; /* True if we are at the end of input */
#endif
#ifdef YYERRORSYMBOL
int yyerrorhit = 0; /* True if yymajor has invoked an error */
#endif
- yyParser *yypParser = (yyParser*)yyp; /* The parser */
- ParseCTX_FETCH
- ParseARG_STORE
+ yyParser *yypParser; /* The parser */
+ yypParser = (yyParser*)yyp;
assert( yypParser->yytos!=0 );
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
yyendofinput = (yymajor==0);
#endif
+ ParseARG_STORE;
- yyact = yypParser->yytos->stateno;
#ifndef NDEBUG
if( yyTraceFILE ){
- if( yyact < YY_MIN_REDUCE ){
+ int stateno = yypParser->yytos->stateno;
+ if( stateno < YY_MIN_REDUCE ){
fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
- yyTracePrompt,yyTokenName[yymajor],yyact);
+ yyTracePrompt,yyTokenName[yymajor],stateno);
}else{
fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
- yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
+ yyTracePrompt,yyTokenName[yymajor],stateno-YY_MIN_REDUCE);
}
}
#endif
do{
- assert( yyact==yypParser->yytos->stateno );
- yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
+ yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
if( yyact >= YY_MIN_REDUCE ){
- yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
- yyminor ParseCTX_PARAM);
+ yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,yyminor);
}else if( yyact <= YY_MAX_SHIFTREDUCE ){
- yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
+ yy_shift(yypParser,yyact,yymajor,yyminor);
#ifndef YYNOERRORRECOVERY
yypParser->yyerrcnt--;
#endif
- break;
+ yymajor = YYNOCODE;
}else if( yyact==YY_ACCEPT_ACTION ){
yypParser->yytos--;
yy_accept(yypParser);
@@ -3304,9 +3060,10 @@ void Parse(
yymajor = YYNOCODE;
}else{
while( yypParser->yytos >= yypParser->yystack
+ && yymx != YYERRORSYMBOL
&& (yyact = yy_find_reduce_action(
yypParser->yytos->stateno,
- YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
+ YYERRORSYMBOL)) >= YY_MIN_REDUCE
){
yy_pop_parser_stack(yypParser);
}
@@ -3323,8 +3080,6 @@ void Parse(
}
yypParser->yyerrcnt = 3;
yyerrorhit = 1;
- if( yymajor==YYNOCODE ) break;
- yyact = yypParser->yytos->stateno;
#elif defined(YYNOERRORRECOVERY)
/* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
** do any kind of error recovery. Instead, simply invoke the syntax
@@ -3335,7 +3090,8 @@ void Parse(
*/
yy_syntax_error(yypParser,yymajor, yyminor);
yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
- break;
+ yymajor = YYNOCODE;
+
#else /* YYERRORSYMBOL is not defined */
/* This is what we do if the grammar does not define ERROR:
**
@@ -3357,10 +3113,10 @@ void Parse(
yypParser->yyerrcnt = -1;
#endif
}
- break;
+ yymajor = YYNOCODE;
#endif
}
- }while( yypParser->yytos>yypParser->yystack );
+ }while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack );
#ifndef NDEBUG
if( yyTraceFILE ){
yyStackEntry *i;
@@ -3375,17 +3131,3 @@ void Parse(
#endif
return;
}
-
-/*
-** Return the fallback token corresponding to canonical token iToken, or
-** 0 if iToken has no fallback.
-*/
-int ParseFallback(int iToken){
-#ifdef YYFALLBACK
- assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
- return yyFallback[iToken];
-#else
- (void)iToken;
- return 0;
-#endif
-}
diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index f59bf62ec5..cb318d5c24 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -580,6 +580,8 @@ static SRpcConn *rpcOpenConn(SRpcInfo *pRpc, char *peerFqdn, uint16_t peerPort,
void *shandle = (connType & RPC_CONN_TCP)? pRpc->tcphandle:pRpc->udphandle;
pConn->chandle = (*taosOpenConn[connType])(shandle, pConn, pConn->peerIp, pConn->peerPort);
if (pConn->chandle == NULL) {
+ tError("failed to connect to:0x%x:%d", pConn->peerIp, pConn->peerPort);
+
terrno = TSDB_CODE_RPC_NETWORK_UNAVAIL;
rpcCloseConn(pConn);
pConn = NULL;
diff --git a/src/util/inc/tskiplist.h b/src/util/inc/tskiplist.h
index 4ba620dce0..a14a856561 100644
--- a/src/util/inc/tskiplist.h
+++ b/src/util/inc/tskiplist.h
@@ -136,6 +136,7 @@ typedef struct SSkipListIterator {
SSkipListNode *cur;
int32_t step; // the number of nodes that have been checked already
int32_t order; // order of the iterator
+ SSkipListNode *next; // next points to the true qualified node in skip list
} SSkipListIterator;
/**
diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index 4d737ebe66..2637699adb 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -97,7 +97,7 @@ static FORCE_INLINE void taosCacheReleaseNode(SCacheObj *pCacheObj, SCacheDataNo
int32_t size = (int32_t)taosHashGetSize(pCacheObj->pHashTable);
assert(size > 0);
- uDebug("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, num:%d size:%" PRId64 "bytes",
+ uDebug("cache:%s, key:%p, %p is destroyed from cache, size:%dbytes, totalNum:%d size:%" PRId64 "bytes",
pCacheObj->name, pNode->key, pNode->data, pNode->size, size - 1, pCacheObj->totalSize);
if (pCacheObj->freeFp) {
@@ -260,7 +260,12 @@ static void incRefFn(void* ptNode) {
}
void *taosCacheAcquireByKey(SCacheObj *pCacheObj, const void *key, size_t keyLen) {
- if (pCacheObj == NULL || taosHashGetSize(pCacheObj->pHashTable) == 0 || pCacheObj->deleting == 1) {
+ if (pCacheObj == NULL || pCacheObj->deleting == 1) {
+ return NULL;
+ }
+
+ if (taosHashGetSize(pCacheObj->pHashTable) == 0) {
+ atomic_add_fetch_32(&pCacheObj->statistics.missCount, 1);
return NULL;
}
diff --git a/src/util/src/tskiplist.c b/src/util/src/tskiplist.c
index 303c2440bf..bacdaef6c8 100644
--- a/src/util/src/tskiplist.c
+++ b/src/util/src/tskiplist.c
@@ -79,9 +79,12 @@ static SSkipListIterator* doCreateSkipListIterator(SSkipList *pSkipList, int32_t
// when order is TSDB_ORDER_ASC, return the last node with key less than val
// when order is TSDB_ORDER_DESC, return the first node with key large than val
-static SSkipListNode* getPriorNode(SSkipList* pSkipList, const char* val, int32_t order) {
+static SSkipListNode* getPriorNode(SSkipList* pSkipList, const char* val, int32_t order, SSkipListNode** pCur) {
__compar_fn_t comparFn = pSkipList->comparFn;
SSkipListNode *pNode = NULL;
+ if (pCur != NULL) {
+ *pCur = NULL;
+ }
if (order == TSDB_ORDER_ASC) {
pNode = pSkipList->pHead;
@@ -93,6 +96,9 @@ static SSkipListNode* getPriorNode(SSkipList* pSkipList, const char* val, int32_
pNode = p;
p = SL_GET_FORWARD_POINTER(p, i);
} else {
+ if (pCur != NULL) {
+ *pCur = p;
+ }
break;
}
}
@@ -107,6 +113,9 @@ static SSkipListNode* getPriorNode(SSkipList* pSkipList, const char* val, int32_
pNode = p;
p = SL_GET_BACKWARD_POINTER(p, i);
} else {
+ if (pCur != NULL) {
+ *pCur = p;
+ }
break;
}
}
@@ -295,7 +304,7 @@ SArray* tSkipListGet(SSkipList *pSkipList, SSkipListKey key) {
pthread_rwlock_wrlock(pSkipList->lock);
}
- SSkipListNode* pNode = getPriorNode(pSkipList, key, TSDB_ORDER_ASC);
+ SSkipListNode* pNode = getPriorNode(pSkipList, key, TSDB_ORDER_ASC, NULL);
while (1) {
SSkipListNode *p = SL_GET_FORWARD_POINTER(pNode, 0);
if (p == pSkipList->pTail) {
@@ -452,7 +461,7 @@ uint32_t tSkipListRemove(SSkipList *pSkipList, SSkipListKey key) {
pthread_rwlock_wrlock(pSkipList->lock);
}
- SSkipListNode* pNode = getPriorNode(pSkipList, key, TSDB_ORDER_ASC);
+ SSkipListNode* pNode = getPriorNode(pSkipList, key, TSDB_ORDER_ASC, NULL);
while (1) {
SSkipListNode *p = SL_GET_FORWARD_POINTER(pNode, 0);
if (p == pSkipList->pTail) {
@@ -545,7 +554,7 @@ SSkipListIterator *tSkipListCreateIterFromVal(SSkipList* pSkipList, const char*
pthread_rwlock_rdlock(pSkipList->lock);
}
- iter->cur = getPriorNode(pSkipList, val, order);
+ iter->cur = getPriorNode(pSkipList, val, order, &iter->next);
if (pSkipList->lock) {
pthread_rwlock_unlock(pSkipList->lock);
@@ -567,8 +576,22 @@ bool tSkipListIterNext(SSkipListIterator *iter) {
if (iter->order == TSDB_ORDER_ASC) { // ascending order iterate
iter->cur = SL_GET_FORWARD_POINTER(iter->cur, 0);
+
+ // a new node is inserted into between iter->cur and iter->next, ignore it
+ if (iter->cur != iter->next && (iter->next != NULL)) {
+ iter->cur = iter->next;
+ }
+
+ iter->next = SL_GET_FORWARD_POINTER(iter->cur, 0);
} else { // descending order iterate
iter->cur = SL_GET_BACKWARD_POINTER(iter->cur, 0);
+
+ // a new node is inserted into between iter->cur and iter->next, ignore it
+ if (iter->cur != iter->next && (iter->next != NULL)) {
+ iter->cur = iter->next;
+ }
+
+ iter->next = SL_GET_BACKWARD_POINTER(iter->cur, 0);
}
if (pSkipList->lock) {
@@ -715,9 +738,11 @@ SSkipListIterator* doCreateSkipListIterator(SSkipList *pSkipList, int32_t order)
iter->order = order;
if(order == TSDB_ORDER_ASC) {
iter->cur = pSkipList->pHead;
+ iter->next = SL_GET_FORWARD_POINTER(iter->cur, 0);
} else {
iter->cur = pSkipList->pTail;
+ iter->next = SL_GET_BACKWARD_POINTER(iter->cur, 0);
}
-
+
return iter;
}
\ No newline at end of file
diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index a4e88fb946..d89c383d6a 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -186,6 +186,12 @@ int32_t vnodeAlter(void *param, SMDCreateVnodeMsg *pVnodeCfg) {
return code;
}
+ code = walAlter(pVnode->wal, &pVnode->walCfg);
+ if (code != TSDB_CODE_SUCCESS) {
+ pVnode->status = TAOS_VN_STATUS_READY;
+ return code;
+ }
+
code = syncReconfig(pVnode->sync, &pVnode->syncCfg);
if (code != TSDB_CODE_SUCCESS) {
pVnode->status = TAOS_VN_STATUS_READY;
@@ -390,6 +396,7 @@ void vnodeRelease(void *pVnodeRaw) {
if (0 == tsEnableVnodeBak) {
vInfo("vgId:%d, vnode backup not enabled", pVnode->vgId);
} else {
+ taosRemoveDir(newDir);
taosRename(rootDir, newDir);
}
diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index 017eeaf426..58e97075ac 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
@@ -58,7 +58,8 @@ int32_t vnodeProcessRead(void *param, SReadMsg *pReadMsg) {
return TSDB_CODE_APP_NOT_READY;
// TODO: Later, let slave to support query
- if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER) {
+ // if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER) {
+ if (pVnode->role != TAOS_SYNC_ROLE_SLAVE && pVnode->role != TAOS_SYNC_ROLE_MASTER) {
vDebug("vgId:%d, msgType:%s not processed, replica:%d role:%d", pVnode->vgId, taosMsg[msgType], pVnode->syncCfg.replica, pVnode->role);
return TSDB_CODE_APP_NOT_READY;
}
diff --git a/src/wal/src/walMain.c b/src/wal/src/walMain.c
index bebad69f32..a90c1b171c 100644
--- a/src/wal/src/walMain.c
+++ b/src/wal/src/walMain.c
@@ -69,6 +69,13 @@ static void walModuleInitFunc() {
wDebug("WAL module is initialized");
}
+static inline bool walNeedFsyncTimer(SWal *pWal) {
+ if (pWal->fsyncPeriod > 0 && pWal->level == TAOS_WAL_FSYNC) {
+ return true;
+ }
+ return false;
+}
+
void *walOpen(const char *path, const SWalCfg *pCfg) {
SWal *pWal = calloc(sizeof(SWal), 1);
if (pWal == NULL) {
@@ -95,7 +102,7 @@ void *walOpen(const char *path, const SWalCfg *pCfg) {
tstrncpy(pWal->path, path, sizeof(pWal->path));
pthread_mutex_init(&pWal->mutex, NULL);
- if (pWal->fsyncPeriod > 0 && pWal->level == TAOS_WAL_FSYNC) {
+ if (walNeedFsyncTimer(pWal)) {
pWal->timer = taosTmrStart(walProcessFsyncTimer, pWal->fsyncPeriod, pWal, walTmrCtrl);
if (pWal->timer == NULL) {
terrno = TAOS_SYSTEM_ERROR(errno);
@@ -127,6 +134,37 @@ void *walOpen(const char *path, const SWalCfg *pCfg) {
return pWal;
}
+int walAlter(twalh wal, const SWalCfg *pCfg) {
+ SWal *pWal = wal;
+ if (pWal == NULL) {
+ return TSDB_CODE_WAL_APP_ERROR;
+ }
+
+ if (pWal->level == pCfg->walLevel && pWal->fsyncPeriod == pCfg->fsyncPeriod) {
+ wDebug("wal:%s, old walLevel:%d fsync:%d, new walLevel:%d fsync:%d not change", pWal->name, pWal->level,
+ pWal->fsyncPeriod, pCfg->walLevel, pCfg->fsyncPeriod);
+ return TSDB_CODE_SUCCESS;
+ }
+
+ wInfo("wal:%s, change old walLevel:%d fsync:%d, new walLevel:%d fsync:%d", pWal->name, pWal->level, pWal->fsyncPeriod,
+ pCfg->walLevel, pCfg->fsyncPeriod);
+
+ pthread_mutex_lock(&pWal->mutex);
+ pWal->level = pCfg->walLevel;
+ pWal->fsyncPeriod = pCfg->fsyncPeriod;
+ if (walNeedFsyncTimer(pWal)) {
+ wInfo("wal:%s, reset fsync timer, walLevel:%d fsyncPeriod:%d", pWal->name, pWal->level, pWal->fsyncPeriod);
+ taosTmrReset(walProcessFsyncTimer, pWal->fsyncPeriod, pWal, &pWal->timer,walTmrCtrl);
+ } else {
+ wInfo("wal:%s, stop fsync timer, walLevel:%d fsyncPeriod:%d", pWal->name, pWal->level, pWal->fsyncPeriod);
+ taosTmrStop(pWal->timer);
+ pWal->timer = NULL;
+ }
+ pthread_mutex_unlock(&pWal->mutex);
+
+ return TSDB_CODE_SUCCESS;
+}
+
void walClose(void *handle) {
if (handle == NULL) return;
@@ -484,6 +522,12 @@ static void walProcessFsyncTimer(void *param, void *tmrId) {
if (fsync(pWal->fd) < 0) {
wError("wal:%s, fsync failed(%s)", pWal->name, strerror(errno));
}
-
- pWal->timer = taosTmrStart(walProcessFsyncTimer, pWal->fsyncPeriod, pWal, walTmrCtrl);
+
+ if (walNeedFsyncTimer(pWal)) {
+ pWal->timer = taosTmrStart(walProcessFsyncTimer, pWal->fsyncPeriod, pWal, walTmrCtrl);
+ } else {
+ wInfo("wal:%s, stop fsync timer for walLevel:%d fsyncPeriod:%d", pWal->name, pWal->level, pWal->fsyncPeriod);
+ taosTmrStop(pWal->timer);
+ pWal->timer = NULL;
+ }
}
diff --git a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java
index 1e801bc658..74e586d7fd 100644
--- a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java
+++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java
@@ -11,7 +11,6 @@ public class JDBCConnectorChecker {
private static String tbName = "weather";
private Connection connection;
-
/**
* get connection
**/
@@ -170,5 +169,4 @@ public class JDBCConnectorChecker {
checker.close();
}
-
}
diff --git a/tests/gotest/batchtest.sh b/tests/gotest/batchtest.sh
new file mode 100644
index 0000000000..a027dd0d7c
--- /dev/null
+++ b/tests/gotest/batchtest.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+bash ./case001/case001.sh
+#bash ./case002/case002.sh
+#bash ./case003/case003.sh
diff --git a/tests/gotest/case001/case001.go b/tests/gotest/case001/case001.go
new file mode 100644
index 0000000000..1d5ede6d21
--- /dev/null
+++ b/tests/gotest/case001/case001.go
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc.
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see .
+ */
+package main
+
+import (
+ "database/sql"
+ "fmt"
+ _ "github.com/taosdata/driver-go/taosSql"
+ "log"
+ "time"
+)
+
+func main() {
+ taosDriverName := "taosSql"
+ demodb := "demodb"
+ demot := "demot"
+
+ fmt.Printf("\n======== start demo test ========\n")
+ // open connect to taos server
+ db, err := sql.Open(taosDriverName, "root:taosdata@/tcp(192.168.1.217:7100)/")
+ if err != nil {
+ log.Fatalf("Open database error: %s\n", err)
+ }
+ defer db.Close()
+
+ drop_database(db, demodb)
+ create_database(db, demodb)
+ use_database(db, demodb)
+ create_table(db, demot)
+ insert_data(db, demot)
+ select_data(db, demot)
+
+ fmt.Printf("\n======== start stmt mode test ========\n")
+
+ demodbStmt := "demodbStmt"
+ demotStmt := "demotStmt"
+ drop_database_stmt(db, demodbStmt)
+ create_database_stmt(db, demodbStmt)
+ use_database_stmt(db, demodbStmt)
+ create_table_stmt(db, demotStmt)
+ insert_data_stmt(db, demotStmt)
+ select_data_stmt(db, demotStmt)
+
+ fmt.Printf("\n======== end demo test ========\n")
+}
+
+func drop_database(db *sql.DB, demodb string) {
+ st := time.Now().Nanosecond()
+ res, err := db.Exec("drop database if exists " + demodb)
+ checkErr(err, "drop database if exists "+demodb)
+
+ affectd, err := res.RowsAffected()
+ checkErr(err, "drop db, res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+
+ fmt.Printf("drop database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+
+ //sleep 50毫秒
+ time.Sleep(time.Duration(50)* time.Millisecond)
+}
+
+func create_database(db *sql.DB, demodb string) {
+ st := time.Now().Nanosecond()
+ // create database
+ res, err := db.Exec("create database " + demodb)
+ checkErr(err, "create db, db.Exec")
+
+ affectd, err := res.RowsAffected()
+ checkErr(err, "create db, res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+
+ fmt.Printf("create database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+
+ return
+}
+
+func use_database(db *sql.DB, demodb string) {
+ st := time.Now().Nanosecond()
+ // use database
+ res, err := db.Exec("use " + demodb) // notes: must no quote to db name
+ checkErr(err, "use db db.Exec")
+
+ affectd, err := res.RowsAffected()
+ checkErr(err, "use db, res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+
+ fmt.Printf("use database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func create_table(db *sql.DB, demot string) {
+ st := time.Now().Nanosecond()
+ // create table
+ res, err := db.Exec("create table " + demot + " (ts timestamp, id int, name binary(8), len tinyint, flag bool, notes binary(8), fv float, dv double)")
+ checkErr(err, "create table db.Exec")
+
+ affectd, err := res.RowsAffected()
+ checkErr(err, "create table res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+ fmt.Printf("create table result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func insert_data(db *sql.DB, demot string) {
+ st := time.Now().Nanosecond()
+ // insert data
+ res, err := db.Exec("insert into " + demot +
+ " values (now, 100, 'beijing', 10, true, 'one', 123.456, 123.456)" +
+ " (now+1s, 101, 'shanghai', 11, true, 'two', 789.123, 789.123)" +
+ " (now+2s, 102, 'shenzhen', 12, false, 'three', 456.789, 456.789)")
+
+ checkErr(err, "insert data, db.Exec")
+
+ affectd, err := res.RowsAffected()
+ checkErr(err, "insert data res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+ fmt.Printf("insert data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func select_data(db *sql.DB, demot string) {
+ st := time.Now().Nanosecond()
+
+ rows, err := db.Query("select * from ? ", demot) // go text mode
+ checkErr(err, "select db.Query")
+
+ fmt.Printf("%10s%s%8s %5s %9s%s %s %8s%s %7s%s %8s%s %4s%s %5s%s\n", " ", "ts", " ", "id", " ", "name", " ", "len", " ", "flag", " ", "notes", " ", "fv", " ", " ", "dv")
+ var affectd int
+
+ //decoder := mahonia.NewDecoder("gbk") // 把原来ANSI格式的文本文件里的字符，用gbk进行解码。
+
+ for rows.Next() {
+ var ts string
+ var name string
+ var id int
+ var len int8
+ var flag bool
+ var notes string
+ var fv float32
+ var dv float64
+
+ err = rows.Scan(&ts, &id, &name, &len, &flag, ¬es, &fv, &dv)
+ checkErr(err, "select rows.Scan")
+
+ fmt.Printf("%s|\t", ts)
+ fmt.Printf("%d|\t", id)
+ fmt.Printf("%10s|\t", name)
+ fmt.Printf("%d|\t", len)
+ fmt.Printf("%t|\t", flag)
+ fmt.Printf("%s|\t", notes)
+ fmt.Printf("%06.3f|\t", fv)
+ fmt.Printf("%09.6f|\n\n", dv)
+
+ affectd++
+ }
+
+ et := time.Now().Nanosecond()
+ fmt.Printf("select data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+ //fmt.Printf("insert data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1E9)
+}
+
+func drop_database_stmt(db *sql.DB, demodb string) {
+ st := time.Now().Nanosecond()
+ // drop test db
+ res, err := db.Exec("drop database if exists " + demodb)
+ checkErr(err, "drop database "+demodb)
+
+ affectd, err := res.RowsAffected()
+ checkErr(err, "drop db, res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+ fmt.Printf("drop database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func create_database_stmt(db *sql.DB, demodb string) {
+ st := time.Now().Nanosecond()
+ // create database
+ //var stmt interface{}
+ stmt, err := db.Prepare("create database ?")
+ checkErr(err, "create db, db.Prepare")
+
+ //var res driver.Result
+ res, err := stmt.Exec(demodb)
+ checkErr(err, "create db, stmt.Exec")
+
+ //fmt.Printf("Query OK, %d row(s) affected()", res.RowsAffected())
+ affectd, err := res.RowsAffected()
+ checkErr(err, "create db, res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+ fmt.Printf("create database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func use_database_stmt(db *sql.DB, demodb string) {
+ st := time.Now().Nanosecond()
+ // create database
+ //var stmt interface{}
+ stmt, err := db.Prepare("use " + demodb)
+ checkErr(err, "use db, db.Prepare")
+
+ res, err := stmt.Exec()
+ checkErr(err, "use db, stmt.Exec")
+
+ affectd, err := res.RowsAffected()
+ checkErr(err, "use db, res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+ fmt.Printf("use database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func create_table_stmt(db *sql.DB, demot string) {
+ st := time.Now().Nanosecond()
+ // create table
+ // (ts timestamp, id int, name binary(8), len tinyint, flag bool, notes binary(8), fv float, dv double)
+ stmt, err := db.Prepare("create table ? (? timestamp, ? int, ? binary(10), ? tinyint, ? bool, ? binary(8), ? float, ? double)")
+ checkErr(err, "create table db.Prepare")
+
+ res, err := stmt.Exec(demot, "ts", "id", "name", "len", "flag", "notes", "fv", "dv")
+ checkErr(err, "create table stmt.Exec")
+
+ affectd, err := res.RowsAffected()
+ checkErr(err, "create table res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+ fmt.Printf("create table result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func insert_data_stmt(db *sql.DB, demot string) {
+ st := time.Now().Nanosecond()
+ // insert data into table
+ stmt, err := db.Prepare("insert into ? values(?, ?, ?, ?, ?, ?, ?, ?) (?, ?, ?, ?, ?, ?, ?, ?) (?, ?, ?, ?, ?, ?, ?, ?)")
+ checkErr(err, "insert db.Prepare")
+
+ res, err := stmt.Exec(demot, "now", 1000, "'haidian'", 6, true, "'AI world'", 6987.654, 321.987,
+ "now+1s", 1001, "'changyang'", 7, false, "'DeepMode'", 12356.456, 128634.456,
+ "now+2s", 1002, "'chuangping'", 8, true, "'database'", 3879.456, 65433478.456)
+ checkErr(err, "insert data, stmt.Exec")
+
+ affectd, err := res.RowsAffected()
+ checkErr(err, "res.RowsAffected")
+
+ et := time.Now().Nanosecond()
+ fmt.Printf("insert data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func select_data_stmt(db *sql.DB, demot string) {
+ st := time.Now().Nanosecond()
+
+ stmt, err := db.Prepare("select ?, ?, ?, ?, ?, ?, ?, ? from ?") // go binary mode
+ checkErr(err, "db.Prepare")
+
+ rows, err := stmt.Query("ts", "id", "name", "len", "flag", "notes", "fv", "dv", demot)
+ checkErr(err, "stmt.Query")
+
+ fmt.Printf("%10s%s%8s %5s %8s%s %s %10s%s %7s%s %8s%s %11s%s %14s%s\n", " ", "ts", " ", "id", " ", "name", " ", "len", " ", "flag", " ", "notes", " ", "fv", " ", " ", "dv")
+ var affectd int
+ for rows.Next() {
+ var ts string
+ var name string
+ var id int
+ var len int8
+ var flag bool
+ var notes string
+ var fv float32
+ var dv float64
+
+ err = rows.Scan(&ts, &id, &name, &len, &flag, ¬es, &fv, &dv)
+ //fmt.Println("start scan fields from row.rs, &fv:", &fv)
+ //err = rows.Scan(&fv)
+ checkErr(err, "rows.Scan")
+
+ fmt.Printf("%s|\t", ts)
+ fmt.Printf("%d|\t", id)
+ fmt.Printf("%10s|\t", name)
+ fmt.Printf("%d|\t", len)
+ fmt.Printf("%t|\t", flag)
+ fmt.Printf("%s|\t", notes)
+ fmt.Printf("%06.3f|\t", fv)
+ fmt.Printf("%09.6f|\n", dv)
+
+ affectd++
+
+ }
+
+ et := time.Now().Nanosecond()
+ fmt.Printf("select data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func checkErr(err error, prompt string) {
+ if err != nil {
+ fmt.Printf("%s\n", prompt)
+ panic(err)
+ }
+}
diff --git a/tests/gotest/case001/case001.sh b/tests/gotest/case001/case001.sh
new file mode 100644
index 0000000000..5a9034c4d1
--- /dev/null
+++ b/tests/gotest/case001/case001.sh
@@ -0,0 +1,70 @@
+#!/bin/bash
+
+##################################################
+#
+# Do go test
+#
+##################################################
+
+set +e
+#set -x
+
+script_dir="$(dirname $(readlink -f $0))"
+#echo "pwd: $script_dir, para0: $0"
+
+execName=$0
+execName=`echo ${execName##*/}`
+goName=`echo ${execName%.*}`
+
+###### step 1: start one taosd
+scriptDir=$script_dir/../../script/sh
+bash $scriptDir/stop_dnodes.sh
+bash $scriptDir/deploy.sh -n dnode1 -i 1
+bash $scriptDir/cfg.sh -n dnode1 -c walLevel -v 0
+bash $scriptDir/exec.sh -n dnode1 -s start
+
+###### step 2: set config item
+TAOS_CFG=/etc/taos/taos.cfg
+HOSTNAME=`hostname -f`
+
+if [ ! -f ${TAOS_CFG} ]; then
+ touch -f $TAOS_CFG
+fi
+
+echo " " > $TAOS_CFG
+echo "firstEp ${HOSTNAME}:7100" >> $TAOS_CFG
+echo "secondEp ${HOSTNAME}:7200" >> $TAOS_CFG
+echo "serverPort 7100" >> $TAOS_CFG
+#echo "dataDir $DATA_DIR" >> $TAOS_CFG
+#echo "logDir $LOG_DIR" >> $TAOS_CFG
+#echo "scriptDir ${CODE_DIR}/../script" >> $TAOS_CFG
+echo "numOfLogLines 100000000" >> $TAOS_CFG
+echo "dDebugFlag 135" >> $TAOS_CFG
+echo "mDebugFlag 135" >> $TAOS_CFG
+echo "sdbDebugFlag 135" >> $TAOS_CFG
+echo "rpcDebugFlag 135" >> $TAOS_CFG
+echo "tmrDebugFlag 131" >> $TAOS_CFG
+echo "cDebugFlag 135" >> $TAOS_CFG
+echo "httpDebugFlag 135" >> $TAOS_CFG
+echo "monitorDebugFlag 135" >> $TAOS_CFG
+echo "udebugFlag 135" >> $TAOS_CFG
+echo "tablemetakeeptimer 5" >> $TAOS_CFG
+echo "wal 0" >> $TAOS_CFG
+echo "asyncLog 0" >> $TAOS_CFG
+echo "locale en_US.UTF-8" >> $TAOS_CFG
+echo "enableCoreFile 1" >> $TAOS_CFG
+echo " " >> $TAOS_CFG
+
+ulimit -n 600000
+ulimit -c unlimited
+#
+##sudo sysctl -w kernel.core_pattern=$TOP_DIR/core.%p.%e
+#
+
+###### step 3: start build
+cd $script_dir
+rm -f go.*
+go mod init $goName
+go build
+sleep 1s
+sudo ./$goName
diff --git a/tests/gotest/test.sh b/tests/gotest/test.sh
new file mode 100644
index 0000000000..fe80d44295
--- /dev/null
+++ b/tests/gotest/test.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+
+##################################################
+#
+# Do go test
+#
+##################################################
+
+set +e
+#set -x
+
+FILE_NAME=
+RELEASE=0
+while getopts "f:" arg
+do
+ case $arg in
+ f)
+ FILE_NAME=$OPTARG
+ echo "input file: $FILE_NAME"
+ ;;
+ ?)
+ echo "unknow argument"
+ ;;
+ esac
+done
+
+# start one taosd
+bash ../script/sh/stop_dnodes.sh
+bash ../script/sh/deploy.sh -n dnode1 -i 1
+bash ../script/sh/cfg.sh -n dnode1 -c walLevel -v 0
+bash ../script/sh/exec.sh -n dnode1 -s start
+
+# start build test go file
+caseDir=`echo ${FILE_NAME%/*}`
+echo "caseDir: $caseDir"
+cd $caseDir
+rm go.*
+go mod init $caseDir
+go build
+sleep 1s
+./$caseDir
+
diff --git a/tests/perftest-scripts/coverage_test.sh b/tests/perftest-scripts/coverage_test.sh
index a0c8fe4b3f..5085ec89d0 100755
--- a/tests/perftest-scripts/coverage_test.sh
+++ b/tests/perftest-scripts/coverage_test.sh
@@ -53,7 +53,7 @@ function buildTDengine {
function runGeneralCaseOneByOne {
while read -r line; do
if [[ $line =~ ^./test.sh* ]]; then
- case=`echo $line | grep -w "general\|unique\/mnode\/mgmt33.sim\|unique\/stable\/dnode3.sim\|unique\/cluster\/balance3.sim\|unique\/arbitrator\/offline_replica2_alterTable_online.sim"|awk '{print $NF}'`
+ case=`echo $line | grep sim$ |awk '{print $NF}'`
if [ -n "$case" ]; then
./test.sh -f $case > /dev/null 2>&1 && \
diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index 9ebf1584e2..597102a0f0 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -16,6 +16,7 @@ python3 ./test.py -f insert/nchar.py
python3 ./test.py -f insert/nchar-unicode.py
python3 ./test.py -f insert/multi.py
python3 ./test.py -f insert/randomNullCommit.py
+python3 insert/retentionpolicy.py
python3 ./test.py -f table/column_name.py
python3 ./test.py -f table/column_num.py
@@ -154,6 +155,7 @@ python3 ./test.py -f stream/new.py
python3 ./test.py -f stream/stream1.py
python3 ./test.py -f stream/stream2.py
python3 ./test.py -f stream/parser.py
+python3 ./test.py -f stream/history.py
#alter table
python3 ./test.py -f alter/alter_table_crash.py
@@ -192,3 +194,8 @@ python3 test.py -f query/queryInterval.py
# tools
python3 test.py -f tools/taosdemo.py
+
+# subscribe
+python3 test.py -f subscribe/singlemeter.py
+#python3 test.py -f subscribe/stability.py
+python3 test.py -f subscribe/supertable.py
\ No newline at end of file
diff --git a/tests/pytest/insert/retentionpolicy.py b/tests/pytest/insert/retentionpolicy.py
new file mode 100644
index 0000000000..c50de31cc4
--- /dev/null
+++ b/tests/pytest/insert/retentionpolicy.py
@@ -0,0 +1,112 @@
+###################################################################
+# 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
+import datetime
+sys.path.insert(0, os.getcwd())
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestRetetion:
+ def init(self):
+ self.queryRows=0
+ tdLog.debug("start to execute %s" % __file__)
+ tdLog.info("prepare cluster")
+ tdDnodes.init("")
+ tdDnodes.setTestCluster(False)
+ tdDnodes.setValgrind(False)
+ tdDnodes.stopAll()
+ tdDnodes.deploy(1)
+ tdDnodes.start(1)
+ print(tdDnodes.getDnodesRootDir())
+ self.conn = taos.connect(config=tdDnodes.getSimCfgPath())
+ tdSql.init(self.conn.cursor())
+ tdSql.execute('reset query cache')
+ def checkRows(self, expectRows,sql):
+ if self.queryRows == expectRows:
+ tdLog.info("sql:%s, queryRows:%d == expect:%d" % (sql, self.queryRows, expectRows))
+ else:
+ caller = inspect.getframeinfo(inspect.stack()[1][0])
+ args = (caller.filename, caller.lineno, sql, self.queryRows, expectRows)
+ os.system("timedatectl set-ntp true")
+ tdLog.exit("%s(%d) failed: sql:%s, queryRows:%d != expect:%d" % args)
+
+ def run(self):
+
+ tdLog.info("=============== step1")
+ tdSql.execute('create database test keep 3 days 1;')
+ tdSql.execute('use test;')
+ tdSql.execute('create table test(ts timestamp,i int);')
+
+ cmd = 'insert into test values(now-2d,11)(now-1d,11)(now,11)(now+1d,11);'
+ tdLog.info(cmd)
+ tdSql.execute(cmd)
+ tdSql.query('select * from test')
+ tdSql.checkRows(4)
+
+ tdLog.info("=============== step2")
+ tdDnodes.stop(1)
+ os.system("timedatectl set-ntp false")
+ os.system("date -s $(date -d \"${DATE} 2 days\" \"+%Y%m%d\")")
+ tdDnodes.start(1)
+ cmd = 'insert into test values(now,11);'
+ tdLog.info(cmd)
+ tdSql.execute(cmd)
+ queryRows=tdSql.query('select * from test')
+ if queryRows==4:
+ tdSql.checkRows(4)
+ return 0
+ else:
+ tdSql.checkRows(5)
+
+ tdLog.info("=============== step3")
+ tdDnodes.stop(1)
+ os.system("date -s $(date -d \"${DATE} 2 days\" \"+%Y%m%d\")")
+ tdDnodes.start(1)
+ cmd = 'insert into test values(now-1d,11);'
+ tdLog.info(cmd)
+ tdSql.execute(cmd)
+ queryRows=tdSql.query('select * from test')
+ tdSql.checkRows(6)
+ tdLog.info("=============== step4")
+ tdDnodes.stop(1)
+ tdDnodes.start(1)
+ cmd = 'insert into test values(now,11);'
+ tdLog.info(cmd)
+ tdSql.execute(cmd)
+ tdSql.query('select * from test')
+ tdSql.checkRows(7)
+
+ tdLog.info("=============== step5")
+ tdDnodes.stop(1)
+ tdDnodes.start(1)
+ cmd='select * from test where ts > now-1d'
+ queryRows=tdSql.query('select * from test where ts > now-1d')
+ self.checkRows(1,cmd)
+
+ def stop(self):
+ os.system("timedatectl set-ntp true")
+ tdSql.close()
+ tdLog.success("%s successfully executed" % __file__)
+
+
+clients = TDTestRetetion()
+clients.init()
+clients.run()
+clients.stop()
+
diff --git a/tests/pytest/stream/history.py b/tests/pytest/stream/history.py
new file mode 100644
index 0000000000..890580001c
--- /dev/null
+++ b/tests/pytest/stream/history.py
@@ -0,0 +1,63 @@
+###################################################################
+# 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 time
+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()
+
+ tdSql.execute("create table cars(ts timestamp, s int) tags(id int)")
+ tdSql.execute("create table car0 using cars tags(0)")
+ tdSql.execute("create table car1 using cars tags(1)")
+ tdSql.execute("create table car2 using cars tags(2)")
+ tdSql.execute("create table car3 using cars tags(3)")
+ tdSql.execute("create table car4 using cars tags(4)")
+
+ tdSql.execute("insert into car0 values('2019-01-01 00:00:00.103', 1)")
+ tdSql.execute("insert into car1 values('2019-01-01 00:00:00.234', 1)")
+ tdSql.execute("insert into car0 values('2019-01-01 00:00:01.012', 1)")
+ tdSql.execute("insert into car0 values('2019-01-01 00:00:02.003', 1)")
+ tdSql.execute("insert into car2 values('2019-01-01 00:00:02.328', 1)")
+ tdSql.execute("insert into car0 values('2019-01-01 00:00:03.139', 1)")
+ tdSql.execute("insert into car0 values('2019-01-01 00:00:04.348', 1)")
+ tdSql.execute("insert into car0 values('2019-01-01 00:00:05.783', 1)")
+ tdSql.execute("insert into car1 values('2019-01-01 00:00:01.893', 1)")
+ tdSql.execute("insert into car1 values('2019-01-01 00:00:02.712', 1)")
+ tdSql.execute("insert into car1 values('2019-01-01 00:00:03.982', 1)")
+ tdSql.execute("insert into car3 values('2019-01-01 00:00:01.389', 1)")
+ tdSql.execute("insert into car4 values('2019-01-01 00:00:01.829', 1)")
+
+ tdSql.execute("create table strm as select count(*) from cars interval(4s)")
+ tdSql.waitedQuery("select * from strm", 2, 100)
+ tdSql.checkData(0, 1, 11)
+ tdSql.checkData(1, 1, 2)
+
+
+ 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/taosdemo.py b/tests/pytest/tools/taosdemo.py
index 54d33c90f3..5bf8ebaf03 100644
--- a/tests/pytest/tools/taosdemo.py
+++ b/tests/pytest/tools/taosdemo.py
@@ -16,6 +16,7 @@ import os
from util.log import *
from util.cases import *
from util.sql import *
+from util.dnodes import *
class TDTestCase:
@@ -25,11 +26,30 @@ class TDTestCase:
self.numberOfTables = 10000
self.numberOfRecords = 100
+ 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 ("taosd" 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):
tdSql.prepare()
-
- os.system("yes | taosdemo -t %d -n %d" % (self.numberOfTables, self.numberOfRecords))
+ buildPath = self.getBuildPath()
+ if (buildPath == ""):
+ tdLog.exit("taosd not found!")
+ else:
+ tdLog.info("taosd found in %s" % buildPath)
+ binPath = buildPath+ "/build/bin/"
+ os.system("yes | %staosdemo -t %d -n %d" % (binPath,self.numberOfTables, self.numberOfRecords))
tdSql.execute("use test")
tdSql.query("select count(*) from meters")
diff --git a/tests/script/fullGeneralSuite.sim b/tests/script/fullGeneralSuite.sim
index 4df7900265..4dd3957f39 100644
--- a/tests/script/fullGeneralSuite.sim
+++ b/tests/script/fullGeneralSuite.sim
@@ -220,3 +220,5 @@ run general/stream/table_del.sim
run general/stream/metrics_del.sim
run general/stream/table_replica1_vnoden.sim
run general/stream/metrics_replica1_vnoden.sim
+run general/db/show_create_db.sim
+run general/db/show_create_table.sim
diff --git a/tests/script/general/db/alter_option.sim b/tests/script/general/db/alter_option.sim
index 49c75966ca..c8aa2480c5 100644
--- a/tests/script/general/db/alter_option.sim
+++ b/tests/script/general/db/alter_option.sim
@@ -218,7 +218,10 @@ if $data12_db != 1 then
return -1
endi
-sql_error alter database db wal 2
+sql alter database db wal 1
+sql alter database db wal 2
+sql alter database db wal 1
+sql alter database db wal 2
sql_error alter database db wal 0
sql_error alter database db wal 3
sql_error alter database db wal 4
@@ -226,11 +229,13 @@ sql_error alter database db wal -1
sql_error alter database db wal 1000
print ============== step fsync
-sql_error alter database db fsync 2
-sql_error alter database db fsync 3
-sql_error alter database db fsync 4
+sql alter database db fsync 0
+sql alter database db fsync 1
+sql alter database db fsync 3600
+sql alter database db fsync 18000
+sql alter database db fsync 180000
+sql_error alter database db fsync 180001
sql_error alter database db fsync -1
-sql_error alter database db fsync 1000
print ============== step comp
sql show databases
diff --git a/tests/script/general/db/show_create_db.sim b/tests/script/general/db/show_create_db.sim
new file mode 100644
index 0000000000..baa7b253e1
--- /dev/null
+++ b/tests/script/general/db/show_create_db.sim
@@ -0,0 +1,32 @@
+system sh/stop_dnodes.sh
+
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+
+system sh/exec.sh -n dnode1 -s start
+sleep 3000
+sql connect
+
+print =============== step2
+sql create database db
+sql show create database db
+
+if $rows != 1 then
+ return -1
+endi
+
+print =============== step3
+sql use db
+sql show create database db
+
+if $rows != 1 then
+ return -1
+endi
+
+if $data00 != db then
+ return -1
+endi
+
+sql drop database db
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/script/general/db/show_create_table.sim b/tests/script/general/db/show_create_table.sim
new file mode 100644
index 0000000000..8338638709
--- /dev/null
+++ b/tests/script/general/db/show_create_table.sim
@@ -0,0 +1,87 @@
+system sh/stop_dnodes.sh
+
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+
+system sh/exec.sh -n dnode1 -s start
+sleep 3000
+sql connect
+
+print ===============create three type table
+sql create database db
+sql use db
+sql create table meters(ts timestamp, f binary(8)) tags(loc int, zone binary(8))
+sql create table t0 using meters tags(1,'ch')
+sql create table normalTbl(ts timestamp, zone binary(8))
+
+sql use db
+sql show create table meters
+if $rows != 1 then
+ return -1
+endi
+
+print ===============check sub table
+sql show create table t0
+if $rows != 1 then
+ return -1
+endi
+if $data00 == 't0' then
+ return -1
+endi
+
+print ===============check normal table
+
+sql show create table normalTbl
+if $rows != 1 then
+ return -1
+endi
+
+if $data00 == 'normalTbl' then
+ return -1
+endi
+
+print ===============check super table
+sql show create table meters
+if $rows != 1 then
+ return -1
+endi
+
+if $data00 == 'meters' then
+ return -1
+endi
+
+print ===============check sub table with prefix
+
+sql show create table db.t0
+if $rows != 1 then
+ return -1
+endi
+
+if $data00 == 't0' then
+ return -1
+endi
+
+print ===============check normal table with prefix
+sql show create table db.normalTbl
+if $rows != 1 then
+ return -1
+endi
+
+if $data00 == 'normalTbl' then
+ return -1
+endi
+
+
+print ===============check super table with prefix
+sql show create table db.meters
+if $rows != 1 then
+ return -1
+endi
+
+if $data00 == 'meters' then
+ return -1
+endi
+
+sql drop database db
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/script/general/http/gzip.sim b/tests/script/general/http/gzip.sim
index 0289e337a6..9c77567abb 100644
--- a/tests/script/general/http/gzip.sim
+++ b/tests/script/general/http/gzip.sim
@@ -3,7 +3,7 @@ sleep 3000
system sh/deploy.sh -n dnode1 -i 1
system sh/cfg.sh -n dnode1 -c wallevel -v 0
system sh/cfg.sh -n dnode1 -c http -v 1
-system sh/cfg.sh -n dnode1 -c maxSQLLength -v 7340032
+system sh/cfg.sh -n dnode1 -c maxSQLLength -v 340032
system sh/exec.sh -n dnode1 -s start
sleep 3000
@@ -18,10 +18,22 @@ sql use d1
sql create table table_rest (ts timestamp, i int)
print sql length is 270KB
restful d1 table_rest 1591072800 10000 gzip
+restful d1 table_rest 1591172800 10000 gzip
+restful d1 table_rest 1591272800 10000 gzip
+restful d1 table_rest 1591372800 10000 gzip
+restful d1 table_rest 1591472800 10000 gzip
+restful d1 table_rest 1591572800 10000 gzip
+restful d1 table_rest 1591672800 10000 gzip
+restful d1 table_rest 1591772800 10000 gzip
+restful d1 table_rest 1591872800 10000 gzip
+restful d1 table_rest 1591972800 10000 gzip
+
sql select * from table_rest;
print rows: $rows
-if $rows != 10000 then
+if $rows != 100000 then
return -1
endi
+system curl -H 'Authorization: Taosd /KfeAzX/f9na8qdtNZmtONryp201ma04bEl8LcvLUd7a8qdtNZmtONryp201ma04' -d 'select * from d1.table_rest' 127.0.0.1:7111/rest/sql --compressed
+
system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file
diff --git a/tests/script/general/parser/where.sim b/tests/script/general/parser/where.sim
index fb15fb6dbe..f9fd919bd6 100644
--- a/tests/script/general/parser/where.sim
+++ b/tests/script/general/parser/where.sim
@@ -308,13 +308,25 @@ sleep 2000
system sh/exec.sh -n dnode1 -s start
-sql select * from wh_mt0 where c3 = 'abc' and tbname in ('test_null_filter');
+sql_error select * from wh_mt0 where c3 = 'abc' and tbname in ('test_null_filter');
+
+sql select * from wh_mt0 where c3 = '1' and tbname in ('test_null_filter');
if $row != 0 then
return -1
endi
-sql select * from wh_mt0 where c3 = 'abc' and tbname in ('test_null_filter');
-if $row != 0 then
+sql select * from wh_mt0 where c3 = '1';
+if $row == 0 then
+ return -1
+endi
+
+sql select * from wh_mt0 where c3 is null and tbname in ('test_null_filter');
+if $rows != 10000 then
+ return -1
+endi
+
+sql select * from wh_mt0 where c3 is not null and tbname in ('test_null_filter');
+if $rows != 0 then
return -1
endi
diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index adb22aa265..9e42adfea9 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -79,6 +79,7 @@ cd ../../../debug; make
./test.sh -f general/http/autocreate.sim
./test.sh -f general/http/chunked.sim
+./test.sh -f general/http/gzip.sim
./test.sh -f general/http/restful.sim
./test.sh -f general/http/restful_insert.sim
./test.sh -f general/http/restful_limit.sim
diff --git a/tests/script/sh/deploy.sh b/tests/script/sh/deploy.sh
index 0d444a5a6e..8fccb1442f 100755
--- a/tests/script/sh/deploy.sh
+++ b/tests/script/sh/deploy.sh
@@ -128,6 +128,7 @@ echo "tmrDebugFlag 131" >> $TAOS_CFG
echo "udebugFlag 135" >> $TAOS_CFG
echo "sdebugFlag 135" >> $TAOS_CFG
echo "wdebugFlag 135" >> $TAOS_CFG
+echo "cqdebugFlag 135" >> $TAOS_CFG
echo "monitor 0" >> $TAOS_CFG
echo "monitorInterval 1" >> $TAOS_CFG
echo "http 0" >> $TAOS_CFG
diff --git a/tests/script/tmp/prepare.sim b/tests/script/tmp/prepare.sim
index 8b8f206233..343c422e9f 100644
--- a/tests/script/tmp/prepare.sim
+++ b/tests/script/tmp/prepare.sim
@@ -34,11 +34,11 @@ system sh/cfg.sh -n dnode4 -c http -v 1
return
# for crash_gen
-system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 10
system sh/cfg.sh -n dnode1 -c rpcMaxTime -v 101
system sh/cfg.sh -n dnode1 -c cache -v 2
system sh/cfg.sh -n dnode1 -c keep -v 36500
-system sh/cfg.sh -n dnode1 -c walLevel -v 2
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
# for windows
diff --git a/tests/script/unique/cluster/vgroup100.sim b/tests/script/unique/cluster/vgroup100.sim
index cddb38cefd..bde6dd2462 100644
--- a/tests/script/unique/cluster/vgroup100.sim
+++ b/tests/script/unique/cluster/vgroup100.sim
@@ -42,9 +42,11 @@ $count = 2
while $count < 102
$db = d . $count
$tb = $db . .t
+ $tb2 = $db . .t2
sql create database $db replica 3 cache 1 blocks 3
sql create table $tb (ts timestamp, i int)
sql insert into $tb values(now, 1)
+ sql create table $tb2 as select count(*) from $tb interval(10s)
$count = $count + 1
print insert into $tb values(now, 1) ==> finished
endw
@@ -74,7 +76,7 @@ print ============================== step6
system sh/exec.sh -n dnode1 -s start
system sh/exec.sh -n dnode2 -s start
system sh/exec.sh -n dnode3 -s start
-sleep 3000
+sleep 10000
print ============================== step7
diff --git a/tests/test-all.sh b/tests/test-all.sh
index 275c6b1677..84b663809d 100755
--- a/tests/test-all.sh
+++ b/tests/test-all.sh
@@ -9,8 +9,9 @@ NC='\033[0m'
function runSimCaseOneByOne {
while read -r line; do
- if [[ $line =~ ^run.* ]]; then
- case=`echo $line | awk '{print $NF}'`
+ if [[ $line =~ ^./test.sh* ]]; then
+ case=`echo $line | grep sim$ |awk '{print $NF}'`
+
start_time=`date +%s`
./test.sh -f $case > /dev/null 2>&1 && \
echo -e "${GREEN}$case success${NC}" | tee -a out.log || \
@@ -54,7 +55,7 @@ if [ "$2" != "python" ]; then
runSimCaseOneByOne regressionSuite.sim
elif [ "$1" == "full" ]; then
echo "### run TSIM full test ###"
- runSimCaseOneByOne fullGeneralSuite.sim
+ runSimCaseOneByOne jenkins/basic.txt
elif [ "$1" == "smoke" ] || [ -z "$1" ]; then
echo "### run TSIM smoke test ###"
runSimCaseOneByOne basicSuite.sim