feat: sql command 'show create database', 'show create table', 'show create...

feat: sql command 'show create database', 'show create table', 'show create stable' and 'alter local'

include/common/ttokendef.h

@@ -64,196 +64,195 @@
 #define TK_PORT          46
 #define TK_NK_INTEGER    47
 #define TK_DNODES        48
-#define TK_NK_IPTOKEN    49
-#define TK_LOCAL         50
-#define TK_QNODE         51
-#define TK_BNODE         52
-#define TK_SNODE         53
-#define TK_MNODE         54
-#define TK_DATABASE      55
-#define TK_USE           56
-#define TK_IF            57
-#define TK_NOT           58
-#define TK_EXISTS        59
-#define TK_BUFFER        60
-#define TK_CACHELAST     61
-#define TK_COMP          62
-#define TK_DURATION      63
-#define TK_NK_VARIABLE   64
-#define TK_FSYNC         65
-#define TK_MAXROWS       66
-#define TK_MINROWS       67
-#define TK_KEEP          68
-#define TK_PAGES         69
-#define TK_PAGESIZE      70
-#define TK_PRECISION     71
-#define TK_REPLICA       72
-#define TK_STRICT        73
-#define TK_WAL           74
-#define TK_VGROUPS       75
-#define TK_SINGLE_STABLE 76
-#define TK_RETENTIONS    77
-#define TK_SCHEMALESS    78
-#define TK_NK_COLON      79
-#define TK_TABLE         80
-#define TK_NK_LP         81
-#define TK_NK_RP         82
-#define TK_STABLE        83
-#define TK_ADD           84
-#define TK_COLUMN        85
-#define TK_MODIFY        86
-#define TK_RENAME        87
-#define TK_TAG           88
-#define TK_SET           89
-#define TK_NK_EQ         90
-#define TK_USING         91
-#define TK_TAGS          92
-#define TK_COMMENT       93
-#define TK_BOOL          94
-#define TK_TINYINT       95
-#define TK_SMALLINT      96
-#define TK_INT           97
-#define TK_INTEGER       98
-#define TK_BIGINT        99
-#define TK_FLOAT         100
-#define TK_DOUBLE        101
-#define TK_BINARY        102
-#define TK_TIMESTAMP     103
-#define TK_NCHAR         104
-#define TK_UNSIGNED      105
-#define TK_JSON          106
-#define TK_VARCHAR       107
-#define TK_MEDIUMBLOB    108
-#define TK_BLOB          109
-#define TK_VARBINARY     110
-#define TK_DECIMAL       111
-#define TK_MAX_DELAY     112
-#define TK_WATERMARK     113
-#define TK_ROLLUP        114
-#define TK_TTL           115
-#define TK_SMA           116
-#define TK_FIRST         117
-#define TK_LAST          118
-#define TK_SHOW          119
-#define TK_DATABASES     120
-#define TK_TABLES        121
-#define TK_STABLES       122
-#define TK_MNODES        123
-#define TK_MODULES       124
-#define TK_QNODES        125
-#define TK_FUNCTIONS     126
-#define TK_INDEXES       127
-#define TK_ACCOUNTS      128
-#define TK_APPS          129
-#define TK_CONNECTIONS   130
-#define TK_LICENCE       131
-#define TK_GRANTS        132
-#define TK_QUERIES       133
-#define TK_SCORES        134
-#define TK_TOPICS        135
-#define TK_VARIABLES     136
-#define TK_BNODES        137
-#define TK_SNODES        138
-#define TK_CLUSTER       139
-#define TK_TRANSACTIONS  140
-#define TK_LIKE          141
-#define TK_INDEX         142
-#define TK_FULLTEXT      143
-#define TK_FUNCTION      144
-#define TK_INTERVAL      145
-#define TK_TOPIC         146
-#define TK_AS            147
-#define TK_CONSUMER      148
-#define TK_GROUP         149
-#define TK_DESC          150
-#define TK_DESCRIBE      151
-#define TK_RESET         152
-#define TK_QUERY         153
-#define TK_CACHE         154
-#define TK_EXPLAIN       155
-#define TK_ANALYZE       156
-#define TK_VERBOSE       157
-#define TK_NK_BOOL       158
-#define TK_RATIO         159
-#define TK_NK_FLOAT      160
-#define TK_COMPACT       161
-#define TK_VNODES        162
-#define TK_IN            163
-#define TK_OUTPUTTYPE    164
-#define TK_AGGREGATE     165
-#define TK_BUFSIZE       166
-#define TK_STREAM        167
-#define TK_INTO          168
-#define TK_TRIGGER       169
-#define TK_AT_ONCE       170
-#define TK_WINDOW_CLOSE  171
-#define TK_KILL          172
-#define TK_CONNECTION    173
-#define TK_TRANSACTION   174
-#define TK_BALANCE       175
-#define TK_VGROUP        176
-#define TK_MERGE         177
-#define TK_REDISTRIBUTE  178
-#define TK_SPLIT         179
-#define TK_SYNCDB        180
-#define TK_DELETE        181
-#define TK_NULL          182
-#define TK_NK_QUESTION   183
-#define TK_NK_ARROW      184
-#define TK_ROWTS         185
-#define TK_TBNAME        186
-#define TK_QSTARTTS      187
-#define TK_QENDTS        188
-#define TK_WSTARTTS      189
-#define TK_WENDTS        190
-#define TK_WDURATION     191
-#define TK_CAST          192
-#define TK_NOW           193
-#define TK_TODAY         194
-#define TK_TIMEZONE      195
-#define TK_COUNT         196
-#define TK_LAST_ROW      197
-#define TK_BETWEEN       198
-#define TK_IS            199
-#define TK_NK_LT         200
-#define TK_NK_GT         201
-#define TK_NK_LE         202
-#define TK_NK_GE         203
-#define TK_NK_NE         204
-#define TK_MATCH         205
-#define TK_NMATCH        206
-#define TK_CONTAINS      207
-#define TK_JOIN          208
-#define TK_INNER         209
-#define TK_SELECT        210
-#define TK_DISTINCT      211
-#define TK_WHERE         212
-#define TK_PARTITION     213
-#define TK_BY            214
-#define TK_SESSION       215
-#define TK_STATE_WINDOW  216
-#define TK_SLIDING       217
-#define TK_FILL          218
-#define TK_VALUE         219
-#define TK_NONE          220
-#define TK_PREV          221
-#define TK_LINEAR        222
-#define TK_NEXT          223
-#define TK_HAVING        224
-#define TK_ORDER         225
-#define TK_SLIMIT        226
-#define TK_SOFFSET       227
-#define TK_LIMIT         228
-#define TK_OFFSET        229
-#define TK_ASC           230
-#define TK_NULLS         231
-#define TK_ID            232
-#define TK_NK_BITNOT     233
-#define TK_INSERT        234
-#define TK_VALUES        235
-#define TK_IMPORT        236
-#define TK_NK_SEMI       237
-#define TK_FILE          238
+#define TK_LOCAL         49
+#define TK_QNODE         50
+#define TK_BNODE         51
+#define TK_SNODE         52
+#define TK_MNODE         53
+#define TK_DATABASE      54
+#define TK_USE           55
+#define TK_IF            56
+#define TK_NOT           57
+#define TK_EXISTS        58
+#define TK_BUFFER        59
+#define TK_CACHELAST     60
+#define TK_COMP          61
+#define TK_DURATION      62
+#define TK_NK_VARIABLE   63
+#define TK_FSYNC         64
+#define TK_MAXROWS       65
+#define TK_MINROWS       66
+#define TK_KEEP          67
+#define TK_PAGES         68
+#define TK_PAGESIZE      69
+#define TK_PRECISION     70
+#define TK_REPLICA       71
+#define TK_STRICT        72
+#define TK_WAL           73
+#define TK_VGROUPS       74
+#define TK_SINGLE_STABLE 75
+#define TK_RETENTIONS    76
+#define TK_SCHEMALESS    77
+#define TK_NK_COLON      78
+#define TK_TABLE         79
+#define TK_NK_LP         80
+#define TK_NK_RP         81
+#define TK_STABLE        82
+#define TK_ADD           83
+#define TK_COLUMN        84
+#define TK_MODIFY        85
+#define TK_RENAME        86
+#define TK_TAG           87
+#define TK_SET           88
+#define TK_NK_EQ         89
+#define TK_USING         90
+#define TK_TAGS          91
+#define TK_COMMENT       92
+#define TK_BOOL          93
+#define TK_TINYINT       94
+#define TK_SMALLINT      95
+#define TK_INT           96
+#define TK_INTEGER       97
+#define TK_BIGINT        98
+#define TK_FLOAT         99
+#define TK_DOUBLE        100
+#define TK_BINARY        101
+#define TK_TIMESTAMP     102
+#define TK_NCHAR         103
+#define TK_UNSIGNED      104
+#define TK_JSON          105
+#define TK_VARCHAR       106
+#define TK_MEDIUMBLOB    107
+#define TK_BLOB          108
+#define TK_VARBINARY     109
+#define TK_DECIMAL       110
+#define TK_MAX_DELAY     111
+#define TK_WATERMARK     112
+#define TK_ROLLUP        113
+#define TK_TTL           114
+#define TK_SMA           115
+#define TK_FIRST         116
+#define TK_LAST          117
+#define TK_SHOW          118
+#define TK_DATABASES     119
+#define TK_TABLES        120
+#define TK_STABLES       121
+#define TK_MNODES        122
+#define TK_MODULES       123
+#define TK_QNODES        124
+#define TK_FUNCTIONS     125
+#define TK_INDEXES       126
+#define TK_ACCOUNTS      127
+#define TK_APPS          128
+#define TK_CONNECTIONS   129
+#define TK_LICENCE       130
+#define TK_GRANTS        131
+#define TK_QUERIES       132
+#define TK_SCORES        133
+#define TK_TOPICS        134
+#define TK_VARIABLES     135
+#define TK_BNODES        136
+#define TK_SNODES        137
+#define TK_CLUSTER       138
+#define TK_TRANSACTIONS  139
+#define TK_LIKE          140
+#define TK_INDEX         141
+#define TK_FULLTEXT      142
+#define TK_FUNCTION      143
+#define TK_INTERVAL      144
+#define TK_TOPIC         145
+#define TK_AS            146
+#define TK_CONSUMER      147
+#define TK_GROUP         148
+#define TK_DESC          149
+#define TK_DESCRIBE      150
+#define TK_RESET         151
+#define TK_QUERY         152
+#define TK_CACHE         153
+#define TK_EXPLAIN       154
+#define TK_ANALYZE       155
+#define TK_VERBOSE       156
+#define TK_NK_BOOL       157
+#define TK_RATIO         158
+#define TK_NK_FLOAT      159
+#define TK_COMPACT       160
+#define TK_VNODES        161
+#define TK_IN            162
+#define TK_OUTPUTTYPE    163
+#define TK_AGGREGATE     164
+#define TK_BUFSIZE       165
+#define TK_STREAM        166
+#define TK_INTO          167
+#define TK_TRIGGER       168
+#define TK_AT_ONCE       169
+#define TK_WINDOW_CLOSE  170
+#define TK_KILL          171
+#define TK_CONNECTION    172
+#define TK_TRANSACTION   173
+#define TK_BALANCE       174
+#define TK_VGROUP        175
+#define TK_MERGE         176
+#define TK_REDISTRIBUTE  177
+#define TK_SPLIT         178
+#define TK_SYNCDB        179
+#define TK_DELETE        180
+#define TK_NULL          181
+#define TK_NK_QUESTION   182
+#define TK_NK_ARROW      183
+#define TK_ROWTS         184
+#define TK_TBNAME        185
+#define TK_QSTARTTS      186
+#define TK_QENDTS        187
+#define TK_WSTARTTS      188
+#define TK_WENDTS        189
+#define TK_WDURATION     190
+#define TK_CAST          191
+#define TK_NOW           192
+#define TK_TODAY         193
+#define TK_TIMEZONE      194
+#define TK_COUNT         195
+#define TK_LAST_ROW      196
+#define TK_BETWEEN       197
+#define TK_IS            198
+#define TK_NK_LT         199
+#define TK_NK_GT         200
+#define TK_NK_LE         201
+#define TK_NK_GE         202
+#define TK_NK_NE         203
+#define TK_MATCH         204
+#define TK_NMATCH        205
+#define TK_CONTAINS      206
+#define TK_JOIN          207
+#define TK_INNER         208
+#define TK_SELECT        209
+#define TK_DISTINCT      210
+#define TK_WHERE         211
+#define TK_PARTITION     212
+#define TK_BY            213
+#define TK_SESSION       214
+#define TK_STATE_WINDOW  215
+#define TK_SLIDING       216
+#define TK_FILL          217
+#define TK_VALUE         218
+#define TK_NONE          219
+#define TK_PREV          220
+#define TK_LINEAR        221
+#define TK_NEXT          222
+#define TK_HAVING        223
+#define TK_ORDER         224
+#define TK_SLIMIT        225
+#define TK_SOFFSET       226
+#define TK_LIMIT         227
+#define TK_OFFSET        228
+#define TK_ASC           229
+#define TK_NULLS         230
+#define TK_ID            231
+#define TK_NK_BITNOT     232
+#define TK_INSERT        233
+#define TK_VALUES        234
+#define TK_IMPORT        235
+#define TK_NK_SEMI       236
+#define TK_FILE          237
 
 #define TK_NK_SPACE   300
 #define TK_NK_COMMENT 301
