Merge pull request #15117 from taosdata/feature/3.0_debug_wxy

feat: sql command 'show tags from table_name'

include/util/taoserror.h

@@ -493,10 +493,11 @@ int32_t* taosGetErrno();
 
 //parser
 #define TSDB_CODE_PAR_SYNTAX_ERROR              TAOS_DEF_ERROR_CODE(0, 0x2600)
-#define TSDB_CODE_PAR_INVALID_COLUMN            TAOS_DEF_ERROR_CODE(0, 0x2601)
-#define TSDB_CODE_PAR_TABLE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x2602)
-#define TSDB_CODE_PAR_AMBIGUOUS_COLUMN          TAOS_DEF_ERROR_CODE(0, 0x2603)
-#define TSDB_CODE_PAR_WRONG_VALUE_TYPE          TAOS_DEF_ERROR_CODE(0, 0x2604)
+#define TSDB_CODE_PAR_INCOMPLETE_SQL            TAOS_DEF_ERROR_CODE(0, 0x2601)
+#define TSDB_CODE_PAR_INVALID_COLUMN            TAOS_DEF_ERROR_CODE(0, 0x2602)
+#define TSDB_CODE_PAR_TABLE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x2603)
+#define TSDB_CODE_PAR_AMBIGUOUS_COLUMN          TAOS_DEF_ERROR_CODE(0, 0x2604)
+#define TSDB_CODE_PAR_WRONG_VALUE_TYPE          TAOS_DEF_ERROR_CODE(0, 0x2605)
 #define TSDB_CODE_PAR_ILLEGAL_USE_AGG_FUNCTION  TAOS_DEF_ERROR_CODE(0, 0x2608)
 #define TSDB_CODE_PAR_WRONG_NUMBER_OF_SELECT    TAOS_DEF_ERROR_CODE(0, 0x2609)
 #define TSDB_CODE_PAR_GROUPBY_LACK_EXPRESSION   TAOS_DEF_ERROR_CODE(0, 0x260A)
@@ -504,7 +505,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_NOT_SINGLE_GROUP          TAOS_DEF_ERROR_CODE(0, 0x260C) 
 #define TSDB_CODE_PAR_TAGS_NOT_MATCHED          TAOS_DEF_ERROR_CODE(0, 0x260D)
 #define TSDB_CODE_PAR_INVALID_TAG_NAME          TAOS_DEF_ERROR_CODE(0, 0x260E)
-#define TSDB_CODE_PAR_INCOMPLETE_SQL            TAOS_DEF_ERROR_CODE(0, 0x260F)
 #define TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG   TAOS_DEF_ERROR_CODE(0, 0x2610)
 #define TSDB_CODE_PAR_PASSWD_EMPTY              TAOS_DEF_ERROR_CODE(0, 0x2611)
 #define TSDB_CODE_PAR_INVALID_PORT              TAOS_DEF_ERROR_CODE(0, 0x2612)
@@ -514,19 +514,9 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_DB_NOT_SPECIFIED          TAOS_DEF_ERROR_CODE(0, 0x2616)
 #define TSDB_CODE_PAR_INVALID_IDENTIFIER_NAME   TAOS_DEF_ERROR_CODE(0, 0x2617)
 #define TSDB_CODE_PAR_CORRESPONDING_STABLE_ERR  TAOS_DEF_ERROR_CODE(0, 0x2618)
-#define TSDB_CODE_PAR_INVALID_RANGE_OPTION      TAOS_DEF_ERROR_CODE(0, 0x2619)
-#define TSDB_CODE_PAR_INVALID_STR_OPTION        TAOS_DEF_ERROR_CODE(0, 0x261A)
-#define TSDB_CODE_PAR_INVALID_ENUM_OPTION       TAOS_DEF_ERROR_CODE(0, 0x261B)
-#define TSDB_CODE_PAR_INVALID_KEEP_NUM          TAOS_DEF_ERROR_CODE(0, 0x261D)
-#define TSDB_CODE_PAR_INVALID_KEEP_ORDER        TAOS_DEF_ERROR_CODE(0, 0x261E)
-#define TSDB_CODE_PAR_INVALID_KEEP_VALUE        TAOS_DEF_ERROR_CODE(0, 0x261F)
-#define TSDB_CODE_PAR_INVALID_COMMENT_OPTION    TAOS_DEF_ERROR_CODE(0, 0x2620)
-#define TSDB_CODE_PAR_INVALID_F_RANGE_OPTION    TAOS_DEF_ERROR_CODE(0, 0x2621)
-#define TSDB_CODE_PAR_INVALID_ROLLUP_OPTION     TAOS_DEF_ERROR_CODE(0, 0x2622)
-#define TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION TAOS_DEF_ERROR_CODE(0, 0x2623)
+#define TSDB_CODE_PAR_INVALID_DB_OPTION         TAOS_DEF_ERROR_CODE(0, 0x2619)
+#define TSDB_CODE_PAR_INVALID_TABLE_OPTION      TAOS_DEF_ERROR_CODE(0, 0x261A)
 #define TSDB_CODE_PAR_GROUPBY_WINDOW_COEXIST    TAOS_DEF_ERROR_CODE(0, 0x2624)
-#define TSDB_CODE_PAR_INVALID_OPTION_UNIT       TAOS_DEF_ERROR_CODE(0, 0x2625)
-#define TSDB_CODE_PAR_INVALID_KEEP_UNIT         TAOS_DEF_ERROR_CODE(0, 0x2626)
 #define TSDB_CODE_PAR_AGG_FUNC_NESTING          TAOS_DEF_ERROR_CODE(0, 0x2627)
 #define TSDB_CODE_PAR_INVALID_STATE_WIN_TYPE    TAOS_DEF_ERROR_CODE(0, 0x2628)
 #define TSDB_CODE_PAR_INVALID_STATE_WIN_COL     TAOS_DEF_ERROR_CODE(0, 0x2629)
@@ -580,7 +570,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_WINDOW_NOT_ALLOWED_FUNC   TAOS_DEF_ERROR_CODE(0, 0x2659)
 #define TSDB_CODE_PAR_STREAM_NOT_ALLOWED_FUNC   TAOS_DEF_ERROR_CODE(0, 0x265A)
 #define TSDB_CODE_PAR_GROUP_BY_NOT_ALLOWED_FUNC TAOS_DEF_ERROR_CODE(0, 0x265B)
-#define TSDB_CODE_PAR_INVALID_TABLE_OPTION      TAOS_DEF_ERROR_CODE(0, 0x265C)
 #define TSDB_CODE_PAR_INVALID_INTERP_CLAUSE     TAOS_DEF_ERROR_CODE(0, 0x265D)
 #define TSDB_CODE_PAR_NO_VALID_FUNC_IN_WIN      TAOS_DEF_ERROR_CODE(0, 0x265E)
 #define TSDB_CODE_PAR_ONLY_SUPPORT_SINGLE_TABLE TAOS_DEF_ERROR_CODE(0, 0x265F)

source/libs/function/src/builtins.c

