diff --git a/.clang-format b/.clang-format index 3ddd8b43f6238f30000b96d8e676892ab2dcec68..f60fd3cb2629f933b6e25452c65716799e416c9e 100644 --- a/.clang-format +++ b/.clang-format @@ -86,5 +86,6 @@ SpacesInSquareBrackets: false Standard: Auto TabWidth: 8 UseTab: Never +AlignConsecutiveDeclarations: true ... diff --git a/contrib/test/craft/clear.sh b/contrib/test/craft/clear.sh index 6412656d7744b5b5ae8a57b42e34d79849d508f9..398b3088f20ae8cce179ff909f206fc162918876 100644 --- a/contrib/test/craft/clear.sh +++ b/contrib/test/craft/clear.sh @@ -1,3 +1,4 @@ #!/bin/bash rm -rf 127.0.0.1* +rm -rf ./data diff --git a/contrib/test/craft/common.h b/contrib/test/craft/common.h new file mode 100644 index 0000000000000000000000000000000000000000..1e94ee8bcae2b990d2fb7ace3d7c0f245bd4069c --- /dev/null +++ b/contrib/test/craft/common.h @@ -0,0 +1,34 @@ +#ifndef TDENGINE_COMMON_H +#define TDENGINE_COMMON_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#define MAX_PEERS 10 +#define COMMAND_LEN 512 +#define TOKEN_LEN 128 +#define DIR_LEN 256 +#define HOST_LEN 64 +#define ADDRESS_LEN (HOST_LEN + 16) + +typedef struct { + char host[HOST_LEN]; + uint32_t port; +} Addr; + +typedef struct { + Addr me; + Addr peers[MAX_PEERS]; + int peersCount; + char dir[DIR_LEN]; + char dataDir[DIR_LEN + HOST_LEN * 2]; +} SRaftServerConfig; + +#ifdef __cplusplus +} +#endif + +#endif // TDENGINE_COMMON_H diff --git a/contrib/test/craft/raftMain.c b/contrib/test/craft/raftMain.c new file mode 100644 index 0000000000000000000000000000000000000000..52e0b694dc325681c7c428e53e9db75b0a1bc3f3 --- /dev/null +++ b/contrib/test/craft/raftMain.c @@ -0,0 +1,367 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "raftServer.h" +#include "common.h" + +const char *exe_name; + +void parseAddr(const char *addr, char *host, int len, uint32_t *port) { + char* tmp = (char*)malloc(strlen(addr) + 1); + strcpy(tmp, addr); + + char* context; + char* separator = ":"; + char* token = strtok_r(tmp, separator, &context); + if (token) { + snprintf(host, len, "%s", token); + } + + token = strtok_r(NULL, separator, &context); + if (token) { + sscanf(token, "%u", port); + } + + free(tmp); +} + +// only parse 3 tokens +int parseCommand(const char* str, char* token1, char* token2, char* token3, int len) +{ + char* tmp = (char*)malloc(strlen(str) + 1); + strcpy(tmp, str); + + char* context; + char* separator = " "; + int n = 0; + + char* token = strtok_r(tmp, separator, &context); + if (!token) { + goto ret; + } + if (strcmp(token, "") != 0) { + strncpy(token1, token, len); + n++; + } + + token = strtok_r(NULL, separator, &context); + if (!token) { + goto ret; + } + if (strcmp(token, "") != 0) { + strncpy(token2, token, len); + n++; + } + + token = strtok_r(NULL, separator, &context); + if (!token) { + goto ret; + } + if (strcmp(token, "") != 0) { + strncpy(token3, token, len); + n++; + } + +ret: + return n; + free(tmp); +} + +void *startServerFunc(void *param) { + SRaftServer *pServer = (SRaftServer*)param; + int32_t r = raftServerStart(pServer); + assert(r == 0); + + return NULL; +} + +// Console --------------------------------- +const char* state2String(unsigned short state) { + if (state == RAFT_UNAVAILABLE) { + return "RAFT_UNAVAILABLE"; + + } else if (state == RAFT_FOLLOWER) { + return "RAFT_FOLLOWER"; + + } else if (state == RAFT_CANDIDATE) { + return "RAFT_CANDIDATE"; + + } else if (state == RAFT_LEADER) { + return "RAFT_LEADER"; + + } + return "UNKNOWN_RAFT_STATE"; +} + +void printRaftConfiguration(struct raft_configuration *c) { + printf("configuration: \n"); + for (int i = 0; i < c->n; ++i) { + printf("%llu -- %d -- %s\n", c->servers->id, c->servers->role, c->servers->address); + } +} + +void printRaftState(struct raft *r) { + printf("----Raft State: -----------\n"); + printf("my_id: %llu \n", r->id); + printf("address: %s \n", r->address); + printf("current_term: %llu \n", r->current_term); + printf("voted_for: %llu \n", r->voted_for); + printf("role: %s \n", state2String(r->state)); + printf("commit_index: %llu \n", r->commit_index); + printf("last_applied: %llu \n", r->last_applied); + printf("last_stored: %llu \n", r->last_stored); + + /* + printf("configuration_index: %llu \n", r->configuration_index); + printf("configuration_uncommitted_index: %llu \n", r->configuration_uncommitted_index); + printRaftConfiguration(&r->configuration); + */ + + printf("----------------------------\n"); +} + +void putValueCb(struct raft_apply *req, int status, void *result) { + raft_free(req); + struct raft *r = req->data; + if (status != 0) { + printf("putValueCb: %s \n", raft_errmsg(r)); + } else { + printf("putValueCb: %s \n", "ok"); + } +} + +void putValue(struct raft *r, const char *value) { + struct raft_buffer buf; + + buf.len = TOKEN_LEN;; + buf.base = raft_malloc(buf.len); + snprintf(buf.base, buf.len, "%s", value); + + struct raft_apply *req = raft_malloc(sizeof(struct raft_apply)); + req->data = r; + int ret = raft_apply(r, req, &buf, 1, putValueCb); + if (ret == 0) { + printf("put %s \n", (char*)buf.base); + } else { + printf("put error: %s \n", raft_errmsg(r)); + } +} + +void getValue(const char *key) { + char *ptr = getKV(key); + if (ptr) { + printf("get value: [%s] \n", ptr); + } else { + printf("value not found for key: [%s] \n", key); + } +} + +void console(SRaftServer *pRaftServer) { + while (1) { + char cmd_buf[COMMAND_LEN]; + memset(cmd_buf, 0, sizeof(cmd_buf)); + char *ret = fgets(cmd_buf, COMMAND_LEN, stdin); + if (!ret) { + exit(-1); + } + + int pos = strlen(cmd_buf); + if(cmd_buf[pos - 1] == '\n') { + cmd_buf[pos - 1] = '\0'; + } + + if (strncmp(cmd_buf, "", COMMAND_LEN) == 0) { + continue; + } + + char cmd[TOKEN_LEN]; + memset(cmd, 0, sizeof(cmd)); + + char param1[TOKEN_LEN]; + memset(param1, 0, sizeof(param1)); + + char param2[TOKEN_LEN]; + memset(param2, 0, sizeof(param2)); + + parseCommand(cmd_buf, cmd, param1, param2, TOKEN_LEN); + if (strcmp(cmd, "addnode") == 0) { + printf("not support \n"); + + /* + char host[HOST_LEN]; + uint32_t port; + parseAddr(param1, host, HOST_LEN, &port); + uint64_t rid = raftId(host, port); + + struct raft_change *req = raft_malloc(sizeof(*req)); + int r = raft_add(&pRaftServer->raft, req, rid, param1, NULL); + if (r != 0) { + printf("raft_add: %s \n", raft_errmsg(&pRaftServer->raft)); + } + printf("add node: %lu %s \n", rid, param1); + + struct raft_change *req2 = raft_malloc(sizeof(*req2)); + r = raft_assign(&pRaftServer->raft, req2, rid, RAFT_VOTER, NULL); + if (r != 0) { + printf("raft_assign: %s \n", raft_errmsg(&pRaftServer->raft)); + } + */ + + } else if (strcmp(cmd, "dropnode") == 0) { + printf("not support \n"); + + } else if (strcmp(cmd, "put") == 0) { + char buf[256]; + snprintf(buf, sizeof(buf), "%s--%s", param1, param2); + putValue(&pRaftServer->raft, buf); + + } else if (strcmp(cmd, "get") == 0) { + getValue(param1); + + } else if (strcmp(cmd, "state") == 0) { + printRaftState(&pRaftServer->raft); + + } else if (strcmp(cmd, "snapshot") == 0) { + printf("not support \n"); + + } else if (strcmp(cmd, "help") == 0) { + printf("addnode \"127.0.0.1:8888\" \n"); + printf("dropnode \"127.0.0.1:8888\" \n"); + printf("put key value \n"); + printf("get key \n"); + printf("state \n"); + + } else { + printf("unknown command: [%s], type \"help\" to see help \n", cmd); + } + + //printf("cmd_buf: [%s] \n", cmd_buf); + } +} + +void *startConsoleFunc(void *param) { + SRaftServer *pServer = (SRaftServer*)param; + console(pServer); + return NULL; +} + +// Config --------------------------------- +void usage() { + printf("\nusage: \n"); + printf("%s --me=127.0.0.1:10000 --dir=./data \n", exe_name); + printf("\n"); + printf("%s --me=127.0.0.1:10000 --peers=127.0.0.1:10001,127.0.0.1:10002 --dir=./data \n", exe_name); + printf("%s --me=127.0.0.1:10001 --peers=127.0.0.1:10000,127.0.0.1:10002 --dir=./data \n", exe_name); + printf("%s --me=127.0.0.1:10002 --peers=127.0.0.1:10000,127.0.0.1:10001 --dir=./data \n", exe_name); + printf("\n"); +} + +void parseConf(int argc, char **argv, SRaftServerConfig *pConf) { + memset(pConf, 0, sizeof(*pConf)); + + int option_index, option_value; + option_index = 0; + static struct option long_options[] = { + {"help", no_argument, NULL, 'h'}, + {"peers", required_argument, NULL, 'p'}, + {"me", required_argument, NULL, 'm'}, + {"dir", required_argument, NULL, 'd'}, + {NULL, 0, NULL, 0} + }; + + while ((option_value = getopt_long(argc, argv, "hp:m:d:", long_options, &option_index)) != -1) { + switch (option_value) { + case 'm': { + parseAddr(optarg, pConf->me.host, sizeof(pConf->me.host), &pConf->me.port); + break; + } + + case 'p': { + char tokens[MAX_PEERS][MAX_TOKEN_LEN]; + int peerCount = splitString(optarg, ",", tokens, MAX_PEERS); + pConf->peersCount = peerCount; + for (int i = 0; i < peerCount; ++i) { + Addr *pAddr = &pConf->peers[i]; + parseAddr(tokens[i], pAddr->host, sizeof(pAddr->host), &pAddr->port); + } + break; + } + + + case 'd': { + snprintf(pConf->dir, sizeof(pConf->dir), "%s", optarg); + break; + } + + case 'h': { + usage(); + exit(-1); + } + + default: { + usage(); + exit(-1); + } + } + } + snprintf(pConf->dataDir, sizeof(pConf->dataDir), "%s/%s:%u", pConf->dir, pConf->me.host, pConf->me.port); +} + +void printConf(SRaftServerConfig *pConf) { + printf("\nconf: \n"); + printf("me: %s:%u \n", pConf->me.host, pConf->me.port); + printf("peersCount: %d \n", pConf->peersCount); + for (int i = 0; i < pConf->peersCount; ++i) { + Addr *pAddr = &pConf->peers[i]; + printf("peer%d: %s:%u \n", i, pAddr->host, pAddr->port); + } + printf("dataDir: %s \n\n", pConf->dataDir); + +} + + +int main(int argc, char **argv) { + srand(time(NULL)); + int32_t ret; + + exe_name = argv[0]; + if (argc < 3) { + usage(); + exit(-1); + } + + SRaftServerConfig conf; + parseConf(argc, argv, &conf); + printConf(&conf); + + char cmd_buf[COMMAND_LEN]; + snprintf(cmd_buf, sizeof(cmd_buf), "mkdir -p %s", conf.dataDir); + system(cmd_buf); + + struct raft_fsm fsm; + initFsm(&fsm); + + SRaftServer raftServer; + ret = raftServerInit(&raftServer, &conf, &fsm); + assert(ret == 0); + + pthread_t tidRaftServer; + pthread_create(&tidRaftServer, NULL, startServerFunc, &raftServer); + + pthread_t tidConsole; + pthread_create(&tidConsole, NULL, startConsoleFunc, &raftServer); + + while (1) { + sleep(10); + } + + return 0; +} diff --git a/contrib/test/craft/raftServer.c b/contrib/test/craft/raftServer.c new file mode 100644 index 0000000000000000000000000000000000000000..6f4dbc1997ce3e3036592a072347e32c7596245a --- /dev/null +++ b/contrib/test/craft/raftServer.c @@ -0,0 +1,156 @@ +#include +#include "common.h" +#include "raftServer.h" + +char *keys; +char *values; + +void initStore() { + keys = malloc(MAX_RECORD_COUNT * MAX_KV_LEN); + values = malloc(MAX_RECORD_COUNT * MAX_KV_LEN); + writeIndex = 0; +} + +void destroyStore() { + free(keys); + free(values); +} + +void putKV(const char *key, const char *value) { + if (writeIndex < MAX_RECORD_COUNT) { + strncpy(&keys[writeIndex], key, MAX_KV_LEN); + strncpy(&values[writeIndex], value, MAX_KV_LEN); + writeIndex++; + } +} + +char *getKV(const char *key) { + for (int i = 0; i < MAX_RECORD_COUNT; ++i) { + if (strcmp(&keys[i], key) == 0) { + return &values[i]; + } + } + return NULL; +} + + +int splitString(const char* str, char* separator, char (*arr)[MAX_TOKEN_LEN], int n_arr) +{ + if (n_arr <= 0) { + return -1; + } + + char* tmp = (char*)malloc(strlen(str) + 1); + strcpy(tmp, str); + char* context; + int n = 0; + + char* token = strtok_r(tmp, separator, &context); + if (!token) { + goto ret; + } + strncpy(arr[n], token, MAX_TOKEN_LEN); + n++; + + while (1) { + token = strtok_r(NULL, separator, &context); + if (!token || n >= n_arr) { + goto ret; + } + strncpy(arr[n], token, MAX_TOKEN_LEN); + n++; + } + +ret: + free(tmp); + return n; +} + +uint64_t raftId(const char *host, uint32_t port) { + uint32_t host_uint32 = (uint32_t)inet_addr(host); + assert(host_uint32 != (uint32_t)-1); + uint64_t code = ((uint64_t)host_uint32) << 32 | port; + return code; +} + +int32_t raftServerInit(SRaftServer *pRaftServer, const SRaftServerConfig *pConf, struct raft_fsm *pFsm) { + int ret; + + snprintf(pRaftServer->host, sizeof(pRaftServer->host), "%s", pConf->me.host); + pRaftServer->port = pConf->me.port; + snprintf(pRaftServer->address, sizeof(pRaftServer->address), "%s:%u", pRaftServer->host, pRaftServer->port); + strncpy(pRaftServer->dir, pConf->dataDir, sizeof(pRaftServer->dir)); + + pRaftServer->raftId = raftId(pRaftServer->host, pRaftServer->port); + pRaftServer->fsm = pFsm; + + ret = uv_loop_init(&pRaftServer->loop); + if (!ret) { + fprintf(stderr, "%s \n", raft_errmsg(&pRaftServer->raft)); + } + + ret = raft_uv_tcp_init(&pRaftServer->transport, &pRaftServer->loop); + if (!ret) { + fprintf(stderr, "%s \n", raft_errmsg(&pRaftServer->raft)); + } + + ret = raft_uv_init(&pRaftServer->io, &pRaftServer->loop, pRaftServer->dir, &pRaftServer->transport); + if (!ret) { + fprintf(stderr, "%s \n", raft_errmsg(&pRaftServer->raft)); + } + + ret = raft_init(&pRaftServer->raft, &pRaftServer->io, pRaftServer->fsm, pRaftServer->raftId, pRaftServer->address); + if (!ret) { + fprintf(stderr, "%s \n", raft_errmsg(&pRaftServer->raft)); + } + + struct raft_configuration conf; + raft_configuration_init(&conf); + raft_configuration_add(&conf, pRaftServer->raftId, pRaftServer->address, RAFT_VOTER); + printf("add myself: %llu - %s \n", pRaftServer->raftId, pRaftServer->address); + for (int i = 0; i < pConf->peersCount; ++i) { + const Addr *pAddr = &pConf->peers[i]; + raft_id rid = raftId(pAddr->host, pAddr->port); + char addrBuf[ADDRESS_LEN]; + snprintf(addrBuf, sizeof(addrBuf), "%s:%u", pAddr->host, pAddr->port); + raft_configuration_add(&conf, rid, addrBuf, RAFT_VOTER); + printf("add peers: %llu - %s \n", rid, addrBuf); + } + + raft_bootstrap(&pRaftServer->raft, &conf); + + return 0; +} + +int32_t raftServerStart(SRaftServer *pRaftServer) { + int ret; + ret = raft_start(&pRaftServer->raft); + if (!ret) { + fprintf(stderr, "%s \n", raft_errmsg(&pRaftServer->raft)); + } + + uv_run(&pRaftServer->loop, UV_RUN_DEFAULT); +} + + +void raftServerClose(SRaftServer *pRaftServer) { + +} + + +int fsmApplyCb(struct raft_fsm *pFsm, const struct raft_buffer *buf, void **result) { + char *msg = (char*)buf->base; + printf("fsm apply: %s \n", msg); + + char arr[2][MAX_TOKEN_LEN]; + splitString(msg, "--", arr, 2); + putKV(arr[0], arr[1]); + + return 0; +} + +int32_t initFsm(struct raft_fsm *fsm) { + initStore(); + fsm->apply = fsmApplyCb; + return 0; +} diff --git a/contrib/test/craft/raftServer.h b/contrib/test/craft/raftServer.h new file mode 100644 index 0000000000000000000000000000000000000000..5fccde6bf252ecd15d58748d399b118e1291370a --- /dev/null +++ b/contrib/test/craft/raftServer.h @@ -0,0 +1,61 @@ +#ifndef TDENGINE_RAFT_SERVER_H +#define TDENGINE_RAFT_SERVER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include "raft.h" +#include "raft/uv.h" +#include "common.h" + + +// simulate a db store, just for test +#define MAX_KV_LEN 100 +#define MAX_RECORD_COUNT 500 +char *keys; +char *values; +int writeIndex; + +void initStore(); +void destroyStore(); +void putKV(const char *key, const char *value); +char *getKV(const char *key); + +typedef struct { + char dir[DIR_LEN + HOST_LEN * 2]; /* Data dir of UV I/O backend */ + char host[HOST_LEN]; + uint32_t port; + char address[ADDRESS_LEN]; /* Raft instance address */ + raft_id raftId; /* For vote */ + struct raft_fsm *fsm; /* Sample application FSM */ + + struct raft raft; /* Raft instance */ + struct raft_io io; /* UV I/O backend */ + struct uv_loop_s loop; /* UV loop */ + struct raft_uv_transport transport; /* UV I/O backend transport */ +} SRaftServer; + +#define MAX_TOKEN_LEN 32 +int splitString(const char* str, char* separator, char (*arr)[MAX_TOKEN_LEN], int n_arr); + +uint64_t raftId(const char *host, uint32_t port); +int32_t raftServerInit(SRaftServer *pRaftServer, const SRaftServerConfig *pConf, struct raft_fsm *pFsm); +int32_t raftServerStart(SRaftServer *pRaftServer); +void raftServerClose(SRaftServer *pRaftServer); + + +int initFsm(struct raft_fsm *fsm); + + + + +#ifdef __cplusplus +} +#endif + +#endif // TDENGINE_RAFT_SERVER_H diff --git a/include/common/taosmsg.h b/include/common/taosmsg.h index ac8725efdf7ee38bf6f2797787e63c7ee55282bf..83ed5970900d49751a555aaadde6647456694e54 100644 --- a/include/common/taosmsg.h +++ b/include/common/taosmsg.h @@ -52,6 +52,10 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_CONNECT, "mq-connect" ) TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_DISCONNECT, "mq-disconnect" ) TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_SET_CUR, "mq-set-cur" ) TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_RES_READY, "res-ready" ) +TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_TASKS_STATUS, "tasks-status" ) +TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CANCEL_TASK, "cancel-task" ) +TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DROP_TASK, "drop-task" ) + // message from client to mnode TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CONNECT, "connect" ) TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_ACCT, "create-acct" ) @@ -317,17 +321,25 @@ typedef struct { char data[]; } SMDCreateTableMsg; +//typedef struct { +// int32_t len; // one create table message +// char tableName[TSDB_TABLE_FNAME_LEN]; +// int16_t numOfColumns; +// int16_t sqlLen; // the length of SQL, it starts after schema , sql is a null-terminated string +// int8_t igExists; +// int8_t rspMeta; +// int8_t reserved[16]; +// char schema[]; +//} SCreateTableMsg; + typedef struct { - int32_t len; // one create table message char tableName[TSDB_TABLE_FNAME_LEN]; - int16_t numOfTags; int16_t numOfColumns; - int16_t sqlLen; // the length of SQL, it starts after schema , sql is a null-terminated string + int16_t numOfTags; int8_t igExists; int8_t rspMeta; - int8_t reserved[16]; char schema[]; -} SCreateTableMsg; +} SCreateCTableMsg; typedef struct { char name[TSDB_TABLE_FNAME_LEN]; @@ -335,7 +347,7 @@ typedef struct { int32_t numOfTags; int32_t numOfColumns; SSchema pSchema[]; -} SCreateStbMsg; +} SCreateStbMsg, SCreateTableMsg; typedef struct { char name[TSDB_TABLE_FNAME_LEN]; @@ -378,6 +390,7 @@ typedef struct { typedef struct { SMsgHead head; char name[TSDB_TABLE_FNAME_LEN]; + int8_t ignoreNotExists; } SDropTableMsg; typedef struct { @@ -583,10 +596,6 @@ typedef struct { typedef struct { int32_t code; - union { - uint64_t qhandle; - uint64_t qId; - }; // query handle } SQueryTableRsp; // todo: the show handle should be replaced with id @@ -918,18 +927,15 @@ typedef struct SShowRsp { typedef struct { char ep[TSDB_EP_LEN]; // end point, hostname:port - int32_t reserve[8]; } SCreateDnodeMsg; typedef struct { int32_t dnodeId; - int32_t reserve[8]; } SDropDnodeMsg; typedef struct { int32_t dnodeId; char config[TSDB_DNODE_CONFIG_LEN]; - int32_t reserve[8]; } SCfgDnodeMsg; typedef struct { @@ -938,7 +944,6 @@ typedef struct { typedef struct { int32_t dnodeId; - int8_t align[3]; int8_t replica; SReplica replicas[TSDB_MAX_REPLICA]; } SCreateMnodeInMsg, SAlterMnodeInMsg; @@ -1107,29 +1112,33 @@ typedef struct { /* data */ } SUpdateTagValRsp; -typedef struct SSchedulerQueryMsg { +typedef struct SSubQueryMsg { uint64_t schedulerId; uint64_t queryId; uint64_t taskId; uint32_t contentLen; char msg[]; -} SSchedulerQueryMsg; +} SSubQueryMsg; -typedef struct SSchedulerReadyMsg { +typedef struct SResReadyMsg { uint64_t schedulerId; uint64_t queryId; uint64_t taskId; -} SSchedulerReadyMsg; +} SResReadyMsg; -typedef struct SSchedulerFetchMsg { +typedef struct SResReadyRsp { + int32_t code; +} SResReadyRsp; + +typedef struct SResFetchMsg { uint64_t schedulerId; uint64_t queryId; uint64_t taskId; -} SSchedulerFetchMsg; +} SResFetchMsg; -typedef struct SSchedulerStatusMsg { +typedef struct SSchTasksStatusMsg { uint64_t schedulerId; -} SSchedulerStatusMsg; +} SSchTasksStatusMsg; typedef struct STaskStatus { uint64_t queryId; @@ -1143,16 +1152,32 @@ typedef struct SSchedulerStatusRsp { } SSchedulerStatusRsp; -typedef struct SSchedulerCancelMsg { +typedef struct STaskCancelMsg { uint64_t schedulerId; uint64_t queryId; uint64_t taskId; -} SSchedulerCancelMsg; +} STaskCancelMsg; + +typedef struct STaskCancelRsp { + int32_t code; +} STaskCancelRsp; + +typedef struct STaskDropMsg { + uint64_t schedulerId; + uint64_t queryId; + uint64_t taskId; +} STaskDropMsg; + +typedef struct STaskDropRsp { + int32_t code; +} STaskDropRsp; typedef struct { char name[TSDB_TOPIC_FNAME_LEN]; int8_t igExists; + int32_t execLen; void* executor; + int32_t sqlLen; char* sql; } SCreateTopicMsg; diff --git a/include/libs/catalog/catalog.h b/include/libs/catalog/catalog.h index 68eae03f518441aad3aeb17837045cb66b34a92d..592c5f707c25bff03e2fea23c790a9687eea7ef5 100644 --- a/include/libs/catalog/catalog.h +++ b/include/libs/catalog/catalog.h @@ -115,14 +115,14 @@ int32_t catalogGetTableDistVgroup(struct SCatalog* pCatalog, void *pRpc, const S /** * Get a table's vgroup from its name's hash value. * @param pCatalog (input, got with catalogGetHandle) - * @param pRpc (input, rpc object) + * @param pTransporter (input, rpc object) * @param pMgmtEps (input, mnode EPs) * @param pDBName (input, full db name) * @param pTableName (input, table name, NOT including db name) * @param vgInfo (output, vgroup info) * @return error code */ -int32_t catalogGetTableHashVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo); +int32_t catalogGetTableHashVgroup(struct SCatalog* pCatalog, void * pTransporter, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo); /** diff --git a/include/libs/parser/parsenodes.h b/include/libs/parser/parsenodes.h index 62f36abcee9c45c0c254848c57e8d24a108999ba..250739c1e649ab47af10b63f5c3355b4b718c9ee 100644 --- a/include/libs/parser/parsenodes.h +++ b/include/libs/parser/parsenodes.h @@ -40,7 +40,7 @@ typedef struct SQueryNode { typedef struct SField { char name[TSDB_COL_NAME_LEN]; uint8_t type; - int16_t bytes; + int32_t bytes; } SField; typedef struct SParseBasicCtx { @@ -160,6 +160,13 @@ typedef struct SInsertStmtInfo { const char* sql; // current sql statement position } SInsertStmtInfo; +typedef struct SDclStmtInfo { + int16_t nodeType; + int16_t msgType; + char* pMsg; + int32_t msgLen; +} SDclStmtInfo; + #ifdef __cplusplus } #endif diff --git a/include/libs/parser/parser.h b/include/libs/parser/parser.h index 03750a16a9e8cb3bce6acafe91d0305fff3ed49e..7834bc6913476aff8023c6a2cb8fb51d4208e6bb 100644 --- a/include/libs/parser/parser.h +++ b/include/libs/parser/parser.h @@ -22,20 +22,11 @@ extern "C" { #include "parsenodes.h" -/** - * True will be returned if the input sql string is insert, false otherwise. - * @param pStr sql string - * @param length length of the sql string - * @return - */ -bool qIsInsertSql(const char* pStr, size_t length); - typedef struct SParseContext { SParseBasicCtx ctx; void *pRpc; struct SCatalog *pCatalog; const SEpSet *pEpSet; - int64_t id; // query id, generated by uuid generator int8_t schemaAttached; // denote if submit block is built with table schema or not const char *pSql; // sql string size_t sqlLen; // length of the sql string @@ -51,17 +42,9 @@ typedef struct SParseContext { * @param msg extended error message if exists. * @return error code */ -int32_t qParseQuerySql(const char* pStr, size_t length, SParseBasicCtx* pParseCtx, int32_t* type, void** pOutput, int32_t* outputLen, char* msg, int32_t msgLen); +int32_t qParseQuerySql(SParseContext* pContext, SQueryNode** pQuery); -/** - * Parse the insert sql statement. - * @param pStr sql string - * @param length length of the sql string - * @param id operator id, generated by uuid generator. - * @param msg extended error message if exists to help avoid the problem in sql statement. - * @return data in binary format to submit to vnode directly. - */ - int32_t qParseInsertSql(SParseContext* pContext, struct SInsertStmtInfo** pInfo); +bool qIsDclQuery(const SQueryNode* pQuery); /** * Convert a normal sql statement to only query tags information to enable that the subscribe client can be aware quickly of the true vgroup ids that diff --git a/include/libs/planner/planner.h b/include/libs/planner/planner.h index 153cf0bb3ec2e4ad33f1e04ebff53a709e3e555c..d4469be5e3a5e2a03973b4c1bf0158eaf9875d2a 100644 --- a/include/libs/planner/planner.h +++ b/include/libs/planner/planner.h @@ -119,9 +119,9 @@ typedef struct SSubplanId { typedef struct SSubplan { SSubplanId id; // unique id of the subplan - int32_t type; // QUERY_TYPE_MERGE|QUERY_TYPE_PARTIAL|QUERY_TYPE_SCAN + int32_t type; // QUERY_TYPE_MERGE|QUERY_TYPE_PARTIAL|QUERY_TYPE_SCAN|QUERY_TYPE_MODIFY int32_t level; // the execution level of current subplan, starting from 0. - SEpSet execEpSet; // for the scan sub plan, the optional execution node + SEpSet execEpSet; // for the scan/modify subplan, the optional execution node SArray *pChildern; // the datasource subplan,from which to fetch the result SArray *pParents; // the data destination subplan, get data from current subplan SPhyNode *pNode; // physical plan of current subplan @@ -152,7 +152,7 @@ int32_t qExplainQuery(const struct SQueryNode* pQueryInfo, struct SEpSet* pQnode /** * Convert to subplan to string for the scheduler to send to the executor */ -int32_t qSubPlanToString(const SSubplan* subplan, char** str); +int32_t qSubPlanToString(const SSubplan* subplan, char** str, int32_t* len); int32_t qStringToSubplan(const char* str, SSubplan** subplan); diff --git a/include/libs/qcom/query.h b/include/libs/qcom/query.h index 002e736c37f1992af6a7693c07b1f64fa879ccb3..877cfb130c3b338d701571c945d4b9b53db6bd91 100644 --- a/include/libs/qcom/query.h +++ b/include/libs/qcom/query.h @@ -25,12 +25,15 @@ extern "C" { #include "tlog.h" enum { + JOB_TASK_STATUS_NULL = 0, JOB_TASK_STATUS_NOT_START = 1, JOB_TASK_STATUS_EXECUTING, + JOB_TASK_STATUS_PARTIAL_SUCCEED, JOB_TASK_STATUS_SUCCEED, JOB_TASK_STATUS_FAILED, JOB_TASK_STATUS_CANCELLING, - JOB_TASK_STATUS_CANCELLED + JOB_TASK_STATUS_CANCELLED, + JOB_TASK_STATUS_DROPPING, }; typedef struct STableComInfo { @@ -107,7 +110,7 @@ int32_t cleanupTaskQueue(); int32_t taosAsyncExec(__async_exec_fn_t execFn, void* execParam, int32_t* code); SSchema* tGetTbnameColumnSchema(); -void msgInit(); +void initQueryModuleMsgHandle(); extern int32_t (*queryBuildMsg[TSDB_MSG_TYPE_MAX])(void* input, char **msg, int32_t msgSize, int32_t *msgLen); extern int32_t (*queryProcessMsgRsp[TSDB_MSG_TYPE_MAX])(void* output, char *msg, int32_t msgSize); diff --git a/include/libs/qworker/qworker.h b/include/libs/qworker/qworker.h index 63a6b6f89bee7100abd91426b979163a99cfd641..83047a44de3e210f611ff8d83426758a79384f9d 100644 --- a/include/libs/qworker/qworker.h +++ b/include/libs/qworker/qworker.h @@ -42,15 +42,17 @@ typedef struct { int32_t qWorkerInit(SQWorkerCfg *cfg, void **qWorkerMgmt); -int32_t qWorkerProcessQueryMsg(void *qWorkerMgmt, SSchedulerQueryMsg *msg, SRpcMsg *rsp); +int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg); -int32_t qWorkerProcessReadyMsg(void *qWorkerMgmt, SSchedulerReadyMsg *msg, SRpcMsg *rsp); +int32_t qWorkerProcessReadyMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg); -int32_t qWorkerProcessStatusMsg(void *qWorkerMgmt, SSchedulerStatusMsg *msg, SRpcMsg *rsp); +int32_t qWorkerProcessStatusMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg); -int32_t qWorkerProcessFetchMsg(void *qWorkerMgmt, SSchedulerFetchMsg *msg, SRpcMsg *rsp); +int32_t qWorkerProcessFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg); -int32_t qWorkerProcessCancelMsg(void *qWorkerMgmt, SSchedulerCancelMsg *msg, SRpcMsg *rsp); +int32_t qWorkerProcessCancelMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg); + +int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg); void qWorkerDestroy(void **qWorkerMgmt); diff --git a/include/util/taoserror.h b/include/util/taoserror.h index bef1189d072bb07067b85daf41692062e1b0660f..b6e8964b983306ba68df52db38ed62a6aea91f0b 100644 --- a/include/util/taoserror.h +++ b/include/util/taoserror.h @@ -324,6 +324,11 @@ int32_t* taosGetErrno(); #define TSDB_CODE_QRY_INVALID_TIME_CONDITION TAOS_DEF_ERROR_CODE(0, 0x070D) //"invalid time condition") #define TSDB_CODE_QRY_SYS_ERROR TAOS_DEF_ERROR_CODE(0, 0x070E) //"System error") #define TSDB_CODE_QRY_INVALID_INPUT TAOS_DEF_ERROR_CODE(0, 0x070F) //"invalid input") +#define TSDB_CODE_QRY_SCH_NOT_EXIST TAOS_DEF_ERROR_CODE(0, 0x0710) //"Scheduler not exist") +#define TSDB_CODE_QRY_TASK_NOT_EXIST TAOS_DEF_ERROR_CODE(0, 0x0711) //"Task not exist") +#define TSDB_CODE_QRY_TASK_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x0712) //"Task already exist") +#define TSDB_CODE_QRY_RES_CACHE_NOT_EXIST TAOS_DEF_ERROR_CODE(0, 0x0713) //"Task result cache not exist") +#define TSDB_CODE_QRY_TASK_CANCELLED TAOS_DEF_ERROR_CODE(0, 0x0714) //"Task cancelled") // grant diff --git a/include/util/thash.h b/include/util/thash.h index ebdc91f0546a7ef9de3801f4eabf13f18c2cdf4c..d0247a0729012b860132cc691e6df745dde12a83 100644 --- a/include/util/thash.h +++ b/include/util/thash.h @@ -33,6 +33,8 @@ typedef void (*_hash_free_fn_t)(void *); #define HASH_INDEX(v, c) ((v) & ((c)-1)) +#define HASH_NODE_EXIST(code) (code == -2) + /** * murmur hash algorithm * @key usually string diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h index 83ff0d29fb99e527a3acb6355f27728b8cb5f169..a34250ccab8f51355e0318bfc65d248234cb4d7e 100644 --- a/source/client/inc/clientInt.h +++ b/source/client/inc/clientInt.h @@ -137,15 +137,14 @@ typedef struct SRequestMsgBody { extern SAppInfo appInfo; extern int32_t tscReqRef; -extern void *tscQhandle; extern int32_t tscConnRef; -extern int (*buildRequestMsgFp[TSDB_SQL_MAX])(SRequestObj *pRequest, SRequestMsgBody *pMsgBody); -extern int (*handleRequestRspFp[TSDB_SQL_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen); +SRequestMsgBody buildRequestMsgImpl(SRequestObj *pRequest); +extern int (*handleRequestRspFp[TSDB_MSG_TYPE_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen); int taos_init(); -void* createTscObj(const char* user, const char* auth, const char *ip, uint32_t port, SAppInstInfo* pAppInfo); +void* createTscObj(const char* user, const char* auth, const char *db, SAppInstInfo* pAppInfo); void destroyTscObj(void*pObj); void *createRequest(STscObj* pObj, __taos_async_fn_t fp, void* param, int32_t type); diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c index b7a622c2e8f0c06859154b2c212f9a4a9f19b659..b54f7fedd788ea464714c17f033ac5b1bac48244 100644 --- a/source/client/src/clientEnv.c +++ b/source/client/src/clientEnv.c @@ -13,11 +13,12 @@ * along with this program. If not, see . */ -#include "os.h" -#include "taosmsg.h" -#include "query.h" +#include #include "clientInt.h" #include "clientLog.h" +#include "os.h" +#include "query.h" +#include "taosmsg.h" #include "tcache.h" #include "tconfig.h" #include "tglobal.h" @@ -129,7 +130,7 @@ void destroyTscObj(void *pObj) { tfree(pTscObj); } -void* createTscObj(const char* user, const char* auth, const char *ip, uint32_t port, SAppInstInfo* pAppInfo) { +void* createTscObj(const char* user, const char* auth, const char *db, SAppInstInfo* pAppInfo) { STscObj *pObj = (STscObj *)calloc(1, sizeof(STscObj)); if (NULL == pObj) { terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; @@ -144,6 +145,10 @@ void* createTscObj(const char* user, const char* auth, const char *ip, uint32_t tstrncpy(pObj->user, user, sizeof(pObj->user)); memcpy(pObj->pass, auth, TSDB_PASSWORD_LEN); + if (db != NULL) { + tstrncpy(pObj->db, db, tListLen(pObj->db)); + } + pthread_mutex_init(&pObj->mutex, NULL); pObj->id = taosAddRef(tscConnRef, pObj); @@ -220,9 +225,13 @@ void taos_init_imp(void) { taosInitNotes(); initMsgHandleFp(); + initQueryModuleMsgHandle(); rpcInit(); + SCatalogCfg cfg = {.enableVgroupCache = true, .maxDBCacheNum = 100, .maxTblCacheNum = 100}; + catalogInit(&cfg); + tscDebug("starting to initialize TAOS driver, local ep: %s", tsLocalEp); taosSetCoreDump(true); diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c index 42de97fe6a2387e824355cd7d491a717cc2d1744..f00e7bd5781ce8f04e3f67410e08f9b44f6b2d39 100644 --- a/source/client/src/clientImpl.c +++ b/source/client/src/clientImpl.c @@ -113,6 +113,13 @@ TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass, return taosConnectImpl(ip, user, &secretEncrypt[0], db, port, NULL, NULL, *pInst); } +static bool supportedQueryType(int32_t type) { + return (type == TSDB_MSG_TYPE_CREATE_USER || type == TSDB_MSG_TYPE_SHOW || type == TSDB_MSG_TYPE_DROP_USER || + type == TSDB_MSG_TYPE_DROP_ACCT || type == TSDB_MSG_TYPE_CREATE_DB || type == TSDB_MSG_TYPE_CREATE_ACCT || + type == TSDB_MSG_TYPE_CREATE_TABLE || type == TSDB_MSG_TYPE_CREATE_STB || type == TSDB_MSG_TYPE_USE_DB || + type == TSDB_MSG_TYPE_DROP_DB || type == TSDB_MSG_TYPE_DROP_STB); +} + TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) { STscObj *pTscObj = (STscObj *)taos; if (sqlLen > (size_t) tsMaxSQLStringLen) { @@ -144,37 +151,67 @@ TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) { tscDebugL("0x%"PRIx64" SQL: %s", pRequest->requestId, pRequest->sqlstr); - int32_t code = 0; - if (qIsInsertSql(pRequest->sqlstr, sqlLen)) { - // todo add - } else { - int32_t type = 0; - void* output = NULL; - int32_t outputLen = 0; + SParseContext cxt = { + .ctx = {.requestId = pRequest->requestId, .acctId = pTscObj->acctId, .db = getConnectionDB(pTscObj)}, + .pSql = pRequest->sqlstr, + .sqlLen = sqlLen, + .pMsg = pRequest->msgBuf, + .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE + }; + + SQueryNode* pQuery = NULL; + int32_t code = qParseQuerySql(&cxt, &pQuery); + if (qIsDclQuery(pQuery)) { + SDclStmtInfo* pDcl = (SDclStmtInfo*) pQuery; + pRequest->type = pDcl->msgType; + pRequest->body.requestMsg = (SReqMsgInfo){.pMsg = pDcl->pMsg, .len = pDcl->msgLen}; + + SRequestMsgBody body = buildRequestMsgImpl(pRequest); + SEpSet* pEpSet = &pTscObj->pAppInfo->mgmtEp.epSet; + + if (pDcl->msgType == TSDB_MSG_TYPE_CREATE_TABLE) { + struct SCatalog* pCatalog = NULL; + + char buf[12] = {0}; + sprintf(buf, "%d", pTscObj->pAppInfo->clusterId); + code = catalogGetHandle(buf, &pCatalog); + if (code != 0) { + pRequest->code = code; + return pRequest; + } + + SCreateTableMsg* pMsg = body.msgInfo.pMsg; + + SName t = {0}; + tNameFromString(&t, pMsg->name, T_NAME_ACCT|T_NAME_DB|T_NAME_TABLE); - SParseBasicCtx c = {.requestId = pRequest->requestId, .acctId = pTscObj->acctId, .db = getConnectionDB(pTscObj)}; - code = qParseQuerySql(pRequest->sqlstr, sqlLen, &c, &type, &output, &outputLen, pRequest->msgBuf, ERROR_MSG_BUF_DEFAULT_SIZE); - if (type == TSDB_SQL_CREATE_USER || type == TSDB_SQL_SHOW || type == TSDB_SQL_DROP_USER || - type == TSDB_SQL_DROP_ACCT || type == TSDB_SQL_CREATE_DB || type == TSDB_SQL_CREATE_ACCT || - type == TSDB_SQL_CREATE_TABLE || type == TSDB_SQL_USE_DB) { - pRequest->type = type; - pRequest->body.requestMsg = (SReqMsgInfo){.pMsg = output, .len = outputLen}; + char db[TSDB_DB_NAME_LEN + TS_PATH_DELIMITER_LEN + TSDB_ACCT_ID_LEN] = {0}; + tNameGetFullDbName(&t, db); - SRequestMsgBody body = {0}; - buildRequestMsgFp[type](pRequest, &body); + SVgroupInfo info = {0}; + catalogGetTableHashVgroup(pCatalog, pTscObj->pTransporter, pEpSet, db, tNameGetTableName(&t), &info); int64_t transporterId = 0; - sendMsgToServer(pTscObj->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &body, &transporterId); + SEpSet ep = {0}; + ep.inUse = info.inUse; + ep.numOfEps = info.numOfEps; + for(int32_t i = 0; i < ep.numOfEps; ++i) { + ep.port[i] = info.epAddr[i].port; + tstrncpy(ep.fqdn[i], info.epAddr[i].fqdn, tListLen(ep.fqdn[i])); + } - tsem_wait(&pRequest->body.rspSem); - destroyRequestMsgBody(&body); + sendMsgToServer(pTscObj->pTransporter, &ep, &body, &transporterId); } else { - assert(0); + int64_t transporterId = 0; + sendMsgToServer(pTscObj->pTransporter, pEpSet, &body, &transporterId); } - tfree(c.db); + tsem_wait(&pRequest->body.rspSem); + destroyRequestMsgBody(&body); } + tfree(cxt.ctx.db); + if (code != TSDB_CODE_SUCCESS) { pRequest->code = code; return pRequest; @@ -186,7 +223,7 @@ TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) { int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet) { pEpSet->version = 0; - // init mgmt ip set + // init mnode ip set SEpSet *mgmtEpSet = &(pEpSet->epSet); mgmtEpSet->numOfEps = 0; mgmtEpSet->inUse = 0; @@ -220,13 +257,13 @@ int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSe } STscObj* taosConnectImpl(const char *ip, const char *user, const char *auth, const char *db, uint16_t port, __taos_async_fn_t fp, void *param, SAppInstInfo* pAppInfo) { - STscObj *pTscObj = createTscObj(user, auth, ip, port, pAppInfo); + STscObj *pTscObj = createTscObj(user, auth, db, pAppInfo); if (NULL == pTscObj) { terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; return pTscObj; } - SRequestObj *pRequest = createRequest(pTscObj, fp, param, TSDB_SQL_CONNECT); + SRequestObj *pRequest = createRequest(pTscObj, fp, param, TSDB_MSG_TYPE_CONNECT); if (pRequest == NULL) { destroyTscObj(pTscObj); terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; @@ -268,16 +305,11 @@ static int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) return -1; } - // TODO refactor full_name - char *db; // ugly code to move the space - STscObj *pObj = pRequest->pTscObj; - pthread_mutex_lock(&pObj->mutex); - db = strstr(pObj->db, TS_PATH_DELIMITER); - db = (db == NULL) ? pObj->db : db + 1; + char* db = getConnectionDB(pObj); tstrncpy(pConnect->db, db, sizeof(pConnect->db)); - pthread_mutex_unlock(&pObj->mutex); + tfree(db); pConnect->pid = htonl(appInfo.pid); pConnect->startTime = htobe64(appInfo.startTime); @@ -395,10 +427,9 @@ void* doFetchRow(SRequestObj* pRequest) { SReqResultInfo* pResultInfo = &pRequest->body.resInfo; if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) { - pRequest->type = TSDB_SQL_RETRIEVE_MNODE; + pRequest->type = TSDB_MSG_TYPE_SHOW_RETRIEVE; - SRequestMsgBody body = {0}; - buildRequestMsgFp[pRequest->type](pRequest, &body); + SRequestMsgBody body = buildRequestMsgImpl(pRequest); int64_t transporterId = 0; STscObj* pTscObj = pRequest->pTscObj; diff --git a/source/client/src/clientMsgHandler.c b/source/client/src/clientMsgHandler.c index 2f996c6ced0499068fe9fda7c5f19803fe487f31..548ea3d725f3cb43fafc393d69fad3d48ca73a87 100644 --- a/source/client/src/clientMsgHandler.c +++ b/source/client/src/clientMsgHandler.c @@ -21,8 +21,7 @@ #include "tmsgtype.h" #include "trpc.h" -int (*buildRequestMsgFp[TSDB_SQL_MAX])(SRequestObj *pRequest, SRequestMsgBody *pMsgBody) = {0}; -int (*handleRequestRspFp[TSDB_SQL_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen); +int (*handleRequestRspFp[TSDB_MSG_TYPE_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen); int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) { pMsgBody->msgType = TSDB_MSG_TYPE_CONNECT; @@ -67,15 +66,6 @@ int processConnectRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) { pConnect->epSet.port[i] = htons(pConnect->epSet.port[i]); } - // TODO refactor - pthread_mutex_lock(&pTscObj->mutex); - char temp[TSDB_TABLE_FNAME_LEN * 2] = {0}; - int32_t len = sprintf(temp, "%d%s%s", pTscObj->acctId, TS_PATH_DELIMITER, pTscObj->db); - - assert(len <= sizeof(pTscObj->db)); - tstrncpy(pTscObj->db, temp, sizeof(pTscObj->db)); - pthread_mutex_unlock(&pTscObj->mutex); - if (!isEpsetEqual(&pTscObj->pAppInfo->mgmtEp.epSet, &pConnect->epSet)) { updateEpSet_s(&pTscObj->pAppInfo->mgmtEp, &pConnect->epSet); } @@ -96,47 +86,35 @@ int processConnectRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) { return 0; } -int32_t doBuildMsgSupp(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) { +static int32_t buildRetrieveMnodeMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) { + pMsgBody->msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE; + pMsgBody->msgInfo.len = sizeof(SRetrieveTableMsg); pMsgBody->requestObjRefId = pRequest->self; - pMsgBody->msgInfo = pRequest->body.requestMsg; - - switch(pRequest->type) { - case TSDB_SQL_CREATE_USER: - pMsgBody->msgType = TSDB_MSG_TYPE_CREATE_USER; - break; - case TSDB_SQL_DROP_USER: - pMsgBody->msgType = TSDB_MSG_TYPE_DROP_USER; - break; - case TSDB_SQL_CREATE_ACCT: - pMsgBody->msgType = TSDB_MSG_TYPE_CREATE_ACCT; - break; - case TSDB_SQL_DROP_ACCT: - pMsgBody->msgType = TSDB_MSG_TYPE_DROP_ACCT; - break; - case TSDB_SQL_CREATE_DB: { - pMsgBody->msgType = TSDB_MSG_TYPE_CREATE_DB; - - SCreateDbMsg* pCreateMsg = pRequest->body.requestMsg.pMsg; - SName name = {0}; - int32_t ret = tNameSetDbName(&name, pRequest->pTscObj->acctId, pCreateMsg->db, strnlen(pCreateMsg->db, tListLen(pCreateMsg->db))); - if (ret != TSDB_CODE_SUCCESS) { - return -1; - } - - tNameGetFullDbName(&name, pCreateMsg->db); - break; - } - case TSDB_SQL_USE_DB: { - pMsgBody->msgType = TSDB_MSG_TYPE_USE_DB; - break; - } - case TSDB_SQL_CREATE_TABLE: { - pMsgBody->msgType = TSDB_MSG_TYPE_CREATE_STB; - break; - } - case TSDB_SQL_SHOW: - pMsgBody->msgType = TSDB_MSG_TYPE_SHOW; - break; + + SRetrieveTableMsg *pRetrieveMsg = calloc(1, sizeof(SRetrieveTableMsg)); + if (pRetrieveMsg == NULL) { + return TSDB_CODE_TSC_OUT_OF_MEMORY; + } + + pRetrieveMsg->showId = htonl(pRequest->body.execId); + pMsgBody->msgInfo.pMsg = pRetrieveMsg; + return TSDB_CODE_SUCCESS; +} + +SRequestMsgBody buildRequestMsgImpl(SRequestObj *pRequest) { + if (pRequest->type == TSDB_MSG_TYPE_SHOW_RETRIEVE) { + SRequestMsgBody body = {0}; + buildRetrieveMnodeMsg(pRequest, &body); + return body; + } else { + assert(pRequest != NULL); + SRequestMsgBody body = { + .requestObjRefId = pRequest->self, + .msgInfo = pRequest->body.requestMsg, + .msgType = pRequest->type, + .requestId = pRequest->requestId, + }; + return body; } } @@ -175,18 +153,6 @@ int32_t processShowRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) return 0; } -int buildRetrieveMnodeMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) { - pMsgBody->msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE; - pMsgBody->msgInfo.len = sizeof(SRetrieveTableMsg); - pMsgBody->requestObjRefId = pRequest->self; - - SRetrieveTableMsg *pRetrieveMsg = calloc(1, sizeof(SRetrieveTableMsg)); - pRetrieveMsg->showId = htonl(pRequest->body.execId); - - pMsgBody->msgInfo.pMsg = pRetrieveMsg; - return TSDB_CODE_SUCCESS; -} - int32_t processRetrieveMnodeRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) { assert(msgLen >= sizeof(SRetrieveTableRsp)); @@ -227,6 +193,10 @@ int32_t processCreateTableRsp(SRequestObj *pRequest, const char* pMsg, int32_t m assert(pMsg != NULL); } +int32_t processDropDbRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) { + // todo: Remove cache in catalog cache. +} + void initMsgHandleFp() { #if 0 tscBuildMsg[TSDB_SQL_SELECT] = tscBuildQueryMsg; @@ -303,27 +273,11 @@ void initMsgHandleFp() { tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp; #endif - buildRequestMsgFp[TSDB_SQL_CONNECT] = buildConnectMsg; - handleRequestRspFp[TSDB_SQL_CONNECT] = processConnectRsp; - - buildRequestMsgFp[TSDB_SQL_CREATE_USER] = doBuildMsgSupp; - buildRequestMsgFp[TSDB_SQL_DROP_USER] = doBuildMsgSupp; - - buildRequestMsgFp[TSDB_SQL_CREATE_ACCT] = doBuildMsgSupp; - buildRequestMsgFp[TSDB_SQL_DROP_ACCT] = doBuildMsgSupp; - - buildRequestMsgFp[TSDB_SQL_SHOW] = doBuildMsgSupp; - handleRequestRspFp[TSDB_SQL_SHOW] = processShowRsp; - - buildRequestMsgFp[TSDB_SQL_RETRIEVE_MNODE] = buildRetrieveMnodeMsg; - handleRequestRspFp[TSDB_SQL_RETRIEVE_MNODE]= processRetrieveMnodeRsp; - - buildRequestMsgFp[TSDB_SQL_CREATE_DB] = doBuildMsgSupp; - handleRequestRspFp[TSDB_SQL_CREATE_DB] = processCreateDbRsp; - - buildRequestMsgFp[TSDB_SQL_USE_DB] = doBuildMsgSupp; - handleRequestRspFp[TSDB_SQL_USE_DB] = processUseDbRsp; - - buildRequestMsgFp[TSDB_SQL_CREATE_TABLE] = doBuildMsgSupp; - handleRequestRspFp[TSDB_SQL_CREATE_TABLE] = processCreateTableRsp; + handleRequestRspFp[TSDB_MSG_TYPE_CONNECT] = processConnectRsp; + handleRequestRspFp[TSDB_MSG_TYPE_SHOW] = processShowRsp; + handleRequestRspFp[TSDB_MSG_TYPE_SHOW_RETRIEVE] = processRetrieveMnodeRsp; + handleRequestRspFp[TSDB_MSG_TYPE_CREATE_DB] = processCreateDbRsp; + handleRequestRspFp[TSDB_MSG_TYPE_USE_DB] = processUseDbRsp; + handleRequestRspFp[TSDB_MSG_TYPE_CREATE_TABLE] = processCreateTableRsp; + handleRequestRspFp[TSDB_MSG_TYPE_DROP_DB] = processDropDbRsp; } \ No newline at end of file diff --git a/source/client/test/clientTests.cpp b/source/client/test/clientTests.cpp index 0ef305d3b610aa3c7e3b39d48e0b94492bb821e8..2938d0180a958af8ace229e009e1b682e895abe4 100644 --- a/source/client/test/clientTests.cpp +++ b/source/client/test/clientTests.cpp @@ -22,11 +22,24 @@ #pragma GCC diagnostic ignored "-Wunused-variable" #pragma GCC diagnostic ignored "-Wsign-compare" +#include "../inc/clientInt.h" #include "taos.h" #include "tglobal.h" -#include "../inc/clientInt.h" namespace { +void showDB(TAOS* pConn) { + TAOS_RES* pRes = taos_query(pConn, "show databases"); + TAOS_ROW pRow = NULL; + + TAOS_FIELD* pFields = taos_fetch_fields(pRes); + int32_t numOfFields = taos_num_fields(pRes); + + char str[512] = {0}; + while ((pRow = taos_fetch_row(pRes)) != NULL) { + int32_t code = taos_print_row(str, pRow, pFields, numOfFields); + printf("%s\n", str); + } +} } // namespace int main(int argc, char** argv) { @@ -34,19 +47,17 @@ int main(int argc, char** argv) { return RUN_ALL_TESTS(); } -TEST(testCase, driverInit_Test) { - taos_init(); -} +TEST(testCase, driverInit_Test) { taos_init(); } -TEST(testCase, connect_Test) { + TEST(testCase, connect_Test) { TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); // assert(pConn != NULL); taos_close(pConn); } -TEST(testCase, create_user_Test) { + TEST(testCase, create_user_Test) { TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); -// assert(pConn != NULL); + assert(pConn != NULL); TAOS_RES* pRes = taos_query(pConn, "create user abc pass 'abc'"); if (taos_errno(pRes) != TSDB_CODE_SUCCESS) { @@ -57,7 +68,7 @@ TEST(testCase, create_user_Test) { taos_close(pConn); } -TEST(testCase, create_account_Test) { + TEST(testCase, create_account_Test) { TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); assert(pConn != NULL); @@ -70,7 +81,7 @@ TEST(testCase, create_account_Test) { taos_close(pConn); } -TEST(testCase, drop_account_Test) { + TEST(testCase, drop_account_Test) { TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); assert(pConn != NULL); @@ -83,7 +94,7 @@ TEST(testCase, drop_account_Test) { taos_close(pConn); } -TEST(testCase, show_user_Test) { + TEST(testCase, show_user_Test) { TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); // assert(pConn != NULL); @@ -102,7 +113,7 @@ TEST(testCase, show_user_Test) { taos_close(pConn); } -TEST(testCase, drop_user_Test) { + TEST(testCase, drop_user_Test) { TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); assert(pConn != NULL); @@ -115,7 +126,7 @@ TEST(testCase, drop_user_Test) { taos_close(pConn); } -TEST(testCase, show_db_Test) { + TEST(testCase, show_db_Test) { TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); // assert(pConn != NULL); @@ -139,6 +150,9 @@ TEST(testCase, create_db_Test) { assert(pConn != NULL); TAOS_RES* pRes = taos_query(pConn, "create database abc1"); + if (taos_errno(pRes) != 0) { + printf("error in create db, reason:%s\n", taos_errstr(pRes)); + } TAOS_FIELD* pFields = taos_fetch_fields(pRes); ASSERT_TRUE(pFields == NULL); @@ -154,6 +168,9 @@ TEST(testCase, use_db_test) { assert(pConn != NULL); TAOS_RES* pRes = taos_query(pConn, "use abc1"); + if (taos_errno(pRes) != 0) { + printf("error in use db, reason:%s\n", taos_errstr(pRes)); + } TAOS_FIELD* pFields = taos_fetch_fields(pRes); ASSERT_TRUE(pFields == NULL); @@ -164,20 +181,124 @@ TEST(testCase, use_db_test) { taos_close(pConn); } -TEST(testCase, create_stable_Test) { +TEST(testCase, drop_db_test) { TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); assert(pConn != NULL); - TAOS_RES* pRes = taos_query(pConn, "use abc1"); + showDB(pConn); + + TAOS_RES* pRes = taos_query(pConn, "drop database abc1"); + if (taos_errno(pRes) != 0) { + printf("failed to drop db, reason:%s\n", taos_errstr(pRes)); + } + taos_free_result(pRes); - pRes = taos_query(pConn, "create stable st1(ts timestamp, k int) tags(a int)"); + showDB(pConn); + taos_close(pConn); +} - TAOS_FIELD* pFields = taos_fetch_fields(pRes); - ASSERT_TRUE(pFields == NULL); +// TEST(testCase, create_stable_Test) { +// TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); +// assert(pConn != NULL); +// +// TAOS_RES* pRes = taos_query(pConn, "create database abc1"); +// if (taos_errno(pRes) != 0) { +// printf("error in create db, reason:%s\n", taos_errstr(pRes)); +// } +// taos_free_result(pRes); +// +// pRes = taos_query(pConn, "use abc1"); +// if (taos_errno(pRes) != 0) { +// printf("error in use db, reason:%s\n", taos_errstr(pRes)); +// } +// taos_free_result(pRes); +// +// pRes = taos_query(pConn, "create stable st1(ts timestamp, k int) tags(a int)"); +// if (taos_errno(pRes) != 0) { +// printf("error in create stable, reason:%s\n", taos_errstr(pRes)); +// } +// +// TAOS_FIELD* pFields = taos_fetch_fields(pRes); +// ASSERT_TRUE(pFields == NULL); +// +// int32_t numOfFields = taos_num_fields(pRes); +// ASSERT_EQ(numOfFields, 0); +// +// taos_free_result(pRes); +// taos_close(pConn); +//} + +TEST(testCase, create_table_Test) { + // TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); + // assert(pConn != NULL); + // + // TAOS_RES* pRes = taos_query(pConn, "use abc1"); + // taos_free_result(pRes); + // + // pRes = taos_query(pConn, "create table tm0(ts timestamp, k int)"); + // taos_free_result(pRes); + // + // taos_close(pConn); +} + +TEST(testCase, create_ctable_Test) {} + +TEST(testCase, show_stable_Test) { + TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); + assert(pConn != NULL); + TAOS_RES* pRes = taos_query(pConn, "show stables"); + TAOS_ROW pRow = NULL; + + TAOS_FIELD* pFields = taos_fetch_fields(pRes); int32_t numOfFields = taos_num_fields(pRes); - ASSERT_EQ(numOfFields, 0); + char str[512] = {0}; + while((pRow = taos_fetch_row(pRes)) != NULL) { + int32_t code = taos_print_row(str, pRow, pFields, numOfFields); + printf("%s\n", str); + } + + taos_free_result(pRes); + + taos_close(pConn); +} + +TEST(testCase, drop_stable_Test) { + TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); + assert(pConn != NULL); + + TAOS_RES* pRes = taos_query(pConn, "create database abc1"); + if (taos_errno(pRes) != 0) { + printf("error in creating db, reason:%s\n", taos_errstr(pRes)); + } + taos_free_result(pRes); + + pRes = taos_query(pConn, "use abc1"); + if (taos_errno(pRes) != 0) { + printf("error in using db, reason:%s\n", taos_errstr(pRes)); + } + taos_free_result(pRes); + + pRes = taos_query(pConn, "drop stable st1"); + if (taos_errno(pRes) != 0) { + printf("failed to drop stable, reason:%s\n", taos_errstr(pRes)); + } + + taos_free_result(pRes); taos_close(pConn); } + +//TEST(testCase, show_table_Test) { +// TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0); +// assert(pConn != NULL); +// +// TAOS_RES* pRes = taos_query(pConn, "use abc1"); +// taos_free_result(pRes); +// +// pRes = taos_query(pConn, "show tables"); +// taos_free_result(pRes); +// +// taos_close(pConn); +//} diff --git a/source/dnode/mgmt/impl/src/dndMnode.c b/source/dnode/mgmt/impl/src/dndMnode.c index 3cf08e619ea4fd80a26f739f2b1248c490c0dd43..c4d69c4626a8ad4c5f48920e81d0149bd499fb08 100644 --- a/source/dnode/mgmt/impl/src/dndMnode.c +++ b/source/dnode/mgmt/impl/src/dndMnode.c @@ -349,7 +349,7 @@ static void dndBuildMnodeDeployOption(SDnode *pDnode, SMnodeOpt *pOption) { SReplica *pReplica = &pOption->replicas[0]; pReplica->id = 1; pReplica->port = pDnode->opt.serverPort; - tstrncpy(pReplica->fqdn, pDnode->opt.localFqdn, TSDB_FQDN_LEN); + memcpy(pReplica->fqdn, pDnode->opt.localFqdn, TSDB_FQDN_LEN); SMnodeMgmt *pMgmt = &pDnode->mmgmt; pMgmt->selfIndex = pOption->selfIndex; @@ -376,7 +376,7 @@ static int32_t dndBuildMnodeOptionFromMsg(SDnode *pDnode, SMnodeOpt *pOption, SC SReplica *pReplica = &pOption->replicas[i]; pReplica->id = pMsg->replicas[i].id; pReplica->port = pMsg->replicas[i].port; - tstrncpy(pReplica->fqdn, pMsg->replicas[i].fqdn, TSDB_FQDN_LEN); + memcpy(pReplica->fqdn, pMsg->replicas[i].fqdn, TSDB_FQDN_LEN); if (pReplica->id == pOption->dnodeId) { pOption->selfIndex = i; } @@ -479,9 +479,11 @@ static int32_t dndDropMnode(SDnode *pDnode) { return -1; } + dndReleaseMnode(pDnode, pMnode); dndStopMnodeWorker(pDnode); dndWriteMnodeFile(pDnode); mndClose(pMnode); + pMgmt->pMnode = NULL; mndDestroy(pDnode->dir.mnode); return 0; @@ -499,7 +501,7 @@ static SCreateMnodeInMsg *dndParseCreateMnodeMsg(SRpcMsg *pRpcMsg) { } static int32_t dndProcessCreateMnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) { - SCreateMnodeInMsg *pMsg = dndParseCreateMnodeMsg(pRpcMsg->pCont); + SCreateMnodeInMsg *pMsg = dndParseCreateMnodeMsg(pRpcMsg); if (pMsg->dnodeId != dndGetDnodeId(pDnode)) { terrno = TSDB_CODE_DND_MNODE_ID_INVALID; @@ -515,18 +517,23 @@ static int32_t dndProcessCreateMnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) { } static int32_t dndProcessAlterMnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) { - SAlterMnodeInMsg *pMsg = dndParseCreateMnodeMsg(pRpcMsg->pCont); + SAlterMnodeInMsg *pMsg = dndParseCreateMnodeMsg(pRpcMsg); if (pMsg->dnodeId != dndGetDnodeId(pDnode)) { terrno = TSDB_CODE_DND_MNODE_ID_INVALID; return -1; - } else { - SMnodeOpt option = {0}; - if (dndBuildMnodeOptionFromMsg(pDnode, &option, pMsg) != 0) { - return -1; - } - return dndAlterMnode(pDnode, &option); } + + SMnodeOpt option = {0}; + if (dndBuildMnodeOptionFromMsg(pDnode, &option, pMsg) != 0) { + return -1; + } + + if (dndAlterMnode(pDnode, &option) != 0) { + return -1; + } + + return dndWriteMnodeFile(pDnode); } static int32_t dndProcessDropMnodeReq(SDnode *pDnode, SRpcMsg *pRpcMsg) { @@ -555,16 +562,17 @@ static void dndProcessMnodeMgmtQueue(SDnode *pDnode, SRpcMsg *pMsg) { code = dndProcessDropMnodeReq(pDnode, pMsg); break; default: - code = TSDB_CODE_MSG_NOT_PROCESSED; + terrno = TSDB_CODE_MSG_NOT_PROCESSED; + code = -1; break; } if (pMsg->msgType & 1u) { + if (code != 0) code = terrno; SRpcMsg rsp = {.code = code, .handle = pMsg->handle}; rpcSendResponse(&rsp); } rpcFreeCont(pMsg->pCont); - pMsg->pCont = NULL; taosFreeQitem(pMsg); } @@ -625,8 +633,6 @@ static void dndProcessMnodeSyncQueue(SDnode *pDnode, SMnodeMsg *pMsg) { } static int32_t dndWriteMnodeMsgToQueue(SMnode *pMnode, taos_queue pQueue, SRpcMsg *pRpcMsg) { - assert(pQueue); - SMnodeMsg *pMsg = mndInitMsg(pMnode, pRpcMsg); if (pMsg == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -647,15 +653,18 @@ void dndProcessMnodeMgmtMsg(SDnode *pDnode, SRpcMsg *pRpcMsg, SEpSet *pEpSet) { SMnode *pMnode = dndAcquireMnode(pDnode); SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg)); + if (pMsg != NULL) *pMsg = *pRpcMsg; + if (pMsg == NULL || taosWriteQitem(pMgmt->pMgmtQ, pMsg) != 0) { if (pRpcMsg->msgType & 1u) { SRpcMsg rsp = {.handle = pRpcMsg->handle, .code = TSDB_CODE_OUT_OF_MEMORY}; rpcSendResponse(&rsp); } rpcFreeCont(pRpcMsg->pCont); - pRpcMsg->pCont = NULL; taosFreeQitem(pMsg); } + + dndReleaseMnode(pDnode, pMnode); } void dndProcessMnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) { @@ -894,6 +903,11 @@ int32_t dndInitMnode(SDnode *pDnode) { return -1; } + if (dndAllocMnodeMgmtQueue(pDnode) != 0) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; + } + char path[PATH_MAX]; snprintf(path, PATH_MAX, "%s/mnode.json", pDnode->dir.dnode); pMgmt->file = strdup(path); @@ -935,8 +949,9 @@ void dndCleanupMnode(SDnode *pDnode) { SMnodeMgmt *pMgmt = &pDnode->mmgmt; dInfo("dnode-mnode start to clean up"); - dndStopMnodeWorker(pDnode); + if (pMgmt->pMnode) dndStopMnodeWorker(pDnode); dndCleanupMnodeMgmtWorker(pDnode); + dndFreeMnodeMgmtQueue(pDnode); tfree(pMgmt->file); mndClose(pMgmt->pMnode); dInfo("dnode-mnode is cleaned up"); diff --git a/source/dnode/mgmt/impl/src/dndTransport.c b/source/dnode/mgmt/impl/src/dndTransport.c index be60d2fcae26fc0a054b83c24a72f9cd7272d600..3d797eba8f0743886d4caa2205ff7588e620670c 100644 --- a/source/dnode/mgmt/impl/src/dndTransport.c +++ b/source/dnode/mgmt/impl/src/dndTransport.c @@ -45,6 +45,10 @@ static void dndInitMsgFp(STransMgmt *pMgmt) { pMgmt->msgFp[TSDB_MSG_TYPE_MQ_CONNECT] = dndProcessVnodeWriteMsg; pMgmt->msgFp[TSDB_MSG_TYPE_MQ_DISCONNECT] = dndProcessVnodeWriteMsg; pMgmt->msgFp[TSDB_MSG_TYPE_MQ_SET_CUR] = dndProcessVnodeWriteMsg; + pMgmt->msgFp[TSDB_MSG_TYPE_RES_READY] = dndProcessVnodeFetchMsg; + pMgmt->msgFp[TSDB_MSG_TYPE_TASKS_STATUS] = dndProcessVnodeFetchMsg; + pMgmt->msgFp[TSDB_MSG_TYPE_CANCEL_TASK] = dndProcessVnodeFetchMsg; + pMgmt->msgFp[TSDB_MSG_TYPE_DROP_TASK] = dndProcessVnodeFetchMsg; // msg from client to mnode pMgmt->msgFp[TSDB_MSG_TYPE_CONNECT] = dndProcessMnodeReadMsg; @@ -136,7 +140,7 @@ static void dndProcessResponse(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) { DndMsgFp fp = pMgmt->msgFp[msgType]; if (fp != NULL) { (*fp)(pDnode, pMsg, pEpSet); - dTrace("RPC %p, rsp:%s is processed, code:0x%0X", pMsg->handle, taosMsg[msgType], pMsg->code & 0XFFFF); + dTrace("RPC %p, rsp:%s is processed, code:0x%x", pMsg->handle, taosMsg[msgType], pMsg->code & 0XFFFF); } else { dError("RPC %p, rsp:%s not processed", pMsg->handle, taosMsg[msgType]); rpcFreeCont(pMsg->pCont); @@ -184,7 +188,7 @@ static void dndProcessRequest(void *param, SRpcMsg *pMsg, SEpSet *pEpSet) { int32_t msgType = pMsg->msgType; if (msgType == TSDB_MSG_TYPE_NETWORK_TEST) { - dTrace("RPC %p, network test req, app:%p will be processed", pMsg->handle, pMsg->ahandle); + dTrace("RPC %p, network test req, app:%p will be processed, code:0x%x", pMsg->handle, pMsg->ahandle, pMsg->code); dndProcessDnodeReq(pDnode, pMsg, pEpSet); return; } diff --git a/source/dnode/mgmt/impl/test/CMakeLists.txt b/source/dnode/mgmt/impl/test/CMakeLists.txt index a29926c8026950028690bf3d07fa224ee1dd5084..dcce270d7ddd30478e84cb848c0e73d8b4de5563 100644 --- a/source/dnode/mgmt/impl/test/CMakeLists.txt +++ b/source/dnode/mgmt/impl/test/CMakeLists.txt @@ -7,7 +7,7 @@ add_subdirectory(cluster) add_subdirectory(db) add_subdirectory(dnode) # add_subdirectory(func) -# add_subdirectory(mnode) +add_subdirectory(mnode) add_subdirectory(profile) add_subdirectory(show) add_subdirectory(stb) diff --git a/source/dnode/mgmt/impl/test/db/db.cpp b/source/dnode/mgmt/impl/test/db/db.cpp index 378f46aa4defe07fa739b170b3cf04f442d99d60..79a7477cea348abd960def6c8437d1bf541397a9 100644 --- a/source/dnode/mgmt/impl/test/db/db.cpp +++ b/source/dnode/mgmt/impl/test/db/db.cpp @@ -27,24 +27,25 @@ Testbase DndTestDb::test; TEST_F(DndTestDb, 01_ShowDb) { test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, ""); - CHECK_META("show databases", 17); + CHECK_META("show databases", 18); CHECK_SCHEMA(0, TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN - 1 + VARSTR_HEADER_SIZE, "name"); CHECK_SCHEMA(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time"); CHECK_SCHEMA(2, TSDB_DATA_TYPE_SMALLINT, 2, "vgroups"); - CHECK_SCHEMA(3, TSDB_DATA_TYPE_SMALLINT, 2, "replica"); - CHECK_SCHEMA(4, TSDB_DATA_TYPE_SMALLINT, 2, "quorum"); - CHECK_SCHEMA(5, TSDB_DATA_TYPE_SMALLINT, 2, "days"); - CHECK_SCHEMA(6, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "keep0,keep1,keep2"); - CHECK_SCHEMA(7, TSDB_DATA_TYPE_INT, 4, "cache"); - CHECK_SCHEMA(8, TSDB_DATA_TYPE_INT, 4, "blocks"); - CHECK_SCHEMA(9, TSDB_DATA_TYPE_INT, 4, "minrows"); - CHECK_SCHEMA(10, TSDB_DATA_TYPE_INT, 4, "maxrows"); - CHECK_SCHEMA(11, TSDB_DATA_TYPE_TINYINT, 1, "wallevel"); - CHECK_SCHEMA(12, TSDB_DATA_TYPE_INT, 4, "fsync"); - CHECK_SCHEMA(13, TSDB_DATA_TYPE_TINYINT, 1, "comp"); - CHECK_SCHEMA(14, TSDB_DATA_TYPE_TINYINT, 1, "cachelast"); - CHECK_SCHEMA(15, TSDB_DATA_TYPE_BINARY, 3 + VARSTR_HEADER_SIZE, "precision"); - CHECK_SCHEMA(16, TSDB_DATA_TYPE_TINYINT, 1, "update"); + CHECK_SCHEMA(3, TSDB_DATA_TYPE_INT, 4, "ntables"); + CHECK_SCHEMA(4, TSDB_DATA_TYPE_SMALLINT, 2, "replica"); + CHECK_SCHEMA(5, TSDB_DATA_TYPE_SMALLINT, 2, "quorum"); + CHECK_SCHEMA(6, TSDB_DATA_TYPE_SMALLINT, 2, "days"); + CHECK_SCHEMA(7, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "keep0,keep1,keep2"); + CHECK_SCHEMA(8, TSDB_DATA_TYPE_INT, 4, "cache"); + CHECK_SCHEMA(9, TSDB_DATA_TYPE_INT, 4, "blocks"); + CHECK_SCHEMA(10, TSDB_DATA_TYPE_INT, 4, "minrows"); + CHECK_SCHEMA(11, TSDB_DATA_TYPE_INT, 4, "maxrows"); + CHECK_SCHEMA(12, TSDB_DATA_TYPE_TINYINT, 1, "wallevel"); + CHECK_SCHEMA(13, TSDB_DATA_TYPE_INT, 4, "fsync"); + CHECK_SCHEMA(14, TSDB_DATA_TYPE_TINYINT, 1, "comp"); + CHECK_SCHEMA(15, TSDB_DATA_TYPE_TINYINT, 1, "cachelast"); + CHECK_SCHEMA(16, TSDB_DATA_TYPE_BINARY, 3 + VARSTR_HEADER_SIZE, "precision"); + CHECK_SCHEMA(17, TSDB_DATA_TYPE_TINYINT, 1, "update"); test.SendShowRetrieveMsg(); EXPECT_EQ(test.GetShowRows(), 0); @@ -82,13 +83,14 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) { } test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, ""); - CHECK_META("show databases", 17); + CHECK_META("show databases", 18); test.SendShowRetrieveMsg(); EXPECT_EQ(test.GetShowRows(), 1); CheckBinary("d1", TSDB_DB_NAME_LEN - 1); CheckTimestamp(); CheckInt16(2); // vgroups + CheckInt32(0); // ntables CheckInt16(1); // replica CheckInt16(1); // quorum CheckInt16(10); // days @@ -147,6 +149,7 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) { CheckBinary("d1", TSDB_DB_NAME_LEN - 1); CheckTimestamp(); CheckInt16(2); // vgroups + CheckInt32(0); CheckInt16(1); // replica CheckInt16(2); // quorum CheckInt16(10); // days @@ -166,7 +169,7 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) { test.Restart(); test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, ""); - CHECK_META("show databases", 17); + CHECK_META("show databases", 18); test.SendShowRetrieveMsg(); EXPECT_EQ(test.GetShowRows(), 1); @@ -174,6 +177,7 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) { CheckBinary("d1", TSDB_DB_NAME_LEN - 1); CheckTimestamp(); CheckInt16(2); // vgroups + CheckInt32(0); CheckInt16(1); // replica CheckInt16(2); // quorum CheckInt16(10); // days @@ -201,7 +205,7 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) { } test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, ""); - CHECK_META("show databases", 17); + CHECK_META("show databases", 18); test.SendShowRetrieveMsg(); EXPECT_EQ(test.GetShowRows(), 0); @@ -239,7 +243,7 @@ TEST_F(DndTestDb, 03_Create_Use_Restart_Use_Db) { } test.SendShowMetaMsg(TSDB_MGMT_TABLE_DB, ""); - CHECK_META("show databases", 17); + CHECK_META("show databases", 18); test.SendShowRetrieveMsg(); EXPECT_EQ(test.GetShowRows(), 1); diff --git a/source/dnode/mgmt/impl/test/mnode/CMakeLists.txt b/source/dnode/mgmt/impl/test/mnode/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..d6b3b16fb68743aa3c9503fcdc83369ab433c953 --- /dev/null +++ b/source/dnode/mgmt/impl/test/mnode/CMakeLists.txt @@ -0,0 +1,11 @@ +aux_source_directory(. MTEST_SRC) +add_executable(dnode_test_mnode ${MTEST_SRC}) +target_link_libraries( + dnode_test_mnode + PUBLIC sut +) + +add_test( + NAME dnode_test_mnode + COMMAND dnode_test_mnode +) diff --git a/source/dnode/mgmt/impl/test/mnode/mnode.cpp b/source/dnode/mgmt/impl/test/mnode/mnode.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6724c8550036b22508e5398834e4561afefd0a8c --- /dev/null +++ b/source/dnode/mgmt/impl/test/mnode/mnode.cpp @@ -0,0 +1,300 @@ +/** + * @file dnode.cpp + * @author slguan (slguan@taosdata.com) + * @brief DNODE module dnode-msg tests + * @version 0.1 + * @date 2021-12-15 + * + * @copyright Copyright (c) 2021 + * + */ + +#include "base.h" + +class DndTestMnode : public ::testing::Test { + public: + void SetUp() override {} + void TearDown() override {} + + public: + static void SetUpTestSuite() { + test.Init("/tmp/dnode_test_mnode1", 9061); + const char* fqdn = "localhost"; + const char* firstEp = "localhost:9061"; + + server2.Start("/tmp/dnode_test_mnode2", fqdn, 9062, firstEp); + server3.Start("/tmp/dnode_test_mnode3", fqdn, 9063, firstEp); + server4.Start("/tmp/dnode_test_mnode4", fqdn, 9064, firstEp); + server5.Start("/tmp/dnode_test_mnode5", fqdn, 9065, firstEp); + taosMsleep(300); + } + + static void TearDownTestSuite() { + server2.Stop(); + server3.Stop(); + server4.Stop(); + server5.Stop(); + test.Cleanup(); + } + + static Testbase test; + static TestServer server2; + static TestServer server3; + static TestServer server4; + static TestServer server5; +}; + +Testbase DndTestMnode::test; +TestServer DndTestMnode::server2; +TestServer DndTestMnode::server3; +TestServer DndTestMnode::server4; +TestServer DndTestMnode::server5; + +TEST_F(DndTestMnode, 01_ShowDnode) { + test.SendShowMetaMsg(TSDB_MGMT_TABLE_MNODE, ""); + CHECK_META("show mnodes", 5); + + CHECK_SCHEMA(0, TSDB_DATA_TYPE_SMALLINT, 2, "id"); + CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, TSDB_EP_LEN + VARSTR_HEADER_SIZE, "endpoint"); + CHECK_SCHEMA(2, TSDB_DATA_TYPE_BINARY, 12 + VARSTR_HEADER_SIZE, "role"); + CHECK_SCHEMA(3, TSDB_DATA_TYPE_TIMESTAMP, 8, "role_time"); + CHECK_SCHEMA(4, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time"); + + test.SendShowRetrieveMsg(); + EXPECT_EQ(test.GetShowRows(), 1); + + CheckInt16(1); + CheckBinary("localhost:9061", TSDB_EP_LEN); + CheckBinary("master", 12); + CheckInt64(0); + CheckTimestamp(); +} + +TEST_F(DndTestMnode, 02_Create_Mnode_Invalid_Id) { + { + int32_t contLen = sizeof(SCreateMnodeMsg); + + SCreateMnodeMsg* pReq = (SCreateMnodeMsg*)rpcMallocCont(contLen); + pReq->dnodeId = htonl(1); + + SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_MNODE, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MNODE_ALREADY_EXIST); + } +} + +TEST_F(DndTestMnode, 03_Create_Mnode_Invalid_Id) { + { + int32_t contLen = sizeof(SCreateMnodeMsg); + + SCreateMnodeMsg* pReq = (SCreateMnodeMsg*)rpcMallocCont(contLen); + pReq->dnodeId = htonl(2); + + SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_MNODE, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_DNODE_NOT_EXIST); + } +} + +TEST_F(DndTestMnode, 04_Create_Mnode) { + { + // create dnode + int32_t contLen = sizeof(SCreateDnodeMsg); + + SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen); + strcpy(pReq->ep, "localhost:9062"); + + SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, 0); + + taosMsleep(1300); + test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, ""); + test.SendShowRetrieveMsg(); + EXPECT_EQ(test.GetShowRows(), 2); + } + + { + // create mnode + int32_t contLen = sizeof(SCreateMnodeMsg); + + SCreateMnodeMsg* pReq = (SCreateMnodeMsg*)rpcMallocCont(contLen); + pReq->dnodeId = htonl(2); + + SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_MNODE, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, 0); + + test.SendShowMetaMsg(TSDB_MGMT_TABLE_MNODE, ""); + test.SendShowRetrieveMsg(); + EXPECT_EQ(test.GetShowRows(), 2); + + CheckInt16(1); + CheckInt16(2); + CheckBinary("localhost:9061", TSDB_EP_LEN); + CheckBinary("localhost:9062", TSDB_EP_LEN); + CheckBinary("master", 12); + CheckBinary("slave", 12); + CheckInt64(0); + CheckInt64(0); + CheckTimestamp(); + CheckTimestamp(); + } + + { + // drop mnode + int32_t contLen = sizeof(SDropMnodeMsg); + + SDropMnodeMsg* pReq = (SDropMnodeMsg*)rpcMallocCont(contLen); + pReq->dnodeId = htonl(2); + + SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_MNODE, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, 0); + + test.SendShowMetaMsg(TSDB_MGMT_TABLE_MNODE, ""); + test.SendShowRetrieveMsg(); + EXPECT_EQ(test.GetShowRows(), 1); + + CheckInt16(1); + CheckBinary("localhost:9061", TSDB_EP_LEN); + CheckBinary("master", 12); + CheckInt64(0); + CheckTimestamp(); + } +} +// { +// int32_t contLen = sizeof(SDropDnodeMsg); + +// SDropDnodeMsg* pReq = (SDropDnodeMsg*)rpcMallocCont(contLen); +// pReq->dnodeId = htonl(2); + +// SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_DROP_DNODE, pReq, contLen); +// ASSERT_NE(pMsg, nullptr); +// ASSERT_EQ(pMsg->code, 0); +// } + +// test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, ""); +// CHECK_META("show dnodes", 7); +// test.SendShowRetrieveMsg(); +// EXPECT_EQ(test.GetShowRows(), 1); + +// CheckInt16(1); +// CheckBinary("localhost:9061", TSDB_EP_LEN); +// CheckInt16(0); +// CheckInt16(1); +// CheckBinary("ready", 10); +// CheckTimestamp(); +// CheckBinary("", 24); + +// { +// int32_t contLen = sizeof(SCreateDnodeMsg); + +// SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen); +// strcpy(pReq->ep, "localhost:9063"); + +// SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen); +// ASSERT_NE(pMsg, nullptr); +// ASSERT_EQ(pMsg->code, 0); +// } + +// { +// int32_t contLen = sizeof(SCreateDnodeMsg); + +// SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen); +// strcpy(pReq->ep, "localhost:9064"); + +// SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen); +// ASSERT_NE(pMsg, nullptr); +// ASSERT_EQ(pMsg->code, 0); +// } + +// { +// int32_t contLen = sizeof(SCreateDnodeMsg); + +// SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(contLen); +// strcpy(pReq->ep, "localhost:9065"); + +// SRpcMsg* pMsg = test.SendMsg(TSDB_MSG_TYPE_CREATE_DNODE, pReq, contLen); +// ASSERT_NE(pMsg, nullptr); +// ASSERT_EQ(pMsg->code, 0); +// } + +// taosMsleep(1300); +// test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, ""); +// CHECK_META("show dnodes", 7); +// test.SendShowRetrieveMsg(); +// EXPECT_EQ(test.GetShowRows(), 4); + +// CheckInt16(1); +// CheckInt16(3); +// CheckInt16(4); +// CheckInt16(5); +// CheckBinary("localhost:9061", TSDB_EP_LEN); +// CheckBinary("localhost:9063", TSDB_EP_LEN); +// CheckBinary("localhost:9064", TSDB_EP_LEN); +// CheckBinary("localhost:9065", TSDB_EP_LEN); +// CheckInt16(0); +// CheckInt16(0); +// CheckInt16(0); +// CheckInt16(0); +// CheckInt16(1); +// CheckInt16(1); +// CheckInt16(1); +// CheckInt16(1); +// CheckBinary("ready", 10); +// CheckBinary("ready", 10); +// CheckBinary("ready", 10); +// CheckBinary("ready", 10); +// CheckTimestamp(); +// CheckTimestamp(); +// CheckTimestamp(); +// CheckTimestamp(); +// CheckBinary("", 24); +// CheckBinary("", 24); +// CheckBinary("", 24); +// CheckBinary("", 24); + +// // restart +// uInfo("stop all server"); +// test.Restart(); +// server2.Restart(); +// server3.Restart(); +// server4.Restart(); +// server5.Restart(); + +// taosMsleep(1300); +// test.SendShowMetaMsg(TSDB_MGMT_TABLE_DNODE, ""); +// CHECK_META("show dnodes", 7); +// test.SendShowRetrieveMsg(); +// EXPECT_EQ(test.GetShowRows(), 4); + +// CheckInt16(1); +// CheckInt16(3); +// CheckInt16(4); +// CheckInt16(5); +// CheckBinary("localhost:9061", TSDB_EP_LEN); +// CheckBinary("localhost:9063", TSDB_EP_LEN); +// CheckBinary("localhost:9064", TSDB_EP_LEN); +// CheckBinary("localhost:9065", TSDB_EP_LEN); +// CheckInt16(0); +// CheckInt16(0); +// CheckInt16(0); +// CheckInt16(0); +// CheckInt16(1); +// CheckInt16(1); +// CheckInt16(1); +// CheckInt16(1); +// CheckBinary("ready", 10); +// CheckBinary("ready", 10); +// CheckBinary("ready", 10); +// CheckBinary("ready", 10); +// CheckTimestamp(); +// CheckTimestamp(); +// CheckTimestamp(); +// CheckTimestamp(); +// CheckBinary("", 24); +// CheckBinary("", 24); +// CheckBinary("", 24); +// CheckBinary("", 24); +// } diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index e3097c8b090676c5decee5b5b846fe89730185ed..1d28d8ea2b0990d9e51687e7f488fe6ea1267644 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -305,11 +305,6 @@ typedef struct SMnodeMsg { char db[TSDB_FULL_DB_NAME_LEN]; int32_t acctId; SMnode *pMnode; - int16_t received; - int16_t successed; - int16_t expected; - int16_t retry; - int32_t code; int64_t createdTime; SRpcMsg rpcMsg; int32_t contLen; diff --git a/source/dnode/mnode/impl/inc/mndMnode.h b/source/dnode/mnode/impl/inc/mndMnode.h index 906d11aec2b123a7cffc6a7a9d5fd28a44afe356..5df13915632469075f995fd33c2b36ee79aa9271 100644 --- a/source/dnode/mnode/impl/inc/mndMnode.h +++ b/source/dnode/mnode/impl/inc/mndMnode.h @@ -27,6 +27,7 @@ void mndCleanupMnode(SMnode *pMnode); bool mndIsMnode(SMnode *pMnode, int32_t dnodeId); void mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet); char *mndGetRoleStr(int32_t role); +void mndUpdateMnodeRole(SMnode *pMnode); #ifdef __cplusplus } diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c index 108896c121eeb1d3d93ffd3a1a9c93cc6f413235..7c12714a46f187b52a72794cc221ee76fa4b7c6d 100644 --- a/source/dnode/mnode/impl/src/mndDb.c +++ b/source/dnode/mnode/impl/src/mndDb.c @@ -828,9 +828,9 @@ static int32_t mndProcessUseDbMsg(SMnodeMsg *pMsg) { static int32_t mndProcessSyncDbMsg(SMnodeMsg *pMsg) { SMnode *pMnode = pMsg->pMnode; SSyncDbMsg *pSync = pMsg->rpcMsg.pCont; - SDbObj *pDb = mndAcquireDb(pMnode, pMsg->db); + SDbObj *pDb = mndAcquireDb(pMnode, pSync->db); if (pDb == NULL) { - mError("db:%s, failed to process sync db msg since %s", pMsg->db, terrstr()); + mError("db:%s, failed to process sync db msg since %s", pSync->db, terrstr()); return -1; } @@ -841,9 +841,9 @@ static int32_t mndProcessSyncDbMsg(SMnodeMsg *pMsg) { static int32_t mndProcessCompactDbMsg(SMnodeMsg *pMsg) { SMnode *pMnode = pMsg->pMnode; SCompactDbMsg *pCompact = pMsg->rpcMsg.pCont; - SDbObj *pDb = mndAcquireDb(pMnode, pMsg->db); + SDbObj *pDb = mndAcquireDb(pMnode, pCompact->db); if (pDb == NULL) { - mError("db:%s, failed to process compact db msg since %s", pMsg->db, terrstr()); + mError("db:%s, failed to process compact db msg since %s", pCompact->db, terrstr()); return -1; } @@ -876,6 +876,12 @@ static int32_t mndGetDbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMe pSchema[cols].bytes = htonl(pShow->bytes[cols]); cols++; + pShow->bytes[cols] = 4; + pSchema[cols].type = TSDB_DATA_TYPE_INT; + strcpy(pSchema[cols].name, "ntables"); + pSchema[cols].bytes = htonl(pShow->bytes[cols]); + cols++; + pShow->bytes[cols] = 2; pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT; strcpy(pSchema[cols].name, "replica"); @@ -1017,6 +1023,10 @@ static int32_t mndRetrieveDbs(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int3 *(int16_t *)pWrite = pDb->cfg.numOfVgroups; cols++; + pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; + *(int16_t *)pWrite = 0; // todo + cols++; + pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; *(int16_t *)pWrite = pDb->cfg.replications; cols++; diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c index 869b6e538b711b8782144041c450a410210fb67a..a019c0dc55406aa20841d28180e8104e2657b245 100644 --- a/source/dnode/mnode/impl/src/mndMnode.c +++ b/source/dnode/mnode/impl/src/mndMnode.c @@ -23,14 +23,15 @@ #define TSDB_MNODE_RESERVE_SIZE 64 static int32_t mndCreateDefaultMnode(SMnode *pMnode); -static SSdbRaw *mndMnodeActionEncode(SMnodeObj *pMnodeObj); +static SSdbRaw *mndMnodeActionEncode(SMnodeObj *pObj); static SSdbRow *mndMnodeActionDecode(SSdbRaw *pRaw); -static int32_t mndMnodeActionInsert(SSdb *pSdb, SMnodeObj *pMnodeObj); -static int32_t mndMnodeActionDelete(SSdb *pSdb, SMnodeObj *pMnodeObj); +static int32_t mndMnodeActionInsert(SSdb *pSdb, SMnodeObj *pObj); +static int32_t mndMnodeActionDelete(SSdb *pSdb, SMnodeObj *pObj); static int32_t mndMnodeActionUpdate(SSdb *pSdb, SMnodeObj *pOldMnode, SMnodeObj *pNewMnode); -static int32_t mndProcessCreateMnodeMsg(SMnodeMsg *pMsg); -static int32_t mndProcessDropMnodeMsg(SMnodeMsg *pMsg); +static int32_t mndProcessCreateMnodeReq(SMnodeMsg *pMsg); +static int32_t mndProcessDropMnodeReq(SMnodeMsg *pMsg); static int32_t mndProcessCreateMnodeRsp(SMnodeMsg *pMsg); +static int32_t mndProcessAlterMnodeRsp(SMnodeMsg *pMsg); static int32_t mndProcessDropMnodeRsp(SMnodeMsg *pMsg); static int32_t mndGetMnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta); static int32_t mndRetrieveMnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows); @@ -46,9 +47,10 @@ int32_t mndInitMnode(SMnode *pMnode) { .updateFp = (SdbUpdateFp)mndMnodeActionUpdate, .deleteFp = (SdbDeleteFp)mndMnodeActionDelete}; - mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_MNODE, mndProcessCreateMnodeMsg); - mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_MNODE, mndProcessDropMnodeMsg); + mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_MNODE, mndProcessCreateMnodeReq); + mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_MNODE, mndProcessDropMnodeReq); mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_CREATE_MNODE_IN_RSP, mndProcessCreateMnodeRsp); + mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_ALTER_MNODE_IN_RSP, mndProcessAlterMnodeRsp); mndSetMsgHandle(pMnode, TSDB_MSG_TYPE_DROP_MNODE_IN_RSP, mndProcessDropMnodeRsp); mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_MNODE, mndGetMnodeMeta); @@ -69,9 +71,9 @@ static SMnodeObj *mndAcquireMnode(SMnode *pMnode, int32_t mnodeId) { return pObj; } -static void mndReleaseMnode(SMnode *pMnode, SMnodeObj *pMnodeObj) { +static void mndReleaseMnode(SMnode *pMnode, SMnodeObj *pObj) { SSdb *pSdb = pMnode->pSdb; - sdbRelease(pSdb, pMnodeObj); + sdbRelease(pSdb, pObj); } char *mndGetRoleStr(int32_t showType) { @@ -87,6 +89,24 @@ char *mndGetRoleStr(int32_t showType) { } } +void mndUpdateMnodeRole(SMnode *pMnode) { + SSdb *pSdb = pMnode->pSdb; + void *pIter = NULL; + while (1) { + SMnodeObj *pObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pObj); + if (pIter == NULL) break; + + if (pObj->id == 1) { + pObj->role = TAOS_SYNC_STATE_LEADER; + } else { + pObj->role = TAOS_SYNC_STATE_CANDIDATE; + } + + sdbRelease(pSdb, pObj); + } +} + static int32_t mndCreateDefaultMnode(SMnode *pMnode) { SMnodeObj mnodeObj = {0}; mnodeObj.id = 1; @@ -101,14 +121,14 @@ static int32_t mndCreateDefaultMnode(SMnode *pMnode) { return sdbWrite(pMnode->pSdb, pRaw); } -static SSdbRaw *mndMnodeActionEncode(SMnodeObj *pMnodeObj) { +static SSdbRaw *mndMnodeActionEncode(SMnodeObj *pObj) { SSdbRaw *pRaw = sdbAllocRaw(SDB_MNODE, TSDB_MNODE_VER_NUMBER, sizeof(SMnodeObj) + TSDB_MNODE_RESERVE_SIZE); if (pRaw == NULL) return NULL; int32_t dataPos = 0; - SDB_SET_INT32(pRaw, dataPos, pMnodeObj->id); - SDB_SET_INT64(pRaw, dataPos, pMnodeObj->createdTime) - SDB_SET_INT64(pRaw, dataPos, pMnodeObj->updateTime) + SDB_SET_INT32(pRaw, dataPos, pObj->id); + SDB_SET_INT64(pRaw, dataPos, pObj->createdTime) + SDB_SET_INT64(pRaw, dataPos, pObj->updateTime) SDB_SET_RESERVE(pRaw, dataPos, TSDB_MNODE_RESERVE_SIZE) return pRaw; @@ -125,42 +145,38 @@ static SSdbRow *mndMnodeActionDecode(SSdbRaw *pRaw) { } SSdbRow *pRow = sdbAllocRow(sizeof(SMnodeObj)); - SMnodeObj *pMnodeObj = sdbGetRowObj(pRow); - if (pMnodeObj == NULL) return NULL; + SMnodeObj *pObj = sdbGetRowObj(pRow); + if (pObj == NULL) return NULL; int32_t dataPos = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &pMnodeObj->id) - SDB_GET_INT64(pRaw, pRow, dataPos, &pMnodeObj->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pMnodeObj->updateTime) + SDB_GET_INT32(pRaw, pRow, dataPos, &pObj->id) + SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->createdTime) + SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->updateTime) SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_MNODE_RESERVE_SIZE) return pRow; } -static void mnodeResetMnode(SMnodeObj *pMnodeObj) { - pMnodeObj->role = TAOS_SYNC_STATE_FOLLOWER; - pMnodeObj->roleTerm = 0; - pMnodeObj->roleTime = 0; -} +static void mnodeResetMnode(SMnodeObj *pObj) { pObj->role = TAOS_SYNC_STATE_FOLLOWER; } -static int32_t mndMnodeActionInsert(SSdb *pSdb, SMnodeObj *pMnodeObj) { - mTrace("mnode:%d, perform insert action", pMnodeObj->id); - pMnodeObj->pDnode = sdbAcquire(pSdb, SDB_DNODE, &pMnodeObj->id); - if (pMnodeObj->pDnode == NULL) { +static int32_t mndMnodeActionInsert(SSdb *pSdb, SMnodeObj *pObj) { + mTrace("mnode:%d, perform insert action", pObj->id); + pObj->pDnode = sdbAcquire(pSdb, SDB_DNODE, &pObj->id); + if (pObj->pDnode == NULL) { terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; - mError("mnode:%d, failed to perform insert action since %s", pMnodeObj->id, terrstr()); + mError("mnode:%d, failed to perform insert action since %s", pObj->id, terrstr()); return -1; } - mnodeResetMnode(pMnodeObj); + mnodeResetMnode(pObj); return 0; } -static int32_t mndMnodeActionDelete(SSdb *pSdb, SMnodeObj *pMnodeObj) { - mTrace("mnode:%d, perform delete action", pMnodeObj->id); - if (pMnodeObj->pDnode != NULL) { - sdbRelease(pSdb, pMnodeObj->pDnode); - pMnodeObj->pDnode = NULL; +static int32_t mndMnodeActionDelete(SSdb *pSdb, SMnodeObj *pObj) { + mTrace("mnode:%d, perform delete action", pObj->id); + if (pObj->pDnode != NULL) { + sdbRelease(pSdb, pObj->pDnode); + pObj->pDnode = NULL; } return 0; @@ -168,8 +184,6 @@ static int32_t mndMnodeActionDelete(SSdb *pSdb, SMnodeObj *pMnodeObj) { static int32_t mndMnodeActionUpdate(SSdb *pSdb, SMnodeObj *pOldMnode, SMnodeObj *pNewMnode) { mTrace("mnode:%d, perform update action", pOldMnode->id); - pOldMnode->id = pNewMnode->id; - pOldMnode->createdTime = pNewMnode->createdTime; pOldMnode->updateTime = pNewMnode->updateTime; return 0; } @@ -177,12 +191,12 @@ static int32_t mndMnodeActionUpdate(SSdb *pSdb, SMnodeObj *pOldMnode, SMnodeObj bool mndIsMnode(SMnode *pMnode, int32_t dnodeId) { SSdb *pSdb = pMnode->pSdb; - SMnodeObj *pMnodeObj = sdbAcquire(pSdb, SDB_MNODE, &dnodeId); - if (pMnodeObj == NULL) { + SMnodeObj *pObj = sdbAcquire(pSdb, SDB_MNODE, &dnodeId); + if (pObj == NULL) { return false; } - sdbRelease(pSdb, pMnodeObj); + sdbRelease(pSdb, pObj); return true; } @@ -193,14 +207,14 @@ void mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet) { void *pIter = NULL; while (1) { - SMnodeObj *pMnodeObj = NULL; - pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMnodeObj); + SMnodeObj *pObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pObj); if (pIter == NULL) break; - if (pMnodeObj->pDnode == NULL) break; + if (pObj->pDnode == NULL) break; - pEpSet->port[pEpSet->numOfEps] = htons(pMnodeObj->pDnode->port); - tstrncpy(pEpSet->fqdn[pEpSet->numOfEps], pMnodeObj->pDnode->fqdn, TSDB_FQDN_LEN); - if (pMnodeObj->role == TAOS_SYNC_STATE_LEADER) { + pEpSet->port[pEpSet->numOfEps] = htons(pObj->pDnode->port); + memcpy(pEpSet->fqdn[pEpSet->numOfEps], pObj->pDnode->fqdn, TSDB_FQDN_LEN); + if (pObj->role == TAOS_SYNC_STATE_LEADER) { pEpSet->inUse = pEpSet->numOfEps; } @@ -208,54 +222,153 @@ void mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet) { } } -static int32_t mndCreateMnode(SMnode *pMnode, SMnodeMsg *pMsg, SCreateMnodeMsg *pCreate) { +static int32_t mndSetCreateMnodeRedoLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + SSdbRaw *pRedoRaw = mndMnodeActionEncode(pObj); + if (pRedoRaw == NULL) return -1; + if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1; + if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) return -1; + return 0; +} + +static int32_t mndSetCreateMnodeUndoLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + SSdbRaw *pUndoRaw = mndMnodeActionEncode(pObj); + if (pUndoRaw == NULL) return -1; + if (mndTransAppendUndolog(pTrans, pUndoRaw) != 0) return -1; + if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) return -1; + return 0; +} + +static int32_t mndSetCreateMnodeCommitLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + SSdbRaw *pCommitRaw = mndMnodeActionEncode(pObj); + if (pCommitRaw == NULL) return -1; + if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1; + if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1; + return 0; +} + +static int32_t mndSetCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnodeObj *pDnode, SMnodeObj *pObj) { + SSdb *pSdb = pMnode->pSdb; + void *pIter = NULL; + int32_t numOfReplicas = 0; + + SCreateMnodeInMsg createMsg = {0}; + while (1) { + SMnodeObj *pMObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); + if (pIter == NULL) break; + + SReplica *pReplica = &createMsg.replicas[numOfReplicas]; + pReplica->id = htonl(pMObj->id); + pReplica->port = htons(pMObj->pDnode->port); + memcpy(pReplica->fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + numOfReplicas++; + + sdbRelease(pSdb, pMObj); + } + + SReplica *pReplica = &createMsg.replicas[numOfReplicas]; + pReplica->id = htonl(pDnode->id); + pReplica->port = htons(pDnode->port); + memcpy(pReplica->fqdn, pDnode->fqdn, TSDB_FQDN_LEN); + numOfReplicas++; + + createMsg.replica = numOfReplicas; + + while (1) { + SMnodeObj *pMObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); + if (pIter == NULL) break; + + STransAction action = {0}; + + SAlterMnodeInMsg *pMsg = malloc(sizeof(SAlterMnodeInMsg)); + if (pMsg == NULL) { + sdbCancelFetch(pSdb, pIter); + sdbRelease(pSdb, pMObj); + return -1; + } + memcpy(pMsg, &createMsg, sizeof(SAlterMnodeInMsg)); + + pMsg->dnodeId = htonl(pMObj->id); + action.epSet = mndGetDnodeEpset(pMObj->pDnode); + action.pCont = pMsg; + action.contLen = sizeof(SAlterMnodeInMsg); + action.msgType = TSDB_MSG_TYPE_ALTER_MNODE_IN; + + if (mndTransAppendRedoAction(pTrans, &action) != 0) { + free(pMsg); + sdbCancelFetch(pSdb, pIter); + sdbRelease(pSdb, pMObj); + return -1; + } + + sdbRelease(pSdb, pMObj); + } + + { + STransAction action = {0}; + action.epSet = mndGetDnodeEpset(pDnode); + + SCreateMnodeInMsg *pMsg = malloc(sizeof(SCreateMnodeInMsg)); + if (pMsg == NULL) return -1; + memcpy(pMsg, &createMsg, sizeof(SAlterMnodeInMsg)); + pMsg->dnodeId = htonl(pObj->id); + + action.epSet = mndGetDnodeEpset(pDnode); + action.pCont = pMsg; + action.contLen = sizeof(SCreateMnodeInMsg); + action.msgType = TSDB_MSG_TYPE_CREATE_MNODE_IN; + if (mndTransAppendRedoAction(pTrans, &action) != 0) { + free(pMsg); + return -1; + } + } + + return 0; +} + +static int32_t mndCreateMnode(SMnode *pMnode, SMnodeMsg *pMsg, SDnodeObj *pDnode, SCreateMnodeMsg *pCreate) { SMnodeObj mnodeObj = {0}; - mnodeObj.id = 1; // todo + mnodeObj.id = sdbGetMaxId(pMnode->pSdb, SDB_MNODE); mnodeObj.createdTime = taosGetTimestampMs(); mnodeObj.updateTime = mnodeObj.createdTime; - STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle); + int32_t code = -1; + STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, pMsg->rpcMsg.handle); if (pTrans == NULL) { - mError("dnode:%d, failed to create since %s", pCreate->dnodeId, terrstr()); - return -1; + mError("mnode:%d, failed to create since %s", pCreate->dnodeId, terrstr()); + goto CREATE_MNODE_OVER; } - mDebug("trans:%d, used to create dnode:%d", pTrans->id, pCreate->dnodeId); + mDebug("trans:%d, used to create mnode:%d", pTrans->id, pCreate->dnodeId); - SSdbRaw *pRedoRaw = mndMnodeActionEncode(&mnodeObj); - if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) { - mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr()); - mndTransDrop(pTrans); - return -1; + if (mndSetCreateMnodeRedoLogs(pMnode, pTrans, &mnodeObj) != 0) { + mError("trans:%d, failed to set redo log since %s", pTrans->id, terrstr()); + goto CREATE_MNODE_OVER; } - sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING); - SSdbRaw *pUndoRaw = mndMnodeActionEncode(&mnodeObj); - if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) { - mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr()); - mndTransDrop(pTrans); - return -1; + if (mndSetCreateMnodeCommitLogs(pMnode, pTrans, &mnodeObj) != 0) { + mError("trans:%d, failed to set commit log since %s", pTrans->id, terrstr()); + goto CREATE_MNODE_OVER; } - sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED); - SSdbRaw *pCommitRaw = mndMnodeActionEncode(&mnodeObj); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) { - mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr()); - mndTransDrop(pTrans); - return -1; + if (mndSetCreateMnodeRedoActions(pMnode, pTrans, pDnode, &mnodeObj) != 0) { + mError("trans:%d, failed to set redo actions since %s", pTrans->id, terrstr()); + goto CREATE_MNODE_OVER; } - sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); if (mndTransPrepare(pMnode, pTrans) != 0) { mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); - mndTransDrop(pTrans); - return -1; + goto CREATE_MNODE_OVER; } + code = 0; + +CREATE_MNODE_OVER: mndTransDrop(pTrans); - return 0; + return code; } -static int32_t mndProcessCreateMnodeMsg(SMnodeMsg *pMsg) { +static int32_t mndProcessCreateMnodeReq(SMnodeMsg *pMsg) { SMnode *pMnode = pMsg->pMnode; SCreateMnodeMsg *pCreate = pMsg->rpcMsg.pCont; @@ -263,22 +376,23 @@ static int32_t mndProcessCreateMnodeMsg(SMnodeMsg *pMsg) { mDebug("mnode:%d, start to create", pCreate->dnodeId); - SDnodeObj *pDnode = mndAcquireDnode(pMnode, pCreate->dnodeId); - if (pDnode == NULL) { - mError("mnode:%d, dnode not exist", pDnode->id); - terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; + SMnodeObj *pObj = mndAcquireMnode(pMnode, pCreate->dnodeId); + if (pObj != NULL) { + mndReleaseMnode(pMnode, pObj); + mError("mnode:%d, mnode already exist", pObj->id); + terrno = TSDB_CODE_MND_MNODE_ALREADY_EXIST; return -1; } - mndReleaseDnode(pMnode, pDnode); - SMnodeObj *pMnodeObj = mndAcquireMnode(pMnode, pCreate->dnodeId); - if (pMnodeObj != NULL) { - mError("mnode:%d, mnode already exist", pMnodeObj->id); - terrno = TSDB_CODE_MND_MNODE_ALREADY_EXIST; + SDnodeObj *pDnode = mndAcquireDnode(pMnode, pCreate->dnodeId); + if (pDnode == NULL) { + mError("mnode:%d, dnode not exist", pCreate->dnodeId); + terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; return -1; } - int32_t code = mndCreateMnode(pMnode, pMsg, pCreate); + int32_t code = mndCreateMnode(pMnode, pMsg, pDnode, pCreate); + mndReleaseDnode(pMnode, pDnode); if (code != 0) { mError("mnode:%d, failed to create since %s", pCreate->dnodeId, terrstr()); @@ -288,49 +402,140 @@ static int32_t mndProcessCreateMnodeMsg(SMnodeMsg *pMsg) { return TSDB_CODE_MND_ACTION_IN_PROGRESS; } -static int32_t mndDropMnode(SMnode *pMnode, SMnodeMsg *pMsg, SMnodeObj *pMnodeObj) { - STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle); +static int32_t mndSetDropMnodeRedoLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + SSdbRaw *pRedoRaw = mndMnodeActionEncode(pObj); + if (pRedoRaw == NULL) return -1; + if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1; + if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING) != 0) return -1; + return 0; +} + +static int32_t mndSetDropMnodeCommitLogs(SMnode *pMnode, STrans *pTrans, SMnodeObj *pObj) { + SSdbRaw *pCommitRaw = mndMnodeActionEncode(pObj); + if (pCommitRaw == NULL) return -1; + if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1; + if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1; + return 0; +} + +static int32_t mndSetDropMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnodeObj *pDnode, SMnodeObj *pObj) { + SSdb *pSdb = pMnode->pSdb; + void *pIter = NULL; + int32_t numOfReplicas = 0; + + SAlterMnodeInMsg alterMsg = {0}; + while (1) { + SMnodeObj *pMObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); + if (pIter == NULL) break; + + if (pMObj->id != pObj->id) { + SReplica *pReplica = &alterMsg.replicas[numOfReplicas]; + pReplica->id = htonl(pMObj->id); + pReplica->port = htons(pMObj->pDnode->port); + memcpy(pReplica->fqdn, pMObj->pDnode->fqdn, TSDB_FQDN_LEN); + numOfReplicas++; + } + + sdbRelease(pSdb, pMObj); + } + + alterMsg.replica = numOfReplicas; + + while (1) { + SMnodeObj *pMObj = NULL; + pIter = sdbFetch(pSdb, SDB_MNODE, pIter, (void **)&pMObj); + if (pIter == NULL) break; + if (pMObj->id != pObj->id) { + STransAction action = {0}; + + SAlterMnodeInMsg *pMsg = malloc(sizeof(SAlterMnodeInMsg)); + if (pMsg == NULL) { + sdbCancelFetch(pSdb, pIter); + sdbRelease(pSdb, pMObj); + return -1; + } + memcpy(pMsg, &alterMsg, sizeof(SAlterMnodeInMsg)); + + pMsg->dnodeId = htonl(pMObj->id); + action.epSet = mndGetDnodeEpset(pMObj->pDnode); + action.pCont = pMsg; + action.contLen = sizeof(SAlterMnodeInMsg); + action.msgType = TSDB_MSG_TYPE_ALTER_MNODE_IN; + + if (mndTransAppendRedoAction(pTrans, &action) != 0) { + free(pMsg); + sdbCancelFetch(pSdb, pIter); + sdbRelease(pSdb, pMObj); + return -1; + } + } + + sdbRelease(pSdb, pMObj); + } + + { + STransAction action = {0}; + action.epSet = mndGetDnodeEpset(pDnode); + + SDropMnodeInMsg *pMsg = malloc(sizeof(SDropMnodeInMsg)); + if (pMsg == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; + } + pMsg->dnodeId = htonl(pObj->id); + + action.epSet = mndGetDnodeEpset(pDnode); + action.pCont = pMsg; + action.contLen = sizeof(SDropMnodeInMsg); + action.msgType = TSDB_MSG_TYPE_DROP_MNODE_IN; + if (mndTransAppendRedoAction(pTrans, &action) != 0) { + free(pMsg); + return -1; + } + } + + return 0; +} + +static int32_t mndDropMnode(SMnode *pMnode, SMnodeMsg *pMsg, SMnodeObj *pObj) { + int32_t code = -1; + STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, pMsg->rpcMsg.handle); if (pTrans == NULL) { - mError("mnode:%d, failed to drop since %s", pMnodeObj->id, terrstr()); - return -1; + mError("mnode:%d, failed to drop since %s", pObj->id, terrstr()); + goto DROP_MNODE_OVER; } - mDebug("trans:%d, used to drop user:%d", pTrans->id, pMnodeObj->id); - SSdbRaw *pRedoRaw = mndMnodeActionEncode(pMnodeObj); - if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) { - mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr()); - mndTransDrop(pTrans); - return -1; + mDebug("trans:%d, used to drop mnode:%d", pTrans->id, pObj->id); + + if (mndSetDropMnodeRedoLogs(pMnode, pTrans, pObj) != 0) { + mError("trans:%d, failed to set redo log since %s", pTrans->id, terrstr()); + goto DROP_MNODE_OVER; } - sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING); - SSdbRaw *pUndoRaw = mndMnodeActionEncode(pMnodeObj); - if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) { - mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr()); - mndTransDrop(pTrans); - return -1; + if (mndSetDropMnodeCommitLogs(pMnode, pTrans, pObj) != 0) { + mError("trans:%d, failed to set commit log since %s", pTrans->id, terrstr()); + goto DROP_MNODE_OVER; } - sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY); - SSdbRaw *pCommitRaw = mndMnodeActionEncode(pMnodeObj); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) { - mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr()); - mndTransDrop(pTrans); - return -1; + if (mndSetDropMnodeRedoActions(pMnode, pTrans, pObj->pDnode, pObj) != 0) { + mError("trans:%d, failed to set redo actions since %s", pTrans->id, terrstr()); + goto DROP_MNODE_OVER; } - sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED); if (mndTransPrepare(pMnode, pTrans) != 0) { mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); - mndTransDrop(pTrans); - return -1; + goto DROP_MNODE_OVER; } + code = 0; + +DROP_MNODE_OVER: mndTransDrop(pTrans); - return 0; + return code; } -static int32_t mndProcessDropMnodeMsg(SMnodeMsg *pMsg) { +static int32_t mndProcessDropMnodeReq(SMnodeMsg *pMsg) { SMnode *pMnode = pMsg->pMnode; SDropMnodeMsg *pDrop = pMsg->rpcMsg.pCont; pDrop->dnodeId = htonl(pDrop->dnodeId); @@ -343,14 +548,14 @@ static int32_t mndProcessDropMnodeMsg(SMnodeMsg *pMsg) { return -1; } - SMnodeObj *pMnodeObj = mndAcquireMnode(pMnode, pDrop->dnodeId); - if (pMnodeObj == NULL) { + SMnodeObj *pObj = mndAcquireMnode(pMnode, pDrop->dnodeId); + if (pObj == NULL) { mError("mnode:%d, not exist", pDrop->dnodeId); terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; return -1; } - int32_t code = mndDropMnode(pMnode, pMsg, pMnodeObj); + int32_t code = mndDropMnode(pMnode, pMsg, pObj); if (code != 0) { mError("mnode:%d, failed to drop since %s", pMnode->dnodeId, terrstr()); @@ -361,9 +566,20 @@ static int32_t mndProcessDropMnodeMsg(SMnodeMsg *pMsg) { return TSDB_CODE_MND_ACTION_IN_PROGRESS; } -static int32_t mndProcessCreateMnodeRsp(SMnodeMsg *pMsg) { return 0; } +static int32_t mndProcessCreateMnodeRsp(SMnodeMsg *pMsg) { + mndTransHandleActionRsp(pMsg); + return 0; +} + +static int32_t mndProcessAlterMnodeRsp(SMnodeMsg *pMsg) { + mndTransHandleActionRsp(pMsg); + return 0; +} -static int32_t mndProcessDropMnodeRsp(SMnodeMsg *pMsg) { return 0; } +static int32_t mndProcessDropMnodeRsp(SMnodeMsg *pMsg) { + mndTransHandleActionRsp(pMsg); + return 0; +} static int32_t mndGetMnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) { SMnode *pMnode = pMsg->pMnode; @@ -414,6 +630,7 @@ static int32_t mndGetMnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg * pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; strcpy(pMeta->tbFname, mndShowStr(pShow->type)); + mndUpdateMnodeRole(pMnode); return 0; } @@ -422,46 +639,39 @@ static int32_t mndRetrieveMnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, i SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; int32_t cols = 0; - SMnodeObj *pMnodeObj = NULL; + SMnodeObj *pObj = NULL; char *pWrite; while (numOfRows < rows) { - pShow->pIter = sdbFetch(pSdb, SDB_MNODE, pShow->pIter, (void **)&pMnodeObj); + pShow->pIter = sdbFetch(pSdb, SDB_MNODE, pShow->pIter, (void **)&pObj); if (pShow->pIter == NULL) break; cols = 0; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int16_t *)pWrite = pMnodeObj->id; + *(int16_t *)pWrite = pObj->id; cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - - SDnodeObj *pDnode = mndAcquireDnode(pMnode, pMnodeObj->id); - if (pDnode != NULL) { - STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pDnode->ep, pShow->bytes[cols]); - } else { - STR_WITH_MAXSIZE_TO_VARSTR(pWrite, "invalid ep", pShow->bytes[cols]); - } - mndReleaseDnode(pMnode, pDnode); + STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pObj->pDnode->ep, pShow->bytes[cols]); cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - char *roles = mndGetRoleStr(pMnodeObj->role); + char *roles = mndGetRoleStr(pObj->role); STR_WITH_MAXSIZE_TO_VARSTR(pWrite, roles, pShow->bytes[cols]); cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int64_t *)pWrite = pMnodeObj->roleTime; + *(int64_t *)pWrite = pObj->roleTime; cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int64_t *)pWrite = pMnodeObj->createdTime; + *(int64_t *)pWrite = pObj->createdTime; cols++; numOfRows++; - sdbRelease(pSdb, pMnodeObj); + sdbRelease(pSdb, pObj); } mndVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow); diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index d99e4d095eabcc6e9db460adb92ebb833ad06c23..72bd2815c1527a4923d02e878336cd1dc2293a25 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -492,7 +492,6 @@ static int32_t mndProcessCreateStbMsg(SMnodeMsg *pMsg) { mError("stb:%s, failed to create since %s", pCreate->name, terrstr()); return -1; } - sdbRelease(pMnode->pSdb, pTopic); SDbObj *pDb = mndAcquireDbByStb(pMnode, pCreate->name); if (pDb == NULL) { diff --git a/source/dnode/mnode/impl/src/mndSync.c b/source/dnode/mnode/impl/src/mndSync.c index 59161b32f290ff7c2eb9c4b724c8d43257f51ca0..5e9165f8980ae9946f86273c6931481a85a49145 100644 --- a/source/dnode/mnode/impl/src/mndSync.c +++ b/source/dnode/mnode/impl/src/mndSync.c @@ -33,4 +33,7 @@ int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw) { return code; } -bool mndIsMaster(SMnode *pMnode) { return true; } \ No newline at end of file +bool mndIsMaster(SMnode *pMnode) { + // pMnode->role = TAOS_SYNC_STATE_LEADER; + return true; +} \ No newline at end of file diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c index 6d5ff9641987bcc03f0f25e008324d828b24c2e6..653c3c65fb22baa0c641c4d6910475adf64cd7c3 100644 --- a/source/dnode/mnode/impl/src/mndTopic.c +++ b/source/dnode/mnode/impl/src/mndTopic.c @@ -444,7 +444,6 @@ static int32_t mndProcessCreateTopicMsg(SMnodeMsg *pMsg) { mError("topic:%s, failed to create since %s", pCreate->name, terrstr()); return -1; } - sdbRelease(pMnode->pSdb, pStb); SDbObj *pDb = mndAcquireDbByTopic(pMnode, pCreate->name); if (pDb == NULL) { @@ -647,6 +646,7 @@ static int32_t mndProcessTopicMetaMsg(SMnodeMsg *pMsg) { mDebug("topic:%s, start to retrieve meta", pInfo->tableFname); +#if 0 SDbObj *pDb = mndAcquireDbByTopic(pMnode, pInfo->tableFname); if (pDb == NULL) { terrno = TSDB_CODE_MND_DB_NOT_SELECTED; @@ -661,7 +661,6 @@ static int32_t mndProcessTopicMetaMsg(SMnodeMsg *pMsg) { mError("topic:%s, failed to get meta since %s", pInfo->tableFname, terrstr()); return -1; } -#if 0 taosRLockLatch(&pTopic->lock); int32_t totalCols = pTopic->numOfColumns + pTopic->numOfTags; diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index 54cd6ab501a0a9294b0f35e575c365d44e14b7bd..53e3bc52036dee574f43dcd96889146bdc312445 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -622,10 +622,10 @@ void mndTransHandleActionRsp(SMnodeMsg *pMsg) { STransAction *pAction = taosArrayGet(pArray, action); if (pAction != NULL) { pAction->msgReceived = 1; - pAction->errCode = pMsg->code; + pAction->errCode = pMsg->rpcMsg.code; } - mDebug("trans:%d, action:%d response is received, code:0x%x", transId, action, pMsg->code); + mDebug("trans:%d, action:%d response is received, code:0x%x", transId, action, pMsg->rpcMsg.code); mndTransExecute(pMnode, pTrans); HANDLE_ACTION_RSP_OVER: @@ -696,7 +696,7 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA for (int32_t action = 0; action < numOfActions; ++action) { STransAction *pAction = taosArrayGet(pArray, action); if (pAction == NULL) continue; - if (pAction->msgSent) continue; + if (pAction->msgReceived && pAction->errCode == 0) continue; int64_t signature = pTrans->id; signature = (signature << 32); @@ -736,6 +736,7 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA terrno = errorCode; return errorCode; } else { + mDebug("trans:%d, %d of %d actions executed, code:0x%x", pTrans->id, numOfReceivedMsgs, numOfActions, errorCode); return TSDB_CODE_MND_ACTION_IN_PROGRESS; } } diff --git a/source/dnode/mnode/impl/src/mnode.c b/source/dnode/mnode/impl/src/mnode.c index fb0b95dc4a696f9a7b2751f3735d73d059838c60..a62a0a9296c120bb0d34c18461f10f1a18f4e0a5 100644 --- a/source/dnode/mnode/impl/src/mnode.c +++ b/source/dnode/mnode/impl/src/mnode.c @@ -178,8 +178,10 @@ static int32_t mndExecSteps(SMnode *pMnode) { // (*pMnode->reportProgress)(pStep->name, "start initialize"); if ((*pStep->initFp)(pMnode) != 0) { + int32_t code = terrno; mError("step:%s exec failed since %s, start to cleanup", pStep->name, terrstr()); mndCleanupSteps(pMnode, pos); + terrno = code; return -1; } else { mDebug("step:%s is initialized", pStep->name); diff --git a/source/dnode/mnode/sdb/src/sdb.c b/source/dnode/mnode/sdb/src/sdb.c index 77614e399e1c8940b7b3eada86ce28b798f16732..bb0e606463dcacd209692f5bdcf41f53600e6ee8 100644 --- a/source/dnode/mnode/sdb/src/sdb.c +++ b/source/dnode/mnode/sdb/src/sdb.c @@ -16,6 +16,8 @@ #define _DEFAULT_SOURCE #include "sdbInt.h" +static int32_t sdbCreateDir(SSdb *pSdb); + SSdb *sdbInit(SSdbOpt *pOption) { mDebug("start to init sdb in %s", pOption->path); @@ -40,6 +42,11 @@ SSdb *sdbInit(SSdbOpt *pOption) { return NULL; } + if (sdbCreateDir(pSdb) != 0) { + sdbCleanup(pSdb); + return NULL; + } + for (ESdbType i = 0; i < SDB_MAX; ++i) { taosInitRWLatch(&pSdb->locks[i]); } @@ -53,8 +60,8 @@ void sdbCleanup(SSdb *pSdb) { mDebug("start to cleanup sdb"); // if (pSdb->curVer != pSdb->lastCommitVer) { - mDebug("write sdb file for curVer:% " PRId64 " and lastVer:%" PRId64, pSdb->curVer, pSdb->lastCommitVer); - sdbWriteFile(pSdb); + mDebug("write sdb file for curVer:% " PRId64 " and lastVer:%" PRId64, pSdb->curVer, pSdb->lastCommitVer); + sdbWriteFile(pSdb); // } if (pSdb->currDir != NULL) { @@ -133,4 +140,26 @@ int32_t sdbSetTable(SSdb *pSdb, SSdbTable table) { mDebug("sdb table:%d is initialized", sdbType); return 0; -} \ No newline at end of file +} + +static int32_t sdbCreateDir(SSdb *pSdb) { + if (taosMkDir(pSdb->currDir) != 0) { + terrno = TAOS_SYSTEM_ERROR(errno); + mError("failed to create dir:%s since %s", pSdb->currDir, terrstr()); + return -1; + } + + if (taosMkDir(pSdb->syncDir) != 0) { + terrno = TAOS_SYSTEM_ERROR(errno); + mError("failed to create dir:%s since %s", pSdb->syncDir, terrstr()); + return -1; + } + + if (taosMkDir(pSdb->tmpDir) != 0) { + terrno = TAOS_SYSTEM_ERROR(errno); + mError("failed to create dir:%s since %s", pSdb->tmpDir, terrstr()); + return -1; + } + + return 0; +} diff --git a/source/dnode/mnode/sdb/src/sdbFile.c b/source/dnode/mnode/sdb/src/sdbFile.c index af37e9e1d5a60f8a609304ddcc956e30f9ef7d31..7828e39e566cdc62fcdecdabbae6b0aa52414605 100644 --- a/source/dnode/mnode/sdb/src/sdbFile.c +++ b/source/dnode/mnode/sdb/src/sdbFile.c @@ -17,28 +17,6 @@ #include "sdbInt.h" #include "tchecksum.h" -static int32_t sdbCreateDir(SSdb *pSdb) { - if (taosMkDir(pSdb->currDir) != 0) { - terrno = TAOS_SYSTEM_ERROR(errno); - mError("failed to create dir:%s since %s", pSdb->currDir, terrstr()); - return -1; - } - - if (taosMkDir(pSdb->syncDir) != 0) { - terrno = TAOS_SYSTEM_ERROR(errno); - mError("failed to create dir:%s since %s", pSdb->syncDir, terrstr()); - return -1; - } - - if (taosMkDir(pSdb->tmpDir) != 0) { - terrno = TAOS_SYSTEM_ERROR(errno); - mError("failed to create dir:%s since %s", pSdb->tmpDir, terrstr()); - return -1; - } - - return 0; -} - static int32_t sdbRunDeployFp(SSdb *pSdb) { mDebug("start to deploy sdb"); @@ -77,7 +55,7 @@ int32_t sdbReadFile(SSdb *pSdb) { free(pRaw); terrno = TAOS_SYSTEM_ERROR(errno); mError("failed to read file:%s since %s", file, terrstr()); - return -1; + return 0; } while (1) { @@ -225,10 +203,6 @@ int32_t sdbWriteFile(SSdb *pSdb) { } int32_t sdbDeploy(SSdb *pSdb) { - if (sdbCreateDir(pSdb) != 0) { - return -1; - } - if (sdbRunDeployFp(pSdb) != 0) { return -1; } diff --git a/source/dnode/vnode/impl/CMakeLists.txt b/source/dnode/vnode/impl/CMakeLists.txt index 6972605afd9c1dd93b7fd0b3198c3837b5351f88..9e892bc4c4393b3f3cd94d51c904349c3569586e 100644 --- a/source/dnode/vnode/impl/CMakeLists.txt +++ b/source/dnode/vnode/impl/CMakeLists.txt @@ -15,9 +15,10 @@ target_link_libraries( PUBLIC wal PUBLIC sync PUBLIC cjson + PUBLIC qworker ) # test if(${BUILD_TEST}) add_subdirectory(test) -endif(${BUILD_TEST}) \ No newline at end of file +endif(${BUILD_TEST}) diff --git a/source/dnode/vnode/impl/inc/vnodeDef.h b/source/dnode/vnode/impl/inc/vnodeDef.h index 605557d4eace479f8cad786c658b2092b3e63d23..c5a57b02a6f67ed06dd457043d47fe5feff91c8e 100644 --- a/source/dnode/vnode/impl/inc/vnodeDef.h +++ b/source/dnode/vnode/impl/inc/vnodeDef.h @@ -34,6 +34,7 @@ #include "vnodeRequest.h" #include "vnodeStateMgr.h" #include "vnodeSync.h" +#include "vnodeQuery.h" #ifdef __cplusplus extern "C" { @@ -72,6 +73,7 @@ struct SVnode { SVnodeSync* pSync; SVnodeFS* pFs; tsem_t canCommit; + void* pQuery; }; int vnodeScheduleTask(SVnodeTask* task); diff --git a/source/dnode/vnode/impl/inc/vnodeQuery.h b/source/dnode/vnode/impl/inc/vnodeQuery.h new file mode 100644 index 0000000000000000000000000000000000000000..59bab42f62cfa98ff925e9c771e4b525e13690f9 --- /dev/null +++ b/source/dnode/vnode/impl/inc/vnodeQuery.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#ifndef _TD_VNODE_READ_H_ +#define _TD_VNODE_READ_H_ + +#ifdef __cplusplus +extern "C" { +#endif +#include "vnodeInt.h" +#include "qworker.h" + +int vnodeQueryOpen(SVnode *pVnode); + +#ifdef __cplusplus +} +#endif + +#endif /*_TD_VNODE_READ_H_*/ diff --git a/source/dnode/vnode/impl/src/vnodeInt.c b/source/dnode/vnode/impl/src/vnodeInt.c index 5deaffe6d220134ac6f8c5f0cfd4607be2ef304a..65185f4a16875ec6dcb301357f4999c281bdd9b0 100644 --- a/source/dnode/vnode/impl/src/vnodeInt.c +++ b/source/dnode/vnode/impl/src/vnodeInt.c @@ -24,16 +24,6 @@ int32_t vnodeSync(SVnode *pVnode) { return 0; } int32_t vnodeGetLoad(SVnode *pVnode, SVnodeLoad *pLoad) { return 0; } -int vnodeProcessQueryReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) { - vInfo("query message is processed"); - return 0; -} - -int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) { - vInfo("fetch message is processed"); - return 0; -} - int vnodeProcessSyncReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) { vInfo("sync message is processed"); return 0; diff --git a/source/dnode/vnode/impl/src/vnodeMain.c b/source/dnode/vnode/impl/src/vnodeMain.c index c98f3e0800eaa0726c29708864040aa5d1a379ca..2b0363c97f2b8b86945a64303e6aac12a72204b9 100644 --- a/source/dnode/vnode/impl/src/vnodeMain.c +++ b/source/dnode/vnode/impl/src/vnodeMain.c @@ -127,6 +127,11 @@ static int vnodeOpenImpl(SVnode *pVnode) { return -1; } + // Open Query + if (vnodeQueryOpen(pVnode)) { + return -1; + } + // TODO return 0; } diff --git a/source/dnode/vnode/impl/src/vnodeQuery.c b/source/dnode/vnode/impl/src/vnodeQuery.c new file mode 100644 index 0000000000000000000000000000000000000000..31481bf7c4710f7cf8b75524c1df602289997ab1 --- /dev/null +++ b/source/dnode/vnode/impl/src/vnodeQuery.c @@ -0,0 +1,35 @@ +/* + * 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 . + */ + +#include "vnodeDef.h" +#include "vnodeQuery.h" + +int vnodeQueryOpen(SVnode *pVnode) { + return qWorkerInit(NULL, &pVnode->pQuery); +} + +int vnodeProcessQueryReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) { + vInfo("query message is processed"); + qWorkerProcessQueryMsg(pVnode, pVnode->pQuery, pMsg); + return 0; +} + +int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) { + vInfo("fetch message is processed"); + qWorkerProcessFetchMsg(pVnode, pVnode->pQuery, pMsg); + return 0; +} + + diff --git a/source/dnode/vnode/meta/inc/metaQuery.h b/source/dnode/vnode/meta/inc/metaQuery.h index 110df8dd4556ce49cbc95d4c0acbe082c289796d..ca3b68b41536a38760ef933ee86dc91ce2c3a509 100644 --- a/source/dnode/vnode/meta/inc/metaQuery.h +++ b/source/dnode/vnode/meta/inc/metaQuery.h @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#ifndef _TD_META_QUERY_H_ -#define _TD_META_QUERY_H_ +#ifndef _VNODE_QUERY_H_ +#define _VNODE_QUERY_H_ #ifdef __cplusplus extern "C" { @@ -24,4 +24,4 @@ extern "C" { } #endif -#endif /*_TD_META_QUERY_H_*/ \ No newline at end of file +#endif /*_VNODE_QUERY_H_*/ \ No newline at end of file diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h index 7b26079f11da10c538514cb4161eb69ba0f3d792..7f2ddb5723eac9c8e6d6cbd279c05ad1ba2506c2 100644 --- a/source/libs/catalog/inc/catalogInt.h +++ b/source/libs/catalog/inc/catalogInt.h @@ -59,8 +59,6 @@ typedef struct SCatalogMgmt { typedef uint32_t (*tableNameHashFp)(const char *, uint32_t); -extern int32_t ctgDebugFlag; - #define ctgFatal(...) do { if (ctgDebugFlag & DEBUG_FATAL) { taosPrintLog("CTG FATAL ", ctgDebugFlag, __VA_ARGS__); }} while(0) #define ctgError(...) do { if (ctgDebugFlag & DEBUG_ERROR) { taosPrintLog("CTG ERROR ", ctgDebugFlag, __VA_ARGS__); }} while(0) #define ctgWarn(...) do { if (ctgDebugFlag & DEBUG_WARN) { taosPrintLog("CTG WARN ", ctgDebugFlag, __VA_ARGS__); }} while(0) @@ -75,7 +73,6 @@ extern int32_t ctgDebugFlag; #define CTG_ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { ctgError(__VA_ARGS__); terrno = _code; return _code; } } while (0) #define CTG_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0) - #ifdef __cplusplus } #endif diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c index e3e84857605733ffab22d8263bc0a18e5353385e..bc7a8b8aff670a5e8a249f4911d47e0b0f244085 100644 --- a/source/libs/catalog/src/catalog.c +++ b/source/libs/catalog/src/catalog.c @@ -371,7 +371,7 @@ int32_t catalogInit(SCatalogCfg *cfg) { return TSDB_CODE_SUCCESS; } -int32_t catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandle) { +int32_t catalogGetHandle(const char* clusterId , struct SCatalog** catalogHandle) { if (NULL == clusterId || NULL == catalogHandle) { CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT); } @@ -565,12 +565,12 @@ _return: } -int32_t catalogGetTableHashVgroup(struct SCatalog *pCatalog, void *pRpc, const SEpSet *pMgmtEps, const char *pDBName, const char *pTableName, SVgroupInfo *pVgroup) { +int32_t catalogGetTableHashVgroup(struct SCatalog *pCatalog, void *pTransporter, const SEpSet *pMgmtEps, const char *pDBName, const char *pTableName, SVgroupInfo *pVgroup) { SDBVgroupInfo dbInfo = {0}; int32_t code = 0; int32_t vgId = 0; - CTG_ERR_RET(catalogGetDBVgroup(pCatalog, pRpc, pMgmtEps, pDBName, false, &dbInfo)); + CTG_ERR_RET(catalogGetDBVgroup(pCatalog, pTransporter, pMgmtEps, pDBName, false, &dbInfo)); if (dbInfo.vgVersion < 0 || NULL == dbInfo.vgInfo) { ctgError("db[%s] vgroup cache invalid, vgroup version:%d, vgInfo:%p", pDBName, dbInfo.vgVersion, dbInfo.vgInfo); diff --git a/source/libs/catalog/test/catalogTests.cpp b/source/libs/catalog/test/catalogTests.cpp index 29c80ae9ec05453dd23605c39d43fa562c2aa2d9..22b5b7adc4d78c563096c0d1e9765d4689a01993 100644 --- a/source/libs/catalog/test/catalogTests.cpp +++ b/source/libs/catalog/test/catalogTests.cpp @@ -29,6 +29,8 @@ #include "catalog.h" #include "tep.h" #include "trpc.h" +#include "stub.h" +#include "addr_any.h" typedef struct SAppInstInfo { int64_t numOfConns; @@ -86,6 +88,27 @@ void sendCreateDbMsg(void *shandle, SEpSet *pEpSet) { ASSERT_EQ(rpcRsp.code, 0); } +void __rpcSendRecv(void *shandle, SEpSet *pEpSet, SRpcMsg *pMsg, SRpcMsg *pRsp) { + SUseDbRsp *rspMsg = NULL; //todo + + return; +} + + +void initTestEnv() { + static Stub stub; + stub.set(rpcSendRecv, __rpcSendRecv); + { + AddrAny any("libtransport.so"); + std::map result; + any.get_global_func_addr_dynsym("^rpcSendRecv$", result); + for (const auto& f : result) { + stub.set(f.second, __rpcSendRecv); + } + } +} + + } TEST(testCase, normalCase) { @@ -99,7 +122,7 @@ TEST(testCase, normalCase) { void *mockPointer = (void *)0x1; SVgroupInfo vgInfo = {0}; - msgInit(); + initQueryModuleMsgHandle(); sendCreateDbMsg(pConn->pTransporter, &pConn->pAppInfo->mgmtEp.epSet); diff --git a/source/libs/index/inc/index_tfile.h b/source/libs/index/inc/index_tfile.h index b19b887e9f86a482634b8c0877c1e4c079ac9f44..416b10bd14c63ebea97b40d80175f033e0e3d7f8 100644 --- a/source/libs/index/inc/index_tfile.h +++ b/source/libs/index/inc/index_tfile.h @@ -42,7 +42,12 @@ typedef struct TFileHeader { #define TFILE_HEADER_SIZE (sizeof(TFileHeader)) #define TFILE_HEADER_NO_FST (TFILE_HEADER_SIZE - sizeof(int32_t)) -//#define TFILE_HADER_PRE_SIZE (sizeof(uint64_t) + sizeof(int32_t) + sizeof(int32_t)) + +typedef struct TFileValue { + char* colVal; // null terminated + SArray* tableId; + int32_t offset; +} TFileValue; typedef struct TFileCacheKey { uint64_t suid; diff --git a/source/libs/index/src/index.c b/source/libs/index/src/index.c index e88cecfd623c86d39ae28c9906c976f60c27927f..f0546afaf591f0f815cb4802f70f73e85ae010c7 100644 --- a/source/libs/index/src/index.c +++ b/source/libs/index/src/index.c @@ -41,7 +41,7 @@ static pthread_once_t isInit = PTHREAD_ONCE_INIT; static void indexInit(); static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* term, SArray** result); -static int indexMergeCacheIntoTindex(SIndex* sIdx); +static int indexFlushCacheToTindex(SIndex* sIdx); static void indexInterResultsDestroy(SArray* results); static int indexMergeFinalResults(SArray* interResults, EIndexOperatorType oType, SArray* finalResult); @@ -49,9 +49,7 @@ static int indexMergeFinalResults(SArray* interResults, EIndexOperatorType oTyp int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) { pthread_once(&isInit, indexInit); SIndex* sIdx = calloc(1, sizeof(SIndex)); - if (sIdx == NULL) { - return -1; - } + if (sIdx == NULL) { return -1; } #ifdef USE_LUCENE index_t* index = index_open(path); @@ -131,9 +129,7 @@ int indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) { int32_t colId = fi->colId; int32_t version = index->cVersion; int ret = indexCachePut(index->cache, p, colId, version, uid); - if (ret != 0) { - return ret; - } + if (ret != 0) { return ret; } } #endif @@ -221,9 +217,7 @@ void indexOptsDestroy(SIndexOpts* opts){ SIndexMultiTermQuery* indexMultiTermQueryCreate(EIndexOperatorType opera) { SIndexMultiTermQuery* p = (SIndexMultiTermQuery*)malloc(sizeof(SIndexMultiTermQuery)); - if (p == NULL) { - return NULL; - } + if (p == NULL) { return NULL; } p->opera = opera; p->query = taosArrayInit(4, sizeof(SIndexTermQuery)); return p; @@ -250,9 +244,7 @@ SIndexTerm* indexTermCreate(int64_t suid, const char* colVal, int32_t nColVal) { SIndexTerm* t = (SIndexTerm*)calloc(1, (sizeof(SIndexTerm))); - if (t == NULL) { - return NULL; - } + if (t == NULL) { return NULL; } t->suid = suid; t->operType = oper; @@ -332,9 +324,7 @@ static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** result return 0; } static void indexInterResultsDestroy(SArray* results) { - if (results == NULL) { - return; - } + if (results == NULL) { return; } size_t sz = taosArrayGetSize(results); for (size_t i = 0; i < sz; i++) { @@ -363,10 +353,10 @@ static int indexMergeFinalResults(SArray* interResults, EIndexOperatorType oType } return 0; } -static int indexMergeCacheIntoTindex(SIndex* sIdx) { - if (sIdx == NULL) { - return -1; - } +static int indexFlushCacheToTindex(SIndex* sIdx) { + if (sIdx == NULL) { return -1; } + indexWarn("suid %" PRIu64 " merge cache into tindex", sIdx->suid); + return 0; } diff --git a/source/libs/index/src/index_cache.c b/source/libs/index/src/index_cache.c index 6170642707434b4daaf22bc14c9f8058f841e611..bb6a5e048af60a4822716395baa094a1c9cec600 100644 --- a/source/libs/index/src/index_cache.c +++ b/source/libs/index/src/index_cache.c @@ -151,8 +151,7 @@ int indexCacheSearch(void* cache, SIndexTermQuery* query, int16_t colId, int32_t EIndexQueryType qtype = query->qType; int32_t keyLen = CACHE_KEY_LEN(term); - - char* buf = calloc(1, keyLen); + char* buf = calloc(1, keyLen); if (qtype == QUERY_TERM) { // } else if (qtype == QUERY_PREFIX) { diff --git a/source/libs/index/src/index_fst_counting_writer.c b/source/libs/index/src/index_fst_counting_writer.c index 962973bb5cd6fa47c0635ac5a4e5d8fa708dbfa5..c8fbdd7690bc3ec0243a01dab89fb53d959854f2 100644 --- a/source/libs/index/src/index_fst_counting_writer.c +++ b/source/libs/index/src/index_fst_counting_writer.c @@ -69,9 +69,9 @@ WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int // ugly code, refactor later ctx->file.readOnly = readOnly; if (readOnly == false) { - ctx->file.fd = tfOpenCreateWriteAppend(tmpFile); + ctx->file.fd = tfOpenCreateWriteAppend(path); } else { - ctx->file.fd = tfOpenReadWrite(tmpFile); + ctx->file.fd = tfOpenReadWrite(path); } if (ctx->file.fd < 0) { indexError("open file error %d", errno); @@ -93,6 +93,7 @@ WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int END: if (ctx->type == TMemory) { free(ctx->mem.buf); } free(ctx); + return NULL; } void writerCtxDestroy(WriterCtx* ctx) { if (ctx->type == TMemory) { diff --git a/source/libs/index/src/index_tfile.c b/source/libs/index/src/index_tfile.c index ecacdcd13c463ef4ffc689534d13737d69f15e1b..9afc29457d58714d0932caebfbbe5e94b67b5689 100644 --- a/source/libs/index/src/index_tfile.c +++ b/source/libs/index/src/index_tfile.c @@ -25,12 +25,7 @@ #define TF_TABLE_TATOAL_SIZE(sz) (sizeof(sz) + sz * sizeof(uint64_t)) -typedef struct TFileValue { - char* colVal; // null terminated - SArray* tableId; - int32_t offset; -} TFileValue; - +static int tfileStrCompare(const void* a, const void* b); static int tfileValueCompare(const void* a, const void* b, const void* param); static void tfileSerialTableIdsToBuf(char* buf, SArray* tableIds); @@ -38,17 +33,18 @@ static int tfileWriteHeader(TFileWriter* writer); static int tfileWriteFstOffset(TFileWriter* tw, int32_t offset); static int tfileWriteData(TFileWriter* write, TFileValue* tval); -static int tfileReadLoadHeader(TFileReader* reader); -static int tfileReadLoadFst(TFileReader* reader); -static int tfileReadLoadTableIds(TFileReader* reader, int32_t offset, SArray* result); -static void tfileReadRef(TFileReader* reader); -static void tfileReadUnRef(TFileReader* reader); +static int tfileReaderLoadHeader(TFileReader* reader); +static int tfileReaderLoadFst(TFileReader* reader); +static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray* result); +static void tfileReaderRef(TFileReader* reader); +static void tfileReaderUnRef(TFileReader* reader); static int tfileGetFileList(const char* path, SArray* result); static int tfileRmExpireFile(SArray* result); static void tfileDestroyFileName(void* elem); static int tfileCompare(const void* a, const void* b); static int tfileParseFileName(const char* filename, uint64_t* suid, int* colId, int* version); +static void tfileGenFileName(char* filename, uint64_t suid, int colId, int version); static void tfileSerialCacheKey(TFileCacheKey* key, char* buf); TFileCache* tfileCacheCreate(const char* path) { @@ -74,23 +70,12 @@ TFileCache* tfileCacheCreate(const char* path) { WriterCtx* wc = writerCtxCreate(TFile, file, true, 1024 * 64); if (wc == NULL) { - indexError("failed to open index: %s", file); + indexError("failed to open index:%s", file); goto End; } TFileReader* reader = tfileReaderCreate(wc); - if (0 != tfileReadLoadHeader(reader)) { - tfileReaderDestroy(reader); - indexError("failed to load index header, index file: %s", file); - goto End; - } - - if (0 != tfileReadLoadFst(reader)) { - tfileReaderDestroy(reader); - indexError("failed to load index fst, index file: %s", file); - goto End; - } - tfileReadRef(reader); + tfileReaderRef(reader); // loader fst and validate it TFileHeader* header = &reader->header; TFileCacheKey key = {.suid = header->suid, .colName = header->colName, .nColName = strlen(header->colName), .colType = header->colType}; @@ -115,7 +100,7 @@ void tfileCacheDestroy(TFileCache* tcache) { TFileReader* p = *reader; indexInfo("drop table cache suid: %" PRIu64 ", colName: %s, colType: %d", p->header.suid, p->header.colName, p->header.colType); - tfileReadUnRef(p); + tfileReaderUnRef(p); reader = taosHashIterate(tcache->tableCache, reader); } taosHashCleanup(tcache->tableCache); @@ -127,7 +112,7 @@ TFileReader* tfileCacheGet(TFileCache* tcache, TFileCacheKey* key) { tfileSerialCacheKey(key, buf); TFileReader* reader = taosHashGet(tcache->tableCache, buf, strlen(buf)); - tfileReadRef(reader); + tfileReaderRef(reader); return reader; } @@ -139,10 +124,10 @@ void tfileCachePut(TFileCache* tcache, TFileCacheKey* key, TFileReader* reader) if (*p != NULL) { TFileReader* oldReader = *p; taosHashRemove(tcache->tableCache, buf, strlen(buf)); - tfileReadUnRef(oldReader); + tfileReaderUnRef(oldReader); } - tfileReadRef(reader); + tfileReaderRef(reader); taosHashPut(tcache->tableCache, buf, strlen(buf), &reader, sizeof(void*)); return; } @@ -153,6 +138,19 @@ TFileReader* tfileReaderCreate(WriterCtx* ctx) { // T_REF_INC(reader); reader->ctx = ctx; + + if (0 != tfileReaderLoadHeader(reader)) { + tfileReaderDestroy(reader); + indexError("failed to load index header, suid: %" PRIu64 ", colName: %s", reader->header.suid, reader->header.colName); + return NULL; + } + + if (0 != tfileReaderLoadFst(reader)) { + tfileReaderDestroy(reader); + indexError("failed to load index fst, suid: %" PRIu64 ", colName: %s", reader->header.suid, reader->header.colName); + return NULL; + } + return reader; } void tfileReaderDestroy(TFileReader* reader) { @@ -174,7 +172,7 @@ int tfileReaderSearch(TFileReader* reader, SIndexTermQuery* query, SArray* resul FstSlice key = fstSliceCreate(term->colVal, term->nColVal); if (fstGet(reader->fst, &key, &offset)) { indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, found table info in tindex", term->suid, term->colName, term->colVal); - ret = tfileReadLoadTableIds(reader, offset, result); + ret = tfileReaderLoadTableIds(reader, offset, result); } else { indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, not found table info in tindex", term->suid, term->colName, term->colVal); } @@ -185,7 +183,7 @@ int tfileReaderSearch(TFileReader* reader, SIndexTermQuery* query, SArray* resul } else { // handle later } - tfileReadUnRef(reader); + tfileReaderUnRef(reader); return ret; } @@ -214,11 +212,18 @@ TFileWriter* tfileWriterCreate(WriterCtx* ctx, TFileHeader* header) { int tfileWriterPut(TFileWriter* tw, void* data) { // sort by coltype and write to tindex - __compar_fn_t fn = getComparFunc(tw->header.colType, 0); + __compar_fn_t fn; + + int8_t colType = tw->header.colType; + if (colType == TSDB_DATA_TYPE_BINARY || colType == TSDB_DATA_TYPE_NCHAR) { + fn = tfileStrCompare; + } else { + fn = getComparFunc(colType, 0); + } taosArraySortPWithExt((SArray*)(data), tfileValueCompare, &fn); int32_t bufLimit = 4096, offset = 0; - char* buf = calloc(1, sizeof(bufLimit)); + char* buf = calloc(1, sizeof(char) * bufLimit); char* p = buf; int32_t sz = taosArrayGetSize((SArray*)data); int32_t fstOffset = tw->offset; @@ -259,6 +264,11 @@ int tfileWriterPut(TFileWriter* tw, void* data) { } tfree(buf); + tw->fb = fstBuilderCreate(tw->ctx, 0); + if (tw->fb == NULL) { + tfileWriterDestroy(tw); + return -1; + } // write fst for (size_t i = 0; i < sz; i++) { // TODO, fst batch write later @@ -267,6 +277,9 @@ int tfileWriterPut(TFileWriter* tw, void* data) { // } } + fstBuilderFinish(tw->fb); + fstBuilderDestroy(tw->fb); + tw->fb = NULL; return 0; } void tfileWriterDestroy(TFileWriter* tw) { @@ -305,6 +318,12 @@ int indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid) { return 0; } +static int tfileStrCompare(const void* a, const void* b) { + int ret = strcmp((char*)a, (char*)b); + if (ret == 0) { return ret; } + return ret < 0 ? -1 : 1; +} + static int tfileValueCompare(const void* a, const void* b, const void* param) { __compar_fn_t fn = *(__compar_fn_t*)param; @@ -326,6 +345,7 @@ static int tfileWriteFstOffset(TFileWriter* tw, int32_t offset) { int32_t fstOffset = offset + sizeof(tw->header.fstOffset); tw->header.fstOffset = fstOffset; if (sizeof(fstOffset) != tw->ctx->write(tw->ctx, (char*)&fstOffset, sizeof(fstOffset))) { return -1; } + tw->offset += sizeof(fstOffset); return 0; } static int tfileWriteHeader(TFileWriter* writer) { @@ -355,16 +375,16 @@ static int tfileWriteData(TFileWriter* write, TFileValue* tval) { } return 0; } -static int tfileReadLoadHeader(TFileReader* reader) { +static int tfileReaderLoadHeader(TFileReader* reader) { // TODO simple tfile header later char buf[TFILE_HEADER_SIZE] = {0}; - int64_t nread = reader->ctx->read(reader->ctx, buf, sizeof(buf)); + int64_t nread = reader->ctx->readFrom(reader->ctx, buf, sizeof(buf), 0); assert(nread == sizeof(buf)); memcpy(&reader->header, buf, sizeof(buf)); return 0; } -static int tfileReadLoadFst(TFileReader* reader) { +static int tfileReaderLoadFst(TFileReader* reader) { // current load fst into memory, refactor it later static int FST_MAX_SIZE = 16 * 1024; @@ -381,9 +401,9 @@ static int tfileReadLoadFst(TFileReader* reader) { free(buf); fstSliceDestroy(&st); - return reader->fst == NULL ? 0 : -1; + return reader->fst != NULL ? 0 : -1; } -static int tfileReadLoadTableIds(TFileReader* reader, int32_t offset, SArray* result) { +static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray* result) { int32_t nid; WriterCtx* ctx = reader->ctx; @@ -403,12 +423,12 @@ static int tfileReadLoadTableIds(TFileReader* reader, int32_t offset, SArray* re free(buf); return 0; } -static void tfileReadRef(TFileReader* reader) { +static void tfileReaderRef(TFileReader* reader) { int ref = T_REF_INC(reader); UNUSED(ref); } -static void tfileReadUnRef(TFileReader* reader) { +static void tfileReaderUnRef(TFileReader* reader) { int ref = T_REF_DEC(reader); if (ref == 0) { tfileReaderDestroy(reader); } } @@ -445,6 +465,10 @@ static int tfileCompare(const void* a, const void* b) { return strncmp(aName, bName, aLen > bLen ? aLen : bLen); } // tfile name suid-colId-version.tindex +static void tfileGenFileName(char* filename, uint64_t suid, int colId, int version) { + sprintf(filename, "%" PRIu64 "-%d-%d.tindex", suid, colId, version); + return; +} static int tfileParseFileName(const char* filename, uint64_t* suid, int* colId, int* version) { if (3 == sscanf(filename, "%" PRIu64 "-%d-%d.tindex", suid, colId, version)) { // read suid & colid & version success diff --git a/source/libs/index/test/indexTests.cc b/source/libs/index/test/indexTests.cc index 85d76bb716a887bf7e7b07d54afde9ae67f431de..6c6f45bd115817d5e85d4e173e30fdd745bb6bd0 100644 --- a/source/libs/index/test/indexTests.cc +++ b/source/libs/index/test/indexTests.cc @@ -2,8 +2,7 @@ * 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. + * 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 @@ -13,141 +12,141 @@ * along with this program. If not, see . */ #include -#include #include +#include #include "index.h" -#include "tutil.h" #include "indexInt.h" #include "index_fst.h" -#include "index_fst_util.h" #include "index_fst_counting_writer.h" +#include "index_fst_util.h" +#include "index_tfile.h" +#include "tutil.h" +using namespace std; +class FstWriter { + public: + FstWriter() { + _wc = writerCtxCreate(TFile, "/tmp/tindex", false, 64 * 1024 * 1024); + _b = fstBuilderCreate(NULL, 0); + } + bool Put(const std::string& key, uint64_t val) { + FstSlice skey = fstSliceCreate((uint8_t*)key.c_str(), key.size()); + bool ok = fstBuilderInsert(_b, skey, val); + fstSliceDestroy(&skey); + return ok; + } + ~FstWriter() { + fstBuilderFinish(_b); + fstBuilderDestroy(_b); + writerCtxDestroy(_wc); + } -class FstWriter { - public: - FstWriter() { - _wc = writerCtxCreate(TFile, "/tmp/tindex", false, 0); - _b = fstBuilderCreate(NULL, 0); - } - bool Put(const std::string &key, uint64_t val) { - FstSlice skey = fstSliceCreate((uint8_t *)key.c_str(), key.size()); - bool ok = fstBuilderInsert(_b, skey, val); - fstSliceDestroy(&skey); - return ok; - } - ~FstWriter() { - fstBuilderFinish(_b); - fstBuilderDestroy(_b); - - writerCtxDestroy(_wc); - } - private: - FstBuilder *_b; - WriterCtx *_wc; + private: + FstBuilder* _b; + WriterCtx* _wc; }; class FstReadMemory { - public: - FstReadMemory(size_t size) { - _wc = writerCtxCreate(TFile, "/tmp/tindex", true, 0); - _w = fstCountingWriterCreate(_wc); - _size = size; - memset((void *)&_s, 0, sizeof(_s)); - } - bool init() { - char *buf = (char *)calloc(1, sizeof(char) * _size); - int nRead = fstCountingWriterRead(_w, (uint8_t *)buf, _size); - if (nRead <= 0) { return false; } - _size = nRead; - _s = fstSliceCreate((uint8_t *)buf, _size); - _fst = fstCreate(&_s); - free(buf); - return _fst != NULL; - } - bool Get(const std::string &key, uint64_t *val) { - FstSlice skey = fstSliceCreate((uint8_t *)key.c_str(), key.size()); - bool ok = fstGet(_fst, &skey, val); - fstSliceDestroy(&skey); - return ok; - } - bool GetWithTimeCostUs(const std::string &key, uint64_t *val, uint64_t *elapse) { - int64_t s = taosGetTimestampUs(); - bool ok = this->Get(key, val); - int64_t e = taosGetTimestampUs(); - *elapse = e - s; - return ok; - } - // add later - bool Search(AutomationCtx *ctx, std::vector &result) { - FstStreamBuilder *sb = fstSearch(_fst, ctx); - StreamWithState *st = streamBuilderIntoStream(sb); - StreamWithStateResult *rt = NULL; - - while ((rt = streamWithStateNextWith(st, NULL)) != NULL) { - result.push_back((uint64_t)(rt->out.out)); - } - return true; - } - bool SearchWithTimeCostUs(AutomationCtx *ctx, std::vector &result) { - int64_t s = taosGetTimestampUs(); - bool ok = this->Search(ctx, result); - int64_t e = taosGetTimestampUs(); - return ok; - } - - ~FstReadMemory() { + public: + FstReadMemory(size_t size) { + _wc = writerCtxCreate(TFile, "/tmp/tindex", true, 64 * 1024); + _w = fstCountingWriterCreate(_wc); + _size = size; + memset((void*)&_s, 0, sizeof(_s)); + } + bool init() { + char* buf = (char*)calloc(1, sizeof(char) * _size); + int nRead = fstCountingWriterRead(_w, (uint8_t*)buf, _size); + if (nRead <= 0) { return false; } + _size = nRead; + _s = fstSliceCreate((uint8_t*)buf, _size); + _fst = fstCreate(&_s); + free(buf); + return _fst != NULL; + } + bool Get(const std::string& key, uint64_t* val) { + FstSlice skey = fstSliceCreate((uint8_t*)key.c_str(), key.size()); + bool ok = fstGet(_fst, &skey, val); + fstSliceDestroy(&skey); + return ok; + } + bool GetWithTimeCostUs(const std::string& key, uint64_t* val, uint64_t* elapse) { + int64_t s = taosGetTimestampUs(); + bool ok = this->Get(key, val); + int64_t e = taosGetTimestampUs(); + *elapse = e - s; + return ok; + } + // add later + bool Search(AutomationCtx* ctx, std::vector& result) { + FstStreamBuilder* sb = fstSearch(_fst, ctx); + StreamWithState* st = streamBuilderIntoStream(sb); + StreamWithStateResult* rt = NULL; + + while ((rt = streamWithStateNextWith(st, NULL)) != NULL) { + result.push_back((uint64_t)(rt->out.out)); + } + return true; + } + bool SearchWithTimeCostUs(AutomationCtx* ctx, std::vector& result) { + int64_t s = taosGetTimestampUs(); + bool ok = this->Search(ctx, result); + int64_t e = taosGetTimestampUs(); + return ok; + } + + ~FstReadMemory() { fstCountingWriterDestroy(_w); fstDestroy(_fst); fstSliceDestroy(&_s); writerCtxDestroy(_wc); - } - - private: - FstCountingWriter *_w; - Fst *_fst; - FstSlice _s; - WriterCtx *_wc; - size_t _size; - -}; - -//TEST(IndexTest, index_create_test) { + } + + private: + FstCountingWriter* _w; + Fst* _fst; + FstSlice _s; + WriterCtx* _wc; + size_t _size; +}; + +// TEST(IndexTest, index_create_test) { // SIndexOpts *opts = indexOptsCreate(); // SIndex *index = indexOpen(opts, "./test"); // if (index == NULL) { -// std::cout << "index open failed" << std::endl; +// std::cout << "index open failed" << std::endl; // } // -// -// // write +// +// // write // for (int i = 0; i < 100000; i++) { // SIndexMultiTerm* terms = indexMultiTermCreate(); -// std::string val = "field"; +// std::string val = "field"; // // indexMultiTermAdd(terms, "tag1", strlen("tag1"), val.c_str(), val.size()); // -// val.append(std::to_string(i)); +// val.append(std::to_string(i)); // indexMultiTermAdd(terms, "tag2", strlen("tag2"), val.c_str(), val.size()); // // val.insert(0, std::to_string(i)); // indexMultiTermAdd(terms, "tag3", strlen("tag3"), val.c_str(), val.size()); // -// val.append("const"); +// val.append("const"); // indexMultiTermAdd(terms, "tag4", strlen("tag4"), val.c_str(), val.size()); // -// +// // indexPut(index, terms, i); // indexMultiTermDestroy(terms); -// } -// +// } +// // // // query -// SIndexMultiTermQuery *multiQuery = indexMultiTermQueryCreate(MUST); -// +// SIndexMultiTermQuery *multiQuery = indexMultiTermQueryCreate(MUST); +// // indexMultiTermQueryAdd(multiQuery, "tag1", strlen("tag1"), "field", strlen("field"), QUERY_PREFIX); // indexMultiTermQueryAdd(multiQuery, "tag3", strlen("tag3"), "0field0", strlen("0field0"), QUERY_TERM); // -// SArray *result = (SArray *)taosArrayInit(10, sizeof(int)); +// SArray *result = (SArray *)taosArrayInit(10, sizeof(int)); // indexSearch(index, multiQuery, result); // // std::cout << "taos'size : " << taosArrayGetSize(result) << std::endl; @@ -155,25 +154,24 @@ class FstReadMemory { // int *v = (int *)taosArrayGet(result, i); // std::cout << "value --->" << *v << std::endl; // } -// // add more test case +// // add more test case // indexMultiTermQueryDestroy(multiQuery); // -// indexOptsDestroy(opts); -// indexClose(index); +// indexOptsDestroy(opts); +// indexClose(index); // // //} - #define L 100 #define M 100 #define N 100 -int Performance_fstWriteRecords(FstWriter *b) { - std::string str("aa"); +int Performance_fstWriteRecords(FstWriter* b) { + std::string str("aa"); for (int i = 0; i < L; i++) { str[0] = 'a' + i; - str.resize(2); - for(int j = 0; j < M; j++) { + str.resize(2); + for (int j = 0; j < M; j++) { str[1] = 'a' + j; str.resize(2); for (int k = 0; k < N; k++) { @@ -181,87 +179,86 @@ int Performance_fstWriteRecords(FstWriter *b) { b->Put(str, k); printf("(%d, %d, %d, %s)\n", i, j, k, str.c_str()); } - } + } } return L * M * N; } -void Performance_fstReadRecords(FstReadMemory *m) { +void Performance_fstReadRecords(FstReadMemory* m) { std::string str("aa"); for (int i = 0; i < M; i++) { str[0] = 'a' + i; - str.resize(2); - for(int j = 0; j < N; j++) { + str.resize(2); + for (int j = 0; j < N; j++) { str[1] = 'a' + j; str.resize(2); for (int k = 0; k < L; k++) { str.push_back('a'); - uint64_t val, cost; + uint64_t val, cost; if (m->GetWithTimeCostUs(str, &val, &cost)) { - printf("succes to get kv(%s, %" PRId64"), cost: %" PRId64"\n", str.c_str(), val, cost); + printf("succes to get kv(%s, %" PRId64 "), cost: %" PRId64 "\n", str.c_str(), val, cost); } else { printf("failed to get key: %s\n", str.c_str()); } } - } + } } } void checkFstPerf() { - FstWriter *fw = new FstWriter; - int64_t s = taosGetTimestampUs(); + FstWriter* fw = new FstWriter; + int64_t s = taosGetTimestampUs(); - int num = Performance_fstWriteRecords(fw); + int num = Performance_fstWriteRecords(fw); int64_t e = taosGetTimestampUs(); - printf("write %d record cost %" PRId64"us\n", num, e - s); + printf("write %d record cost %" PRId64 "us\n", num, e - s); delete fw; - FstReadMemory *m = new FstReadMemory(1024 * 64); - if (m->init()) { - printf("success to init fst read"); - } - Performance_fstReadRecords(m); + FstReadMemory* m = new FstReadMemory(1024 * 64); + if (m->init()) { printf("success to init fst read"); } + Performance_fstReadRecords(m); delete m; -} +} void checkFstPrefixSearch() { - FstWriter *fw = new FstWriter; - int64_t s = taosGetTimestampUs(); - int count = 2; + FstWriter* fw = new FstWriter; + int64_t s = taosGetTimestampUs(); + int count = 2; std::string key("ab"); - + for (int i = 0; i < count; i++) { - key[1] = key[1] + i; - fw->Put(key, i); + key[1] = key[1] + i; + fw->Put(key, i); } int64_t e = taosGetTimestampUs(); - + std::cout << "insert data count : " << count << "elapas time: " << e - s << std::endl; delete fw; - FstReadMemory *m = new FstReadMemory(1024 * 64); + FstReadMemory* m = new FstReadMemory(1024 * 64); if (m->init() == false) { - std::cout << "init readMemory failed" << std::endl; + std::cout << "init readMemory failed" << std::endl; delete m; return; } - - // prefix search + + // prefix search std::vector result; - AutomationCtx *ctx = automCtxCreate((void *)"ab", AUTOMATION_PREFIX); - m->Search(ctx, result); - assert(result.size() == count); + + AutomationCtx* ctx = automCtxCreate((void*)"ab", AUTOMATION_PREFIX); + m->Search(ctx, result); + assert(result.size() == count); for (int i = 0; i < result.size(); i++) { - assert(result[i] == i); // check result + assert(result[i] == i); // check result } free(ctx); delete m; -} +} void validateFst() { - int val = 100; - int count = 100; - FstWriter *fw = new FstWriter; - // write + int val = 100; + int count = 100; + FstWriter* fw = new FstWriter; + // write { std::string key("ab"); for (int i = 0; i < count; i++) { @@ -272,99 +269,255 @@ void validateFst() { delete fw; // read - FstReadMemory *m = new FstReadMemory(1024 * 64); - if (m->init() == false) { - std::cout << "init readMemory failed" << std::endl; + FstReadMemory* m = new FstReadMemory(1024 * 64); + if (m->init() == false) { + std::cout << "init readMemory failed" << std::endl; delete m; return; } { - std::string key("ab"); - uint64_t out; - if (m->Get(key, &out)) { - printf("success to get (%s, %" PRId64")\n", key.c_str(), out); - } else { - printf("failed to get(%s)\n", key.c_str()); - } - for (int i = 0; i < count; i++) { - key.push_back('a' + i); - if (m->Get(key, &out) ) { - assert(val - i == out); - printf("success to get (%s, %" PRId64")\n", key.c_str(), out); - } else { - printf("failed to get(%s)\n", key.c_str()); + std::string key("ab"); + uint64_t out; + if (m->Get(key, &out)) { + printf("success to get (%s, %" PRId64 ")\n", key.c_str(), out); + } else { + printf("failed to get(%s)\n", key.c_str()); + } + for (int i = 0; i < count; i++) { + key.push_back('a' + i); + if (m->Get(key, &out)) { + assert(val - i == out); + printf("success to get (%s, %" PRId64 ")\n", key.c_str(), out); + } else { + printf("failed to get(%s)\n", key.c_str()); + } } - } - } + } delete m; -} +} class IndexEnv : public ::testing::Test { - protected: - virtual void SetUp() { - taosRemoveDir(path); - opts = indexOptsCreate(); - int ret = indexOpen(opts, path, &index); - assert(ret == 0); - } - virtual void TearDown() { - indexClose(index); - indexOptsDestroy(opts); - } - - const char *path = "/tmp/tindex"; - SIndexOpts *opts; - SIndex *index; + protected: + virtual void SetUp() { + taosRemoveDir(path); + opts = indexOptsCreate(); + int ret = indexOpen(opts, path, &index); + assert(ret == 0); + } + virtual void TearDown() { + indexClose(index); + indexOptsDestroy(opts); + } + + const char* path = "/tmp/tindex"; + SIndexOpts* opts; + SIndex* index; }; -TEST_F(IndexEnv, testPut) { - - // single index column - { - - std::string colName("tag1"), colVal("Hello world"); - SIndexTerm *term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size()); - SIndexMultiTerm *terms = indexMultiTermCreate(); - indexMultiTermAdd(terms, term); - - for (size_t i = 0; i < 100; i++) { - int tableId = i; - int ret = indexPut(index, terms, tableId); - assert(ret == 0); +// TEST_F(IndexEnv, testPut) { +// // single index column +// { +// std::string colName("tag1"), colVal("Hello world"); +// SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), +// colVal.size()); SIndexMultiTerm* terms = indexMultiTermCreate(); indexMultiTermAdd(terms, term); +// +// for (size_t i = 0; i < 100; i++) { +// int tableId = i; +// int ret = indexPut(index, terms, tableId); +// assert(ret == 0); +// } +// indexMultiTermDestroy(terms); +// } +// // multi index column +// { +// SIndexMultiTerm* terms = indexMultiTermCreate(); +// { +// std::string colName("tag1"), colVal("Hello world"); +// SIndexTerm* term = +// indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size()); +// indexMultiTermAdd(terms, term); +// } +// { +// std::string colName("tag2"), colVal("Hello world"); +// SIndexTerm* term = +// indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size()); +// indexMultiTermAdd(terms, term); +// } +// +// for (int i = 0; i < 100; i++) { +// int tableId = i; +// int ret = indexPut(index, terms, tableId); +// assert(ret == 0); +// } +// indexMultiTermDestroy(terms); +// } +// // +//} + +class TFileObj { + public: + TFileObj(const std::string& path = "/tmp/tindex", const std::string& colName = "voltage") : path_(path), colName_(colName) { + colId_ = 10; + // Do Nothing + // + } + int Put(SArray* tv) { + if (reader_ != NULL) { + tfileReaderDestroy(reader_); + reader_ = NULL; } - indexMultiTermDestroy(terms); - } - // multi index column - { - - SIndexMultiTerm *terms = indexMultiTermCreate(); - { - std::string colName("tag1"), colVal("Hello world"); - SIndexTerm *term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size()); - indexMultiTermAdd(terms, term); + if (writer_ == NULL) { InitWriter(); } + return tfileWriterPut(writer_, tv); + } + bool InitWriter() { + TFileHeader header; + header.suid = 1; + header.version = 1; + memcpy(header.colName, colName_.c_str(), colName_.size()); + header.colType = TSDB_DATA_TYPE_BINARY; + + std::string path(path_); + int colId = 2; + char buf[64] = {0}; + sprintf(buf, "%" PRIu64 "-%d-%d.tindex", header.suid, colId_, header.version); + path.append("/").append(buf); + + fileName_ = path; + + WriterCtx* ctx = writerCtxCreate(TFile, path.c_str(), false, 64 * 1024 * 1024); + + writer_ = tfileWriterCreate(ctx, &header); + return writer_ != NULL ? true : false; + } + bool InitReader() { + WriterCtx* ctx = writerCtxCreate(TFile, fileName_.c_str(), true, 64 * 1024 * 1024); + reader_ = tfileReaderCreate(ctx); + return reader_ != NULL ? true : false; + } + int Get(SIndexTermQuery* query, SArray* result) { + if (writer_ != NULL) { + tfileWriterDestroy(writer_); + writer_ = NULL; } - { - std::string colName("tag2"), colVal("Hello world"); - SIndexTerm *term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size()); - indexMultiTermAdd(terms, term); + if (reader_ == NULL && InitReader()) { + // + // } - - for (int i = 0; i < 100; i++) { - int tableId = i; - int ret = indexPut(index, terms, tableId); - assert(ret == 0); - } - indexMultiTermDestroy(terms); - } - // -} - -TEST_F(IndexEnv, testDel) { - + return tfileReaderSearch(reader_, query, result); + } + ~TFileObj() { + if (writer_) { tfileWriterDestroy(writer_); } + if (reader_) { tfileReaderDestroy(reader_); } + } + + private: + std::string path_; + std::string colName_; + std::string fileName_; + + TFileWriter* writer_; + TFileReader* reader_; + + int colId_; +}; +class IndexTFileEnv : public ::testing::Test { + protected: + virtual void SetUp() { + taosRemoveDir(dir.c_str()); + taosMkDir(dir.c_str()); + tfInit(); + fObj = new TFileObj(dir, colName); + + // std::string colName("voltage"); + // header.suid = 1; + // header.version = 1; + // memcpy(header.colName, colName.c_str(), colName.size()); + // header.colType = TSDB_DATA_TYPE_BINARY; + + // std::string path(dir); + // int colId = 2; + // char buf[64] = {0}; + // sprintf(buf, "%" PRIu64 "-%d-%d.tindex", header.suid, colId, header.version); + // path.append("/").append(buf); + + // ctx = writerCtxCreate(TFile, path.c_str(), false, 64 * 1024 * 1024); + + // twrite = tfileWriterCreate(ctx, &header); + } + + virtual void TearDown() { + // indexClose(index); + // indexeptsDestroy(opts); + delete fObj; + tfCleanup(); + // tfileWriterDestroy(twrite); + } + TFileObj* fObj; + std::string dir = "/tmp/tindex"; + std::string colName = "voltage"; + + int coldId = 2; + int version = 1; + int colType = TSDB_DATA_TYPE_BINARY; + + // WriterCtx* ctx = NULL; + // TFileHeader header; + // TFileWriter* twrite = NULL; +}; + +// static TFileWriter* genTFileWriter(const char* path, TFileHeader* header) { +// char buf[128] = {0}; +// WriterCtx* ctx = writerCtxCreate(TFile, path, false, ) +//} +static TFileValue* genTFileValue(const char* val) { + TFileValue* tv = (TFileValue*)calloc(1, sizeof(TFileValue)); + int32_t vlen = strlen(val) + 1; + tv->colVal = (char*)calloc(1, vlen); + memcpy(tv->colVal, val, vlen); + + tv->tableId = (SArray*)taosArrayInit(1, sizeof(uint64_t)); + for (size_t i = 0; i < 10; i++) { + uint64_t v = i; + taosArrayPush(tv->tableId, &v); + } + return tv; +} +static void destroyTFileValue(void* val) { + TFileValue* tv = (TFileValue*)val; + free(tv->colVal); + taosArrayDestroy(tv->tableId); + free(tv); } +TEST_F(IndexTFileEnv, test_tfile_write) { + TFileValue* v1 = genTFileValue("c"); + TFileValue* v2 = genTFileValue("a"); + TFileValue* v3 = genTFileValue("b"); + TFileValue* v4 = genTFileValue("d"); + + SArray* data = (SArray*)taosArrayInit(4, sizeof(void*)); + taosArrayPush(data, &v1); + taosArrayPush(data, &v2); + taosArrayPush(data, &v3); + taosArrayPush(data, &v4); + fObj->Put(data); + for (size_t i = 0; i < taosArrayGetSize(data); i++) { + destroyTFileValue(taosArrayGetP(data, i)); + } + taosArrayDestroy(data); + + std::string colName("voltage"); + std::string colVal("b"); + SIndexTerm* term = indexTermCreate(1, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size()); + SIndexTermQuery query = {.term = term, .qType = QUERY_TERM}; + SArray* result = (SArray*)taosArrayInit(1, sizeof(uint64_t)); + fObj->Get(&query, result); + assert(taosArrayGetSize(result) == 10); + indexTermDestroy(term); + // tfileWriterDestroy(twrite); +} diff --git a/source/libs/parser/inc/astToMsg.h b/source/libs/parser/inc/astToMsg.h index 400b533bf794bdbcfe66438de9fc8538e87d5acf..c0c3c8386b5237707881204efd00dcda07896126 100644 --- a/source/libs/parser/inc/astToMsg.h +++ b/source/libs/parser/inc/astToMsg.h @@ -8,7 +8,8 @@ SCreateUserMsg* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, in SCreateAcctMsg* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen); SDropUserMsg* buildDropUserMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen); SShowMsg* buildShowMsg(SShowInfo* pShowInfo, int64_t id, char* msgBuf, int32_t msgLen); -SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, char* msgBuf, int32_t msgLen); +SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf); SCreateStbMsg* buildCreateTableMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf); +SDropTableMsg* buildDropTableMsg(SSqlInfo* pInfo, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf); #endif // TDENGINE_ASTTOMSG_H diff --git a/source/libs/parser/inc/parserInt.h b/source/libs/parser/inc/parserInt.h index 93df023fbaedb0de568249557dd887e3250f9b4a..186a4869e67871c48a919d5022fb0b3a4bde0465 100644 --- a/source/libs/parser/inc/parserInt.h +++ b/source/libs/parser/inc/parserInt.h @@ -68,7 +68,7 @@ int32_t qParserValidateSqlNode(struct SCatalog* pCatalog, SSqlInfo* pSqlInfo, SQ * @param type * @return */ -int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, void** output, int32_t* outputLen, int32_t* type, char* msgBuf, int32_t msgBufLen); +int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStmtInfo* pDcl, char* msgBuf, int32_t msgBufLen); /** * Evaluate the numeric and timestamp arithmetic expression in the WHERE clause. diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index da975b966ea2360a9c9672f15669c8f1bf5f4ff9..183b71483be7d275f5745678e4882bc6ed444db3 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -31,6 +31,7 @@ #include "ttoken.h" #include "ttokendef.h" #include "tvariant.h" +#include "parserInt.h" } %syntax_error { @@ -173,7 +174,7 @@ cmd ::= ALTER DNODE ids(X) ids(Y) ids(Z). { setDCLSqlElems(pInfo, TSDB_SQL cmd ::= ALTER LOCAL ids(X). { setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &X); } cmd ::= ALTER LOCAL ids(X) ids(Y). { setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &X, &Y); } cmd ::= ALTER DATABASE ids(X) alter_db_optr(Y). { SToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);} -cmd ::= ALTER TOPIC ids(X) alter_topic_optr(Y). { SToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);} +//cmd ::= ALTER TOPIC ids(X) alter_topic_optr(Y). { SToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);} cmd ::= ALTER ACCOUNT ids(X) acct_optr(Z). { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &X, NULL, &Z);} cmd ::= ALTER ACCOUNT ids(X) PASS ids(Y) acct_optr(Z). { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &X, &Y, &Z);} @@ -203,7 +204,7 @@ cmd ::= CREATE DNODE ids(X). { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE cmd ::= CREATE ACCOUNT ids(X) PASS ids(Y) acct_optr(Z). { setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &X, &Y, &Z);} cmd ::= CREATE DATABASE ifnotexists(Z) ids(X) db_optr(Y). { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);} -cmd ::= CREATE TOPIC ifnotexists(Z) ids(X) topic_optr(Y). { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);} +//cmd ::= CREATE TOPIC ifnotexists(Z) ids(X) topic_optr(Y). { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);} cmd ::= CREATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize(B). { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &X, &Y, &Z, &B, 1);} cmd ::= CREATE AGGREGATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize(B). { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &X, &Y, &Z, &B, 2);} cmd ::= CREATE USER ids(X) PASS ids(Y). { setCreateUserSql(pInfo, &X, &Y);} @@ -278,10 +279,10 @@ comp(Y) ::= COMP INTEGER(X). { Y = X; } prec(Y) ::= PRECISION STRING(X). { Y = X; } update(Y) ::= UPDATE INTEGER(X). { Y = X; } cachelast(Y) ::= CACHELAST INTEGER(X). { Y = X; } -partitions(Y) ::= PARTITIONS INTEGER(X). { Y = X; } +//partitions(Y) ::= PARTITIONS INTEGER(X). { Y = X; } %type db_optr {SCreateDbInfo} -db_optr(Y) ::= . {setDefaultCreateDbOption(&Y); Y.dbType = TSDB_DB_TYPE_DEFAULT;} +db_optr(Y) ::= . {setDefaultCreateDbOption(&Y);} db_optr(Y) ::= db_optr(Z) cache(X). { Y = Z; Y.cacheBlockSize = strtol(X.z, NULL, 10); } db_optr(Y) ::= db_optr(Z) replica(X). { Y = Z; Y.replica = strtol(X.z, NULL, 10); } @@ -299,13 +300,13 @@ db_optr(Y) ::= db_optr(Z) keep(X). { Y = Z; Y.keep = X; } db_optr(Y) ::= db_optr(Z) update(X). { Y = Z; Y.update = strtol(X.z, NULL, 10); } db_optr(Y) ::= db_optr(Z) cachelast(X). { Y = Z; Y.cachelast = strtol(X.z, NULL, 10); } -%type topic_optr {SCreateDbInfo} - -topic_optr(Y) ::= db_optr(Z). { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; } -topic_optr(Y) ::= topic_optr(Z) partitions(X). { Y = Z; Y.partitions = strtol(X.z, NULL, 10); } +//%type topic_optr {SCreateDbInfo} +// +//topic_optr(Y) ::= db_optr(Z). { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; } +//topic_optr(Y) ::= topic_optr(Z) partitions(X). { Y = Z; Y.partitions = strtol(X.z, NULL, 10); } %type alter_db_optr {SCreateDbInfo} -alter_db_optr(Y) ::= . { setDefaultCreateDbOption(&Y); Y.dbType = TSDB_DB_TYPE_DEFAULT;} +alter_db_optr(Y) ::= . { setDefaultCreateDbOption(&Y);} alter_db_optr(Y) ::= alter_db_optr(Z) replica(X). { Y = Z; Y.replica = strtol(X.z, NULL, 10); } alter_db_optr(Y) ::= alter_db_optr(Z) quorum(X). { Y = Z; Y.quorum = strtol(X.z, NULL, 10); } @@ -319,10 +320,10 @@ alter_db_optr(Y) ::= alter_db_optr(Z) cachelast(X). { Y = Z; Y.cachelast = str //alter_db_optr(Y) ::= alter_db_optr(Z) fsync(X). { Y = Z; Y.fsyncPeriod = strtol(X.z, NULL, 10); } //alter_db_optr(Y) ::= alter_db_optr(Z) wal(X). { Y = Z; Y.walLevel = strtol(X.z, NULL, 10); } not support yet -%type alter_topic_optr {SCreateDbInfo} +//%type alter_topic_optr {SCreateDbInfo} -alter_topic_optr(Y) ::= alter_db_optr(Z). { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; } -alter_topic_optr(Y) ::= alter_topic_optr(Z) partitions(X). { Y = Z; Y.partitions = strtol(X.z, NULL, 10); } +//alter_topic_optr(Y) ::= alter_db_optr(Z). { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; } +//alter_topic_optr(Y) ::= alter_topic_optr(Z) partitions(X). { Y = Z; Y.partitions = strtol(X.z, NULL, 10); } %type typename {SField} typename(A) ::= ids(X). { diff --git a/source/libs/parser/inc/ttokendef.h b/source/libs/parser/inc/ttokendef.h index 9b0ad2cf13b6df01bda56906891a4de677ff08a3..ccb62b33208ef2b5c766cdfeacd4899006db604e 100644 --- a/source/libs/parser/inc/ttokendef.h +++ b/source/libs/parser/inc/ttokendef.h @@ -130,88 +130,88 @@ #define TK_PRECISION 112 #define TK_UPDATE 113 #define TK_CACHELAST 114 -#define TK_PARTITIONS 115 -#define TK_UNSIGNED 116 -#define TK_TAGS 117 -#define TK_USING 118 -#define TK_NULL 119 -#define TK_NOW 120 -#define TK_SELECT 121 -#define TK_UNION 122 -#define TK_ALL 123 -#define TK_DISTINCT 124 -#define TK_FROM 125 -#define TK_VARIABLE 126 -#define TK_INTERVAL 127 -#define TK_EVERY 128 -#define TK_SESSION 129 -#define TK_STATE_WINDOW 130 -#define TK_FILL 131 -#define TK_SLIDING 132 -#define TK_ORDER 133 -#define TK_BY 134 -#define TK_ASC 135 -#define TK_GROUP 136 -#define TK_HAVING 137 -#define TK_LIMIT 138 -#define TK_OFFSET 139 -#define TK_SLIMIT 140 -#define TK_SOFFSET 141 -#define TK_WHERE 142 -#define TK_RESET 143 -#define TK_QUERY 144 -#define TK_SYNCDB 145 -#define TK_ADD 146 -#define TK_COLUMN 147 -#define TK_MODIFY 148 -#define TK_TAG 149 -#define TK_CHANGE 150 -#define TK_SET 151 -#define TK_KILL 152 -#define TK_CONNECTION 153 -#define TK_STREAM 154 -#define TK_COLON 155 -#define TK_ABORT 156 -#define TK_AFTER 157 -#define TK_ATTACH 158 -#define TK_BEFORE 159 -#define TK_BEGIN 160 -#define TK_CASCADE 161 -#define TK_CLUSTER 162 -#define TK_CONFLICT 163 -#define TK_COPY 164 -#define TK_DEFERRED 165 -#define TK_DELIMITERS 166 -#define TK_DETACH 167 -#define TK_EACH 168 -#define TK_END 169 -#define TK_EXPLAIN 170 -#define TK_FAIL 171 -#define TK_FOR 172 -#define TK_IGNORE 173 -#define TK_IMMEDIATE 174 -#define TK_INITIALLY 175 -#define TK_INSTEAD 176 -#define TK_KEY 177 -#define TK_OF 178 -#define TK_RAISE 179 -#define TK_REPLACE 180 -#define TK_RESTRICT 181 -#define TK_ROW 182 -#define TK_STATEMENT 183 -#define TK_TRIGGER 184 -#define TK_VIEW 185 -#define TK_IPTOKEN 186 -#define TK_SEMI 187 -#define TK_NONE 188 -#define TK_PREV 189 -#define TK_LINEAR 190 -#define TK_IMPORT 191 -#define TK_TBNAME 192 -#define TK_JOIN 193 -#define TK_INSERT 194 -#define TK_INTO 195 -#define TK_VALUES 196 +#define TK_UNSIGNED 115 +#define TK_TAGS 116 +#define TK_USING 117 +#define TK_NULL 118 +#define TK_NOW 119 +#define TK_SELECT 120 +#define TK_UNION 121 +#define TK_ALL 122 +#define TK_DISTINCT 123 +#define TK_FROM 124 +#define TK_VARIABLE 125 +#define TK_INTERVAL 126 +#define TK_EVERY 127 +#define TK_SESSION 128 +#define TK_STATE_WINDOW 129 +#define TK_FILL 130 +#define TK_SLIDING 131 +#define TK_ORDER 132 +#define TK_BY 133 +#define TK_ASC 134 +#define TK_GROUP 135 +#define TK_HAVING 136 +#define TK_LIMIT 137 +#define TK_OFFSET 138 +#define TK_SLIMIT 139 +#define TK_SOFFSET 140 +#define TK_WHERE 141 +#define TK_RESET 142 +#define TK_QUERY 143 +#define TK_SYNCDB 144 +#define TK_ADD 145 +#define TK_COLUMN 146 +#define TK_MODIFY 147 +#define TK_TAG 148 +#define TK_CHANGE 149 +#define TK_SET 150 +#define TK_KILL 151 +#define TK_CONNECTION 152 +#define TK_STREAM 153 +#define TK_COLON 154 +#define TK_ABORT 155 +#define TK_AFTER 156 +#define TK_ATTACH 157 +#define TK_BEFORE 158 +#define TK_BEGIN 159 +#define TK_CASCADE 160 +#define TK_CLUSTER 161 +#define TK_CONFLICT 162 +#define TK_COPY 163 +#define TK_DEFERRED 164 +#define TK_DELIMITERS 165 +#define TK_DETACH 166 +#define TK_EACH 167 +#define TK_END 168 +#define TK_EXPLAIN 169 +#define TK_FAIL 170 +#define TK_FOR 171 +#define TK_IGNORE 172 +#define TK_IMMEDIATE 173 +#define TK_INITIALLY 174 +#define TK_INSTEAD 175 +#define TK_KEY 176 +#define TK_OF 177 +#define TK_RAISE 178 +#define TK_REPLACE 179 +#define TK_RESTRICT 180 +#define TK_ROW 181 +#define TK_STATEMENT 182 +#define TK_TRIGGER 183 +#define TK_VIEW 184 +#define TK_IPTOKEN 185 +#define TK_SEMI 186 +#define TK_NONE 187 +#define TK_PREV 188 +#define TK_LINEAR 189 +#define TK_IMPORT 190 +#define TK_TBNAME 191 +#define TK_JOIN 192 +#define TK_INSERT 193 +#define TK_INTO 194 +#define TK_VALUES 195 + #define TK_SPACE 300 diff --git a/source/libs/parser/src/astToMsg.c b/source/libs/parser/src/astToMsg.c index a9272f39df9cbbfece0ea7d1fe4d97107a272bea..00f3d3f7162cb4df8de51d7755fce8911dbfaa57 100644 --- a/source/libs/parser/src/astToMsg.c +++ b/source/libs/parser/src/astToMsg.c @@ -207,17 +207,23 @@ int32_t setDbOptions(SCreateDbMsg* pCreateDbMsg, const SCreateDbInfo* pCreateDbS return TSDB_CODE_SUCCESS; } -SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, char* msgBuf, int32_t msgLen) { +SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf) { SCreateDbMsg* pCreateMsg = calloc(1, sizeof(SCreateDbMsg)); - - SMsgBuf msg = {.buf = msgBuf, .len = msgLen}; - if (setDbOptions(pCreateMsg, pCreateDbInfo, &msg) != TSDB_CODE_SUCCESS) { + if (setDbOptions(pCreateMsg, pCreateDbInfo, pMsgBuf) != TSDB_CODE_SUCCESS) { tfree(pCreateMsg); terrno = TSDB_CODE_TSC_INVALID_OPERATION; return NULL; } + SName name = {0}; + int32_t ret = tNameSetDbName(&name, pCtx->acctId, pCreateDbInfo->dbname.z, pCreateDbInfo->dbname.n); + if (ret != TSDB_CODE_SUCCESS) { + terrno = ret; + return NULL; + } + + tNameGetFullDbName(&name, pCreateMsg->db); return pCreateMsg; } @@ -263,14 +269,17 @@ int32_t createSName(SName* pName, SToken* pTableName, SParseBasicCtx* pParseCtx, SCreateStbMsg* buildCreateTableMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) { SSchema* pSchema; + int32_t numOfTags = 0; int32_t numOfCols = (int32_t) taosArrayGetSize(pCreateTableSql->colInfo.pColumns); - int32_t numOfTags = (int32_t) taosArrayGetSize(pCreateTableSql->colInfo.pTagColumns); + if (pCreateTableSql->colInfo.pTagColumns != NULL) { + numOfTags = (int32_t) taosArrayGetSize(pCreateTableSql->colInfo.pTagColumns); + } SCreateStbMsg* pCreateTableMsg = (SCreateStbMsg*)calloc(1, sizeof(SCreateStbMsg) + (numOfCols + numOfTags) * sizeof(SSchema)); char* pMsg = NULL; - int8_t type = pCreateTableSql->type; - if (type == TSQL_CREATE_TABLE) { // create by using super table, tags value + int32_t tableType = pCreateTableSql->type; + if (tableType != TSQL_CREATE_TABLE && tableType != TSQL_CREATE_STABLE) { // create by using super table, tags value #if 0 SArray* list = pInfo->pCreateTableInfo->childTableInfo; @@ -309,15 +318,13 @@ SCreateStbMsg* buildCreateTableMsg(SCreateTableSql* pCreateTableSql, int32_t* le return NULL; } - pCreateTableMsg->igExists = pCreateTableSql->existCheck ? 1 : 0; - + pCreateTableMsg->igExists = pCreateTableSql->existCheck ? 1 : 0; pCreateTableMsg->numOfColumns = htonl(numOfCols); - pCreateTableMsg->numOfTags = htonl(numOfTags); + pCreateTableMsg->numOfTags = htonl(numOfTags); pSchema = (SSchema*) pCreateTableMsg->pSchema; for (int i = 0; i < numOfCols; ++i) { - TAOS_FIELD* pField = taosArrayGet(pCreateTableSql->colInfo.pColumns, i); - + SField* pField = taosArrayGet(pCreateTableSql->colInfo.pColumns, i); pSchema->type = pField->type; pSchema->bytes = htonl(pField->bytes); strcpy(pSchema->name, pField->name); @@ -326,8 +333,7 @@ SCreateStbMsg* buildCreateTableMsg(SCreateTableSql* pCreateTableSql, int32_t* le } for(int32_t i = 0; i < numOfTags; ++i) { - TAOS_FIELD* pField = taosArrayGet(pCreateTableSql->colInfo.pTagColumns, i); - + SField* pField = taosArrayGet(pCreateTableSql->colInfo.pTagColumns, i); pSchema->type = pField->type; pSchema->bytes = htonl(pField->bytes); strcpy(pSchema->name, pField->name); @@ -343,3 +349,24 @@ SCreateStbMsg* buildCreateTableMsg(SCreateTableSql* pCreateTableSql, int32_t* le return pCreateTableMsg; } + +SDropTableMsg* buildDropTableMsg(SSqlInfo* pInfo, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) { + SToken* tableName = taosArrayGet(pInfo->pMiscInfo->a, 0); + + SName name = {0}; + int32_t code = createSName(&name, tableName, pParseCtx, pMsgBuf); + if (code != TSDB_CODE_SUCCESS) { + terrno = buildInvalidOperationMsg(pMsgBuf, "invalid table name"); + return NULL; + } + + SDropTableMsg *pDropTableMsg = (SDropTableMsg*) calloc(1, sizeof(SDropTableMsg)); + + code = tNameExtractFullName(&name, pDropTableMsg->name); + assert(code == TSDB_CODE_SUCCESS && name.type == TSDB_TABLE_NAME_T); + + pDropTableMsg->ignoreNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0; + *len = sizeof(SDropTableMsg); + return pDropTableMsg; +} + diff --git a/source/libs/parser/src/astValidate.c b/source/libs/parser/src/astValidate.c index 33efeb469d7ad50fd51eebeacbe62a3e1689d58c..cd11607326a33a8b277dbed0367138e269865b86 100644 --- a/source/libs/parser/src/astValidate.c +++ b/source/libs/parser/src/astValidate.c @@ -4028,7 +4028,7 @@ int32_t qParserValidateSqlNode(struct SCatalog* pCatalog, SSqlInfo* pInfo, SQuer } // todo remove it -static int32_t setShowInfo(struct SSqlInfo* pInfo, void** output, int32_t* msgLen, SMsgBuf* pMsgBuf) { +static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx *pCtx, void** output, int32_t* outputLen, SMsgBuf* pMsgBuf) { const char* msg1 = "invalid name"; const char* msg2 = "wildcard string should be less than %d characters"; const char* msg3 = "database name too long"; @@ -4040,9 +4040,8 @@ static int32_t setShowInfo(struct SSqlInfo* pInfo, void** output, int32_t* msgLe * database prefix in pInfo->pMiscInfo->a[0] * wildcard in like clause in pInfo->pMiscInfo->a[1] */ - SShowInfo* pShowInfo = &pInfo->pMiscInfo->showOpt; int16_t showType = pShowInfo->showType; - if (showType == TSDB_MGMT_TABLE_TABLE || showType == TSDB_MGMT_TABLE_VGROUP) { + if (showType == TSDB_MGMT_TABLE_STB || showType == TSDB_MGMT_TABLE_VGROUP) { SToken* pDbPrefixToken = &pShowInfo->prefix; if (pDbPrefixToken->type != 0) { if (pDbPrefixToken->n >= TSDB_DB_NAME_LEN) { // db name is too long @@ -4091,8 +4090,8 @@ static int32_t setShowInfo(struct SSqlInfo* pInfo, void** output, int32_t* msgLe } } - *output = buildShowMsg(pShowInfo, 0, pMsgBuf->buf, pMsgBuf->len); - *msgLen = sizeof(SShowMsg)/* + htons(pShowMsg->payloadLen)*/; + *output = buildShowMsg(pShowInfo, pCtx->requestId, pMsgBuf->buf, pMsgBuf->len); + *outputLen = sizeof(SShowMsg)/* + htons(pShowMsg->payloadLen)*/; return TSDB_CODE_SUCCESS; } @@ -4246,7 +4245,7 @@ static int32_t validateTableColumnInfo(SArray* pFieldList, SMsgBuf* pMsgBuf) { const char* msg8 = "illegal number of columns"; // first column must be timestamp - TAOS_FIELD* pField = taosArrayGet(pFieldList, 0); + SField* pField = taosArrayGet(pFieldList, 0); if (pField->type != TSDB_DATA_TYPE_TIMESTAMP) { return buildInvalidOperationMsg(pMsgBuf, msg1); } @@ -4274,7 +4273,7 @@ static int32_t validateTagParams(SArray* pTagsList, SArray* pFieldList, SMsgBuf* // field name must be unique for (int32_t i = 0; i < numOfTags; ++i) { - TAOS_FIELD* p = taosArrayGet(pTagsList, i); + SField* p = taosArrayGet(pTagsList, i); if (has(pFieldList, 0, p->name) == true) { return buildInvalidOperationMsg(pMsgBuf, msg3); } @@ -4295,7 +4294,6 @@ int32_t doCheckForCreateTable(SSqlInfo* pInfo, SMsgBuf* pMsgBuf) { // if sql specifies db, use it, otherwise use default db SToken* pzTableName = &(pCreateTable->name); - bool dbIncluded = false; if (parserValidateNameToken(pzTableName) != TSDB_CODE_SUCCESS) { return buildInvalidOperationMsg(pMsgBuf, msg1); } @@ -4308,14 +4306,12 @@ int32_t doCheckForCreateTable(SSqlInfo* pInfo, SMsgBuf* pMsgBuf) { return TSDB_CODE_SUCCESS; } -int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, void** output, int32_t* outputLen, int32_t* type, char* msgBuf, int32_t msgBufLen) { +int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStmtInfo* pDcl, char* msgBuf, int32_t msgBufLen) { int32_t code = 0; SMsgBuf m = {.buf = msgBuf, .len = msgBufLen}; SMsgBuf *pMsgBuf = &m; - *type = pInfo->type; - switch (pInfo->type) { case TSDB_SQL_CREATE_USER: case TSDB_SQL_ALTER_USER: { @@ -4361,7 +4357,8 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, void** } } - *output = buildUserManipulationMsg(pInfo, outputLen, pCtx->requestId, msgBuf, msgBufLen); + pDcl->pMsg = (char*)buildUserManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen); + pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_USER)? TSDB_MSG_TYPE_CREATE_USER:TSDB_MSG_TYPE_ALTER_USER; break; } @@ -4397,18 +4394,21 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, void** } } - *output = buildAcctManipulationMsg(pInfo, outputLen, pCtx->requestId, msgBuf, msgBufLen); + pDcl->pMsg = (char*)buildAcctManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen); + pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_ACCT)? TSDB_MSG_TYPE_CREATE_ACCT:TSDB_MSG_TYPE_ALTER_ACCT; break; } case TSDB_SQL_DROP_ACCT: case TSDB_SQL_DROP_USER: { - *output = buildDropUserMsg(pInfo, outputLen, pCtx->requestId, msgBuf, msgBufLen); + pDcl->pMsg = (char*)buildDropUserMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen); + pDcl->msgType = (pInfo->type == TSDB_SQL_DROP_ACCT)? TSDB_MSG_TYPE_DROP_ACCT:TSDB_MSG_TYPE_DROP_USER; break; } case TSDB_SQL_SHOW: { - code = setShowInfo(pInfo, output, outputLen, pMsgBuf); + code = setShowInfo(&pInfo->pMiscInfo->showOpt, pCtx, (void**)&pDcl->pMsg, &pDcl->msgLen, pMsgBuf); + pDcl->msgType = TSDB_MSG_TYPE_SHOW; break; } @@ -4429,8 +4429,9 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, void** SUseDbMsg *pUseDbMsg = (SUseDbMsg *) calloc(1, sizeof(SUseDbMsg)); tNameExtractFullName(&n, pUseDbMsg->db); - *output = pUseDbMsg; - *outputLen = sizeof(SUseDbMsg); + pDcl->pMsg = (char*)pUseDbMsg; + pDcl->msgLen = sizeof(SUseDbMsg); + pDcl->msgType = TSDB_MSG_TYPE_USE_DB; break; } @@ -4451,18 +4452,41 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, void** return buildInvalidOperationMsg(pMsgBuf, msg1); } - SCreateDbMsg* pCreateMsg = buildCreateDbMsg(pCreateDB, pMsgBuf->buf, pMsgBuf->len); + SCreateDbMsg* pCreateMsg = buildCreateDbMsg(pCreateDB, pCtx, pMsgBuf); if (doCheckDbOptions(pCreateMsg, pMsgBuf) != TSDB_CODE_SUCCESS) { return TSDB_CODE_TSC_INVALID_OPERATION; } - strncpy(pCreateMsg->db, token.z, token.n); - - *output = pCreateMsg; - *outputLen = sizeof(SCreateDbMsg); + pDcl->pMsg = (char*)pCreateMsg; + pDcl->msgLen = sizeof(SCreateDbMsg); + pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_DB)? TSDB_MSG_TYPE_CREATE_DB:TSDB_MSG_TYPE_ALTER_DB; break; } + case TSDB_SQL_DROP_DB: { + const char* msg1 = "invalid database name"; + + assert(taosArrayGetSize(pInfo->pMiscInfo->a) == 1); + SToken* dbName = taosArrayGet(pInfo->pMiscInfo->a, 0); + + SName name = {0}; + code = tNameSetDbName(&name, pCtx->acctId, dbName->z, dbName->n); + if (code != TSDB_CODE_SUCCESS) { + return buildInvalidOperationMsg(pMsgBuf, msg1); + } + + SDropDbMsg *pDropDbMsg = (SDropDbMsg*) calloc(1, sizeof(SDropDbMsg)); + + code = tNameExtractFullName(&name, pDropDbMsg->db); + pDropDbMsg->ignoreNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0; + assert(code == TSDB_CODE_SUCCESS && name.type == TSDB_DB_NAME_T); + + pDcl->msgType = TSDB_MSG_TYPE_DROP_DB; + pDcl->msgLen = sizeof(SDropDbMsg); + pDcl->pMsg = (char*)pDropDbMsg; + return TSDB_CODE_SUCCESS; + } + case TSDB_SQL_CREATE_TABLE: { SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo; @@ -4470,7 +4494,8 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, void** if ((code = doCheckForCreateTable(pInfo, pMsgBuf)) != TSDB_CODE_SUCCESS) { return code; } - *output = buildCreateTableMsg(pCreateTable, outputLen, pCtx, pMsgBuf); + pDcl->pMsg = (char*)buildCreateTableMsg(pCreateTable, &pDcl->msgLen, pCtx, pMsgBuf); + pDcl->msgType = (pCreateTable->type == TSQL_CREATE_TABLE)? TSDB_MSG_TYPE_CREATE_TABLE:TSDB_MSG_TYPE_CREATE_STB; } else if (pCreateTable->type == TSQL_CREATE_CTABLE) { // if ((code = doCheckForCreateFromStable(pSql, pInfo)) != TSDB_CODE_SUCCESS) { // return code; @@ -4483,6 +4508,18 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, void** break; } + + case TSDB_SQL_DROP_TABLE: { + pDcl->pMsg = (char*)buildDropTableMsg(pInfo, &pDcl->msgLen, pCtx, pMsgBuf); + if (pDcl->pMsg == NULL) { + return terrno; + } + + pDcl->msgType = TSDB_MSG_TYPE_DROP_STB; + return TSDB_CODE_SUCCESS; + break; + } + default: break; } diff --git a/source/libs/parser/src/insertParser.c b/source/libs/parser/src/insertParser.c index 68aa7554833c34feee541d4c20a9ebd6b1e41873..fb7790452d8ddbbc447c7d9b3753ef094e086808 100644 --- a/source/libs/parser/src/insertParser.c +++ b/source/libs/parser/src/insertParser.c @@ -909,6 +909,7 @@ int32_t parseInsertSql(SParseContext* pContext, SInsertStmtInfo** pInfo) { } *pInfo = context.pOutput; + context.pOutput->nodeType = TSDB_SQL_INSERT; context.pOutput->schemaAttache = pContext->schemaAttached; context.pOutput->payloadType = PAYLOAD_TYPE_KV; diff --git a/source/libs/parser/src/parser.c b/source/libs/parser/src/parser.c index 3490580f155f2f583c487852f3803091ef49c48d..9922642df31e7e86611193a70b3fadd4dfb1bfdd 100644 --- a/source/libs/parser/src/parser.c +++ b/source/libs/parser/src/parser.c @@ -20,7 +20,7 @@ #include "function.h" #include "insertParser.h" -bool qIsInsertSql(const char* pStr, size_t length) { +bool isInsertSql(const char* pStr, size_t length) { int32_t index = 0; do { @@ -31,18 +31,28 @@ bool qIsInsertSql(const char* pStr, size_t length) { } while (1); } -int32_t qParseQuerySql(const char* pStr, size_t length, SParseBasicCtx* pParseCtx, int32_t *type, void** pOutput, int32_t* outputLen, char* msg, int32_t msgLen) { - SSqlInfo info = doGenerateAST(pStr); +bool qIsDclQuery(const SQueryNode* pQuery) { + return TSDB_SQL_INSERT != pQuery->type && TSDB_SQL_SELECT != pQuery->type; +} + +int32_t parseQuerySql(SParseContext* pCxt, SQueryNode** pQuery) { + SSqlInfo info = doGenerateAST(pCxt->pSql); if (!info.valid) { - strncpy(msg, info.msg, msgLen); + strncpy(pCxt->pMsg, info.msg, pCxt->msgLen); terrno = TSDB_CODE_TSC_SQL_SYNTAX_ERROR; return terrno; } if (!isDqlSqlStatement(&info)) { - int32_t code = qParserValidateDclSqlNode(&info, pParseCtx, pOutput, outputLen, type, msg, msgLen); + SDclStmtInfo* pDcl = calloc(1, sizeof(SQueryStmtInfo)); + if (NULL == pDcl) { + terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; // set correct error code. + return terrno; + } + pDcl->nodeType = info.type; + int32_t code = qParserValidateDclSqlNode(&info, &pCxt->ctx, pDcl, pCxt->pMsg, pCxt->msgLen); if (code == TSDB_CODE_SUCCESS) { - // do nothing + *pQuery = (SQueryNode*)pDcl; } } else { SQueryStmtInfo* pQueryInfo = calloc(1, sizeof(SQueryStmtInfo)); @@ -53,9 +63,9 @@ int32_t qParseQuerySql(const char* pStr, size_t length, SParseBasicCtx* pParseCt struct SCatalog* pCatalog = NULL; int32_t code = catalogGetHandle(NULL, &pCatalog); - code = qParserValidateSqlNode(pCatalog, &info, pQueryInfo, pParseCtx->requestId, msg, msgLen); + code = qParserValidateSqlNode(pCatalog, &info, pQueryInfo, pCxt->ctx.requestId, pCxt->pMsg, pCxt->msgLen); if (code == TSDB_CODE_SUCCESS) { - *pOutput = pQueryInfo; + *pQuery = (SQueryNode*)pQueryInfo; } } @@ -63,8 +73,12 @@ int32_t qParseQuerySql(const char* pStr, size_t length, SParseBasicCtx* pParseCt return TSDB_CODE_SUCCESS; } -int32_t qParseInsertSql(SParseContext* pContext, SInsertStmtInfo** pInfo) { - return parseInsertSql(pContext, pInfo); +int32_t qParseQuerySql(SParseContext* pCxt, SQueryNode** pQuery) { + if (isInsertSql(pCxt->pSql, pCxt->sqlLen)) { + return parseInsertSql(pCxt, (SInsertStmtInfo**)pQuery); + } else { + return parseQuerySql(pCxt, pQuery); + } } int32_t qParserConvertSql(const char* pStr, size_t length, char** pConvertSql) { diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index 9922ff1be0e591916e03419131f273701be6f597..5295faf645c137e749eac0b0f3ed30b2e393a562 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -31,11 +31,11 @@ #include #include #include "astGenerator.h" -#include "parserInt.h" #include "tmsgtype.h" #include "ttoken.h" #include "ttokendef.h" #include "tvariant.h" +#include "parserInt.h" /**************** End of %include directives **********************************/ /* These constants specify the various numeric values for terminal symbols ** in a format understandable to "makeheaders". This section is blank unless @@ -97,30 +97,30 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 280 +#define YYNOCODE 276 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SToken typedef union { int yyinit; ParseTOKENTYPE yy0; - SCreatedTableInfo yy78; - SCreateTableSql* yy110; - int yy130; - SArray* yy135; - SIntervalVal yy160; - SVariant yy191; - SLimit yy247; - SCreateDbInfo yy256; - SWindowStateVal yy258; - int32_t yy262; - SCreateAcctInfo yy277; - SField yy304; - SRelationInfo* yy460; - SSqlNode* yy488; - SSessionWindowVal yy511; - tSqlExpr* yy526; - int64_t yy531; - SSubclause* yy551; + SSessionWindowVal yy39; + SCreateDbInfo yy42; + SVariant yy43; + int yy44; + tSqlExpr* yy46; + SLimit yy55; + SCreatedTableInfo yy96; + SArray* yy131; + SSqlNode* yy256; + SCreateTableSql* yy272; + SField yy290; + SSubclause* yy303; + int32_t yy310; + SCreateAcctInfo yy341; + int64_t yy459; + SIntervalVal yy530; + SWindowStateVal yy538; + SRelationInfo* yy544; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -130,17 +130,17 @@ typedef union { #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo #define ParseARG_STORE yypParser->pInfo = pInfo #define YYFALLBACK 1 -#define YYNSTATE 368 -#define YYNRULE 295 -#define YYNTOKEN 197 -#define YY_MAX_SHIFT 367 -#define YY_MIN_SHIFTREDUCE 577 -#define YY_MAX_SHIFTREDUCE 871 -#define YY_ERROR_ACTION 872 -#define YY_ACCEPT_ACTION 873 -#define YY_NO_ACTION 874 -#define YY_MIN_REDUCE 875 -#define YY_MAX_REDUCE 1169 +#define YYNSTATE 358 +#define YYNRULE 288 +#define YYNTOKEN 196 +#define YY_MAX_SHIFT 357 +#define YY_MIN_SHIFTREDUCE 564 +#define YY_MAX_SHIFTREDUCE 851 +#define YY_ERROR_ACTION 852 +#define YY_ACCEPT_ACTION 853 +#define YY_NO_ACTION 854 +#define YY_MIN_REDUCE 855 +#define YY_MAX_REDUCE 1142 /************* End control #defines *******************************************/ /* Define the yytestcase() macro to be a no-op if is not already defined @@ -206,293 +206,287 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (776) +#define YY_ACTTAB_COUNT (762) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 23, 629, 366, 236, 1054, 209, 242, 713, 212, 630, - /* 10 */ 1031, 873, 367, 59, 60, 174, 63, 64, 1044, 1145, - /* 20 */ 256, 53, 52, 51, 629, 62, 324, 67, 65, 68, - /* 30 */ 66, 158, 630, 286, 239, 58, 57, 344, 343, 56, - /* 40 */ 55, 54, 59, 60, 248, 63, 64, 253, 1031, 256, - /* 50 */ 53, 52, 51, 665, 62, 324, 67, 65, 68, 66, - /* 60 */ 1001, 1044, 999, 1000, 58, 57, 210, 1002, 56, 55, - /* 70 */ 54, 1003, 1051, 1004, 1005, 58, 57, 278, 216, 56, - /* 80 */ 55, 54, 59, 60, 165, 63, 64, 38, 83, 256, - /* 90 */ 53, 52, 51, 89, 62, 324, 67, 65, 68, 66, - /* 100 */ 284, 283, 250, 754, 58, 57, 1031, 212, 56, 55, - /* 110 */ 54, 38, 59, 61, 808, 63, 64, 1044, 1146, 256, - /* 120 */ 53, 52, 51, 629, 62, 324, 67, 65, 68, 66, - /* 130 */ 45, 630, 238, 240, 58, 57, 1028, 165, 56, 55, - /* 140 */ 54, 60, 1025, 63, 64, 773, 774, 256, 53, 52, - /* 150 */ 51, 96, 62, 324, 67, 65, 68, 66, 165, 1093, - /* 160 */ 1027, 296, 58, 57, 89, 84, 56, 55, 54, 578, - /* 170 */ 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, - /* 180 */ 589, 590, 591, 156, 322, 237, 63, 64, 758, 249, - /* 190 */ 256, 53, 52, 51, 629, 62, 324, 67, 65, 68, - /* 200 */ 66, 45, 630, 88, 1017, 58, 57, 362, 962, 56, - /* 210 */ 55, 54, 1092, 44, 320, 361, 360, 319, 318, 317, - /* 220 */ 359, 316, 315, 314, 358, 313, 357, 356, 155, 153, - /* 230 */ 152, 298, 24, 94, 993, 981, 982, 983, 984, 985, - /* 240 */ 986, 987, 988, 989, 990, 991, 992, 994, 995, 215, - /* 250 */ 751, 255, 823, 924, 126, 812, 223, 815, 354, 818, - /* 260 */ 193, 98, 140, 139, 138, 222, 354, 255, 823, 329, - /* 270 */ 89, 812, 252, 815, 270, 818, 9, 29, 217, 67, - /* 280 */ 65, 68, 66, 274, 273, 234, 235, 58, 57, 325, - /* 290 */ 322, 56, 55, 54, 1014, 1015, 35, 1018, 814, 218, - /* 300 */ 817, 234, 235, 259, 5, 41, 183, 45, 56, 55, - /* 310 */ 54, 182, 107, 112, 103, 111, 38, 264, 737, 38, - /* 320 */ 934, 734, 742, 735, 743, 736, 165, 193, 257, 277, - /* 330 */ 309, 81, 212, 38, 69, 124, 118, 129, 230, 813, - /* 340 */ 1140, 816, 128, 1146, 134, 137, 127, 203, 201, 199, - /* 350 */ 69, 261, 262, 131, 198, 144, 143, 142, 141, 38, - /* 360 */ 44, 246, 361, 360, 247, 1028, 101, 359, 1028, 824, - /* 370 */ 819, 358, 38, 357, 356, 38, 820, 38, 333, 260, - /* 380 */ 38, 258, 1028, 332, 331, 824, 819, 790, 212, 365, - /* 390 */ 364, 149, 820, 266, 38, 263, 38, 339, 338, 1146, - /* 400 */ 265, 95, 1019, 14, 334, 265, 82, 97, 1028, 86, - /* 410 */ 77, 179, 265, 3, 194, 87, 180, 335, 326, 821, - /* 420 */ 336, 1028, 340, 1029, 1028, 341, 1028, 925, 279, 1028, - /* 430 */ 74, 1, 181, 770, 193, 738, 739, 100, 34, 342, - /* 440 */ 1016, 346, 39, 1028, 789, 1028, 73, 160, 780, 781, - /* 450 */ 78, 723, 73, 301, 725, 303, 724, 810, 254, 846, - /* 460 */ 822, 825, 70, 26, 628, 39, 80, 39, 70, 99, - /* 470 */ 70, 304, 75, 25, 16, 25, 15, 1139, 25, 117, - /* 480 */ 6, 116, 18, 1138, 17, 740, 20, 741, 19, 123, - /* 490 */ 232, 122, 22, 233, 21, 811, 136, 135, 712, 213, - /* 500 */ 275, 214, 219, 211, 220, 221, 225, 1030, 226, 227, - /* 510 */ 224, 208, 1165, 1157, 1103, 1046, 1102, 244, 1099, 1098, - /* 520 */ 245, 345, 827, 157, 48, 1053, 1064, 1085, 1061, 1062, - /* 530 */ 1045, 1084, 281, 1066, 1026, 154, 159, 164, 292, 175, - /* 540 */ 176, 1024, 33, 285, 177, 168, 178, 939, 769, 306, - /* 550 */ 307, 308, 311, 312, 1042, 46, 206, 42, 323, 933, - /* 560 */ 330, 1164, 114, 241, 79, 1163, 287, 1160, 289, 76, - /* 570 */ 166, 299, 184, 337, 167, 1156, 50, 120, 1155, 297, - /* 580 */ 1152, 185, 295, 959, 43, 40, 47, 207, 921, 130, - /* 590 */ 919, 132, 133, 917, 916, 267, 293, 196, 197, 913, - /* 600 */ 912, 911, 910, 291, 909, 908, 907, 200, 202, 904, - /* 610 */ 902, 900, 898, 204, 895, 205, 288, 891, 49, 310, - /* 620 */ 280, 85, 90, 290, 355, 1086, 348, 125, 347, 349, - /* 630 */ 350, 351, 231, 352, 251, 305, 353, 363, 871, 269, - /* 640 */ 870, 268, 271, 228, 229, 108, 938, 937, 109, 272, - /* 650 */ 869, 852, 276, 851, 73, 10, 915, 300, 282, 914, - /* 660 */ 745, 145, 188, 146, 187, 960, 186, 189, 190, 192, - /* 670 */ 191, 906, 905, 961, 147, 997, 2, 30, 148, 897, - /* 680 */ 896, 91, 171, 169, 172, 170, 173, 1007, 771, 4, - /* 690 */ 161, 163, 782, 162, 243, 776, 92, 31, 778, 93, - /* 700 */ 294, 11, 12, 32, 13, 27, 302, 28, 100, 102, - /* 710 */ 105, 36, 104, 643, 37, 106, 678, 676, 675, 674, - /* 720 */ 672, 671, 670, 667, 633, 321, 110, 7, 327, 328, - /* 730 */ 828, 39, 826, 8, 113, 71, 115, 72, 715, 714, - /* 740 */ 119, 711, 659, 121, 657, 649, 655, 651, 653, 647, - /* 750 */ 645, 681, 680, 679, 677, 673, 669, 668, 195, 631, - /* 760 */ 595, 875, 874, 874, 874, 874, 874, 874, 874, 874, - /* 770 */ 874, 874, 874, 874, 150, 151, + /* 0 */ 94, 615, 233, 244, 356, 227, 1004, 239, 243, 616, + /* 10 */ 615, 1004, 21, 55, 56, 241, 59, 60, 616, 1004, + /* 20 */ 247, 49, 48, 47, 200, 58, 315, 63, 61, 64, + /* 30 */ 62, 987, 988, 33, 991, 54, 53, 853, 357, 52, + /* 40 */ 51, 50, 55, 56, 97, 59, 60, 650, 248, 247, + /* 50 */ 49, 48, 47, 201, 58, 315, 63, 61, 64, 62, + /* 60 */ 976, 203, 974, 975, 54, 53, 203, 977, 52, 51, + /* 70 */ 50, 978, 1119, 979, 980, 54, 53, 1119, 992, 52, + /* 80 */ 51, 50, 55, 56, 1017, 59, 60, 159, 79, 247, + /* 90 */ 49, 48, 47, 27, 58, 315, 63, 61, 64, 62, + /* 100 */ 269, 313, 693, 990, 54, 53, 203, 998, 52, 51, + /* 110 */ 50, 345, 55, 57, 788, 59, 60, 1119, 36, 247, + /* 120 */ 49, 48, 47, 615, 58, 315, 63, 61, 64, 62, + /* 130 */ 1017, 616, 335, 334, 54, 53, 152, 615, 52, 51, + /* 140 */ 50, 56, 36, 59, 60, 616, 230, 247, 49, 48, + /* 150 */ 47, 240, 58, 315, 63, 61, 64, 62, 159, 1066, + /* 160 */ 229, 287, 54, 53, 1001, 73, 52, 51, 50, 565, + /* 170 */ 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, + /* 180 */ 576, 577, 578, 150, 237, 228, 59, 60, 1001, 313, + /* 190 */ 247, 49, 48, 47, 250, 58, 315, 63, 61, 64, + /* 200 */ 62, 203, 275, 274, 74, 54, 53, 753, 754, 52, + /* 210 */ 51, 50, 1118, 42, 311, 351, 350, 310, 309, 308, + /* 220 */ 349, 307, 306, 305, 348, 304, 347, 346, 289, 22, + /* 230 */ 90, 970, 958, 959, 960, 961, 962, 963, 964, 965, + /* 240 */ 966, 967, 968, 969, 971, 972, 212, 1017, 246, 803, + /* 250 */ 36, 36, 792, 213, 795, 36, 798, 168, 36, 134, + /* 260 */ 133, 132, 214, 231, 246, 803, 320, 85, 792, 251, + /* 270 */ 795, 249, 798, 323, 322, 277, 63, 61, 64, 62, + /* 280 */ 206, 255, 225, 226, 54, 53, 316, 85, 52, 51, + /* 290 */ 50, 12, 238, 324, 85, 93, 1001, 1001, 225, 226, + /* 300 */ 325, 1000, 717, 43, 1001, 714, 261, 715, 207, 716, + /* 310 */ 194, 192, 190, 159, 1027, 265, 264, 189, 138, 137, + /* 320 */ 136, 135, 36, 43, 96, 268, 42, 77, 351, 350, + /* 330 */ 43, 65, 84, 349, 221, 252, 253, 348, 36, 347, + /* 340 */ 346, 3, 39, 175, 119, 113, 123, 65, 36, 103, + /* 350 */ 107, 99, 106, 128, 131, 122, 257, 36, 254, 36, + /* 360 */ 330, 329, 125, 159, 326, 804, 799, 300, 1001, 734, + /* 370 */ 36, 121, 800, 52, 51, 50, 794, 256, 797, 1024, + /* 380 */ 327, 804, 799, 345, 1001, 1065, 173, 793, 800, 796, + /* 390 */ 331, 149, 147, 146, 1001, 355, 354, 143, 256, 332, + /* 400 */ 256, 333, 903, 1001, 770, 1001, 78, 174, 185, 1002, + /* 410 */ 352, 940, 337, 70, 92, 731, 1001, 913, 718, 719, + /* 420 */ 904, 82, 270, 185, 790, 83, 185, 750, 80, 760, + /* 430 */ 761, 703, 292, 705, 294, 91, 37, 704, 989, 32, + /* 440 */ 7, 154, 826, 66, 24, 37, 37, 66, 95, 805, + /* 450 */ 245, 66, 317, 738, 71, 614, 23, 69, 76, 208, + /* 460 */ 769, 69, 791, 23, 14, 112, 13, 111, 16, 23, + /* 470 */ 15, 295, 4, 722, 720, 723, 721, 18, 118, 17, + /* 480 */ 117, 20, 1113, 19, 130, 129, 1112, 1111, 223, 692, + /* 490 */ 224, 204, 205, 209, 202, 210, 801, 211, 216, 217, + /* 500 */ 218, 215, 199, 1003, 1138, 1130, 1019, 802, 1076, 1075, + /* 510 */ 235, 1072, 1071, 44, 236, 336, 266, 1058, 169, 151, + /* 520 */ 1026, 148, 1037, 1034, 1035, 1018, 272, 1057, 1039, 999, + /* 530 */ 1015, 276, 153, 232, 278, 280, 31, 158, 283, 163, + /* 540 */ 170, 160, 997, 161, 749, 162, 164, 165, 166, 171, + /* 550 */ 172, 301, 917, 297, 290, 807, 284, 298, 299, 302, + /* 560 */ 303, 197, 40, 75, 314, 912, 321, 1137, 109, 72, + /* 570 */ 46, 1136, 1133, 288, 176, 328, 1129, 115, 1128, 1125, + /* 580 */ 177, 286, 937, 41, 38, 198, 901, 279, 124, 899, + /* 590 */ 126, 127, 897, 896, 258, 187, 188, 893, 892, 891, + /* 600 */ 890, 889, 888, 282, 887, 191, 193, 884, 882, 880, + /* 610 */ 878, 195, 875, 196, 871, 45, 120, 271, 81, 86, + /* 620 */ 338, 281, 1059, 339, 340, 341, 222, 343, 342, 242, + /* 630 */ 296, 344, 353, 851, 259, 260, 219, 220, 850, 104, + /* 640 */ 916, 915, 262, 263, 849, 832, 895, 894, 831, 267, + /* 650 */ 291, 139, 69, 886, 180, 140, 179, 938, 178, 181, + /* 660 */ 182, 184, 183, 939, 141, 885, 8, 142, 877, 2, + /* 670 */ 1, 876, 725, 28, 273, 167, 87, 751, 155, 157, + /* 680 */ 762, 156, 234, 756, 88, 29, 758, 89, 285, 9, + /* 690 */ 30, 10, 11, 25, 293, 26, 96, 98, 101, 34, + /* 700 */ 100, 628, 35, 102, 663, 661, 660, 659, 657, 656, + /* 710 */ 655, 652, 619, 312, 105, 5, 318, 806, 319, 6, + /* 720 */ 808, 108, 110, 67, 68, 695, 37, 694, 691, 114, + /* 730 */ 644, 116, 642, 634, 640, 636, 638, 632, 630, 665, + /* 740 */ 664, 662, 658, 654, 653, 186, 617, 144, 582, 855, + /* 750 */ 854, 854, 854, 854, 854, 854, 854, 854, 854, 854, + /* 760 */ 854, 145, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 267, 1, 200, 201, 200, 267, 246, 5, 267, 9, - /* 10 */ 250, 198, 199, 13, 14, 254, 16, 17, 248, 278, - /* 20 */ 20, 21, 22, 23, 1, 25, 26, 27, 28, 29, - /* 30 */ 30, 200, 9, 272, 264, 35, 36, 35, 36, 39, - /* 40 */ 40, 41, 13, 14, 246, 16, 17, 207, 250, 20, - /* 50 */ 21, 22, 23, 5, 25, 26, 27, 28, 29, 30, - /* 60 */ 224, 248, 226, 227, 35, 36, 267, 231, 39, 40, - /* 70 */ 41, 235, 268, 237, 238, 35, 36, 264, 267, 39, - /* 80 */ 40, 41, 13, 14, 200, 16, 17, 200, 88, 20, + /* 0 */ 206, 1, 242, 205, 199, 200, 246, 242, 205, 9, + /* 10 */ 1, 246, 263, 13, 14, 242, 16, 17, 9, 246, + /* 20 */ 20, 21, 22, 23, 263, 25, 26, 27, 28, 29, + /* 30 */ 30, 237, 238, 239, 240, 35, 36, 197, 198, 39, + /* 40 */ 40, 41, 13, 14, 206, 16, 17, 5, 205, 20, + /* 50 */ 21, 22, 23, 263, 25, 26, 27, 28, 29, 30, + /* 60 */ 221, 263, 223, 224, 35, 36, 263, 228, 39, 40, + /* 70 */ 41, 232, 274, 234, 235, 35, 36, 274, 240, 39, + /* 80 */ 40, 41, 13, 14, 244, 16, 17, 199, 88, 20, /* 90 */ 21, 22, 23, 84, 25, 26, 27, 28, 29, 30, - /* 100 */ 269, 270, 246, 39, 35, 36, 250, 267, 39, 40, - /* 110 */ 41, 200, 13, 14, 85, 16, 17, 248, 278, 20, + /* 100 */ 260, 86, 5, 0, 35, 36, 263, 199, 39, 40, + /* 110 */ 41, 92, 13, 14, 85, 16, 17, 274, 199, 20, /* 120 */ 21, 22, 23, 1, 25, 26, 27, 28, 29, 30, - /* 130 */ 121, 9, 245, 264, 35, 36, 249, 200, 39, 40, - /* 140 */ 41, 14, 200, 16, 17, 127, 128, 20, 21, 22, - /* 150 */ 23, 251, 25, 26, 27, 28, 29, 30, 200, 275, - /* 160 */ 249, 277, 35, 36, 84, 265, 39, 40, 41, 47, + /* 130 */ 244, 9, 35, 36, 35, 36, 199, 1, 39, 40, + /* 140 */ 41, 14, 199, 16, 17, 9, 260, 20, 21, 22, + /* 150 */ 23, 243, 25, 26, 27, 28, 29, 30, 199, 271, + /* 160 */ 241, 273, 35, 36, 245, 99, 39, 40, 41, 47, /* 170 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - /* 180 */ 58, 59, 60, 61, 86, 63, 16, 17, 124, 247, - /* 190 */ 20, 21, 22, 23, 1, 25, 26, 27, 28, 29, - /* 200 */ 30, 121, 9, 123, 0, 35, 36, 222, 223, 39, - /* 210 */ 40, 41, 275, 100, 101, 102, 103, 104, 105, 106, - /* 220 */ 107, 108, 109, 110, 111, 112, 113, 114, 64, 65, - /* 230 */ 66, 273, 46, 275, 224, 225, 226, 227, 228, 229, - /* 240 */ 230, 231, 232, 233, 234, 235, 236, 237, 238, 63, - /* 250 */ 99, 1, 2, 206, 80, 5, 70, 7, 92, 9, - /* 260 */ 213, 208, 76, 77, 78, 79, 92, 1, 2, 83, - /* 270 */ 84, 5, 207, 7, 144, 9, 125, 84, 267, 27, - /* 280 */ 28, 29, 30, 153, 154, 35, 36, 35, 36, 39, - /* 290 */ 86, 39, 40, 41, 241, 242, 243, 244, 5, 267, - /* 300 */ 7, 35, 36, 70, 64, 65, 66, 121, 39, 40, - /* 310 */ 41, 71, 72, 73, 74, 75, 200, 70, 2, 200, - /* 320 */ 206, 5, 5, 7, 7, 9, 200, 213, 207, 143, - /* 330 */ 90, 145, 267, 200, 84, 64, 65, 66, 152, 5, - /* 340 */ 267, 7, 71, 278, 73, 74, 75, 64, 65, 66, - /* 350 */ 84, 35, 36, 82, 71, 72, 73, 74, 75, 200, - /* 360 */ 100, 245, 102, 103, 245, 249, 208, 107, 249, 119, - /* 370 */ 120, 111, 200, 113, 114, 200, 126, 200, 245, 146, - /* 380 */ 200, 148, 249, 150, 151, 119, 120, 78, 267, 67, - /* 390 */ 68, 69, 126, 146, 200, 148, 200, 150, 151, 278, - /* 400 */ 200, 275, 244, 84, 245, 200, 208, 88, 249, 85, - /* 410 */ 99, 211, 200, 204, 205, 85, 211, 245, 15, 126, - /* 420 */ 245, 249, 245, 211, 249, 245, 249, 206, 85, 249, - /* 430 */ 99, 209, 210, 85, 213, 119, 120, 118, 84, 245, - /* 440 */ 242, 245, 99, 249, 135, 249, 122, 99, 85, 85, - /* 450 */ 139, 85, 122, 85, 85, 85, 85, 1, 62, 85, - /* 460 */ 126, 85, 99, 99, 85, 99, 84, 99, 99, 99, - /* 470 */ 99, 117, 141, 99, 147, 99, 149, 267, 99, 147, - /* 480 */ 84, 149, 147, 267, 149, 5, 147, 7, 149, 147, - /* 490 */ 267, 149, 147, 267, 149, 39, 80, 81, 116, 267, - /* 500 */ 200, 267, 267, 267, 267, 267, 267, 250, 267, 267, - /* 510 */ 267, 267, 250, 250, 240, 248, 240, 240, 240, 240, - /* 520 */ 240, 240, 119, 200, 266, 200, 200, 276, 200, 200, - /* 530 */ 248, 276, 248, 200, 248, 62, 200, 200, 200, 252, - /* 540 */ 200, 200, 253, 271, 200, 260, 200, 200, 126, 200, - /* 550 */ 200, 200, 200, 200, 263, 200, 200, 200, 200, 200, - /* 560 */ 200, 200, 200, 271, 138, 200, 271, 200, 271, 140, - /* 570 */ 262, 133, 200, 200, 261, 200, 137, 200, 200, 136, - /* 580 */ 200, 200, 131, 200, 200, 200, 200, 200, 200, 200, - /* 590 */ 200, 200, 200, 200, 200, 200, 130, 200, 200, 200, - /* 600 */ 200, 200, 200, 129, 200, 200, 200, 200, 200, 200, - /* 610 */ 200, 200, 200, 200, 200, 200, 132, 200, 142, 91, - /* 620 */ 202, 202, 202, 202, 115, 202, 53, 98, 97, 94, - /* 630 */ 96, 57, 202, 95, 202, 202, 93, 86, 5, 5, - /* 640 */ 5, 155, 155, 202, 202, 208, 212, 212, 208, 5, - /* 650 */ 5, 102, 144, 101, 122, 84, 202, 117, 99, 202, - /* 660 */ 85, 203, 215, 203, 219, 221, 220, 218, 216, 214, - /* 670 */ 217, 202, 202, 223, 203, 239, 209, 84, 203, 202, - /* 680 */ 202, 99, 257, 259, 256, 258, 255, 239, 85, 204, - /* 690 */ 84, 99, 85, 84, 1, 85, 84, 99, 85, 84, - /* 700 */ 84, 134, 134, 99, 84, 84, 117, 84, 118, 80, - /* 710 */ 72, 89, 88, 5, 89, 88, 9, 5, 5, 5, - /* 720 */ 5, 5, 5, 5, 87, 15, 80, 84, 26, 61, - /* 730 */ 119, 99, 85, 84, 149, 16, 149, 16, 5, 5, - /* 740 */ 149, 85, 5, 149, 5, 5, 5, 5, 5, 5, - /* 750 */ 5, 5, 5, 5, 5, 5, 5, 5, 99, 87, - /* 760 */ 62, 0, 279, 279, 279, 279, 279, 279, 279, 279, - /* 770 */ 279, 279, 279, 279, 21, 21, 279, 279, 279, 279, - /* 780 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 790 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 800 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 810 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 820 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 830 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 840 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 850 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 860 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 870 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 880 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 890 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 900 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 910 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 920 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 930 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 940 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 950 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 960 */ 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, - /* 970 */ 279, 279, 279, + /* 180 */ 58, 59, 60, 61, 241, 63, 16, 17, 245, 86, + /* 190 */ 20, 21, 22, 23, 70, 25, 26, 27, 28, 29, + /* 200 */ 30, 263, 265, 266, 138, 35, 36, 126, 127, 39, + /* 210 */ 40, 41, 274, 100, 101, 102, 103, 104, 105, 106, + /* 220 */ 107, 108, 109, 110, 111, 112, 113, 114, 269, 46, + /* 230 */ 271, 221, 222, 223, 224, 225, 226, 227, 228, 229, + /* 240 */ 230, 231, 232, 233, 234, 235, 63, 244, 1, 2, + /* 250 */ 199, 199, 5, 70, 7, 199, 9, 250, 199, 76, + /* 260 */ 77, 78, 79, 260, 1, 2, 83, 84, 5, 145, + /* 270 */ 7, 147, 9, 149, 150, 268, 27, 28, 29, 30, + /* 280 */ 263, 70, 35, 36, 35, 36, 39, 84, 39, 40, + /* 290 */ 41, 84, 241, 241, 84, 88, 245, 245, 35, 36, + /* 300 */ 241, 245, 2, 120, 245, 5, 143, 7, 263, 9, + /* 310 */ 64, 65, 66, 199, 199, 152, 153, 71, 72, 73, + /* 320 */ 74, 75, 199, 120, 117, 142, 100, 144, 102, 103, + /* 330 */ 120, 84, 122, 107, 151, 35, 36, 111, 199, 113, + /* 340 */ 114, 64, 65, 66, 64, 65, 66, 84, 199, 72, + /* 350 */ 73, 74, 75, 73, 74, 75, 145, 199, 147, 199, + /* 360 */ 149, 150, 82, 199, 241, 118, 119, 90, 245, 39, + /* 370 */ 199, 80, 125, 39, 40, 41, 5, 199, 7, 264, + /* 380 */ 241, 118, 119, 92, 245, 271, 208, 5, 125, 7, + /* 390 */ 241, 64, 65, 66, 245, 67, 68, 69, 199, 241, + /* 400 */ 199, 241, 204, 245, 78, 245, 206, 208, 210, 208, + /* 410 */ 219, 220, 241, 99, 247, 99, 245, 204, 118, 119, + /* 420 */ 204, 85, 85, 210, 1, 85, 210, 85, 261, 85, + /* 430 */ 85, 85, 85, 85, 85, 271, 99, 85, 238, 84, + /* 440 */ 124, 99, 85, 99, 99, 99, 99, 99, 99, 85, + /* 450 */ 62, 99, 15, 123, 140, 85, 99, 121, 84, 263, + /* 460 */ 134, 121, 39, 99, 146, 146, 148, 148, 146, 99, + /* 470 */ 148, 116, 84, 5, 5, 7, 7, 146, 146, 148, + /* 480 */ 148, 146, 263, 148, 80, 81, 263, 263, 263, 115, + /* 490 */ 263, 263, 263, 263, 263, 263, 125, 263, 263, 263, + /* 500 */ 263, 263, 263, 246, 246, 246, 244, 125, 236, 236, + /* 510 */ 236, 236, 236, 262, 236, 236, 199, 272, 248, 199, + /* 520 */ 199, 62, 199, 199, 199, 244, 244, 272, 199, 244, + /* 530 */ 259, 267, 199, 267, 267, 267, 249, 199, 199, 255, + /* 540 */ 199, 258, 199, 257, 125, 256, 254, 253, 252, 199, + /* 550 */ 199, 91, 199, 199, 132, 118, 129, 199, 199, 199, + /* 560 */ 199, 199, 199, 137, 199, 199, 199, 199, 199, 139, + /* 570 */ 136, 199, 199, 135, 199, 199, 199, 199, 199, 199, + /* 580 */ 199, 130, 199, 199, 199, 199, 199, 131, 199, 199, + /* 590 */ 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, + /* 600 */ 199, 199, 199, 128, 199, 199, 199, 199, 199, 199, + /* 610 */ 199, 199, 199, 199, 199, 141, 98, 201, 201, 201, + /* 620 */ 97, 201, 201, 53, 94, 96, 201, 95, 57, 201, + /* 630 */ 201, 93, 86, 5, 154, 5, 201, 201, 5, 206, + /* 640 */ 209, 209, 154, 5, 5, 102, 201, 201, 101, 143, + /* 650 */ 116, 202, 121, 201, 212, 202, 216, 218, 217, 215, + /* 660 */ 213, 211, 214, 220, 202, 201, 84, 202, 201, 203, + /* 670 */ 207, 201, 85, 84, 99, 251, 99, 85, 84, 99, + /* 680 */ 85, 84, 1, 85, 84, 99, 85, 84, 84, 133, + /* 690 */ 99, 133, 84, 84, 116, 84, 117, 80, 72, 89, + /* 700 */ 88, 5, 89, 88, 9, 5, 5, 5, 5, 5, + /* 710 */ 5, 5, 87, 15, 80, 84, 26, 85, 61, 84, + /* 720 */ 118, 148, 148, 16, 16, 5, 99, 5, 85, 148, + /* 730 */ 5, 148, 5, 5, 5, 5, 5, 5, 5, 5, + /* 740 */ 5, 5, 5, 5, 5, 99, 87, 21, 62, 0, + /* 750 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 760 */ 275, 21, 275, 275, 275, 275, 275, 275, 275, 275, + /* 770 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 780 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 790 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 800 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 810 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 820 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 830 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 840 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 850 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 860 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 870 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 880 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 890 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 900 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 910 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 920 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 930 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 940 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275, + /* 950 */ 275, 275, 275, 275, 275, 275, 275, 275, }; -#define YY_SHIFT_COUNT (367) +#define YY_SHIFT_COUNT (357) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (761) +#define YY_SHIFT_MAX (749) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 186, 113, 113, 260, 260, 98, 250, 266, 266, 193, - /* 10 */ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, - /* 20 */ 23, 23, 23, 0, 122, 266, 316, 316, 316, 9, - /* 30 */ 9, 23, 23, 18, 23, 204, 23, 23, 23, 23, - /* 40 */ 174, 98, 166, 166, 48, 776, 776, 776, 266, 266, - /* 50 */ 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, - /* 60 */ 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, - /* 70 */ 316, 316, 316, 80, 2, 2, 2, 2, 2, 2, - /* 80 */ 2, 23, 23, 23, 64, 23, 23, 23, 9, 9, - /* 90 */ 23, 23, 23, 23, 309, 309, 151, 9, 23, 23, - /* 100 */ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, - /* 110 */ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, - /* 120 */ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, - /* 130 */ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, - /* 140 */ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, - /* 150 */ 23, 23, 23, 23, 23, 23, 23, 473, 473, 473, - /* 160 */ 422, 422, 422, 422, 473, 473, 426, 429, 438, 439, - /* 170 */ 443, 451, 466, 474, 484, 476, 473, 473, 473, 528, - /* 180 */ 528, 509, 98, 98, 473, 473, 529, 531, 573, 535, - /* 190 */ 534, 574, 538, 543, 509, 48, 473, 473, 551, 551, - /* 200 */ 473, 551, 473, 551, 473, 473, 776, 776, 29, 69, - /* 210 */ 69, 99, 69, 127, 170, 240, 252, 252, 252, 252, - /* 220 */ 252, 252, 271, 283, 40, 40, 40, 40, 233, 247, - /* 230 */ 130, 319, 269, 269, 293, 334, 322, 164, 343, 324, - /* 240 */ 330, 348, 363, 364, 331, 311, 366, 368, 369, 370, - /* 250 */ 371, 354, 374, 376, 456, 396, 403, 379, 327, 332, - /* 260 */ 335, 317, 480, 339, 342, 382, 345, 416, 633, 486, - /* 270 */ 634, 635, 487, 644, 645, 549, 552, 508, 532, 540, - /* 280 */ 571, 575, 593, 559, 582, 603, 606, 607, 609, 610, - /* 290 */ 592, 612, 613, 615, 693, 616, 598, 567, 604, 568, - /* 300 */ 620, 540, 621, 589, 623, 590, 629, 622, 624, 638, - /* 310 */ 708, 625, 627, 707, 712, 713, 714, 715, 716, 717, - /* 320 */ 718, 637, 710, 646, 643, 647, 611, 649, 702, 668, - /* 330 */ 719, 585, 587, 632, 632, 632, 632, 721, 591, 594, - /* 340 */ 632, 632, 632, 733, 734, 656, 632, 737, 739, 740, - /* 350 */ 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, - /* 360 */ 751, 752, 659, 672, 753, 754, 698, 761, + /* 0 */ 183, 113, 226, 15, 247, 263, 263, 9, 136, 136, + /* 10 */ 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + /* 20 */ 136, 0, 122, 263, 300, 300, 300, 203, 203, 136, + /* 30 */ 136, 81, 136, 103, 136, 136, 136, 136, 291, 15, + /* 40 */ 19, 19, 42, 762, 263, 263, 263, 263, 263, 263, + /* 50 */ 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + /* 60 */ 263, 263, 263, 263, 263, 263, 300, 300, 300, 210, + /* 70 */ 97, 97, 97, 97, 97, 97, 97, 136, 136, 136, + /* 80 */ 330, 136, 136, 136, 203, 203, 136, 136, 136, 136, + /* 90 */ 326, 326, 316, 203, 136, 136, 136, 136, 136, 136, + /* 100 */ 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + /* 110 */ 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + /* 120 */ 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + /* 130 */ 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + /* 140 */ 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + /* 150 */ 136, 459, 459, 459, 419, 419, 419, 419, 459, 459, + /* 160 */ 426, 430, 422, 434, 438, 451, 427, 475, 456, 474, + /* 170 */ 459, 459, 459, 460, 460, 15, 459, 459, 518, 523, + /* 180 */ 570, 530, 529, 571, 532, 538, 42, 459, 459, 546, + /* 190 */ 546, 459, 546, 459, 546, 459, 459, 762, 762, 29, + /* 200 */ 69, 69, 99, 69, 127, 170, 249, 249, 249, 249, + /* 210 */ 249, 249, 277, 246, 280, 40, 40, 40, 40, 124, + /* 220 */ 211, 163, 207, 334, 334, 371, 382, 328, 327, 337, + /* 230 */ 336, 340, 342, 344, 345, 314, 66, 346, 347, 348, + /* 240 */ 349, 352, 355, 357, 364, 423, 388, 437, 370, 318, + /* 250 */ 319, 322, 468, 469, 331, 332, 374, 335, 404, 628, + /* 260 */ 480, 630, 633, 488, 638, 639, 543, 547, 506, 531, + /* 270 */ 534, 582, 587, 589, 575, 577, 592, 594, 595, 597, + /* 280 */ 598, 580, 600, 601, 603, 681, 604, 586, 556, 591, + /* 290 */ 558, 608, 534, 609, 578, 611, 579, 617, 610, 612, + /* 300 */ 626, 696, 613, 615, 695, 700, 701, 702, 703, 704, + /* 310 */ 705, 706, 625, 698, 634, 631, 632, 602, 635, 690, + /* 320 */ 657, 707, 573, 574, 627, 627, 627, 627, 708, 581, + /* 330 */ 583, 627, 627, 627, 720, 722, 643, 627, 725, 727, + /* 340 */ 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, + /* 350 */ 738, 739, 646, 659, 726, 740, 686, 749, }; -#define YY_REDUCE_COUNT (207) -#define YY_REDUCE_MIN (-267) -#define YY_REDUCE_MAX (485) +#define YY_REDUCE_COUNT (198) +#define YY_REDUCE_MIN (-251) +#define YY_REDUCE_MAX (470) static const short yy_reduce_ofst[] = { - /* 0 */ -187, 10, 10, -164, -164, 53, -160, 65, 121, -169, - /* 10 */ -113, -116, -42, 116, 119, 133, 159, 172, 175, 177, - /* 20 */ 180, 194, 196, -196, -198, -259, -240, -202, -144, -230, - /* 30 */ -131, -63, 126, -239, -58, 158, 200, 205, 212, -89, - /* 40 */ 47, 198, 114, 221, -15, -100, 222, 209, -267, -262, - /* 50 */ -201, -189, 11, 32, 73, 210, 216, 223, 226, 232, - /* 60 */ 234, 235, 236, 237, 238, 239, 241, 242, 243, 244, - /* 70 */ 257, 262, 263, 267, 274, 276, 277, 278, 279, 280, - /* 80 */ 281, 300, 323, 325, 258, 326, 328, 329, 282, 284, - /* 90 */ 333, 336, 337, 338, 251, 255, 287, 286, 340, 341, - /* 100 */ 344, 346, 347, 349, 350, 351, 352, 353, 355, 356, - /* 110 */ 357, 358, 359, 360, 361, 362, 365, 367, 372, 373, - /* 120 */ 375, 377, 378, 380, 381, 383, 384, 385, 386, 387, - /* 130 */ 388, 389, 390, 391, 392, 393, 394, 395, 397, 398, - /* 140 */ 399, 400, 401, 402, 404, 405, 406, 407, 408, 409, - /* 150 */ 410, 411, 412, 413, 414, 415, 417, 418, 419, 420, - /* 160 */ 272, 292, 295, 297, 421, 423, 291, 308, 313, 285, - /* 170 */ 424, 427, 425, 428, 431, 289, 430, 432, 433, 434, - /* 180 */ 435, 436, 437, 440, 441, 442, 444, 446, 445, 447, - /* 190 */ 449, 452, 453, 455, 448, 450, 454, 457, 458, 460, - /* 200 */ 469, 471, 470, 475, 477, 478, 467, 485, + /* 0 */ -160, 10, -161, -206, -202, -197, -157, -63, -81, -112, + /* 10 */ -41, -57, 51, 52, 59, 123, 139, 149, 158, 160, + /* 20 */ 171, 115, -195, -62, -240, -235, -227, -114, 3, 114, + /* 30 */ 164, 7, -92, -162, 178, 199, 201, 56, 198, 200, + /* 40 */ 213, 216, 191, 167, -251, -239, -210, 17, 45, 196, + /* 50 */ 219, 223, 224, 225, 227, 228, 229, 230, 231, 232, + /* 60 */ 234, 235, 236, 237, 238, 239, 257, 258, 259, 262, + /* 70 */ 272, 273, 274, 275, 276, 278, 279, 317, 320, 321, + /* 80 */ 251, 323, 324, 325, 281, 282, 329, 333, 338, 339, + /* 90 */ 245, 255, 270, 285, 341, 343, 350, 351, 353, 354, + /* 100 */ 358, 359, 360, 361, 362, 363, 365, 366, 367, 368, + /* 110 */ 369, 372, 373, 375, 376, 377, 378, 379, 380, 381, + /* 120 */ 383, 384, 385, 386, 387, 389, 390, 391, 392, 393, + /* 130 */ 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, + /* 140 */ 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + /* 150 */ 415, 416, 417, 418, 264, 266, 267, 268, 420, 421, + /* 160 */ 271, 283, 286, 289, 284, 292, 294, 296, 424, 287, + /* 170 */ 425, 428, 429, 431, 432, 433, 435, 436, 439, 441, + /* 180 */ 440, 442, 444, 447, 448, 450, 443, 445, 446, 449, + /* 190 */ 453, 452, 462, 464, 465, 467, 470, 463, 466, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 872, 996, 935, 1006, 922, 932, 1148, 1148, 1148, 872, - /* 10 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 20 */ 872, 872, 872, 1055, 892, 1148, 872, 872, 872, 872, - /* 30 */ 872, 872, 872, 1070, 872, 932, 872, 872, 872, 872, - /* 40 */ 942, 932, 942, 942, 872, 1050, 980, 998, 872, 872, - /* 50 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 60 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 70 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 80 */ 872, 872, 872, 872, 1057, 1063, 1060, 872, 872, 872, - /* 90 */ 1065, 872, 872, 872, 1089, 1089, 1048, 872, 872, 872, - /* 100 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 110 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 120 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 130 */ 920, 872, 918, 872, 872, 872, 872, 872, 872, 872, - /* 140 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 903, - /* 150 */ 872, 872, 872, 872, 872, 872, 890, 894, 894, 894, - /* 160 */ 872, 872, 872, 872, 894, 894, 1096, 1100, 1082, 1094, - /* 170 */ 1090, 1077, 1075, 1073, 1081, 1104, 894, 894, 894, 940, - /* 180 */ 940, 936, 932, 932, 894, 894, 958, 956, 954, 946, - /* 190 */ 952, 948, 950, 944, 923, 872, 894, 894, 930, 930, - /* 200 */ 894, 930, 894, 930, 894, 894, 980, 998, 872, 1105, - /* 210 */ 1095, 872, 1147, 1135, 1134, 872, 1143, 1142, 1141, 1133, - /* 220 */ 1132, 1131, 872, 872, 1127, 1130, 1129, 1128, 872, 872, - /* 230 */ 872, 872, 1137, 1136, 872, 872, 872, 872, 872, 872, - /* 240 */ 872, 872, 872, 872, 1101, 1097, 872, 872, 872, 872, - /* 250 */ 872, 872, 872, 872, 872, 1107, 872, 872, 872, 872, - /* 260 */ 872, 872, 872, 872, 872, 1008, 872, 872, 872, 872, - /* 270 */ 872, 872, 872, 872, 872, 872, 872, 872, 1047, 872, - /* 280 */ 872, 872, 872, 1059, 1058, 872, 872, 872, 872, 872, - /* 290 */ 872, 872, 872, 872, 872, 872, 1091, 872, 1083, 872, - /* 300 */ 872, 1020, 872, 872, 872, 872, 872, 872, 872, 872, - /* 310 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 320 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 330 */ 872, 872, 872, 1166, 1161, 1162, 1159, 872, 872, 872, - /* 340 */ 1158, 1153, 1154, 872, 872, 872, 1151, 872, 872, 872, - /* 350 */ 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, - /* 360 */ 872, 872, 964, 872, 901, 899, 872, 872, + /* 0 */ 852, 914, 902, 911, 1121, 1121, 1121, 852, 852, 852, + /* 10 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 20 */ 852, 1028, 872, 1121, 852, 852, 852, 852, 852, 852, + /* 30 */ 852, 1043, 852, 911, 852, 852, 852, 852, 920, 911, + /* 40 */ 920, 920, 852, 1023, 852, 852, 852, 852, 852, 852, + /* 50 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 60 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 70 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 80 */ 1030, 1036, 1033, 852, 852, 852, 1038, 852, 852, 852, + /* 90 */ 1062, 1062, 1021, 852, 852, 852, 852, 852, 852, 852, + /* 100 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 110 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 120 */ 852, 852, 852, 852, 900, 852, 898, 852, 852, 852, + /* 130 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 140 */ 852, 852, 852, 883, 852, 852, 852, 852, 852, 852, + /* 150 */ 870, 874, 874, 874, 852, 852, 852, 852, 874, 874, + /* 160 */ 1069, 1073, 1055, 1067, 1063, 1050, 1048, 1046, 1054, 1077, + /* 170 */ 874, 874, 874, 918, 918, 911, 874, 874, 936, 934, + /* 180 */ 932, 924, 930, 926, 928, 922, 852, 874, 874, 909, + /* 190 */ 909, 874, 909, 874, 909, 874, 874, 957, 973, 852, + /* 200 */ 1078, 1068, 852, 1120, 1108, 1107, 1116, 1115, 1114, 1106, + /* 210 */ 1105, 1104, 852, 852, 852, 1100, 1103, 1102, 1101, 852, + /* 220 */ 852, 852, 852, 1110, 1109, 852, 852, 852, 852, 852, + /* 230 */ 852, 852, 852, 852, 852, 1074, 1070, 852, 852, 852, + /* 240 */ 852, 852, 852, 852, 852, 852, 1080, 852, 852, 852, + /* 250 */ 852, 852, 852, 852, 852, 852, 981, 852, 852, 852, + /* 260 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 1020, + /* 270 */ 852, 852, 852, 852, 1032, 1031, 852, 852, 852, 852, + /* 280 */ 852, 852, 852, 852, 852, 852, 852, 1064, 852, 1056, + /* 290 */ 852, 852, 993, 852, 852, 852, 852, 852, 852, 852, + /* 300 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 310 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 320 */ 852, 852, 852, 852, 1139, 1134, 1135, 1132, 852, 852, + /* 330 */ 852, 1131, 1126, 1127, 852, 852, 852, 1124, 852, 852, + /* 340 */ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, + /* 350 */ 852, 852, 942, 852, 881, 879, 852, 852, }; /********** End of lemon-generated parsing tables *****************************/ @@ -627,7 +621,6 @@ static const YYCODETYPE yyFallback[] = { 0, /* PRECISION => nothing */ 0, /* UPDATE => nothing */ 0, /* CACHELAST => nothing */ - 0, /* PARTITIONS => nothing */ 0, /* UNSIGNED => nothing */ 0, /* TAGS => nothing */ 0, /* USING => nothing */ @@ -910,170 +903,166 @@ static const char *const yyTokenName[] = { /* 112 */ "PRECISION", /* 113 */ "UPDATE", /* 114 */ "CACHELAST", - /* 115 */ "PARTITIONS", - /* 116 */ "UNSIGNED", - /* 117 */ "TAGS", - /* 118 */ "USING", - /* 119 */ "NULL", - /* 120 */ "NOW", - /* 121 */ "SELECT", - /* 122 */ "UNION", - /* 123 */ "ALL", - /* 124 */ "DISTINCT", - /* 125 */ "FROM", - /* 126 */ "VARIABLE", - /* 127 */ "INTERVAL", - /* 128 */ "EVERY", - /* 129 */ "SESSION", - /* 130 */ "STATE_WINDOW", - /* 131 */ "FILL", - /* 132 */ "SLIDING", - /* 133 */ "ORDER", - /* 134 */ "BY", - /* 135 */ "ASC", - /* 136 */ "GROUP", - /* 137 */ "HAVING", - /* 138 */ "LIMIT", - /* 139 */ "OFFSET", - /* 140 */ "SLIMIT", - /* 141 */ "SOFFSET", - /* 142 */ "WHERE", - /* 143 */ "RESET", - /* 144 */ "QUERY", - /* 145 */ "SYNCDB", - /* 146 */ "ADD", - /* 147 */ "COLUMN", - /* 148 */ "MODIFY", - /* 149 */ "TAG", - /* 150 */ "CHANGE", - /* 151 */ "SET", - /* 152 */ "KILL", - /* 153 */ "CONNECTION", - /* 154 */ "STREAM", - /* 155 */ "COLON", - /* 156 */ "ABORT", - /* 157 */ "AFTER", - /* 158 */ "ATTACH", - /* 159 */ "BEFORE", - /* 160 */ "BEGIN", - /* 161 */ "CASCADE", - /* 162 */ "CLUSTER", - /* 163 */ "CONFLICT", - /* 164 */ "COPY", - /* 165 */ "DEFERRED", - /* 166 */ "DELIMITERS", - /* 167 */ "DETACH", - /* 168 */ "EACH", - /* 169 */ "END", - /* 170 */ "EXPLAIN", - /* 171 */ "FAIL", - /* 172 */ "FOR", - /* 173 */ "IGNORE", - /* 174 */ "IMMEDIATE", - /* 175 */ "INITIALLY", - /* 176 */ "INSTEAD", - /* 177 */ "KEY", - /* 178 */ "OF", - /* 179 */ "RAISE", - /* 180 */ "REPLACE", - /* 181 */ "RESTRICT", - /* 182 */ "ROW", - /* 183 */ "STATEMENT", - /* 184 */ "TRIGGER", - /* 185 */ "VIEW", - /* 186 */ "IPTOKEN", - /* 187 */ "SEMI", - /* 188 */ "NONE", - /* 189 */ "PREV", - /* 190 */ "LINEAR", - /* 191 */ "IMPORT", - /* 192 */ "TBNAME", - /* 193 */ "JOIN", - /* 194 */ "INSERT", - /* 195 */ "INTO", - /* 196 */ "VALUES", - /* 197 */ "error", - /* 198 */ "program", - /* 199 */ "cmd", - /* 200 */ "ids", - /* 201 */ "dbPrefix", - /* 202 */ "cpxName", - /* 203 */ "ifexists", - /* 204 */ "alter_db_optr", - /* 205 */ "alter_topic_optr", - /* 206 */ "acct_optr", - /* 207 */ "exprlist", - /* 208 */ "ifnotexists", - /* 209 */ "db_optr", - /* 210 */ "topic_optr", - /* 211 */ "typename", - /* 212 */ "bufsize", - /* 213 */ "pps", - /* 214 */ "tseries", - /* 215 */ "dbs", - /* 216 */ "streams", - /* 217 */ "storage", - /* 218 */ "qtime", - /* 219 */ "users", - /* 220 */ "conns", - /* 221 */ "state", - /* 222 */ "intitemlist", - /* 223 */ "intitem", - /* 224 */ "keep", - /* 225 */ "cache", - /* 226 */ "replica", - /* 227 */ "quorum", - /* 228 */ "days", - /* 229 */ "minrows", - /* 230 */ "maxrows", - /* 231 */ "blocks", - /* 232 */ "ctime", - /* 233 */ "wal", - /* 234 */ "fsync", - /* 235 */ "comp", - /* 236 */ "prec", - /* 237 */ "update", - /* 238 */ "cachelast", - /* 239 */ "partitions", - /* 240 */ "signed", - /* 241 */ "create_table_args", - /* 242 */ "create_stable_args", - /* 243 */ "create_table_list", - /* 244 */ "create_from_stable", - /* 245 */ "columnlist", - /* 246 */ "tagitemlist", - /* 247 */ "tagNamelist", - /* 248 */ "select", - /* 249 */ "column", - /* 250 */ "tagitem", - /* 251 */ "selcollist", - /* 252 */ "from", - /* 253 */ "where_opt", - /* 254 */ "interval_option", - /* 255 */ "sliding_opt", - /* 256 */ "session_option", - /* 257 */ "windowstate_option", - /* 258 */ "fill_opt", - /* 259 */ "groupby_opt", - /* 260 */ "having_opt", - /* 261 */ "orderby_opt", - /* 262 */ "slimit_opt", - /* 263 */ "limit_opt", - /* 264 */ "union", - /* 265 */ "sclp", - /* 266 */ "distinct", - /* 267 */ "expr", - /* 268 */ "as", - /* 269 */ "tablelist", - /* 270 */ "sub", - /* 271 */ "tmvar", - /* 272 */ "intervalKey", - /* 273 */ "sortlist", - /* 274 */ "sortitem", - /* 275 */ "item", - /* 276 */ "sortorder", - /* 277 */ "grouplist", - /* 278 */ "expritem", + /* 115 */ "UNSIGNED", + /* 116 */ "TAGS", + /* 117 */ "USING", + /* 118 */ "NULL", + /* 119 */ "NOW", + /* 120 */ "SELECT", + /* 121 */ "UNION", + /* 122 */ "ALL", + /* 123 */ "DISTINCT", + /* 124 */ "FROM", + /* 125 */ "VARIABLE", + /* 126 */ "INTERVAL", + /* 127 */ "EVERY", + /* 128 */ "SESSION", + /* 129 */ "STATE_WINDOW", + /* 130 */ "FILL", + /* 131 */ "SLIDING", + /* 132 */ "ORDER", + /* 133 */ "BY", + /* 134 */ "ASC", + /* 135 */ "GROUP", + /* 136 */ "HAVING", + /* 137 */ "LIMIT", + /* 138 */ "OFFSET", + /* 139 */ "SLIMIT", + /* 140 */ "SOFFSET", + /* 141 */ "WHERE", + /* 142 */ "RESET", + /* 143 */ "QUERY", + /* 144 */ "SYNCDB", + /* 145 */ "ADD", + /* 146 */ "COLUMN", + /* 147 */ "MODIFY", + /* 148 */ "TAG", + /* 149 */ "CHANGE", + /* 150 */ "SET", + /* 151 */ "KILL", + /* 152 */ "CONNECTION", + /* 153 */ "STREAM", + /* 154 */ "COLON", + /* 155 */ "ABORT", + /* 156 */ "AFTER", + /* 157 */ "ATTACH", + /* 158 */ "BEFORE", + /* 159 */ "BEGIN", + /* 160 */ "CASCADE", + /* 161 */ "CLUSTER", + /* 162 */ "CONFLICT", + /* 163 */ "COPY", + /* 164 */ "DEFERRED", + /* 165 */ "DELIMITERS", + /* 166 */ "DETACH", + /* 167 */ "EACH", + /* 168 */ "END", + /* 169 */ "EXPLAIN", + /* 170 */ "FAIL", + /* 171 */ "FOR", + /* 172 */ "IGNORE", + /* 173 */ "IMMEDIATE", + /* 174 */ "INITIALLY", + /* 175 */ "INSTEAD", + /* 176 */ "KEY", + /* 177 */ "OF", + /* 178 */ "RAISE", + /* 179 */ "REPLACE", + /* 180 */ "RESTRICT", + /* 181 */ "ROW", + /* 182 */ "STATEMENT", + /* 183 */ "TRIGGER", + /* 184 */ "VIEW", + /* 185 */ "IPTOKEN", + /* 186 */ "SEMI", + /* 187 */ "NONE", + /* 188 */ "PREV", + /* 189 */ "LINEAR", + /* 190 */ "IMPORT", + /* 191 */ "TBNAME", + /* 192 */ "JOIN", + /* 193 */ "INSERT", + /* 194 */ "INTO", + /* 195 */ "VALUES", + /* 196 */ "error", + /* 197 */ "program", + /* 198 */ "cmd", + /* 199 */ "ids", + /* 200 */ "dbPrefix", + /* 201 */ "cpxName", + /* 202 */ "ifexists", + /* 203 */ "alter_db_optr", + /* 204 */ "acct_optr", + /* 205 */ "exprlist", + /* 206 */ "ifnotexists", + /* 207 */ "db_optr", + /* 208 */ "typename", + /* 209 */ "bufsize", + /* 210 */ "pps", + /* 211 */ "tseries", + /* 212 */ "dbs", + /* 213 */ "streams", + /* 214 */ "storage", + /* 215 */ "qtime", + /* 216 */ "users", + /* 217 */ "conns", + /* 218 */ "state", + /* 219 */ "intitemlist", + /* 220 */ "intitem", + /* 221 */ "keep", + /* 222 */ "cache", + /* 223 */ "replica", + /* 224 */ "quorum", + /* 225 */ "days", + /* 226 */ "minrows", + /* 227 */ "maxrows", + /* 228 */ "blocks", + /* 229 */ "ctime", + /* 230 */ "wal", + /* 231 */ "fsync", + /* 232 */ "comp", + /* 233 */ "prec", + /* 234 */ "update", + /* 235 */ "cachelast", + /* 236 */ "signed", + /* 237 */ "create_table_args", + /* 238 */ "create_stable_args", + /* 239 */ "create_table_list", + /* 240 */ "create_from_stable", + /* 241 */ "columnlist", + /* 242 */ "tagitemlist", + /* 243 */ "tagNamelist", + /* 244 */ "select", + /* 245 */ "column", + /* 246 */ "tagitem", + /* 247 */ "selcollist", + /* 248 */ "from", + /* 249 */ "where_opt", + /* 250 */ "interval_option", + /* 251 */ "sliding_opt", + /* 252 */ "session_option", + /* 253 */ "windowstate_option", + /* 254 */ "fill_opt", + /* 255 */ "groupby_opt", + /* 256 */ "having_opt", + /* 257 */ "orderby_opt", + /* 258 */ "slimit_opt", + /* 259 */ "limit_opt", + /* 260 */ "union", + /* 261 */ "sclp", + /* 262 */ "distinct", + /* 263 */ "expr", + /* 264 */ "as", + /* 265 */ "tablelist", + /* 266 */ "sub", + /* 267 */ "tmvar", + /* 268 */ "intervalKey", + /* 269 */ "sortlist", + /* 270 */ "sortitem", + /* 271 */ "item", + /* 272 */ "sortorder", + /* 273 */ "grouplist", + /* 274 */ "expritem", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -1129,253 +1118,246 @@ static const char *const yyRuleName[] = { /* 45 */ "cmd ::= ALTER LOCAL ids", /* 46 */ "cmd ::= ALTER LOCAL ids ids", /* 47 */ "cmd ::= ALTER DATABASE ids alter_db_optr", - /* 48 */ "cmd ::= ALTER TOPIC ids alter_topic_optr", - /* 49 */ "cmd ::= ALTER ACCOUNT ids acct_optr", - /* 50 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr", - /* 51 */ "cmd ::= COMPACT VNODES IN LP exprlist RP", - /* 52 */ "ids ::= ID", - /* 53 */ "ids ::= STRING", - /* 54 */ "ifexists ::= IF EXISTS", - /* 55 */ "ifexists ::=", - /* 56 */ "ifnotexists ::= IF NOT EXISTS", - /* 57 */ "ifnotexists ::=", - /* 58 */ "cmd ::= CREATE DNODE ids", - /* 59 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr", - /* 60 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr", - /* 61 */ "cmd ::= CREATE TOPIC ifnotexists ids topic_optr", - /* 62 */ "cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize", - /* 63 */ "cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize", - /* 64 */ "cmd ::= CREATE USER ids PASS ids", - /* 65 */ "bufsize ::=", - /* 66 */ "bufsize ::= BUFSIZE INTEGER", - /* 67 */ "pps ::=", - /* 68 */ "pps ::= PPS INTEGER", - /* 69 */ "tseries ::=", - /* 70 */ "tseries ::= TSERIES INTEGER", - /* 71 */ "dbs ::=", - /* 72 */ "dbs ::= DBS INTEGER", - /* 73 */ "streams ::=", - /* 74 */ "streams ::= STREAMS INTEGER", - /* 75 */ "storage ::=", - /* 76 */ "storage ::= STORAGE INTEGER", - /* 77 */ "qtime ::=", - /* 78 */ "qtime ::= QTIME INTEGER", - /* 79 */ "users ::=", - /* 80 */ "users ::= USERS INTEGER", - /* 81 */ "conns ::=", - /* 82 */ "conns ::= CONNS INTEGER", - /* 83 */ "state ::=", - /* 84 */ "state ::= STATE ids", - /* 85 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state", - /* 86 */ "intitemlist ::= intitemlist COMMA intitem", - /* 87 */ "intitemlist ::= intitem", - /* 88 */ "intitem ::= INTEGER", - /* 89 */ "keep ::= KEEP intitemlist", - /* 90 */ "cache ::= CACHE INTEGER", - /* 91 */ "replica ::= REPLICA INTEGER", - /* 92 */ "quorum ::= QUORUM INTEGER", - /* 93 */ "days ::= DAYS INTEGER", - /* 94 */ "minrows ::= MINROWS INTEGER", - /* 95 */ "maxrows ::= MAXROWS INTEGER", - /* 96 */ "blocks ::= BLOCKS INTEGER", - /* 97 */ "ctime ::= CTIME INTEGER", - /* 98 */ "wal ::= WAL INTEGER", - /* 99 */ "fsync ::= FSYNC INTEGER", - /* 100 */ "comp ::= COMP INTEGER", - /* 101 */ "prec ::= PRECISION STRING", - /* 102 */ "update ::= UPDATE INTEGER", - /* 103 */ "cachelast ::= CACHELAST INTEGER", - /* 104 */ "partitions ::= PARTITIONS INTEGER", - /* 105 */ "db_optr ::=", - /* 106 */ "db_optr ::= db_optr cache", - /* 107 */ "db_optr ::= db_optr replica", - /* 108 */ "db_optr ::= db_optr quorum", - /* 109 */ "db_optr ::= db_optr days", - /* 110 */ "db_optr ::= db_optr minrows", - /* 111 */ "db_optr ::= db_optr maxrows", - /* 112 */ "db_optr ::= db_optr blocks", - /* 113 */ "db_optr ::= db_optr ctime", - /* 114 */ "db_optr ::= db_optr wal", - /* 115 */ "db_optr ::= db_optr fsync", - /* 116 */ "db_optr ::= db_optr comp", - /* 117 */ "db_optr ::= db_optr prec", - /* 118 */ "db_optr ::= db_optr keep", - /* 119 */ "db_optr ::= db_optr update", - /* 120 */ "db_optr ::= db_optr cachelast", - /* 121 */ "topic_optr ::= db_optr", - /* 122 */ "topic_optr ::= topic_optr partitions", - /* 123 */ "alter_db_optr ::=", - /* 124 */ "alter_db_optr ::= alter_db_optr replica", - /* 125 */ "alter_db_optr ::= alter_db_optr quorum", - /* 126 */ "alter_db_optr ::= alter_db_optr keep", - /* 127 */ "alter_db_optr ::= alter_db_optr blocks", - /* 128 */ "alter_db_optr ::= alter_db_optr comp", - /* 129 */ "alter_db_optr ::= alter_db_optr update", - /* 130 */ "alter_db_optr ::= alter_db_optr cachelast", - /* 131 */ "alter_topic_optr ::= alter_db_optr", - /* 132 */ "alter_topic_optr ::= alter_topic_optr partitions", - /* 133 */ "typename ::= ids", - /* 134 */ "typename ::= ids LP signed RP", - /* 135 */ "typename ::= ids UNSIGNED", - /* 136 */ "signed ::= INTEGER", - /* 137 */ "signed ::= PLUS INTEGER", - /* 138 */ "signed ::= MINUS INTEGER", - /* 139 */ "cmd ::= CREATE TABLE create_table_args", - /* 140 */ "cmd ::= CREATE TABLE create_stable_args", - /* 141 */ "cmd ::= CREATE STABLE create_stable_args", - /* 142 */ "cmd ::= CREATE TABLE create_table_list", - /* 143 */ "create_table_list ::= create_from_stable", - /* 144 */ "create_table_list ::= create_table_list create_from_stable", - /* 145 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP", - /* 146 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP", - /* 147 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP", - /* 148 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP", - /* 149 */ "tagNamelist ::= tagNamelist COMMA ids", - /* 150 */ "tagNamelist ::= ids", - /* 151 */ "create_table_args ::= ifnotexists ids cpxName AS select", - /* 152 */ "columnlist ::= columnlist COMMA column", - /* 153 */ "columnlist ::= column", - /* 154 */ "column ::= ids typename", - /* 155 */ "tagitemlist ::= tagitemlist COMMA tagitem", - /* 156 */ "tagitemlist ::= tagitem", - /* 157 */ "tagitem ::= INTEGER", - /* 158 */ "tagitem ::= FLOAT", - /* 159 */ "tagitem ::= STRING", - /* 160 */ "tagitem ::= BOOL", - /* 161 */ "tagitem ::= NULL", - /* 162 */ "tagitem ::= NOW", - /* 163 */ "tagitem ::= MINUS INTEGER", - /* 164 */ "tagitem ::= MINUS FLOAT", - /* 165 */ "tagitem ::= PLUS INTEGER", - /* 166 */ "tagitem ::= PLUS FLOAT", - /* 167 */ "select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt", - /* 168 */ "select ::= LP select RP", - /* 169 */ "union ::= select", - /* 170 */ "union ::= union UNION ALL select", - /* 171 */ "union ::= union UNION select", - /* 172 */ "cmd ::= union", - /* 173 */ "select ::= SELECT selcollist", - /* 174 */ "sclp ::= selcollist COMMA", - /* 175 */ "sclp ::=", - /* 176 */ "selcollist ::= sclp distinct expr as", - /* 177 */ "selcollist ::= sclp STAR", - /* 178 */ "as ::= AS ids", - /* 179 */ "as ::= ids", - /* 180 */ "as ::=", - /* 181 */ "distinct ::= DISTINCT", - /* 182 */ "distinct ::=", - /* 183 */ "from ::= FROM tablelist", - /* 184 */ "from ::= FROM sub", - /* 185 */ "sub ::= LP union RP", - /* 186 */ "sub ::= LP union RP ids", - /* 187 */ "sub ::= sub COMMA LP union RP ids", - /* 188 */ "tablelist ::= ids cpxName", - /* 189 */ "tablelist ::= ids cpxName ids", - /* 190 */ "tablelist ::= tablelist COMMA ids cpxName", - /* 191 */ "tablelist ::= tablelist COMMA ids cpxName ids", - /* 192 */ "tmvar ::= VARIABLE", - /* 193 */ "interval_option ::= intervalKey LP tmvar RP", - /* 194 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP", - /* 195 */ "interval_option ::=", - /* 196 */ "intervalKey ::= INTERVAL", - /* 197 */ "intervalKey ::= EVERY", - /* 198 */ "session_option ::=", - /* 199 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP", - /* 200 */ "windowstate_option ::=", - /* 201 */ "windowstate_option ::= STATE_WINDOW LP ids RP", - /* 202 */ "fill_opt ::=", - /* 203 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP", - /* 204 */ "fill_opt ::= FILL LP ID RP", - /* 205 */ "sliding_opt ::= SLIDING LP tmvar RP", - /* 206 */ "sliding_opt ::=", - /* 207 */ "orderby_opt ::=", - /* 208 */ "orderby_opt ::= ORDER BY sortlist", - /* 209 */ "sortlist ::= sortlist COMMA item sortorder", - /* 210 */ "sortlist ::= item sortorder", - /* 211 */ "item ::= ids cpxName", - /* 212 */ "sortorder ::= ASC", - /* 213 */ "sortorder ::= DESC", - /* 214 */ "sortorder ::=", - /* 215 */ "groupby_opt ::=", - /* 216 */ "groupby_opt ::= GROUP BY grouplist", - /* 217 */ "grouplist ::= grouplist COMMA item", - /* 218 */ "grouplist ::= item", - /* 219 */ "having_opt ::=", - /* 220 */ "having_opt ::= HAVING expr", - /* 221 */ "limit_opt ::=", - /* 222 */ "limit_opt ::= LIMIT signed", - /* 223 */ "limit_opt ::= LIMIT signed OFFSET signed", - /* 224 */ "limit_opt ::= LIMIT signed COMMA signed", - /* 225 */ "slimit_opt ::=", - /* 226 */ "slimit_opt ::= SLIMIT signed", - /* 227 */ "slimit_opt ::= SLIMIT signed SOFFSET signed", - /* 228 */ "slimit_opt ::= SLIMIT signed COMMA signed", - /* 229 */ "where_opt ::=", - /* 230 */ "where_opt ::= WHERE expr", - /* 231 */ "expr ::= LP expr RP", - /* 232 */ "expr ::= ID", - /* 233 */ "expr ::= ID DOT ID", - /* 234 */ "expr ::= ID DOT STAR", - /* 235 */ "expr ::= INTEGER", - /* 236 */ "expr ::= MINUS INTEGER", - /* 237 */ "expr ::= PLUS INTEGER", - /* 238 */ "expr ::= FLOAT", - /* 239 */ "expr ::= MINUS FLOAT", - /* 240 */ "expr ::= PLUS FLOAT", - /* 241 */ "expr ::= STRING", - /* 242 */ "expr ::= NOW", - /* 243 */ "expr ::= VARIABLE", - /* 244 */ "expr ::= PLUS VARIABLE", - /* 245 */ "expr ::= MINUS VARIABLE", - /* 246 */ "expr ::= BOOL", - /* 247 */ "expr ::= NULL", - /* 248 */ "expr ::= ID LP exprlist RP", - /* 249 */ "expr ::= ID LP STAR RP", - /* 250 */ "expr ::= expr IS NULL", - /* 251 */ "expr ::= expr IS NOT NULL", - /* 252 */ "expr ::= expr LT expr", - /* 253 */ "expr ::= expr GT expr", - /* 254 */ "expr ::= expr LE expr", - /* 255 */ "expr ::= expr GE expr", - /* 256 */ "expr ::= expr NE expr", - /* 257 */ "expr ::= expr EQ expr", - /* 258 */ "expr ::= expr BETWEEN expr AND expr", - /* 259 */ "expr ::= expr AND expr", - /* 260 */ "expr ::= expr OR expr", - /* 261 */ "expr ::= expr PLUS expr", - /* 262 */ "expr ::= expr MINUS expr", - /* 263 */ "expr ::= expr STAR expr", - /* 264 */ "expr ::= expr SLASH expr", - /* 265 */ "expr ::= expr REM expr", - /* 266 */ "expr ::= expr LIKE expr", - /* 267 */ "expr ::= expr MATCH expr", - /* 268 */ "expr ::= expr NMATCH expr", - /* 269 */ "expr ::= expr IN LP exprlist RP", - /* 270 */ "exprlist ::= exprlist COMMA expritem", - /* 271 */ "exprlist ::= expritem", - /* 272 */ "expritem ::= expr", - /* 273 */ "expritem ::=", - /* 274 */ "cmd ::= RESET QUERY CACHE", - /* 275 */ "cmd ::= SYNCDB ids REPLICA", - /* 276 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist", - /* 277 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids", - /* 278 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist", - /* 279 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", - /* 280 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", - /* 281 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", - /* 282 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", - /* 283 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist", - /* 284 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", - /* 285 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", - /* 286 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist", - /* 287 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", - /* 288 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", - /* 289 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", - /* 290 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem", - /* 291 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist", - /* 292 */ "cmd ::= KILL CONNECTION INTEGER", - /* 293 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", - /* 294 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", + /* 48 */ "cmd ::= ALTER ACCOUNT ids acct_optr", + /* 49 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr", + /* 50 */ "cmd ::= COMPACT VNODES IN LP exprlist RP", + /* 51 */ "ids ::= ID", + /* 52 */ "ids ::= STRING", + /* 53 */ "ifexists ::= IF EXISTS", + /* 54 */ "ifexists ::=", + /* 55 */ "ifnotexists ::= IF NOT EXISTS", + /* 56 */ "ifnotexists ::=", + /* 57 */ "cmd ::= CREATE DNODE ids", + /* 58 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr", + /* 59 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr", + /* 60 */ "cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize", + /* 61 */ "cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize", + /* 62 */ "cmd ::= CREATE USER ids PASS ids", + /* 63 */ "bufsize ::=", + /* 64 */ "bufsize ::= BUFSIZE INTEGER", + /* 65 */ "pps ::=", + /* 66 */ "pps ::= PPS INTEGER", + /* 67 */ "tseries ::=", + /* 68 */ "tseries ::= TSERIES INTEGER", + /* 69 */ "dbs ::=", + /* 70 */ "dbs ::= DBS INTEGER", + /* 71 */ "streams ::=", + /* 72 */ "streams ::= STREAMS INTEGER", + /* 73 */ "storage ::=", + /* 74 */ "storage ::= STORAGE INTEGER", + /* 75 */ "qtime ::=", + /* 76 */ "qtime ::= QTIME INTEGER", + /* 77 */ "users ::=", + /* 78 */ "users ::= USERS INTEGER", + /* 79 */ "conns ::=", + /* 80 */ "conns ::= CONNS INTEGER", + /* 81 */ "state ::=", + /* 82 */ "state ::= STATE ids", + /* 83 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state", + /* 84 */ "intitemlist ::= intitemlist COMMA intitem", + /* 85 */ "intitemlist ::= intitem", + /* 86 */ "intitem ::= INTEGER", + /* 87 */ "keep ::= KEEP intitemlist", + /* 88 */ "cache ::= CACHE INTEGER", + /* 89 */ "replica ::= REPLICA INTEGER", + /* 90 */ "quorum ::= QUORUM INTEGER", + /* 91 */ "days ::= DAYS INTEGER", + /* 92 */ "minrows ::= MINROWS INTEGER", + /* 93 */ "maxrows ::= MAXROWS INTEGER", + /* 94 */ "blocks ::= BLOCKS INTEGER", + /* 95 */ "ctime ::= CTIME INTEGER", + /* 96 */ "wal ::= WAL INTEGER", + /* 97 */ "fsync ::= FSYNC INTEGER", + /* 98 */ "comp ::= COMP INTEGER", + /* 99 */ "prec ::= PRECISION STRING", + /* 100 */ "update ::= UPDATE INTEGER", + /* 101 */ "cachelast ::= CACHELAST INTEGER", + /* 102 */ "db_optr ::=", + /* 103 */ "db_optr ::= db_optr cache", + /* 104 */ "db_optr ::= db_optr replica", + /* 105 */ "db_optr ::= db_optr quorum", + /* 106 */ "db_optr ::= db_optr days", + /* 107 */ "db_optr ::= db_optr minrows", + /* 108 */ "db_optr ::= db_optr maxrows", + /* 109 */ "db_optr ::= db_optr blocks", + /* 110 */ "db_optr ::= db_optr ctime", + /* 111 */ "db_optr ::= db_optr wal", + /* 112 */ "db_optr ::= db_optr fsync", + /* 113 */ "db_optr ::= db_optr comp", + /* 114 */ "db_optr ::= db_optr prec", + /* 115 */ "db_optr ::= db_optr keep", + /* 116 */ "db_optr ::= db_optr update", + /* 117 */ "db_optr ::= db_optr cachelast", + /* 118 */ "alter_db_optr ::=", + /* 119 */ "alter_db_optr ::= alter_db_optr replica", + /* 120 */ "alter_db_optr ::= alter_db_optr quorum", + /* 121 */ "alter_db_optr ::= alter_db_optr keep", + /* 122 */ "alter_db_optr ::= alter_db_optr blocks", + /* 123 */ "alter_db_optr ::= alter_db_optr comp", + /* 124 */ "alter_db_optr ::= alter_db_optr update", + /* 125 */ "alter_db_optr ::= alter_db_optr cachelast", + /* 126 */ "typename ::= ids", + /* 127 */ "typename ::= ids LP signed RP", + /* 128 */ "typename ::= ids UNSIGNED", + /* 129 */ "signed ::= INTEGER", + /* 130 */ "signed ::= PLUS INTEGER", + /* 131 */ "signed ::= MINUS INTEGER", + /* 132 */ "cmd ::= CREATE TABLE create_table_args", + /* 133 */ "cmd ::= CREATE TABLE create_stable_args", + /* 134 */ "cmd ::= CREATE STABLE create_stable_args", + /* 135 */ "cmd ::= CREATE TABLE create_table_list", + /* 136 */ "create_table_list ::= create_from_stable", + /* 137 */ "create_table_list ::= create_table_list create_from_stable", + /* 138 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP", + /* 139 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP", + /* 140 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP", + /* 141 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP", + /* 142 */ "tagNamelist ::= tagNamelist COMMA ids", + /* 143 */ "tagNamelist ::= ids", + /* 144 */ "create_table_args ::= ifnotexists ids cpxName AS select", + /* 145 */ "columnlist ::= columnlist COMMA column", + /* 146 */ "columnlist ::= column", + /* 147 */ "column ::= ids typename", + /* 148 */ "tagitemlist ::= tagitemlist COMMA tagitem", + /* 149 */ "tagitemlist ::= tagitem", + /* 150 */ "tagitem ::= INTEGER", + /* 151 */ "tagitem ::= FLOAT", + /* 152 */ "tagitem ::= STRING", + /* 153 */ "tagitem ::= BOOL", + /* 154 */ "tagitem ::= NULL", + /* 155 */ "tagitem ::= NOW", + /* 156 */ "tagitem ::= MINUS INTEGER", + /* 157 */ "tagitem ::= MINUS FLOAT", + /* 158 */ "tagitem ::= PLUS INTEGER", + /* 159 */ "tagitem ::= PLUS FLOAT", + /* 160 */ "select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt", + /* 161 */ "select ::= LP select RP", + /* 162 */ "union ::= select", + /* 163 */ "union ::= union UNION ALL select", + /* 164 */ "union ::= union UNION select", + /* 165 */ "cmd ::= union", + /* 166 */ "select ::= SELECT selcollist", + /* 167 */ "sclp ::= selcollist COMMA", + /* 168 */ "sclp ::=", + /* 169 */ "selcollist ::= sclp distinct expr as", + /* 170 */ "selcollist ::= sclp STAR", + /* 171 */ "as ::= AS ids", + /* 172 */ "as ::= ids", + /* 173 */ "as ::=", + /* 174 */ "distinct ::= DISTINCT", + /* 175 */ "distinct ::=", + /* 176 */ "from ::= FROM tablelist", + /* 177 */ "from ::= FROM sub", + /* 178 */ "sub ::= LP union RP", + /* 179 */ "sub ::= LP union RP ids", + /* 180 */ "sub ::= sub COMMA LP union RP ids", + /* 181 */ "tablelist ::= ids cpxName", + /* 182 */ "tablelist ::= ids cpxName ids", + /* 183 */ "tablelist ::= tablelist COMMA ids cpxName", + /* 184 */ "tablelist ::= tablelist COMMA ids cpxName ids", + /* 185 */ "tmvar ::= VARIABLE", + /* 186 */ "interval_option ::= intervalKey LP tmvar RP", + /* 187 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP", + /* 188 */ "interval_option ::=", + /* 189 */ "intervalKey ::= INTERVAL", + /* 190 */ "intervalKey ::= EVERY", + /* 191 */ "session_option ::=", + /* 192 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP", + /* 193 */ "windowstate_option ::=", + /* 194 */ "windowstate_option ::= STATE_WINDOW LP ids RP", + /* 195 */ "fill_opt ::=", + /* 196 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP", + /* 197 */ "fill_opt ::= FILL LP ID RP", + /* 198 */ "sliding_opt ::= SLIDING LP tmvar RP", + /* 199 */ "sliding_opt ::=", + /* 200 */ "orderby_opt ::=", + /* 201 */ "orderby_opt ::= ORDER BY sortlist", + /* 202 */ "sortlist ::= sortlist COMMA item sortorder", + /* 203 */ "sortlist ::= item sortorder", + /* 204 */ "item ::= ids cpxName", + /* 205 */ "sortorder ::= ASC", + /* 206 */ "sortorder ::= DESC", + /* 207 */ "sortorder ::=", + /* 208 */ "groupby_opt ::=", + /* 209 */ "groupby_opt ::= GROUP BY grouplist", + /* 210 */ "grouplist ::= grouplist COMMA item", + /* 211 */ "grouplist ::= item", + /* 212 */ "having_opt ::=", + /* 213 */ "having_opt ::= HAVING expr", + /* 214 */ "limit_opt ::=", + /* 215 */ "limit_opt ::= LIMIT signed", + /* 216 */ "limit_opt ::= LIMIT signed OFFSET signed", + /* 217 */ "limit_opt ::= LIMIT signed COMMA signed", + /* 218 */ "slimit_opt ::=", + /* 219 */ "slimit_opt ::= SLIMIT signed", + /* 220 */ "slimit_opt ::= SLIMIT signed SOFFSET signed", + /* 221 */ "slimit_opt ::= SLIMIT signed COMMA signed", + /* 222 */ "where_opt ::=", + /* 223 */ "where_opt ::= WHERE expr", + /* 224 */ "expr ::= LP expr RP", + /* 225 */ "expr ::= ID", + /* 226 */ "expr ::= ID DOT ID", + /* 227 */ "expr ::= ID DOT STAR", + /* 228 */ "expr ::= INTEGER", + /* 229 */ "expr ::= MINUS INTEGER", + /* 230 */ "expr ::= PLUS INTEGER", + /* 231 */ "expr ::= FLOAT", + /* 232 */ "expr ::= MINUS FLOAT", + /* 233 */ "expr ::= PLUS FLOAT", + /* 234 */ "expr ::= STRING", + /* 235 */ "expr ::= NOW", + /* 236 */ "expr ::= VARIABLE", + /* 237 */ "expr ::= PLUS VARIABLE", + /* 238 */ "expr ::= MINUS VARIABLE", + /* 239 */ "expr ::= BOOL", + /* 240 */ "expr ::= NULL", + /* 241 */ "expr ::= ID LP exprlist RP", + /* 242 */ "expr ::= ID LP STAR RP", + /* 243 */ "expr ::= expr IS NULL", + /* 244 */ "expr ::= expr IS NOT NULL", + /* 245 */ "expr ::= expr LT expr", + /* 246 */ "expr ::= expr GT expr", + /* 247 */ "expr ::= expr LE expr", + /* 248 */ "expr ::= expr GE expr", + /* 249 */ "expr ::= expr NE expr", + /* 250 */ "expr ::= expr EQ expr", + /* 251 */ "expr ::= expr BETWEEN expr AND expr", + /* 252 */ "expr ::= expr AND expr", + /* 253 */ "expr ::= expr OR expr", + /* 254 */ "expr ::= expr PLUS expr", + /* 255 */ "expr ::= expr MINUS expr", + /* 256 */ "expr ::= expr STAR expr", + /* 257 */ "expr ::= expr SLASH expr", + /* 258 */ "expr ::= expr REM expr", + /* 259 */ "expr ::= expr LIKE expr", + /* 260 */ "expr ::= expr MATCH expr", + /* 261 */ "expr ::= expr NMATCH expr", + /* 262 */ "expr ::= expr IN LP exprlist RP", + /* 263 */ "exprlist ::= exprlist COMMA expritem", + /* 264 */ "exprlist ::= expritem", + /* 265 */ "expritem ::= expr", + /* 266 */ "expritem ::=", + /* 267 */ "cmd ::= RESET QUERY CACHE", + /* 268 */ "cmd ::= SYNCDB ids REPLICA", + /* 269 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist", + /* 270 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids", + /* 271 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist", + /* 272 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", + /* 273 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", + /* 274 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", + /* 275 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", + /* 276 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist", + /* 277 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", + /* 278 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", + /* 279 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist", + /* 280 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", + /* 281 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", + /* 282 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", + /* 283 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem", + /* 284 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist", + /* 285 */ "cmd ::= KILL CONNECTION INTEGER", + /* 286 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", + /* 287 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", }; #endif /* NDEBUG */ @@ -1496,60 +1478,60 @@ static void yy_destructor( ** inside the C code. */ /********* Begin destructor definitions ***************************************/ - case 207: /* exprlist */ - case 251: /* selcollist */ - case 265: /* sclp */ + case 205: /* exprlist */ + case 247: /* selcollist */ + case 261: /* sclp */ { -tSqlExprListDestroy((yypminor->yy135)); +tSqlExprListDestroy((yypminor->yy131)); } break; - case 222: /* intitemlist */ - case 224: /* keep */ - case 245: /* columnlist */ - case 246: /* tagitemlist */ - case 247: /* tagNamelist */ - case 258: /* fill_opt */ - case 259: /* groupby_opt */ - case 261: /* orderby_opt */ - case 273: /* sortlist */ - case 277: /* grouplist */ -{ -taosArrayDestroy((yypminor->yy135)); + case 219: /* intitemlist */ + case 221: /* keep */ + case 241: /* columnlist */ + case 242: /* tagitemlist */ + case 243: /* tagNamelist */ + case 254: /* fill_opt */ + case 255: /* groupby_opt */ + case 257: /* orderby_opt */ + case 269: /* sortlist */ + case 273: /* grouplist */ +{ +taosArrayDestroy((yypminor->yy131)); } break; - case 243: /* create_table_list */ + case 239: /* create_table_list */ { -destroyCreateTableSql((yypminor->yy110)); +destroyCreateTableSql((yypminor->yy272)); } break; - case 248: /* select */ + case 244: /* select */ { -destroySqlNode((yypminor->yy488)); +destroySqlNode((yypminor->yy256)); } break; - case 252: /* from */ - case 269: /* tablelist */ - case 270: /* sub */ + case 248: /* from */ + case 265: /* tablelist */ + case 266: /* sub */ { -destroyRelationInfo((yypminor->yy460)); +destroyRelationInfo((yypminor->yy544)); } break; - case 253: /* where_opt */ - case 260: /* having_opt */ - case 267: /* expr */ - case 278: /* expritem */ + case 249: /* where_opt */ + case 256: /* having_opt */ + case 263: /* expr */ + case 274: /* expritem */ { -tSqlExprDestroy((yypminor->yy526)); +tSqlExprDestroy((yypminor->yy46)); } break; - case 264: /* union */ + case 260: /* union */ { -destroyAllSqlNode((yypminor->yy551)); +destroyAllSqlNode((yypminor->yy303)); } break; - case 274: /* sortitem */ + case 270: /* sortitem */ { -taosVariantDestroy(&(yypminor->yy191)); +taosVariantDestroy(&(yypminor->yy43)); } break; /********* End destructor definitions *****************************************/ @@ -1843,301 +1825,294 @@ 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[] = { - { 198, -1 }, /* (0) program ::= cmd */ - { 199, -2 }, /* (1) cmd ::= SHOW DATABASES */ - { 199, -2 }, /* (2) cmd ::= SHOW TOPICS */ - { 199, -2 }, /* (3) cmd ::= SHOW FUNCTIONS */ - { 199, -2 }, /* (4) cmd ::= SHOW MNODES */ - { 199, -2 }, /* (5) cmd ::= SHOW DNODES */ - { 199, -2 }, /* (6) cmd ::= SHOW ACCOUNTS */ - { 199, -2 }, /* (7) cmd ::= SHOW USERS */ - { 199, -2 }, /* (8) cmd ::= SHOW MODULES */ - { 199, -2 }, /* (9) cmd ::= SHOW QUERIES */ - { 199, -2 }, /* (10) cmd ::= SHOW CONNECTIONS */ - { 199, -2 }, /* (11) cmd ::= SHOW STREAMS */ - { 199, -2 }, /* (12) cmd ::= SHOW VARIABLES */ - { 199, -2 }, /* (13) cmd ::= SHOW SCORES */ - { 199, -2 }, /* (14) cmd ::= SHOW GRANTS */ - { 199, -2 }, /* (15) cmd ::= SHOW VNODES */ - { 199, -3 }, /* (16) cmd ::= SHOW VNODES ids */ - { 201, 0 }, /* (17) dbPrefix ::= */ - { 201, -2 }, /* (18) dbPrefix ::= ids DOT */ - { 202, 0 }, /* (19) cpxName ::= */ - { 202, -2 }, /* (20) cpxName ::= DOT ids */ - { 199, -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */ - { 199, -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */ - { 199, -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */ - { 199, -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */ - { 199, -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE ids */ - { 199, -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */ - { 199, -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE ids */ - { 199, -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */ - { 199, -4 }, /* (29) cmd ::= SHOW dbPrefix VGROUPS ids */ - { 199, -5 }, /* (30) cmd ::= DROP TABLE ifexists ids cpxName */ - { 199, -5 }, /* (31) cmd ::= DROP STABLE ifexists ids cpxName */ - { 199, -4 }, /* (32) cmd ::= DROP DATABASE ifexists ids */ - { 199, -4 }, /* (33) cmd ::= DROP TOPIC ifexists ids */ - { 199, -3 }, /* (34) cmd ::= DROP FUNCTION ids */ - { 199, -3 }, /* (35) cmd ::= DROP DNODE ids */ - { 199, -3 }, /* (36) cmd ::= DROP USER ids */ - { 199, -3 }, /* (37) cmd ::= DROP ACCOUNT ids */ - { 199, -2 }, /* (38) cmd ::= USE ids */ - { 199, -3 }, /* (39) cmd ::= DESCRIBE ids cpxName */ - { 199, -3 }, /* (40) cmd ::= DESC ids cpxName */ - { 199, -5 }, /* (41) cmd ::= ALTER USER ids PASS ids */ - { 199, -5 }, /* (42) cmd ::= ALTER USER ids PRIVILEGE ids */ - { 199, -4 }, /* (43) cmd ::= ALTER DNODE ids ids */ - { 199, -5 }, /* (44) cmd ::= ALTER DNODE ids ids ids */ - { 199, -3 }, /* (45) cmd ::= ALTER LOCAL ids */ - { 199, -4 }, /* (46) cmd ::= ALTER LOCAL ids ids */ - { 199, -4 }, /* (47) cmd ::= ALTER DATABASE ids alter_db_optr */ - { 199, -4 }, /* (48) cmd ::= ALTER TOPIC ids alter_topic_optr */ - { 199, -4 }, /* (49) cmd ::= ALTER ACCOUNT ids acct_optr */ - { 199, -6 }, /* (50) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ - { 199, -6 }, /* (51) cmd ::= COMPACT VNODES IN LP exprlist RP */ - { 200, -1 }, /* (52) ids ::= ID */ - { 200, -1 }, /* (53) ids ::= STRING */ - { 203, -2 }, /* (54) ifexists ::= IF EXISTS */ - { 203, 0 }, /* (55) ifexists ::= */ - { 208, -3 }, /* (56) ifnotexists ::= IF NOT EXISTS */ - { 208, 0 }, /* (57) ifnotexists ::= */ - { 199, -3 }, /* (58) cmd ::= CREATE DNODE ids */ - { 199, -6 }, /* (59) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ - { 199, -5 }, /* (60) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ - { 199, -5 }, /* (61) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ - { 199, -8 }, /* (62) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ - { 199, -9 }, /* (63) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ - { 199, -5 }, /* (64) cmd ::= CREATE USER ids PASS ids */ - { 212, 0 }, /* (65) bufsize ::= */ - { 212, -2 }, /* (66) bufsize ::= BUFSIZE INTEGER */ - { 213, 0 }, /* (67) pps ::= */ - { 213, -2 }, /* (68) pps ::= PPS INTEGER */ - { 214, 0 }, /* (69) tseries ::= */ - { 214, -2 }, /* (70) tseries ::= TSERIES INTEGER */ - { 215, 0 }, /* (71) dbs ::= */ - { 215, -2 }, /* (72) dbs ::= DBS INTEGER */ - { 216, 0 }, /* (73) streams ::= */ - { 216, -2 }, /* (74) streams ::= STREAMS INTEGER */ - { 217, 0 }, /* (75) storage ::= */ - { 217, -2 }, /* (76) storage ::= STORAGE INTEGER */ - { 218, 0 }, /* (77) qtime ::= */ - { 218, -2 }, /* (78) qtime ::= QTIME INTEGER */ - { 219, 0 }, /* (79) users ::= */ - { 219, -2 }, /* (80) users ::= USERS INTEGER */ - { 220, 0 }, /* (81) conns ::= */ - { 220, -2 }, /* (82) conns ::= CONNS INTEGER */ - { 221, 0 }, /* (83) state ::= */ - { 221, -2 }, /* (84) state ::= STATE ids */ - { 206, -9 }, /* (85) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ - { 222, -3 }, /* (86) intitemlist ::= intitemlist COMMA intitem */ - { 222, -1 }, /* (87) intitemlist ::= intitem */ - { 223, -1 }, /* (88) intitem ::= INTEGER */ - { 224, -2 }, /* (89) keep ::= KEEP intitemlist */ - { 225, -2 }, /* (90) cache ::= CACHE INTEGER */ - { 226, -2 }, /* (91) replica ::= REPLICA INTEGER */ - { 227, -2 }, /* (92) quorum ::= QUORUM INTEGER */ - { 228, -2 }, /* (93) days ::= DAYS INTEGER */ - { 229, -2 }, /* (94) minrows ::= MINROWS INTEGER */ - { 230, -2 }, /* (95) maxrows ::= MAXROWS INTEGER */ - { 231, -2 }, /* (96) blocks ::= BLOCKS INTEGER */ - { 232, -2 }, /* (97) ctime ::= CTIME INTEGER */ - { 233, -2 }, /* (98) wal ::= WAL INTEGER */ - { 234, -2 }, /* (99) fsync ::= FSYNC INTEGER */ - { 235, -2 }, /* (100) comp ::= COMP INTEGER */ - { 236, -2 }, /* (101) prec ::= PRECISION STRING */ - { 237, -2 }, /* (102) update ::= UPDATE INTEGER */ - { 238, -2 }, /* (103) cachelast ::= CACHELAST INTEGER */ - { 239, -2 }, /* (104) partitions ::= PARTITIONS INTEGER */ - { 209, 0 }, /* (105) db_optr ::= */ - { 209, -2 }, /* (106) db_optr ::= db_optr cache */ - { 209, -2 }, /* (107) db_optr ::= db_optr replica */ - { 209, -2 }, /* (108) db_optr ::= db_optr quorum */ - { 209, -2 }, /* (109) db_optr ::= db_optr days */ - { 209, -2 }, /* (110) db_optr ::= db_optr minrows */ - { 209, -2 }, /* (111) db_optr ::= db_optr maxrows */ - { 209, -2 }, /* (112) db_optr ::= db_optr blocks */ - { 209, -2 }, /* (113) db_optr ::= db_optr ctime */ - { 209, -2 }, /* (114) db_optr ::= db_optr wal */ - { 209, -2 }, /* (115) db_optr ::= db_optr fsync */ - { 209, -2 }, /* (116) db_optr ::= db_optr comp */ - { 209, -2 }, /* (117) db_optr ::= db_optr prec */ - { 209, -2 }, /* (118) db_optr ::= db_optr keep */ - { 209, -2 }, /* (119) db_optr ::= db_optr update */ - { 209, -2 }, /* (120) db_optr ::= db_optr cachelast */ - { 210, -1 }, /* (121) topic_optr ::= db_optr */ - { 210, -2 }, /* (122) topic_optr ::= topic_optr partitions */ - { 204, 0 }, /* (123) alter_db_optr ::= */ - { 204, -2 }, /* (124) alter_db_optr ::= alter_db_optr replica */ - { 204, -2 }, /* (125) alter_db_optr ::= alter_db_optr quorum */ - { 204, -2 }, /* (126) alter_db_optr ::= alter_db_optr keep */ - { 204, -2 }, /* (127) alter_db_optr ::= alter_db_optr blocks */ - { 204, -2 }, /* (128) alter_db_optr ::= alter_db_optr comp */ - { 204, -2 }, /* (129) alter_db_optr ::= alter_db_optr update */ - { 204, -2 }, /* (130) alter_db_optr ::= alter_db_optr cachelast */ - { 205, -1 }, /* (131) alter_topic_optr ::= alter_db_optr */ - { 205, -2 }, /* (132) alter_topic_optr ::= alter_topic_optr partitions */ - { 211, -1 }, /* (133) typename ::= ids */ - { 211, -4 }, /* (134) typename ::= ids LP signed RP */ - { 211, -2 }, /* (135) typename ::= ids UNSIGNED */ - { 240, -1 }, /* (136) signed ::= INTEGER */ - { 240, -2 }, /* (137) signed ::= PLUS INTEGER */ - { 240, -2 }, /* (138) signed ::= MINUS INTEGER */ - { 199, -3 }, /* (139) cmd ::= CREATE TABLE create_table_args */ - { 199, -3 }, /* (140) cmd ::= CREATE TABLE create_stable_args */ - { 199, -3 }, /* (141) cmd ::= CREATE STABLE create_stable_args */ - { 199, -3 }, /* (142) cmd ::= CREATE TABLE create_table_list */ - { 243, -1 }, /* (143) create_table_list ::= create_from_stable */ - { 243, -2 }, /* (144) create_table_list ::= create_table_list create_from_stable */ - { 241, -6 }, /* (145) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ - { 242, -10 }, /* (146) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ - { 244, -10 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ - { 244, -13 }, /* (148) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ - { 247, -3 }, /* (149) tagNamelist ::= tagNamelist COMMA ids */ - { 247, -1 }, /* (150) tagNamelist ::= ids */ - { 241, -5 }, /* (151) create_table_args ::= ifnotexists ids cpxName AS select */ - { 245, -3 }, /* (152) columnlist ::= columnlist COMMA column */ - { 245, -1 }, /* (153) columnlist ::= column */ - { 249, -2 }, /* (154) column ::= ids typename */ - { 246, -3 }, /* (155) tagitemlist ::= tagitemlist COMMA tagitem */ - { 246, -1 }, /* (156) tagitemlist ::= tagitem */ - { 250, -1 }, /* (157) tagitem ::= INTEGER */ - { 250, -1 }, /* (158) tagitem ::= FLOAT */ - { 250, -1 }, /* (159) tagitem ::= STRING */ - { 250, -1 }, /* (160) tagitem ::= BOOL */ - { 250, -1 }, /* (161) tagitem ::= NULL */ - { 250, -1 }, /* (162) tagitem ::= NOW */ - { 250, -2 }, /* (163) tagitem ::= MINUS INTEGER */ - { 250, -2 }, /* (164) tagitem ::= MINUS FLOAT */ - { 250, -2 }, /* (165) tagitem ::= PLUS INTEGER */ - { 250, -2 }, /* (166) tagitem ::= PLUS FLOAT */ - { 248, -14 }, /* (167) select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ - { 248, -3 }, /* (168) select ::= LP select RP */ - { 264, -1 }, /* (169) union ::= select */ - { 264, -4 }, /* (170) union ::= union UNION ALL select */ - { 264, -3 }, /* (171) union ::= union UNION select */ - { 199, -1 }, /* (172) cmd ::= union */ - { 248, -2 }, /* (173) select ::= SELECT selcollist */ - { 265, -2 }, /* (174) sclp ::= selcollist COMMA */ - { 265, 0 }, /* (175) sclp ::= */ - { 251, -4 }, /* (176) selcollist ::= sclp distinct expr as */ - { 251, -2 }, /* (177) selcollist ::= sclp STAR */ - { 268, -2 }, /* (178) as ::= AS ids */ - { 268, -1 }, /* (179) as ::= ids */ - { 268, 0 }, /* (180) as ::= */ - { 266, -1 }, /* (181) distinct ::= DISTINCT */ - { 266, 0 }, /* (182) distinct ::= */ - { 252, -2 }, /* (183) from ::= FROM tablelist */ - { 252, -2 }, /* (184) from ::= FROM sub */ - { 270, -3 }, /* (185) sub ::= LP union RP */ - { 270, -4 }, /* (186) sub ::= LP union RP ids */ - { 270, -6 }, /* (187) sub ::= sub COMMA LP union RP ids */ - { 269, -2 }, /* (188) tablelist ::= ids cpxName */ - { 269, -3 }, /* (189) tablelist ::= ids cpxName ids */ - { 269, -4 }, /* (190) tablelist ::= tablelist COMMA ids cpxName */ - { 269, -5 }, /* (191) tablelist ::= tablelist COMMA ids cpxName ids */ - { 271, -1 }, /* (192) tmvar ::= VARIABLE */ - { 254, -4 }, /* (193) interval_option ::= intervalKey LP tmvar RP */ - { 254, -6 }, /* (194) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ - { 254, 0 }, /* (195) interval_option ::= */ - { 272, -1 }, /* (196) intervalKey ::= INTERVAL */ - { 272, -1 }, /* (197) intervalKey ::= EVERY */ - { 256, 0 }, /* (198) session_option ::= */ - { 256, -7 }, /* (199) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ - { 257, 0 }, /* (200) windowstate_option ::= */ - { 257, -4 }, /* (201) windowstate_option ::= STATE_WINDOW LP ids RP */ - { 258, 0 }, /* (202) fill_opt ::= */ - { 258, -6 }, /* (203) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ - { 258, -4 }, /* (204) fill_opt ::= FILL LP ID RP */ - { 255, -4 }, /* (205) sliding_opt ::= SLIDING LP tmvar RP */ - { 255, 0 }, /* (206) sliding_opt ::= */ - { 261, 0 }, /* (207) orderby_opt ::= */ - { 261, -3 }, /* (208) orderby_opt ::= ORDER BY sortlist */ - { 273, -4 }, /* (209) sortlist ::= sortlist COMMA item sortorder */ - { 273, -2 }, /* (210) sortlist ::= item sortorder */ - { 275, -2 }, /* (211) item ::= ids cpxName */ - { 276, -1 }, /* (212) sortorder ::= ASC */ - { 276, -1 }, /* (213) sortorder ::= DESC */ - { 276, 0 }, /* (214) sortorder ::= */ - { 259, 0 }, /* (215) groupby_opt ::= */ - { 259, -3 }, /* (216) groupby_opt ::= GROUP BY grouplist */ - { 277, -3 }, /* (217) grouplist ::= grouplist COMMA item */ - { 277, -1 }, /* (218) grouplist ::= item */ - { 260, 0 }, /* (219) having_opt ::= */ - { 260, -2 }, /* (220) having_opt ::= HAVING expr */ - { 263, 0 }, /* (221) limit_opt ::= */ - { 263, -2 }, /* (222) limit_opt ::= LIMIT signed */ - { 263, -4 }, /* (223) limit_opt ::= LIMIT signed OFFSET signed */ - { 263, -4 }, /* (224) limit_opt ::= LIMIT signed COMMA signed */ - { 262, 0 }, /* (225) slimit_opt ::= */ - { 262, -2 }, /* (226) slimit_opt ::= SLIMIT signed */ - { 262, -4 }, /* (227) slimit_opt ::= SLIMIT signed SOFFSET signed */ - { 262, -4 }, /* (228) slimit_opt ::= SLIMIT signed COMMA signed */ - { 253, 0 }, /* (229) where_opt ::= */ - { 253, -2 }, /* (230) where_opt ::= WHERE expr */ - { 267, -3 }, /* (231) expr ::= LP expr RP */ - { 267, -1 }, /* (232) expr ::= ID */ - { 267, -3 }, /* (233) expr ::= ID DOT ID */ - { 267, -3 }, /* (234) expr ::= ID DOT STAR */ - { 267, -1 }, /* (235) expr ::= INTEGER */ - { 267, -2 }, /* (236) expr ::= MINUS INTEGER */ - { 267, -2 }, /* (237) expr ::= PLUS INTEGER */ - { 267, -1 }, /* (238) expr ::= FLOAT */ - { 267, -2 }, /* (239) expr ::= MINUS FLOAT */ - { 267, -2 }, /* (240) expr ::= PLUS FLOAT */ - { 267, -1 }, /* (241) expr ::= STRING */ - { 267, -1 }, /* (242) expr ::= NOW */ - { 267, -1 }, /* (243) expr ::= VARIABLE */ - { 267, -2 }, /* (244) expr ::= PLUS VARIABLE */ - { 267, -2 }, /* (245) expr ::= MINUS VARIABLE */ - { 267, -1 }, /* (246) expr ::= BOOL */ - { 267, -1 }, /* (247) expr ::= NULL */ - { 267, -4 }, /* (248) expr ::= ID LP exprlist RP */ - { 267, -4 }, /* (249) expr ::= ID LP STAR RP */ - { 267, -3 }, /* (250) expr ::= expr IS NULL */ - { 267, -4 }, /* (251) expr ::= expr IS NOT NULL */ - { 267, -3 }, /* (252) expr ::= expr LT expr */ - { 267, -3 }, /* (253) expr ::= expr GT expr */ - { 267, -3 }, /* (254) expr ::= expr LE expr */ - { 267, -3 }, /* (255) expr ::= expr GE expr */ - { 267, -3 }, /* (256) expr ::= expr NE expr */ - { 267, -3 }, /* (257) expr ::= expr EQ expr */ - { 267, -5 }, /* (258) expr ::= expr BETWEEN expr AND expr */ - { 267, -3 }, /* (259) expr ::= expr AND expr */ - { 267, -3 }, /* (260) expr ::= expr OR expr */ - { 267, -3 }, /* (261) expr ::= expr PLUS expr */ - { 267, -3 }, /* (262) expr ::= expr MINUS expr */ - { 267, -3 }, /* (263) expr ::= expr STAR expr */ - { 267, -3 }, /* (264) expr ::= expr SLASH expr */ - { 267, -3 }, /* (265) expr ::= expr REM expr */ - { 267, -3 }, /* (266) expr ::= expr LIKE expr */ - { 267, -3 }, /* (267) expr ::= expr MATCH expr */ - { 267, -3 }, /* (268) expr ::= expr NMATCH expr */ - { 267, -5 }, /* (269) expr ::= expr IN LP exprlist RP */ - { 207, -3 }, /* (270) exprlist ::= exprlist COMMA expritem */ - { 207, -1 }, /* (271) exprlist ::= expritem */ - { 278, -1 }, /* (272) expritem ::= expr */ - { 278, 0 }, /* (273) expritem ::= */ - { 199, -3 }, /* (274) cmd ::= RESET QUERY CACHE */ - { 199, -3 }, /* (275) cmd ::= SYNCDB ids REPLICA */ - { 199, -7 }, /* (276) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ - { 199, -7 }, /* (277) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ - { 199, -7 }, /* (278) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ - { 199, -7 }, /* (279) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ - { 199, -7 }, /* (280) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ - { 199, -8 }, /* (281) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ - { 199, -9 }, /* (282) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ - { 199, -7 }, /* (283) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ - { 199, -7 }, /* (284) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ - { 199, -7 }, /* (285) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ - { 199, -7 }, /* (286) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ - { 199, -7 }, /* (287) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ - { 199, -7 }, /* (288) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ - { 199, -8 }, /* (289) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ - { 199, -9 }, /* (290) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ - { 199, -7 }, /* (291) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ - { 199, -3 }, /* (292) cmd ::= KILL CONNECTION INTEGER */ - { 199, -5 }, /* (293) cmd ::= KILL STREAM INTEGER COLON INTEGER */ - { 199, -5 }, /* (294) cmd ::= KILL QUERY INTEGER COLON INTEGER */ + { 197, -1 }, /* (0) program ::= cmd */ + { 198, -2 }, /* (1) cmd ::= SHOW DATABASES */ + { 198, -2 }, /* (2) cmd ::= SHOW TOPICS */ + { 198, -2 }, /* (3) cmd ::= SHOW FUNCTIONS */ + { 198, -2 }, /* (4) cmd ::= SHOW MNODES */ + { 198, -2 }, /* (5) cmd ::= SHOW DNODES */ + { 198, -2 }, /* (6) cmd ::= SHOW ACCOUNTS */ + { 198, -2 }, /* (7) cmd ::= SHOW USERS */ + { 198, -2 }, /* (8) cmd ::= SHOW MODULES */ + { 198, -2 }, /* (9) cmd ::= SHOW QUERIES */ + { 198, -2 }, /* (10) cmd ::= SHOW CONNECTIONS */ + { 198, -2 }, /* (11) cmd ::= SHOW STREAMS */ + { 198, -2 }, /* (12) cmd ::= SHOW VARIABLES */ + { 198, -2 }, /* (13) cmd ::= SHOW SCORES */ + { 198, -2 }, /* (14) cmd ::= SHOW GRANTS */ + { 198, -2 }, /* (15) cmd ::= SHOW VNODES */ + { 198, -3 }, /* (16) cmd ::= SHOW VNODES ids */ + { 200, 0 }, /* (17) dbPrefix ::= */ + { 200, -2 }, /* (18) dbPrefix ::= ids DOT */ + { 201, 0 }, /* (19) cpxName ::= */ + { 201, -2 }, /* (20) cpxName ::= DOT ids */ + { 198, -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */ + { 198, -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */ + { 198, -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */ + { 198, -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */ + { 198, -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE ids */ + { 198, -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */ + { 198, -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE ids */ + { 198, -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */ + { 198, -4 }, /* (29) cmd ::= SHOW dbPrefix VGROUPS ids */ + { 198, -5 }, /* (30) cmd ::= DROP TABLE ifexists ids cpxName */ + { 198, -5 }, /* (31) cmd ::= DROP STABLE ifexists ids cpxName */ + { 198, -4 }, /* (32) cmd ::= DROP DATABASE ifexists ids */ + { 198, -4 }, /* (33) cmd ::= DROP TOPIC ifexists ids */ + { 198, -3 }, /* (34) cmd ::= DROP FUNCTION ids */ + { 198, -3 }, /* (35) cmd ::= DROP DNODE ids */ + { 198, -3 }, /* (36) cmd ::= DROP USER ids */ + { 198, -3 }, /* (37) cmd ::= DROP ACCOUNT ids */ + { 198, -2 }, /* (38) cmd ::= USE ids */ + { 198, -3 }, /* (39) cmd ::= DESCRIBE ids cpxName */ + { 198, -3 }, /* (40) cmd ::= DESC ids cpxName */ + { 198, -5 }, /* (41) cmd ::= ALTER USER ids PASS ids */ + { 198, -5 }, /* (42) cmd ::= ALTER USER ids PRIVILEGE ids */ + { 198, -4 }, /* (43) cmd ::= ALTER DNODE ids ids */ + { 198, -5 }, /* (44) cmd ::= ALTER DNODE ids ids ids */ + { 198, -3 }, /* (45) cmd ::= ALTER LOCAL ids */ + { 198, -4 }, /* (46) cmd ::= ALTER LOCAL ids ids */ + { 198, -4 }, /* (47) cmd ::= ALTER DATABASE ids alter_db_optr */ + { 198, -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */ + { 198, -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ + { 198, -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */ + { 199, -1 }, /* (51) ids ::= ID */ + { 199, -1 }, /* (52) ids ::= STRING */ + { 202, -2 }, /* (53) ifexists ::= IF EXISTS */ + { 202, 0 }, /* (54) ifexists ::= */ + { 206, -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */ + { 206, 0 }, /* (56) ifnotexists ::= */ + { 198, -3 }, /* (57) cmd ::= CREATE DNODE ids */ + { 198, -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ + { 198, -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ + { 198, -8 }, /* (60) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ + { 198, -9 }, /* (61) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ + { 198, -5 }, /* (62) cmd ::= CREATE USER ids PASS ids */ + { 209, 0 }, /* (63) bufsize ::= */ + { 209, -2 }, /* (64) bufsize ::= BUFSIZE INTEGER */ + { 210, 0 }, /* (65) pps ::= */ + { 210, -2 }, /* (66) pps ::= PPS INTEGER */ + { 211, 0 }, /* (67) tseries ::= */ + { 211, -2 }, /* (68) tseries ::= TSERIES INTEGER */ + { 212, 0 }, /* (69) dbs ::= */ + { 212, -2 }, /* (70) dbs ::= DBS INTEGER */ + { 213, 0 }, /* (71) streams ::= */ + { 213, -2 }, /* (72) streams ::= STREAMS INTEGER */ + { 214, 0 }, /* (73) storage ::= */ + { 214, -2 }, /* (74) storage ::= STORAGE INTEGER */ + { 215, 0 }, /* (75) qtime ::= */ + { 215, -2 }, /* (76) qtime ::= QTIME INTEGER */ + { 216, 0 }, /* (77) users ::= */ + { 216, -2 }, /* (78) users ::= USERS INTEGER */ + { 217, 0 }, /* (79) conns ::= */ + { 217, -2 }, /* (80) conns ::= CONNS INTEGER */ + { 218, 0 }, /* (81) state ::= */ + { 218, -2 }, /* (82) state ::= STATE ids */ + { 204, -9 }, /* (83) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ + { 219, -3 }, /* (84) intitemlist ::= intitemlist COMMA intitem */ + { 219, -1 }, /* (85) intitemlist ::= intitem */ + { 220, -1 }, /* (86) intitem ::= INTEGER */ + { 221, -2 }, /* (87) keep ::= KEEP intitemlist */ + { 222, -2 }, /* (88) cache ::= CACHE INTEGER */ + { 223, -2 }, /* (89) replica ::= REPLICA INTEGER */ + { 224, -2 }, /* (90) quorum ::= QUORUM INTEGER */ + { 225, -2 }, /* (91) days ::= DAYS INTEGER */ + { 226, -2 }, /* (92) minrows ::= MINROWS INTEGER */ + { 227, -2 }, /* (93) maxrows ::= MAXROWS INTEGER */ + { 228, -2 }, /* (94) blocks ::= BLOCKS INTEGER */ + { 229, -2 }, /* (95) ctime ::= CTIME INTEGER */ + { 230, -2 }, /* (96) wal ::= WAL INTEGER */ + { 231, -2 }, /* (97) fsync ::= FSYNC INTEGER */ + { 232, -2 }, /* (98) comp ::= COMP INTEGER */ + { 233, -2 }, /* (99) prec ::= PRECISION STRING */ + { 234, -2 }, /* (100) update ::= UPDATE INTEGER */ + { 235, -2 }, /* (101) cachelast ::= CACHELAST INTEGER */ + { 207, 0 }, /* (102) db_optr ::= */ + { 207, -2 }, /* (103) db_optr ::= db_optr cache */ + { 207, -2 }, /* (104) db_optr ::= db_optr replica */ + { 207, -2 }, /* (105) db_optr ::= db_optr quorum */ + { 207, -2 }, /* (106) db_optr ::= db_optr days */ + { 207, -2 }, /* (107) db_optr ::= db_optr minrows */ + { 207, -2 }, /* (108) db_optr ::= db_optr maxrows */ + { 207, -2 }, /* (109) db_optr ::= db_optr blocks */ + { 207, -2 }, /* (110) db_optr ::= db_optr ctime */ + { 207, -2 }, /* (111) db_optr ::= db_optr wal */ + { 207, -2 }, /* (112) db_optr ::= db_optr fsync */ + { 207, -2 }, /* (113) db_optr ::= db_optr comp */ + { 207, -2 }, /* (114) db_optr ::= db_optr prec */ + { 207, -2 }, /* (115) db_optr ::= db_optr keep */ + { 207, -2 }, /* (116) db_optr ::= db_optr update */ + { 207, -2 }, /* (117) db_optr ::= db_optr cachelast */ + { 203, 0 }, /* (118) alter_db_optr ::= */ + { 203, -2 }, /* (119) alter_db_optr ::= alter_db_optr replica */ + { 203, -2 }, /* (120) alter_db_optr ::= alter_db_optr quorum */ + { 203, -2 }, /* (121) alter_db_optr ::= alter_db_optr keep */ + { 203, -2 }, /* (122) alter_db_optr ::= alter_db_optr blocks */ + { 203, -2 }, /* (123) alter_db_optr ::= alter_db_optr comp */ + { 203, -2 }, /* (124) alter_db_optr ::= alter_db_optr update */ + { 203, -2 }, /* (125) alter_db_optr ::= alter_db_optr cachelast */ + { 208, -1 }, /* (126) typename ::= ids */ + { 208, -4 }, /* (127) typename ::= ids LP signed RP */ + { 208, -2 }, /* (128) typename ::= ids UNSIGNED */ + { 236, -1 }, /* (129) signed ::= INTEGER */ + { 236, -2 }, /* (130) signed ::= PLUS INTEGER */ + { 236, -2 }, /* (131) signed ::= MINUS INTEGER */ + { 198, -3 }, /* (132) cmd ::= CREATE TABLE create_table_args */ + { 198, -3 }, /* (133) cmd ::= CREATE TABLE create_stable_args */ + { 198, -3 }, /* (134) cmd ::= CREATE STABLE create_stable_args */ + { 198, -3 }, /* (135) cmd ::= CREATE TABLE create_table_list */ + { 239, -1 }, /* (136) create_table_list ::= create_from_stable */ + { 239, -2 }, /* (137) create_table_list ::= create_table_list create_from_stable */ + { 237, -6 }, /* (138) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ + { 238, -10 }, /* (139) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ + { 240, -10 }, /* (140) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ + { 240, -13 }, /* (141) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ + { 243, -3 }, /* (142) tagNamelist ::= tagNamelist COMMA ids */ + { 243, -1 }, /* (143) tagNamelist ::= ids */ + { 237, -5 }, /* (144) create_table_args ::= ifnotexists ids cpxName AS select */ + { 241, -3 }, /* (145) columnlist ::= columnlist COMMA column */ + { 241, -1 }, /* (146) columnlist ::= column */ + { 245, -2 }, /* (147) column ::= ids typename */ + { 242, -3 }, /* (148) tagitemlist ::= tagitemlist COMMA tagitem */ + { 242, -1 }, /* (149) tagitemlist ::= tagitem */ + { 246, -1 }, /* (150) tagitem ::= INTEGER */ + { 246, -1 }, /* (151) tagitem ::= FLOAT */ + { 246, -1 }, /* (152) tagitem ::= STRING */ + { 246, -1 }, /* (153) tagitem ::= BOOL */ + { 246, -1 }, /* (154) tagitem ::= NULL */ + { 246, -1 }, /* (155) tagitem ::= NOW */ + { 246, -2 }, /* (156) tagitem ::= MINUS INTEGER */ + { 246, -2 }, /* (157) tagitem ::= MINUS FLOAT */ + { 246, -2 }, /* (158) tagitem ::= PLUS INTEGER */ + { 246, -2 }, /* (159) tagitem ::= PLUS FLOAT */ + { 244, -14 }, /* (160) select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ + { 244, -3 }, /* (161) select ::= LP select RP */ + { 260, -1 }, /* (162) union ::= select */ + { 260, -4 }, /* (163) union ::= union UNION ALL select */ + { 260, -3 }, /* (164) union ::= union UNION select */ + { 198, -1 }, /* (165) cmd ::= union */ + { 244, -2 }, /* (166) select ::= SELECT selcollist */ + { 261, -2 }, /* (167) sclp ::= selcollist COMMA */ + { 261, 0 }, /* (168) sclp ::= */ + { 247, -4 }, /* (169) selcollist ::= sclp distinct expr as */ + { 247, -2 }, /* (170) selcollist ::= sclp STAR */ + { 264, -2 }, /* (171) as ::= AS ids */ + { 264, -1 }, /* (172) as ::= ids */ + { 264, 0 }, /* (173) as ::= */ + { 262, -1 }, /* (174) distinct ::= DISTINCT */ + { 262, 0 }, /* (175) distinct ::= */ + { 248, -2 }, /* (176) from ::= FROM tablelist */ + { 248, -2 }, /* (177) from ::= FROM sub */ + { 266, -3 }, /* (178) sub ::= LP union RP */ + { 266, -4 }, /* (179) sub ::= LP union RP ids */ + { 266, -6 }, /* (180) sub ::= sub COMMA LP union RP ids */ + { 265, -2 }, /* (181) tablelist ::= ids cpxName */ + { 265, -3 }, /* (182) tablelist ::= ids cpxName ids */ + { 265, -4 }, /* (183) tablelist ::= tablelist COMMA ids cpxName */ + { 265, -5 }, /* (184) tablelist ::= tablelist COMMA ids cpxName ids */ + { 267, -1 }, /* (185) tmvar ::= VARIABLE */ + { 250, -4 }, /* (186) interval_option ::= intervalKey LP tmvar RP */ + { 250, -6 }, /* (187) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ + { 250, 0 }, /* (188) interval_option ::= */ + { 268, -1 }, /* (189) intervalKey ::= INTERVAL */ + { 268, -1 }, /* (190) intervalKey ::= EVERY */ + { 252, 0 }, /* (191) session_option ::= */ + { 252, -7 }, /* (192) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ + { 253, 0 }, /* (193) windowstate_option ::= */ + { 253, -4 }, /* (194) windowstate_option ::= STATE_WINDOW LP ids RP */ + { 254, 0 }, /* (195) fill_opt ::= */ + { 254, -6 }, /* (196) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ + { 254, -4 }, /* (197) fill_opt ::= FILL LP ID RP */ + { 251, -4 }, /* (198) sliding_opt ::= SLIDING LP tmvar RP */ + { 251, 0 }, /* (199) sliding_opt ::= */ + { 257, 0 }, /* (200) orderby_opt ::= */ + { 257, -3 }, /* (201) orderby_opt ::= ORDER BY sortlist */ + { 269, -4 }, /* (202) sortlist ::= sortlist COMMA item sortorder */ + { 269, -2 }, /* (203) sortlist ::= item sortorder */ + { 271, -2 }, /* (204) item ::= ids cpxName */ + { 272, -1 }, /* (205) sortorder ::= ASC */ + { 272, -1 }, /* (206) sortorder ::= DESC */ + { 272, 0 }, /* (207) sortorder ::= */ + { 255, 0 }, /* (208) groupby_opt ::= */ + { 255, -3 }, /* (209) groupby_opt ::= GROUP BY grouplist */ + { 273, -3 }, /* (210) grouplist ::= grouplist COMMA item */ + { 273, -1 }, /* (211) grouplist ::= item */ + { 256, 0 }, /* (212) having_opt ::= */ + { 256, -2 }, /* (213) having_opt ::= HAVING expr */ + { 259, 0 }, /* (214) limit_opt ::= */ + { 259, -2 }, /* (215) limit_opt ::= LIMIT signed */ + { 259, -4 }, /* (216) limit_opt ::= LIMIT signed OFFSET signed */ + { 259, -4 }, /* (217) limit_opt ::= LIMIT signed COMMA signed */ + { 258, 0 }, /* (218) slimit_opt ::= */ + { 258, -2 }, /* (219) slimit_opt ::= SLIMIT signed */ + { 258, -4 }, /* (220) slimit_opt ::= SLIMIT signed SOFFSET signed */ + { 258, -4 }, /* (221) slimit_opt ::= SLIMIT signed COMMA signed */ + { 249, 0 }, /* (222) where_opt ::= */ + { 249, -2 }, /* (223) where_opt ::= WHERE expr */ + { 263, -3 }, /* (224) expr ::= LP expr RP */ + { 263, -1 }, /* (225) expr ::= ID */ + { 263, -3 }, /* (226) expr ::= ID DOT ID */ + { 263, -3 }, /* (227) expr ::= ID DOT STAR */ + { 263, -1 }, /* (228) expr ::= INTEGER */ + { 263, -2 }, /* (229) expr ::= MINUS INTEGER */ + { 263, -2 }, /* (230) expr ::= PLUS INTEGER */ + { 263, -1 }, /* (231) expr ::= FLOAT */ + { 263, -2 }, /* (232) expr ::= MINUS FLOAT */ + { 263, -2 }, /* (233) expr ::= PLUS FLOAT */ + { 263, -1 }, /* (234) expr ::= STRING */ + { 263, -1 }, /* (235) expr ::= NOW */ + { 263, -1 }, /* (236) expr ::= VARIABLE */ + { 263, -2 }, /* (237) expr ::= PLUS VARIABLE */ + { 263, -2 }, /* (238) expr ::= MINUS VARIABLE */ + { 263, -1 }, /* (239) expr ::= BOOL */ + { 263, -1 }, /* (240) expr ::= NULL */ + { 263, -4 }, /* (241) expr ::= ID LP exprlist RP */ + { 263, -4 }, /* (242) expr ::= ID LP STAR RP */ + { 263, -3 }, /* (243) expr ::= expr IS NULL */ + { 263, -4 }, /* (244) expr ::= expr IS NOT NULL */ + { 263, -3 }, /* (245) expr ::= expr LT expr */ + { 263, -3 }, /* (246) expr ::= expr GT expr */ + { 263, -3 }, /* (247) expr ::= expr LE expr */ + { 263, -3 }, /* (248) expr ::= expr GE expr */ + { 263, -3 }, /* (249) expr ::= expr NE expr */ + { 263, -3 }, /* (250) expr ::= expr EQ expr */ + { 263, -5 }, /* (251) expr ::= expr BETWEEN expr AND expr */ + { 263, -3 }, /* (252) expr ::= expr AND expr */ + { 263, -3 }, /* (253) expr ::= expr OR expr */ + { 263, -3 }, /* (254) expr ::= expr PLUS expr */ + { 263, -3 }, /* (255) expr ::= expr MINUS expr */ + { 263, -3 }, /* (256) expr ::= expr STAR expr */ + { 263, -3 }, /* (257) expr ::= expr SLASH expr */ + { 263, -3 }, /* (258) expr ::= expr REM expr */ + { 263, -3 }, /* (259) expr ::= expr LIKE expr */ + { 263, -3 }, /* (260) expr ::= expr MATCH expr */ + { 263, -3 }, /* (261) expr ::= expr NMATCH expr */ + { 263, -5 }, /* (262) expr ::= expr IN LP exprlist RP */ + { 205, -3 }, /* (263) exprlist ::= exprlist COMMA expritem */ + { 205, -1 }, /* (264) exprlist ::= expritem */ + { 274, -1 }, /* (265) expritem ::= expr */ + { 274, 0 }, /* (266) expritem ::= */ + { 198, -3 }, /* (267) cmd ::= RESET QUERY CACHE */ + { 198, -3 }, /* (268) cmd ::= SYNCDB ids REPLICA */ + { 198, -7 }, /* (269) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ + { 198, -7 }, /* (270) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ + { 198, -7 }, /* (271) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ + { 198, -7 }, /* (272) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + { 198, -7 }, /* (273) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + { 198, -8 }, /* (274) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + { 198, -9 }, /* (275) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + { 198, -7 }, /* (276) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ + { 198, -7 }, /* (277) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + { 198, -7 }, /* (278) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + { 198, -7 }, /* (279) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ + { 198, -7 }, /* (280) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + { 198, -7 }, /* (281) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + { 198, -8 }, /* (282) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + { 198, -9 }, /* (283) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ + { 198, -7 }, /* (284) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ + { 198, -3 }, /* (285) cmd ::= KILL CONNECTION INTEGER */ + { 198, -5 }, /* (286) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + { 198, -5 }, /* (287) cmd ::= KILL QUERY INTEGER COLON INTEGER */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -2218,9 +2193,9 @@ static void yy_reduce( /********** Begin reduce actions **********************************************/ YYMINORTYPE yylhsminor; case 0: /* program ::= cmd */ - case 139: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==139); - case 140: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==140); - case 141: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==141); + case 132: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==132); + case 133: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==133); + case 134: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==134); {} break; case 1: /* cmd ::= SHOW DATABASES */ @@ -2396,780 +2371,767 @@ static void yy_reduce( { setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; case 47: /* cmd ::= ALTER DATABASE ids alter_db_optr */ - case 48: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==48); -{ SToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy256, &t);} +{ SToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy42, &t);} break; - case 49: /* cmd ::= ALTER ACCOUNT ids acct_optr */ -{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy277);} + case 48: /* cmd ::= ALTER ACCOUNT ids acct_optr */ +{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy341);} break; - case 50: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ -{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy277);} + case 49: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ +{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy341);} break; - case 51: /* cmd ::= COMPACT VNODES IN LP exprlist RP */ -{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy135);} + case 50: /* cmd ::= COMPACT VNODES IN LP exprlist RP */ +{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy131);} break; - case 52: /* ids ::= ID */ - case 53: /* ids ::= STRING */ yytestcase(yyruleno==53); + case 51: /* ids ::= ID */ + case 52: /* ids ::= STRING */ yytestcase(yyruleno==52); {yylhsminor.yy0 = yymsp[0].minor.yy0; } yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 54: /* ifexists ::= IF EXISTS */ + case 53: /* ifexists ::= IF EXISTS */ { yymsp[-1].minor.yy0.n = 1;} break; - case 55: /* ifexists ::= */ - case 57: /* ifnotexists ::= */ yytestcase(yyruleno==57); - case 182: /* distinct ::= */ yytestcase(yyruleno==182); + case 54: /* ifexists ::= */ + case 56: /* ifnotexists ::= */ yytestcase(yyruleno==56); + case 175: /* distinct ::= */ yytestcase(yyruleno==175); { yymsp[1].minor.yy0.n = 0;} break; - case 56: /* ifnotexists ::= IF NOT EXISTS */ + case 55: /* ifnotexists ::= IF NOT EXISTS */ { yymsp[-2].minor.yy0.n = 1;} break; - case 58: /* cmd ::= CREATE DNODE ids */ + case 57: /* cmd ::= CREATE DNODE ids */ { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);} break; - case 59: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ -{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy277);} + case 58: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ +{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy341);} break; - case 60: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */ - case 61: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==61); -{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy256, &yymsp[-2].minor.yy0);} + case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */ +{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy42, &yymsp[-2].minor.yy0);} break; - case 62: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ -{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy304, &yymsp[0].minor.yy0, 1);} + case 60: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ +{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy290, &yymsp[0].minor.yy0, 1);} break; - case 63: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ -{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy304, &yymsp[0].minor.yy0, 2);} + case 61: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ +{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy290, &yymsp[0].minor.yy0, 2);} break; - case 64: /* cmd ::= CREATE USER ids PASS ids */ + case 62: /* cmd ::= CREATE USER ids PASS ids */ { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);} break; - case 65: /* bufsize ::= */ - case 67: /* pps ::= */ yytestcase(yyruleno==67); - case 69: /* tseries ::= */ yytestcase(yyruleno==69); - case 71: /* dbs ::= */ yytestcase(yyruleno==71); - case 73: /* streams ::= */ yytestcase(yyruleno==73); - case 75: /* storage ::= */ yytestcase(yyruleno==75); - case 77: /* qtime ::= */ yytestcase(yyruleno==77); - case 79: /* users ::= */ yytestcase(yyruleno==79); - case 81: /* conns ::= */ yytestcase(yyruleno==81); - case 83: /* state ::= */ yytestcase(yyruleno==83); + case 63: /* bufsize ::= */ + case 65: /* pps ::= */ yytestcase(yyruleno==65); + case 67: /* tseries ::= */ yytestcase(yyruleno==67); + case 69: /* dbs ::= */ yytestcase(yyruleno==69); + case 71: /* streams ::= */ yytestcase(yyruleno==71); + case 73: /* storage ::= */ yytestcase(yyruleno==73); + case 75: /* qtime ::= */ yytestcase(yyruleno==75); + case 77: /* users ::= */ yytestcase(yyruleno==77); + case 79: /* conns ::= */ yytestcase(yyruleno==79); + case 81: /* state ::= */ yytestcase(yyruleno==81); { yymsp[1].minor.yy0.n = 0; } break; - case 66: /* bufsize ::= BUFSIZE INTEGER */ - case 68: /* pps ::= PPS INTEGER */ yytestcase(yyruleno==68); - case 70: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==70); - case 72: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==72); - case 74: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==74); - case 76: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==76); - case 78: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==78); - case 80: /* users ::= USERS INTEGER */ yytestcase(yyruleno==80); - case 82: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==82); - case 84: /* state ::= STATE ids */ yytestcase(yyruleno==84); + case 64: /* bufsize ::= BUFSIZE INTEGER */ + case 66: /* pps ::= PPS INTEGER */ yytestcase(yyruleno==66); + case 68: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==68); + case 70: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==70); + case 72: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==72); + case 74: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==74); + case 76: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==76); + case 78: /* users ::= USERS INTEGER */ yytestcase(yyruleno==78); + case 80: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==80); + case 82: /* state ::= STATE ids */ yytestcase(yyruleno==82); { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } break; - case 85: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */ -{ - yylhsminor.yy277.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1; - yylhsminor.yy277.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1; - yylhsminor.yy277.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1; - yylhsminor.yy277.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1; - yylhsminor.yy277.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1; - yylhsminor.yy277.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1; - yylhsminor.yy277.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1; - yylhsminor.yy277.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1; - yylhsminor.yy277.stat = yymsp[0].minor.yy0; -} - yymsp[-8].minor.yy277 = yylhsminor.yy277; - break; - case 86: /* intitemlist ::= intitemlist COMMA intitem */ - case 155: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==155); -{ yylhsminor.yy135 = tListItemAppend(yymsp[-2].minor.yy135, &yymsp[0].minor.yy191, -1); } - yymsp[-2].minor.yy135 = yylhsminor.yy135; - break; - case 87: /* intitemlist ::= intitem */ - case 156: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==156); -{ yylhsminor.yy135 = tListItemAppend(NULL, &yymsp[0].minor.yy191, -1); } - yymsp[0].minor.yy135 = yylhsminor.yy135; - break; - case 88: /* intitem ::= INTEGER */ - case 157: /* tagitem ::= INTEGER */ yytestcase(yyruleno==157); - case 158: /* tagitem ::= FLOAT */ yytestcase(yyruleno==158); - case 159: /* tagitem ::= STRING */ yytestcase(yyruleno==159); - case 160: /* tagitem ::= BOOL */ yytestcase(yyruleno==160); -{ toTSDBType(yymsp[0].minor.yy0.type); taosVariantCreate(&yylhsminor.yy191, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.type); } - yymsp[0].minor.yy191 = yylhsminor.yy191; - break; - case 89: /* keep ::= KEEP intitemlist */ -{ yymsp[-1].minor.yy135 = yymsp[0].minor.yy135; } - break; - case 90: /* cache ::= CACHE INTEGER */ - case 91: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==91); - case 92: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==92); - case 93: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==93); - case 94: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==94); - case 95: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==95); - case 96: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==96); - case 97: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==97); - case 98: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==98); - case 99: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==99); - case 100: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==100); - case 101: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==101); - case 102: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==102); - case 103: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==103); - case 104: /* partitions ::= PARTITIONS INTEGER */ yytestcase(yyruleno==104); + case 83: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */ +{ + yylhsminor.yy341.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1; + yylhsminor.yy341.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1; + yylhsminor.yy341.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1; + yylhsminor.yy341.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1; + yylhsminor.yy341.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1; + yylhsminor.yy341.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1; + yylhsminor.yy341.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1; + yylhsminor.yy341.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1; + yylhsminor.yy341.stat = yymsp[0].minor.yy0; +} + yymsp[-8].minor.yy341 = yylhsminor.yy341; + break; + case 84: /* intitemlist ::= intitemlist COMMA intitem */ + case 148: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==148); +{ yylhsminor.yy131 = tListItemAppend(yymsp[-2].minor.yy131, &yymsp[0].minor.yy43, -1); } + yymsp[-2].minor.yy131 = yylhsminor.yy131; + break; + case 85: /* intitemlist ::= intitem */ + case 149: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==149); +{ yylhsminor.yy131 = tListItemAppend(NULL, &yymsp[0].minor.yy43, -1); } + yymsp[0].minor.yy131 = yylhsminor.yy131; + break; + case 86: /* intitem ::= INTEGER */ + case 150: /* tagitem ::= INTEGER */ yytestcase(yyruleno==150); + case 151: /* tagitem ::= FLOAT */ yytestcase(yyruleno==151); + case 152: /* tagitem ::= STRING */ yytestcase(yyruleno==152); + case 153: /* tagitem ::= BOOL */ yytestcase(yyruleno==153); +{ toTSDBType(yymsp[0].minor.yy0.type); taosVariantCreate(&yylhsminor.yy43, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.type); } + yymsp[0].minor.yy43 = yylhsminor.yy43; + break; + case 87: /* keep ::= KEEP intitemlist */ +{ yymsp[-1].minor.yy131 = yymsp[0].minor.yy131; } + break; + case 88: /* cache ::= CACHE INTEGER */ + case 89: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==89); + case 90: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==90); + case 91: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==91); + case 92: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==92); + case 93: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==93); + case 94: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==94); + case 95: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==95); + case 96: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==96); + case 97: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==97); + case 98: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==98); + case 99: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==99); + case 100: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==100); + case 101: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==101); { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } break; - case 105: /* db_optr ::= */ -{setDefaultCreateDbOption(&yymsp[1].minor.yy256);} + case 102: /* db_optr ::= */ +{setDefaultCreateDbOption(&yymsp[1].minor.yy42);} break; - case 106: /* db_optr ::= db_optr cache */ -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 103: /* db_optr ::= db_optr cache */ +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 107: /* db_optr ::= db_optr replica */ - case 124: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==124); -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 104: /* db_optr ::= db_optr replica */ + case 119: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==119); +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 108: /* db_optr ::= db_optr quorum */ - case 125: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==125); -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 105: /* db_optr ::= db_optr quorum */ + case 120: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==120); +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 109: /* db_optr ::= db_optr days */ -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 106: /* db_optr ::= db_optr days */ +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 110: /* db_optr ::= db_optr minrows */ -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 107: /* db_optr ::= db_optr minrows */ +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 111: /* db_optr ::= db_optr maxrows */ -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 108: /* db_optr ::= db_optr maxrows */ +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 112: /* db_optr ::= db_optr blocks */ - case 127: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==127); -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 109: /* db_optr ::= db_optr blocks */ + case 122: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==122); +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 113: /* db_optr ::= db_optr ctime */ -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 110: /* db_optr ::= db_optr ctime */ +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 114: /* db_optr ::= db_optr wal */ -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 111: /* db_optr ::= db_optr wal */ +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 115: /* db_optr ::= db_optr fsync */ -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; - break; - case 116: /* db_optr ::= db_optr comp */ - case 128: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==128); -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; - break; - case 117: /* db_optr ::= db_optr prec */ -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.precision = yymsp[0].minor.yy0; } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 112: /* db_optr ::= db_optr fsync */ +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 118: /* db_optr ::= db_optr keep */ - case 126: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==126); -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.keep = yymsp[0].minor.yy135; } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 113: /* db_optr ::= db_optr comp */ + case 123: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==123); +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 119: /* db_optr ::= db_optr update */ - case 129: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==129); -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 114: /* db_optr ::= db_optr prec */ +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.precision = yymsp[0].minor.yy0; } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 120: /* db_optr ::= db_optr cachelast */ - case 130: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==130); -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 115: /* db_optr ::= db_optr keep */ + case 121: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==121); +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.keep = yymsp[0].minor.yy131; } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 121: /* topic_optr ::= db_optr */ - case 131: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==131); -{ yylhsminor.yy256 = yymsp[0].minor.yy256;} - yymsp[0].minor.yy256 = yylhsminor.yy256; + case 116: /* db_optr ::= db_optr update */ + case 124: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==124); +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 122: /* topic_optr ::= topic_optr partitions */ - case 132: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==132); -{ yylhsminor.yy256 = yymsp[-1].minor.yy256; } - yymsp[-1].minor.yy256 = yylhsminor.yy256; + case 117: /* db_optr ::= db_optr cachelast */ + case 125: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==125); +{ yylhsminor.yy42 = yymsp[-1].minor.yy42; yylhsminor.yy42.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 123: /* alter_db_optr ::= */ -{ setDefaultCreateDbOption(&yymsp[1].minor.yy256); } + case 118: /* alter_db_optr ::= */ +{ setDefaultCreateDbOption(&yymsp[1].minor.yy42);} break; - case 133: /* typename ::= ids */ + case 126: /* typename ::= ids */ { yymsp[0].minor.yy0.type = 0; - tSetColumnType (&yylhsminor.yy304, &yymsp[0].minor.yy0); + tSetColumnType (&yylhsminor.yy290, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy304 = yylhsminor.yy304; + yymsp[0].minor.yy290 = yylhsminor.yy290; break; - case 134: /* typename ::= ids LP signed RP */ + case 127: /* typename ::= ids LP signed RP */ { - if (yymsp[-1].minor.yy531 <= 0) { + if (yymsp[-1].minor.yy459 <= 0) { yymsp[-3].minor.yy0.type = 0; - tSetColumnType(&yylhsminor.yy304, &yymsp[-3].minor.yy0); + tSetColumnType(&yylhsminor.yy290, &yymsp[-3].minor.yy0); } else { - yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy531; // negative value of name length - tSetColumnType(&yylhsminor.yy304, &yymsp[-3].minor.yy0); + yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy459; // negative value of name length + tSetColumnType(&yylhsminor.yy290, &yymsp[-3].minor.yy0); } } - yymsp[-3].minor.yy304 = yylhsminor.yy304; + yymsp[-3].minor.yy290 = yylhsminor.yy290; break; - case 135: /* typename ::= ids UNSIGNED */ + case 128: /* typename ::= ids UNSIGNED */ { yymsp[-1].minor.yy0.type = 0; yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z); - tSetColumnType (&yylhsminor.yy304, &yymsp[-1].minor.yy0); + tSetColumnType (&yylhsminor.yy290, &yymsp[-1].minor.yy0); } - yymsp[-1].minor.yy304 = yylhsminor.yy304; + yymsp[-1].minor.yy290 = yylhsminor.yy290; break; - case 136: /* signed ::= INTEGER */ -{ yylhsminor.yy531 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[0].minor.yy531 = yylhsminor.yy531; + case 129: /* signed ::= INTEGER */ +{ yylhsminor.yy459 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[0].minor.yy459 = yylhsminor.yy459; break; - case 137: /* signed ::= PLUS INTEGER */ -{ yymsp[-1].minor.yy531 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + case 130: /* signed ::= PLUS INTEGER */ +{ yymsp[-1].minor.yy459 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } break; - case 138: /* signed ::= MINUS INTEGER */ -{ yymsp[-1].minor.yy531 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);} + case 131: /* signed ::= MINUS INTEGER */ +{ yymsp[-1].minor.yy459 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);} break; - case 142: /* cmd ::= CREATE TABLE create_table_list */ -{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy110;} + case 135: /* cmd ::= CREATE TABLE create_table_list */ +{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy272;} break; - case 143: /* create_table_list ::= create_from_stable */ + case 136: /* create_table_list ::= create_from_stable */ { SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql)); pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo)); - taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy78); + taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy96); pCreateTable->type = TSQL_CREATE_CTABLE; - yylhsminor.yy110 = pCreateTable; + yylhsminor.yy272 = pCreateTable; } - yymsp[0].minor.yy110 = yylhsminor.yy110; + yymsp[0].minor.yy272 = yylhsminor.yy272; break; - case 144: /* create_table_list ::= create_table_list create_from_stable */ + case 137: /* create_table_list ::= create_table_list create_from_stable */ { - taosArrayPush(yymsp[-1].minor.yy110->childTableInfo, &yymsp[0].minor.yy78); - yylhsminor.yy110 = yymsp[-1].minor.yy110; + taosArrayPush(yymsp[-1].minor.yy272->childTableInfo, &yymsp[0].minor.yy96); + yylhsminor.yy272 = yymsp[-1].minor.yy272; } - yymsp[-1].minor.yy110 = yylhsminor.yy110; + yymsp[-1].minor.yy272 = yylhsminor.yy272; break; - case 145: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ + case 138: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ { - yylhsminor.yy110 = tSetCreateTableInfo(yymsp[-1].minor.yy135, NULL, NULL, TSQL_CREATE_TABLE); - setSqlInfo(pInfo, yylhsminor.yy110, NULL, TSDB_SQL_CREATE_TABLE); + yylhsminor.yy272 = tSetCreateTableInfo(yymsp[-1].minor.yy131, NULL, NULL, TSQL_CREATE_TABLE); + setSqlInfo(pInfo, yylhsminor.yy272, NULL, TSDB_SQL_CREATE_TABLE); yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0); } - yymsp[-5].minor.yy110 = yylhsminor.yy110; + yymsp[-5].minor.yy272 = yylhsminor.yy272; break; - case 146: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ + case 139: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ { - yylhsminor.yy110 = tSetCreateTableInfo(yymsp[-5].minor.yy135, yymsp[-1].minor.yy135, NULL, TSQL_CREATE_STABLE); - setSqlInfo(pInfo, yylhsminor.yy110, NULL, TSDB_SQL_CREATE_TABLE); + yylhsminor.yy272 = tSetCreateTableInfo(yymsp[-5].minor.yy131, yymsp[-1].minor.yy131, NULL, TSQL_CREATE_STABLE); + setSqlInfo(pInfo, yylhsminor.yy272, NULL, TSDB_SQL_CREATE_TABLE); yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); } - yymsp[-9].minor.yy110 = yylhsminor.yy110; + yymsp[-9].minor.yy272 = yylhsminor.yy272; break; - case 147: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ + case 140: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; - yylhsminor.yy78 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy135, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); + yylhsminor.yy96 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy131, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); } - yymsp[-9].minor.yy78 = yylhsminor.yy78; + yymsp[-9].minor.yy96 = yylhsminor.yy96; break; - case 148: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ + case 141: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ { yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n; - yylhsminor.yy78 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy135, yymsp[-1].minor.yy135, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0); + yylhsminor.yy96 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy131, yymsp[-1].minor.yy131, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0); } - yymsp[-12].minor.yy78 = yylhsminor.yy78; + yymsp[-12].minor.yy96 = yylhsminor.yy96; break; - case 149: /* tagNamelist ::= tagNamelist COMMA ids */ -{taosArrayPush(yymsp[-2].minor.yy135, &yymsp[0].minor.yy0); yylhsminor.yy135 = yymsp[-2].minor.yy135; } - yymsp[-2].minor.yy135 = yylhsminor.yy135; + case 142: /* tagNamelist ::= tagNamelist COMMA ids */ +{taosArrayPush(yymsp[-2].minor.yy131, &yymsp[0].minor.yy0); yylhsminor.yy131 = yymsp[-2].minor.yy131; } + yymsp[-2].minor.yy131 = yylhsminor.yy131; break; - case 150: /* tagNamelist ::= ids */ -{yylhsminor.yy135 = taosArrayInit(4, sizeof(SToken)); taosArrayPush(yylhsminor.yy135, &yymsp[0].minor.yy0);} - yymsp[0].minor.yy135 = yylhsminor.yy135; + case 143: /* tagNamelist ::= ids */ +{yylhsminor.yy131 = taosArrayInit(4, sizeof(SToken)); taosArrayPush(yylhsminor.yy131, &yymsp[0].minor.yy0);} + yymsp[0].minor.yy131 = yylhsminor.yy131; break; - case 151: /* create_table_args ::= ifnotexists ids cpxName AS select */ + case 144: /* create_table_args ::= ifnotexists ids cpxName AS select */ { - yylhsminor.yy110 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy488, TSQL_CREATE_STREAM); - setSqlInfo(pInfo, yylhsminor.yy110, NULL, TSDB_SQL_CREATE_TABLE); + yylhsminor.yy272 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy256, TSQL_CREATE_STREAM); + setSqlInfo(pInfo, yylhsminor.yy272, NULL, TSDB_SQL_CREATE_TABLE); yymsp[-3].minor.yy0.n += yymsp[-2].minor.yy0.n; setCreatedTableName(pInfo, &yymsp[-3].minor.yy0, &yymsp[-4].minor.yy0); } - yymsp[-4].minor.yy110 = yylhsminor.yy110; + yymsp[-4].minor.yy272 = yylhsminor.yy272; break; - case 152: /* columnlist ::= columnlist COMMA column */ -{taosArrayPush(yymsp[-2].minor.yy135, &yymsp[0].minor.yy304); yylhsminor.yy135 = yymsp[-2].minor.yy135; } - yymsp[-2].minor.yy135 = yylhsminor.yy135; + case 145: /* columnlist ::= columnlist COMMA column */ +{taosArrayPush(yymsp[-2].minor.yy131, &yymsp[0].minor.yy290); yylhsminor.yy131 = yymsp[-2].minor.yy131; } + yymsp[-2].minor.yy131 = yylhsminor.yy131; break; - case 153: /* columnlist ::= column */ -{yylhsminor.yy135 = taosArrayInit(4, sizeof(SField)); taosArrayPush(yylhsminor.yy135, &yymsp[0].minor.yy304);} - yymsp[0].minor.yy135 = yylhsminor.yy135; + case 146: /* columnlist ::= column */ +{yylhsminor.yy131 = taosArrayInit(4, sizeof(SField)); taosArrayPush(yylhsminor.yy131, &yymsp[0].minor.yy290);} + yymsp[0].minor.yy131 = yylhsminor.yy131; break; - case 154: /* column ::= ids typename */ + case 147: /* column ::= ids typename */ { - tSetColumnInfo(&yylhsminor.yy304, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy304); + tSetColumnInfo(&yylhsminor.yy290, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy290); } - yymsp[-1].minor.yy304 = yylhsminor.yy304; + yymsp[-1].minor.yy290 = yylhsminor.yy290; break; - case 161: /* tagitem ::= NULL */ -{ yymsp[0].minor.yy0.type = 0; taosVariantCreate(&yylhsminor.yy191, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.type); } - yymsp[0].minor.yy191 = yylhsminor.yy191; + case 154: /* tagitem ::= NULL */ +{ yymsp[0].minor.yy0.type = 0; taosVariantCreate(&yylhsminor.yy43, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.type); } + yymsp[0].minor.yy43 = yylhsminor.yy43; break; - case 162: /* tagitem ::= NOW */ -{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; taosVariantCreate(&yylhsminor.yy191, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.type);} - yymsp[0].minor.yy191 = yylhsminor.yy191; + case 155: /* tagitem ::= NOW */ +{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; taosVariantCreate(&yylhsminor.yy43, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.type);} + yymsp[0].minor.yy43 = yylhsminor.yy43; break; - case 163: /* tagitem ::= MINUS INTEGER */ - case 164: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==164); - case 165: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==165); - case 166: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==166); + case 156: /* tagitem ::= MINUS INTEGER */ + case 157: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==157); + case 158: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==158); + case 159: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==159); { 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); - taosVariantCreate(&yylhsminor.yy191, yymsp[-1].minor.yy0.z, yymsp[-1].minor.yy0.n, yymsp[-1].minor.yy0.type); + taosVariantCreate(&yylhsminor.yy43, yymsp[-1].minor.yy0.z, yymsp[-1].minor.yy0.n, yymsp[-1].minor.yy0.type); } - yymsp[-1].minor.yy191 = yylhsminor.yy191; + yymsp[-1].minor.yy43 = yylhsminor.yy43; break; - case 167: /* select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ + case 160: /* select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ { - yylhsminor.yy488 = tSetQuerySqlNode(&yymsp[-13].minor.yy0, yymsp[-12].minor.yy135, yymsp[-11].minor.yy460, yymsp[-10].minor.yy526, yymsp[-4].minor.yy135, yymsp[-2].minor.yy135, &yymsp[-9].minor.yy160, &yymsp[-7].minor.yy511, &yymsp[-6].minor.yy258, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy135, &yymsp[0].minor.yy247, &yymsp[-1].minor.yy247, yymsp[-3].minor.yy526); + yylhsminor.yy256 = tSetQuerySqlNode(&yymsp[-13].minor.yy0, yymsp[-12].minor.yy131, yymsp[-11].minor.yy544, yymsp[-10].minor.yy46, yymsp[-4].minor.yy131, yymsp[-2].minor.yy131, &yymsp[-9].minor.yy530, &yymsp[-7].minor.yy39, &yymsp[-6].minor.yy538, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy131, &yymsp[0].minor.yy55, &yymsp[-1].minor.yy55, yymsp[-3].minor.yy46); } - yymsp[-13].minor.yy488 = yylhsminor.yy488; + yymsp[-13].minor.yy256 = yylhsminor.yy256; break; - case 168: /* select ::= LP select RP */ -{yymsp[-2].minor.yy488 = yymsp[-1].minor.yy488;} + case 161: /* select ::= LP select RP */ +{yymsp[-2].minor.yy256 = yymsp[-1].minor.yy256;} break; - case 169: /* union ::= select */ -{ yylhsminor.yy551 = setSubclause(NULL, yymsp[0].minor.yy488); } - yymsp[0].minor.yy551 = yylhsminor.yy551; + case 162: /* union ::= select */ +{ yylhsminor.yy303 = setSubclause(NULL, yymsp[0].minor.yy256); } + yymsp[0].minor.yy303 = yylhsminor.yy303; break; - case 170: /* union ::= union UNION ALL select */ -{ yylhsminor.yy551 = appendSelectClause(yymsp[-3].minor.yy551, SQL_TYPE_UNIONALL, yymsp[0].minor.yy488); } - yymsp[-3].minor.yy551 = yylhsminor.yy551; + case 163: /* union ::= union UNION ALL select */ +{ yylhsminor.yy303 = appendSelectClause(yymsp[-3].minor.yy303, SQL_TYPE_UNIONALL, yymsp[0].minor.yy256); } + yymsp[-3].minor.yy303 = yylhsminor.yy303; break; - case 171: /* union ::= union UNION select */ -{ yylhsminor.yy551 = appendSelectClause(yymsp[-2].minor.yy551, SQL_TYPE_UNION, yymsp[0].minor.yy488); } - yymsp[-2].minor.yy551 = yylhsminor.yy551; + case 164: /* union ::= union UNION select */ +{ yylhsminor.yy303 = appendSelectClause(yymsp[-2].minor.yy303, SQL_TYPE_UNION, yymsp[0].minor.yy256); } + yymsp[-2].minor.yy303 = yylhsminor.yy303; break; - case 172: /* cmd ::= union */ -{ setSqlInfo(pInfo, yymsp[0].minor.yy551, NULL, TSDB_SQL_SELECT); } + case 165: /* cmd ::= union */ +{ setSqlInfo(pInfo, yymsp[0].minor.yy303, NULL, TSDB_SQL_SELECT); } break; - case 173: /* select ::= SELECT selcollist */ + case 166: /* select ::= SELECT selcollist */ { - yylhsminor.yy488 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy135, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); + yylhsminor.yy256 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy131, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); } - yymsp[-1].minor.yy488 = yylhsminor.yy488; + yymsp[-1].minor.yy256 = yylhsminor.yy256; break; - case 174: /* sclp ::= selcollist COMMA */ -{yylhsminor.yy135 = yymsp[-1].minor.yy135;} - yymsp[-1].minor.yy135 = yylhsminor.yy135; + case 167: /* sclp ::= selcollist COMMA */ +{yylhsminor.yy131 = yymsp[-1].minor.yy131;} + yymsp[-1].minor.yy131 = yylhsminor.yy131; break; - case 175: /* sclp ::= */ - case 207: /* orderby_opt ::= */ yytestcase(yyruleno==207); -{yymsp[1].minor.yy135 = 0;} + case 168: /* sclp ::= */ + case 200: /* orderby_opt ::= */ yytestcase(yyruleno==200); +{yymsp[1].minor.yy131 = 0;} break; - case 176: /* selcollist ::= sclp distinct expr as */ + case 169: /* selcollist ::= sclp distinct expr as */ { - yylhsminor.yy135 = tSqlExprListAppend(yymsp[-3].minor.yy135, yymsp[-1].minor.yy526, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0); + yylhsminor.yy131 = tSqlExprListAppend(yymsp[-3].minor.yy131, yymsp[-1].minor.yy46, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0); } - yymsp[-3].minor.yy135 = yylhsminor.yy135; + yymsp[-3].minor.yy131 = yylhsminor.yy131; break; - case 177: /* selcollist ::= sclp STAR */ + case 170: /* selcollist ::= sclp STAR */ { tSqlExpr *pNode = tSqlExprCreateIdValue(NULL, TK_ALL); - yylhsminor.yy135 = tSqlExprListAppend(yymsp[-1].minor.yy135, pNode, 0, 0); + yylhsminor.yy131 = tSqlExprListAppend(yymsp[-1].minor.yy131, pNode, 0, 0); } - yymsp[-1].minor.yy135 = yylhsminor.yy135; + yymsp[-1].minor.yy131 = yylhsminor.yy131; break; - case 178: /* as ::= AS ids */ + case 171: /* as ::= AS ids */ { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } break; - case 179: /* as ::= ids */ + case 172: /* as ::= ids */ { yylhsminor.yy0 = yymsp[0].minor.yy0; } yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 180: /* as ::= */ + case 173: /* as ::= */ { yymsp[1].minor.yy0.n = 0; } break; - case 181: /* distinct ::= DISTINCT */ + case 174: /* distinct ::= DISTINCT */ { yylhsminor.yy0 = yymsp[0].minor.yy0; } yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 183: /* from ::= FROM tablelist */ - case 184: /* from ::= FROM sub */ yytestcase(yyruleno==184); -{yymsp[-1].minor.yy460 = yymsp[0].minor.yy460;} + case 176: /* from ::= FROM tablelist */ + case 177: /* from ::= FROM sub */ yytestcase(yyruleno==177); +{yymsp[-1].minor.yy544 = yymsp[0].minor.yy544;} break; - case 185: /* sub ::= LP union RP */ -{yymsp[-2].minor.yy460 = addSubquery(NULL, yymsp[-1].minor.yy551, NULL);} + case 178: /* sub ::= LP union RP */ +{yymsp[-2].minor.yy544 = addSubquery(NULL, yymsp[-1].minor.yy303, NULL);} break; - case 186: /* sub ::= LP union RP ids */ -{yymsp[-3].minor.yy460 = addSubquery(NULL, yymsp[-2].minor.yy551, &yymsp[0].minor.yy0);} + case 179: /* sub ::= LP union RP ids */ +{yymsp[-3].minor.yy544 = addSubquery(NULL, yymsp[-2].minor.yy303, &yymsp[0].minor.yy0);} break; - case 187: /* sub ::= sub COMMA LP union RP ids */ -{yylhsminor.yy460 = addSubquery(yymsp[-5].minor.yy460, yymsp[-2].minor.yy551, &yymsp[0].minor.yy0);} - yymsp[-5].minor.yy460 = yylhsminor.yy460; + case 180: /* sub ::= sub COMMA LP union RP ids */ +{yylhsminor.yy544 = addSubquery(yymsp[-5].minor.yy544, yymsp[-2].minor.yy303, &yymsp[0].minor.yy0);} + yymsp[-5].minor.yy544 = yylhsminor.yy544; break; - case 188: /* tablelist ::= ids cpxName */ + case 181: /* tablelist ::= ids cpxName */ { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - yylhsminor.yy460 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL); + yylhsminor.yy544 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL); } - yymsp[-1].minor.yy460 = yylhsminor.yy460; + yymsp[-1].minor.yy544 = yylhsminor.yy544; break; - case 189: /* tablelist ::= ids cpxName ids */ + case 182: /* tablelist ::= ids cpxName ids */ { yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; - yylhsminor.yy460 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); + yylhsminor.yy544 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy460 = yylhsminor.yy460; + yymsp[-2].minor.yy544 = yylhsminor.yy544; break; - case 190: /* tablelist ::= tablelist COMMA ids cpxName */ + case 183: /* tablelist ::= tablelist COMMA ids cpxName */ { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - yylhsminor.yy460 = setTableNameList(yymsp[-3].minor.yy460, &yymsp[-1].minor.yy0, NULL); + yylhsminor.yy544 = setTableNameList(yymsp[-3].minor.yy544, &yymsp[-1].minor.yy0, NULL); } - yymsp[-3].minor.yy460 = yylhsminor.yy460; + yymsp[-3].minor.yy544 = yylhsminor.yy544; break; - case 191: /* tablelist ::= tablelist COMMA ids cpxName ids */ + case 184: /* tablelist ::= tablelist COMMA ids cpxName ids */ { yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; - yylhsminor.yy460 = setTableNameList(yymsp[-4].minor.yy460, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); + yylhsminor.yy544 = setTableNameList(yymsp[-4].minor.yy544, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } - yymsp[-4].minor.yy460 = yylhsminor.yy460; + yymsp[-4].minor.yy544 = yylhsminor.yy544; break; - case 192: /* tmvar ::= VARIABLE */ + case 185: /* tmvar ::= VARIABLE */ {yylhsminor.yy0 = yymsp[0].minor.yy0;} yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 193: /* interval_option ::= intervalKey LP tmvar RP */ -{yylhsminor.yy160.interval = yymsp[-1].minor.yy0; yylhsminor.yy160.offset.n = 0; yylhsminor.yy160.token = yymsp[-3].minor.yy262;} - yymsp[-3].minor.yy160 = yylhsminor.yy160; + case 186: /* interval_option ::= intervalKey LP tmvar RP */ +{yylhsminor.yy530.interval = yymsp[-1].minor.yy0; yylhsminor.yy530.offset.n = 0; yylhsminor.yy530.token = yymsp[-3].minor.yy310;} + yymsp[-3].minor.yy530 = yylhsminor.yy530; break; - case 194: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ -{yylhsminor.yy160.interval = yymsp[-3].minor.yy0; yylhsminor.yy160.offset = yymsp[-1].minor.yy0; yylhsminor.yy160.token = yymsp[-5].minor.yy262;} - yymsp[-5].minor.yy160 = yylhsminor.yy160; + case 187: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ +{yylhsminor.yy530.interval = yymsp[-3].minor.yy0; yylhsminor.yy530.offset = yymsp[-1].minor.yy0; yylhsminor.yy530.token = yymsp[-5].minor.yy310;} + yymsp[-5].minor.yy530 = yylhsminor.yy530; break; - case 195: /* interval_option ::= */ -{memset(&yymsp[1].minor.yy160, 0, sizeof(yymsp[1].minor.yy160));} + case 188: /* interval_option ::= */ +{memset(&yymsp[1].minor.yy530, 0, sizeof(yymsp[1].minor.yy530));} break; - case 196: /* intervalKey ::= INTERVAL */ -{yymsp[0].minor.yy262 = TK_INTERVAL;} + case 189: /* intervalKey ::= INTERVAL */ +{yymsp[0].minor.yy310 = TK_INTERVAL;} break; - case 197: /* intervalKey ::= EVERY */ -{yymsp[0].minor.yy262 = TK_EVERY; } + case 190: /* intervalKey ::= EVERY */ +{yymsp[0].minor.yy310 = TK_EVERY; } break; - case 198: /* session_option ::= */ -{yymsp[1].minor.yy511.col.n = 0; yymsp[1].minor.yy511.gap.n = 0;} + case 191: /* session_option ::= */ +{yymsp[1].minor.yy39.col.n = 0; yymsp[1].minor.yy39.gap.n = 0;} break; - case 199: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ + case 192: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - yymsp[-6].minor.yy511.col = yymsp[-4].minor.yy0; - yymsp[-6].minor.yy511.gap = yymsp[-1].minor.yy0; + yymsp[-6].minor.yy39.col = yymsp[-4].minor.yy0; + yymsp[-6].minor.yy39.gap = yymsp[-1].minor.yy0; } break; - case 200: /* windowstate_option ::= */ -{ yymsp[1].minor.yy258.col.n = 0; yymsp[1].minor.yy258.col.z = NULL;} + case 193: /* windowstate_option ::= */ +{ yymsp[1].minor.yy538.col.n = 0; yymsp[1].minor.yy538.col.z = NULL;} break; - case 201: /* windowstate_option ::= STATE_WINDOW LP ids RP */ -{ yymsp[-3].minor.yy258.col = yymsp[-1].minor.yy0; } + case 194: /* windowstate_option ::= STATE_WINDOW LP ids RP */ +{ yymsp[-3].minor.yy538.col = yymsp[-1].minor.yy0; } break; - case 202: /* fill_opt ::= */ -{ yymsp[1].minor.yy135 = 0; } + case 195: /* fill_opt ::= */ +{ yymsp[1].minor.yy131 = 0; } break; - case 203: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */ + case 196: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */ { SVariant A = {0}; toTSDBType(yymsp[-3].minor.yy0.type); taosVariantCreate(&A, yymsp[-3].minor.yy0.z, yymsp[-3].minor.yy0.n, yymsp[-3].minor.yy0.type); - tListItemInsert(yymsp[-1].minor.yy135, &A, -1, 0); - yymsp[-5].minor.yy135 = yymsp[-1].minor.yy135; + tListItemInsert(yymsp[-1].minor.yy131, &A, -1, 0); + yymsp[-5].minor.yy131 = yymsp[-1].minor.yy131; } break; - case 204: /* fill_opt ::= FILL LP ID RP */ + case 197: /* fill_opt ::= FILL LP ID RP */ { toTSDBType(yymsp[-1].minor.yy0.type); - yymsp[-3].minor.yy135 = tListItemAppendToken(NULL, &yymsp[-1].minor.yy0, -1); + yymsp[-3].minor.yy131 = tListItemAppendToken(NULL, &yymsp[-1].minor.yy0, -1); } break; - case 205: /* sliding_opt ::= SLIDING LP tmvar RP */ + case 198: /* sliding_opt ::= SLIDING LP tmvar RP */ {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0; } break; - case 206: /* sliding_opt ::= */ + case 199: /* sliding_opt ::= */ {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0; } break; - case 208: /* orderby_opt ::= ORDER BY sortlist */ -{yymsp[-2].minor.yy135 = yymsp[0].minor.yy135;} + case 201: /* orderby_opt ::= ORDER BY sortlist */ +{yymsp[-2].minor.yy131 = yymsp[0].minor.yy131;} break; - case 209: /* sortlist ::= sortlist COMMA item sortorder */ + case 202: /* sortlist ::= sortlist COMMA item sortorder */ { - yylhsminor.yy135 = tListItemAppend(yymsp[-3].minor.yy135, &yymsp[-1].minor.yy191, yymsp[0].minor.yy130); + yylhsminor.yy131 = tListItemAppend(yymsp[-3].minor.yy131, &yymsp[-1].minor.yy43, yymsp[0].minor.yy44); } - yymsp[-3].minor.yy135 = yylhsminor.yy135; + yymsp[-3].minor.yy131 = yylhsminor.yy131; break; - case 210: /* sortlist ::= item sortorder */ + case 203: /* sortlist ::= item sortorder */ { - yylhsminor.yy135 = tListItemAppend(NULL, &yymsp[-1].minor.yy191, yymsp[0].minor.yy130); + yylhsminor.yy131 = tListItemAppend(NULL, &yymsp[-1].minor.yy43, yymsp[0].minor.yy44); } - yymsp[-1].minor.yy135 = yylhsminor.yy135; + yymsp[-1].minor.yy131 = yylhsminor.yy131; break; - case 211: /* item ::= ids cpxName */ + case 204: /* item ::= ids cpxName */ { toTSDBType(yymsp[-1].minor.yy0.type); yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - taosVariantCreate(&yylhsminor.yy191, yymsp[-1].minor.yy0.z, yymsp[-1].minor.yy0.n, yymsp[-1].minor.yy0.type); + taosVariantCreate(&yylhsminor.yy43, yymsp[-1].minor.yy0.z, yymsp[-1].minor.yy0.n, yymsp[-1].minor.yy0.type); } - yymsp[-1].minor.yy191 = yylhsminor.yy191; + yymsp[-1].minor.yy43 = yylhsminor.yy43; break; - case 212: /* sortorder ::= ASC */ -{ yymsp[0].minor.yy130 = TSDB_ORDER_ASC; } + case 205: /* sortorder ::= ASC */ +{ yymsp[0].minor.yy44 = TSDB_ORDER_ASC; } break; - case 213: /* sortorder ::= DESC */ -{ yymsp[0].minor.yy130 = TSDB_ORDER_DESC;} + case 206: /* sortorder ::= DESC */ +{ yymsp[0].minor.yy44 = TSDB_ORDER_DESC;} break; - case 214: /* sortorder ::= */ -{ yymsp[1].minor.yy130 = TSDB_ORDER_ASC; } + case 207: /* sortorder ::= */ +{ yymsp[1].minor.yy44 = TSDB_ORDER_ASC; } break; - case 215: /* groupby_opt ::= */ -{ yymsp[1].minor.yy135 = 0;} + case 208: /* groupby_opt ::= */ +{ yymsp[1].minor.yy131 = 0;} break; - case 216: /* groupby_opt ::= GROUP BY grouplist */ -{ yymsp[-2].minor.yy135 = yymsp[0].minor.yy135;} + case 209: /* groupby_opt ::= GROUP BY grouplist */ +{ yymsp[-2].minor.yy131 = yymsp[0].minor.yy131;} break; - case 217: /* grouplist ::= grouplist COMMA item */ + case 210: /* grouplist ::= grouplist COMMA item */ { - yylhsminor.yy135 = tListItemAppend(yymsp[-2].minor.yy135, &yymsp[0].minor.yy191, -1); + yylhsminor.yy131 = tListItemAppend(yymsp[-2].minor.yy131, &yymsp[0].minor.yy43, -1); } - yymsp[-2].minor.yy135 = yylhsminor.yy135; + yymsp[-2].minor.yy131 = yylhsminor.yy131; break; - case 218: /* grouplist ::= item */ + case 211: /* grouplist ::= item */ { - yylhsminor.yy135 = tListItemAppend(NULL, &yymsp[0].minor.yy191, -1); + yylhsminor.yy131 = tListItemAppend(NULL, &yymsp[0].minor.yy43, -1); } - yymsp[0].minor.yy135 = yylhsminor.yy135; + yymsp[0].minor.yy131 = yylhsminor.yy131; break; - case 219: /* having_opt ::= */ - case 229: /* where_opt ::= */ yytestcase(yyruleno==229); - case 273: /* expritem ::= */ yytestcase(yyruleno==273); -{yymsp[1].minor.yy526 = 0;} + case 212: /* having_opt ::= */ + case 222: /* where_opt ::= */ yytestcase(yyruleno==222); + case 266: /* expritem ::= */ yytestcase(yyruleno==266); +{yymsp[1].minor.yy46 = 0;} break; - case 220: /* having_opt ::= HAVING expr */ - case 230: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==230); -{yymsp[-1].minor.yy526 = yymsp[0].minor.yy526;} + case 213: /* having_opt ::= HAVING expr */ + case 223: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==223); +{yymsp[-1].minor.yy46 = yymsp[0].minor.yy46;} break; - case 221: /* limit_opt ::= */ - case 225: /* slimit_opt ::= */ yytestcase(yyruleno==225); -{yymsp[1].minor.yy247.limit = -1; yymsp[1].minor.yy247.offset = 0;} + case 214: /* limit_opt ::= */ + case 218: /* slimit_opt ::= */ yytestcase(yyruleno==218); +{yymsp[1].minor.yy55.limit = -1; yymsp[1].minor.yy55.offset = 0;} break; - case 222: /* limit_opt ::= LIMIT signed */ - case 226: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==226); -{yymsp[-1].minor.yy247.limit = yymsp[0].minor.yy531; yymsp[-1].minor.yy247.offset = 0;} + case 215: /* limit_opt ::= LIMIT signed */ + case 219: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==219); +{yymsp[-1].minor.yy55.limit = yymsp[0].minor.yy459; yymsp[-1].minor.yy55.offset = 0;} break; - case 223: /* limit_opt ::= LIMIT signed OFFSET signed */ -{ yymsp[-3].minor.yy247.limit = yymsp[-2].minor.yy531; yymsp[-3].minor.yy247.offset = yymsp[0].minor.yy531;} + case 216: /* limit_opt ::= LIMIT signed OFFSET signed */ +{ yymsp[-3].minor.yy55.limit = yymsp[-2].minor.yy459; yymsp[-3].minor.yy55.offset = yymsp[0].minor.yy459;} break; - case 224: /* limit_opt ::= LIMIT signed COMMA signed */ -{ yymsp[-3].minor.yy247.limit = yymsp[0].minor.yy531; yymsp[-3].minor.yy247.offset = yymsp[-2].minor.yy531;} + case 217: /* limit_opt ::= LIMIT signed COMMA signed */ +{ yymsp[-3].minor.yy55.limit = yymsp[0].minor.yy459; yymsp[-3].minor.yy55.offset = yymsp[-2].minor.yy459;} break; - case 227: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ -{yymsp[-3].minor.yy247.limit = yymsp[-2].minor.yy531; yymsp[-3].minor.yy247.offset = yymsp[0].minor.yy531;} + case 220: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ +{yymsp[-3].minor.yy55.limit = yymsp[-2].minor.yy459; yymsp[-3].minor.yy55.offset = yymsp[0].minor.yy459;} break; - case 228: /* slimit_opt ::= SLIMIT signed COMMA signed */ -{yymsp[-3].minor.yy247.limit = yymsp[0].minor.yy531; yymsp[-3].minor.yy247.offset = yymsp[-2].minor.yy531;} + case 221: /* slimit_opt ::= SLIMIT signed COMMA signed */ +{yymsp[-3].minor.yy55.limit = yymsp[0].minor.yy459; yymsp[-3].minor.yy55.offset = yymsp[-2].minor.yy459;} break; - case 231: /* expr ::= LP expr RP */ -{yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy526->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 224: /* expr ::= LP expr RP */ +{yylhsminor.yy46 = yymsp[-1].minor.yy46; yylhsminor.yy46->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy46->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 232: /* expr ::= ID */ -{ yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);} - yymsp[0].minor.yy526 = yylhsminor.yy526; + case 225: /* expr ::= ID */ +{ yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);} + yymsp[0].minor.yy46 = yylhsminor.yy46; break; - case 233: /* expr ::= ID DOT ID */ -{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 226: /* expr ::= ID DOT ID */ +{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 234: /* expr ::= ID DOT STAR */ -{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 227: /* expr ::= ID DOT STAR */ +{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 235: /* expr ::= INTEGER */ -{ yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);} - yymsp[0].minor.yy526 = yylhsminor.yy526; + case 228: /* expr ::= INTEGER */ +{ yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);} + yymsp[0].minor.yy46 = yylhsminor.yy46; break; - case 236: /* expr ::= MINUS INTEGER */ - case 237: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==237); -{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);} - yymsp[-1].minor.yy526 = yylhsminor.yy526; + case 229: /* expr ::= MINUS INTEGER */ + case 230: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==230); +{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);} + yymsp[-1].minor.yy46 = yylhsminor.yy46; break; - case 238: /* expr ::= FLOAT */ -{ yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);} - yymsp[0].minor.yy526 = yylhsminor.yy526; + case 231: /* expr ::= FLOAT */ +{ yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);} + yymsp[0].minor.yy46 = yylhsminor.yy46; break; - case 239: /* expr ::= MINUS FLOAT */ - case 240: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==240); -{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);} - yymsp[-1].minor.yy526 = yylhsminor.yy526; + case 232: /* expr ::= MINUS FLOAT */ + case 233: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==233); +{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);} + yymsp[-1].minor.yy46 = yylhsminor.yy46; break; - case 241: /* expr ::= STRING */ -{ yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);} - yymsp[0].minor.yy526 = yylhsminor.yy526; + case 234: /* expr ::= STRING */ +{ yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);} + yymsp[0].minor.yy46 = yylhsminor.yy46; break; - case 242: /* expr ::= NOW */ -{ yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); } - yymsp[0].minor.yy526 = yylhsminor.yy526; + case 235: /* expr ::= NOW */ +{ yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); } + yymsp[0].minor.yy46 = yylhsminor.yy46; break; - case 243: /* expr ::= VARIABLE */ -{ yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);} - yymsp[0].minor.yy526 = yylhsminor.yy526; + case 236: /* expr ::= VARIABLE */ +{ yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);} + yymsp[0].minor.yy46 = yylhsminor.yy46; break; - case 244: /* expr ::= PLUS VARIABLE */ - case 245: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==245); -{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);} - yymsp[-1].minor.yy526 = yylhsminor.yy526; + case 237: /* expr ::= PLUS VARIABLE */ + case 238: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==238); +{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);} + yymsp[-1].minor.yy46 = yylhsminor.yy46; break; - case 246: /* expr ::= BOOL */ -{ yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);} - yymsp[0].minor.yy526 = yylhsminor.yy526; + case 239: /* expr ::= BOOL */ +{ yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);} + yymsp[0].minor.yy46 = yylhsminor.yy46; break; - case 247: /* expr ::= NULL */ -{ yylhsminor.yy526 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);} - yymsp[0].minor.yy526 = yylhsminor.yy526; + case 240: /* expr ::= NULL */ +{ yylhsminor.yy46 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);} + yymsp[0].minor.yy46 = yylhsminor.yy46; break; - case 248: /* expr ::= ID LP exprlist RP */ -{ tRecordFuncName(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy526 = tSqlExprCreateFunction(yymsp[-1].minor.yy135, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } - yymsp[-3].minor.yy526 = yylhsminor.yy526; + case 241: /* expr ::= ID LP exprlist RP */ +{ tRecordFuncName(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy46 = tSqlExprCreateFunction(yymsp[-1].minor.yy131, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } + yymsp[-3].minor.yy46 = yylhsminor.yy46; break; - case 249: /* expr ::= ID LP STAR RP */ -{ tRecordFuncName(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy526 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } - yymsp[-3].minor.yy526 = yylhsminor.yy526; + case 242: /* expr ::= ID LP STAR RP */ +{ tRecordFuncName(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy46 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } + yymsp[-3].minor.yy46 = yylhsminor.yy46; break; - case 250: /* expr ::= expr IS NULL */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, NULL, TK_ISNULL);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 243: /* expr ::= expr IS NULL */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, NULL, TK_ISNULL);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 251: /* expr ::= expr IS NOT NULL */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-3].minor.yy526, NULL, TK_NOTNULL);} - yymsp[-3].minor.yy526 = yylhsminor.yy526; + case 244: /* expr ::= expr IS NOT NULL */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-3].minor.yy46, NULL, TK_NOTNULL);} + yymsp[-3].minor.yy46 = yylhsminor.yy46; break; - case 252: /* expr ::= expr LT expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_LT);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 245: /* expr ::= expr LT expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_LT);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 253: /* expr ::= expr GT expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_GT);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 246: /* expr ::= expr GT expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_GT);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 254: /* expr ::= expr LE expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_LE);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 247: /* expr ::= expr LE expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_LE);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 255: /* expr ::= expr GE expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_GE);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 248: /* expr ::= expr GE expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_GE);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 256: /* expr ::= expr NE expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_NE);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 249: /* expr ::= expr NE expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_NE);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 257: /* expr ::= expr EQ expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_EQ);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 250: /* expr ::= expr EQ expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_EQ);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 258: /* expr ::= expr BETWEEN expr AND expr */ -{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy526); yylhsminor.yy526 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy526, yymsp[-2].minor.yy526, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy526, TK_LE), TK_AND);} - yymsp[-4].minor.yy526 = yylhsminor.yy526; + case 251: /* expr ::= expr BETWEEN expr AND expr */ +{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy46); yylhsminor.yy46 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy46, yymsp[-2].minor.yy46, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy46, TK_LE), TK_AND);} + yymsp[-4].minor.yy46 = yylhsminor.yy46; break; - case 259: /* expr ::= expr AND expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_AND);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 252: /* expr ::= expr AND expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_AND);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 260: /* expr ::= expr OR expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_OR); } - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 253: /* expr ::= expr OR expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_OR); } + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 261: /* expr ::= expr PLUS expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_PLUS); } - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 254: /* expr ::= expr PLUS expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_PLUS); } + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 262: /* expr ::= expr MINUS expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_MINUS); } - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 255: /* expr ::= expr MINUS expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_MINUS); } + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 263: /* expr ::= expr STAR expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_STAR); } - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 256: /* expr ::= expr STAR expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_STAR); } + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 264: /* expr ::= expr SLASH expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_DIVIDE);} - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 257: /* expr ::= expr SLASH expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_DIVIDE);} + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 265: /* expr ::= expr REM expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_REM); } - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 258: /* expr ::= expr REM expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_REM); } + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 266: /* expr ::= expr LIKE expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_LIKE); } - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 259: /* expr ::= expr LIKE expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_LIKE); } + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 267: /* expr ::= expr MATCH expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_MATCH); } - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 260: /* expr ::= expr MATCH expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_MATCH); } + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 268: /* expr ::= expr NMATCH expr */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-2].minor.yy526, yymsp[0].minor.yy526, TK_NMATCH); } - yymsp[-2].minor.yy526 = yylhsminor.yy526; + case 261: /* expr ::= expr NMATCH expr */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-2].minor.yy46, yymsp[0].minor.yy46, TK_NMATCH); } + yymsp[-2].minor.yy46 = yylhsminor.yy46; break; - case 269: /* expr ::= expr IN LP exprlist RP */ -{yylhsminor.yy526 = tSqlExprCreate(yymsp[-4].minor.yy526, (tSqlExpr*)yymsp[-1].minor.yy135, TK_IN); } - yymsp[-4].minor.yy526 = yylhsminor.yy526; + case 262: /* expr ::= expr IN LP exprlist RP */ +{yylhsminor.yy46 = tSqlExprCreate(yymsp[-4].minor.yy46, (tSqlExpr*)yymsp[-1].minor.yy131, TK_IN); } + yymsp[-4].minor.yy46 = yylhsminor.yy46; break; - case 270: /* exprlist ::= exprlist COMMA expritem */ -{yylhsminor.yy135 = tSqlExprListAppend(yymsp[-2].minor.yy135,yymsp[0].minor.yy526,0, 0);} - yymsp[-2].minor.yy135 = yylhsminor.yy135; + case 263: /* exprlist ::= exprlist COMMA expritem */ +{yylhsminor.yy131 = tSqlExprListAppend(yymsp[-2].minor.yy131,yymsp[0].minor.yy46,0, 0);} + yymsp[-2].minor.yy131 = yylhsminor.yy131; break; - case 271: /* exprlist ::= expritem */ -{yylhsminor.yy135 = tSqlExprListAppend(0,yymsp[0].minor.yy526,0, 0);} - yymsp[0].minor.yy135 = yylhsminor.yy135; + case 264: /* exprlist ::= expritem */ +{yylhsminor.yy131 = tSqlExprListAppend(0,yymsp[0].minor.yy46,0, 0);} + yymsp[0].minor.yy131 = yylhsminor.yy131; break; - case 272: /* expritem ::= expr */ -{yylhsminor.yy526 = yymsp[0].minor.yy526;} - yymsp[0].minor.yy526 = yylhsminor.yy526; + case 265: /* expritem ::= expr */ +{yylhsminor.yy46 = yymsp[0].minor.yy46;} + yymsp[0].minor.yy46 = yylhsminor.yy46; break; - case 274: /* cmd ::= RESET QUERY CACHE */ + case 267: /* cmd ::= RESET QUERY CACHE */ { setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);} break; - case 275: /* cmd ::= SYNCDB ids REPLICA */ + case 268: /* cmd ::= SYNCDB ids REPLICA */ { setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);} break; - case 276: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ + case 269: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 277: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ + case 270: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; toTSDBType(yymsp[0].minor.yy0.type); @@ -3178,21 +3140,21 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 278: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ + case 271: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 279: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + case 272: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 280: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + case 273: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3203,7 +3165,7 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 281: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + case 274: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3217,33 +3179,33 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 282: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + case 275: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ { yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; toTSDBType(yymsp[-2].minor.yy0.type); SArray* A = tListItemAppendToken(NULL, &yymsp[-2].minor.yy0, -1); - A = tListItemAppend(A, &yymsp[0].minor.yy191, -1); + A = tListItemAppend(A, &yymsp[0].minor.yy43, -1); SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 283: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ + case 276: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 284: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + case 277: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 285: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + case 278: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3254,21 +3216,21 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 286: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ + case 279: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 287: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + case 280: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 288: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + case 281: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3279,7 +3241,7 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 289: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + case 282: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3293,32 +3255,32 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 290: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ + case 283: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ { yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; toTSDBType(yymsp[-2].minor.yy0.type); SArray* A = tListItemAppendToken(NULL, &yymsp[-2].minor.yy0, -1); - A = tListItemAppend(A, &yymsp[0].minor.yy191, -1); + A = tListItemAppend(A, &yymsp[0].minor.yy43, -1); SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 291: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ + case 284: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 292: /* cmd ::= KILL CONNECTION INTEGER */ + case 285: /* cmd ::= KILL CONNECTION INTEGER */ {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);} break; - case 293: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */ + case 286: /* 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 294: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ + case 287: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);} break; default: diff --git a/source/libs/parser/src/ttokenizer.c b/source/libs/parser/src/ttokenizer.c index d69fa2b95b0feb6fdd8e57f54d34331070baca90..4e6b77a3d653088f091b8711b6e5843b59fe7ce7 100644 --- a/source/libs/parser/src/ttokenizer.c +++ b/source/libs/parser/src/ttokenizer.c @@ -217,7 +217,7 @@ static SKeyword keywordTable[] = { {"UNION", TK_UNION}, {"CACHELAST", TK_CACHELAST}, {"DISTINCT", TK_DISTINCT}, - {"PARTITIONS", TK_PARTITIONS}, +// {"PARTITIONS", TK_PARTITIONS}, {"TOPIC", TK_TOPIC}, {"TOPICS", TK_TOPICS}, {"COMPACT", TK_COMPACT}, diff --git a/source/libs/parser/test/mockCatalog.cpp b/source/libs/parser/test/mockCatalog.cpp index 6d8973366803dc30f5cd29f5baed40f0563facf3..d7f410a01eadc3cc7151a660b09dc3ee33d45884 100644 --- a/source/libs/parser/test/mockCatalog.cpp +++ b/source/libs/parser/test/mockCatalog.cpp @@ -23,20 +23,20 @@ namespace { void generateTestT1(MockCatalogService* mcs) { - ITableBuilder& builder = mcs->createTableBuilder("root.test", "t1", TSDB_NORMAL_TABLE, 3) + ITableBuilder& builder = mcs->createTableBuilder("test", "t1", TSDB_NORMAL_TABLE, 3) .setPrecision(TSDB_TIME_PRECISION_MILLI).setVgid(1).addColumn("ts", TSDB_DATA_TYPE_TIMESTAMP) .addColumn("c1", TSDB_DATA_TYPE_INT).addColumn("c2", TSDB_DATA_TYPE_BINARY, 20); builder.done(); } void generateTestST1(MockCatalogService* mcs) { - ITableBuilder& builder = mcs->createTableBuilder("root.test", "st1", TSDB_SUPER_TABLE, 3, 2) + ITableBuilder& builder = mcs->createTableBuilder("test", "st1", TSDB_SUPER_TABLE, 3, 2) .setPrecision(TSDB_TIME_PRECISION_MILLI).addColumn("ts", TSDB_DATA_TYPE_TIMESTAMP) .addTag("tag1", TSDB_DATA_TYPE_INT).addTag("tag2", TSDB_DATA_TYPE_BINARY, 20) .addColumn("c1", TSDB_DATA_TYPE_INT).addColumn("c2", TSDB_DATA_TYPE_BINARY, 20); builder.done(); - mcs->createSubTable("root.test", "st1", "st1s1", 1); - mcs->createSubTable("root.test", "st1", "st1s2", 2); + mcs->createSubTable("test", "st1", "st1s1", 1); + mcs->createSubTable("test", "st1", "st1s2", 2); } } diff --git a/source/libs/parser/test/mockCatalogService.cpp b/source/libs/parser/test/mockCatalogService.cpp index e234f82da93aad8612e57673fd89f64025d52685..520ef3a89bd25a10e8e125ac54bcd3c2e2e4a4ea 100644 --- a/source/libs/parser/test/mockCatalogService.cpp +++ b/source/libs/parser/test/mockCatalogService.cpp @@ -94,9 +94,9 @@ public: return 0; } - int32_t catalogGetTableMeta(const char* pDBName, const char* pTableName, STableMeta** pTableMeta) const { + int32_t catalogGetTableMeta(const char* pDbFullName, const char* pTableName, STableMeta** pTableMeta) const { std::unique_ptr table; - int32_t code = copyTableSchemaMeta(pDBName, pTableName, &table); + int32_t code = copyTableSchemaMeta(toDbname(pDbFullName), pTableName, &table); if (TSDB_CODE_SUCCESS != code) { return code; } @@ -104,7 +104,7 @@ public: return TSDB_CODE_SUCCESS; } - int32_t catalogGetTableHashVgroup(const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo) const { + int32_t catalogGetTableHashVgroup(const char* pDbFullName, const char* pTableName, SVgroupInfo* vgInfo) const { // todo return 0; } @@ -195,6 +195,14 @@ private: typedef std::map> TableMetaCache; typedef std::map DbMetaCache; + std::string toDbname(const std::string& dbFullName) const { + std::string::size_type n = dbFullName.find("."); + if (n == std::string::npos) { + return dbFullName; + } + return dbFullName.substr(n + 1); + } + std::string ttToString(int8_t tableType) const { switch (tableType) { case TSDB_SUPER_TABLE: diff --git a/source/libs/parser/test/parserTests.cpp b/source/libs/parser/test/parserTests.cpp index be68149e09a7d57f1315a3d7f6a56dcfdbcdeb18..f2cb4864fba79e06e16b454ea8e0f9f695e828b0 100644 --- a/source/libs/parser/test/parserTests.cpp +++ b/source/libs/parser/test/parserTests.cpp @@ -714,12 +714,9 @@ TEST(testCase, show_user_Test) { SSqlInfo info1 = doGenerateAST(sql1); ASSERT_EQ(info1.valid, true); - void* output = NULL; - int32_t type = 0; - int32_t len = 0; - + SDclStmtInfo output; SParseBasicCtx ct= {.db= "abc", .acctId = 1, .requestId = 1}; - int32_t code = qParserValidateDclSqlNode(&info1, &ct, &output, &len, &type, msg, buf.len); + int32_t code = qParserValidateDclSqlNode(&info1, &ct, &output, msg, buf.len); ASSERT_EQ(code, 0); // convert the show command to be the select query @@ -738,12 +735,9 @@ TEST(testCase, create_user_Test) { ASSERT_EQ(info1.valid, true); ASSERT_EQ(isDclSqlStatement(&info1), true); - void* output = NULL; - int32_t type = 0; - int32_t len = 0; - + SDclStmtInfo output; SParseBasicCtx ct= {.db= "abc", .acctId = 1, .requestId = 1}; - int32_t code = qParserValidateDclSqlNode(&info1, &ct, &output, &len, &type, msg, buf.len); + int32_t code = qParserValidateDclSqlNode(&info1, &ct, &output, msg, buf.len); ASSERT_EQ(code, 0); destroySqlInfo(&info1); diff --git a/source/libs/planner/inc/plannerInt.h b/source/libs/planner/inc/plannerInt.h index 1bee95b8e56965f424488e38c3fe2da6a66de677..ed29839905d47f2e40753123b3c50bd8464d9f84 100644 --- a/source/libs/planner/inc/plannerInt.h +++ b/source/libs/planner/inc/plannerInt.h @@ -102,7 +102,7 @@ int32_t queryPlanToSql(struct SQueryPlanNode* pQueryNode, char** sql); int32_t createDag(SQueryPlanNode* pQueryNode, struct SCatalog* pCatalog, SQueryDag** pDag); int32_t setSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SEpAddr* ep); -int32_t subPlanToString(const SSubplan *pPhyNode, char** str); +int32_t subPlanToString(const SSubplan *pPhyNode, char** str, int32_t* len); int32_t stringToSubplan(const char* str, SSubplan** subplan); /** @@ -121,6 +121,9 @@ void* destroyQueryPhyPlan(struct SPhyNode* pQueryPhyNode); const char* opTypeToOpName(int32_t type); int32_t opNameToOpType(const char* name); +const char* dsinkTypeToDsinkName(int32_t type); +int32_t dsinkNameToDsinkType(const char* name); + #ifdef __cplusplus } #endif diff --git a/source/libs/planner/src/physicalPlan.c b/source/libs/planner/src/physicalPlan.c index 9db9e059b33df0bfe8f6e70492b8b6151bb0a395..8388458b4c0ea0d04d505aac5f765d890a485d88 100644 --- a/source/libs/planner/src/physicalPlan.c +++ b/source/libs/planner/src/physicalPlan.c @@ -47,16 +47,38 @@ const char* opTypeToOpName(int32_t type) { int32_t opNameToOpType(const char* name) { for (int32_t i = 1; i < sizeof(gOpName) / sizeof(gOpName[0]); ++i) { - if (strcmp(name, gOpName[i])) { + if (0 == strcmp(name, gOpName[i])) { return i; } } return OP_Unknown; } +const char* dsinkTypeToDsinkName(int32_t type) { + switch (type) { + case DSINK_Dispatch: + return "Dispatch"; + case DSINK_Insert: + return "Insert"; + default: + break; + } + return "Unknown"; +} + +int32_t dsinkNameToDsinkType(const char* name) { + if (0 == strcmp(name, "Dispatch")) { + return DSINK_Dispatch; + } else if (0 == strcmp(name, "Insert")) { + return DSINK_Insert; + } + return DSINK_Unknown; +} + static SDataSink* initDataSink(int32_t type, int32_t size) { SDataSink* sink = (SDataSink*)vailidPointer(calloc(1, size)); sink->info.type = type; + sink->info.name = dsinkTypeToDsinkName(type); return sink; } diff --git a/source/libs/planner/src/physicalPlanJson.c b/source/libs/planner/src/physicalPlanJson.c index 15c0e632a7d7ccf1e2fa32f89e66f85f86e0259f..5a1b2a6da298d03c81e6e3bae15052693d2f27f7 100644 --- a/source/libs/planner/src/physicalPlanJson.c +++ b/source/libs/planner/src/physicalPlanJson.c @@ -695,6 +695,70 @@ static bool phyNodeFromJson(const cJSON* json, void* obj) { return res; } +static const char* jkInserterNumOfTables = "NumOfTables"; +static const char* jkInserterDataSize = "DataSize"; + +static bool inserterToJson(const void* obj, cJSON* json) { + const SDataInserter* inserter = (const SDataInserter*)obj; + bool res = cJSON_AddNumberToObject(json, jkInserterNumOfTables, inserter->numOfTables); + if (res) { + res = cJSON_AddNumberToObject(json, jkInserterDataSize, inserter->size); + } + // todo pData + return res; +} + +static bool inserterFromJson(const cJSON* json, void* obj) { + SDataInserter* inserter = (SDataInserter*)obj; + inserter->numOfTables = getNumber(json, jkInserterNumOfTables); + inserter->size = getNumber(json, jkInserterDataSize); + // todo pData +} + +static bool specificDataSinkToJson(const void* obj, cJSON* json) { + const SDataSink* dsink = (const SDataSink*)obj; + switch (dsink->info.type) { + case DSINK_Dispatch: + return true; + case DSINK_Insert: + return inserterToJson(obj, json); + default: + break; + } + return false; +} + +static bool specificDataSinkFromJson(const cJSON* json, void* obj) { + SDataSink* dsink = (SDataSink*)obj; + switch (dsink->info.type) { + case DSINK_Dispatch: + return true; + case DSINK_Insert: + return inserterFromJson(json, obj); + default: + break; + } + return false; +} + +static const char* jkDataSinkName = "Name"; + +static bool dataSinkToJson(const void* obj, cJSON* json) { + const SDataSink* dsink = (const SDataSink*)obj; + bool res = cJSON_AddStringToObject(json, jkDataSinkName, dsink->info.name); + if (res) { + res = addObject(json, dsink->info.name, specificDataSinkToJson, dsink); + } + return res; +} + +static bool dataSinkFromJson(const cJSON* json, void* obj) { + SDataSink* dsink = (SDataSink*)obj; + dsink->info.name = getString(json, jkDataSinkName); + dsink->info.type = dsinkNameToDsinkType(dsink->info.name); + return fromObject(json, dsink->info.name, specificDataSinkFromJson, dsink, true); +} + static const char* jkIdQueryId = "QueryId"; static const char* jkIdTemplateId = "TemplateId"; static const char* jkIdSubplanId = "SubplanId"; @@ -721,6 +785,7 @@ static bool subplanIdFromJson(const cJSON* json, void* obj) { static const char* jkSubplanId = "Id"; static const char* jkSubplanNode = "Node"; +static const char* jkSubplanDataSink = "DataSink"; static cJSON* subplanToJson(const SSubplan* subplan) { cJSON* jSubplan = cJSON_CreateObject(); @@ -734,6 +799,9 @@ static cJSON* subplanToJson(const SSubplan* subplan) { if (res) { res = addObject(jSubplan, jkSubplanNode, phyNodeToJson, subplan->pNode); } + if (res) { + res = addObject(jSubplan, jkSubplanDataSink, dataSinkToJson, subplan->pDataSink); + } if (!res) { cJSON_Delete(jSubplan); @@ -751,6 +819,9 @@ static SSubplan* subplanFromJson(const cJSON* json) { if (res) { res = fromObjectWithAlloc(json, jkSubplanNode, phyNodeFromJson, (void**)&subplan->pNode, sizeof(SPhyNode), false); } + if (res) { + res = fromObjectWithAlloc(json, jkSubplanDataSink, dataSinkFromJson, (void**)&subplan->pDataSink, sizeof(SDataSink), false); + } if (!res) { qDestroySubplan(subplan); @@ -759,13 +830,22 @@ static SSubplan* subplanFromJson(const cJSON* json) { return subplan; } -int32_t subPlanToString(const SSubplan* subplan, char** str) { +int32_t subPlanToString(const SSubplan* subplan, char** str, int32_t* len) { + if (QUERY_TYPE_MODIFY == subplan->type) { + SDataInserter* insert = (SDataInserter*)(subplan->pDataSink); + *len = insert->size; + *str = insert->pData; + insert->pData == NULL; + return TSDB_CODE_SUCCESS; + } + cJSON* json = subplanToJson(subplan); if (NULL == json) { terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; return TSDB_CODE_FAILED; } *str = cJSON_Print(json); + *len = strlen(*str) + 1; return TSDB_CODE_SUCCESS; } diff --git a/source/libs/planner/src/planner.c b/source/libs/planner/src/planner.c index 7722a7d3639ffcfef62ef9610de5d1ff90daa4c4..e8523249e4cede000d0e6114409c3893ad3fa55b 100644 --- a/source/libs/planner/src/planner.c +++ b/source/libs/planner/src/planner.c @@ -50,8 +50,8 @@ int32_t qSetSubplanExecutionNode(SSubplan* subplan, uint64_t templateId, SEpAddr return setSubplanExecutionNode(subplan, templateId, ep); } -int32_t qSubPlanToString(const SSubplan *subplan, char** str) { - return subPlanToString(subplan, str); +int32_t qSubPlanToString(const SSubplan *subplan, char** str, int32_t* len) { + return subPlanToString(subplan, str, len); } int32_t qStringToSubplan(const char* str, SSubplan** subplan) { diff --git a/source/libs/planner/test/phyPlanTests.cpp b/source/libs/planner/test/phyPlanTests.cpp index 3be3337304534efa3d02a068585ec5f1a916ae3c..f14fd50e034f950b4b048fd8d19dabe6b606f1d4 100644 --- a/source/libs/planner/test/phyPlanTests.cpp +++ b/source/libs/planner/test/phyPlanTests.cpp @@ -33,10 +33,6 @@ protected: void pushScan(const string& db, const string& table, int32_t scanOp) { shared_ptr meta = mockCatalogService->getTableMeta(db, table); EXPECT_TRUE(meta); -// typedef struct SQueryPlanNode { -// SArray *pExpr; // the query functions or sql aggregations -// int32_t numOfExpr; // number of result columns, which is also the number of pExprs -// } SQueryPlanNode; unique_ptr scan((SQueryPlanNode*)calloc(1, sizeof(SQueryPlanNode))); scan->info.type = scanOp; scan->numOfCols = meta->schema->tableInfo.numOfColumns; @@ -54,6 +50,21 @@ protected: return code; } + int32_t run(const string& db, const string& sql) { + SParseContext cxt; + buildParseContext(db, sql, &cxt); + SQueryNode* query; + int32_t code = qParseQuerySql(&cxt, &query); + if (TSDB_CODE_SUCCESS != code) { + cout << "error no:" << code << ", msg:" << cxt.pMsg << endl; + return code; + } + SQueryDag* dag = nullptr; + code = qCreateQueryDag(query, nullptr, &dag); + dag_.reset(dag); + return code; + } + void explain() { size_t level = taosArrayGetSize(dag_->pSubplans); for (size_t i = 0; i < level; ++i) { @@ -62,8 +73,10 @@ protected: size_t num = taosArrayGetSize(subplans); for (size_t j = 0; j < num; ++j) { std::cout << "no " << j << ":" << std::endl; + int32_t len = 0; char* str = nullptr; - ASSERT_EQ (TSDB_CODE_SUCCESS, qSubPlanToString((const SSubplan*)taosArrayGetP(subplans, j), &str)); + ASSERT_EQ(TSDB_CODE_SUCCESS, qSubPlanToString((const SSubplan*)taosArrayGetP(subplans, j), &str, &len)); + std::cout << "len:" << len << std::endl; std::cout << str << std::endl; free(str); } @@ -107,6 +120,25 @@ private: return info; } + void buildParseContext(const string& db, const string& sql, SParseContext* pCxt) { + static string _db; + static string _sql; + static const int32_t _msgMaxLen = 4096; + static char _msg[_msgMaxLen]; + + _db = db; + _sql = sql; + memset(_msg, 0, _msgMaxLen); + + pCxt->ctx.acctId = 1; + pCxt->ctx.db = _db.c_str(); + pCxt->ctx.requestId = 1; + pCxt->pSql = _sql.c_str(); + pCxt->sqlLen = _sql.length(); + pCxt->pMsg = _msg; + pCxt->msgLen = _msgMaxLen; + } + shared_ptr meta_; unique_ptr logicPlan_; unique_ptr dag_; @@ -114,7 +146,7 @@ private: // select * from table TEST_F(PhyPlanTest, tableScanTest) { - pushScan("root.test", "t1", QNODE_TABLESCAN); + pushScan("test", "t1", QNODE_TABLESCAN); ASSERT_EQ(run(), TSDB_CODE_SUCCESS); explain(); SQueryDag* dag = reslut(); @@ -123,9 +155,17 @@ TEST_F(PhyPlanTest, tableScanTest) { // select * from supertable TEST_F(PhyPlanTest, superTableScanTest) { - pushScan("root.test", "st1", QNODE_TABLESCAN); + pushScan("test", "st1", QNODE_TABLESCAN); ASSERT_EQ(run(), TSDB_CODE_SUCCESS); explain(); SQueryDag* dag = reslut(); // todo check } + +// insert into t values(...) +TEST_F(PhyPlanTest, insertTest) { + ASSERT_EQ(run("test", "insert into t1 values (now, 1, \"beijing\")"), TSDB_CODE_SUCCESS); + explain(); + SQueryDag* dag = reslut(); + // todo check +} diff --git a/source/libs/qcom/src/querymsg.c b/source/libs/qcom/src/querymsg.c index 728c47af1e71e4c8b15d1f2a921c34149f3c098f..eb5527f076f7e5ca59607af66d3582c9d0264dfc 100644 --- a/source/libs/qcom/src/querymsg.c +++ b/source/libs/qcom/src/querymsg.c @@ -263,87 +263,12 @@ int32_t queryProcessTableMetaRsp(void* output, char *msg, int32_t msgSize) { } -void msgInit() { +void initQueryModuleMsgHandle() { queryBuildMsg[TSDB_MSG_TYPE_TABLE_META] = queryBuildTableMetaReqMsg; queryBuildMsg[TSDB_MSG_TYPE_USE_DB] = queryBuildUseDbMsg; queryProcessMsgRsp[TSDB_MSG_TYPE_TABLE_META] = queryProcessTableMetaRsp; queryProcessMsgRsp[TSDB_MSG_TYPE_USE_DB] = queryProcessUseDBRsp; - -/* - tscBuildMsg[TSDB_SQL_SELECT] = tscBuildQueryMsg; - tscBuildMsg[TSDB_SQL_INSERT] = tscBuildSubmitMsg; - tscBuildMsg[TSDB_SQL_FETCH] = tscBuildFetchMsg; - - tscBuildMsg[TSDB_SQL_CREATE_DB] = tscBuildCreateDbMsg; - tscBuildMsg[TSDB_SQL_CREATE_USER] = tscBuildUserMsg; - tscBuildMsg[TSDB_SQL_CREATE_FUNCTION] = tscBuildCreateFuncMsg; - - tscBuildMsg[TSDB_SQL_CREATE_ACCT] = tscBuildAcctMsg; - tscBuildMsg[TSDB_SQL_ALTER_ACCT] = tscBuildAcctMsg; - - tscBuildMsg[TSDB_SQL_CREATE_TABLE] = tscBuildCreateTableMsg; - tscBuildMsg[TSDB_SQL_DROP_USER] = tscBuildDropUserAcctMsg; - tscBuildMsg[TSDB_SQL_DROP_ACCT] = tscBuildDropUserAcctMsg; - tscBuildMsg[TSDB_SQL_DROP_DB] = tscBuildDropDbMsg; - tscBuildMsg[TSDB_SQL_DROP_FUNCTION] = tscBuildDropFuncMsg; - tscBuildMsg[TSDB_SQL_SYNC_DB_REPLICA] = tscBuildSyncDbReplicaMsg; - tscBuildMsg[TSDB_SQL_DROP_TABLE] = tscBuildDropTableMsg; - tscBuildMsg[TSDB_SQL_ALTER_USER] = tscBuildUserMsg; - tscBuildMsg[TSDB_SQL_CREATE_DNODE] = tscBuildCreateDnodeMsg; - tscBuildMsg[TSDB_SQL_DROP_DNODE] = tscBuildDropDnodeMsg; - tscBuildMsg[TSDB_SQL_CFG_DNODE] = tscBuildCfgDnodeMsg; - tscBuildMsg[TSDB_SQL_ALTER_TABLE] = tscBuildAlterTableMsg; - tscBuildMsg[TSDB_SQL_UPDATE_TAG_VAL] = tscBuildUpdateTagMsg; - tscBuildMsg[TSDB_SQL_ALTER_DB] = tscAlterDbMsg; - tscBuildMsg[TSDB_SQL_COMPACT_VNODE] = tscBuildCompactMsg; - - tscBuildMsg[TSDB_SQL_CONNECT] = tscBuildConnectMsg; - tscBuildMsg[TSDB_SQL_USE_DB] = tscBuildUseDbMsg; - tscBuildMsg[TSDB_SQL_STABLEVGROUP] = tscBuildSTableVgroupMsg; - tscBuildMsg[TSDB_SQL_RETRIEVE_FUNC] = tscBuildRetrieveFuncMsg; - - tscBuildMsg[TSDB_SQL_HB] = tscBuildHeartBeatMsg; - tscBuildMsg[TSDB_SQL_SHOW] = tscBuildShowMsg; - tscBuildMsg[TSDB_SQL_RETRIEVE_MNODE] = tscBuildRetrieveFromMgmtMsg; - tscBuildMsg[TSDB_SQL_KILL_QUERY] = tscBuildKillMsg; - tscBuildMsg[TSDB_SQL_KILL_STREAM] = tscBuildKillMsg; - tscBuildMsg[TSDB_SQL_KILL_CONNECTION] = tscBuildKillMsg; - - tscProcessMsgRsp[TSDB_SQL_SELECT] = tscProcessQueryRsp; - tscProcessMsgRsp[TSDB_SQL_FETCH] = tscProcessRetrieveRspFromNode; - - tscProcessMsgRsp[TSDB_SQL_DROP_DB] = tscProcessDropDbRsp; - tscProcessMsgRsp[TSDB_SQL_DROP_TABLE] = tscProcessDropTableRsp; - tscProcessMsgRsp[TSDB_SQL_CONNECT] = tscProcessConnectRsp; - tscProcessMsgRsp[TSDB_SQL_USE_DB] = tscProcessUseDbRsp; - tscProcessMsgRsp[TSDB_SQL_META] = tscProcessTableMetaRsp; - tscProcessMsgRsp[TSDB_SQL_STABLEVGROUP] = tscProcessSTableVgroupRsp; - tscProcessMsgRsp[TSDB_SQL_MULTI_META] = tscProcessMultiTableMetaRsp; - tscProcessMsgRsp[TSDB_SQL_RETRIEVE_FUNC] = tscProcessRetrieveFuncRsp; - - tscProcessMsgRsp[TSDB_SQL_SHOW] = tscProcessShowRsp; - tscProcessMsgRsp[TSDB_SQL_RETRIEVE_MNODE] = tscProcessRetrieveRspFromNode; // rsp handled by same function. - tscProcessMsgRsp[TSDB_SQL_DESCRIBE_TABLE] = tscProcessDescribeTableRsp; - - tscProcessMsgRsp[TSDB_SQL_CURRENT_DB] = tscProcessLocalRetrieveRsp; - tscProcessMsgRsp[TSDB_SQL_CURRENT_USER] = tscProcessLocalRetrieveRsp; - tscProcessMsgRsp[TSDB_SQL_SERV_VERSION] = tscProcessLocalRetrieveRsp; - tscProcessMsgRsp[TSDB_SQL_CLI_VERSION] = tscProcessLocalRetrieveRsp; - tscProcessMsgRsp[TSDB_SQL_SERV_STATUS] = tscProcessLocalRetrieveRsp; - - tscProcessMsgRsp[TSDB_SQL_RETRIEVE_EMPTY_RESULT] = tscProcessEmptyResultRsp; - - tscProcessMsgRsp[TSDB_SQL_RETRIEVE_GLOBALMERGE] = tscProcessRetrieveGlobalMergeRsp; - - tscProcessMsgRsp[TSDB_SQL_ALTER_TABLE] = tscProcessAlterTableMsgRsp; - tscProcessMsgRsp[TSDB_SQL_ALTER_DB] = tscProcessAlterDbMsgRsp; - tscProcessMsgRsp[TSDB_SQL_COMPACT_VNODE] = tscProcessCompactRsp; - - tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_TABLE] = tscProcessShowCreateRsp; - tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_STABLE] = tscProcessShowCreateRsp; - tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp; -*/ } diff --git a/source/libs/qworker/inc/qworkerInt.h b/source/libs/qworker/inc/qworkerInt.h index 1adc09def41234a26d3557916eb40917e6e1b57e..6f454e2f8199404778e076bfb7b183601cf51dee 100644 --- a/source/libs/qworker/inc/qworkerInt.h +++ b/source/libs/qworker/inc/qworkerInt.h @@ -20,6 +20,8 @@ extern "C" { #endif +#include "tlockfree.h" + #define QWORKER_DEFAULT_SCHEDULER_NUMBER 10000 #define QWORKER_DEFAULT_RES_CACHE_NUMBER 10000 #define QWORKER_DEFAULT_SCH_TASK_NUMBER 10000 @@ -30,36 +32,63 @@ enum { QW_READY_RESPONSED, }; -typedef struct SQWorkerTaskStatus { - int8_t status; - int8_t ready; +enum { + QW_TASK_INFO_STATUS = 1, + QW_TASK_INFO_READY, +}; + +enum { + QW_READ = 1, + QW_WRITE, +}; + +typedef struct SQWorkerTaskStatus { + SRWLatch lock; + int32_t code; + int8_t status; + int8_t ready; + bool cancel; + bool drop; } SQWorkerTaskStatus; typedef struct SQWorkerResCache { + SRWLatch lock; void *data; } SQWorkerResCache; -typedef struct SQWorkerSchTaskStatus { +typedef struct SQWorkerSchStatus { int32_t lastAccessTs; // timestamp in second - SHashObj *taskStatus; // key:queryId+taskId, value: SQWorkerTaskStatus -} SQWorkerSchTaskStatus; + SRWLatch tasksLock; + SHashObj *tasksHash; // key:queryId+taskId, value: SQWorkerTaskStatus +} SQWorkerSchStatus; // Qnode/Vnode level task management typedef struct SQWorkerMgmt { SQWorkerCfg cfg; - SHashObj *scheduleHash; //key: schedulerId, value: SQWorkerSchTaskStatus + SRWLatch schLock; + SRWLatch resLock; + SHashObj *schHash; //key: schedulerId, value: SQWorkerSchStatus SHashObj *resHash; //key: queryId+taskId, value: SQWorkerResCache } SQWorkerMgmt; -#define QW_TASK_DONE(status) (status == JOB_TASK_STATUS_SUCCEED || status == JOB_TASK_STATUS_FAILED || status == status == JOB_TASK_STATUS_CANCELLED) +#define QW_GOT_RES_DATA(data) (false) +#define QW_LOW_RES_DATA(data) (false) + +#define QW_TASK_NOT_EXIST(code) (TSDB_CODE_QRY_SCH_NOT_EXIST == (code) || TSDB_CODE_QRY_TASK_NOT_EXIST == (code)) +#define QW_TASK_ALREADY_EXIST(code) (TSDB_CODE_QRY_TASK_ALREADY_EXIST == (code)) +#define QW_TASK_READY_RESP(status) (status == JOB_TASK_STATUS_SUCCEED || status == JOB_TASK_STATUS_FAILED || status == JOB_TASK_STATUS_CANCELLED || status == JOB_TASK_STATUS_PARTIAL_SUCCEED) #define QW_SET_QTID(id, qid, tid) do { *(uint64_t *)(id) = (qid); *(uint64_t *)((char *)(id) + sizeof(qid)) = (tid); } while (0) #define QW_GET_QTID(id, qid, tid) do { (qid) = *(uint64_t *)(id); (tid) = *(uint64_t *)((char *)(id) + sizeof(qid)); } while (0) + #define QW_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; return _code; } } while (0) #define QW_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; } return _code; } while (0) #define QW_ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { qError(__VA_ARGS__); terrno = _code; return _code; } } while (0) #define QW_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0) +#define QW_LOCK(type, _lock) (QW_READ == (type) ? taosRLockLatch(_lock) : taosWLockLatch(_lock)) +#define QW_UNLOCK(type, _lock) (QW_READ == (type) ? taosRUnLockLatch(_lock) : taosWUnLockLatch(_lock)) + #ifdef __cplusplus } diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c index 82bfd75b6a1d2ffb22a4c11b6f286b185d6a643a..37d3e655c24b3d13c63b1fd5f9fb9036d966dd30 100644 --- a/source/libs/qworker/src/qworker.c +++ b/source/libs/qworker/src/qworker.c @@ -4,69 +4,79 @@ #include "qworkerInt.h" #include "planner.h" -int32_t qwAddTaskStatus(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId, int8_t taskStatus) { - SQWorkerTaskStatus tStatus = {0}; - tStatus.status = taskStatus; - - char id[sizeof(queryId) + sizeof(taskId)] = {0}; - QW_SET_QTID(id, queryId, taskId); +int32_t qwCheckStatusSwitch(int8_t oriStatus, int8_t newStatus) { + int32_t code = 0; - SQWorkerSchTaskStatus *schStatus = taosHashGet(mgmt->scheduleHash, &schedulerId, sizeof(schedulerId)); - if (NULL == schStatus) { - SQWorkerSchTaskStatus newSchStatus = {0}; - newSchStatus.taskStatus = taosHashInit(mgmt->cfg.maxSchTaskNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); - if (NULL == newSchStatus.taskStatus) { - qError("taosHashInit %d failed", mgmt->cfg.maxSchTaskNum); - return TSDB_CODE_QRY_OUT_OF_MEMORY; + if (oriStatus == newStatus) { + if (newStatus == JOB_TASK_STATUS_CANCELLING) { + return TSDB_CODE_SUCCESS; } - - if (0 != taosHashPut(newSchStatus.taskStatus, id, sizeof(id), &tStatus, sizeof(tStatus))) { - qError("taosHashPut schedulerId[%"PRIx64"]queryId[%"PRIx64"] taskId[%"PRIx64"] to scheduleHash failed", schedulerId, queryId, taskId); - taosHashCleanup(newSchStatus.taskStatus); - return TSDB_CODE_QRY_APP_ERROR; - } - - newSchStatus.lastAccessTs = taosGetTimestampSec(); - - if (0 != taosHashPut(mgmt->scheduleHash, &schedulerId, sizeof(schedulerId), &newSchStatus, sizeof(newSchStatus))) { - qError("taosHashPut schedulerId[%"PRIx64"] to scheduleHash failed", schedulerId); - taosHashCleanup(newSchStatus.taskStatus); + + QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); + } + + switch (oriStatus) { + case JOB_TASK_STATUS_NULL: + if (newStatus != JOB_TASK_STATUS_EXECUTING && newStatus != JOB_TASK_STATUS_FAILED ) { + QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); + } + + break; + case JOB_TASK_STATUS_NOT_START: + if (newStatus != JOB_TASK_STATUS_EXECUTING && newStatus != JOB_TASK_STATUS_FAILED) { + QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); + } + + break; + case JOB_TASK_STATUS_EXECUTING: + if (newStatus != JOB_TASK_STATUS_SUCCEED && newStatus != JOB_TASK_STATUS_FAILED && newStatus != JOB_TASK_STATUS_CANCELLING) { + QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); + } + + break; + case JOB_TASK_STATUS_PARTIAL_SUCCEED: + if (newStatus != JOB_TASK_STATUS_EXECUTING && newStatus != JOB_TASK_STATUS_CANCELLING) { + QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); + } + + break; + case JOB_TASK_STATUS_SUCCEED: + case JOB_TASK_STATUS_FAILED: + case JOB_TASK_STATUS_CANCELLING: + if (newStatus != JOB_TASK_STATUS_CANCELLED) { + QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); + } + + break; + case JOB_TASK_STATUS_CANCELLED: + default: + qError("invalid task status:%d", oriStatus); return TSDB_CODE_QRY_APP_ERROR; - } - - return TSDB_CODE_SUCCESS; } - schStatus->lastAccessTs = taosGetTimestampSec(); + return TSDB_CODE_SUCCESS; - if (0 != taosHashPut(schStatus->taskStatus, id, sizeof(id), &tStatus, sizeof(tStatus))) { - qError("taosHashPut schedulerId[%"PRIx64"]queryId[%"PRIx64"] taskId[%"PRIx64"] to scheduleHash failed", schedulerId, queryId, taskId); - return TSDB_CODE_QRY_APP_ERROR; - } +_return: - return TSDB_CODE_SUCCESS; + qError("invalid task status:%d", oriStatus); + QW_ERR_RET(code); } -int32_t qwGetTaskStatus(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId, SQWorkerTaskStatus **taskStatus) { - SQWorkerSchTaskStatus *schStatus = taosHashGet(mgmt->scheduleHash, &schedulerId, sizeof(schedulerId)); - if (NULL == schStatus) { - qError("no scheduler for schedulerId[%"PRIx64"]", schedulerId); - return TSDB_CODE_QRY_APP_ERROR; - } - - schStatus->lastAccessTs = taosGetTimestampSec(); +int32_t qwUpdateTaskInfo(SQWorkerTaskStatus *task, int8_t type, void *data) { + int32_t code = 0; - char id[sizeof(queryId) + sizeof(taskId)] = {0}; - QW_SET_QTID(id, queryId, taskId); - - SQWorkerTaskStatus *tStatus = taosHashGet(schStatus->taskStatus, id, sizeof(id)); - if (NULL == tStatus) { - qError("no task status for schedulerId[%"PRIx64"] queryId[%"PRIx64"] taskId[%"PRIx64"]", schedulerId, queryId, taskId); - return TSDB_CODE_QRY_APP_ERROR; + switch (type) { + case QW_TASK_INFO_STATUS: { + int8_t newStatus = *(int8_t *)data; + QW_ERR_RET(qwCheckStatusSwitch(task->status, newStatus)); + task->status = newStatus; + break; + } + default: + qError("uknown task info type:%d", type); + return TSDB_CODE_QRY_APP_ERROR; } - - *taskStatus = tStatus; - + return TSDB_CODE_SUCCESS; } @@ -76,12 +86,16 @@ int32_t qwAddTaskResult(SQWorkerMgmt *mgmt, uint64_t queryId, uint64_t taskId, v SQWorkerResCache resCache = {0}; resCache.data = data; - + + QW_LOCK(QW_WRITE, &mgmt->resLock); if (0 != taosHashPut(mgmt->resHash, id, sizeof(id), &resCache, sizeof(SQWorkerResCache))) { + QW_UNLOCK(QW_WRITE, &mgmt->resLock); qError("taosHashPut queryId[%"PRIx64"] taskId[%"PRIx64"] to resHash failed", queryId, taskId); return TSDB_CODE_QRY_APP_ERROR; } + QW_UNLOCK(QW_WRITE, &mgmt->resLock); + return TSDB_CODE_SUCCESS; } @@ -101,62 +115,794 @@ int32_t qwGetTaskResult(SQWorkerMgmt *mgmt, uint64_t queryId, uint64_t taskId, v return TSDB_CODE_SUCCESS; } -int32_t qwUpdateSchLastAccess(SQWorkerMgmt *mgmt, uint64_t schedulerId) { - SQWorkerSchTaskStatus *schStatus = taosHashGet(mgmt->scheduleHash, &schedulerId, sizeof(schedulerId)); - if (NULL == schStatus) { - qError("no scheduler for schedulerId[%"PRIx64"]", schedulerId); - return TSDB_CODE_QRY_APP_ERROR; + +static FORCE_INLINE int32_t qwAcquireScheduler(int32_t rwType, SQWorkerMgmt *mgmt, uint64_t schedulerId, SQWorkerSchStatus **sch) { + QW_LOCK(rwType, &mgmt->schLock); + *sch = taosHashGet(mgmt->schHash, &schedulerId, sizeof(schedulerId)); + if (NULL == (*sch)) { + QW_LOCK(rwType, &mgmt->schLock); + return TSDB_CODE_QRY_SCH_NOT_EXIST; } - schStatus->lastAccessTs = taosGetTimestampSec(); + return TSDB_CODE_SUCCESS; +} + + +static FORCE_INLINE int32_t qwInsertAndAcquireScheduler(int32_t rwType, SQWorkerMgmt *mgmt, uint64_t schedulerId, SQWorkerSchStatus **sch) { + SQWorkerSchStatus newSch = {0}; + newSch.tasksHash = taosHashInit(mgmt->cfg.maxSchTaskNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK); + if (NULL == newSch.tasksHash) { + qError("taosHashInit %d failed", mgmt->cfg.maxSchTaskNum); + return TSDB_CODE_QRY_OUT_OF_MEMORY; + } + + while (true) { + QW_LOCK(QW_WRITE, &mgmt->schLock); + int32_t code = taosHashPut(mgmt->schHash, &schedulerId, sizeof(schedulerId), &newSch, sizeof(newSch)); + if (0 != code) { + if (!HASH_NODE_EXIST(code)) { + QW_UNLOCK(QW_WRITE, &mgmt->schLock); + qError("taosHashPut schedulerId[%"PRIx64"] to scheduleHash failed", schedulerId); + taosHashCleanup(newSch.tasksHash); + return TSDB_CODE_QRY_APP_ERROR; + } + } + + QW_UNLOCK(QW_WRITE, &mgmt->schLock); + if (TSDB_CODE_SUCCESS == qwAcquireScheduler(rwType, mgmt, schedulerId, sch)) { + taosHashCleanup(newSch.tasksHash); + return TSDB_CODE_SUCCESS; + } + } return TSDB_CODE_SUCCESS; } -int32_t qwGetSchTasksStatus(SQWorkerMgmt *mgmt, uint64_t schedulerId, SSchedulerStatusRsp **rsp) { - SQWorkerSchTaskStatus *schStatus = taosHashGet(mgmt->scheduleHash, &schedulerId, sizeof(schedulerId)); - if (NULL == schStatus) { - qError("no scheduler for schedulerId[%"PRIx64"]", schedulerId); - return TSDB_CODE_QRY_APP_ERROR; + +static FORCE_INLINE void qwReleaseScheduler(int32_t rwType, SQWorkerMgmt *mgmt) { + QW_UNLOCK(rwType, &mgmt->schLock); +} + +static FORCE_INLINE int32_t qwAcquireTask(int32_t rwType, SQWorkerSchStatus *sch, uint64_t queryId, uint64_t taskId, SQWorkerTaskStatus **task) { + char id[sizeof(queryId) + sizeof(taskId)] = {0}; + QW_SET_QTID(id, queryId, taskId); + + QW_LOCK(rwType, &sch->tasksLock); + *task = taosHashGet(sch->tasksHash, id, sizeof(id)); + if (NULL == (*task)) { + QW_UNLOCK(rwType, &sch->tasksLock); + return TSDB_CODE_QRY_TASK_NOT_EXIST; } - schStatus->lastAccessTs = taosGetTimestampSec(); + return TSDB_CODE_SUCCESS; +} - int32_t i = 0; - int32_t taskNum = taosHashGetSize(schStatus->taskStatus); +static FORCE_INLINE int32_t qwInsertAndAcquireTask(int32_t rwType, SQWorkerSchStatus *sch, uint64_t queryId, uint64_t taskId, int8_t status, bool *inserted, SQWorkerTaskStatus **task) { + char id[sizeof(queryId) + sizeof(taskId)] = {0}; + QW_SET_QTID(id, queryId, taskId); + + while (true) { + *inserted = false; + + QW_LOCK(QW_WRITE, &sch->tasksLock); + int32_t code = taosHashPut(sch->tasksHash, id, sizeof(id), &status, sizeof(status)); + if (0 != code) { + QW_UNLOCK(QW_WRITE, &sch->tasksLock); + if (HASH_NODE_EXIST(code)) { + if (qwAcquireTask(rwType, sch, queryId, taskId, task)) { + continue; + } + + break; + } else { + qError("taosHashPut queryId[%"PRIx64"] taskId[%"PRIx64"] to scheduleHash failed", queryId, taskId); + return TSDB_CODE_QRY_APP_ERROR; + } + } + QW_UNLOCK(QW_WRITE, &sch->tasksLock); + + *inserted = true; + + if (TSDB_CODE_SUCCESS == qwAcquireTask(rwType, sch, queryId, taskId, task)) { + return TSDB_CODE_SUCCESS; + } + } + + return TSDB_CODE_SUCCESS; +} + + +static FORCE_INLINE void qwReleaseTask(int32_t rwType, SQWorkerSchStatus *sch) { + QW_UNLOCK(rwType, &sch->tasksLock); +} + +static FORCE_INLINE int32_t qwAcquireTaskResCache(int32_t rwType, SQWorkerMgmt *mgmt, uint64_t queryId, uint64_t taskId, SQWorkerResCache **res) { + char id[sizeof(queryId) + sizeof(taskId)] = {0}; + QW_SET_QTID(id, queryId, taskId); + + QW_LOCK(rwType, &mgmt->resLock); + *res = taosHashGet(mgmt->resHash, id, sizeof(id)); + if (NULL == (*res)) { + QW_UNLOCK(rwType, &mgmt->resLock); + return TSDB_CODE_QRY_RES_CACHE_NOT_EXIST; + } + + return TSDB_CODE_SUCCESS; +} + +static FORCE_INLINE void qwReleaseTaskResCache(int32_t rwType, SQWorkerMgmt *mgmt) { + QW_UNLOCK(rwType, &mgmt->resLock); +} + + +int32_t qwGetSchTasksStatus(SQWorkerMgmt *mgmt, uint64_t schedulerId, SSchedulerStatusRsp **rsp) { + SQWorkerSchStatus *schStatus = NULL; + int32_t taskNum = 0; + + if (qwAcquireScheduler(QW_READ, mgmt, schedulerId, &schStatus)) { + qWarn("no scheduler for schedulerId[%"PRIx64"]", schedulerId); + } else { + schStatus->lastAccessTs = taosGetTimestampSec(); + + QW_LOCK(QW_READ, &schStatus->tasksLock); + taskNum = taosHashGetSize(schStatus->tasksHash); + } + int32_t size = sizeof(SSchedulerStatusRsp) + sizeof((*rsp)->status[0]) * taskNum; *rsp = calloc(1, size); if (NULL == *rsp) { qError("calloc %d failed", size); + if (schStatus) { + QW_UNLOCK(QW_READ, &schStatus->tasksLock); + qwReleaseScheduler(QW_READ, mgmt); + } + return TSDB_CODE_QRY_OUT_OF_MEMORY; } void *key = NULL; size_t keyLen = 0; - void *pIter = taosHashIterate(schStatus->taskStatus, NULL); - while (pIter) { - SQWorkerTaskStatus *taskStatus = (SQWorkerTaskStatus *)pIter; - taosHashGetKey(pIter, &key, &keyLen); + int32_t i = 0; - QW_GET_QTID(key, (*rsp)->status[i].queryId, (*rsp)->status[i].taskId); - (*rsp)->status[i].status = taskStatus->status; - - pIter = taosHashIterate(schStatus->taskStatus, pIter); - } + if (schStatus) { + void *pIter = taosHashIterate(schStatus->tasksHash, NULL); + while (pIter) { + SQWorkerTaskStatus *taskStatus = (SQWorkerTaskStatus *)pIter; + taosHashGetKey(pIter, &key, &keyLen); + + QW_GET_QTID(key, (*rsp)->status[i].queryId, (*rsp)->status[i].taskId); + (*rsp)->status[i].status = taskStatus->status; + + pIter = taosHashIterate(schStatus->tasksHash, pIter); + } + } + + if (schStatus) { + QW_UNLOCK(QW_READ, &schStatus->tasksLock); + qwReleaseScheduler(QW_READ, mgmt); + } (*rsp)->num = taskNum; return TSDB_CODE_SUCCESS; } -int32_t qwBuildRspMsg(void *data, int32_t msgType); + + +int32_t qwUpdateSchLastAccess(SQWorkerMgmt *mgmt, uint64_t schedulerId) { + SQWorkerSchStatus *schStatus = NULL; + + QW_ERR_RET(qwAcquireScheduler(QW_READ, mgmt, schedulerId, &schStatus)); + + schStatus->lastAccessTs = taosGetTimestampSec(); + + qwReleaseScheduler(QW_READ, mgmt); + + return TSDB_CODE_SUCCESS; +} + + +int32_t qwGetTaskStatus(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId, int8_t *taskStatus) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + + QW_ERR_RET(qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)); + + QW_ERR_JRET(qwAcquireTask(QW_READ, sch, queryId, taskId, &task)); + + *taskStatus = task->status; + +_return: + if (task) { + qwReleaseTask(QW_READ, sch); + } + + if (sch) { + qwReleaseScheduler(QW_READ, mgmt); + } + + QW_RET(code); +} + + +int32_t qwSwitchTaskStatus(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId, int8_t taskStatus) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + bool inserted = false; + + if (qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)) { + if (qwCheckStatusSwitch(JOB_TASK_STATUS_NULL, taskStatus)) { + qError("switch status error, not start to %d", taskStatus); + QW_ERR_RET(TSDB_CODE_QRY_APP_ERROR); + } + + QW_ERR_RET(qwInsertAndAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)); + } + + if (qwAcquireTask(QW_READ, sch, queryId, taskId, &task)) { + if (qwCheckStatusSwitch(JOB_TASK_STATUS_NOT_START, taskStatus)) { + qwReleaseScheduler(QW_READ, mgmt); + qError("switch status error, not start to %d", taskStatus); + QW_ERR_RET(TSDB_CODE_QRY_APP_ERROR); + } + + QW_ERR_JRET(qwInsertAndAcquireTask(QW_READ, sch, queryId, taskId, taskStatus, &inserted, &task)); + + if (inserted) { + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + return TSDB_CODE_SUCCESS; + } + + QW_LOCK(QW_WRITE, &task->lock); + code = qwUpdateTaskInfo(task, QW_TASK_INFO_STATUS, &taskStatus); + QW_UNLOCK(QW_WRITE, &task->lock); + + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + QW_RET(code); + } + + QW_LOCK(QW_WRITE, &task->lock); + code = qwUpdateTaskInfo(task, QW_TASK_INFO_STATUS, &taskStatus); + QW_UNLOCK(QW_WRITE, &task->lock); + +_return: + + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + QW_RET(code); +} + + +int32_t qwCancelTask(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + + if (TSDB_CODE_SUCCESS != qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)) { + QW_ERR_RET(qwSwitchTaskStatus(mgmt, schedulerId, queryId, taskId, JOB_TASK_STATUS_NOT_START)); + + QW_ERR_RET(qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)); + } + + if (qwAcquireTask(QW_READ, sch, queryId, taskId, &task)) { + code = qwSwitchTaskStatus(mgmt, schedulerId, queryId, taskId, JOB_TASK_STATUS_NOT_START); + if (code) { + qwReleaseScheduler(QW_READ, mgmt); + QW_ERR_RET(code); + } + + QW_ERR_JRET(qwAcquireTask(QW_READ, sch, queryId, taskId, &task)); + } + + QW_LOCK(QW_WRITE, &task->lock); + + task->cancel = true; + + int8_t oriStatus = task->status; + int8_t newStatus = 0; + + if (task->status == JOB_TASK_STATUS_CANCELLED || task->status == JOB_TASK_STATUS_NOT_START || task->status == JOB_TASK_STATUS_CANCELLING || task->status == JOB_TASK_STATUS_DROPPING) { + QW_UNLOCK(QW_WRITE, &task->lock); + + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + return TSDB_CODE_SUCCESS; + } else if (task->status == JOB_TASK_STATUS_FAILED || task->status == JOB_TASK_STATUS_SUCCEED || task->status == JOB_TASK_STATUS_PARTIAL_SUCCEED) { + newStatus = JOB_TASK_STATUS_CANCELLED; + QW_ERR_JRET(qwUpdateTaskInfo(task, QW_TASK_INFO_STATUS, &newStatus)); + } else { + newStatus = JOB_TASK_STATUS_CANCELLING; + QW_ERR_JRET(qwUpdateTaskInfo(task, QW_TASK_INFO_STATUS, &newStatus)); + } + + QW_UNLOCK(QW_WRITE, &task->lock); + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + if (oriStatus == JOB_TASK_STATUS_EXECUTING) { + //TODO call executer to cancel subquery async + } + + return TSDB_CODE_SUCCESS; + +_return: + + if (task) { + QW_UNLOCK(QW_WRITE, &task->lock); + + qwReleaseTask(QW_READ, sch); + } + + if (sch) { + qwReleaseScheduler(QW_READ, mgmt); + } + + QW_RET(code); +} + + + +int32_t qwDropTask(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + char id[sizeof(queryId) + sizeof(taskId)] = {0}; + QW_SET_QTID(id, queryId, taskId); + + QW_LOCK(QW_WRITE, &mgmt->resLock); + if (mgmt->resHash) { + taosHashRemove(mgmt->resHash, id, sizeof(id)); + } + QW_UNLOCK(QW_WRITE, &mgmt->resLock); + + if (TSDB_CODE_SUCCESS != qwAcquireScheduler(QW_WRITE, mgmt, schedulerId, &sch)) { + qWarn("scheduler %"PRIx64" doesn't exist", schedulerId); + return TSDB_CODE_SUCCESS; + } + + if (qwAcquireTask(QW_WRITE, sch, queryId, taskId, &task)) { + qwReleaseScheduler(QW_WRITE, mgmt); + + qWarn("scheduler %"PRIx64" queryId %"PRIx64" taskId:%"PRIx64" doesn't exist", schedulerId, queryId, taskId); + return TSDB_CODE_SUCCESS; + } + + taosHashRemove(sch->tasksHash, id, sizeof(id)); + + qwReleaseTask(QW_WRITE, sch); + qwReleaseScheduler(QW_WRITE, mgmt); + + return TSDB_CODE_SUCCESS; +} + + +int32_t qwCancelDropTask(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + + if (TSDB_CODE_SUCCESS != qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)) { + qWarn("scheduler %"PRIx64" doesn't exist", schedulerId); + return TSDB_CODE_SUCCESS; + } + + if (qwAcquireTask(QW_READ, sch, queryId, taskId, &task)) { + qwReleaseScheduler(QW_READ, mgmt); + + qWarn("scheduler %"PRIx64" queryId %"PRIx64" taskId:%"PRIx64" doesn't exist", schedulerId, queryId, taskId); + return TSDB_CODE_SUCCESS; + } + + QW_LOCK(QW_WRITE, &task->lock); + + task->drop = true; + + int8_t oriStatus = task->status; + int8_t newStatus = 0; + + if (task->status == JOB_TASK_STATUS_EXECUTING) { + newStatus = JOB_TASK_STATUS_CANCELLING; + QW_ERR_JRET(qwUpdateTaskInfo(task, QW_TASK_INFO_STATUS, &newStatus)); + } else if (task->status == JOB_TASK_STATUS_CANCELLING || task->status == JOB_TASK_STATUS_DROPPING || task->status == JOB_TASK_STATUS_NOT_START) { + QW_UNLOCK(QW_WRITE, &task->lock); + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + return TSDB_CODE_SUCCESS; + } else { + QW_UNLOCK(QW_WRITE, &task->lock); + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + QW_ERR_RET(qwDropTask(mgmt, schedulerId, queryId, taskId)); + return TSDB_CODE_SUCCESS; + } + + QW_UNLOCK(QW_WRITE, &task->lock); + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + if (oriStatus == JOB_TASK_STATUS_EXECUTING) { + //TODO call executer to cancel subquery async + } + + return TSDB_CODE_SUCCESS; + +_return: + + if (task) { + QW_UNLOCK(QW_WRITE, &task->lock); + + qwReleaseTask(QW_READ, sch); + } + + if (sch) { + qwReleaseScheduler(QW_READ, mgmt); + } + + QW_RET(code); +} + + + +int32_t qwBuildAndSendQueryRsp(SRpcMsg *pMsg, int32_t code) { + SQueryTableRsp *pRsp = (SQueryTableRsp *)rpcMallocCont(sizeof(SQueryTableRsp)); + pRsp->code = code; + + SRpcMsg rpcRsp = { + .handle = pMsg->handle, + .ahandle = pMsg->ahandle, + .pCont = pRsp, + .contLen = sizeof(*pRsp), + .code = code, + }; + + rpcSendResponse(&rpcRsp); + + return TSDB_CODE_SUCCESS; +} + +int32_t qwBuildAndSendReadyRsp(SRpcMsg *pMsg, int32_t code) { + SResReadyRsp *pRsp = (SResReadyRsp *)rpcMallocCont(sizeof(SResReadyRsp)); + pRsp->code = code; + + SRpcMsg rpcRsp = { + .handle = pMsg->handle, + .ahandle = pMsg->ahandle, + .pCont = pRsp, + .contLen = sizeof(*pRsp), + .code = code, + }; + + rpcSendResponse(&rpcRsp); + + return TSDB_CODE_SUCCESS; +} + +int32_t qwBuildAndSendStatusRsp(SRpcMsg *pMsg, SSchedulerStatusRsp *sStatus) { + int32_t size = 0; + + if (sStatus) { + size = sizeof(SSchedulerStatusRsp) + sizeof(sStatus->status[0]) * sStatus->num; + } else { + size = sizeof(SSchedulerStatusRsp); + } + + SSchedulerStatusRsp *pRsp = (SSchedulerStatusRsp *)rpcMallocCont(size); + + if (sStatus) { + memcpy(pRsp, sStatus, size); + } else { + pRsp->num = 0; + } + + SRpcMsg rpcRsp = { + .handle = pMsg->handle, + .ahandle = pMsg->ahandle, + .pCont = pRsp, + .contLen = size, + .code = 0, + }; + + rpcSendResponse(&rpcRsp); + + return TSDB_CODE_SUCCESS; +} + +int32_t qwBuildAndSendFetchRsp(SRpcMsg *pMsg, void *data) { + SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp)); + memset(pRsp, 0, sizeof(SRetrieveTableRsp)); + + //TODO fill msg + pRsp->completed = true; + + SRpcMsg rpcRsp = { + .handle = pMsg->handle, + .ahandle = pMsg->ahandle, + .pCont = pRsp, + .contLen = sizeof(*pRsp), + .code = 0, + }; + + rpcSendResponse(&rpcRsp); + + return TSDB_CODE_SUCCESS; +} + + +int32_t qwBuildAndSendCancelRsp(SRpcMsg *pMsg, int32_t code) { + STaskCancelRsp *pRsp = (STaskCancelRsp *)rpcMallocCont(sizeof(STaskCancelRsp)); + pRsp->code = code; + + SRpcMsg rpcRsp = { + .handle = pMsg->handle, + .ahandle = pMsg->ahandle, + .pCont = pRsp, + .contLen = sizeof(*pRsp), + .code = code, + }; + + rpcSendResponse(&rpcRsp); + + return TSDB_CODE_SUCCESS; +} + +int32_t qwBuildAndSendDropRsp(SRpcMsg *pMsg, int32_t code) { + STaskDropRsp *pRsp = (STaskDropRsp *)rpcMallocCont(sizeof(STaskDropRsp)); + pRsp->code = code; + + SRpcMsg rpcRsp = { + .handle = pMsg->handle, + .ahandle = pMsg->ahandle, + .pCont = pRsp, + .contLen = sizeof(*pRsp), + .code = code, + }; + + rpcSendResponse(&rpcRsp); + + return TSDB_CODE_SUCCESS; +} + + + +int32_t qwCheckAndSendReadyRsp(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId, SRpcMsg *pMsg, int32_t rspCode) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + + QW_ERR_RET(qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)); + + QW_ERR_JRET(qwAcquireTask(QW_READ, sch, queryId, taskId, &task)); + + QW_LOCK(QW_WRITE, &task->lock); + + if (QW_READY_NOT_RECEIVED == task->ready) { + QW_UNLOCK(QW_WRITE, &task->lock); + + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + return TSDB_CODE_SUCCESS; + } else if (QW_READY_RECEIVED == task->ready) { + QW_ERR_JRET(qwBuildAndSendReadyRsp(pMsg, rspCode)); + + task->ready = QW_READY_RESPONSED; + } else if (QW_READY_RESPONSED == task->ready) { + qError("query response already send"); + QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); + } else { + assert(0); + } + +_return: + + if (task) { + QW_UNLOCK(QW_WRITE, &task->lock); + } + + if (sch) { + qwReleaseTask(QW_READ, sch); + } + + qwReleaseScheduler(QW_READ, mgmt); + + QW_RET(code); +} + +int32_t qwSetAndSendReadyRsp(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId, SRpcMsg *pMsg) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + + QW_ERR_RET(qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)); + + QW_ERR_JRET(qwAcquireTask(QW_READ, sch, queryId, taskId, &task)); + + QW_LOCK(QW_WRITE, &task->lock); + if (QW_TASK_READY_RESP(task->status)) { + QW_ERR_JRET(qwBuildAndSendReadyRsp(pMsg, task->code)); + + task->ready = QW_READY_RESPONSED; + } else { + task->ready = QW_READY_RECEIVED; + QW_UNLOCK(QW_WRITE, &task->lock); + + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + return TSDB_CODE_SUCCESS; + } + +_return: + + if (task) { + QW_UNLOCK(QW_WRITE, &task->lock); + } + + if (sch) { + qwReleaseTask(QW_READ, sch); + } + + qwReleaseScheduler(QW_READ, mgmt); + + QW_RET(code); +} + +int32_t qwCheckTaskCancelDrop( SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId, bool *needStop) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + int8_t status = JOB_TASK_STATUS_CANCELLED; + + *needStop = false; + + if (qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)) { + return TSDB_CODE_SUCCESS; + } + + if (qwAcquireTask(QW_READ, sch, queryId, taskId, &task)) { + qwReleaseScheduler(QW_READ, mgmt); + return TSDB_CODE_SUCCESS; + } + + QW_LOCK(QW_READ, &task->lock); + + if ((!task->cancel) && (!task->drop)) { + QW_UNLOCK(QW_READ, &task->lock); + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + return TSDB_CODE_SUCCESS; + } + + QW_UNLOCK(QW_READ, &task->lock); + + *needStop = true; + + if (task->cancel) { + QW_LOCK(QW_WRITE, &task->lock); + qwUpdateTaskInfo(task, QW_TASK_INFO_STATUS, &status); + QW_UNLOCK(QW_WRITE, &task->lock); + } else if (task->drop) { + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + qwDropTask(mgmt, schedulerId, queryId, taskId); + } + + return TSDB_CODE_SUCCESS; +} + + +int32_t qwHandleFetch(SQWorkerResCache *res, SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId, SRpcMsg *pMsg) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + int32_t needRsp = true; + void *data = NULL; + + QW_ERR_JRET(qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch)); + QW_ERR_JRET(qwAcquireTask(QW_READ, sch, queryId, taskId, &task)); + + QW_LOCK(QW_READ, &task->lock); + + if (task->status != JOB_TASK_STATUS_EXECUTING && task->status != JOB_TASK_STATUS_PARTIAL_SUCCEED && task->status != JOB_TASK_STATUS_SUCCEED) { + qError("invalid status %d for fetch", task->status); + QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); + } + + if (QW_GOT_RES_DATA(res->data)) { + data = res->data; + if (QW_LOW_RES_DATA(res->data)) { + if (task->status == JOB_TASK_STATUS_PARTIAL_SUCCEED) { + //TODO add query back to queue + } + } + } else { + if (task->status != JOB_TASK_STATUS_EXECUTING) { + qError("invalid status %d for fetch without res", task->status); + QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); + } + + //TODO SET FLAG FOR QUERY TO SEND RSP WHEN RES READY + + needRsp = false; + } + +_return: + if (task) { + QW_UNLOCK(QW_READ, &task->lock); + } + + if (sch) { + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + } + + if (needRsp) { + qwBuildAndSendFetchRsp(pMsg, res->data); + } + + QW_RET(code); +} + +int32_t qwQueryPostProcess(SQWorkerMgmt *mgmt, uint64_t schedulerId, uint64_t queryId, uint64_t taskId, int8_t status, int32_t errCode) { + SQWorkerSchStatus *sch = NULL; + SQWorkerTaskStatus *task = NULL; + int32_t code = 0; + int8_t newStatus = JOB_TASK_STATUS_CANCELLED; + + code = qwAcquireScheduler(QW_READ, mgmt, schedulerId, &sch); + if (code) { + qError("schedulerId:%"PRIx64" not in cache", schedulerId); + QW_ERR_RET(code); + } + + code = qwAcquireTask(QW_READ, sch, queryId, taskId, &task); + if (code) { + qwReleaseScheduler(QW_READ, mgmt); + qError("schedulerId:%"PRIx64" queryId:%"PRIx64" taskId:%"PRIx64" not in cache", schedulerId, queryId, taskId); + QW_ERR_RET(code); + } + + if (task->cancel) { + QW_LOCK(QW_WRITE, &task->lock); + qwUpdateTaskInfo(task, QW_TASK_INFO_STATUS, &newStatus); + QW_UNLOCK(QW_WRITE, &task->lock); + } else if (task->drop) { + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + qwDropTask(mgmt, schedulerId, queryId, taskId); + + return TSDB_CODE_SUCCESS; + } else { + QW_LOCK(QW_WRITE, &task->lock); + qwUpdateTaskInfo(task, QW_TASK_INFO_STATUS, &status); + task->code = errCode; + QW_UNLOCK(QW_WRITE, &task->lock); + } + + qwReleaseTask(QW_READ, sch); + qwReleaseScheduler(QW_READ, mgmt); + + return TSDB_CODE_SUCCESS; +} int32_t qWorkerInit(SQWorkerCfg *cfg, void **qWorkerMgmt) { SQWorkerMgmt *mgmt = calloc(1, sizeof(SQWorkerMgmt)); if (NULL == mgmt) { qError("calloc %d failed", (int32_t)sizeof(SQWorkerMgmt)); - return TSDB_CODE_QRY_OUT_OF_MEMORY; + QW_RET(TSDB_CODE_QRY_OUT_OF_MEMORY); } if (cfg) { @@ -167,16 +913,16 @@ int32_t qWorkerInit(SQWorkerCfg *cfg, void **qWorkerMgmt) { mgmt->cfg.maxSchTaskNum = QWORKER_DEFAULT_SCH_TASK_NUMBER; } - mgmt->scheduleHash = taosHashInit(mgmt->cfg.maxSchedulerNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK); - if (NULL == mgmt->scheduleHash) { + mgmt->schHash = taosHashInit(mgmt->cfg.maxSchedulerNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK); + if (NULL == mgmt->schHash) { tfree(mgmt); QW_ERR_LRET(TSDB_CODE_QRY_OUT_OF_MEMORY, "init %d schduler hash failed", mgmt->cfg.maxSchedulerNum); } - mgmt->resHash = taosHashInit(mgmt->cfg.maxResCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); + mgmt->resHash = taosHashInit(mgmt->cfg.maxResCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK); if (NULL == mgmt->resHash) { - taosHashCleanup(mgmt->scheduleHash); - mgmt->scheduleHash = NULL; + taosHashCleanup(mgmt->schHash); + mgmt->schHash = NULL; tfree(mgmt); QW_ERR_LRET(TSDB_CODE_QRY_OUT_OF_MEMORY, "init %d res cache hash failed", mgmt->cfg.maxResCacheNum); @@ -187,99 +933,193 @@ int32_t qWorkerInit(SQWorkerCfg *cfg, void **qWorkerMgmt) { return TSDB_CODE_SUCCESS; } -int32_t qWorkerProcessQueryMsg(void *qWorkerMgmt, SSchedulerQueryMsg *msg, SRpcMsg *rsp) { - if (NULL == qWorkerMgmt || NULL == msg || NULL == rsp) { - return TSDB_CODE_QRY_INVALID_INPUT; +int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) { + if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) { + QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT); } + SSubQueryMsg *msg = pMsg->pCont; + if (NULL == msg || pMsg->contLen <= sizeof(*msg)) { + qError("invalid query msg"); + QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT); + } + + bool queryDone = false; + bool queryRsp = false; + bool needStop = false; SSubplan *plan = NULL; - SQWorkerTaskStatus *tStatus = NULL; + int32_t code = 0; - int32_t code = qStringToSubplan(msg->msg, &plan); + QW_ERR_JRET(qwCheckTaskCancelDrop(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, &needStop)); + if (needStop) { + qWarn("task need stop"); + QW_ERR_JRET(TSDB_CODE_QRY_TASK_CANCELLED); + } + + code = qStringToSubplan(msg->msg, &plan); if (TSDB_CODE_SUCCESS != code) { qError("schId:%"PRIx64",qId:%"PRIx64",taskId:%"PRIx64" string to subplan failed, code:%d", msg->schedulerId, msg->queryId, msg->taskId, code); - return code; + QW_ERR_JRET(code); } - - //TODO call executer to init subquery - QW_ERR_JRET(qwAddTaskStatus(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, JOB_TASK_STATUS_EXECUTING)); + //TODO call executer to init subquery + code = 0; // return error directly + //TODO call executer to init subquery + + if (code) { + QW_ERR_JRET(code); + } else { + QW_ERR_JRET(qwSwitchTaskStatus(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, JOB_TASK_STATUS_EXECUTING)); + } - QW_ERR_JRET(qwBuildRspMsg(NULL, TSDB_MSG_TYPE_QUERY_RSP)); + QW_ERR_JRET(qwBuildAndSendQueryRsp(pMsg, TSDB_CODE_SUCCESS)); + queryRsp = true; + //TODO call executer to execute subquery - code = 0; + code = 0; void *data = NULL; + queryDone = false; //TODO call executer to execute subquery - QW_ERR_JRET(qwGetTaskStatus(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, &tStatus)); - - tStatus->status = (code) ? JOB_TASK_STATUS_FAILED : JOB_TASK_STATUS_SUCCEED; + if (code) { + QW_ERR_JRET(code); + } else { + QW_ERR_JRET(qwAddTaskResult(qWorkerMgmt, msg->queryId, msg->taskId, data)); - QW_ERR_JRET(qwAddTaskResult(qWorkerMgmt, msg->queryId, msg->taskId, data)); + QW_ERR_JRET(qwSwitchTaskStatus(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, JOB_TASK_STATUS_PARTIAL_SUCCEED)); + } _return: - if (tStatus && QW_TASK_DONE(tStatus->status) && QW_READY_RECEIVED == tStatus->ready) { - QW_ERR_RET(qwBuildRspMsg(NULL, TSDB_MSG_TYPE_RES_READY_RSP)); + if (queryRsp) { + code = qwCheckAndSendReadyRsp(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, pMsg, code); + } else { + code = qwBuildAndSendQueryRsp(pMsg, code); } + + int8_t status = 0; + if (TSDB_CODE_SUCCESS != code || queryDone) { + if (code) { + status = JOB_TASK_STATUS_FAILED; //TODO set CANCELLED from code + } else { + status = JOB_TASK_STATUS_SUCCEED; + } - qDestroySubplan(plan); + qwQueryPostProcess(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, status, code); + } - return code; + QW_RET(code); } -int32_t qWorkerProcessReadyMsg(void *qWorkerMgmt, SSchedulerReadyMsg *msg, SRpcMsg *rsp){ - if (NULL == qWorkerMgmt || NULL == msg || NULL == rsp) { +int32_t qWorkerProcessReadyMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg){ + if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) { return TSDB_CODE_QRY_INVALID_INPUT; } - SQWorkerTaskStatus *tStatus = NULL; - - QW_ERR_RET(qwGetTaskStatus(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, &tStatus)); - - if (QW_TASK_DONE(tStatus->status)) { - QW_ERR_RET(qwBuildRspMsg(tStatus, TSDB_MSG_TYPE_RES_READY_RSP)); - } else { - tStatus->ready = QW_READY_RECEIVED; - - return TSDB_CODE_SUCCESS; - } + SResReadyMsg *msg = pMsg->pCont; + if (NULL == msg || pMsg->contLen <= sizeof(*msg)) { + qError("invalid task status msg"); + QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT); + } - tStatus->ready = QW_READY_RESPONSED; + QW_ERR_RET(qwSetAndSendReadyRsp(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, pMsg)); return TSDB_CODE_SUCCESS; } -int32_t qWorkerProcessStatusMsg(void *qWorkerMgmt, SSchedulerStatusMsg *msg, SRpcMsg *rsp) { - if (NULL == qWorkerMgmt || NULL == msg || NULL == rsp) { +int32_t qWorkerProcessStatusMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) { + if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) { return TSDB_CODE_QRY_INVALID_INPUT; } + int32_t code = 0; + SSchTasksStatusMsg *msg = pMsg->pCont; + if (NULL == msg || pMsg->contLen <= sizeof(*msg)) { + qError("invalid task status msg"); + QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT); + } + SSchedulerStatusRsp *sStatus = NULL; - QW_ERR_RET(qwGetSchTasksStatus(qWorkerMgmt, msg->schedulerId, &sStatus)); + QW_ERR_JRET(qwGetSchTasksStatus(qWorkerMgmt, msg->schedulerId, &sStatus)); + +_return: + + QW_ERR_RET(qwBuildAndSendStatusRsp(pMsg, sStatus)); return TSDB_CODE_SUCCESS; } -int32_t qWorkerProcessFetchMsg(void *qWorkerMgmt, SSchedulerFetchMsg *msg, SRpcMsg *rsp) { - if (NULL == qWorkerMgmt || NULL == msg || NULL == rsp) { +int32_t qWorkerProcessFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) { + if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) { return TSDB_CODE_QRY_INVALID_INPUT; } + SResFetchMsg *msg = pMsg->pCont; + if (NULL == msg || pMsg->contLen <= sizeof(*msg)) { + QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT); + } + QW_ERR_RET(qwUpdateSchLastAccess(qWorkerMgmt, msg->schedulerId)); void *data = NULL; + SQWorkerResCache *res = NULL; + int32_t code = 0; - QW_ERR_RET(qwGetTaskResult(qWorkerMgmt, msg->queryId, msg->taskId, &data)); + QW_ERR_RET(qwAcquireTaskResCache(QW_READ, qWorkerMgmt, msg->queryId, msg->taskId, &res)); + + QW_ERR_JRET(qwHandleFetch(res, qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId, pMsg)); + +_return: + + qwReleaseTaskResCache(QW_READ, qWorkerMgmt); + + QW_RET(code); +} + +int32_t qWorkerProcessCancelMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) { + if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) { + return TSDB_CODE_QRY_INVALID_INPUT; + } + + int32_t code = 0; + STaskCancelMsg *msg = pMsg->pCont; + if (NULL == msg || pMsg->contLen <= sizeof(*msg)) { + qError("invalid task cancel msg"); + QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT); + } + + QW_ERR_JRET(qwCancelTask(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId)); + +_return: + + QW_ERR_RET(qwBuildAndSendCancelRsp(pMsg, code)); + + return TSDB_CODE_SUCCESS; +} + +int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) { + if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) { + return TSDB_CODE_QRY_INVALID_INPUT; + } + + int32_t code = 0; + STaskDropMsg *msg = pMsg->pCont; + if (NULL == msg || pMsg->contLen <= sizeof(*msg)) { + qError("invalid task drop msg"); + QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT); + } + + QW_ERR_JRET(qwCancelDropTask(qWorkerMgmt, msg->schedulerId, msg->queryId, msg->taskId)); + +_return: - QW_ERR_RET(qwBuildRspMsg(data, TSDB_MSG_TYPE_FETCH_RSP)); + QW_ERR_RET(qwBuildAndSendDropRsp(pMsg, code)); return TSDB_CODE_SUCCESS; } -int32_t qWorkerProcessCancelMsg(void *qWorkerMgmt, SSchedulerCancelMsg *msg, SRpcMsg *rsp); void qWorkerDestroy(void **qWorkerMgmt) { if (NULL == qWorkerMgmt || NULL == *qWorkerMgmt) { diff --git a/source/libs/scheduler/inc/schedulerInt.h b/source/libs/scheduler/inc/schedulerInt.h index 3fab91edacd77096fbacceee5df3f762452ad16d..bc7bc44350245814cfb960ceee38720822cbdef3 100644 --- a/source/libs/scheduler/inc/schedulerInt.h +++ b/source/libs/scheduler/inc/schedulerInt.h @@ -31,17 +31,35 @@ extern "C" { #define SCH_MAX_CONDIDATE_EP_NUM TSDB_MAX_REPLICA +enum { + SCH_READ = 1, + SCH_WRITE, +}; + typedef struct SSchedulerMgmt { uint64_t taskId; uint64_t schedulerId; SSchedulerCfg cfg; - SHashObj *Jobs; // key: queryId, value: SQueryJob* + SHashObj *jobs; // key: queryId, value: SQueryJob* } SSchedulerMgmt; +typedef struct SQueryLevel { + int32_t level; + int8_t status; + SRWLatch lock; + int32_t taskFailed; + int32_t taskSucceed; + int32_t taskNum; + SArray *subTasks; // Element is SQueryTask +} SQueryLevel; + + typedef struct SQueryTask { uint64_t taskId; // task id + SQueryLevel *level; // level SSubplan *plan; // subplan char *msg; // operator tree + int32_t msgLen; // msg length int8_t status; // task status SEpAddr execAddr; // task actual executed node address SQueryProfileSummary summary; // task execution summary @@ -50,21 +68,14 @@ typedef struct SQueryTask { SArray *parents; // the data destination tasks, get data from current task, element is SQueryTask* } SQueryTask; -typedef struct SQueryLevel { - int32_t level; - int8_t status; - int32_t taskNum; - SArray *subTasks; // Element is SQueryTask -} SQueryLevel; - typedef struct SQueryJob { uint64_t queryId; int32_t levelNum; int32_t levelIdx; int8_t status; SQueryProfileSummary summary; - SEpSet dataSrcEps; - SEpAddr resEp; + SEpSet dataSrcEps; + SEpAddr resEp; void *transport; SArray *qnodeList; tsem_t rspSem; @@ -74,6 +85,7 @@ typedef struct SQueryJob { SHashObj *execTasks; // executing tasks, key:taskid, value:SQueryTask* SHashObj *succTasks; // succeed tasks, key:taskid, value:SQueryTask* + SHashObj *failTasks; // failed tasks, key:taskid, value:SQueryTask* SArray *levels; // Element is SQueryLevel, starting from 0. SArray *subPlans; // Element is SArray*, and nested element is SSubplan. The execution level of subplan, starting from 0. @@ -81,7 +93,8 @@ typedef struct SQueryJob { #define SCH_HAS_QNODE_IN_CLUSTER(type) (false) //TODO CLUSTER TYPE #define SCH_TASK_READY_TO_LUNCH(task) ((task)->childReady >= taosArrayGetSize((task)->children)) // MAY NEED TO ENHANCE -#define SCH_IS_DATA_SRC_TASK(task) (task->plan->type == QUERY_TYPE_SCAN) +#define SCH_IS_DATA_SRC_TASK(task) ((task)->plan->type == QUERY_TYPE_SCAN) +#define SCH_TASK_NEED_WAIT_ALL(task) ((task)->plan->type == QUERY_TYPE_MODIFY) #define SCH_JOB_ERR_LOG(param, ...) qError("QID:%"PRIx64 param, job->queryId, __VA_ARGS__) #define SCH_TASK_ERR_LOG(param, ...) qError("QID:%"PRIx64",TID:%"PRIx64 param, job->queryId, task->taskId, __VA_ARGS__) @@ -91,6 +104,9 @@ typedef struct SQueryJob { #define SCH_ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { qError(__VA_ARGS__); terrno = _code; return _code; } } while (0) #define SCH_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0) +#define SCH_LOCK(type, _lock) (SCH_READ == (type) ? taosRLockLatch(_lock) : taosWLockLatch(_lock)) +#define SCH_UNLOCK(type, _lock) (SCH_READ == (type) ? taosRUnLockLatch(_lock) : taosWUnLockLatch(_lock)) + extern int32_t schLaunchTask(SQueryJob *job, SQueryTask *task); diff --git a/source/libs/scheduler/src/scheduler.c b/source/libs/scheduler/src/scheduler.c index 99a9b06fe441832d42fbc5bc86ad24bcc3ebc263..4185b3176c7f531f8ac3664b3aba4550d2874681 100644 --- a/source/libs/scheduler/src/scheduler.c +++ b/source/libs/scheduler/src/scheduler.c @@ -160,11 +160,19 @@ int32_t schValidateAndBuildJob(SQueryDag *dag, SQueryJob *job) { SQueryLevel level = {0}; SArray *levelPlans = NULL; int32_t levelPlanNum = 0; + SQueryLevel *pLevel = NULL; level.status = JOB_TASK_STATUS_NOT_START; for (int32_t i = 0; i < levelNum; ++i) { - level.level = i; + if (NULL == taosArrayPush(job->levels, &level)) { + qError("taosArrayPush failed"); + SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY); + } + + pLevel = taosArrayGet(job->levels, i); + + pLevel->level = i; levelPlans = taosArrayGetP(dag->pSubplans, i); if (NULL == levelPlans) { qError("no level plans for level %d", i); @@ -177,10 +185,10 @@ int32_t schValidateAndBuildJob(SQueryDag *dag, SQueryJob *job) { SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT); } - level.taskNum = levelPlanNum; + pLevel->taskNum = levelPlanNum; - level.subTasks = taosArrayInit(levelPlanNum, sizeof(SQueryTask)); - if (NULL == level.subTasks) { + pLevel->subTasks = taosArrayInit(levelPlanNum, sizeof(SQueryTask)); + if (NULL == pLevel->subTasks) { qError("taosArrayInit %d failed", levelPlanNum); SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY); } @@ -191,9 +199,10 @@ int32_t schValidateAndBuildJob(SQueryDag *dag, SQueryJob *job) { task.taskId = atomic_add_fetch_64(&schMgmt.taskId, 1); task.plan = plan; + task.level = pLevel; task.status = JOB_TASK_STATUS_NOT_START; - void *p = taosArrayPush(level.subTasks, &task); + void *p = taosArrayPush(pLevel->subTasks, &task); if (NULL == p) { qError("taosArrayPush failed"); SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY); @@ -205,10 +214,6 @@ int32_t schValidateAndBuildJob(SQueryDag *dag, SQueryJob *job) { } } - if (NULL == taosArrayPush(job->levels, &level)) { - qError("taosArrayPush failed"); - SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY); - } } SCH_ERR_JRET(schBuildTaskRalation(job, planToTask)); @@ -220,8 +225,8 @@ int32_t schValidateAndBuildJob(SQueryDag *dag, SQueryJob *job) { return TSDB_CODE_SUCCESS; _return: - if (level.subTasks) { - taosArrayDestroy(level.subTasks); + if (pLevel->subTasks) { + taosArrayDestroy(pLevel->subTasks); } if (planToTask) { @@ -273,7 +278,23 @@ int32_t schMoveTaskToSuccList(SQueryJob *job, SQueryTask *task, bool *moved) { return TSDB_CODE_SUCCESS; } - if (0 != taosHashPut(job->execTasks, &task->taskId, sizeof(task->taskId), &task, POINTER_BYTES)) { + if (0 != taosHashPut(job->succTasks, &task->taskId, sizeof(task->taskId), &task, POINTER_BYTES)) { + qError("taosHashPut failed"); + SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY); + } + + *moved = true; + + return TSDB_CODE_SUCCESS; +} + +int32_t schMoveTaskToFailList(SQueryJob *job, SQueryTask *task, bool *moved) { + if (0 != taosHashRemove(job->execTasks, &task->taskId, sizeof(task->taskId))) { + qWarn("remove task[%"PRIx64"] from execTasks failed", task->taskId); + return TSDB_CODE_SUCCESS; + } + + if (0 != taosHashPut(job->failTasks, &task->taskId, sizeof(task->taskId), &task, POINTER_BYTES)) { qError("taosHashPut failed"); SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY); } @@ -289,51 +310,76 @@ int32_t schAsyncSendMsg(SQueryJob *job, SQueryTask *task, int32_t msgType) { void *msg = NULL; switch (msgType) { + case TSDB_MSG_TYPE_SUBMIT: { + if (NULL == task->msg || task->msgLen <= 0) { + qError("submit msg is NULL"); + SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR); + } + + msgSize = task->msgLen; + msg = task->msg; + break; + } case TSDB_MSG_TYPE_QUERY: { if (NULL == task->msg) { qError("query msg is NULL"); SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR); } - int32_t len = strlen(task->msg); - msgSize = sizeof(SSchedulerQueryMsg) + len; + msgSize = sizeof(SSubQueryMsg) + task->msgLen; msg = calloc(1, msgSize); if (NULL == msg) { qError("calloc %d failed", msgSize); SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY); } - SSchedulerQueryMsg *pMsg = msg; + SSubQueryMsg *pMsg = msg; pMsg->schedulerId = htobe64(schMgmt.schedulerId); pMsg->queryId = htobe64(job->queryId); pMsg->taskId = htobe64(task->taskId); - pMsg->contentLen = htonl(len); - memcpy(pMsg->msg, task->msg, len); + pMsg->contentLen = htonl(task->msgLen); + memcpy(pMsg->msg, task->msg, task->msgLen); break; - } + } case TSDB_MSG_TYPE_RES_READY: { - msgSize = sizeof(SSchedulerReadyMsg); + msgSize = sizeof(SResReadyMsg); msg = calloc(1, msgSize); if (NULL == msg) { qError("calloc %d failed", msgSize); SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY); } - SSchedulerReadyMsg *pMsg = msg; + SResReadyMsg *pMsg = msg; + pMsg->schedulerId = htobe64(schMgmt.schedulerId); pMsg->queryId = htobe64(job->queryId); pMsg->taskId = htobe64(task->taskId); break; } case TSDB_MSG_TYPE_FETCH: { - msgSize = sizeof(SSchedulerFetchMsg); + msgSize = sizeof(SResFetchMsg); + msg = calloc(1, msgSize); + if (NULL == msg) { + qError("calloc %d failed", msgSize); + SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY); + } + + SResFetchMsg *pMsg = msg; + pMsg->schedulerId = htobe64(schMgmt.schedulerId); + pMsg->queryId = htobe64(job->queryId); + pMsg->taskId = htobe64(task->taskId); + break; + } + case TSDB_MSG_TYPE_DROP_TASK:{ + msgSize = sizeof(STaskDropMsg); msg = calloc(1, msgSize); if (NULL == msg) { qError("calloc %d failed", msgSize); SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY); } - SSchedulerFetchMsg *pMsg = msg; + STaskDropMsg *pMsg = msg; + pMsg->schedulerId = htobe64(schMgmt.schedulerId); pMsg->queryId = htobe64(job->queryId); pMsg->taskId = htobe64(task->taskId); break; @@ -344,6 +390,7 @@ int32_t schAsyncSendMsg(SQueryJob *job, SQueryTask *task, int32_t msgType) { } //TODO SEND MSG + //taosAsyncExec(rpcSendRequest(void * shandle, const SEpSet * pEpSet, SRpcMsg * pMsg, int64_t * pRid), p, &code); return TSDB_CODE_SUCCESS; } @@ -424,8 +471,29 @@ int32_t schProcessOnTaskSuccess(SQueryJob *job, SQueryTask *task) { SCH_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT); } - strncpy(job->resEp.fqdn, task->execAddr.fqdn, sizeof(job->resEp.fqdn)); - job->resEp.port = task->execAddr.port; + int32_t taskDone = 0; + + if (SCH_TASK_NEED_WAIT_ALL(task)) { + SCH_LOCK(SCH_WRITE, &task->level->lock); + task->level->taskFailed++; + taskDone = task->level->taskSucceed + task->level->taskFailed; + SCH_UNLOCK(SCH_WRITE, &task->level->lock); + + if (taskDone < task->level->taskNum) { + qDebug("wait all tasks, done:%d, all:%d", taskDone, task->level->taskNum); + return TSDB_CODE_SUCCESS; + } + + if (task->level->taskFailed > 0) { + job->status = JOB_TASK_STATUS_FAILED; + SCH_ERR_RET(schProcessOnJobFailure(job)); + + return TSDB_CODE_SUCCESS; + } + } else { + strncpy(job->resEp.fqdn, task->execAddr.fqdn, sizeof(job->resEp.fqdn)); + job->resEp.port = task->execAddr.port; + } SCH_ERR_RET(schProcessOnJobSuccess(job)); @@ -456,10 +524,30 @@ int32_t schProcessOnTaskSuccess(SQueryJob *job, SQueryTask *task) { int32_t schProcessOnTaskFailure(SQueryJob *job, SQueryTask *task, int32_t errCode) { bool needRetry = false; + bool moved = false; + int32_t taskDone = 0; SCH_ERR_RET(schTaskCheckAndSetRetry(job, task, errCode, &needRetry)); if (!needRetry) { SCH_TASK_ERR_LOG("task failed[%x], no more retry", errCode); + + SCH_ERR_RET(schMoveTaskToFailList(job, task, &moved)); + if (!moved) { + SCH_TASK_ERR_LOG("task may already moved, status:%d", task->status); + return TSDB_CODE_SUCCESS; + } + + if (SCH_TASK_NEED_WAIT_ALL(task)) { + SCH_LOCK(SCH_WRITE, &task->level->lock); + task->level->taskFailed++; + taskDone = task->level->taskSucceed + task->level->taskFailed; + SCH_UNLOCK(SCH_WRITE, &task->level->lock); + + if (taskDone < task->level->taskNum) { + qDebug("wait all tasks, done:%d, all:%d", taskDone, task->level->taskNum); + return TSDB_CODE_SUCCESS; + } + } job->status = JOB_TASK_STATUS_FAILED; SCH_ERR_RET(schProcessOnJobFailure(job)); @@ -521,8 +609,7 @@ _return: int32_t schLaunchTask(SQueryJob *job, SQueryTask *task) { SSubplan *plan = task->plan; - - SCH_ERR_RET(qSubPlanToString(plan, &task->msg)); + SCH_ERR_RET(qSubPlanToString(plan, &task->msg, &task->msgLen)); if (plan->execEpSet.numOfEps <= 0) { SCH_ERR_RET(schSetTaskExecEpSet(job, &plan->execEpSet)); } @@ -531,8 +618,10 @@ int32_t schLaunchTask(SQueryJob *job, SQueryTask *task) { SCH_TASK_ERR_LOG("invalid execEpSet num:%d", plan->execEpSet.numOfEps); SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR); } + + int32_t msgType = (plan->type == QUERY_TYPE_MODIFY) ? TSDB_MSG_TYPE_SUBMIT : TSDB_MSG_TYPE_QUERY; - SCH_ERR_RET(schAsyncSendMsg(job, task, TSDB_MSG_TYPE_QUERY)); + SCH_ERR_RET(schAsyncSendMsg(job, task, msgType)); SCH_ERR_RET(schPushTaskToExecList(job, task)); @@ -553,6 +642,25 @@ int32_t schLaunchJob(SQueryJob *job) { return TSDB_CODE_SUCCESS; } +void schDropJobAllTasks(SQueryJob *job) { + void *pIter = taosHashIterate(job->succTasks, NULL); + while (pIter) { + SQueryTask *task = *(SQueryTask **)pIter; + + schAsyncSendMsg(job, task, TSDB_MSG_TYPE_DROP_TASK); + + pIter = taosHashIterate(job->succTasks, pIter); + } + + pIter = taosHashIterate(job->failTasks, NULL); + while (pIter) { + SQueryTask *task = *(SQueryTask **)pIter; + + schAsyncSendMsg(job, task, TSDB_MSG_TYPE_DROP_TASK); + + pIter = taosHashIterate(job->succTasks, pIter); + } +} int32_t schedulerInit(SSchedulerCfg *cfg) { if (cfg) { @@ -561,8 +669,8 @@ int32_t schedulerInit(SSchedulerCfg *cfg) { schMgmt.cfg.maxJobNum = SCHEDULE_DEFAULT_JOB_NUMBER; } - schMgmt.Jobs = taosHashInit(schMgmt.cfg.maxJobNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK); - if (NULL == schMgmt.Jobs) { + schMgmt.jobs = taosHashInit(schMgmt.cfg.maxJobNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK); + if (NULL == schMgmt.jobs) { SCH_ERR_LRET(TSDB_CODE_QRY_OUT_OF_MEMORY, "init %d schduler jobs failed", schMgmt.cfg.maxJobNum); } @@ -604,9 +712,15 @@ int32_t scheduleExecJob(void *transport, SArray *qnodeList, SQueryDag* pDag, voi SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY); } + job->failTasks = taosHashInit(pDag->numOfSubplans, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK); + if (NULL == job->failTasks) { + qError("taosHashInit %d failed", pDag->numOfSubplans); + SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY); + } + tsem_init(&job->rspSem, 0, 0); - if (0 != taosHashPut(schMgmt.Jobs, &job->queryId, sizeof(job->queryId), &job, POINTER_BYTES)) { + if (0 != taosHashPut(schMgmt.jobs, &job->queryId, sizeof(job->queryId), &job, POINTER_BYTES)) { qError("taosHashPut queryId:%"PRIx64" failed", job->queryId); SCH_ERR_JRET(TSDB_CODE_SCH_INTERNAL_ERROR); } @@ -658,6 +772,8 @@ _return: int32_t scheduleCancelJob(void *pJob) { //TODO + //TODO MOVE ALL TASKS FROM EXEC LIST TO FAIL LIST + return TSDB_CODE_SUCCESS; } @@ -669,7 +785,7 @@ void scheduleFreeJob(void *pJob) { SQueryJob *job = pJob; if (job->status > 0) { - if (0 != taosHashRemove(schMgmt.Jobs, &job->queryId, sizeof(job->queryId))) { + if (0 != taosHashRemove(schMgmt.jobs, &job->queryId, sizeof(job->queryId))) { qError("remove job:%"PRIx64"from mgmt failed", job->queryId); // maybe already freed return; } @@ -677,15 +793,17 @@ void scheduleFreeJob(void *pJob) { if (job->status == JOB_TASK_STATUS_EXECUTING) { scheduleCancelJob(pJob); } + + schDropJobAllTasks(job); } //TODO free job } void schedulerDestroy(void) { - if (schMgmt.Jobs) { - taosHashCleanup(schMgmt.Jobs); //TODO - schMgmt.Jobs = NULL; + if (schMgmt.jobs) { + taosHashCleanup(schMgmt.jobs); //TODO + schMgmt.jobs = NULL; } } diff --git a/source/util/src/terror.c b/source/util/src/terror.c index 43ac7606432b6380fbac9b683ef8737e1903c8f3..65057501b9e7c592a81459732be2d0703d7604bf 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -323,7 +323,10 @@ TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INCONSISTAN, "File inconsistance in TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_TIME_CONDITION, "One valid time range condition expected") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_SYS_ERROR, "System error") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_INPUT, "invalid input") - +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_SCH_NOT_EXIST, "Scheduler not exist") +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_NOT_EXIST, "Task not exist") +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_ALREADY_EXIST, "Task already exist") +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_RES_CACHE_NOT_EXIST, "Task result cache not exist") // grant TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_EXPIRED, "License expired") diff --git a/source/util/src/thash.c b/source/util/src/thash.c index c4f6f78106e1ee6703e0429e705f62ab83db1881..cfe14f00e14d2f00f09ffbf276c81c9eca14bfe6 100644 --- a/source/util/src/thash.c +++ b/source/util/src/thash.c @@ -291,7 +291,7 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *da // enable resize __rd_unlock(&pHashObj->lock, pHashObj->type); - return pHashObj->enableUpdate ? 0 : -1; + return pHashObj->enableUpdate ? 0 : -2; } } diff --git a/source/util/src/tworker.c b/source/util/src/tworker.c index 11972e84cba613ed6dd757d91c6083eb6c0b520d..fb7b71b845e5f5a5584f651e14b20d67fa3d6eb4 100644 --- a/source/util/src/tworker.c +++ b/source/util/src/tworker.c @@ -38,6 +38,7 @@ int32_t tWorkerInit(SWorkerPool *pool) { void tWorkerCleanup(SWorkerPool *pool) { for (int i = 0; i < pool->max; ++i) { SWorker *worker = pool->workers + i; + if (worker == NULL) continue; if (taosCheckPthreadValid(worker->thread)) { taosQsetThreadResume(pool->qset); } @@ -45,6 +46,7 @@ void tWorkerCleanup(SWorkerPool *pool) { for (int i = 0; i < pool->max; ++i) { SWorker *worker = pool->workers + i; + if (worker == NULL) continue; if (taosCheckPthreadValid(worker->thread)) { pthread_join(worker->thread, NULL); } diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y index 800ee034414e2d282bd1aa506b4e440a48f4a6d1..50806fdfd6e9198b318e3a8a4aa3fcd928b527c1 100644 --- a/src/query/inc/sql.y +++ b/src/query/inc/sql.y @@ -32,6 +32,7 @@ #include "ttokendef.h" #include "tutil.h" #include "tvariant.h" +#include "parserInt.h" } %syntax_error { @@ -302,8 +303,8 @@ db_optr(Y) ::= db_optr(Z) cachelast(X). { Y = Z; Y.cachelast = strtol(X.z, %type topic_optr {SCreateDbInfo} -topic_optr(Y) ::= db_optr(Z). { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; } -topic_optr(Y) ::= topic_optr(Z) partitions(X). { Y = Z; Y.partitions = strtol(X.z, NULL, 10); } +//topic_optr(Y) ::= db_optr(Z). { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; } +//topic_optr(Y) ::= topic_optr(Z) partitions(X). { Y = Z; Y.partitions = strtol(X.z, NULL, 10); } %type alter_db_optr {SCreateDbInfo} alter_db_optr(Y) ::= . { setDefaultCreateDbOption(&Y); Y.dbType = TSDB_DB_TYPE_DEFAULT;} @@ -325,7 +326,7 @@ alter_db_optr(Y) ::= alter_db_optr(Z) cachelast(X). { Y = Z; Y.cachelast = str alter_topic_optr(Y) ::= alter_db_optr(Z). { Y = Z; Y.dbType = TSDB_DB_TYPE_TOPIC; } alter_topic_optr(Y) ::= alter_topic_optr(Z) partitions(X). { Y = Z; Y.partitions = strtol(X.z, NULL, 10); } -%type typename {TAOS_FIELD} +%type typename {SField} typename(A) ::= ids(X). { X.type = 0; tSetColumnType (&A, &X); @@ -425,11 +426,11 @@ create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) AS select(S). { setCreatedTableName(pInfo, &V, &U); } -%type column{TAOS_FIELD} +%type column{SField} %type columnlist{SArray*} %destructor columnlist {taosArrayDestroy($$);} columnlist(A) ::= columnlist(X) COMMA column(Y). {taosArrayPush(X, &Y); A = X; } -columnlist(A) ::= column(X). {A = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(A, &X);} +columnlist(A) ::= column(X). {A = taosArrayInit(4, sizeof(SField)); taosArrayPush(A, &X);} // The information used for a column is the name and type of column: // tinyint smallint int bigint float double bool timestamp binary(x) nchar(x) diff --git a/tests/script/general/db/basic1.sim b/tests/script/general/db/basic1.sim index 9ec1aabe98ba21af5927faec2e26aef1c3a14aeb..dc62c33842ef9a1a1af4bff341867c77dbc7ed6c 100644 --- a/tests/script/general/db/basic1.sim +++ b/tests/script/general/db/basic1.sim @@ -15,7 +15,7 @@ if $data00 != d1 then return -1 endi -if $data02 != 0 then +if $data02 != 2 then return -1 endi @@ -51,7 +51,7 @@ if $data00 != d4 then return -1 endi -if $data02 != 0 then +if $data02 != 2 then return -1 endi diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt index 2408faefa0418b83ab7e1fb715e81ee4fa6a4caf..1cc15f731d343d63b7894e7e5c43b66364cf169f 100644 --- a/tests/script/jenkins/basic.txt +++ b/tests/script/jenkins/basic.txt @@ -1,7 +1,11 @@ #======================b1-start=============== +# ---- user ./test.sh -f general/user/basic1.sim +# ---- db +./test.sh -f general/db/basic1.sim + #======================b1-end===============