@@ -261,6 +260,7 @@
 #define TK_NK_HEX     303  // hex number  0x123
 #define TK_NK_OCT     304  // oct number
 #define TK_NK_BIN     305  // bin format data 0b111
+#define TK_NK_IPTOKEN 306
 
 #define TK_NK_NIL 65535
 

include/libs/nodes/cmdnodes.h

@@ -208,11 +208,18 @@ typedef struct SShowStmt {
   SNode*    pTbNamePattern;  // SValueNode
 } SShowStmt;
 
-typedef struct SShowCreatStmt {
+typedef struct SShowCreateDatabaseStmt {
   ENodeType type;
   char      dbName[TSDB_DB_NAME_LEN];
-  char      tableName[TSDB_TABLE_NAME_LEN];
-} SShowCreatStmt;
+  void*     pCfg;  // SDbCfgInfo
+} SShowCreateDatabaseStmt;
+
+typedef struct SShowCreateTableStmt {
+  ENodeType   type;
+  char        dbName[TSDB_DB_NAME_LEN];
+  char        tableName[TSDB_TABLE_NAME_LEN];
+  STableMeta* pMeta;
+} SShowCreateTableStmt;
 
 typedef enum EIndexType { INDEX_TYPE_SMA = 1, INDEX_TYPE_FULLTEXT } EIndexType;
 