@@ -192,9 +192,9 @@ static bool validateTimezoneFormat(const SValueNode* pVal) {
 }
 
 void static addTimezoneParam(SNodeList* pList) {
-  char       buf[6] = {0};
-  time_t     t = taosTime(NULL);
-  struct tm  tmInfo;
+  char      buf[6] = {0};
+  time_t    t = taosTime(NULL);
+  struct tm tmInfo;
   taosLocalTime(&t, &tmInfo);
   strftime(buf, sizeof(buf), "%z", &tmInfo);
   int32_t len = (int32_t)strlen(buf);
@@ -976,7 +976,7 @@ static int32_t translateHistogram(SFunctionNode* pFunc, char* pErrBuf, int32_t l
   // param1 ~ param3
   if (((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type != TSDB_DATA_TYPE_BINARY ||
       ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type != TSDB_DATA_TYPE_BINARY ||
-      ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 3))->resType.type != TSDB_DATA_TYPE_BIGINT) {
+      !IS_INTEGER_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 3))->resType.type)) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
@@ -1034,7 +1034,7 @@ static int32_t translateHistogramImpl(SFunctionNode* pFunc, char* pErrBuf, int32
     // param1 ~ param3
     if (((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type != TSDB_DATA_TYPE_BINARY ||
         ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type != TSDB_DATA_TYPE_BINARY ||
-        ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 3))->resType.type != TSDB_DATA_TYPE_BIGINT) {
+        !IS_INTEGER_TYPE(((SExprNode*)nodesListGetNode(pFunc->pParameterList, 3))->resType.type)) {
       return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
     }
 
@@ -1133,9 +1133,10 @@ static bool validateStateOper(const SValueNode* pVal) {
   if (TSDB_DATA_TYPE_BINARY != pVal->node.resType.type) {
     return false;
   }
-  return (0 == strncasecmp(varDataVal(pVal->datum.p), "GT", 2) || 0 == strncasecmp(varDataVal(pVal->datum.p), "GE", 2) ||
-          0 == strncasecmp(varDataVal(pVal->datum.p), "LT", 2) || 0 == strncasecmp(varDataVal(pVal->datum.p), "LE", 2) ||
-          0 == strncasecmp(varDataVal(pVal->datum.p), "EQ", 2) || 0 == strncasecmp(varDataVal(pVal->datum.p), "NE", 2));
+  return (
+      0 == strncasecmp(varDataVal(pVal->datum.p), "GT", 2) || 0 == strncasecmp(varDataVal(pVal->datum.p), "GE", 2) ||
+      0 == strncasecmp(varDataVal(pVal->datum.p), "LT", 2) || 0 == strncasecmp(varDataVal(pVal->datum.p), "LE", 2) ||
+      0 == strncasecmp(varDataVal(pVal->datum.p), "EQ", 2) || 0 == strncasecmp(varDataVal(pVal->datum.p), "NE", 2));
 }
 
 static int32_t translateStateCount(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
@@ -1348,7 +1349,8 @@ static int32_t translateTail(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
 
     SValueNode* pValue = (SValueNode*)pParamNode;
 
-    if (pValue->datum.i < ((i > 1) ? 0 : 1) || pValue->datum.i > 100) {
+    if ((IS_SIGNED_NUMERIC_TYPE(pValue->node.resType.type) ? pValue->datum.i : pValue->datum.u) < ((i > 1) ? 0 : 1) ||
+        (IS_SIGNED_NUMERIC_TYPE(pValue->node.resType.type) ? pValue->datum.i : pValue->datum.u) > 100) {
       return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
                              "TAIL function second parameter should be in range [1, 100], "
                              "third parameter should be in range [0, 100]");

source/libs/function/src/builtinsimpl.c

@@ -80,7 +80,7 @@ typedef struct STopBotRes {
 } STopBotRes;
 
 typedef struct SFirstLastRes {
-  bool      hasResult;
+  bool hasResult;
   // used for last_row function only, isNullRes in SResultRowEntry can not be passed to downstream.So,
   // this attribute is required
   bool      isNull;
@@ -2380,7 +2380,8 @@ int32_t percentileFunction(SqlFunctionCtx* pCtx) {
 
 int32_t percentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   SVariant* pVal = &pCtx->param[1].param;
-  double    v = (pVal->nType == TSDB_DATA_TYPE_BIGINT) ? pVal->i : pVal->d;
+  double    v =
+      (IS_SIGNED_NUMERIC_TYPE(pVal->nType) ? pVal->i : (IS_UNSIGNED_NUMERIC_TYPE(pVal->nType) ? pVal->u : pVal->d));
 
   SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
   SPercentileInfo*     ppInfo = (SPercentileInfo*)GET_ROWCELL_INTERBUF(pResInfo);
@@ -2439,7 +2440,8 @@ bool apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResult
   SAPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
 
   SVariant* pVal = &pCtx->param[1].param;
-  pInfo->percent = (pVal->nType == TSDB_DATA_TYPE_BIGINT) ? pVal->i : pVal->d;
+  pInfo->percent =
+      (IS_SIGNED_NUMERIC_TYPE(pVal->nType) ? pVal->i : (IS_UNSIGNED_NUMERIC_TYPE(pVal->nType) ? pVal->u : pVal->d));
 
   if (pCtx->numOfParams == 2) {
     pInfo->algo = APERCT_ALGO_DEFAULT;
@@ -2640,9 +2642,7 @@ int32_t apercentileCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx)
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t getFirstLastInfoSize(int32_t resBytes) {
-  return sizeof(SFirstLastRes) + resBytes;
-}
+int32_t getFirstLastInfoSize(int32_t resBytes) { return sizeof(SFirstLastRes) + resBytes; }
 
 bool getFirstLastFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
   SColumnNode* pNode = (SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0);
@@ -2968,7 +2968,7 @@ int32_t firstLastPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   return 1;
 }
 
-//todo rewrite:
+// todo rewrite:
 int32_t lastCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
   SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
   char*                pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
@@ -2986,7 +2986,7 @@ int32_t lastCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
   return TSDB_CODE_SUCCESS;
 }
 
-static void doSaveLastrow(SqlFunctionCtx *pCtx, char* pData, int32_t rowIndex, int64_t cts, SFirstLastRes* pInfo) {
+static void doSaveLastrow(SqlFunctionCtx* pCtx, char* pData, int32_t rowIndex, int64_t cts, SFirstLastRes* pInfo) {
   SInputColumnInfoData* pInput = &pCtx->input;
   SColumnInfoData*      pInputCol = pInput->pData[0];
 

source/libs/nodes/src/nodesCodeFuncs.c

@@ -159,6 +159,8 @@ const char* nodesNodeName(ENodeType type) {
       return "ShowStreamsStmt";
     case QUERY_NODE_SHOW_TABLES_STMT:
       return "ShowTablesStmt";
+    case QUERY_NODE_SHOW_TAGS_STMT:
+      return "ShowTagsStmt";
     case QUERY_NODE_SHOW_USERS_STMT:
       return "ShowUsersStmt";
     case QUERY_NODE_SHOW_LICENCE_STMT:
@@ -4295,6 +4297,7 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) {
       return alterDnodeStmtToJson(pObj, pJson);
     case QUERY_NODE_SHOW_DATABASES_STMT:
     case QUERY_NODE_SHOW_TABLES_STMT:
+    case QUERY_NODE_SHOW_TAGS_STMT:
       break;
     case QUERY_NODE_CREATE_TOPIC_STMT:
       return createTopicStmtToJson(pObj, pJson);

source/libs/nodes/src/nodesUtilFuncs.c

@@ -216,6 +216,7 @@ SNode* nodesMakeNode(ENodeType type) {
     case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:
     case QUERY_NODE_SHOW_TRANSACTIONS_STMT:
     case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT:
+    case QUERY_NODE_SHOW_TAGS_STMT:
       return makeNode(type, sizeof(SShowStmt));
     case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT:
       return makeNode(type, sizeof(SShowDnodeVariablesStmt));
@@ -678,7 +679,8 @@ void nodesDestroyNode(SNode* pNode) {
     case QUERY_NODE_SHOW_VARIABLES_STMT:
     case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:
     case QUERY_NODE_SHOW_TRANSACTIONS_STMT:
-    case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT: {
+    case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT:
+    case QUERY_NODE_SHOW_TAGS_STMT: {
       SShowStmt* pStmt = (SShowStmt*)pNode;
       nodesDestroyNode(pStmt->pDbName);
       nodesDestroyNode(pStmt->pTbName);

source/libs/parser/inc/sql.y

@@ -82,7 +82,6 @@ alter_account_option ::= STATE literal.
 /************************************************ create/alter/drop user **********************************************/
 cmd ::= CREATE USER user_name(A) PASS NK_STRING(B) sysinfo_opt(C).                { pCxt->pRootNode = createCreateUserStmt(pCxt, &A, &B, C); }
 cmd ::= ALTER USER user_name(A) PASS NK_STRING(B).                                { pCxt->pRootNode = createAlterUserStmt(pCxt, &A, TSDB_ALTER_USER_PASSWD, &B); }
-//cmd ::= ALTER USER user_name(A) PRIVILEGE NK_STRING(B).                           { pCxt->pRootNode = createAlterUserStmt(pCxt, &A, TSDB_ALTER_USER_PRIVILEGES, &B); }
 cmd ::= ALTER USER user_name(A) ENABLE NK_INTEGER(B).                             { pCxt->pRootNode = createAlterUserStmt(pCxt, &A, TSDB_ALTER_USER_ENABLE, &B); }
 cmd ::= ALTER USER user_name(A) SYSINFO NK_INTEGER(B).                            { pCxt->pRootNode = createAlterUserStmt(pCxt, &A, TSDB_ALTER_USER_SYSINFO, &B); }
 cmd ::= DROP USER user_name(A).                                                   { pCxt->pRootNode = createDropUserStmt(pCxt, &A); }
@@ -198,15 +197,15 @@ alter_db_options(A) ::= alter_db_options(B) alter_db_option(C).
 
 %type alter_db_option                                                             { SAlterOption }
 %destructor alter_db_option                                                       { }
-alter_db_option(A) ::= BUFFER NK_INTEGER(B).                                      { A.type = DB_OPTION_BUFFER; A.val = B; }
+//alter_db_option(A) ::= BUFFER NK_INTEGER(B).                                      { A.type = DB_OPTION_BUFFER; A.val = B; }
 alter_db_option(A) ::= CACHEMODEL NK_STRING(B).                                   { A.type = DB_OPTION_CACHEMODEL; A.val = B; }
 alter_db_option(A) ::= CACHESIZE NK_INTEGER(B).                                   { A.type = DB_OPTION_CACHESIZE; A.val = B; }
 alter_db_option(A) ::= FSYNC NK_INTEGER(B).                                       { A.type = DB_OPTION_FSYNC; A.val = B; }
 alter_db_option(A) ::= KEEP integer_list(B).                                      { A.type = DB_OPTION_KEEP; A.pList = B; }
 alter_db_option(A) ::= KEEP variable_list(B).                                     { A.type = DB_OPTION_KEEP; A.pList = B; }
-alter_db_option(A) ::= PAGES NK_INTEGER(B).                                       { A.type = DB_OPTION_PAGES; A.val = B; }
-alter_db_option(A) ::= REPLICA NK_INTEGER(B).                                     { A.type = DB_OPTION_REPLICA; A.val = B; }
-alter_db_option(A) ::= STRICT NK_INTEGER(B).                                      { A.type = DB_OPTION_STRICT; A.val = B; }
+//alter_db_option(A) ::= PAGES NK_INTEGER(B).                                       { A.type = DB_OPTION_PAGES; A.val = B; }
+//alter_db_option(A) ::= REPLICA NK_INTEGER(B).                                     { A.type = DB_OPTION_REPLICA; A.val = B; }
+//alter_db_option(A) ::= STRICT NK_STRING(B).                                       { A.type = DB_OPTION_STRICT; A.val = B; }
 alter_db_option(A) ::= WAL NK_INTEGER(B).                                         { A.type = DB_OPTION_WAL; A.val = B; }
 
 %type integer_list                                                                { SNodeList* }
@@ -394,6 +393,7 @@ cmd ::= SHOW TRANSACTIONS.
 cmd ::= SHOW TABLE DISTRIBUTED full_table_name(A).                                { pCxt->pRootNode = createShowTableDistributedStmt(pCxt, A); }
 cmd ::= SHOW CONSUMERS.                                                           { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); }
 cmd ::= SHOW SUBSCRIPTIONS.                                                       { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); }
+cmd ::= SHOW TAGS FROM table_name_cond(A) from_db_opt(B).                         { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, B, A, OP_TYPE_EQUAL); }
 
 db_name_cond_opt(A) ::= .                                                         { A = createDefaultDatabaseCondValue(pCxt); }
 db_name_cond_opt(A) ::= db_name(B) NK_DOT.                                        { A = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &B); }
@@ -525,7 +525,7 @@ cmd ::= INSERT INTO full_table_name(A)
 cmd ::= INSERT INTO full_table_name(A) query_expression(B).                       { pCxt->pRootNode = createInsertStmt(pCxt, A, NULL, B); }
 
 /************************************************ literal *************************************************************/
-literal(A) ::= NK_INTEGER(B).                                                     { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B)); }
+literal(A) ::= NK_INTEGER(B).                                                     { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &B)); }
 literal(A) ::= NK_FLOAT(B).                                                       { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &B)); }
 literal(A) ::= NK_STRING(B).                                                      { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &B)); }
 literal(A) ::= NK_BOOL(B).                                                        { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &B)); }
