TD-12450 perfect parser interface

include/common/taosmsg.h

@@ -308,17 +308,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];
@@ -326,7 +334,7 @@ typedef struct {
   int32_t numOfTags;
   int32_t numOfColumns;
   SSchema pSchema[];
-} SCreateStbMsg;
+} SCreateStbMsg, SCreateTableMsg;
 
 typedef struct {
   char   name[TSDB_TABLE_FNAME_LEN];
@@ -369,6 +377,7 @@ typedef struct {
 typedef struct {
   SMsgHead head;
   char     name[TSDB_TABLE_FNAME_LEN];
+  int8_t   ignoreNotExists;
 } SDropTableMsg;
 
 typedef struct {

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);
 
 
 /**

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 {

include/libs/qcom/query.h

@@ -107,7 +107,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);

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);

source/client/src/clientEnv.c

@@ -13,11 +13,12 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "os.h"
-#include "taosmsg.h"
-#include "query.h"
+#include <catalog.h>
 #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);

source/client/src/clientImpl.c

@@ -158,11 +158,45 @@ TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) {
     pRequest->type = pDcl->nodeType;
     pRequest->body.requestMsg = (SReqMsgInfo){.pMsg = pDcl->pMsg, .len = pDcl->msgLen};
 
-    SRequestMsgBody body = {0};
-    buildRequestMsgFp[pDcl->nodeType](pRequest, &body);
+    SRequestMsgBody body = buildRequestMsgImpl(pRequest);
+    SEpSet* pEpSet = &pTscObj->pAppInfo->mgmtEp.epSet;
+
+    if (pDcl->nodeType == 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;
+      }
 
-    int64_t transporterId = 0;
-    sendMsgToServer(pTscObj->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &body, &transporterId);
+      SCreateTableMsg* pMsg = body.msgInfo.pMsg;
+
+      SName t = {0};
+      tNameFromString(&t, pMsg->name, T_NAME_ACCT|T_NAME_DB|T_NAME_TABLE);
+
+      char db[TSDB_DB_NAME_LEN + TS_PATH_DELIMITER_LEN + TSDB_ACCT_ID_LEN] = {0};
+      tNameGetFullDbName(&t, db);
+
+      SVgroupInfo info = {0};
+      catalogGetTableHashVgroup(pCatalog, pTscObj->pTransporter, pEpSet, db, tNameGetTableName(&t), &info);
+
+      int64_t transporterId = 0;
+      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]));
+      }
+
+      sendMsgToServer(pTscObj->pTransporter, &ep, &body, &transporterId);
+    } else {
+      int64_t transporterId = 0;
+      sendMsgToServer(pTscObj->pTransporter, pEpSet, &body, &transporterId);
+    }
 
     tsem_wait(&pRequest->body.rspSem);
     destroyRequestMsgBody(&body);
@@ -215,13 +249,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;
@@ -263,16 +297,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);
@@ -390,10 +419,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;

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

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,92 +47,208 @@ 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) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+// TEST(testCase, connect_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+////  assert(pConn != NULL);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, create_user_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
-  taos_close(pConn);
-}
-
-TEST(testCase, create_user_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "create user abc pass 'abc'");
+//  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+//    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, create_account_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "create account aabc pass 'abc'");
+//  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+//    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, drop_account_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+//  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "drop account aabc");
+//  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+//    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, show_user_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+////  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "show users");
+//  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);
+//  }
+//
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, drop_user_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+//  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "drop user abc");
+//  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+//    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
+//
+// TEST(testCase, show_db_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+////  assert(pConn != NULL);
+//
+//  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);
+//  }
+//
+//  taos_close(pConn);
+//}
 
-  TAOS_RES* pRes = taos_query(pConn, "create user abc pass 'abc'");
-  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
-    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
-  }
-
-  taos_free_result(pRes);
-  taos_close(pConn);
-}
-
-TEST(testCase, create_account_Test) {
+TEST(testCase, create_db_Test) {
   TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
   assert(pConn != NULL);
 
-  TAOS_RES* pRes = taos_query(pConn, "create account aabc pass 'abc'");
-  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
-    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+  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);
-  taos_close(pConn);
-}
-
-TEST(testCase, drop_account_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  ASSERT_TRUE(pFields == NULL);
 
-  TAOS_RES* pRes = taos_query(pConn, "drop account aabc");
-  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
-    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
-  }
+  int32_t numOfFields = taos_num_fields(pRes);
+  ASSERT_EQ(numOfFields, 0);
 
-  taos_free_result(pRes);
   taos_close(pConn);
 }
 
-TEST(testCase, show_user_Test) {
+TEST(testCase, use_db_test) {
   TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
-//  assert(pConn != NULL);
+  assert(pConn != NULL);
 
-  TAOS_RES* pRes = taos_query(pConn, "show users");
-  TAOS_ROW pRow = 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);
-  int32_t numOfFields = taos_num_fields(pRes);
+  ASSERT_TRUE(pFields == NULL);
 
-  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);
-  }
+  int32_t numOfFields = taos_num_fields(pRes);
+  ASSERT_EQ(numOfFields, 0);
 
   taos_close(pConn);
 }
 
-TEST(testCase, drop_user_Test) {
+TEST(testCase, drop_db_test) {
   TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
   assert(pConn != NULL);
 
-  TAOS_RES* pRes = taos_query(pConn, "drop user abc");
-  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
-    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+  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);
+
+  showDB(pConn);
   taos_close(pConn);
 }
 
-TEST(testCase, show_db_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+// 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);
+}
 
-  TAOS_RES* pRes = taos_query(pConn, "show databases");
+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);
@@ -131,53 +260,45 @@ TEST(testCase, show_db_Test) {
     printf("%s\n", str);
   }
 
-  taos_close(pConn);
-}
-
-TEST(testCase, create_db_Test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "create database abc1");
-
-  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  ASSERT_TRUE(pFields == NULL);
-
-  int32_t numOfFields = taos_num_fields(pRes);
-  ASSERT_EQ(numOfFields, 0);
-
-  taos_close(pConn);
-}
-
-TEST(testCase, use_db_test) {
-  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "use abc1");
-
-  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_stable_Test) {
+TEST(testCase, drop_stable_Test) {
   TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
   assert(pConn != NULL);
 
-  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  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, "create stable st1(ts timestamp, k int) tags(a int)");
-
-  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  ASSERT_TRUE(pFields == NULL);
+  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);
 
-  int32_t numOfFields = taos_num_fields(pRes);
-  ASSERT_EQ(numOfFields, 0);
+  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);
+//}

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

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);

source/libs/catalog/test/catalogTests.cpp

@@ -99,7 +99,7 @@ TEST(testCase, normalCase) {
   void *mockPointer = (void *)0x1;
   SVgroupInfo vgInfo = {0};
 
-  msgInit();
+  initQueryModuleMsgHandle();
 
   sendCreateDbMsg(pConn->pTransporter, &pConn->pAppInfo->mgmtEp.epSet);
   

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

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). { 

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

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;
+}
+

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);
   }
@@ -4314,8 +4312,6 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
   SMsgBuf m = {.buf = msgBuf, .len = msgBufLen};
   SMsgBuf *pMsgBuf = &m;
 
-  pDcl->nodeType = pInfo->type;
-
   switch (pInfo->type) {
     case TSDB_SQL_CREATE_USER:
     case TSDB_SQL_ALTER_USER: {
@@ -4362,6 +4358,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       }
 
       pDcl->pMsg = (char*)buildUserManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
+      pDcl->nodeType = (pInfo->type == TSDB_SQL_CREATE_USER)? TSDB_MSG_TYPE_CREATE_USER:TSDB_MSG_TYPE_ALTER_USER;
       break;
     }
 
@@ -4398,17 +4395,20 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       }
 
       pDcl->pMsg = (char*)buildAcctManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
+      pDcl->nodeType = (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: {
       pDcl->pMsg = (char*)buildDropUserMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
+      pDcl->nodeType = (pInfo->type == TSDB_SQL_DROP_ACCT)? TSDB_MSG_TYPE_DROP_ACCT:TSDB_MSG_TYPE_DROP_USER;
       break;
     }
     
     case TSDB_SQL_SHOW: {
-      code = setShowInfo(pInfo, (void**)&pDcl->pMsg, &pDcl->msgLen, pMsgBuf);
+      code = setShowInfo(&pInfo->pMiscInfo->showOpt, pCtx, (void**)&pDcl->pMsg, &pDcl->msgLen, pMsgBuf);
+      pDcl->nodeType = TSDB_MSG_TYPE_SHOW;
       break;
     }
 
@@ -4431,6 +4431,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
 
       pDcl->pMsg = (char*)pUseDbMsg;
       pDcl->msgLen = sizeof(SUseDbMsg);
+      pDcl->nodeType = TSDB_MSG_TYPE_USE_DB;
       break;
     }
 
@@ -4451,7 +4452,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
         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;
       }
@@ -4460,9 +4461,34 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
 
       pDcl->pMsg = (char*)pCreateMsg;
       pDcl->msgLen = sizeof(SCreateDbMsg);
+      pDcl->nodeType = (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->nodeType = 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;
 
@@ -4471,6 +4497,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
           return code;
         }
         pDcl->pMsg = (char*)buildCreateTableMsg(pCreateTable, &pDcl->msgLen, pCtx, pMsgBuf);
+        pDcl->nodeType = (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 +4510,18 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
 
       break;
     }
+
+    case TSDB_SQL_DROP_TABLE: {
+      pDcl->pMsg = (char*)buildDropTableMsg(pInfo, &pDcl->msgLen, pCtx, pMsgBuf);
+      if (pDcl->pMsg == NULL) {
+        return terrno;
+      }
+
+      pDcl->nodeType = TSDB_MSG_TYPE_DROP_STB;
+      return TSDB_CODE_SUCCESS;
+      break;
+    }
+
     default:
       break;
   }

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},

source/libs/planner/src/physicalPlanJson.c

@@ -845,7 +845,7 @@ int32_t subPlanToString(const SSubplan* subplan, char** str, int32_t* len) {
     return TSDB_CODE_FAILED;
   }
   *str = cJSON_Print(json);
-  *len = strlen(*str);
+  *len = strlen(*str) + 1;
   return TSDB_CODE_SUCCESS;
 }
 

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)