source/libs/command/src/command.c

@@ -47,7 +47,8 @@ static SSDataBlock* buildDescResultDataBlock() {
   taosArrayPush(pBlock->pDataBlock, &infoData);
 
   infoData.info.type = TSDB_DATA_TYPE_INT;
-  infoData.info.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes;;
+  infoData.info.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes;
+
   taosArrayPush(pBlock->pDataBlock, &infoData);
 
   infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
@@ -63,7 +64,7 @@ static void setDescResultIntoDataBlock(SSDataBlock* pBlock, int32_t numOfRows, S
 
   // field
   SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);
-  char buf[DESCRIBE_RESULT_FIELD_LEN] = {0};
+  char             buf[DESCRIBE_RESULT_FIELD_LEN] = {0};
   for (int32_t i = 0; i < numOfRows; ++i) {
     STR_TO_VARSTR(buf, pMeta->schema[i].name);
     colDataAppend(pCol1, i, buf, false);
@@ -92,8 +93,8 @@ static void setDescResultIntoDataBlock(SSDataBlock* pBlock, int32_t numOfRows, S
 }
 
 static int32_t execDescribe(SNode* pStmt, SRetrieveTableRsp** pRsp) {
-  SDescribeStmt* pDesc = (SDescribeStmt*) pStmt;
-  int32_t numOfRows = TABLE_TOTAL_COL_NUM(pDesc->pMeta);
+  SDescribeStmt* pDesc = (SDescribeStmt*)pStmt;
+  int32_t        numOfRows = TABLE_TOTAL_COL_NUM(pDesc->pMeta);
 
   SSDataBlock* pBlock = buildDescResultDataBlock();
   setDescResultIntoDataBlock(pBlock, numOfRows, pDesc->pMeta);
@@ -120,9 +121,15 @@ static int32_t execDescribe(SNode* pStmt, SRetrieveTableRsp** pRsp) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t execResetQueryCache() {
-  return catalogClearCache();
-}
+static int32_t execResetQueryCache() { return catalogClearCache(); }
+
+static int32_t execShowCreateDatabase(SShowCreateDatabaseStmt* pStmt) { return TSDB_CODE_FAILED; }
+
+static int32_t execShowCreateTable(SShowCreateTableStmt* pStmt) { return TSDB_CODE_FAILED; }
+
+static int32_t execShowCreateSTable(SShowCreateTableStmt* pStmt) { return TSDB_CODE_FAILED; }
+
+static int32_t execAlterLocal(SAlterLocalStmt* pStmt) { return TSDB_CODE_FAILED; }
 
 int32_t qExecCommand(SNode* pStmt, SRetrieveTableRsp** pRsp) {
   switch (nodeType(pStmt)) {
@@ -130,6 +137,14 @@ int32_t qExecCommand(SNode* pStmt, SRetrieveTableRsp** pRsp) {
       return execDescribe(pStmt, pRsp);
     case QUERY_NODE_RESET_QUERY_CACHE_STMT:
       return execResetQueryCache();
+    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
+      return execShowCreateDatabase((SShowCreateDatabaseStmt*)pStmt);
+    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
+      return execShowCreateTable((SShowCreateTableStmt*)pStmt);
+    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
+      return execShowCreateSTable((SShowCreateTableStmt*)pStmt);
+    case QUERY_NODE_ALTER_LOCAL_STMT:
+      return execAlterLocal((SAlterLocalStmt*)pStmt);
     default:
       break;
   }

source/libs/nodes/src/nodesUtilFuncs.c

@@ -150,6 +150,8 @@ SNode* nodesMakeNode(ENodeType type) {
       return makeNode(type, sizeof(SDropTopicStmt));
     case QUERY_NODE_DROP_CGROUP_STMT:
       return makeNode(type, sizeof(SDropCGroupStmt));
+    case QUERY_NODE_ALTER_LOCAL_STMT:
+      return makeNode(type, sizeof(SAlterLocalStmt));
     case QUERY_NODE_EXPLAIN_STMT:
       return makeNode(type, sizeof(SExplainStmt));
     case QUERY_NODE_DESCRIBE_STMT:
@@ -206,11 +208,13 @@ SNode* nodesMakeNode(ENodeType type) {
     case QUERY_NODE_SHOW_APPS_STMT:
     case QUERY_NODE_SHOW_SCORES_STMT:
     case QUERY_NODE_SHOW_VARIABLE_STMT:
+    case QUERY_NODE_SHOW_TRANSACTIONS_STMT:
+      return makeNode(type, sizeof(SShowStmt));
     case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
+      return makeNode(type, sizeof(SShowCreateDatabaseStmt));
     case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
     case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
-    case QUERY_NODE_SHOW_TRANSACTIONS_STMT:
-      return makeNode(type, sizeof(SShowStmt));
+      return makeNode(type, sizeof(SShowCreateTableStmt));
     case QUERY_NODE_KILL_QUERY_STMT:
       return makeNode(type, sizeof(SKillQueryStmt));
     case QUERY_NODE_KILL_TRANSACTION_STMT:

source/libs/parser/inc/parAst.h

@@ -152,7 +152,7 @@ SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int
 SNode* createAlterTableSetTag(SAstCreateContext* pCxt, SNode* pRealTable, SToken* pTagName, SNode* pVal);
 SNode* createUseDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName);
 SNode* createShowStmt(SAstCreateContext* pCxt, ENodeType type, SNode* pDbName, SNode* pTbNamePattern);
-SNode* createShowCreateDatabaseStmt(SAstCreateContext* pCxt, const SToken* pDbName);
+SNode* createShowCreateDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName);
 SNode* createShowCreateTableStmt(SAstCreateContext* pCxt, ENodeType type, SNode* pRealTable);
 SNode* createCreateUserStmt(SAstCreateContext* pCxt, SToken* pUserName, const SToken* pPassword);
 SNode* createAlterUserStmt(SAstCreateContext* pCxt, SToken* pUserName, int8_t alterType, const SToken* pVal);

source/libs/parser/inc/sql.y

@@ -125,8 +125,7 @@ dnode_endpoint(A) ::= NK_STRING(B).
 
 %type dnode_host_name                                                             { SToken }
 %destructor dnode_host_name                                                       { }
-dnode_host_name(A) ::= NK_ID(B).                                                  { A = B; }
-dnode_host_name(A) ::= NK_IPTOKEN(B).                                             { A = B; }
+dnode_host_name(A) ::= NK_STRING(B).                                              { A = B; }
 
 /************************************************ alter local *********************************************************/
 cmd ::= ALTER LOCAL NK_STRING(A).                                                 { pCxt->pRootNode = createAlterLocalStmt(pCxt, &A, NULL); }

source/libs/parser/src/parAstCreater.c

@@ -36,6 +36,14 @@
     }                                         \
   } while (0)
 
+#define COPY_STRING_FORM_ID_TOKEN(buf, pToken) strncpy(buf, (pToken)->z, TMIN((pToken)->n, sizeof(buf) - 1))
+#define COPY_STRING_FORM_STR_TOKEN(buf, pToken)                              \
+  do {                                                                       \
+    if ((pToken)->n > 2) {                                                   \
+      strncpy(buf, (pToken)->z + 1, TMIN((pToken)->n - 2, sizeof(buf) - 1)); \
+    }                                                                        \
+  } while (0)
+
 SToken nil_token = {.type = TK_NK_NIL, .n = 0, .z = NULL};
 
 void initAstCreateContext(SParseContext* pParseCxt, SAstCreateContext* pCxt) {
@@ -50,12 +58,6 @@ void initAstCreateContext(SParseContext* pParseCxt, SAstCreateContext* pCxt) {
   pCxt->errCode = TSDB_CODE_SUCCESS;
 }
 
-static void copyStringFormStringToken(SToken* pToken, char* pBuf, int32_t len) {
-  if (pToken->n > 2) {
-    strncpy(pBuf, pToken->z + 1, TMIN(pToken->n - 2, len - 1));
-  }
-}
-
 static void trimEscape(SToken* pName) {
   // todo need to deal with `ioo``ii` -> ioo`ii
   if (NULL != pName && pName->n > 1 && '`' == pName->z[0]) {
@@ -97,7 +99,7 @@ static bool checkPassword(SAstCreateContext* pCxt, const SToken* pPasswordToken,
   } else if (pPasswordToken->n >= (TSDB_USET_PASSWORD_LEN + 2)) {
     pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG);
   } else {
-    strncpy(pPassword, pPasswordToken->z, pPasswordToken->n);
+    COPY_STRING_FORM_ID_TOKEN(pPassword, pPasswordToken);
     strdequote(pPassword);
     if (strtrim(pPassword) <= 0) {
       pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_PASSWD_EMPTY);
@@ -114,8 +116,8 @@ static bool checkAndSplitEndpoint(SAstCreateContext* pCxt, const SToken* pEp, ch
   } else if (pEp->n >= TSDB_FQDN_LEN + 2 + 6) {  // format 'fqdn:port'
     pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG);
   } else {
-    char ep[TSDB_FQDN_LEN + 2 + 6];
-    strncpy(ep, pEp->z, pEp->n);
+    char ep[TSDB_FQDN_LEN + 6];
+    COPY_STRING_FORM_STR_TOKEN(ep, pEp);
     strdequote(ep);
     strtrim(ep);
     char* pColon = strchr(ep, ':');
@@ -274,9 +276,9 @@ SNode* createColumnNode(SAstCreateContext* pCxt, SToken* pTableAlias, SToken* pC
   SColumnNode* col = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
   CHECK_OUT_OF_MEM(col);
   if (NULL != pTableAlias) {
-    strncpy(col->tableAlias, pTableAlias->z, pTableAlias->n);
+    COPY_STRING_FORM_ID_TOKEN(col->tableAlias, pTableAlias);
   }
-  strncpy(col->colName, pColumnName->z, pColumnName->n);
+  COPY_STRING_FORM_ID_TOKEN(col->colName, pColumnName);
   return (SNode*)col;
 }
 
@@ -417,7 +419,7 @@ SNode* createFunctionNode(SAstCreateContext* pCxt, const SToken* pFuncName, SNod
   }
   SFunctionNode* func = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
   CHECK_OUT_OF_MEM(func);
-  strncpy(func->functionName, pFuncName->z, pFuncName->n);
+  COPY_STRING_FORM_ID_TOKEN(func->functionName, pFuncName);
   func->pParameterList = pParameterList;
   return (SNode*)func;
 }
@@ -464,16 +466,16 @@ SNode* createRealTableNode(SAstCreateContext* pCxt, SToken* pDbName, SToken* pTa
   SRealTableNode* realTable = (SRealTableNode*)nodesMakeNode(QUERY_NODE_REAL_TABLE);
   CHECK_OUT_OF_MEM(realTable);
   if (NULL != pDbName) {
-    strncpy(realTable->table.dbName, pDbName->z, pDbName->n);
+    COPY_STRING_FORM_ID_TOKEN(realTable->table.dbName, pDbName);
   } else {
     strcpy(realTable->table.dbName, pCxt->pQueryCxt->db);
   }
   if (NULL != pTableAlias && TK_NK_NIL != pTableAlias->type) {
-    strncpy(realTable->table.tableAlias, pTableAlias->z, pTableAlias->n);
+    COPY_STRING_FORM_ID_TOKEN(realTable->table.tableAlias, pTableAlias);
   } else {
-    strncpy(realTable->table.tableAlias, pTableName->z, pTableName->n);
+    COPY_STRING_FORM_ID_TOKEN(realTable->table.tableAlias, pTableName);
   }
-  strncpy(realTable->table.tableName, pTableName->z, pTableName->n);
+  COPY_STRING_FORM_ID_TOKEN(realTable->table.tableName, pTableName);
   return (SNode*)realTable;
 }
 
@@ -483,7 +485,7 @@ SNode* createTempTableNode(SAstCreateContext* pCxt, SNode* pSubquery, const STok
   CHECK_OUT_OF_MEM(tempTable);
   tempTable->pSubquery = pSubquery;
   if (NULL != pTableAlias && TK_NK_NIL != pTableAlias->type) {
-    strncpy(tempTable->table.tableAlias, pTableAlias->z, pTableAlias->n);
+    COPY_STRING_FORM_ID_TOKEN(tempTable->table.tableAlias, pTableAlias);
   } else {
     sprintf(tempTable->table.tableAlias, "%p", tempTable);
   }
@@ -785,8 +787,7 @@ SNode* setDatabaseOption(SAstCreateContext* pCxt, SNode* pOptions, EDatabaseOpti
       ((SDatabaseOptions*)pOptions)->pagesize = taosStr2Int32(((SToken*)pVal)->z, NULL, 10);
       break;
     case DB_OPTION_PRECISION:
-      copyStringFormStringToken((SToken*)pVal, ((SDatabaseOptions*)pOptions)->precisionStr,
-                                sizeof(((SDatabaseOptions*)pOptions)->precisionStr));
+      COPY_STRING_FORM_STR_TOKEN(((SDatabaseOptions*)pOptions)->precisionStr, (SToken*)pVal);
       break;
     case DB_OPTION_REPLICA:
       ((SDatabaseOptions*)pOptions)->replica = taosStr2Int8(((SToken*)pVal)->z, NULL, 10);
@@ -835,7 +836,7 @@ SNode* createCreateDatabaseStmt(SAstCreateContext* pCxt, bool ignoreExists, STok
   }
   SCreateDatabaseStmt* pStmt = (SCreateDatabaseStmt*)nodesMakeNode(QUERY_NODE_CREATE_DATABASE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->dbName, pDbName->z, pDbName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName);
   pStmt->ignoreExists = ignoreExists;
   pStmt->pOptions = (SDatabaseOptions*)pOptions;
   return (SNode*)pStmt;
@@ -848,7 +849,7 @@ SNode* createDropDatabaseStmt(SAstCreateContext* pCxt, bool ignoreNotExists, STo
   }
   SDropDatabaseStmt* pStmt = (SDropDatabaseStmt*)nodesMakeNode(QUERY_NODE_DROP_DATABASE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->dbName, pDbName->z, pDbName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName);
   pStmt->ignoreNotExists = ignoreNotExists;
   return (SNode*)pStmt;
 }
@@ -860,7 +861,7 @@ SNode* createAlterDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode*
   }
   SAlterDatabaseStmt* pStmt = (SAlterDatabaseStmt*)nodesMakeNode(QUERY_NODE_ALTER_DATABASE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->dbName, pDbName->z, pDbName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName);
   pStmt->pOptions = (SDatabaseOptions*)pOptions;
   return (SNode*)pStmt;
 }
@@ -890,8 +891,7 @@ SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType
   switch (type) {
     case TABLE_OPTION_COMMENT:
       if (checkComment(pCxt, (SToken*)pVal, true)) {
-        copyStringFormStringToken((SToken*)pVal, ((STableOptions*)pOptions)->comment,
-                                  sizeof(((STableOptions*)pOptions)->comment));
+        COPY_STRING_FORM_STR_TOKEN(((STableOptions*)pOptions)->comment, (SToken*)pVal);
       }
       break;
     case TABLE_OPTION_MAXDELAY:
@@ -922,7 +922,7 @@ SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType
   }
   SColumnDefNode* pCol = (SColumnDefNode*)nodesMakeNode(QUERY_NODE_COLUMN_DEF);
   CHECK_OUT_OF_MEM(pCol);
-  strncpy(pCol->colName, pColName->z, pColName->n);
+  COPY_STRING_FORM_ID_TOKEN(pCol->colName, pColName);
   pCol->dataType = dataType;
   if (NULL != pComment) {
     trimString(pComment->z, pComment->n, pCol->comments, sizeof(pCol->comments));
@@ -1037,7 +1037,7 @@ SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable,
   SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->alterType = alterType;
-  strncpy(pStmt->colName, pColName->z, pColName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pColName);
   pStmt->dataType = dataType;
   return createAlterTableStmtFinalize(pRealTable, pStmt);
 }
@@ -1050,7 +1050,7 @@ SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_
   SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->alterType = alterType;
-  strncpy(pStmt->colName, pColName->z, pColName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pColName);
   return createAlterTableStmtFinalize(pRealTable, pStmt);
 }
 
@@ -1063,8 +1063,8 @@ SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int
   SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->alterType = alterType;
-  strncpy(pStmt->colName, pOldColName->z, pOldColName->n);
-  strncpy(pStmt->newColName, pNewColName->z, pNewColName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pOldColName);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->newColName, pNewColName);
   return createAlterTableStmtFinalize(pRealTable, pStmt);
 }
 
@@ -1076,7 +1076,7 @@ SNode* createAlterTableSetTag(SAstCreateContext* pCxt, SNode* pRealTable, SToken
   SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->alterType = TSDB_ALTER_TABLE_UPDATE_TAG_VAL;
-  strncpy(pStmt->colName, pTagName->z, pTagName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pTagName);
   pStmt->pVal = (SValueNode*)pVal;
   return createAlterTableStmtFinalize(pRealTable, pStmt);
 }
@@ -1088,7 +1088,7 @@ SNode* createUseDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName) {
   }
   SUseDatabaseStmt* pStmt = (SUseDatabaseStmt*)nodesMakeNode(QUERY_NODE_USE_DATABASE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->dbName, pDbName->z, pDbName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName);
   return (SNode*)pStmt;
 }
 