@@ -536,8 +536,8 @@ literal(A) ::= NK_QUESTION(B).
 
 duration_literal(A) ::= NK_VARIABLE(B).                                           { A = createRawExprNode(pCxt, &B, createDurationValueNode(pCxt, &B)); }
 
-signed(A) ::= NK_INTEGER(B).                                                      { A = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
-signed(A) ::= NK_PLUS NK_INTEGER(B).                                              { A = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
+signed(A) ::= NK_INTEGER(B).                                                      { A = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &B); }
+signed(A) ::= NK_PLUS NK_INTEGER(B).                                              { A = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &B); }
 signed(A) ::= NK_MINUS(B) NK_INTEGER(C).                                          { 
                                                                                     SToken t = B;
                                                                                     t.n = (C.z + C.n) - B.z;

source/libs/parser/src/parAstCreater.c

@@ -393,9 +393,16 @@ SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pL
     SValueNode* pVal = (SValueNode*)pLeft;
     char*       pNewLiteral = taosMemoryCalloc(1, strlen(pVal->literal) + 2);
     CHECK_OUT_OF_MEM(pNewLiteral);
-    sprintf(pNewLiteral, "-%s", pVal->literal);
+    if ('+' == pVal->literal[0]) {
+      sprintf(pNewLiteral, "-%s", pVal->literal + 1);
+    } else if ('-' == pVal->literal[0]) {
+      sprintf(pNewLiteral, "%s", pVal->literal + 1);
+    } else {
+      sprintf(pNewLiteral, "-%s", pVal->literal);
+    }
     taosMemoryFree(pVal->literal);
     pVal->literal = pNewLiteral;
+    pVal->node.resType.type = TSDB_DATA_TYPE_BIGINT;
     return pLeft;
   }
   SOperatorNode* op = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR);