@@ -1111,18 +1111,24 @@ SNode* createShowStmt(SAstCreateContext* pCxt, ENodeType type, SNode* pDbName, S
   return (SNode*)pStmt;
 }
 
-SNode* createShowCreateDatabaseStmt(SAstCreateContext* pCxt, const SToken* pDbName) {
+SNode* createShowCreateDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName) {
   CHECK_PARSER_STATUS(pCxt);
-  SNode* pStmt = nodesMakeNode(QUERY_NODE_SHOW_CREATE_DATABASE_STMT);
+  if (!checkDbName(pCxt, pDbName, true)) {
+    return NULL;
+  }
+  SShowCreateDatabaseStmt* pStmt = (SShowCreateDatabaseStmt*)nodesMakeNode(QUERY_NODE_SHOW_CREATE_DATABASE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  return pStmt;
+  COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName);
+  return (SNode*)pStmt;
 }
 
 SNode* createShowCreateTableStmt(SAstCreateContext* pCxt, ENodeType type, SNode* pRealTable) {
   CHECK_PARSER_STATUS(pCxt);
-  SNode* pStmt = nodesMakeNode(type);
+  SShowCreateTableStmt* pStmt = (SShowCreateTableStmt*)nodesMakeNode(type);
   CHECK_OUT_OF_MEM(pStmt);
-  return pStmt;
+  strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
+  strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
+  return (SNode*)pStmt;
 }
 
 SNode* createCreateUserStmt(SAstCreateContext* pCxt, SToken* pUserName, const SToken* pPassword) {
@@ -1133,7 +1139,7 @@ SNode* createCreateUserStmt(SAstCreateContext* pCxt, SToken* pUserName, const ST
   }
   SCreateUserStmt* pStmt = (SCreateUserStmt*)nodesMakeNode(QUERY_NODE_CREATE_USER_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->useName, pUserName->z, pUserName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->useName, pUserName);
   strcpy(pStmt->password, password);
   return (SNode*)pStmt;
 }
@@ -1145,7 +1151,7 @@ SNode* createAlterUserStmt(SAstCreateContext* pCxt, SToken* pUserName, int8_t al
   }
   SAlterUserStmt* pStmt = (SAlterUserStmt*)nodesMakeNode(QUERY_NODE_ALTER_USER_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->useName, pUserName->z, pUserName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->useName, pUserName);
   if (TSDB_ALTER_USER_PASSWD == alterType) {
     char password[TSDB_USET_PASSWORD_LEN] = {0};
     if (!checkPassword(pCxt, pVal, password)) {
@@ -1165,7 +1171,7 @@ SNode* createDropUserStmt(SAstCreateContext* pCxt, SToken* pUserName) {
   }
   SDropUserStmt* pStmt = (SDropUserStmt*)nodesMakeNode(QUERY_NODE_DROP_USER_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->useName, pUserName->z, pUserName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->useName, pUserName);
   return (SNode*)pStmt;
 }
 
@@ -1185,7 +1191,7 @@ SNode* createCreateDnodeStmt(SAstCreateContext* pCxt, const SToken* pFqdn, const
   if (NULL == pPort) {
     strcpy(pStmt->fqdn, fqdn);
   } else {
-    strncpy(pStmt->fqdn, pFqdn->z, pFqdn->n);
+    COPY_STRING_FORM_ID_TOKEN(pStmt->fqdn, pFqdn);
   }
   pStmt->port = port;
   return (SNode*)pStmt;
@@ -1229,8 +1235,8 @@ SNode* createCreateIndexStmt(SAstCreateContext* pCxt, EIndexType type, bool igno
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->indexType = type;
   pStmt->ignoreExists = ignoreExists;
-  strncpy(pStmt->indexName, pIndexName->z, pIndexName->n);
-  strncpy(pStmt->tableName, pTableName->z, pTableName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->indexName, pIndexName);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->tableName, pTableName);
   pStmt->pCols = pCols;
   pStmt->pOptions = (SIndexOptions*)pOptions;
   return (SNode*)pStmt;
@@ -1256,8 +1262,8 @@ SNode* createDropIndexStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToken
   SDropIndexStmt* pStmt = (SDropIndexStmt*)nodesMakeNode(QUERY_NODE_DROP_INDEX_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->ignoreNotExists = ignoreNotExists;
-  strncpy(pStmt->indexName, pIndexName->z, pIndexName->n);
-  strncpy(pStmt->tableName, pTableName->z, pTableName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->indexName, pIndexName);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->tableName, pTableName);
   return (SNode*)pStmt;
 }
 
@@ -1282,14 +1288,14 @@ SNode* createCreateTopicStmt(SAstCreateContext* pCxt, bool ignoreExists, const S
   CHECK_PARSER_STATUS(pCxt);
   SCreateTopicStmt* pStmt = (SCreateTopicStmt*)nodesMakeNode(QUERY_NODE_CREATE_TOPIC_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->topicName, pTopicName->z, pTopicName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->topicName, pTopicName);
   pStmt->ignoreExists = ignoreExists;
   if (NULL != pRealTable) {
     strcpy(pStmt->subDbName, ((SRealTableNode*)pRealTable)->table.dbName);
     strcpy(pStmt->subSTbName, ((SRealTableNode*)pRealTable)->table.tableName);
     nodesDestroyNode(pRealTable);
   } else if (NULL != pSubDbName) {
-    strncpy(pStmt->subDbName, pSubDbName->z, pSubDbName->n);
+    COPY_STRING_FORM_ID_TOKEN(pStmt->subDbName, pSubDbName);
   } else {
     pStmt->pQuery = pQuery;
   }
@@ -1300,7 +1306,7 @@ SNode* createDropTopicStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const
   CHECK_PARSER_STATUS(pCxt);
   SDropTopicStmt* pStmt = (SDropTopicStmt*)nodesMakeNode(QUERY_NODE_DROP_TOPIC_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->topicName, pTopicName->z, pTopicName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->topicName, pTopicName);
   pStmt->ignoreNotExists = ignoreNotExists;
   return (SNode*)pStmt;
 }
@@ -1311,8 +1317,8 @@ SNode* createDropCGroupStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const
   SDropCGroupStmt* pStmt = (SDropCGroupStmt*)nodesMakeNode(QUERY_NODE_DROP_CGROUP_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->ignoreNotExists = ignoreNotExists;
-  strncpy(pStmt->topicName, pTopicName->z, pTopicName->n);
-  strncpy(pStmt->cgroup, pCGroupId->z, pCGroupId->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->topicName, pTopicName);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->cgroup, pCGroupId);
   return (SNode*)pStmt;
 }
 