@@ -1343,7 +1350,11 @@ SNode* createAlterDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode, const
   CHECK_PARSER_STATUS(pCxt);
   SAlterDnodeStmt* pStmt = (SAlterDnodeStmt*)nodesMakeNode(QUERY_NODE_ALTER_DNODE_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  pStmt->dnodeId = taosStr2Int32(pDnode->z, NULL, 10);
+  if (NULL != pDnode) {
+    pStmt->dnodeId = taosStr2Int32(pDnode->z, NULL, 10);
+  } else {
+    pStmt->dnodeId = -1;
+  }
   trimString(pConfig->z, pConfig->n, pStmt->config, sizeof(pStmt->config));
   if (NULL != pValue) {
     trimString(pValue->z, pValue->n, pStmt->value, sizeof(pStmt->value));

source/libs/parser/src/parAstParser.c

@@ -372,8 +372,8 @@ static int32_t collectMetaKeyFromShowTables(SCollectMetaKeyCxt* pCxt, SShowStmt*
 }
 
 static int32_t collectMetaKeyFromShowTags(SCollectMetaKeyCxt* pCxt, SShowStmt* pStmt) {
-  int32_t code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, TSDB_INFORMATION_SCHEMA_DB,
-                                         TSDB_INS_TABLE_USER_TAGS, pCxt->pMetaCache);
+  int32_t code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, TSDB_INFORMATION_SCHEMA_DB, TSDB_INS_TABLE_USER_TAGS,
+                                         pCxt->pMetaCache);
   if (TSDB_CODE_SUCCESS == code) {
     if (NULL != pStmt->pDbName) {
       code = reserveDbVgInfoInCache(pCxt->pParseCxt->acctId, ((SValueNode*)pStmt->pDbName)->literal, pCxt->pMetaCache);

source/libs/parser/src/parUtil.c

@@ -67,32 +67,8 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "Invalid identifier name: %s";
     case TSDB_CODE_PAR_CORRESPONDING_STABLE_ERR:
       return "Corresponding super table not in this db";
-    case TSDB_CODE_PAR_INVALID_RANGE_OPTION:
-      return "Invalid option %s: %" PRId64 " valid range: [%d, %d]";
-    case TSDB_CODE_PAR_INVALID_STR_OPTION:
-      return "Invalid option %s: %s";
-    case TSDB_CODE_PAR_INVALID_ENUM_OPTION:
-      return "Invalid option %s: %" PRId64 ", only %d, %d allowed";
-    case TSDB_CODE_PAR_INVALID_KEEP_NUM:
-      return "Invalid number of keep options";
-    case TSDB_CODE_PAR_INVALID_KEEP_ORDER:
-      return "Invalid keep value, should be keep0 <= keep1 <= keep2";
-    case TSDB_CODE_PAR_INVALID_KEEP_VALUE:
-      return "Invalid option keep: %" PRId64 ", %" PRId64 ", %" PRId64 " valid range: [%dm, %dm]";
-    case TSDB_CODE_PAR_INVALID_COMMENT_OPTION:
-      return "Invalid option comment, length cannot exceed %d";
-    case TSDB_CODE_PAR_INVALID_F_RANGE_OPTION:
-      return "Invalid option %s: %f valid range: [%d, %d]";
-    case TSDB_CODE_PAR_INVALID_ROLLUP_OPTION:
-      return "Invalid option rollup: only one function is allowed";
-    case TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION:
-      return "Invalid option retentions";
     case TSDB_CODE_PAR_GROUPBY_WINDOW_COEXIST:
       return "GROUP BY and WINDOW-clause can't be used together";
-    case TSDB_CODE_PAR_INVALID_OPTION_UNIT:
-      return "Invalid option %s unit: %c, only %c, %c, %c allowed";
-    case TSDB_CODE_PAR_INVALID_KEEP_UNIT:
-      return "Invalid option keep unit: %c, only m, h, d allowed";
     case TSDB_CODE_PAR_AGG_FUNC_NESTING:
       return "Aggregate functions do not support nesting";
     case TSDB_CODE_PAR_INVALID_STATE_WIN_TYPE:
@@ -194,8 +170,6 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "%s function is not supported in stream query";
     case TSDB_CODE_PAR_GROUP_BY_NOT_ALLOWED_FUNC:
       return "%s function is not supported in group query";
-    case TSDB_CODE_PAR_INVALID_TABLE_OPTION:
-      return "Invalid option %s";
     case TSDB_CODE_PAR_INVALID_INTERP_CLAUSE:
       return "Invalid usage of RANGE clause, EVERY clause or FILL clause";
     case TSDB_CODE_PAR_NO_VALID_FUNC_IN_WIN:
@@ -389,7 +363,7 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, voi
       continue;
     }
     STagVal val = {0};
-//    strcpy(val.colName, colName);
+    //    strcpy(val.colName, colName);
     val.pKey = jsonKey;
     taosHashPut(keyHash, jsonKey, keyLen, &keyLen,
                 CHAR_BYTES);  // add key to hash to remove dumplicate, value is useless

source/libs/parser/test/mockCatalog.cpp

@@ -328,46 +328,6 @@ void initMetaDataEnv() {
   stub.set(catalogGetTableIndex, __catalogGetTableIndex);
   stub.set(catalogGetDnodeList, __catalogGetDnodeList);
   stub.set(catalogRefreshGetTableCfg, __catalogRefreshGetTableCfg);
-  // {
-  //   AddrAny any("libcatalog.so");
-  //   std::map<std::string,void*> result;
-  //   any.get_global_func_addr_dynsym("^catalogGetHandle$", result);
-  //   for (const auto& f : result) {
-  //     stub.set(f.second, __catalogGetHandle);
-  //   }
-  // }
-  // {
-  //   AddrAny any("libcatalog.so");
-  //   std::map<std::string,void*> result;
-  //   any.get_global_func_addr_dynsym("^catalogGetTableMeta$", result);
-  //   for (const auto& f : result) {
-  //     stub.set(f.second, __catalogGetTableMeta);
-  //   }
-  // }
-  // {
-  //   AddrAny any("libcatalog.so");
-  //   std::map<std::string,void*> result;
-  //   any.get_global_func_addr_dynsym("^catalogGetTableHashVgroup$", result);
-  //   for (const auto& f : result) {
-  //     stub.set(f.second, __catalogGetTableHashVgroup);
-  //   }
-  // }
-  // {
-  //   AddrAny any("libcatalog.so");
-  //   std::map<std::string,void*> result;
-  //   any.get_global_func_addr_dynsym("^catalogGetTableDistVgInfo$", result);
-  //   for (const auto& f : result) {
-  //     stub.set(f.second, __catalogGetTableDistVgInfo);
-  //   }
-  // }
-  // {
-  //   AddrAny any("libcatalog.so");
-  //   std::map<std::string,void*> result;
-  //   any.get_global_func_addr_dynsym("^catalogGetDBVgVersion$", result);
-  //   for (const auto& f : result) {
-  //     stub.set(f.second, __catalogGetDBVgVersion);
-  //   }
-  // }
 }
 
 void generateMetaData() {

source/libs/parser/test/parInitialATest.cpp

@@ -27,22 +27,217 @@ TEST_F(ParserInitialATest, alterAccount) {
   run("ALTER ACCOUNT ac_wxy PASS '123456'", TSDB_CODE_PAR_EXPRIE_STATEMENT, PARSER_STAGE_PARSE);
 }
 
+/*
+ * ALTER DNODE dnode_id 'config' ['value']
+ * ALTER ALL DNODES 'config' ['value']
+ */
 TEST_F(ParserInitialATest, alterDnode) {
   useDb("root", "test");
 
+  SMCfgDnodeReq expect = {0};
+
+  auto clearCfgDnodeReq = [&]() { memset(&expect, 0, sizeof(SMCfgDnodeReq)); };
+
+  auto setCfgDnodeReq = [&](int32_t dnodeId, const char* pConfig, const char* pValue = nullptr) {
+    expect.dnodeId = dnodeId;
+    strcpy(expect.config, pConfig);
+    if (nullptr != pValue) {
+      strcpy(expect.value, pValue);
+    }
+  };
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_ALTER_DNODE_STMT);
+    SMCfgDnodeReq req = {0};
+    ASSERT_EQ(tDeserializeSMCfgDnodeReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req), TSDB_CODE_SUCCESS);
+    ASSERT_EQ(req.dnodeId, expect.dnodeId);
+    ASSERT_EQ(std::string(req.config), std::string(expect.config));
+    ASSERT_EQ(std::string(req.value), std::string(expect.value));
+  });
+
+  setCfgDnodeReq(1, "resetLog");
   run("ALTER DNODE 1 'resetLog'");
+  clearCfgDnodeReq();
+
+  setCfgDnodeReq(2, "debugFlag", "134");
+  run("ALTER DNODE 2 'debugFlag' '134'");
+  clearCfgDnodeReq();
 
-  run("ALTER DNODE 1 'debugFlag' '134'");
+  setCfgDnodeReq(-1, "resetQueryCache");
+  run("ALTER ALL DNODES 'resetQueryCache'");
+  clearCfgDnodeReq();
+
+  setCfgDnodeReq(-1, "qDebugflag", "135");
+  run("ALTER ALL DNODES 'qDebugflag' '135'");
+  clearCfgDnodeReq();
 }
 
+/*
+ * ALTER DATABASE db_name [alter_database_options]
+ *
+ * alter_database_options:
+ *     alter_database_option ...
+ *
+ * alter_database_option: {
+ *     BUFFER int_value                                          -- todo: range [3, 16384], default 96, unit MB
+ *   | CACHEMODEL {'none' | 'last_row' | 'last_value' | 'both'}  -- default 'none'
+ *   | CACHESIZE int_value                                       -- range [1, 65536], default 1, unit MB
+ *   | FSYNC int_value                                           -- rang [0, 180000], default 3000, unit ms
+ *   | KEEP {int_value | duration_value}                         -- rang [1, 365000], default 3650, unit day
+ *   | PAGES int_value                                           -- todo: rang [64, +oo), default 256, unit page
+ *   | REPLICA int_value                                         -- todo: enum 1, 3, default 1, unit replica
+ *   | STRICT {'off' | 'on'}                                     -- todo: default 'off'
+ *   | WAL int_value                                             -- enum 1, 2, default 1
+ * }
+ */
 TEST_F(ParserInitialATest, alterDatabase) {
   useDb("root", "test");
 
-  run("ALTER DATABASE test CACHEMODEL 'last_row' FSYNC 200 WAL 1");
+  SAlterDbReq expect = {0};
+
+  auto clearAlterDbReq = [&]() { memset(&expect, 0, sizeof(SAlterDbReq)); };
+
+  auto initAlterDb = [&](const char* pDb) {
+    snprintf(expect.db, sizeof(expect.db), "0.%s", pDb);
+    expect.buffer = -1;
+    expect.pageSize = -1;
+    expect.pages = -1;
+    expect.daysPerFile = -1;
+    expect.daysToKeep0 = -1;
+    expect.daysToKeep1 = -1;
+    expect.daysToKeep2 = -1;
+    expect.fsyncPeriod = -1;
+    expect.walLevel = -1;
+    expect.strict = -1;
+    expect.cacheLast = -1;
+    expect.cacheLastSize = -1;
+    expect.replications = -1;
+  };
+  auto setAlterDbBuffer = [&](int32_t buffer) { expect.buffer = buffer; };
+  auto setAlterDbPageSize = [&](int32_t pageSize) { expect.pageSize = pageSize; };
+  auto setAlterDbPages = [&](int32_t pages) { expect.pages = pages; };
+  auto setAlterDbCacheSize = [&](int32_t cacheSize) { expect.cacheLastSize = cacheSize; };
+  auto setAlterDbDuration = [&](int32_t duration) { expect.daysPerFile = duration; };
+  auto setAlterDbKeep = [&](int32_t daysToKeep0, int32_t daysToKeep1 = -1, int32_t daysToKeep2 = -1) {
+    expect.daysToKeep0 = daysToKeep0;
+    expect.daysToKeep1 = (-1 == daysToKeep1 ? expect.daysToKeep0 : daysToKeep1);
+    expect.daysToKeep2 = (-1 == daysToKeep1 ? expect.daysToKeep1 : daysToKeep2);
+  };
+  auto setAlterDbFsync = [&](int32_t fsync) { expect.fsyncPeriod = fsync; };
+  auto setAlterDbWal = [&](int8_t wal) { expect.walLevel = wal; };
+  auto setAlterDbStrict = [&](int8_t strict) { expect.strict = strict; };
+  auto setAlterDbCacheModel = [&](int8_t cacheModel) { expect.cacheLast = cacheModel; };
+  auto setAlterDbReplica = [&](int8_t replications) { expect.replications = replications; };
+
+  setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) {
+    ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_ALTER_DATABASE_STMT);
+    SAlterDbReq req = {0};
+    ASSERT_EQ(tDeserializeSAlterDbReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req), TSDB_CODE_SUCCESS);
+    ASSERT_EQ(std::string(req.db), std::string(expect.db));
+    ASSERT_EQ(req.buffer, expect.buffer);
+    ASSERT_EQ(req.pageSize, expect.pageSize);
+    ASSERT_EQ(req.pages, expect.pages);
+    ASSERT_EQ(req.cacheLastSize, expect.cacheLastSize);
+    ASSERT_EQ(req.daysToKeep0, expect.daysToKeep0);
+    ASSERT_EQ(req.daysToKeep1, expect.daysToKeep1);
+    ASSERT_EQ(req.daysToKeep2, expect.daysToKeep2);
+    ASSERT_EQ(req.fsyncPeriod, expect.fsyncPeriod);
+    ASSERT_EQ(req.walLevel, expect.walLevel);
+    ASSERT_EQ(req.strict, expect.strict);
+    ASSERT_EQ(req.cacheLast, expect.cacheLast);
+    ASSERT_EQ(req.replications, expect.replications);
+  });
+
+  const int32_t MINUTE_PER_DAY = MILLISECOND_PER_DAY / MILLISECOND_PER_MINUTE;
+  const int32_t MINUTE_PER_HOUR = MILLISECOND_PER_HOUR / MILLISECOND_PER_MINUTE;
+
+  initAlterDb("test");
+  setAlterDbCacheSize(32);
+  setAlterDbKeep(10 * MINUTE_PER_DAY);
+  setAlterDbFsync(200);
+  setAlterDbWal(1);
+  setAlterDbCacheModel(TSDB_CACHE_MODEL_LAST_ROW);
+  run("ALTER DATABASE test CACHEMODEL 'last_row' CACHESIZE 32 FSYNC 200 KEEP 10 WAL 1");
+  clearAlterDbReq();
+
+  initAlterDb("test");
+  setAlterDbCacheModel(TSDB_CACHE_MODEL_NONE);
+  run("ALTER DATABASE test CACHEMODEL 'none'");
+  setAlterDbCacheModel(TSDB_CACHE_MODEL_LAST_ROW);
+  run("ALTER DATABASE test CACHEMODEL 'last_row'");
+  setAlterDbCacheModel(TSDB_CACHE_MODEL_LAST_VALUE);
+  run("ALTER DATABASE test CACHEMODEL 'last_value'");
+  setAlterDbCacheModel(TSDB_CACHE_MODEL_BOTH);
+  run("ALTER DATABASE test CACHEMODEL 'both'");
+  clearAlterDbReq();
+
+  initAlterDb("test");
+  setAlterDbCacheSize(1);
+  run("ALTER DATABASE test CACHESIZE 1");
+  setAlterDbCacheSize(64);
+  run("ALTER DATABASE test CACHESIZE 64");
+  setAlterDbCacheSize(65536);
+  run("ALTER DATABASE test CACHESIZE 65536");
+  clearAlterDbReq();
+
+  initAlterDb("test");
+  setAlterDbFsync(0);
+  run("ALTER DATABASE test FSYNC 0");
+  setAlterDbFsync(1000);
+  run("ALTER DATABASE test FSYNC 1000");
+  setAlterDbFsync(180000);
+  run("ALTER DATABASE test FSYNC 180000");
+  clearAlterDbReq();
+
+  initAlterDb("test");
+  setAlterDbKeep(1 * MINUTE_PER_DAY);
+  run("ALTER DATABASE test KEEP 1");
+  setAlterDbKeep(30 * MINUTE_PER_DAY);
+  run("ALTER DATABASE test KEEP 30");
+  setAlterDbKeep(365000 * MINUTE_PER_DAY);
+  run("ALTER DATABASE test KEEP 365000");
+  setAlterDbKeep(1440);
+  run("ALTER DATABASE test KEEP 1440m");
+  setAlterDbKeep(14400);
+  run("ALTER DATABASE test KEEP 14400m");
+  setAlterDbKeep(525600000);
+  run("ALTER DATABASE test KEEP 525600000m");
+  setAlterDbKeep(5 * MINUTE_PER_DAY, 35 * MINUTE_PER_DAY, 500 * MINUTE_PER_DAY);
+  run("ALTER DATABASE test KEEP 5,35,500");
+  setAlterDbKeep(14400, 2400 * MINUTE_PER_HOUR, 1500 * MINUTE_PER_DAY);
+  run("ALTER DATABASE test KEEP 14400m,2400h,1500d");
+  clearAlterDbReq();
+
+  initAlterDb("test");
+  setAlterDbWal(1);
+  run("ALTER DATABASE test WAL 1");
+  setAlterDbWal(2);
+  run("ALTER DATABASE test WAL 2");
+  clearAlterDbReq();
+}
+
+TEST_F(ParserInitialATest, alterDatabaseSemanticCheck) {
+  useDb("root", "test");
 
-  run("ALTER DATABASE test KEEP 2400");
+  run("ALTER DATABASE test CACHEMODEL 'other'", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test CACHESIZE 0", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test CACHESIZE 65537", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  // The syntax limits it to only positive numbers
+  run("ALTER DATABASE test FSYNC -1", TSDB_CODE_PAR_SYNTAX_ERROR, PARSER_STAGE_PARSE);
+  run("ALTER DATABASE test FSYNC 180001", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test KEEP 0", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test KEEP 365001", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test KEEP 1000000000s", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test KEEP 1w", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test WAL 0", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("ALTER DATABASE test WAL 3", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  // Regardless of the specific sentence
+  run("ALTER DATABASE db WAL 0     # td-14436", TSDB_CODE_PAR_SYNTAX_ERROR, PARSER_STAGE_PARSE);
 }
 
+/*
+ * ALTER LOCAL dnode_id 'config' ['value']
+ */
 TEST_F(ParserInitialATest, alterLocal) {
   useDb("root", "test");
 
@@ -53,7 +248,7 @@ TEST_F(ParserInitialATest, alterLocal) {
     expect.second.clear();
   };
 
-  auto setAlterLocalFunc = [&](const char* pConfig, const char* pValue = nullptr) {
+  auto setAlterLocal = [&](const char* pConfig, const char* pValue = nullptr) {
     expect.first.assign(pConfig);
     if (nullptr != pValue) {
       expect.second.assign(pValue);
@@ -68,38 +263,37 @@ TEST_F(ParserInitialATest, alterLocal) {
     ASSERT_EQ(string(pStmt->value), expect.second);
   });
 
-  setAlterLocalFunc("resetlog");
+  setAlterLocal("resetlog");
   run("ALTER LOCAL 'resetlog'");
   clearAlterLocal();
 
-  setAlterLocalFunc("querypolicy", "2");
+  setAlterLocal("querypolicy", "2");
   run("ALTER LOCAL 'querypolicy' '2'");
   clearAlterLocal();
 }
 
 /*
- * ALTER TABLE [db_name.]tb_name alter_table_clause
+ * ALTER STABLE [db_name.]tb_name alter_table_clause
  *
  * alter_table_clause: {
  *     alter_table_options
  *   | ADD COLUMN col_name column_type
  *   | DROP COLUMN col_name
  *   | MODIFY COLUMN col_name column_type
- *   | RENAME COLUMN old_col_name new_col_name
- *   | ADD TAG tag_name tag_type
- *   | DROP TAG tag_name
- *   | MODIFY TAG tag_name tag_type
- *   | RENAME TAG old_tag_name new_tag_name
- *   | SET TAG tag_name = new_tag_value
- *   | ADD {FULLTEXT | SMA} INDEX index_name (col_name [, col_name] ...) [index_option]
+ *   | RENAME COLUMN old_col_name new_col_name  -- normal table
+ *   | ADD TAG tag_name tag_type                -- super table
+ *   | DROP TAG tag_name                        -- super table
+ *   | MODIFY TAG tag_name tag_type             -- super table
+ *   | RENAME TAG old_tag_name new_tag_name     -- super table
+ *   | SET TAG tag_name = new_tag_value         -- child table
  * }
  *
  * alter_table_options:
  *     alter_table_option ...
  *
  * alter_table_option: {
- *     TTL value
- *   | COMMENT 'string_value'
+ *    TTL int_value                             -- child/normal table
+ *  | COMMENT 'string_value'
  * }
  */
 TEST_F(ParserInitialATest, alterSTable) {
@@ -112,14 +306,12 @@ TEST_F(ParserInitialATest, alterSTable) {
     memset(&expect, 0, sizeof(SMAlterStbReq));
   };
 
-  auto setAlterStbReqFunc = [&](const char* pTbname, int8_t alterType, int32_t numOfFields = 0,
-                                const char* pField1Name = nullptr, int8_t field1Type = 0, int32_t field1Bytes = 0,
-                                const char* pField2Name = nullptr, const char* pComment = nullptr,
-                                int32_t ttl = TSDB_DEFAULT_TABLE_TTL) {
+  auto setAlterStbReq = [&](const char* pTbname, int8_t alterType, int32_t numOfFields = 0,
+                            const char* pField1Name = nullptr, int8_t field1Type = 0, int32_t field1Bytes = 0,
+                            const char* pField2Name = nullptr, const char* pComment = nullptr) {
     int32_t len = snprintf(expect.name, sizeof(expect.name), "0.test.%s", pTbname);
     expect.name[len] = '\0';
     expect.alterType = alterType;
-    //    expect.ttl = ttl;
     if (nullptr != pComment) {
       expect.comment = strdup(pComment);
       expect.commentLen = strlen(pComment);
@@ -178,59 +370,47 @@ TEST_F(ParserInitialATest, alterSTable) {
     tFreeSMAltertbReq(&req);
   });
 
-  //  setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_UPDATE_OPTIONS, 0, nullptr, 0, 0, nullptr, nullptr, 10);
-  //  run("ALTER STABLE st1 TTL 10");
-  //  clearAlterStbReq();
-
-  setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_UPDATE_OPTIONS, 0, nullptr, 0, 0, nullptr, "test");
+  setAlterStbReq("st1", TSDB_ALTER_TABLE_UPDATE_OPTIONS, 0, nullptr, 0, 0, nullptr, "test");
   run("ALTER STABLE st1 COMMENT 'test'");
   clearAlterStbReq();
 
-  setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_ADD_COLUMN, 1, "cc1", TSDB_DATA_TYPE_BIGINT);
+  setAlterStbReq("st1", TSDB_ALTER_TABLE_ADD_COLUMN, 1, "cc1", TSDB_DATA_TYPE_BIGINT);
   run("ALTER STABLE st1 ADD COLUMN cc1 BIGINT");
   clearAlterStbReq();
 
-  setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_DROP_COLUMN, 1, "c1");
+  setAlterStbReq("st1", TSDB_ALTER_TABLE_DROP_COLUMN, 1, "c1");
   run("ALTER STABLE st1 DROP COLUMN c1");
   clearAlterStbReq();
 
-  setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, 1, "c2", TSDB_DATA_TYPE_VARCHAR,
-                     30 + VARSTR_HEADER_SIZE);
+  setAlterStbReq("st1", TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, 1, "c2", TSDB_DATA_TYPE_VARCHAR, 30 + VARSTR_HEADER_SIZE);
   run("ALTER STABLE st1 MODIFY COLUMN c2 VARCHAR(30)");
   clearAlterStbReq();
 
-  // setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, 2, "c1", 0, 0, "cc1");
-  // run("ALTER STABLE st1 RENAME COLUMN c1 cc1");
-
-  setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_ADD_TAG, 1, "tag11", TSDB_DATA_TYPE_BIGINT);
+  setAlterStbReq("st1", TSDB_ALTER_TABLE_ADD_TAG, 1, "tag11", TSDB_DATA_TYPE_BIGINT);
   run("ALTER STABLE st1 ADD TAG tag11 BIGINT");
   clearAlterStbReq();
 
-  setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_DROP_TAG, 1, "tag1");
+  setAlterStbReq("st1", TSDB_ALTER_TABLE_DROP_TAG, 1, "tag1");
   run("ALTER STABLE st1 DROP TAG tag1");
   clearAlterStbReq();
 
-  setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, 1, "tag2", TSDB_DATA_TYPE_VARCHAR,
-                     30 + VARSTR_HEADER_SIZE);
+  setAlterStbReq("st1", TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, 1, "tag2", TSDB_DATA_TYPE_VARCHAR, 30 + VARSTR_HEADER_SIZE);
   run("ALTER STABLE st1 MODIFY TAG tag2 VARCHAR(30)");
   clearAlterStbReq();
 