@@ -1392,9 +1398,9 @@ SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool ignoreExists, bool
   SCreateFunctionStmt* pStmt = (SCreateFunctionStmt*)nodesMakeNode(QUERY_NODE_CREATE_FUNCTION_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->ignoreExists = ignoreExists;
-  strncpy(pStmt->funcName, pFuncName->z, pFuncName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->funcName, pFuncName);
   pStmt->isAgg = aggFunc;
-  strncpy(pStmt->libraryPath, pLibPath->z + 1, pLibPath->n - 2);
+  COPY_STRING_FORM_STR_TOKEN(pStmt->libraryPath, pLibPath);
   pStmt->outputDt = dataType;
   pStmt->bufSize = bufSize;
   return (SNode*)pStmt;
@@ -1405,7 +1411,7 @@ SNode* createDropFunctionStmt(SAstCreateContext* pCxt, bool ignoreNotExists, con
   SDropFunctionStmt* pStmt = (SDropFunctionStmt*)nodesMakeNode(QUERY_NODE_DROP_FUNCTION_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->ignoreNotExists = ignoreNotExists;
-  strncpy(pStmt->funcName, pFuncName->z, pFuncName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->funcName, pFuncName);
   return (SNode*)pStmt;
 }
 
@@ -1422,7 +1428,7 @@ SNode* createCreateStreamStmt(SAstCreateContext* pCxt, bool ignoreExists, const
   CHECK_PARSER_STATUS(pCxt);
   SCreateStreamStmt* pStmt = (SCreateStreamStmt*)nodesMakeNode(QUERY_NODE_CREATE_STREAM_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->streamName, pStreamName->z, pStreamName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->streamName, pStreamName);
   if (NULL != pRealTable) {
     strcpy(pStmt->targetDbName, ((SRealTableNode*)pRealTable)->table.dbName);
     strcpy(pStmt->targetTabName, ((SRealTableNode*)pRealTable)->table.tableName);
@@ -1438,7 +1444,7 @@ SNode* createDropStreamStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const
   CHECK_PARSER_STATUS(pCxt);
   SDropStreamStmt* pStmt = (SDropStreamStmt*)nodesMakeNode(QUERY_NODE_DROP_STREAM_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  strncpy(pStmt->streamName, pStreamName->z, TMIN(pStreamName->n, sizeof(pStmt->streamName) - 1));
+  COPY_STRING_FORM_ID_TOKEN(pStmt->streamName, pStreamName);
   pStmt->ignoreNotExists = ignoreNotExists;
   return (SNode*)pStmt;
 }
@@ -1507,8 +1513,8 @@ SNode* createGrantStmt(SAstCreateContext* pCxt, int64_t privileges, SToken* pDbN
   SGrantStmt* pStmt = (SGrantStmt*)nodesMakeNode(QUERY_NODE_GRANT_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->privileges = privileges;
-  strncpy(pStmt->dbName, pDbName->z, pDbName->n);
-  strncpy(pStmt->userName, pUserName->z, pUserName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->userName, pUserName);
   return (SNode*)pStmt;
 }
 
@@ -1520,8 +1526,8 @@ SNode* createRevokeStmt(SAstCreateContext* pCxt, int64_t privileges, SToken* pDb
   SRevokeStmt* pStmt = (SRevokeStmt*)nodesMakeNode(QUERY_NODE_REVOKE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
   pStmt->privileges = privileges;
-  strncpy(pStmt->dbName, pDbName->z, pDbName->n);
-  strncpy(pStmt->userName, pUserName->z, pUserName->n);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName);
+  COPY_STRING_FORM_ID_TOKEN(pStmt->userName, pUserName);
   return (SNode*)pStmt;
 }
 

source/libs/parser/src/parAstParser.c

@@ -397,6 +397,14 @@ static int32_t collectMetaKeyFromShowVariables(SCollectMetaKeyCxt* pCxt, SShowSt
                                  pCxt->pMetaCache);
 }
 
+static int32_t collectMetaKeyFromShowCreateDatabase(SCollectMetaKeyCxt* pCxt, SShowCreateDatabaseStmt* pStmt) {
+  return reserveDbCfgInCache(pCxt->pParseCxt->acctId, pStmt->dbName, pCxt->pMetaCache);
+}
+
+static int32_t collectMetaKeyFromShowCreateTable(SCollectMetaKeyCxt* pCxt, SShowCreateTableStmt* pStmt) {
+  return reserveTableMetaInCache(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, pCxt->pMetaCache);
+}
+
 static int32_t collectMetaKeyFromShowApps(SCollectMetaKeyCxt* pCxt, SShowStmt* pStmt) {
   return reserveTableMetaInCache(pCxt->pParseCxt->acctId, TSDB_PERFORMANCE_SCHEMA_DB, TSDB_PERFS_TABLE_APPS,
                                  pCxt->pMetaCache);
@@ -478,6 +486,11 @@ static int32_t collectMetaKeyFromQuery(SCollectMetaKeyCxt* pCxt, SNode* pStmt) {
       return collectMetaKeyFromShowQueries(pCxt, (SShowStmt*)pStmt);
     case QUERY_NODE_SHOW_VARIABLE_STMT:
       return collectMetaKeyFromShowVariables(pCxt, (SShowStmt*)pStmt);
+    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
+      return collectMetaKeyFromShowCreateDatabase(pCxt, (SShowCreateDatabaseStmt*)pStmt);
+    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
+    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
+      return collectMetaKeyFromShowCreateTable(pCxt, (SShowCreateTableStmt*)pStmt);
     case QUERY_NODE_SHOW_APPS_STMT:
       return collectMetaKeyFromShowApps(pCxt, (SShowStmt*)pStmt);
     case QUERY_NODE_SHOW_TRANSACTIONS_STMT:

source/libs/parser/src/parTranslater.c

@@ -3612,27 +3612,6 @@ static int32_t translateAlterDnode(STranslateContext* pCxt, SAlterDnodeStmt* pSt
   return buildCmdMsg(pCxt, TDMT_MND_CONFIG_DNODE, (FSerializeFunc)tSerializeSMCfgDnodeReq, &cfgReq);
 }
 
-static int32_t nodeTypeToShowType(ENodeType nt) {
-  switch (nt) {
-    case QUERY_NODE_SHOW_CONNECTIONS_STMT:
-      return TSDB_MGMT_TABLE_CONNS;
-    case QUERY_NODE_SHOW_LICENCE_STMT:
-      return TSDB_MGMT_TABLE_GRANTS;
-    case QUERY_NODE_SHOW_QUERIES_STMT:
-      return TSDB_MGMT_TABLE_QUERIES;
-    case QUERY_NODE_SHOW_VARIABLE_STMT:
-      return TSDB_MGMT_TABLE_CONFIGS;
-    default:
-      break;
-  }
-  return 0;
-}
-
-static int32_t translateShow(STranslateContext* pCxt, SShowStmt* pStmt) {
-  SShowReq showReq = {.type = nodeTypeToShowType(nodeType(pStmt))};
-  return buildCmdMsg(pCxt, TDMT_MND_SHOW, (FSerializeFunc)tSerializeSShowReq, &showReq);
-}
-
 static int32_t getSmaIndexDstVgId(STranslateContext* pCxt, char* pTableName, int32_t* pVgId) {
   SVgroupInfo vg = {0};
   int32_t     code = getTableHashVgroup(pCxt, pCxt->pParseCxt->db, pTableName, &vg);
@@ -4178,6 +4157,18 @@ static int32_t translateSplitVgroup(STranslateContext* pCxt, SSplitVgroupStmt* p
   return buildCmdMsg(pCxt, TDMT_MND_SPLIT_VGROUP, (FSerializeFunc)tSerializeSSplitVgroupReq, &req);
 }
 
+static int32_t translateShowCreateDatabase(STranslateContext* pCxt, SShowCreateDatabaseStmt* pStmt) {
+  pStmt->pCfg = taosMemoryCalloc(1, sizeof(SDbCfgInfo));
+  if (NULL == pStmt->pCfg) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  return getDBCfg(pCxt, pStmt->dbName, (SDbCfgInfo*)pStmt->pCfg);
+}
+
+static int32_t translateShowCreateTable(STranslateContext* pCxt, SShowCreateTableStmt* pStmt) {
+  return getTableMeta(pCxt, pStmt->dbName, pStmt->tableName, &pStmt->pMeta);
+}
+
 static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) {
   int32_t code = TSDB_CODE_SUCCESS;
   switch (nodeType(pNode)) {
@@ -4232,12 +4223,6 @@ static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) {
     case QUERY_NODE_ALTER_DNODE_STMT:
       code = translateAlterDnode(pCxt, (SAlterDnodeStmt*)pNode);
       break;
-    case QUERY_NODE_SHOW_CONNECTIONS_STMT:
-    case QUERY_NODE_SHOW_QUERIES_STMT:
-    case QUERY_NODE_SHOW_TOPICS_STMT:
-    case QUERY_NODE_SHOW_VARIABLE_STMT:
-      code = translateShow(pCxt, (SShowStmt*)pNode);
-      break;
     case QUERY_NODE_CREATE_INDEX_STMT:
       code = translateCreateIndex(pCxt, (SCreateIndexStmt*)pNode);
       break;
@@ -4313,6 +4298,13 @@ static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) {
     case QUERY_NODE_SPLIT_VGROUP_STMT:
       code = translateSplitVgroup(pCxt, (SSplitVgroupStmt*)pNode);
       break;
+    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
+      code = translateShowCreateDatabase(pCxt, (SShowCreateDatabaseStmt*)pNode);
+      break;
+    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
+    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
+      code = translateShowCreateTable(pCxt, (SShowCreateTableStmt*)pNode);
+      break;
     default:
       break;
   }
@@ -4395,6 +4387,42 @@ static int32_t extractDescribeResultSchema(int32_t* numOfCols, SSchema** pSchema
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t extractShowCreateDatabaseResultSchema(int32_t* numOfCols, SSchema** pSchema) {
+  *numOfCols = 2;
+  *pSchema = taosMemoryCalloc((*numOfCols), sizeof(SSchema));
+  if (NULL == (*pSchema)) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  (*pSchema)[0].type = TSDB_DATA_TYPE_BINARY;
+  (*pSchema)[0].bytes = TSDB_DB_NAME_LEN;
+  strcpy((*pSchema)[0].name, "Database");
+
+  (*pSchema)[1].type = TSDB_DATA_TYPE_BINARY;
+  (*pSchema)[1].bytes = TSDB_MAX_BINARY_LEN;
+  strcpy((*pSchema)[1].name, "Create Database");
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t extractShowCreateTableResultSchema(int32_t* numOfCols, SSchema** pSchema) {
+  *numOfCols = 2;
+  *pSchema = taosMemoryCalloc((*numOfCols), sizeof(SSchema));
+  if (NULL == (*pSchema)) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  (*pSchema)[0].type = TSDB_DATA_TYPE_BINARY;
+  (*pSchema)[0].bytes = TSDB_TABLE_NAME_LEN;
+  strcpy((*pSchema)[0].name, "Table");
+
+  (*pSchema)[1].type = TSDB_DATA_TYPE_BINARY;
+  (*pSchema)[1].bytes = TSDB_MAX_BINARY_LEN;
+  strcpy((*pSchema)[1].name, "Create Table");
+
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t extractResultSchema(const SNode* pRoot, int32_t* numOfCols, SSchema** pSchema) {
   if (NULL == pRoot) {
     return TSDB_CODE_SUCCESS;
@@ -4408,6 +4436,11 @@ int32_t extractResultSchema(const SNode* pRoot, int32_t* numOfCols, SSchema** pS
       return extractExplainResultSchema(numOfCols, pSchema);
     case QUERY_NODE_DESCRIBE_STMT:
       return extractDescribeResultSchema(numOfCols, pSchema);
+    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
+      return extractShowCreateDatabaseResultSchema(numOfCols, pSchema);
+    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
+    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
+      return extractShowCreateTableResultSchema(numOfCols, pSchema);
     default:
       break;
   }
@@ -5628,10 +5661,14 @@ static int32_t setQuery(STranslateContext* pCxt, SQuery* pQuery) {
       pQuery->msgType = toMsgType(((SVnodeModifOpStmt*)pQuery->pRoot)->sqlNodeType);
       break;
     case QUERY_NODE_DESCRIBE_STMT:
+    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
+    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
+    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
       pQuery->execMode = QUERY_EXEC_MODE_LOCAL;
       pQuery->haveResultSet = true;
       break;
     case QUERY_NODE_RESET_QUERY_CACHE_STMT:
+    case QUERY_NODE_ALTER_LOCAL_STMT:
       pQuery->execMode = QUERY_EXEC_MODE_LOCAL;
       break;
     default:

source/libs/parser/test/parInitialATest.cpp

@@ -43,7 +43,40 @@ TEST_F(ParserInitialATest, alterDatabase) {
   run("ALTER DATABASE wxy_db KEEP 2400");
 }
 
-// todo ALTER local
+TEST_F(ParserInitialATest, alterLocal) {
+  useDb("root", "test");
+
+  pair<string, string> expect;
+
+  auto clearAlterLocal = [&]() {
+    expect.first.clear();
+    expect.second.clear();
+  };
+
+  auto setAlterLocalFunc = [&](const char* pConfig, const char* pValue = nullptr) {
+    expect.first.assign(pConfig);
+    if (nullptr != pValue) {
+      expect.second.assign(pValue);
+    }
+  };
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_ALTER_LOCAL_STMT);
+    ASSERT_EQ(pQuery->execMode, QUERY_EXEC_MODE_LOCAL);
+    SAlterLocalStmt* pStmt = (SAlterLocalStmt*)pQuery->pRoot;
+    ASSERT_EQ(string(pStmt->config), expect.first);
+    ASSERT_EQ(string(pStmt->value), expect.second);
+  });
+
+  setAlterLocalFunc("resetlog");
+  run("ALTER LOCAL 'resetlog'");
+  clearAlterLocal();
+
+  setAlterLocalFunc("querypolicy", "2");
+  run("ALTER LOCAL 'querypolicy' '2'");
+  clearAlterLocal();
+}
+
 // todo ALTER stable
 
 /*

source/libs/parser/test/parInitialCTest.cpp

@@ -242,9 +242,9 @@ TEST_F(ParserInitialCTest, createDatabaseSemanticCheck) {
 TEST_F(ParserInitialCTest, createDnode) {
   useDb("root", "test");
 
-  run("CREATE DNODE abc1 PORT 7000");
+  run("CREATE DNODE 'abc1' PORT 7000");
 
-  run("CREATE DNODE 1.1.1.1 PORT 9000");
+  run("CREATE DNODE '1.1.1.1' PORT 9000");
 }
 
 // CREATE [AGGREGATE] FUNCTION [IF NOT EXISTS] func_name AS library_path OUTPUTTYPE type_name [BUFSIZE value]

source/libs/parser/test/parShowToUse.cpp

@@ -24,9 +24,45 @@ class ParserShowToUseTest : public ParserDdlTest {};
 // todo SHOW accounts
 // todo SHOW apps
 // todo SHOW connections
-// todo SHOW create database
-// todo SHOW create stable
-// todo SHOW create table
+
+TEST_F(ParserShowToUseTest, showCreateDatabase) {
+  useDb("root", "test");
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_SHOW_CREATE_DATABASE_STMT);
+    ASSERT_EQ(pQuery->execMode, QUERY_EXEC_MODE_LOCAL);
+    ASSERT_TRUE(pQuery->haveResultSet);
+    ASSERT_NE(((SShowCreateDatabaseStmt*)pQuery->pRoot)->pCfg, nullptr);
+  });
+
+  run("SHOW CREATE DATABASE test");
+}
+
+TEST_F(ParserShowToUseTest, showCreateSTable) {
+  useDb("root", "test");
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_SHOW_CREATE_STABLE_STMT);
+    ASSERT_EQ(pQuery->execMode, QUERY_EXEC_MODE_LOCAL);
+    ASSERT_TRUE(pQuery->haveResultSet);
+    ASSERT_NE(((SShowCreateTableStmt*)pQuery->pRoot)->pMeta, nullptr);
+  });
+
+  run("SHOW CREATE STABLE st1");
+}
+
+TEST_F(ParserShowToUseTest, showCreateTable) {
+  useDb("root", "test");
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_SHOW_CREATE_TABLE_STMT);
+    ASSERT_EQ(pQuery->execMode, QUERY_EXEC_MODE_LOCAL);
+    ASSERT_TRUE(pQuery->haveResultSet);
+    ASSERT_NE(((SShowCreateTableStmt*)pQuery->pRoot)->pMeta, nullptr);
+  });
+
+  run("SHOW CREATE TABLE t1");
+}
 
 TEST_F(ParserShowToUseTest, showDatabases) {
   useDb("root", "test");

source/libs/parser/test/parTestUtil.h

@@ -20,6 +20,7 @@
 
 #define ALLOW_FORBID_FUNC
 
+#include "cmdnodes.h"
 #include "querynodes.h"
 #include "taoserror.h"