-  setAlterStbReqFunc("st1", TSDB_ALTER_TABLE_UPDATE_TAG_NAME, 2, "tag1", 0, 0, "tag11");
+  setAlterStbReq("st1", TSDB_ALTER_TABLE_UPDATE_TAG_NAME, 2, "tag1", 0, 0, "tag11");
   run("ALTER STABLE st1 RENAME TAG tag1 tag11");
   clearAlterStbReq();
-
-  // todo
-  // ADD {FULLTEXT | SMA} INDEX index_name (col_name [, col_name] ...) [index_option]
 }
 
 TEST_F(ParserInitialATest, alterSTableSemanticCheck) {
   useDb("root", "test");
 
   run("ALTER STABLE st1 RENAME COLUMN c1 cc1", TSDB_CODE_PAR_INVALID_ALTER_TABLE);
-
   run("ALTER STABLE st1 MODIFY COLUMN c2 NCHAR(10)", TSDB_CODE_PAR_INVALID_MODIFY_COL);
-
   run("ALTER STABLE st1 MODIFY TAG tag2 NCHAR(10)", TSDB_CODE_PAR_INVALID_MODIFY_COL);
+  run("ALTER STABLE st1 SET TAG tag1 = 10", TSDB_CODE_PAR_INVALID_ALTER_TABLE);
+  run("ALTER STABLE st1 TTL 10", TSDB_CODE_PAR_INVALID_ALTER_TABLE);
 }
 
 TEST_F(ParserInitialATest, alterTable) {
@@ -246,8 +426,8 @@ TEST_F(ParserInitialATest, alterTable) {
     memset(&expect, 0, sizeof(SVAlterTbReq));
   };
 
-  auto setAlterColFunc = [&](const char* pTbname, int8_t alterType, const char* pColName, int8_t dataType = 0,
-                             int32_t dataBytes = 0, const char* pNewColName = nullptr) {
+  auto setAlterTableCol = [&](const char* pTbname, int8_t alterType, const char* pColName, int8_t dataType = 0,
+                              int32_t dataBytes = 0, const char* pNewColName = nullptr) {
     expect.tbName = strdup(pTbname);
     expect.action = alterType;
     expect.colName = strdup(pColName);
@@ -269,7 +449,7 @@ TEST_F(ParserInitialATest, alterTable) {
     }
   };
 
-  auto setAlterTagFunc = [&](const char* pTbname, const char* pTagName, uint8_t* pNewVal, uint32_t bytes) {
+  auto setAlterTableTag = [&](const char* pTbname, const char* pTagName, uint8_t* pNewVal, uint32_t bytes) {
     expect.tbName = strdup(pTbname);
     expect.action = TSDB_ALTER_TABLE_UPDATE_TAG_VAL;
     expect.tagName = strdup(pTagName);
@@ -279,7 +459,7 @@ TEST_F(ParserInitialATest, alterTable) {
     expect.pTagVal = pNewVal;
   };
 
-  auto setAlterOptionsFunc = [&](const char* pTbname, int32_t ttl, char* pComment = nullptr) {
+  auto setAlterTableOptions = [&](const char* pTbname, int32_t ttl, char* pComment = nullptr) {
     expect.tbName = strdup(pTbname);
     expect.action = TSDB_ALTER_TABLE_UPDATE_OPTIONS;
     if (-1 != ttl) {
@@ -335,47 +515,56 @@ TEST_F(ParserInitialATest, alterTable) {
     tDecoderClear(&coder);
   });
 
-  setAlterOptionsFunc("t1", 10, nullptr);
+  setAlterTableOptions("t1", 10, nullptr);
   run("ALTER TABLE t1 TTL 10");
   clearAlterTbReq();
 
-  setAlterOptionsFunc("t1", -1, (char*)"test");
+  setAlterTableOptions("t1", -1, (char*)"test");
   run("ALTER TABLE t1 COMMENT 'test'");
   clearAlterTbReq();
 
-  setAlterColFunc("t1", TSDB_ALTER_TABLE_ADD_COLUMN, "cc1", TSDB_DATA_TYPE_BIGINT);
+  setAlterTableCol("t1", TSDB_ALTER_TABLE_ADD_COLUMN, "cc1", TSDB_DATA_TYPE_BIGINT);
   run("ALTER TABLE t1 ADD COLUMN cc1 BIGINT");
   clearAlterTbReq();
 
-  setAlterColFunc("t1", TSDB_ALTER_TABLE_DROP_COLUMN, "c1");
+  setAlterTableCol("t1", TSDB_ALTER_TABLE_DROP_COLUMN, "c1");
   run("ALTER TABLE t1 DROP COLUMN c1");
   clearAlterTbReq();
 
-  setAlterColFunc("t1", TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, "c2", TSDB_DATA_TYPE_VARCHAR, 30 + VARSTR_HEADER_SIZE);
+  setAlterTableCol("t1", TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, "c2", TSDB_DATA_TYPE_VARCHAR, 30 + VARSTR_HEADER_SIZE);
   run("ALTER TABLE t1 MODIFY COLUMN c2 VARCHAR(30)");
   clearAlterTbReq();
 
-  setAlterColFunc("t1", TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, "c1", 0, 0, "cc1");
+  setAlterTableCol("t1", TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, "c1", 0, 0, "cc1");
   run("ALTER TABLE t1 RENAME COLUMN c1 cc1");
   clearAlterTbReq();
 
   int32_t val = 10;
-  setAlterTagFunc("st1s1", "tag1", (uint8_t*)&val, sizeof(val));
+  setAlterTableTag("st1s1", "tag1", (uint8_t*)&val, sizeof(val));
   run("ALTER TABLE st1s1 SET TAG tag1=10");
   clearAlterTbReq();
-
-  // todo
-  // ADD {FULLTEXT | SMA} INDEX index_name (col_name [, col_name] ...) [index_option]
 }
 
 TEST_F(ParserInitialATest, alterTableSemanticCheck) {
   useDb("root", "test");
 
   run("ALTER TABLE st1s1 RENAME COLUMN c1 cc1", TSDB_CODE_PAR_INVALID_ALTER_TABLE);
-
+  run("ALTER TABLE st1s1 ADD TAG tag11 BIGINT", TSDB_CODE_PAR_INVALID_ALTER_TABLE);
+  run("ALTER TABLE st1s1 DROP TAG tag1", TSDB_CODE_PAR_INVALID_ALTER_TABLE);
+  run("ALTER TABLE st1s1 MODIFY TAG tag2 VARCHAR(30)", TSDB_CODE_PAR_INVALID_ALTER_TABLE);
+  run("ALTER TABLE st1s1 RENAME TAG tag1 tag11", TSDB_CODE_PAR_INVALID_ALTER_TABLE);
   run("ALTER TABLE st1s1 SET TAG tag2 =  '123456789012345678901'", TSDB_CODE_PAR_WRONG_VALUE_TYPE);
 }
 
+/*
+ * ALTER USER user_name PASS str_value
+ *
+ * alter_user_clause: {
+ *    PASS str_value
+ *  | ENABLE int_value
+ *  | SYSINFO int_value
+ * }
+ */
 TEST_F(ParserInitialATest, alterUser) {
   useDb("root", "test");
 
@@ -423,6 +612,9 @@ TEST_F(ParserInitialATest, alterUser) {
   clearAlterUserReq();
 }
 
+/*
+ * BALANCE VGROUP
+ */
 TEST_F(ParserInitialATest, balanceVgroup) {
   useDb("root", "test");
 
@@ -436,10 +628,4 @@ TEST_F(ParserInitialATest, balanceVgroup) {
   run("BALANCE VGROUP");
 }
 
-TEST_F(ParserInitialATest, bug001) {
-  useDb("root", "test");
-
-  run("ALTER DATABASE db WAL 0     # td-14436", TSDB_CODE_PAR_SYNTAX_ERROR, PARSER_STAGE_PARSE);
-}
-
 }  // namespace ParserTest
\ No newline at end of file

source/libs/parser/test/parInitialCTest.cpp

@@ -236,12 +236,12 @@ TEST_F(ParserInitialCTest, createDatabase) {
 TEST_F(ParserInitialCTest, createDatabaseSemanticCheck) {
   useDb("root", "test");
 
-  run("create database db2 retentions 0s:1d", TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION);
-  run("create database db2 retentions 10s:0d", TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION);
-  run("create database db2 retentions 1w:1d", TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION);
-  run("create database db2 retentions 1w:1n", TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION);
-  run("create database db2 retentions 15s:7d,15m:21d,10m:500d", TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION);
-  run("create database db2 retentions 15s:7d,5m:21d,10m:10d", TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION);
+  run("create database db2 retentions 0s:1d", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("create database db2 retentions 10s:0d", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("create database db2 retentions 1w:1d", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("create database db2 retentions 1w:1n", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("create database db2 retentions 15s:7d,15m:21d,10m:500d", TSDB_CODE_PAR_INVALID_DB_OPTION);
+  run("create database db2 retentions 15s:7d,5m:21d,10m:10d", TSDB_CODE_PAR_INVALID_DB_OPTION);
 }
 
 TEST_F(ParserInitialCTest, createDnode) {
@@ -514,13 +514,13 @@ TEST_F(ParserInitialCTest, createStableSemanticCheck) {
   useDb("root", "test");
 
   run("CREATE STABLE rollup_db.stb2 (ts TIMESTAMP, c1 INT) TAGS (tag1 INT) ROLLUP(CEIL)",
-      TSDB_CODE_PAR_INVALID_ROLLUP_OPTION);
+      TSDB_CODE_PAR_INVALID_TABLE_OPTION);
 
   run("CREATE STABLE rollup_db.stb2 (ts TIMESTAMP, c1 INT) TAGS (tag1 INT) ROLLUP(MAX) MAX_DELAY 0s WATERMARK 1m",
-      TSDB_CODE_PAR_INVALID_RANGE_OPTION);
+      TSDB_CODE_PAR_INVALID_TABLE_OPTION);
 
   run("CREATE STABLE rollup_db.stb2 (ts TIMESTAMP, c1 INT) TAGS (tag1 INT) ROLLUP(MAX) MAX_DELAY 10s WATERMARK 18m",
-      TSDB_CODE_PAR_INVALID_RANGE_OPTION);
+      TSDB_CODE_PAR_INVALID_TABLE_OPTION);
 }
 
 TEST_F(ParserInitialCTest, createStream) {

source/libs/parser/test/parTestUtil.cpp

@@ -192,7 +192,7 @@ class ParserTestBaseImpl {
 
   void setParseContext(const string& sql, SParseContext* pCxt, bool async = false) {
     stmtEnv_.sql_ = sql;
-    transform(stmtEnv_.sql_.begin(), stmtEnv_.sql_.end(), stmtEnv_.sql_.begin(), ::tolower);
+    strtolower((char*)stmtEnv_.sql_.c_str(), sql.c_str());
 
     pCxt->acctId = atoi(caseEnv_.acctId_.c_str());
     pCxt->db = caseEnv_.db_.c_str();

source/libs/scalar/src/filter.c

@@ -3682,6 +3682,10 @@ EDealRes fltReviseRewriter(SNode** pNode, void* pContext) {
       if (OP_TYPE_IN != node->opType) {
         SColumnNode *refNode = (SColumnNode *)node->pLeft;
         SValueNode *valueNode = (SValueNode *)node->pRight;
+        if (FILTER_GET_FLAG(stat->info->options, FLT_OPTION_TIMESTAMP) 
+            && TSDB_DATA_TYPE_UBIGINT == valueNode->node.resType.type && valueNode->datum.u <= INT64_MAX) {
+          valueNode->node.resType.type = TSDB_DATA_TYPE_BIGINT;
+        }
         int32_t type = vectorGetConvertType(refNode->node.resType.type, valueNode->node.resType.type);
         if (0 != type && type != refNode->node.resType.type) {
           stat->scalarMode = true;

source/util/src/terror.c

@@ -501,19 +501,9 @@ TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INTER_VALUE_TOO_SMALL,     "Interval too small")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_DB_NOT_SPECIFIED,          "Database not specified")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_IDENTIFIER_NAME,   "Invalid identifier name")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_CORRESPONDING_STABLE_ERR,  "Corresponding super table not in this db")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_RANGE_OPTION,      "Invalid option")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_STR_OPTION,        "Invalid option")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_ENUM_OPTION,       "Invalid option")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_KEEP_NUM,          "Invalid number of keep options")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_KEEP_ORDER,        "Invalid keep value, should be keep0 <= keep1 <= keep2")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_KEEP_VALUE,        "Invalid option keep")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_COMMENT_OPTION,    "Invalid option comment")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_F_RANGE_OPTION,    "Invalid option")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_ROLLUP_OPTION,     "Invalid option rollup: only one function is allowed")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_RETENTIONS_OPTION, "Invalid option retentions")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_DB_OPTION,         "Invalid database option")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TABLE_OPTION,      "Invalid table option")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_GROUPBY_WINDOW_COEXIST,    "GROUP BY and WINDOW-clause can't be used together")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_OPTION_UNIT,       "Invalid option unit: only m, h, d allowed")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_KEEP_UNIT,         "Invalid option keep unit: only m, h, d allowed")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_AGG_FUNC_NESTING,          "Aggregate functions do not support nesting")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_STATE_WIN_TYPE,    "Only support STATE_WINDOW on integer/bool/varchar column")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_STATE_WIN_COL,     "Not support STATE_WINDOW on tag column")