conflict resolve

cmake/define.inc

@@ -83,6 +83,8 @@ IF (TD_ARM_64)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "arm64 is defined")
   SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
 ENDIF ()
 
 IF (TD_ARM_32)
@@ -91,6 +93,8 @@ IF (TD_ARM_32)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "arm32 is defined")
   SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast -Wno-incompatible-pointer-types ")
+
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
 ENDIF ()
 
 IF (TD_MIPS_64)
@@ -143,6 +147,7 @@ IF (TD_LINUX)
 
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lz4/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
 ENDIF ()
 
 IF (TD_DARWIN_64)
@@ -164,6 +169,7 @@ IF (TD_DARWIN_64)
   SET(RELEASE_FLAGS "-Og")
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lz4/inc)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
 ENDIF ()
 
 IF (TD_WINDOWS)
@@ -194,6 +200,7 @@ IF (TD_WINDOWS)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/regex)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/wepoll/inc)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/MsvcLibX/include)
+  INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/lua/src)
 ENDIF ()
 
 IF (TD_WINDOWS_64)

src/client/CMakeLists.txt

@@ -37,13 +37,13 @@ ELSEIF (TD_DARWIN)
 
   # set the static lib name
   ADD_LIBRARY(taos_static STATIC ${SRC})
-  TARGET_LINK_LIBRARIES(taos_static common query trpc tutil pthread m)
+  TARGET_LINK_LIBRARIES(taos_static common query trpc tutil pthread m lua)
   SET_TARGET_PROPERTIES(taos_static PROPERTIES OUTPUT_NAME "taos_static")
   SET_TARGET_PROPERTIES(taos_static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
 
   # generate dynamic library (*.dylib)
   ADD_LIBRARY(taos SHARED ${SRC})
-  TARGET_LINK_LIBRARIES(taos common query trpc tutil pthread m)
+  TARGET_LINK_LIBRARIES(taos common query trpc tutil pthread m lua)
   SET_TARGET_PROPERTIES(taos PROPERTIES CLEAN_DIRECT_OUTPUT 1)
 
   #set version of .dylib
@@ -68,19 +68,19 @@ ELSEIF (TD_WINDOWS)
   IF (NOT TD_GODLL)
     SET_TARGET_PROPERTIES(taos PROPERTIES LINK_FLAGS /DEF:${TD_COMMUNITY_DIR}/src/client/src/taos.def)
   ENDIF ()
-  TARGET_LINK_LIBRARIES(taos trpc tutil query)
+  TARGET_LINK_LIBRARIES(taos trpc tutil query lua)
 
 ELSEIF (TD_DARWIN)
   SET(CMAKE_MACOSX_RPATH 1)
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/jni/linux)
 
   ADD_LIBRARY(taos_static STATIC ${SRC})
-  TARGET_LINK_LIBRARIES(taos_static query trpc tutil pthread m)
+  TARGET_LINK_LIBRARIES(taos_static query trpc tutil pthread m lua)
   SET_TARGET_PROPERTIES(taos_static PROPERTIES OUTPUT_NAME "taos_static")
 
   # generate dynamic library (*.dylib)
   ADD_LIBRARY(taos SHARED ${SRC})
-  TARGET_LINK_LIBRARIES(taos query trpc tutil pthread m)
+  TARGET_LINK_LIBRARIES(taos query trpc tutil pthread m lua)
 
   SET_TARGET_PROPERTIES(taos PROPERTIES CLEAN_DIRECT_OUTPUT 1)
 

src/client/inc/tscUtil.h

@@ -117,6 +117,7 @@ SParamInfo* tscAddParamToDataBlock(STableDataBlocks* pDataBlock, char type, uint
                                    uint32_t offset);
 
 void*   tscDestroyBlockArrayList(SArray* pDataBlockList);
+void*  tscDestroyUdfArrayList(SArray* pUdfList);
 void*   tscDestroyBlockHashTable(SHashObj* pBlockHashTable, bool removeMeta);
 
 int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock);
@@ -271,6 +272,7 @@ void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo);
 int  tscGetSTableVgroupInfo(SSqlObj* pSql, SQueryInfo* pQueryInfo);
 int  tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
 int  tscGetTableMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
+int32_t tscGetUdfFromNode(SSqlObj *pSql, SQueryInfo* pQueryInfo);
 
 void tscResetForNextRetrieve(SSqlRes* pRes);
 void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo);
@@ -320,7 +322,7 @@ void tscTryQueryNextVnode(SSqlObj *pSql, __async_cb_func_t fp);
 void tscAsyncQuerySingleRowForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
 void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp);
 int  tscSetMgmtEpSetFromCfg(const char *first, const char *second, SRpcCorEpSet *corEpSet);
-int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, __async_cb_func_t fp);
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, SArray* pUdfList, __async_cb_func_t fp);
 
 int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length, SArray* pNameArray);
 

src/client/inc/tsclient.h

@@ -177,6 +177,7 @@ typedef struct {
   SInsertStatementParam insertParam;
   char    reserve1[3];        // fix bus error on arm32
   int32_t count;   // todo remove it
+  bool    subCmd;
 
   char         reserve2[3];        // fix bus error on arm32
   int16_t      numOfCols;

src/client/src/tscGlobalmerge.c

@@ -602,6 +602,15 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
           if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
             continue;
           }
+
+          if (functionId < 0) {
+            SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
+
+            doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
+
+            continue;
+          }
+
           aAggs[functionId].mergeFunc(&pCtx[j]);
         }
       } else {
@@ -610,6 +619,15 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
           if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
             continue;
           }
+
+          if (functionId < 0) {
+            SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
+
+            doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
+
+            continue;
+          }
+
           aAggs[functionId].xFinalize(&pCtx[j]);
         }
 
@@ -626,7 +644,11 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
         }
 
         for(int32_t j = 0; j < numOfExpr; ++j) {
-          aAggs[pCtx[j].functionId].init(&pCtx[j]);
+          if (pCtx[j].functionId < 0) {
+            continue;
+          }
+
+          aAggs[pCtx[j].functionId].init(&pCtx[j], pCtx[j].resultInfo);
         }
 
         for (int32_t j = 0; j < numOfExpr; ++j) {
@@ -638,6 +660,15 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
           if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
             continue;
           }
+
+          if (functionId < 0) {
+            SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
+
+            doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
+
+            continue;
+          }
+
           aAggs[functionId].mergeFunc(&pCtx[j]);
         }
       }
@@ -651,6 +682,15 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
         if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
           continue;
         }
+
+        if (functionId < 0) {
+          SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
+
+          doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
+
+          continue;
+        }
+
         aAggs[functionId].mergeFunc(&pCtx[j]);
       }
     }
@@ -871,7 +911,6 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
 
   {
     if (pAggInfo->hasDataBlockForNewGroup) {
-      pAggInfo->binfo.pRes->info.rows = 0;
       pAggInfo->hasPrev = false; // now we start from a new group data set.
 
       // not belongs to the same group, return the result of current group;
@@ -880,7 +919,13 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
 
       { // reset output buffer
         for(int32_t j = 0; j < pOperator->numOfOutput; ++j) {
-          aAggs[pAggInfo->binfo.pCtx[j].functionId].init(&pAggInfo->binfo.pCtx[j]);
+          SQLFunctionCtx* pCtx = &pAggInfo->binfo.pCtx[j];
+          if (pCtx->functionId < 0) {
+            clearOutputBuf(&pAggInfo->binfo, &pAggInfo->bufCapacity);
+            continue;
+          }
+
+          aAggs[pCtx->functionId].init(pCtx, pCtx->resultInfo);
         }
       }
 
@@ -933,6 +978,14 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
         continue;
       }
 
+      if (functionId < 0) {
+        SUdfInfo* pUdfInfo = taosArrayGet(pAggInfo->udfInfo, -1 * functionId - 1);
+
+        doInvokeUdf(pUdfInfo, &pAggInfo->binfo.pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
+
+        continue;
+      }
+
       aAggs[functionId].xFinalize(&pAggInfo->binfo.pCtx[j]);
     }
 

src/client/src/tscSQLParser.c

@@ -37,6 +37,7 @@
 #include "tstrbuild.h"
 #include "ttoken.h"
 #include "ttokendef.h"
+#include "qScript.h"
 #include "ttype.h"
 
 #define DEFAULT_PRIMARY_TIMESTAMP_COL_NAME "_c0"
@@ -77,7 +78,8 @@ static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pC
 static int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStrToken* tableName, int32_t* len);
 static void getColumnName(tSqlExprItem* pItem, char* resultFieldName, char* rawName, int32_t nameLength);
 
-static int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t colIndex, tSqlExprItem* pItem, bool finalResult);
+static int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t colIndex, tSqlExprItem* pItem,
+    bool finalResult, SUdfInfo* pUdfInfo);
 static int32_t insertResultField(SQueryInfo* pQueryInfo, int32_t outputIndex, SColumnList* pIdList, int16_t bytes,
                                  int8_t type, char* fieldName, SExprInfo* pSqlExpr);
 
@@ -386,6 +388,137 @@ static int32_t normalizeVarDataTypeLength(SSqlCmd* pCmd) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t readFromFile(char *name, uint32_t *len, void **buf) {
+  struct stat fileStat;
+  if (stat(name, &fileStat) < 0) {
+    tscError("stat file %s failed, error:%s", name, strerror(errno));
+    return TAOS_SYSTEM_ERROR(errno);
+  }
+
+  *len = fileStat.st_size;
+
+  if (*len <= 0) {
+    tscError("file %s is empty", name);
+    return TSDB_CODE_TSC_FILE_EMPTY;
+  }
+
+  *buf = calloc(1, *len);
+  if (*buf == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  int fd = open(name, O_RDONLY);
+  if (fd < 0) {
+    tscError("open file %s failed, error:%s", name, strerror(errno));
+    tfree(*buf);
+    return TAOS_SYSTEM_ERROR(errno);
+  }
+
+  int64_t s = taosRead(fd, *buf, *len);
+  if (s != *len) {
+    tscError("read file %s failed, error:%s", name, strerror(errno));
+    close(fd);
+    tfree(*buf);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t handleUserDefinedFunc(SSqlObj* pSql, struct SSqlInfo* pInfo) {
+  const char *msg1 = "function name is too long";
+  const char *msg2 = "path is too long";
+  const char *msg3 = "invalid outputtype";
+  const char *msg4 = "invalid script";
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  switch (pInfo->type) {
+    case TSDB_SQL_CREATE_FUNCTION: {
+      SCreateFuncInfo *createInfo = &pInfo->pMiscInfo->funcOpt;
+      uint32_t len = 0;
+      void *buf = NULL;
+
+      if (createInfo->output.type == (uint8_t)-1 || createInfo->output.bytes < 0) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      }
+
+      createInfo->name.z[createInfo->name.n] = 0;
+
+      strdequote(createInfo->name.z);
+
+      if (strlen(createInfo->name.z) >= TSDB_FUNC_NAME_LEN) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      }
+
+      createInfo->path.z[createInfo->path.n] = 0;
+
+      strdequote(createInfo->path.z);
+
+      if (strlen(createInfo->path.z) >= PATH_MAX) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      }
+
+      int32_t ret = readFromFile(createInfo->path.z, &len, &buf);
+      if (ret) {
+        return ret;
+      }
+      //distinguish  *.lua and *.so
+      int32_t pathLen = (int32_t)strlen(createInfo->path.z);
+      if ((pathLen > 3) && (0 == strncmp(createInfo->path.z + pathLen - 3, "lua", 3)) && !isValidScript(buf, len)) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
+      }
+
+      //TODO CHECK CODE
+      if (len + sizeof(SCreateFuncMsg) > pSql->cmd.allocSize) {
+        ret = tscAllocPayload(&pSql->cmd, len + sizeof(SCreateFuncMsg));
+        if (ret) {
+          tfree(buf);
+          return ret;
+        }
+      }
+
+      SCreateFuncMsg *pMsg = (SCreateFuncMsg *)pSql->cmd.payload;
+
+      strcpy(pMsg->name, createInfo->name.z);
+      strcpy(pMsg->path, createInfo->path.z);
+
+      pMsg->funcType = htonl(createInfo->type);
+      pMsg->bufSize = htonl(createInfo->bufSize);
+
+      pMsg->outputType = createInfo->output.type;
+      pMsg->outputLen = htons(createInfo->output.bytes);
+
+      pMsg->codeLen = htonl(len);
+      memcpy(pMsg->code, buf, len);
+      tfree(buf);
+
+      break;
+    }
+    case TSDB_SQL_DROP_FUNCTION: {
+      SStrToken* t0 = taosArrayGet(pInfo->pMiscInfo->a, 0);
+
+      SDropFuncMsg *pMsg = (SDropFuncMsg *)pSql->cmd.payload;
+
+      t0->z[t0->n] = 0;
+
+      strdequote(t0->z);
+
+      if (strlen(t0->z) >= TSDB_FUNC_NAME_LEN) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      }
+
+      strcpy(pMsg->name, t0->z);
+
+      break;
+    }
+    default:
+      return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   if (pInfo == NULL || pSql == NULL) {
     return TSDB_CODE_TSC_APP_ERROR;
@@ -486,6 +619,16 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       break;
     }
 
+    case TSDB_SQL_CREATE_FUNCTION:
+    case TSDB_SQL_DROP_FUNCTION:  {
+      code = handleUserDefinedFunc(pSql, pInfo);
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
+      }
+
+      break;
+    }
+
     case TSDB_SQL_ALTER_DB:
     case TSDB_SQL_CREATE_DB: {
       const char* msg1 = "invalid db name";
@@ -769,7 +912,15 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
             return code;
           }
 
+          SArray *pUdfInfo = NULL;
+          if (pQueryInfo->pUdfInfo) {
+            pUdfInfo = taosArrayDup(pQueryInfo->pUdfInfo);
+          }
+
           pQueryInfo = pCmd->active;
+          pQueryInfo->pUdfInfo = pUdfInfo;
+          pQueryInfo->udfCopy = true;
+
         }
       }
 
@@ -1813,6 +1964,69 @@ static bool hasNoneUserDefineExpr(SQueryInfo* pQueryInfo) {
   return false;
 }
 
+void genUdfList(SArray* pUdfInfo, tSqlExpr *pNode) {
+  if (pNode == NULL) {
+    return;
+  }
+
+  if (pNode->type == SQL_NODE_EXPR) {
+    genUdfList(pUdfInfo, pNode->pLeft);
+    genUdfList(pUdfInfo, pNode->pRight);
+    return;
+  }
+
+  if (pNode->type == SQL_NODE_SQLFUNCTION) {
+    pNode->functionId = isValidFunction(pNode->Expr.operand.z, pNode->Expr.operand.n);
+    if (pNode->functionId < 0) { // extract all possible user defined function
+      struct SUdfInfo info = {0};
+      info.name = strndup(pNode->Expr.operand.z, pNode->Expr.operand.n);
+      int32_t functionId = (int32_t)taosArrayGetSize(pUdfInfo) * (-1) - 1;
+      info.functionId = functionId;
+
+      taosArrayPush(pUdfInfo, &info);
+    }
+  }
+}
+
+/*
+static int32_t checkForUdf(SSqlObj* pSql, SQueryInfo* pQueryInfo, SArray* pSelection) {
+  if (pQueryInfo->pUdfInfo != NULL) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  pQueryInfo->pUdfInfo = taosArrayInit(4, sizeof(struct SUdfInfo));
+
+  size_t nExpr = taosArrayGetSize(pSelection);
+
+  for (int32_t i = 0; i < nExpr; ++i) {
+    tSqlExprItem* pItem = taosArrayGet(pSelection, i);
+
+    int32_t type = pItem->pNode->type;
+    if (type == SQL_NODE_EXPR || type == SQL_NODE_SQLFUNCTION) {
+      genUdfList(pQueryInfo->pUdfInfo, pItem->pNode);
+    }
+  }
+
+  if (taosArrayGetSize(pQueryInfo->pUdfInfo) > 0) {
+    return tscGetUdfFromNode(pSql, pQueryInfo);
+  } else {
+    return TSDB_CODE_SUCCESS;
+  }
+}
+*/
+
+static SUdfInfo* isValidUdf(SArray* pUdfInfo, const char* name, int32_t len) {
+  size_t t = taosArrayGetSize(pUdfInfo);
+  for(int32_t i = 0; i < t; ++i) {
+    SUdfInfo* pUdf = taosArrayGet(pUdfInfo, i);
+    if (strlen(pUdf->name) == len && strncasecmp(pUdf->name, name, len) == 0) {
+      return pUdf;
+    }
+  }
+
+  return NULL;
+}
+
 int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelNodeList, bool joinQuery,
                                bool timeWindowQuery, bool outerQuery) {
   assert(pSelNodeList != NULL && pCmd != NULL);
@@ -1845,12 +2059,18 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
     int32_t type = pItem->pNode->type;
     if (type == SQL_NODE_SQLFUNCTION) {
       pItem->pNode->functionId = isValidFunction(pItem->pNode->Expr.operand.z, pItem->pNode->Expr.operand.n);
+      SUdfInfo* pUdfInfo = NULL;
       if (pItem->pNode->functionId < 0) {
+        pUdfInfo = isValidUdf(pQueryInfo->pUdfInfo, pItem->pNode->Expr.operand.z, pItem->pNode->Expr.operand.n);
+        if (pUdfInfo == NULL) {
           return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
         }
 
+        pItem->pNode->functionId = pUdfInfo->functionId;
+      }
+
       // sql function in selection clause, append sql function info in pSqlCmd structure sequentially
-      if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, pItem, true) != TSDB_CODE_SUCCESS) {
+      if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, pItem, true, pUdfInfo) != TSDB_CODE_SUCCESS) {
         return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     } else if (type == SQL_NODE_TABLE_COLUMN || type == SQL_NODE_VALUE) {
@@ -2105,7 +2325,8 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
 }
 
 static int32_t setExprInfoForFunctions(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSchema* pSchema, SConvertFunc cvtFunc,
-                                       const char* name, int32_t resColIdx, SColumnIndex* pColIndex, bool finalResult) {
+                                       const char* name, int32_t resColIdx, SColumnIndex* pColIndex, bool finalResult,
+                                       SUdfInfo* pUdfInfo) {
   const char* msg1 = "not support column types";
 
   int32_t f = cvtFunc.execFuncId;
@@ -2121,7 +2342,7 @@ static int32_t setExprInfoForFunctions(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SS
   int16_t resBytes = 0;
   int32_t interBufSize = 0;
 
-  getResultDataInfo(pSchema->type, pSchema->bytes, f, 0, &resType, &resBytes, &interBufSize, 0, false);
+  getResultDataInfo(pSchema->type, pSchema->bytes, f, 0, &resType, &resBytes, &interBufSize, 0, false, pUdfInfo);
   SExprInfo* pExpr = tscExprAppend(pQueryInfo, f, pColIndex, resType, resBytes, getNewResColId(pCmd), interBufSize, false);
   tstrncpy(pExpr->base.aliasName, name, tListLen(pExpr->base.aliasName));
 
@@ -2193,18 +2414,19 @@ static void updateLastScanOrderIfNeeded(SQueryInfo* pQueryInfo) {
   }
 }
 
-static UNUSED_FUNC void updateFunctionInterBuf(SQueryInfo* pQueryInfo, bool superTable) {
+static UNUSED_FUNC void updateFunctionInterBuf(SQueryInfo* pQueryInfo, bool superTable, SUdfInfo* pUdfInfo) {
   size_t numOfExpr = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < numOfExpr; ++i) {
     SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
 
     int32_t param = (int32_t)pExpr->base.param[0].i64;
     getResultDataInfo(pExpr->base.colType, pExpr->base.colBytes, pExpr->base.functionId, param, &pExpr->base.resType, &pExpr->base.resBytes,
-                      &pExpr->base.interBytes, 0, superTable);
+                      &pExpr->base.interBytes, 0, superTable, pUdfInfo);
   }
 }
 
-int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t colIndex, tSqlExprItem* pItem, bool finalResult) {
+int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t colIndex, tSqlExprItem* pItem, bool finalResult,
+    SUdfInfo* pUdfInfo) {
   STableMetaInfo* pTableMetaInfo = NULL;
   int32_t functionId = pItem->pNode->functionId;
 
@@ -2353,7 +2575,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       int32_t intermediateResSize = 0;
 
       if (getResultDataInfo(pSchema->type, pSchema->bytes, functionId, 0, &resultType, &resultSize,
-                            &intermediateResSize, 0, false) != TSDB_CODE_SUCCESS) {
+                            &intermediateResSize, 0, false, NULL) != TSDB_CODE_SUCCESS) {
         return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
@@ -2487,7 +2709,8 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
               SStrToken t = {.z = pSchema[j].name, .n = (uint32_t)strnlen(pSchema[j].name, TSDB_COL_NAME_LEN)};
               setResultColName(name, pItem, cvtFunc.originFuncId, &t, true);
 
-              if (setExprInfoForFunctions(pCmd, pQueryInfo, &pSchema[j], cvtFunc, name, colIndex++, &index, finalResult) != 0) {
+              if (setExprInfoForFunctions(pCmd, pQueryInfo, &pSchema[j], cvtFunc, name, colIndex++, &index,
+                  finalResult, pUdfInfo) != 0) {
                 return TSDB_CODE_TSC_INVALID_OPERATION;
               }
             }
@@ -2510,7 +2733,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
             bool multiColOutput = taosArrayGetSize(pItem->pNode->Expr.paramList) > 1;
             setResultColName(name, pItem, cvtFunc.originFuncId, &pParamElem->pNode->columnName, multiColOutput);
 
-            if (setExprInfoForFunctions(pCmd, pQueryInfo, pSchema, cvtFunc, name, colIndex++, &index, finalResult) != 0) {
+            if (setExprInfoForFunctions(pCmd, pQueryInfo, pSchema, cvtFunc, name, colIndex++, &index, finalResult, pUdfInfo) != 0) {
               return TSDB_CODE_TSC_INVALID_OPERATION;
             }
           }
@@ -2535,7 +2758,8 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
             SStrToken t = {.z = pSchema[i].name, .n = (uint32_t)strnlen(pSchema[i].name, TSDB_COL_NAME_LEN)};
             setResultColName(name, pItem, cvtFunc.originFuncId, &t, true);
 
-            if (setExprInfoForFunctions(pCmd, pQueryInfo, &pSchema[index.columnIndex], cvtFunc, name, colIndex, &index, finalResult) != 0) {
+            if (setExprInfoForFunctions(pCmd, pQueryInfo, &pSchema[index.columnIndex], cvtFunc, name, colIndex, &index,
+                finalResult, pUdfInfo) != 0) {
               return TSDB_CODE_TSC_INVALID_OPERATION;
             }
             colIndex++;
@@ -2606,7 +2830,8 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
           return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
         }
 
-        getResultDataInfo(pSchema->type, pSchema->bytes, functionId, 0, &resultType, &resultSize, &interResult, 0, false);
+        getResultDataInfo(pSchema->type, pSchema->bytes, functionId, 0, &resultType, &resultSize, &interResult, 0, false,
+            pUdfInfo);
 
         /*
          * sql function transformation
@@ -2719,7 +2944,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       int16_t type  = 0;
       int32_t inter = 0;
 
-      int32_t ret = getResultDataInfo(s.type, s.bytes, TSDB_FUNC_TID_TAG, 0, &type, &bytes, &inter, 0, 0);
+      int32_t ret = getResultDataInfo(s.type, s.bytes, TSDB_FUNC_TID_TAG, 0, &type, &bytes, &inter, 0, 0, NULL);
       assert(ret == TSDB_CODE_SUCCESS);
       
       s.type = (uint8_t)type;
@@ -2743,7 +2968,8 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       int32_t inter   = 0;
       int16_t resType = 0;
       int16_t bytes   = 0;
-      getResultDataInfo(TSDB_DATA_TYPE_INT, 4, TSDB_FUNC_BLKINFO, 0, &resType, &bytes, &inter, 0, 0);
+
+      getResultDataInfo(TSDB_DATA_TYPE_INT, 4, TSDB_FUNC_BLKINFO, 0, &resType, &bytes, &inter, 0, 0, NULL);
 
       SSchema s = {.name = "block_dist", .type = TSDB_DATA_TYPE_BINARY, .bytes = bytes};
 
@@ -2761,10 +2987,64 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       return TSDB_CODE_SUCCESS;
     }
 
-    default:
-      return TSDB_CODE_TSC_INVALID_OPERATION;
+    default: {
+      pUdfInfo = isValidUdf(pQueryInfo->pUdfInfo, pItem->pNode->Expr.operand.z, pItem->pNode->Expr.operand.n);
+      if (pUdfInfo == NULL) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
+      }
+
+      tSqlExprItem* pParamElem = taosArrayGet(pItem->pNode->Expr.paramList, 0);;
+      if (pParamElem->pNode->tokenId != TK_ID) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      }
+
+      SColumnIndex index = COLUMN_INDEX_INITIALIZER;
+      if (getColumnIndexByName(&pParamElem->pNode->columnName, pQueryInfo, &index, tscGetErrorMsgPayload(pCmd)) != TSDB_CODE_SUCCESS) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      }
+
+      if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
+      }
+
+      pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
+
+      // functions can not be applied to tags
+      if (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
 
+      int32_t inter   = 0;
+      int16_t resType = 0;
+      int16_t bytes   = 0;
+      getResultDataInfo(TSDB_DATA_TYPE_INT, 4, functionId, 0, &resType, &bytes, &inter, 0, false, pUdfInfo);
+
+      SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionId, &index, resType, bytes, getNewResColId(pCmd), inter, false);
+
+      memset(pExpr->base.aliasName, 0, tListLen(pExpr->base.aliasName));
+      getColumnName(pItem, pExpr->base.aliasName, pExpr->base.token, sizeof(pExpr->base.aliasName) - 1);
+
+      SSchema s = {0};
+      s.type = (uint8_t)resType;
+      s.bytes = bytes;
+      s.colId = pExpr->base.colInfo.colId;
+
+      uint64_t uid = pTableMetaInfo->pTableMeta->id.uid;
+      SColumnList ids = createColumnList(1, index.tableIndex, index.columnIndex);
+      if (finalResult) {
+        insertResultField(pQueryInfo, colIndex, &ids, pUdfInfo->resBytes, pUdfInfo->resType, pExpr->base.aliasName, pExpr);
+      } else {
+        for (int32_t i = 0; i < ids.num; ++i) {
+          tscColumnListInsert(pQueryInfo->colList, index.columnIndex, uid, &s);
+        }
+      }
+
+      tscInsertPrimaryTsSourceColumn(pQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
+      return TSDB_CODE_SUCCESS;
+    }
+  }
+
+  return TSDB_CODE_TSC_INVALID_OPERATION;
 }
 
 // todo refactor
@@ -3078,7 +3358,7 @@ int32_t tscTansformFuncForSTableQuery(SQueryInfo* pQueryInfo) {
         (functionId >= TSDB_FUNC_FIRST_DST && functionId <= TSDB_FUNC_STDDEV_DST) ||
         (functionId >= TSDB_FUNC_RATE && functionId <= TSDB_FUNC_IRATE)) {
       if (getResultDataInfo(pSrcSchema->type, pSrcSchema->bytes, functionId, (int32_t)pExpr->base.param[0].i64, &type, &bytes,
-                            &interBytes, 0, true) != TSDB_CODE_SUCCESS) {
+                            &interBytes, 0, true, NULL) != TSDB_CODE_SUCCESS) {
         return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
@@ -3109,6 +3389,10 @@ void tscRestoreFuncForSTableQuery(SQueryInfo* pQueryInfo) {
     int32_t inter = 0;
     
     int32_t functionId = pExpr->base.functionId;
+    if (functionId < 0) {
+      continue;
+    }
+
     if (functionId >= TSDB_FUNC_TS && functionId <= TSDB_FUNC_DIFF) {
       continue;
     }
@@ -3121,8 +3405,8 @@ void tscRestoreFuncForSTableQuery(SQueryInfo* pQueryInfo) {
       functionId = TSDB_FUNC_STDDEV;
     }
 
-    getResultDataInfo(pSchema->type, pSchema->bytes, functionId, 0, &pExpr->base.resType, &pExpr->base.resBytes,
-                      &inter, 0, false);
+    getResultDataInfo(pSchema->type, pSchema->bytes, functionId, 0, &pExpr->base.resType, &pExpr->base.resBytes, &inter,
+                      0, false, NULL);
   }
 }
 
@@ -3135,6 +3419,10 @@ bool hasUnsupportFunctionsForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo)
   size_t size = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < size; ++i) {
     int32_t functionId = tscExprGet(pQueryInfo, i)->base.functionId;
+    if (functionId < 0) {
+      continue;
+    }
+
     if ((aAggs[functionId].status & TSDB_FUNCSTATE_STABLE) == 0) {
       invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       return true;
@@ -3179,40 +3467,48 @@ static bool groupbyTagsOrNull(SQueryInfo* pQueryInfo) {
 
 static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool twQuery) {
   int32_t startIdx = 0;
+  int32_t aggUdf = 0;
+  int32_t scalarUdf = 0;
+  int32_t prjNum = 0;
+  int32_t aggNum = 0;
 
   size_t numOfExpr = tscNumOfExprs(pQueryInfo);
   assert(numOfExpr > 0);
 
-  SExprInfo* pExpr = tscExprGet(pQueryInfo, startIdx);
-
-  // ts function can be simultaneously used with any other functions.
-  int32_t functionID = pExpr->base.functionId;
-  if (functionID == TSDB_FUNC_TS || functionID == TSDB_FUNC_TS_DUMMY) {
-    startIdx++;
-  }
-
-  int32_t factor = functionCompatList[tscExprGet(pQueryInfo, startIdx)->base.functionId];
-
-  if (tscExprGet(pQueryInfo, 0)->base.functionId == TSDB_FUNC_LAST_ROW && (joinQuery || twQuery || !groupbyTagsOrNull(pQueryInfo))) {
-    return false;
-  }
+  int32_t factor = INT32_MAX;
 
   // diff function cannot be executed with other function
   // arithmetic function can be executed with other arithmetic functions
   size_t size = tscNumOfExprs(pQueryInfo);
   
-  for (int32_t i = startIdx + 1; i < size; ++i) {
+  for (int32_t i = startIdx; i < size; ++i) {
     SExprInfo* pExpr1 = tscExprGet(pQueryInfo, i);
 
     int16_t functionId = pExpr1->base.functionId;
-    if (functionId == TSDB_FUNC_TAGPRJ || functionId == TSDB_FUNC_TAG || functionId == TSDB_FUNC_TS) {
+    if (functionId < 0) {
+       SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * functionId - 1);
+       pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE ? ++aggUdf : ++scalarUdf;
+
        continue;
     }
 
+    if (functionId == TSDB_FUNC_TAGPRJ || functionId == TSDB_FUNC_TAG || functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY) {
+      ++prjNum;
+
+      continue;
+    }
+
+    if (functionId == TSDB_FUNC_PRJ) {
+      ++prjNum;
+    }
+
     if (functionId == TSDB_FUNC_PRJ && (pExpr1->base.colInfo.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX || TSDB_COL_IS_UD_COL(pExpr1->base.colInfo.flag))) {
       continue;
     }
 
+    if (factor == INT32_MAX) {
+      factor = functionCompatList[functionId];
+    } else {
       if (functionCompatList[functionId] != factor) {
         return false;
       } else {
@@ -3220,12 +3516,25 @@ static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool
           return false;
         }
       }
+    }
 
     if (functionId == TSDB_FUNC_LAST_ROW && (joinQuery || twQuery || !groupbyTagsOrNull(pQueryInfo))) {
       return false;
     }
   }
 
+  aggNum = (int32_t)size - prjNum - aggUdf - scalarUdf;
+
+  assert(aggNum >= 0);
+
+  if (aggUdf > 0 && (prjNum > 0 || aggNum > 0 || scalarUdf > 0)) {
+    return false;
+  }
+
+  if (scalarUdf > 0 && aggNum > 0) {
+    return false;
+  }
+
   return true;
 }
 
@@ -3834,7 +4143,7 @@ static int32_t validateSQLExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, SQueryInfo* pQuer
       return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
-    if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, false) != TSDB_CODE_SUCCESS) {
+    if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, false, NULL) != TSDB_CODE_SUCCESS) {
       return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
@@ -5775,6 +6084,16 @@ int32_t validateFunctionsInIntervalOrGroupbyQuery(SSqlCmd* pCmd, SQueryInfo* pQu
   for (int32_t k = 0; k < size; ++k) {
     SExprInfo* pExpr = tscExprGet(pQueryInfo, k);
 
+    if (pExpr->base.functionId < 0) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * pExpr->base.functionId - 1);
+      if (pUdfInfo->funcType == TSDB_UDF_TYPE_SCALAR) {
+        isProjectionFunction = true;
+        break;
+      } else {
+        continue;
+      }
+    }
+
     // projection query on primary timestamp, the selectivity function needs to be present.
     if (pExpr->base.functionId == TSDB_FUNC_PRJ && pExpr->base.colInfo.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
       bool hasSelectivity = false;
@@ -5794,6 +6113,7 @@ int32_t validateFunctionsInIntervalOrGroupbyQuery(SSqlCmd* pCmd, SQueryInfo* pQu
     int32_t f = pExpr->base.functionId;
     if ((f == TSDB_FUNC_PRJ && pExpr->base.numOfParams == 0) || f == TSDB_FUNC_DIFF || f == TSDB_FUNC_ARITHM || f == TSDB_FUNC_DERIVATIVE) {
       isProjectionFunction = true;
+      break;
     }
   }
 
@@ -6279,11 +6599,15 @@ static void doUpdateSqlFunctionForTagPrj(SQueryInfo* pQueryInfo) {
 
   for (int32_t i = 0; i < size; ++i) {
     SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+    if (pExpr->base.functionId < 0) {
+      continue;
+    }
+
     if ((pExpr->base.functionId != TSDB_FUNC_TAG_DUMMY && pExpr->base.functionId != TSDB_FUNC_TS_DUMMY) &&
        !(pExpr->base.functionId == TSDB_FUNC_PRJ && TSDB_COL_IS_UD_COL(pExpr->base.colInfo.flag))) {
       SSchema* pColSchema = &pSchema[pExpr->base.colInfo.colIndex];
       getResultDataInfo(pColSchema->type, pColSchema->bytes, pExpr->base.functionId, (int32_t)pExpr->base.param[0].i64, &pExpr->base.resType,
-                        &pExpr->base.resBytes, &pExpr->base.interBytes, tagLength, isSTable);
+                        &pExpr->base.resBytes, &pExpr->base.interBytes, tagLength, isSTable, NULL);
     }
   }
 }
@@ -6411,6 +6735,14 @@ static int32_t checkUpdateTagPrjFunctions(SQueryInfo* pQueryInfo, char* msg) {
       continue;
     }
 
+    if (functionId < 0) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * functionId - 1);
+      if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
+        ++numOfAggregation;
+      }
+
+      continue;
+    }
 
     if ((aAggs[functionId].status & TSDB_FUNCSTATE_SELECTIVITY) != 0) {
       numOfSelectivity++;
@@ -6638,6 +6970,10 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, char*
         }
       }
 
+      if (f < 0) {
+        continue;
+      }
+
       if ((!pQueryInfo->stateWindow) && (f == TSDB_FUNC_DIFF || f == TSDB_FUNC_DERIVATIVE || f == TSDB_FUNC_TWA || f == TSDB_FUNC_IRATE)) {
         for (int32_t j = 0; j < pQueryInfo->groupbyExpr.numOfGroupCols; ++j) {
           SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, j);
@@ -6651,8 +6987,8 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, char*
         }
       }
 
-      if (IS_MULTIOUTPUT(aAggs[f].status) && f != TSDB_FUNC_TOP && f != TSDB_FUNC_BOTTOM &&
-          f != TSDB_FUNC_DIFF && f != TSDB_FUNC_DERIVATIVE && f != TSDB_FUNC_TAGPRJ && f != TSDB_FUNC_PRJ) {
+      if (IS_MULTIOUTPUT(aAggs[f].status) && f != TSDB_FUNC_TOP && f != TSDB_FUNC_BOTTOM && f != TSDB_FUNC_DIFF &&
+          f != TSDB_FUNC_DERIVATIVE && f != TSDB_FUNC_TAGPRJ && f != TSDB_FUNC_PRJ) {
         return invalidOperationMsg(msg, msg1);
       }
 
@@ -6679,6 +7015,7 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, char*
     return checkUpdateTagPrjFunctions(pQueryInfo, msg);
   }
 }
+
 int32_t doLocalQueryProcess(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode) {
   const char* msg1 = "only one expression allowed";
   const char* msg2 = "invalid expression in select clause";
@@ -6857,9 +7194,17 @@ void tscPrintSelNodeList(SSqlObj* pSql, int32_t subClauseIndex) {
 
     char    tmpBuf[1024] = {0};
     int32_t tmpLen = 0;
+    char   *name = NULL;
+
+    if (pExpr->base.functionId < 0) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * pExpr->base.functionId - 1);
+      name = pUdfInfo->name;
+    } else {
+      name = aAggs[pExpr->base.functionId].name;
+    }
+
     tmpLen =
-        sprintf(tmpBuf, "%s(uid:%" PRIu64 ", %d)", aAggs[pExpr->base.functionId].name, pExpr->base.uid,
-            pExpr->base.colInfo.colId);
+        sprintf(tmpBuf, "%s(uid:%" PRId64 ", %d)", name, pExpr->base.uid, pExpr->base.colInfo.colId);
 
     if (tmpLen + offset >= totalBufSize - 1) break;
 
@@ -7388,7 +7733,7 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelect
   int32_t outputIndex = (int32_t)tscNumOfExprs(pQueryInfo);
 
   // ADD TRUE FOR TEST
-  if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, true) != TSDB_CODE_SUCCESS) {
+  if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, true, NULL) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
@@ -7678,6 +8023,7 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   SArray* pVgroupList   = NULL;
   SArray* plist         = NULL;
   STableMeta* pTableMeta = NULL;
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   pCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
 
@@ -7761,9 +8107,41 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     }
   }
 
+  size_t funcSize = 0;
+  if (pInfo->funcs) {
+    funcSize = taosArrayGetSize(pInfo->funcs);
+  }
+  if (funcSize > 0) {
+    for (size_t i = 0; i < funcSize; ++i) {
+      SStrToken* t = taosArrayGet(pInfo->funcs, i);
+      if (NULL == t) {
+        continue;
+      }
+
+      if (t->n >= TSDB_FUNC_NAME_LEN) {
+        code = tscSQLSyntaxErrMsg(tscGetErrorMsgPayload(pCmd), "too long function name", t->z);
+        if (code != TSDB_CODE_SUCCESS) {
+          goto _end;
+        }
+      }
+
+      int32_t functionId = isValidFunction(t->z, t->n);
+      if (functionId < 0) {
+        struct SUdfInfo info = {0};
+        info.name = strndup(t->z, t->n);
+        if (pQueryInfo->pUdfInfo == NULL) {
+          pQueryInfo->pUdfInfo = taosArrayInit(4, sizeof(struct SUdfInfo));
+        }
+
+        info.functionId = (int32_t)taosArrayGetSize(pQueryInfo->pUdfInfo) * (-1) - 1;;
+        taosArrayPush(pQueryInfo->pUdfInfo, &info);
+      }
+    }
+  }
+
   // load the table meta for a given table name list
-  if (taosArrayGetSize(plist) > 0 || taosArrayGetSize(pVgroupList) > 0) {
-    code = getMultiTableMetaFromMnode(pSql, plist, pVgroupList, tscTableMetaCallBack);
+  if (taosArrayGetSize(plist) > 0 || taosArrayGetSize(pVgroupList) > 0 || (pQueryInfo->pUdfInfo && taosArrayGetSize(pQueryInfo->pUdfInfo) > 0)) {
+    code = getMultiTableMetaFromMnode(pSql, plist, pVgroupList, pQueryInfo->pUdfInfo, tscTableMetaCallBack);
   }
 
 _end:
@@ -7896,8 +8274,15 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
   SQueryInfo* pSub = calloc(1, sizeof(SQueryInfo));
   tscInitQueryInfo(pSub);
 
+  SArray *pUdfInfo = NULL;
+  if (pQueryInfo->pUdfInfo) {
+    pUdfInfo = taosArrayDup(pQueryInfo->pUdfInfo);
+  }
+
+  pSub->pUdfInfo = pUdfInfo;
+  pSub->udfCopy = true;
+
   int32_t code = validateSqlNode(pSql, p, pSub);
-  assert(code != TSDB_CODE_TSC_ACTION_IN_PROGRESS);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -8239,6 +8624,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     pQueryInfo->simpleAgg = isSimpleAggregateRv(pQueryInfo);
     pQueryInfo->onlyTagQuery = onlyTagPrjFunction(pQueryInfo);
     pQueryInfo->groupbyColumn = tscGroupbyColumn(pQueryInfo);
+    //pQueryInfo->globalMerge = tscIsTwoStageSTableQuery(pQueryInfo, 0);
 
     pQueryInfo->arithmeticOnAgg   = tsIsArithmeticQueryOnAggResult(pQueryInfo);
     pQueryInfo->orderProjectQuery = tscOrderedProjectionQueryOnSTable(pQueryInfo, 0);
@@ -8468,9 +8854,7 @@ void normalizeSqlNode(SSqlNode* pSqlNode, const char* dbName) {
 //  2. pSqlNode->pWhere
 //  3. pSqlNode->pHaving
 //  4. pSqlNode->pSortOrder
-
 //  pSqlNode->from
-
 }
 
 #endif

src/client/src/tscServer.c

@@ -503,6 +503,7 @@ int doBuildAndSendMsg(SSqlObj *pSql) {
       pCmd->command == TSDB_SQL_INSERT ||
       pCmd->command == TSDB_SQL_CONNECT ||
       pCmd->command == TSDB_SQL_HB ||
+      pCmd->command == TSDB_SQL_RETRIEVE_FUNC ||
       pCmd->command == TSDB_SQL_STABLEVGROUP) {
     pRes->code = tscBuildMsg[pCmd->command](pSql, NULL);
   }
@@ -545,7 +546,7 @@ int tscBuildAndSendRequest(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
     type = pQueryInfo->type;
 
     // while numOfTables equals to 0, it must be Heartbeat
-    assert((pQueryInfo->numOfTables == 0 && pQueryInfo->command == TSDB_SQL_HB) || pQueryInfo->numOfTables > 0);
+    assert((pQueryInfo->numOfTables == 0 && (pQueryInfo->command == TSDB_SQL_HB || pSql->cmd.command == TSDB_SQL_RETRIEVE_FUNC)) || pQueryInfo->numOfTables > 0);
   }
 
   tscDebug("0x%"PRIx64" SQL cmd:%s will be processed, name:%s, type:%d", pSql->self, sqlCmd[pCmd->command], name, type);
@@ -1032,6 +1033,34 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     pMsg += sizeof(int32_t);
   }
 
+  // support only one udf
+  if (pQueryInfo->pUdfInfo != NULL && taosArrayGetSize(pQueryInfo->pUdfInfo) > 0) {
+    pQueryMsg->udfContentOffset = htonl((int32_t) (pMsg - pCmd->payload));
+    for(int32_t i = 0; i < taosArrayGetSize(pQueryInfo->pUdfInfo); ++i) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, i);
+      *(int8_t*) pMsg = pUdfInfo->resType;
+      pMsg += sizeof(pUdfInfo->resType);
+
+      *(int16_t*) pMsg = htons(pUdfInfo->resBytes);
+      pMsg += sizeof(pUdfInfo->resBytes);
+
+      STR_TO_VARSTR(pMsg, pUdfInfo->name);
+
+      pMsg += varDataTLen(pMsg);
+
+      *(int32_t*) pMsg = htonl(pUdfInfo->funcType);
+      pMsg += sizeof(pUdfInfo->funcType);
+
+      *(int32_t*) pMsg = htonl(pUdfInfo->bufSize);
+      pMsg += sizeof(pUdfInfo->bufSize);
+
+      pQueryMsg->udfContentLen = htonl(pUdfInfo->contLen);
+      memcpy(pMsg, pUdfInfo->content, pUdfInfo->contLen);
+
+      pMsg += pUdfInfo->contLen;
+    }
+  }
+
   memcpy(pMsg, pSql->sqlstr, sqlLen);
   pMsg += sqlLen;
 
@@ -1067,6 +1096,18 @@ int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t tscBuildCreateFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+  SCreateFuncMsg *pCreateFuncMsg = (SCreateFuncMsg *)pCmd->payload;
+
+  pCmd->msgType = TSDB_MSG_TYPE_CM_CREATE_FUNCTION;
+
+  pCmd->payloadLen = sizeof(SCreateFuncMsg) + htonl(pCreateFuncMsg->codeLen);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t tscBuildCreateDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->payloadLen = sizeof(SCreateDnodeMsg);
@@ -1191,6 +1232,17 @@ int32_t tscBuildDropDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t tscBuildDropFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  pCmd->msgType = TSDB_MSG_TYPE_CM_DROP_FUNCTION;
+
+  pCmd->payloadLen = sizeof(SDropFuncMsg);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t tscBuildDropTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->payloadLen = sizeof(SCMDropTableMsg);
@@ -1294,9 +1346,17 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
+  SShowInfo *pShowInfo = &pInfo->pMiscInfo->showOpt;
   SShowMsg  *pShowMsg = (SShowMsg *)pCmd->payload;
 
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+  if (pShowInfo->showType == TSDB_MGMT_TABLE_FUNCTION) {
+    pShowMsg->type = pShowInfo->showType;
+    pShowMsg->payloadLen = 0;
+    pCmd->payloadLen = sizeof(SShowMsg);
+
+    return TSDB_CODE_SUCCESS;
+  }
 
   if (tNameIsEmpty(&pTableMetaInfo->name)) {
     pthread_mutex_lock(&pObj->mutex);
@@ -1306,7 +1366,6 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     tNameGetFullDbName(&pTableMetaInfo->name, pShowMsg->db);
   }
 
-  SShowInfo *pShowInfo = &pInfo->pMiscInfo->showOpt;
   pShowMsg->type = pShowInfo->showType;
 
   if (pShowInfo->showType != TSDB_MGMT_TABLE_VNODES) {
@@ -1819,6 +1878,29 @@ int tscBuildSTableVgroupMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
+int tscBuildRetrieveFuncMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  char *pMsg = pCmd->payload;
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  int32_t numOfFuncs = (int32_t)taosArrayGetSize(pQueryInfo->pUdfInfo);
+
+  SRetrieveFuncMsg *pRetrieveFuncMsg = (SRetrieveFuncMsg *)pMsg;
+  pRetrieveFuncMsg->num = htonl(numOfFuncs);
+
+  pMsg += sizeof(SRetrieveFuncMsg);
+  for(int32_t i = 0; i < numOfFuncs; ++i) {
+    SUdfInfo* pUdf = taosArrayGet(pQueryInfo->pUdfInfo, i);
+    STR_TO_NET_VARSTR(pMsg, pUdf->name);
+    pMsg += varDataNetTLen(pMsg);
+  }
+
+  pCmd->msgType = TSDB_MSG_TYPE_CM_RETRIEVE_FUNC;
+  pCmd->payloadLen = (int32_t)(pMsg - pCmd->payload);
+
+  return TSDB_CODE_SUCCESS;
+}
+
 int tscBuildHeartBeatMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   STscObj *pObj = pSql->pTscObj;
@@ -2034,12 +2116,64 @@ static SVgroupsInfo* createVgroupInfoFromMsg(char* pMsg, int32_t* size, uint64_t
   return pVgroupInfo;
 }
 
+int tscProcessRetrieveFuncRsp(SSqlObj* pSql) {
+  SSqlCmd* pCmd = &pSql->cmd;
+  SUdfFuncMsg* pFuncMsg = (SUdfFuncMsg *)pSql->res.pRsp;
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+
+  pFuncMsg->num = htonl(pFuncMsg->num);
+  assert(pFuncMsg->num == taosArrayGetSize(pQueryInfo->pUdfInfo));
+
+  char* pMsg = pFuncMsg->content;
+  for(int32_t i = 0; i < pFuncMsg->num; ++i) {
+    SFunctionInfoMsg* pFunc = (SFunctionInfoMsg*) pMsg;
+
+    for(int32_t j = 0; j < pFuncMsg->num; ++j) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, j);
+      if (strcmp(pUdfInfo->name, pFunc->name) != 0) {
+        continue;
+      }
+
+      if (pUdfInfo->content) {
+        continue;
+      }
+
+      pUdfInfo->resBytes = htons(pFunc->resBytes);
+      pUdfInfo->resType  = pFunc->resType;
+      pUdfInfo->funcType = htonl(pFunc->funcType);
+      pUdfInfo->contLen  = htonl(pFunc->len);
+      pUdfInfo->bufSize  = htonl(pFunc->bufSize);
+
+      pUdfInfo->content = malloc(pUdfInfo->contLen);
+      memcpy(pUdfInfo->content, pFunc->content, pUdfInfo->contLen);
+
+      pMsg += sizeof(SFunctionInfoMsg) + pUdfInfo->contLen;
+    }
+  }
+
+  // master sqlObj locates in param
+  SSqlObj* parent = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pSql->param);
+  if(parent == NULL) {
+    return pSql->res.code;
+  }
+
+  SQueryInfo* parQueryInfo = tscGetQueryInfo(&parent->cmd);
+
+  assert(parent->signature == parent && (int64_t)pSql->param == parent->self);
+  taosArrayDestroy(parQueryInfo->pUdfInfo);
+
+  parQueryInfo->pUdfInfo = pQueryInfo->pUdfInfo;   // assigned to parent sql obj.
+  pQueryInfo->pUdfInfo = NULL;
+  return TSDB_CODE_SUCCESS;
+}
+
 int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
   char *rsp = pSql->res.pRsp;
 
   SMultiTableMeta *pMultiMeta = (SMultiTableMeta *)rsp;
   pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
   pMultiMeta->numOfVgroup = htonl(pMultiMeta->numOfVgroup);
+  pMultiMeta->numOfUdf = htonl(pMultiMeta->numOfUdf);
 
   rsp += sizeof(SMultiTableMeta);
 
@@ -2128,6 +2262,37 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
     pMsg += size;
   }
 
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pParentCmd);
+  if (pMultiMeta->numOfUdf > 0) {
+    assert(pQueryInfo->pUdfInfo != NULL);
+  }
+
+  for(int32_t i = 0; i < pMultiMeta->numOfUdf; ++i) {
+    SFunctionInfoMsg* pFunc = (SFunctionInfoMsg*) pMsg;
+
+    for(int32_t j = 0; j < pMultiMeta->numOfUdf; ++j) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, j);
+      if (strcmp(pUdfInfo->name, pFunc->name) != 0) {
+        continue;
+      }
+
+      if (pUdfInfo->content) {
+        continue;
+      }
+
+      pUdfInfo->resBytes = htons(pFunc->resBytes);
+      pUdfInfo->resType  = pFunc->resType;
+      pUdfInfo->funcType = htonl(pFunc->funcType);
+      pUdfInfo->contLen  = htonl(pFunc->len);
+      pUdfInfo->bufSize  = htonl(pFunc->bufSize);
+
+      pUdfInfo->content = malloc(pUdfInfo->contLen);
+      memcpy(pUdfInfo->content, pFunc->content, pUdfInfo->contLen);
+
+      pMsg += sizeof(SFunctionInfoMsg) + pUdfInfo->contLen;
+    }
+  }
+
   pSql->res.code = TSDB_CODE_SUCCESS;
   pSql->res.numOfTotal = pMultiMeta->numOfTables;
   tscDebug("0x%"PRIx64" load multi-tableMeta from mnode, numOfTables:%d", pSql->self, pMultiMeta->numOfTables);
@@ -2518,7 +2683,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
   return code;
 }
 
-int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, __async_cb_func_t fp) {
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, SArray* pUdfList, __async_cb_func_t fp) {
   SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
   if (NULL == pNew) {
     tscError("0x%"PRIx64" failed to allocate sqlobj to get multiple table meta", pSql->self);
@@ -2531,8 +2696,9 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
 
   int32_t numOfTable      = (int32_t) taosArrayGetSize(pNameList);
   int32_t numOfVgroupList = (int32_t) taosArrayGetSize(pVgroupNameList);
+  int32_t numOfUdf        = pUdfList ? (int32_t)taosArrayGetSize(pUdfList) : 0;
 
-  int32_t size = (numOfTable + numOfVgroupList) * TSDB_TABLE_FNAME_LEN + sizeof(SMultiTableInfoMsg);
+  int32_t size = (numOfTable + numOfVgroupList) * TSDB_TABLE_FNAME_LEN + TSDB_FUNC_NAME_LEN * numOfUdf + sizeof(SMultiTableInfoMsg);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, size)) {
     tscError("0x%"PRIx64" malloc failed for payload to get table meta", pSql->self);
     tscFreeSqlObj(pNew);
@@ -2542,12 +2708,13 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
   SMultiTableInfoMsg* pInfo = (SMultiTableInfoMsg*) pNew->cmd.payload;
   pInfo->numOfTables  = htonl((uint32_t) taosArrayGetSize(pNameList));
   pInfo->numOfVgroups = htonl((uint32_t) taosArrayGetSize(pVgroupNameList));
+  pInfo->numOfUdfs    = htonl(numOfUdf);
 
   char* start = pInfo->tableNames;
   int32_t len = 0;
   for(int32_t i = 0; i < numOfTable; ++i) {
     char* name = taosArrayGetP(pNameList, i);
-    if (i < numOfTable - 1 || numOfVgroupList > 0) {
+    if (i < numOfTable - 1 || numOfVgroupList > 0 || numOfUdf > 0) {
       len = sprintf(start, "%s,", name);
     } else {
       len = sprintf(start, "%s", name);
@@ -2558,7 +2725,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
 
   for(int32_t i = 0; i < numOfVgroupList; ++i) {
     char* name = taosArrayGetP(pVgroupNameList, i);
-    if (i < numOfVgroupList - 1) {
+    if (i < numOfVgroupList - 1 || numOfUdf > 0) {
       len = sprintf(start, "%s,", name);
     } else {
       len = sprintf(start, "%s", name);
@@ -2567,12 +2734,23 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
     start += len;
   }
 
+  for(int32_t i = 0; i < numOfUdf; ++i) {
+    SUdfInfo * u = taosArrayGet(pUdfList, i);
+    if (i < numOfUdf - 1) {
+      len = sprintf(start, "%s,", u->name);
+    } else {
+      len = sprintf(start, "%s", u->name);
+    }
+
+    start += len;
+  }
+
   pNew->cmd.payloadLen = (int32_t) ((start - pInfo->tableNames) + sizeof(SMultiTableInfoMsg));
   pNew->cmd.msgType = TSDB_MSG_TYPE_CM_TABLES_META;
 
   registerSqlObj(pNew);
-  tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, vgroupInfo:%d, msg size:%d", pSql->self,
-      pNew->self, numOfTable, numOfVgroupList, pNew->cmd.payloadLen);
+  tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, vgroupInfo:%d, udf:%d, msg size:%d", pSql->self,
+      pNew->self, numOfTable, numOfVgroupList, numOfUdf, pNew->cmd.payloadLen);
 
   pNew->fp = fp;
   pNew->param = (void *)pSql->self;
@@ -2645,6 +2823,60 @@ int tscGetTableMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool create
   return tscGetTableMetaImpl(pSql, pTableMetaInfo, createIfNotExists);
 }
 
+int32_t tscGetUdfFromNode(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
+  SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
+  if (NULL == pNew) {
+    tscError("%p malloc failed for new sqlobj to get user-defined functions", pSql);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  pNew->pTscObj = pSql->pTscObj;
+  pNew->signature = pNew;
+  pNew->cmd.command = TSDB_SQL_RETRIEVE_FUNC;
+
+  if (tscAddQueryInfo(&pNew->cmd) != TSDB_CODE_SUCCESS) {
+    tscError("%p malloc failed for new queryinfo", pSql);
+    tscFreeSqlObj(pNew);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd);
+
+  pNewQueryInfo->pUdfInfo = taosArrayInit(4, sizeof(SUdfInfo));
+  for(int32_t i = 0; i < taosArrayGetSize(pQueryInfo->pUdfInfo); ++i) {
+    SUdfInfo info = {0};
+    SUdfInfo* p1 = taosArrayGet(pQueryInfo->pUdfInfo, i);
+    info = *p1;
+    info.name = strdup(p1->name);
+    taosArrayPush(pNewQueryInfo->pUdfInfo, &info);
+  }
+
+  pNew->cmd.active = pNewQueryInfo;
+
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE + pSql->cmd.payloadLen)) {
+    tscError("%p malloc failed for payload to get table meta", pSql);
+    tscFreeSqlObj(pNew);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  tscDebug("%p new pSqlObj:%p to retrieve udf", pSql, pNew);
+  registerSqlObj(pNew);
+
+  pNew->fp = tscTableMetaCallBack;
+  pNew->param = (void *)pSql->self;
+
+  tscDebug("%p metaRid from %" PRId64 " to %" PRId64 , pSql, pSql->metaRid, pNew->self);
+
+  pSql->metaRid = pNew->self;
+
+  int32_t code = tscBuildAndSendRequest(pNew, NULL);
+  if (code == TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_ACTION_IN_PROGRESS;  // notify application that current process needs to be terminated
+  }
+
+  return code;
+}
+
 /**
  * retrieve table meta from mnode, and then update the local table meta hashmap.
  * @param pSql          sql object
@@ -2745,6 +2977,7 @@ void tscInitMsgsFp() {
 
   tscBuildMsg[TSDB_SQL_CREATE_DB] = tscBuildCreateDbMsg;
   tscBuildMsg[TSDB_SQL_CREATE_USER] = tscBuildUserMsg;
+  tscBuildMsg[TSDB_SQL_CREATE_FUNCTION] = tscBuildCreateFuncMsg;
 
   tscBuildMsg[TSDB_SQL_CREATE_ACCT] = tscBuildAcctMsg;
   tscBuildMsg[TSDB_SQL_ALTER_ACCT] = tscBuildAcctMsg;
@@ -2753,6 +2986,7 @@ void tscInitMsgsFp() {
   tscBuildMsg[TSDB_SQL_DROP_USER] = tscBuildDropUserAcctMsg;
   tscBuildMsg[TSDB_SQL_DROP_ACCT] = tscBuildDropUserAcctMsg;
   tscBuildMsg[TSDB_SQL_DROP_DB] = tscBuildDropDbMsg;
+  tscBuildMsg[TSDB_SQL_DROP_FUNCTION] = tscBuildDropFuncMsg;
   tscBuildMsg[TSDB_SQL_SYNC_DB_REPLICA] = tscBuildSyncDbReplicaMsg;
   tscBuildMsg[TSDB_SQL_DROP_TABLE] = tscBuildDropTableMsg;
   tscBuildMsg[TSDB_SQL_ALTER_USER] = tscBuildUserMsg;
@@ -2768,6 +3002,7 @@ void tscInitMsgsFp() {
   tscBuildMsg[TSDB_SQL_USE_DB] = tscBuildUseDbMsg;
 //  tscBuildMsg[TSDB_SQL_META] = tscBuildTableMetaMsg;
   tscBuildMsg[TSDB_SQL_STABLEVGROUP] = tscBuildSTableVgroupMsg;
+  tscBuildMsg[TSDB_SQL_RETRIEVE_FUNC] = tscBuildRetrieveFuncMsg;
 
   tscBuildMsg[TSDB_SQL_HB] = tscBuildHeartBeatMsg;
   tscBuildMsg[TSDB_SQL_SHOW] = tscBuildShowMsg;
@@ -2786,6 +3021,7 @@ void tscInitMsgsFp() {
   tscProcessMsgRsp[TSDB_SQL_META] = tscProcessTableMetaRsp;
   tscProcessMsgRsp[TSDB_SQL_STABLEVGROUP] = tscProcessSTableVgroupRsp;
   tscProcessMsgRsp[TSDB_SQL_MULTI_META] = tscProcessMultiTableMetaRsp;
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_FUNC] = tscProcessRetrieveFuncRsp;
 
   tscProcessMsgRsp[TSDB_SQL_SHOW] = tscProcessShowRsp;
   tscProcessMsgRsp[TSDB_SQL_RETRIEVE] = tscProcessRetrieveRspFromNode;  // rsp handled by same function.
@@ -2815,3 +3051,4 @@ void tscInitMsgsFp() {
   tscKeepConn[TSDB_SQL_FETCH] = 1;
   tscKeepConn[TSDB_SQL_HB] = 1;
 }
+

src/client/src/tscSql.c

@@ -566,7 +566,7 @@ static bool tscKillQueryInDnode(SSqlObj* pSql) {
 
   SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
-  if ((pQueryInfo == NULL) || tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
+  if ((pQueryInfo == NULL) || pQueryInfo->globalMerge) {
     return true;
   }
 
@@ -679,7 +679,7 @@ static void tscKillSTableQuery(SSqlObj *pSql) {
 
   SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
-  if (!tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
+  if (!pQueryInfo->globalMerge) {
     return;
   }
 
@@ -730,7 +730,7 @@ void taos_stop_query(TAOS_RES *res) {
 
   SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
-  if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
+  if (pQueryInfo->globalMerge) {
     assert(pSql->rpcRid <= 0);
     tscKillSTableQuery(pSql);
   } else {
@@ -979,7 +979,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   registerSqlObj(pSql);
   tscDebug("0x%"PRIx64" load multiple table meta, tableNameList: %s pObj:%p", pSql->self, tableNameList, pObj);
 
-  code = getMultiTableMetaFromMnode(pSql, plist, vgroupList, loadMultiTableMetaCallback);
+  code = getMultiTableMetaFromMnode(pSql, plist, vgroupList, NULL, loadMultiTableMetaCallback);
   if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
     code = TSDB_CODE_SUCCESS;
   }

src/client/src/tscSubquery.c

@@ -23,6 +23,7 @@
 #include "tscSubquery.h"
 #include "qTableMeta.h"
 #include "tsclient.h"
+#include "qUdf.h"
 #include "qUtil.h"
 #include "qPlan.h"
 
@@ -32,7 +33,7 @@ typedef struct SInsertSupporter {
 } SInsertSupporter;
 
 static void freeJoinSubqueryObj(SSqlObj* pSql);
-static bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql);
+//static bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql);
 
 static int32_t tsCompare(int32_t order, int64_t left, int64_t right) {
   if (left == right) {
@@ -1896,7 +1897,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
       int16_t type  = 0;
       int32_t inter = 0;
 
-      getResultDataInfo(s->type, s->bytes, TSDB_FUNC_TID_TAG, 0, &type, &bytes, &inter, 0, 0);
+      getResultDataInfo(s->type, s->bytes, TSDB_FUNC_TID_TAG, 0, &type, &bytes, &inter, 0, 0, NULL);
 
       SSchema s1 = {.colId = s->colId, .type = (uint8_t)type, .bytes = bytes};
       pSupporter->tagSize = s1.bytes;
@@ -2801,6 +2802,28 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
 
   tscFreeRetrieveSup(pSql);
 
+  // set the command flag must be after the semaphore been correctly set.
+  if (pParentSql->cmd.command != TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
+    pParentSql->cmd.command = TSDB_SQL_RETRIEVE_GLOBALMERGE;
+
+    SQueryInfo *pQueryInfo2 = tscGetQueryInfo(&pParentSql->cmd);
+
+    size_t size = tscNumOfExprs(pQueryInfo);
+    for (int32_t j = 0; j < size; ++j) {
+      SExprInfo* pExprInfo = tscExprGet(pQueryInfo2, j);
+
+      int32_t functionId = pExprInfo->base.functionId;
+      if (functionId < 0) {
+        SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo2->pUdfInfo, -1 * functionId - 1);
+        code = initUdfInfo(pUdfInfo);
+        if (code != TSDB_CODE_SUCCESS) {
+          pParentSql->res.code = code;
+          tscAsyncResultOnError(pParentSql);
+        }
+      }
+    }
+  }
+
   if (pParentSql->res.code == TSDB_CODE_SUCCESS) {
     (*pParentSql->fp)(pParentSql->param, pParentSql, 0);
   } else {

src/client/src/tscSystem.c

@@ -28,6 +28,7 @@
 #include "tconfig.h"
 #include "ttimezone.h"
 #include "tlocale.h"
+#include "qScript.h"
 
 // global, not configurable
 #define TSC_VAR_NOT_RELEASE 1
@@ -148,6 +149,8 @@ void taos_init_imp(void) {
     taosInitNotes();
 
     rpcInit();
+
+    scriptEnvPoolInit();
     tscDebug("starting to initialize TAOS client ...");
     tscDebug("Local End Point is:%s", tsLocalEp);
   }
@@ -202,7 +205,9 @@ void taos_cleanup(void) {
   if (atomic_val_compare_exchange_32(&sentinel, TSC_VAR_NOT_RELEASE, TSC_VAR_RELEASED) != TSC_VAR_NOT_RELEASE) {
     return;
   }
-
+  if (tscEmbedded == 0) {
+    scriptEnvPoolCleanup();
+  }
   taosHashCleanup(tscTableMetaInfo);
   tscTableMetaInfo = NULL;
 

src/client/src/tscUtil.c

@@ -216,6 +216,15 @@ bool tscIsProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex) {
   for (int32_t i = 0; i < numOfExprs; ++i) {
     int32_t functionId = tscExprGet(pQueryInfo, i)->base.functionId;
 
+    if (functionId < 0) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * functionId - 1);
+      if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
+        return false;
+      }
+
+      continue;
+    }
+
     if (functionId != TSDB_FUNC_PRJ &&
         functionId != TSDB_FUNC_TAGPRJ &&
         functionId != TSDB_FUNC_TAG &&
@@ -266,6 +275,16 @@ bool tscIsProjectionQuery(SQueryInfo* pQueryInfo) {
         f != TSDB_FUNC_DERIVATIVE) {
       return false;
     }
+
+    if (f < 0) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * f - 1);
+      if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
+        return false;
+      }
+
+      continue;
+    }
+
   }
 
   return true;
@@ -338,6 +357,10 @@ bool tsIsArithmeticQueryOnAggResult(SQueryInfo* pQueryInfo) {
     }
   }
 
+  if (tscIsProjectionQuery(pQueryInfo)) {
+    return false;
+  }
+
   return false;
 }
 
@@ -526,6 +549,15 @@ bool isSimpleAggregateRv(SQueryInfo* pQueryInfo) {
     }
 
     int32_t functionId = pExpr->base.functionId;
+    if (functionId < 0) {
+      SUdfInfo* pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * functionId - 1);
+      if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
+        return true;
+      }
+
+      continue;
+    }
+
     if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY) {
       continue;
     }
@@ -1302,6 +1334,12 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
       tfree(pUpQueryInfo);
     }
 
+    if (pQueryInfo->udfCopy) {
+      pQueryInfo->pUdfInfo = taosArrayDestroy(pQueryInfo->pUdfInfo);
+    } else {
+      pQueryInfo->pUdfInfo = tscDestroyUdfArrayList(pQueryInfo->pUdfInfo);
+    }
+
     freeQueryInfoImpl(pQueryInfo);
     clearAllTableMetaInfo(pQueryInfo, removeMeta);
 
@@ -1537,6 +1575,47 @@ void*  tscDestroyBlockArrayList(SArray* pDataBlockList) {
   return NULL;
 }
 
+
+void freeUdfInfo(SUdfInfo* pUdfInfo) {
+  if (pUdfInfo == NULL) {
+    return;
+  }
+
+  if (pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY]) {
+    (*(udfDestroyFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY])(&pUdfInfo->init);
+  }
+
+  tfree(pUdfInfo->name);
+
+  if (pUdfInfo->path) {
+    unlink(pUdfInfo->path);
+  }
+
+  tfree(pUdfInfo->path);
+
+  tfree(pUdfInfo->content);
+
+  taosCloseDll(pUdfInfo->handle);
+}
+
+
+void*  tscDestroyUdfArrayList(SArray* pUdfList) {
+  if (pUdfList == NULL) {
+    return NULL;
+  }
+
+  size_t size = taosArrayGetSize(pUdfList);
+  for (int32_t i = 0; i < size; i++) {
+    SUdfInfo* udf = taosArrayGet(pUdfList, i);
+    freeUdfInfo(udf);
+  }
+
+  taosArrayDestroy(pUdfList);
+  return NULL;
+}
+
+
+
 void* tscDestroyBlockHashTable(SHashObj* pBlockHashTable, bool removeMeta) {
   if (pBlockHashTable == NULL) {
     return NULL;
@@ -3169,6 +3248,14 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
     tscAddTableMetaInfo(pQueryInfo, &p1->name, pMeta, p1->vgroupList, p1->tagColList, p1->pVgroupTables);
   }
 
+  SArray *pUdfInfo = NULL;
+  if (pSrc->pUdfInfo) {
+    pUdfInfo = taosArrayDup(pSrc->pUdfInfo);
+  }
+
+  pQueryInfo->pUdfInfo = pUdfInfo;
+  pQueryInfo->udfCopy = true;
+
   _error:
   return code;
 }
@@ -3215,7 +3302,9 @@ void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo) {
     info->vgInfo.epAddr[j].fqdn = strdup(pInfo->vgInfo.epAddr[j].fqdn);
   }
 
+  if (pInfo->itemList) {
     info->itemList = taosArrayDup(pInfo->itemList);
+  }
 }
 
 SArray* tscVgroupTableInfoDup(SArray* pVgroupTables) {
@@ -3466,6 +3555,11 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
 
   SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pnCmd);
 
+  if (pQueryInfo->pUdfInfo) {
+    pNewQueryInfo->pUdfInfo = taosArrayDup(pQueryInfo->pUdfInfo);
+    pNewQueryInfo->udfCopy = true;
+  }
+
   pNewQueryInfo->command = pQueryInfo->command;
   pnCmd->active = pNewQueryInfo;
 
@@ -3485,6 +3579,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
   pNewQueryInfo->numOfTables = 0;
   pNewQueryInfo->pTableMetaInfo = NULL;
   pNewQueryInfo->bufLen = pQueryInfo->bufLen;
+
   pNewQueryInfo->buf = malloc(pQueryInfo->bufLen);
   if (pNewQueryInfo->buf == NULL) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -4327,7 +4422,7 @@ int32_t createProjectionExpr(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaI
 
       int32_t inter = 0;
       getResultDataInfo(pSource->base.colType, pSource->base.colBytes, functionId, 0, &pse->resType,
-          &pse->resBytes, &inter, 0, false);
+          &pse->resBytes, &inter, 0, false, NULL);
       pse->colType  = pse->resType;
       pse->colBytes = pse->resBytes;
 
@@ -4394,8 +4489,14 @@ static int32_t createGlobalAggregateExpr(SQueryAttr* pQueryAttr, SQueryInfo* pQu
         functionId = TSDB_FUNC_STDDEV;
       }
 
+      SUdfInfo* pUdfInfo = NULL;
+
+      if (functionId < 0) {
+        pUdfInfo = taosArrayGet(pQueryInfo->pUdfInfo, -1 * functionId - 1);
+      }
+
       getResultDataInfo(pExpr->base.colType, pExpr->base.colBytes, functionId, 0, &pse->resType, &pse->resBytes, &inter,
-                        0, false);
+                        0, false, pUdfInfo);
     }
   }
 
@@ -4471,6 +4572,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
   pQueryAttr->order             = pQueryInfo->order;
   pQueryAttr->fillType          = pQueryInfo->fillType;
   pQueryAttr->havingNum         = pQueryInfo->havingFieldNum;
+  pQueryAttr->pUdfInfo          = pQueryInfo->pUdfInfo;
 
   if (pQueryInfo->order.order == TSDB_ORDER_ASC) {   // TODO refactor
     pQueryAttr->window = pQueryInfo->window;

src/common/inc/tcmdtype.h

@@ -41,8 +41,10 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MGMT, "mgmt" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_DB, "create-db" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_TABLE, "create-table" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_FUNCTION, "create-function" )  
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_DB, "drop-db" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_TABLE, "drop-table" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_FUNCTION, "drop-function" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_ACCT, "create-acct" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_USER, "create-user" ) 
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_ACCT, "drop-acct" )
@@ -74,6 +76,7 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_STABLEVGROUP, "stable-vgroup" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MULTI_META, "multi-meta" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_HB, "heart-beat" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RETRIEVE_FUNC, "retrieve-function" )
 
   // SQL below for client local 
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_LOCAL, "local" ) 

src/common/inc/tdataformat.h

@@ -58,6 +58,14 @@ extern const SNCharNullT  NcharNull;
     memcpy(varDataVal(x), (str), __len);          \
   } while (0);
 
+#define STR_TO_NET_VARSTR(x, str)                   \
+    do {                                            \
+      VarDataLenT __len = (VarDataLenT)strlen(str); \
+      *(VarDataLenT *)(x) = htons(__len);           \
+      memcpy(varDataVal(x), (str), __len);          \
+    } while (0);
+
+
 #define STR_WITH_MAXSIZE_TO_VARSTR(x, str, _maxs)                         \
   do {                                                                    \
     char *_e = stpncpy(varDataVal(x), (str), (_maxs)-VARSTR_HEADER_SIZE); \

go @ 7a26c432

-Subproject commit b8f76da4a708d158ec3cc4b844571dc4414e36b4
+Subproject commit 7a26c432f8b4203e42344ff3290b9b9b01b983d5

grafanaplugin @ 23cf0b93

-Subproject commit 3530c6df097134a410bacec6b3cd013ef38a61aa
+Subproject commit 23cf0b933510af5e87b61bace0f6ff2f06d8eaac

hivemq-tdengine-extension @ b62a26ec

-Subproject commit ce5201014136503d34fecbd56494b67b4961056c
+Subproject commit b62a26ecc164a310104df57691691b237e091c89

src/dnode/CMakeLists.txt

@@ -18,7 +18,7 @@ ELSE ()
 ENDIF ()
 
 ADD_EXECUTABLE(taosd ${SRC})
-TARGET_LINK_LIBRARIES(taosd mnode monitor http tsdb twal vnode cJson lz4 balance sync ${LINK_JEMALLOC})
+TARGET_LINK_LIBRARIES(taosd mnode monitor http tsdb twal vnode cJson lua lz4 balance sync ${LINK_JEMALLOC})
 
 IF (TD_SOMODE_STATIC)
   TARGET_LINK_LIBRARIES(taosd taos_static)

src/dnode/src/dnodeMain.c

@@ -40,6 +40,7 @@
 #include "dnodeShell.h"
 #include "dnodeTelemetry.h"
 #include "module.h"
+#include "qScript.h"
 #include "mnode.h"
 
 #if !defined(_MODULE) || !defined(_TD_LINUX)
@@ -84,6 +85,7 @@ static SStep tsDnodeSteps[] = {
   {"dnode-shell",     dnodeInitShell,      dnodeCleanupShell},
   {"dnode-statustmr", dnodeInitStatusTimer,dnodeCleanupStatusTimer},
   {"dnode-telemetry", dnodeInitTelemetry,  dnodeCleanupTelemetry},
+  {"dnode-script",    scriptEnvPoolInit,   scriptEnvPoolCleanup},
 };
 
 static SStep tsDnodeCompactSteps[] = {

src/dnode/src/dnodeShell.c

@@ -48,9 +48,11 @@ int32_t dnodeInitShell() {
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DNODE]  = dnodeDispatchToMWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_DB]   = dnodeDispatchToMWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TP]   = dnodeDispatchToMWriteQueue;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_FUNCTION] = dnodeDispatchToMWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_DB]     = dnodeDispatchToMWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_SYNC_DB]     = dnodeDispatchToMWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_TP]     = dnodeDispatchToMWriteQueue;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_DROP_FUNCTION] = dnodeDispatchToMWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_DB]    = dnodeDispatchToMWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_TP]    = dnodeDispatchToMWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_TABLE]= dnodeDispatchToMWriteQueue;
@@ -72,6 +74,7 @@ int32_t dnodeInitShell() {
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_TABLES_META] = dnodeDispatchToMReadQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_SHOW]        = dnodeDispatchToMReadQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE]    = dnodeDispatchToMReadQueue;
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_RETRIEVE_FUNC] = dnodeDispatchToMReadQueue;
 
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_NETWORK_TEST]   = dnodeSendStartupStep;
 

src/inc/query.h

@@ -28,7 +28,7 @@ typedef void* qinfo_t;
  * @param qinfo
  * @return
  */
-int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryTableMsg, qinfo_t* qinfo, uint64_t *qId);
+int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryTableMsg, qinfo_t* qinfo, uint64_t qId);
 
 
 /**

src/inc/taosdef.h

@@ -186,6 +186,10 @@ do { \
 #define TSDB_NODE_NAME_LEN        64
 #define TSDB_TABLE_NAME_LEN       193     // it is a null-terminated string
 #define TSDB_DB_NAME_LEN          33
+#define TSDB_FUNC_NAME_LEN        65
+#define TSDB_FUNC_CODE_LEN        (65535 - 512)
+#define TSDB_FUNC_BUF_SIZE        512
+#define TSDB_TYPE_STR_MAX_LEN     32
 #define TSDB_TABLE_FNAME_LEN      (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_TABLE_NAME_LEN)
 #define TSDB_COL_NAME_LEN         65
 #define TSDB_MAX_SAVED_SQL_LEN    TSDB_MAX_COLUMNS * 64
@@ -197,7 +201,7 @@ do { \
 
   /**
    *  In some scenarios uint16_t (0~65535) is used to store the row len.
-   *  - Firstly, we use 65531(65535 - 4), as the SDataRow and SKVRow including 4 bits header.
+   *  - Firstly, we use 65531(65535 - 4), as the SDataRow/SKVRow contains 4 bits header.
    *  - Secondly, if all cols are VarDataT type except primary key, we need 4 bits to store the offset, thus
    *    the final value is 65531-(4096-1)*4 = 49151.
    */
@@ -339,6 +343,10 @@ do { \
 #define TSDB_QUERY_TYPE_NON_TYPE               0x00u     // none type
 #define TSDB_QUERY_TYPE_FREE_RESOURCE          0x01u     // free qhandle at vnode
 
+#define TSDB_UDF_TYPE_SCALAR       1
+#define TSDB_UDF_TYPE_AGGREGATE    2
+
+
 /*
  * 1. ordinary sub query for select * from super_table
  * 2. all sqlobj generated by createSubqueryObj with this flag

src/inc/taoserror.h

@@ -100,6 +100,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_TSC_DB_NOT_SELECTED           TAOS_DEF_ERROR_CODE(0, 0x0217)  //"Database not specified or available")
 #define TSDB_CODE_TSC_INVALID_TABLE_NAME        TAOS_DEF_ERROR_CODE(0, 0x0218)  //"Table does not exist")
 #define TSDB_CODE_TSC_EXCEED_SQL_LIMIT          TAOS_DEF_ERROR_CODE(0, 0x0219)  //"SQL statement too long check maxSQLLength config")
+#define TSDB_CODE_TSC_FILE_EMPTY                TAOS_DEF_ERROR_CODE(0, 0x021A)  //"File is empty")
 
 // mnode
 #define TSDB_CODE_MND_MSG_NOT_PROCESSED         TAOS_DEF_ERROR_CODE(0, 0x0300)  //"Message not processed")
@@ -174,6 +175,13 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_INVALID_STABLE_NAME       TAOS_DEF_ERROR_CODE(0, 0x036D)  //"Super table does not exist")
 #define TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG  TAOS_DEF_ERROR_CODE(0, 0x036E)  //"Invalid create table message")
 
+#define TSDB_CODE_MND_INVALID_FUNC_NAME         TAOS_DEF_ERROR_CODE(0, 0x0370)  //"Invalid func name")
+#define TSDB_CODE_MND_INVALID_FUNC_LEN          TAOS_DEF_ERROR_CODE(0, 0x0371)  //"Invalid func length")
+#define TSDB_CODE_MND_INVALID_FUNC_CODE         TAOS_DEF_ERROR_CODE(0, 0x0372)  //"Invalid func code")
+#define TSDB_CODE_MND_FUNC_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0373)  //"Func already exists")
+#define TSDB_CODE_MND_INVALID_FUNC              TAOS_DEF_ERROR_CODE(0, 0x0374)  //"Invalid func")
+#define TSDB_CODE_MND_INVALID_FUNC_BUFSIZE      TAOS_DEF_ERROR_CODE(0, 0x0375)  //"Invalid func bufSize")
+
 #define TSDB_CODE_MND_DB_NOT_SELECTED           TAOS_DEF_ERROR_CODE(0, 0x0380)  //"Database not specified or available")
 #define TSDB_CODE_MND_DB_ALREADY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0381)  //"Database already exists")
 #define TSDB_CODE_MND_INVALID_DB_OPTION         TAOS_DEF_ERROR_CODE(0, 0x0382)  //"Invalid database options")
@@ -261,6 +269,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW       TAOS_DEF_ERROR_CODE(0, 0x070A)  //"Too many time window in query")
 #define TSDB_CODE_QRY_NOT_ENOUGH_BUFFER         TAOS_DEF_ERROR_CODE(0, 0x070B)  //"Query buffer limit has reached")
 #define TSDB_CODE_QRY_INCONSISTAN               TAOS_DEF_ERROR_CODE(0, 0x070C)  //"File inconsistency in replica")
+#define TSDB_CODE_QRY_SYS_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x070D)  //"System error")
 
 
 // grant

src/inc/taosmsg.h

@@ -77,7 +77,9 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_USER, "drop-user" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_DNODE, "create-dnode" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_DNODE, "drop-dnode" )   
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_DB, "create-db" )
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_FUNCTION, "create-function" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_DB, "drop-db" )
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_FUNCTION, "drop-function" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_USE_DB, "use-db" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_ALTER_DB, "alter-db" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_SYNC_DB, "sync-db-replica" )
@@ -96,7 +98,7 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_KILL_STREAM, "kill-stream" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_KILL_CONN, "kill-conn" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CONFIG_DNODE, "cm-config-dnode" ) 
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_HEARTBEAT, "heartbeat" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY8, "dummy8" )
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_RETRIEVE_FUNC, "retrieve-func" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY9, "dummy9" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY10, "dummy10" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY11, "dummy11" )
@@ -153,6 +155,7 @@ enum _mgmt_table {
   TSDB_MGMT_TABLE_STREAMTABLES,
   TSDB_MGMT_TABLE_CLUSTER,
   TSDB_MGMT_TABLE_TP,
+  TSDB_MGMT_TABLE_FUNCTION,
   TSDB_MGMT_TABLE_MAX,
 };
 
@@ -507,6 +510,9 @@ typedef struct {
   int32_t     prevResultLen;    // previous result length
   int32_t     numOfOperator;
   int32_t     tableScanOperator;// table scan operator. -1 means no scan operator
+  int32_t     udfNum;           // number of udf function
+  int32_t     udfContentOffset;
+  int32_t     udfContentLen;
   SColumnInfo tableCols[];
 } SQueryTableMsg;
 
@@ -571,6 +577,41 @@ typedef struct {
   int8_t   reserve[5];
 } SCreateDbMsg, SAlterDbMsg;
 
+typedef struct {
+  char     name[TSDB_FUNC_NAME_LEN];
+  char     path[PATH_MAX];
+  int32_t  funcType;
+  uint8_t  outputType;
+  int16_t  outputLen;
+  int32_t  bufSize;
+  int32_t  codeLen;
+  char     code[];
+} SCreateFuncMsg;
+
+typedef struct {
+  int32_t num;
+  char    name[];
+} SRetrieveFuncMsg;
+
+typedef struct {
+  char    name[TSDB_FUNC_NAME_LEN];
+  int32_t funcType;
+  int8_t  resType;
+  int16_t resBytes;
+  int32_t bufSize;
+  int32_t len;
+  char    content[];
+} SFunctionInfoMsg;
+
+typedef struct {
+  int32_t num;
+  char    content[];
+} SUdfFuncMsg;
+
+typedef struct {
+  char     name[TSDB_FUNC_NAME_LEN];
+} SDropFuncMsg;
+
 typedef struct {
   char    db[TSDB_TABLE_FNAME_LEN];
   uint8_t ignoreNotExists;
@@ -712,6 +753,7 @@ typedef struct {
 typedef struct {
   int32_t numOfVgroups;
   int32_t numOfTables;
+  int32_t numOfUdfs;
   char    tableNames[];
 } SMultiTableInfoMsg;
 
@@ -762,8 +804,9 @@ typedef struct STableMetaMsg {
 typedef struct SMultiTableMeta {
   int32_t       numOfTables;
   int32_t       numOfVgroup;
-  uint32_t contLen:31;
-  uint8_t  compressed:1;      // denote if compressed or not
+  int32_t       numOfUdf;
+  int32_t       contLen;
+  uint8_t       compressed;      // denote if compressed or not
   uint32_t      rawLen;          // size before compress
   char          meta[];
 } SMultiTableMeta;

src/inc/ttokendef.h

@@ -62,149 +62,154 @@
 #define TK_SHOW                            44
 #define TK_DATABASES                       45
 #define TK_TOPICS                          46
-#define TK_MNODES                          47
-#define TK_DNODES                          48
-#define TK_ACCOUNTS                        49
-#define TK_USERS                           50
-#define TK_MODULES                         51
-#define TK_QUERIES                         52
-#define TK_CONNECTIONS                     53
-#define TK_STREAMS                         54
-#define TK_VARIABLES                       55
-#define TK_SCORES                          56
-#define TK_GRANTS                          57
-#define TK_VNODES                          58
-#define TK_IPTOKEN                         59
-#define TK_DOT                             60
-#define TK_CREATE                          61
-#define TK_TABLE                           62
-#define TK_STABLE                          63
-#define TK_DATABASE                        64
-#define TK_TABLES                          65
-#define TK_STABLES                         66
-#define TK_VGROUPS                         67
-#define TK_DROP                            68
-#define TK_TOPIC                           69
-#define TK_DNODE                           70
-#define TK_USER                            71
-#define TK_ACCOUNT                         72
-#define TK_USE                             73
-#define TK_DESCRIBE                        74
-#define TK_ALTER                           75
-#define TK_PASS                            76
-#define TK_PRIVILEGE                       77
-#define TK_LOCAL                           78
-#define TK_COMPACT                         79
-#define TK_LP                              80
-#define TK_RP                              81
-#define TK_IF                              82
-#define TK_EXISTS                          83
-#define TK_PPS                             84
-#define TK_TSERIES                         85
-#define TK_DBS                             86
-#define TK_STORAGE                         87
-#define TK_QTIME                           88
-#define TK_CONNS                           89
-#define TK_STATE                           90
-#define TK_COMMA                           91
-#define TK_KEEP                            92
-#define TK_CACHE                           93
-#define TK_REPLICA                         94
-#define TK_QUORUM                          95
-#define TK_DAYS                            96
-#define TK_MINROWS                         97
-#define TK_MAXROWS                         98
-#define TK_BLOCKS                          99
-#define TK_CTIME                          100
-#define TK_WAL                            101
-#define TK_FSYNC                          102
-#define TK_COMP                           103
-#define TK_PRECISION                      104
-#define TK_UPDATE                         105
-#define TK_CACHELAST                      106
-#define TK_PARTITIONS                     107
-#define TK_UNSIGNED                       108
-#define TK_TAGS                           109
-#define TK_USING                          110
-#define TK_AS                             111
-#define TK_NULL                           112
-#define TK_NOW                            113
-#define TK_SELECT                         114
-#define TK_UNION                          115
-#define TK_ALL                            116
-#define TK_DISTINCT                       117
-#define TK_FROM                           118
-#define TK_VARIABLE                       119
-#define TK_INTERVAL                       120
-#define TK_SESSION                        121
-#define TK_STATE_WINDOW                   122
-#define TK_FILL                           123
-#define TK_SLIDING                        124
-#define TK_ORDER                          125
-#define TK_BY                             126
-#define TK_ASC                            127
-#define TK_DESC                           128
-#define TK_GROUP                          129
-#define TK_HAVING                         130
-#define TK_LIMIT                          131
-#define TK_OFFSET                         132
-#define TK_SLIMIT                         133
-#define TK_SOFFSET                        134
-#define TK_WHERE                          135
-#define TK_RESET                          136
-#define TK_QUERY                          137
-#define TK_SYNCDB                         138
-#define TK_ADD                            139
-#define TK_COLUMN                         140
-#define TK_MODIFY                         141
-#define TK_TAG                            142
-#define TK_CHANGE                         143
-#define TK_SET                            144
-#define TK_KILL                           145
-#define TK_CONNECTION                     146
-#define TK_STREAM                         147
-#define TK_COLON                          148
-#define TK_ABORT                          149
-#define TK_AFTER                          150
-#define TK_ATTACH                         151
-#define TK_BEFORE                         152
-#define TK_BEGIN                          153
-#define TK_CASCADE                        154
-#define TK_CLUSTER                        155
-#define TK_CONFLICT                       156
-#define TK_COPY                           157
-#define TK_DEFERRED                       158
-#define TK_DELIMITERS                     159
-#define TK_DETACH                         160
-#define TK_EACH                           161
-#define TK_END                            162
-#define TK_EXPLAIN                        163
-#define TK_FAIL                           164
-#define TK_FOR                            165
-#define TK_IGNORE                         166
-#define TK_IMMEDIATE                      167
-#define TK_INITIALLY                      168
-#define TK_INSTEAD                        169
-#define TK_MATCH                          170
-#define TK_KEY                            171
-#define TK_OF                             172
-#define TK_RAISE                          173
-#define TK_REPLACE                        174
-#define TK_RESTRICT                       175
-#define TK_ROW                            176
-#define TK_STATEMENT                      177
-#define TK_TRIGGER                        178
-#define TK_VIEW                           179
-#define TK_SEMI                           180
-#define TK_NONE                           181
-#define TK_PREV                           182
-#define TK_LINEAR                         183
-#define TK_IMPORT                         184
-#define TK_TBNAME                         185
-#define TK_JOIN                           186
-#define TK_INSERT                         187
-#define TK_INTO                           188
-#define TK_VALUES                         189
+#define TK_FUNCTIONS                       47
+#define TK_MNODES                          48
+#define TK_DNODES                          49
+#define TK_ACCOUNTS                        50
+#define TK_USERS                           51
+#define TK_MODULES                         52
+#define TK_QUERIES                         53
+#define TK_CONNECTIONS                     54
+#define TK_STREAMS                         55
+#define TK_VARIABLES                       56
+#define TK_SCORES                          57
+#define TK_GRANTS                          58
+#define TK_VNODES                          59
+#define TK_IPTOKEN                         60
+#define TK_DOT                             61
+#define TK_CREATE                          62
+#define TK_TABLE                           63
+#define TK_STABLE                          64
+#define TK_DATABASE                        65
+#define TK_TABLES                          66
+#define TK_STABLES                         67
+#define TK_VGROUPS                         68
+#define TK_DROP                            69
+#define TK_TOPIC                           70
+#define TK_FUNCTION                        71
+#define TK_DNODE                           72
+#define TK_USER                            73
+#define TK_ACCOUNT                         74
+#define TK_USE                             75
+#define TK_DESCRIBE                        76
+#define TK_ALTER                           77
+#define TK_PASS                            78
+#define TK_PRIVILEGE                       79
+#define TK_LOCAL                           80
+#define TK_COMPACT                         81
+#define TK_LP                              82
+#define TK_RP                              83
+#define TK_IF                              84
+#define TK_EXISTS                          85
+#define TK_AS                              86
+#define TK_OUTPUTTYPE                      87
+#define TK_AGGREGATE                       88
+#define TK_BUFSIZE                         89
+#define TK_PPS                             90
+#define TK_TSERIES                         91
+#define TK_DBS                             92
+#define TK_STORAGE                         93
+#define TK_QTIME                           94
+#define TK_CONNS                           95
+#define TK_STATE                           96
+#define TK_COMMA                           97
+#define TK_KEEP                            98
+#define TK_CACHE                           99
+#define TK_REPLICA                        100
+#define TK_QUORUM                         101
+#define TK_DAYS                           102
+#define TK_MINROWS                        103
+#define TK_MAXROWS                        104
+#define TK_BLOCKS                         105
+#define TK_CTIME                          106
+#define TK_WAL                            107
+#define TK_FSYNC                          108
+#define TK_COMP                           109
+#define TK_PRECISION                      110
+#define TK_UPDATE                         111
+#define TK_CACHELAST                      112
+#define TK_PARTITIONS                     113
+#define TK_UNSIGNED                       114
+#define TK_TAGS                           115
+#define TK_USING                          116
+#define TK_NULL                           117
+#define TK_NOW                            118
+#define TK_SELECT                         119
+#define TK_UNION                          120
+#define TK_ALL                            121
+#define TK_DISTINCT                       122
+#define TK_FROM                           123
+#define TK_VARIABLE                       124
+#define TK_INTERVAL                       125
+#define TK_SESSION                        126
+#define TK_STATE_WINDOW                   127
+#define TK_FILL                           128
+#define TK_SLIDING                        129
+#define TK_ORDER                          130
+#define TK_BY                             131
+#define TK_ASC                            132
+#define TK_DESC                           133
+#define TK_GROUP                          134
+#define TK_HAVING                         135
+#define TK_LIMIT                          136
+#define TK_OFFSET                         137
+#define TK_SLIMIT                         138
+#define TK_SOFFSET                        139
+#define TK_WHERE                          140
+#define TK_RESET                          141
+#define TK_QUERY                          142
+#define TK_SYNCDB                         143
+#define TK_ADD                            144
+#define TK_COLUMN                         145
+#define TK_MODIFY                         146
+#define TK_TAG                            147
+#define TK_CHANGE                         148
+#define TK_SET                            149
+#define TK_KILL                           150
+#define TK_CONNECTION                     151
+#define TK_STREAM                         152
+#define TK_COLON                          153
+#define TK_ABORT                          154
+#define TK_AFTER                          155
+#define TK_ATTACH                         156
+#define TK_BEFORE                         157
+#define TK_BEGIN                          158
+#define TK_CASCADE                        159
+#define TK_CLUSTER                        160
+#define TK_CONFLICT                       161
+#define TK_COPY                           162
+#define TK_DEFERRED                       163
+#define TK_DELIMITERS                     164
+#define TK_DETACH                         165
+#define TK_EACH                           166
+#define TK_END                            167
+#define TK_EXPLAIN                        168
+#define TK_FAIL                           169
+#define TK_FOR                            170
+#define TK_IGNORE                         171
+#define TK_IMMEDIATE                      172
+#define TK_INITIALLY                      173
+#define TK_INSTEAD                        174
+#define TK_MATCH                          175
+#define TK_KEY                            176
+#define TK_OF                             177
+#define TK_RAISE                          178
+#define TK_REPLACE                        179
+#define TK_RESTRICT                       180
+#define TK_ROW                            181
+#define TK_STATEMENT                      182
+#define TK_TRIGGER                        183
+#define TK_VIEW                           184
+#define TK_SEMI                           185
+#define TK_NONE                           186
+#define TK_PREV                           187
+#define TK_LINEAR                         188
+#define TK_IMPORT                         189
+#define TK_TBNAME                         190
+#define TK_JOIN                           191
+#define TK_INSERT                         192
+#define TK_INTO                           193
+#define TK_VALUES                         194
 
 
 #define TK_SPACE                          300

src/inc/ttype.h

@@ -30,6 +30,10 @@ typedef struct tstr {
 #define varDataSetLen(v, _len) (((VarDataLenT *)(v))[0] = (VarDataLenT) (_len))
 #define IS_VAR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_BINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
 
+#define varDataNetLen(v)       (htons(((VarDataLenT *)(v))[0]))
+#define varDataNetTLen(v)      (sizeof(VarDataLenT) + varDataNetLen(v))
+
+
 // this data type is internally used only in 'in' query to hold the values
 #define TSDB_DATA_TYPE_ARRAY      (1000)
 

src/kit/shell/CMakeLists.txt

@@ -19,9 +19,9 @@ ELSE ()
 ENDIF ()
 
   IF (TD_SOMODE_STATIC)
-      TARGET_LINK_LIBRARIES(shell taos_static ${LINK_JEMALLOC})
+      TARGET_LINK_LIBRARIES(shell taos_static lua ${LINK_JEMALLOC})
   ELSE ()
-      TARGET_LINK_LIBRARIES(shell taos ${LINK_JEMALLOC})
+      TARGET_LINK_LIBRARIES(shell taos lua ${LINK_JEMALLOC})
   ENDIF ()
 
   SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME taos)

src/kit/taosdemo/CMakeLists.txt

@@ -67,7 +67,7 @@ IF (TD_LINUX)
   ADD_EXECUTABLE(taosdemo ${SRC})
 
   IF (TD_SOMODE_STATIC)
-      TARGET_LINK_LIBRARIES(taosdemo taos_static cJson ${LINK_JEMALLOC})
+      TARGET_LINK_LIBRARIES(taosdemo taos_static cJson lua ${LINK_JEMALLOC})
   ELSE ()
       TARGET_LINK_LIBRARIES(taosdemo taos cJson ${LINK_JEMALLOC})
   ENDIF ()
@@ -76,9 +76,9 @@ ELSEIF (TD_WINDOWS)
   ADD_EXECUTABLE(taosdemo ${SRC})
   SET_SOURCE_FILES_PROPERTIES(./taosdemo.c PROPERTIES COMPILE_FLAGS -w)
   IF (TD_SOMODE_STATIC)
-    TARGET_LINK_LIBRARIES(taosdemo taos_static cJson)
+    TARGET_LINK_LIBRARIES(taosdemo taos_static cJson lua)
   ELSE ()
-    TARGET_LINK_LIBRARIES(taosdemo taos cJson)
+    TARGET_LINK_LIBRARIES(taosdemo taos cJson lua)
   ENDIF ()
 ELSEIF (TD_DARWIN)
   # missing a few dependencies, such as <argp.h>
@@ -86,9 +86,9 @@ ELSEIF (TD_DARWIN)
   ADD_EXECUTABLE(taosdemo ${SRC})
   
   IF (TD_SOMODE_STATIC)
-    TARGET_LINK_LIBRARIES(taosdemo taos_static cJson)
+    TARGET_LINK_LIBRARIES(taosdemo taos_static cJson lua)
   ELSE ()
-    TARGET_LINK_LIBRARIES(taosdemo taos cJson)
+    TARGET_LINK_LIBRARIES(taosdemo taos cJson lua)
   ENDIF ()
 ENDIF ()
 

src/kit/taosdemo/taosdemo.c

@@ -637,7 +637,7 @@ static FILE *          g_fpOfInsertResult = NULL;
 
 #define performancePrint(fmt, ...) \
     do { if (g_args.performance_print) \
-        fprintf(stderr, "VERB: "fmt, __VA_ARGS__); } while(0)
+        fprintf(stderr, "PERF: "fmt, __VA_ARGS__); } while(0)
 
 #define errorPrint(fmt, ...) \
     do { fprintf(stderr, "ERROR: "fmt, __VA_ARGS__); } while(0)
@@ -3183,8 +3183,10 @@ static void createChildTables() {
             if (g_Dbs.db[i].superTblCount > 0) {
                 // with super table
                 for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
-                    if ((AUTO_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable)
-                            || (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists)) {
+                    if ((AUTO_CREATE_SUBTBL
+                                == g_Dbs.db[i].superTbls[j].autoCreateTable)
+                            || (TBL_ALREADY_EXISTS
+                                == g_Dbs.db[i].superTbls[j].childTblExists)) {
                         continue;
                     }
                     verbosePrint("%s() LN%d: %s\n", __func__, __LINE__,
@@ -4156,6 +4158,22 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
         goto PARSE_OVER;
       }
 */
+      cJSON* insertRows = cJSON_GetObjectItem(stbInfo, "insert_rows");
+      if (insertRows && insertRows->type == cJSON_Number) {
+        if (insertRows->valueint < 0) {
+          errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
+                __func__, __LINE__);
+          goto PARSE_OVER;
+        }
+        g_Dbs.db[i].superTbls[j].insertRows = insertRows->valueint;
+      } else if (!insertRows) {
+        g_Dbs.db[i].superTbls[j].insertRows = 0x7FFFFFFFFFFFFFFF;
+      } else {
+        errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
+                __func__, __LINE__);
+        goto PARSE_OVER;
+      }
+
       cJSON* stbInterlaceRows = cJSON_GetObjectItem(stbInfo, "interlace_rows");
       if (stbInterlaceRows && stbInterlaceRows->type == cJSON_Number) {
         if (stbInterlaceRows->valueint < 0) {
@@ -4164,15 +4182,15 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
           goto PARSE_OVER;
         }
         g_Dbs.db[i].superTbls[j].interlaceRows = stbInterlaceRows->valueint;
-        // rows per table need be less than insert batch
-        if (g_Dbs.db[i].superTbls[j].interlaceRows > g_args.num_of_RPR) {
-          printf("NOTICE: db[%d].superTbl[%d]'s interlace rows value %u > num_of_records_per_req %u\n\n",
+
+        if (g_Dbs.db[i].superTbls[j].interlaceRows > g_Dbs.db[i].superTbls[j].insertRows) {
+            printf("NOTICE: db[%d].superTbl[%d]'s interlace rows value %u > insert_rows %"PRId64"\n\n",
                     i, j, g_Dbs.db[i].superTbls[j].interlaceRows,
-                  g_args.num_of_RPR);
-          printf("        interlace rows value will be set to num_of_records_per_req %u\n\n",
-                  g_args.num_of_RPR);
+                    g_Dbs.db[i].superTbls[j].insertRows);
+            printf("        interlace rows value will be set to insert_rows %"PRId64"\n\n",
+                    g_Dbs.db[i].superTbls[j].insertRows);
             prompt();
-          g_Dbs.db[i].superTbls[j].interlaceRows = g_args.num_of_RPR;
+            g_Dbs.db[i].superTbls[j].interlaceRows = g_Dbs.db[i].superTbls[j].insertRows;
         }
       } else if (!stbInterlaceRows) {
         g_Dbs.db[i].superTbls[j].interlaceRows = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
@@ -4209,22 +4227,6 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
         goto PARSE_OVER;
       }
 
-      cJSON* insertRows = cJSON_GetObjectItem(stbInfo, "insert_rows");
-      if (insertRows && insertRows->type == cJSON_Number) {
-        if (insertRows->valueint < 0) {
-          errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
-                __func__, __LINE__);
-          goto PARSE_OVER;
-        }
-        g_Dbs.db[i].superTbls[j].insertRows = insertRows->valueint;
-      } else if (!insertRows) {
-        g_Dbs.db[i].superTbls[j].insertRows = 0x7FFFFFFFFFFFFFFF;
-      } else {
-        errorPrint("%s() LN%d, failed to read json, insert_rows input mistake\n",
-                __func__, __LINE__);
-        goto PARSE_OVER;
-      }
-
       cJSON* insertInterval = cJSON_GetObjectItem(stbInfo, "insert_interval");
       if (insertInterval && insertInterval->type == cJSON_Number) {
         g_Dbs.db[i].superTbls[j].insertInterval = insertInterval->valueint;
@@ -4981,12 +4983,20 @@ static int64_t generateData(char *recBuf, char **data_type,
       bool b = rand_bool() & 1;
       pstr += sprintf(pstr, ",%s", b ? "true" : "false");
     } else if (strcasecmp(data_type[i % columnCount], "BINARY") == 0) {
-      char *s = malloc(lenOfBinary);
+      char *s = malloc(lenOfBinary + 1);
+      if (s == NULL) {
+          errorPrint("%s() LN%d, memory allocation %d bytes failed\n",
+                  __func__, __LINE__, lenOfBinary + 1);
+      }
       rand_string(s, lenOfBinary);
       pstr += sprintf(pstr, ",\"%s\"", s);
       free(s);
     } else if (strcasecmp(data_type[i % columnCount], "NCHAR") == 0) {
-      char *s = malloc(lenOfBinary);
+      char *s = malloc(lenOfBinary + 1);
+      if (s == NULL) {
+          errorPrint("%s() LN%d, memory allocation %d bytes failed\n",
+                  __func__, __LINE__, lenOfBinary + 1);
+      }
       rand_string(s, lenOfBinary);
       pstr += sprintf(pstr, ",\"%s\"", s);
       free(s);
@@ -5143,12 +5153,18 @@ static int32_t generateDataTailWithoutStb(
     char **data_type = g_args.datatype;
     int lenOfBinary = g_args.len_of_binary;
 
+    if (g_args.disorderRatio) {
         retLen = generateData(data, data_type,
                 startTime + getTSRandTail(
                     (int64_t) DEFAULT_TIMESTAMP_STEP, k,
                     g_args.disorderRatio,
                     g_args.disorderRange),
                 lenOfBinary);
+    } else {
+        retLen = generateData(data, data_type,
+                startTime + (int64_t) (DEFAULT_TIMESTAMP_STEP* k),
+                lenOfBinary);
+    }
 
     if (len > remainderBufLen)
         break;
@@ -5207,7 +5223,7 @@ static int32_t generateStbDataTail(
   verbosePrint("%s() LN%d batch=%u buflen=%"PRId64"\n",
           __func__, __LINE__, batch, remainderBufLen);
 
-  int32_t k = 0;
+  int32_t k;
   for (k = 0; k < batch;) {
     char data[MAX_DATA_SIZE];
     memset(data, 0, MAX_DATA_SIZE);
@@ -5656,10 +5672,15 @@ static int32_t prepareStmtWithoutStb(
 
         bind_ts = (int64_t *)ptr;
         bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+
+        if (g_args.disorderRatio) {
             *bind_ts = startTime + getTSRandTail(
                     (int64_t)DEFAULT_TIMESTAMP_STEP, k,
                     g_args.disorderRatio,
                     g_args.disorderRange);
+        } else {
+            *bind_ts = startTime + (int64_t)(DEFAULT_TIMESTAMP_STEP * k);
+        }
         bind->buffer_length = sizeof(int64_t);
         bind->buffer = bind_ts;
         bind->length = &bind->buffer_length;
@@ -5744,7 +5765,7 @@ static int32_t prepareStbStmt(
 
         bind_ts = (int64_t *)ptr;
         bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
-        if (sourceRand) {
+        if (stbInfo->disorderRatio) {
             *bind_ts = startTime + getTSRandTail(
                     stbInfo->timeStampStep, k,
                     stbInfo->disorderRatio,
@@ -5811,6 +5832,7 @@ static int32_t prepareStbStmt(
         if (!sourceRand) {
             (*pSamplePos) ++;
         }
+
         if (recordFrom >= insertRows) {
             break;
         }
@@ -5820,6 +5842,43 @@ static int32_t prepareStbStmt(
     free(bindArray);
     return k;
 }
+
+static int32_t prepareStbStmtInterlace(
+        SSuperTable *stbInfo,
+        TAOS_STMT *stmt,
+        char *tableName, uint32_t batch,
+        uint64_t insertRows,
+        uint64_t recordFrom,
+        int64_t startTime,
+        int64_t *pSamplePos)
+{
+    return prepareStbStmt(
+            stbInfo,
+            stmt,
+            tableName,
+            g_args.num_of_RPR,
+            insertRows, 0, startTime,
+            pSamplePos);
+}
+
+static int32_t prepareStbStmtProgressive(
+        SSuperTable *stbInfo,
+        TAOS_STMT *stmt,
+        char *tableName, uint32_t batch,
+        uint64_t insertRows,
+        uint64_t recordFrom,
+        int64_t startTime,
+        int64_t *pSamplePos)
+{
+    return prepareStbStmt(
+            stbInfo,
+            stmt,
+            tableName,
+            g_args.num_of_RPR,
+            insertRows, recordFrom, startTime,
+            pSamplePos);
+}
+
 #endif
 
 static int32_t generateStbProgressiveData(
@@ -5893,7 +5952,9 @@ static void printStatPerThread(threadInfo *pThreadInfo)
             pThreadInfo->threadID,
             pThreadInfo->totalInsertRows,
             pThreadInfo->totalAffectedRows,
-          (pThreadInfo->totalDelay)?(double)((pThreadInfo->totalAffectedRows / (pThreadInfo->totalDelay)/1000.0)): FLT_MAX);
+            (pThreadInfo->totalDelay/1000.0)?
+            (double)(pThreadInfo->totalAffectedRows/(pThreadInfo->totalDelay/1000.0)):
+            FLT_MAX);
 }
 
 // sync write interlace data
@@ -5992,7 +6053,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
 
     uint32_t recOfBatch = 0;
 
-    for (uint32_t i = 0; i < batchPerTblTimes; i ++) {
+    for (uint64_t i = 0; i < batchPerTblTimes; i ++) {
         char tableName[TSDB_TABLE_NAME_LEN];
 
       getTableName(tableName, pThreadInfo, tableSeq);
@@ -6009,7 +6070,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
       if (superTblInfo) {
           if (superTblInfo->iface == STMT_IFACE) {
 #if STMT_IFACE_ENABLED == 1
-              generated = prepareStbStmt(
+              generated = prepareStbStmtInterlace(
                       superTblInfo,
                       pThreadInfo->stmt,
                       tableName,
@@ -6238,7 +6299,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
       if (superTblInfo) {
           if (superTblInfo->iface == STMT_IFACE) {
 #if STMT_IFACE_ENABLED == 1
-              generated = prepareStbStmt(
+              generated = prepareStbStmtProgressive(
                       superTblInfo,
                       pThreadInfo->stmt,
                       tableName,
@@ -6668,13 +6729,24 @@ static void startMultiThreadInsertData(int threads, char* db_name,
 
         char buffer[3000];
         char *pstr = buffer;
-        pstr += sprintf(pstr, "INSERT INTO ? values(?");
+
+        if (AUTO_CREATE_SUBTBL == superTblInfo->autoCreateTable) {
+            pstr += sprintf(pstr, "INSERT INTO ? USING %s TAGS(?",
+                    superTblInfo->sTblName);
+            for (int tag = 0; tag < (superTblInfo->tagCount - 1); tag ++ ) {
+                pstr += sprintf(pstr, ",?");
+            }
+            pstr += sprintf(pstr, ") VALUES(?");
+        } else {
+            pstr += sprintf(pstr, "INSERT INTO ? VALUES(?");
+        }
 
         for (int col = 0; col < columnCount; col ++) {
             pstr += sprintf(pstr, ",?");
         }
         pstr += sprintf(pstr, ")");
 
+        debugPrint("%s() LN%d, buffer: %s", __func__, __LINE__, buffer);
         int ret = taos_stmt_prepare(pThreadInfo->stmt, buffer, 0);
         if (ret != 0){
             errorPrint("failed to execute taos_stmt_prepare. return 0x%x. reason: %s\n",
@@ -6758,34 +6830,40 @@ static void startMultiThreadInsertData(int threads, char* db_name,
   int64_t end = taosGetTimestampMs();
   int64_t t = end - start;
 
+  double tInMs = t/1000.0;
+
   if (superTblInfo) {
     fprintf(stderr, "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
-          t / 1000.0, superTblInfo->totalInsertRows,
+          tInMs, superTblInfo->totalInsertRows,
           superTblInfo->totalAffectedRows,
           threads, db_name, superTblInfo->sTblName,
-          (double)superTblInfo->totalInsertRows / (t / 1000.0));
+          (tInMs)?
+          (double)(superTblInfo->totalInsertRows/tInMs):FLT_MAX);
 
     if (g_fpOfInsertResult) {
       fprintf(g_fpOfInsertResult,
           "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s.%s. %.2f records/second\n\n",
-          t / 1000.0, superTblInfo->totalInsertRows,
+          tInMs, superTblInfo->totalInsertRows,
           superTblInfo->totalAffectedRows,
           threads, db_name, superTblInfo->sTblName,
-          (double)superTblInfo->totalInsertRows / (t / 1000.0));
+          (tInMs)?
+          (double)(superTblInfo->totalInsertRows/tInMs):FLT_MAX);
     }
   } else {
     fprintf(stderr, "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s %.2f records/second\n\n",
-          t / 1000.0, g_args.totalInsertRows,
+          tInMs, g_args.totalInsertRows,
           g_args.totalAffectedRows,
           threads, db_name,
-          (double)g_args.totalInsertRows / (t / 1000.0));
+          (tInMs)?
+          (double)(g_args.totalInsertRows/tInMs):FLT_MAX);
     if (g_fpOfInsertResult) {
       fprintf(g_fpOfInsertResult,
           "Spent %.2f seconds to insert rows: %"PRIu64", affected rows: %"PRIu64" with %d thread(s) into %s %.2f records/second\n\n",
-          t * 1000.0, g_args.totalInsertRows,
+          tInMs, g_args.totalInsertRows,
           g_args.totalAffectedRows,
           threads, db_name,
-          (double)g_args.totalInsertRows / (t / 1000.0));
+          (tInMs)?
+          (double)(g_args.totalInsertRows/tInMs):FLT_MAX);
     }
   }
 

src/mnode/inc/mnodeDef.h

@@ -214,6 +214,23 @@ typedef struct SUserObj {
   struct SAcctObj * pAcct;
 } SUserObj;
 
+typedef struct SFuncObj {
+  char              name[TSDB_FUNC_NAME_LEN];
+  char              path[128];
+  int32_t           contLen;
+  char              cont[TSDB_FUNC_CODE_LEN];
+  int32_t           funcType;
+  int32_t           bufSize;
+  int64_t           createdTime;
+  uint8_t           resType;
+  int16_t           resBytes;
+  int64_t           sig;         // partial md5 sign
+  int16_t           type;        // [lua script|so|js]
+  int8_t            reserved[64];
+  int8_t            updateEnd[4];
+  int32_t           refCount;
+} SFuncObj;
+
 typedef struct {
   int64_t totalStorage;  // Total storage wrtten from this account
   int64_t compStorage;   // Compressed storage on disk
@@ -258,7 +275,7 @@ typedef struct {
   void *   pIter;
   void **  ppShow;
   int16_t  offset[TSDB_MAX_COLUMNS];
-  int16_t  bytes[TSDB_MAX_COLUMNS];
+  int32_t  bytes[TSDB_MAX_COLUMNS];
   int32_t  numOfReads;
   int8_t   maxReplica;
   int8_t   reserved0[1];

src/mnode/inc/mnodeFunc.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_MNODE_FUNC_H
+#define TDENGINE_MNODE_FUNC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "mnodeDef.h"
+
+int32_t   mnodeInitFuncs();
+void      mnodeCleanupFuncs();
+
+SFuncObj *mnodeGetFunc(char *name);
+void *    mnodeGetNextFunc(void *pIter, SFuncObj **pFunc);
+void      mnodeCancelGetNextFunc(void *pIter);
+
+void      mnodeIncFuncRef(SFuncObj *pFunc);
+void      mnodeDecFuncRef(SFuncObj *pFunc);
+
+int32_t   mnodeCreateFunc(SAcctObj *pAcct, char *name, int32_t codeLen, char *code, char *path, uint8_t outputType, int16_t outputLen, int32_t funcType, int32_t bufSize, SMnodeMsg *pMsg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/mnode/inc/mnodeSdb.h

@@ -33,7 +33,8 @@ typedef enum {
   SDB_TABLE_VGROUP  = 6,
   SDB_TABLE_STABLE  = 7,
   SDB_TABLE_CTABLE  = 8,
-  SDB_TABLE_MAX     = 9
+  SDB_TABLE_FUNC    = 9,
+  SDB_TABLE_MAX     = 10
 } ESdbTable;
 
 typedef enum {

src/mnode/src/mnodeDb.c

@@ -554,6 +554,9 @@ void mnodeCleanupDbs() {
   tsDbSdb = NULL;
 }
 
+
+
+
 static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 

src/mnode/src/mnodeFunc.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "trpc.h"
+#include "tutil.h"
+#include "tglobal.h"
+#include "tgrant.h"
+#include "tdataformat.h"
+#include "tkey.h"
+#include "mnode.h"
+#include "dnode.h"
+#include "mnodeDef.h"
+#include "mnodeInt.h"
+#include "mnodeAcct.h"
+#include "mnodeUser.h"
+#include "mnodeMnode.h"
+#include "mnodeSdb.h"
+#include "mnodeShow.h"
+#include "mnodeFunc.h"
+#include "mnodeWrite.h"
+#include "mnodeRead.h"
+#include "mnodePeer.h"
+
+int64_t        tsFuncRid = -1;
+static void *  tsFuncSdb = NULL;
+static int32_t tsFuncUpdateSize = 0;
+static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
+static int32_t mnodeProcessRetrieveFuncImplMsg(SMnodeMsg *pMsg);
+static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg);
+static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg);
+
+static int32_t mnodeFuncActionDestroy(SSdbRow *pRow) {
+  tfree(pRow->pObj);
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeFuncActionInsert(SSdbRow *pRow) {
+  SFuncObj *pFunc = pRow->pObj;
+
+  mTrace("func:%s, contLen: %d, insert into sdb", pFunc->name, pFunc->contLen);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeFuncActionDelete(SSdbRow *pRow) {
+  SFuncObj *pFunc = pRow->pObj;
+
+  mTrace("func:%s, length: %d, delete from sdb", pFunc->name, pFunc->contLen);
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeFuncActionUpdate(SSdbRow *pRow) {
+  SFuncObj *pFunc = pRow->pObj;
+
+  SFuncObj *pSaved = mnodeGetFunc(pFunc->name);
+  if (pFunc != pSaved) {
+    memcpy(pSaved, pFunc, tsFuncUpdateSize);
+    free(pFunc);
+  }
+
+  mnodeDecFuncRef(pSaved);
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeFuncActionEncode(SSdbRow *pRow) {
+  SFuncObj *pFunc = pRow->pObj;
+
+  memcpy(pRow->rowData, pFunc, tsFuncUpdateSize);
+  pRow->rowSize = tsFuncUpdateSize;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeFuncActionDecode(SSdbRow *pRow) {
+  SFuncObj *pFunc = (SFuncObj *)calloc(1, sizeof(SFuncObj));
+  if (pFunc == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY;
+
+  memcpy(pFunc, pRow->rowData, tsFuncUpdateSize);
+  pRow->pObj = pFunc;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeFuncActionRestored() {
+  int64_t numOfRows = sdbGetNumOfRows(tsFuncSdb);
+
+  if (numOfRows <= 0 && dnodeIsFirstDeploy()) {
+    mInfo("dnode first deploy, func restored.");
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t mnodeInitFuncs() {
+  SFuncObj tObj;
+  tsFuncUpdateSize = (int32_t)((int8_t *)tObj.updateEnd - (int8_t *)&tObj);
+
+  SSdbTableDesc desc = {
+    .id           = SDB_TABLE_FUNC,
+    .name         = "funcs",
+    .hashSessions = TSDB_DEFAULT_USERS_HASH_SIZE,
+    .maxRowSize   = tsFuncUpdateSize,
+    .refCountPos  = (int32_t)((int8_t *)(&tObj.refCount) - (int8_t *)&tObj),
+    .keyType      = SDB_KEY_STRING,
+    .fpInsert     = mnodeFuncActionInsert,
+    .fpDelete     = mnodeFuncActionDelete,
+    .fpUpdate     = mnodeFuncActionUpdate,
+    .fpEncode     = mnodeFuncActionEncode,
+    .fpDecode     = mnodeFuncActionDecode,
+    .fpDestroy    = mnodeFuncActionDestroy,
+    .fpRestored   = mnodeFuncActionRestored
+  };
+
+  tsFuncRid = sdbOpenTable(&desc);
+  tsFuncSdb = sdbGetTableByRid(tsFuncRid);
+  if (tsFuncSdb == NULL) {
+    mError("table:%s, failed to create hash", desc.name);
+    return -1;
+  }
+
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_CREATE_FUNCTION, mnodeProcessCreateFuncMsg);
+  mnodeAddWriteMsgHandle(TSDB_MSG_TYPE_CM_DROP_FUNCTION, mnodeProcessDropFuncMsg);
+  mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_RETRIEVE_FUNC, mnodeProcessRetrieveFuncImplMsg);
+
+  mnodeAddShowMetaHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeGetFuncMeta);
+  mnodeAddShowRetrieveHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeRetrieveFuncs);
+  mnodeAddShowFreeIterHandle(TSDB_MGMT_TABLE_FUNCTION, mnodeCancelGetNextFunc);
+
+  mDebug("table:%s, hash is created", desc.name);
+
+  return 0;
+}
+
+void mnodeCleanupFuncs() {
+  sdbCloseTable(tsFuncRid);
+  tsFuncSdb = NULL;
+}
+
+SFuncObj *mnodeGetFunc(char *name) {
+  return (SFuncObj *)sdbGetRow(tsFuncSdb, name);
+}
+
+void *mnodeGetNextFunc(void *pIter, SFuncObj **pFunc) {
+  return sdbFetchRow(tsFuncSdb, pIter, (void **)pFunc);
+}
+
+void mnodeCancelGetNextFunc(void *pIter) {
+ sdbFreeIter(tsFuncSdb, pIter);
+}
+
+void mnodeIncFuncRef(SFuncObj *pFunc) {
+  sdbIncRef(tsFuncSdb, pFunc);
+}
+
+void mnodeDecFuncRef(SFuncObj *pFunc) {
+  sdbDecRef(tsFuncSdb, pFunc);
+}
+/*
+static int32_t mnodeUpdateFunc(SFuncObj *pFunc, void *pMsg) {
+  SSdbRow row = {
+    .type   = SDB_OPER_GLOBAL,
+    .pTable = tsFuncSdb,
+    .pObj   = pFunc,
+    .pMsg   = pMsg
+  };
+
+  int32_t code = sdbUpdateRow(&row);
+  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("func:%s, failed to alter by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
+  } else {
+    mLInfo("func:%s, is altered by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
+  }
+
+  return code;
+}
+*/
+int32_t mnodeCreateFunc(SAcctObj *pAcct, char *name, int32_t codeLen, char *codeScript, char *path, uint8_t outputType, int16_t outputLen, int32_t funcType, int32_t bufSize, SMnodeMsg *pMsg) {
+  if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) {
+    return TSDB_CODE_GRANT_EXPIRED;
+  }
+
+  if (!pMsg->pUser->writeAuth) {
+    return TSDB_CODE_MND_NO_RIGHTS;
+  }
+
+  int32_t code = acctCheck(pAcct, ACCT_GRANT_USER);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  code = grantCheck(TSDB_GRANT_USER);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  if (name[0] == 0) {
+    return TSDB_CODE_MND_INVALID_FUNC_NAME;
+  }
+
+  if (codeScript[0] == 0) {
+    return TSDB_CODE_MND_INVALID_FUNC_CODE;
+  }
+
+  if (codeLen < 0 || codeLen > TSDB_FUNC_CODE_LEN) {
+    return TSDB_CODE_MND_INVALID_FUNC_CODE;
+  }
+
+  if (bufSize < 0 || bufSize > TSDB_FUNC_BUF_SIZE) {
+    return TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
+  }
+
+  SFuncObj *pFunc = mnodeGetFunc(name);
+  if (pFunc != NULL) {
+    mDebug("func:%s, is already there", name);
+    mnodeDecFuncRef(pFunc);
+    return TSDB_CODE_MND_FUNC_ALREADY_EXIST;
+  }
+
+  pFunc = calloc(1, sizeof(SFuncObj));
+  tstrncpy(pFunc->name, name, TSDB_FUNC_NAME_LEN);
+  tstrncpy(pFunc->path, path, tListLen(pFunc->path));
+  memcpy(pFunc->cont, codeScript, codeLen);
+  pFunc->contLen     = codeLen;
+  pFunc->createdTime = taosGetTimestampMs();
+  pFunc->resType     = outputType;
+  pFunc->resBytes    = outputLen;
+  pFunc->funcType    = funcType;
+  pFunc->bufSize     = bufSize;
+  pFunc->sig  = 0;
+  pFunc->type = 1; //lua script, refactor
+
+  SSdbRow row = {
+    .type     = SDB_OPER_GLOBAL,
+    .pTable   = tsFuncSdb,
+    .pObj     = pFunc,
+    .rowSize  = sizeof(SFuncObj),
+    .pMsg     = pMsg
+  };
+
+  code = sdbInsertRow(&row);
+  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("func:%s, failed to create by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
+    tfree(pFunc);
+  } else {
+    mLInfo("func:%s, is created by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
+  }
+
+  return code;
+}
+
+static int32_t mnodeDropFunc(SFuncObj *pFunc, void *pMsg) {
+  SSdbRow row = {
+    .type   = SDB_OPER_GLOBAL,
+    .pTable = tsFuncSdb,
+    .pObj   = pFunc,
+    .pMsg   = pMsg
+  };
+
+  int32_t code = sdbDeleteRow(&row);
+  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
+    mError("func:%s, failed to drop by %s, reason:%s", pFunc->name, mnodeGetUserFromMsg(pMsg), tstrerror(code));
+  } else {
+    mLInfo("func:%s, is dropped by %s", pFunc->name, mnodeGetUserFromMsg(pMsg));
+  }
+
+  return code;
+}
+
+static int32_t mnodeGetFuncsNum() {
+  return (int32_t)sdbGetNumOfRows(tsFuncSdb);
+}
+
+static int32_t mnodeGetFuncMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
+  SUserObj *pUser = mnodeGetUserFromConn(pConn);
+  if (pUser == NULL) {
+    return TSDB_CODE_MND_NO_USER_FROM_CONN;
+  }
+
+  int32_t cols = 0;
+  SSchema *pSchema = pMeta->schema;
+
+  pShow->bytes[cols] = TSDB_FUNC_NAME_LEN + VARSTR_HEADER_SIZE;
+  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema[cols].name, "name");
+  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  cols++;
+
+  pShow->bytes[cols] = PATH_MAX + VARSTR_HEADER_SIZE;
+  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema[cols].name, "path");
+  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  cols++;
+
+  pShow->bytes[cols] = 4;
+  pSchema[cols].type = TSDB_DATA_TYPE_INT;
+  strcpy(pSchema[cols].name, "aggregate");
+  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  cols++;
+
+  pShow->bytes[cols] = TSDB_TYPE_STR_MAX_LEN + VARSTR_HEADER_SIZE;
+  pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
+  strcpy(pSchema[cols].name, "outputtype");
+  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  cols++;
+
+  pShow->bytes[cols] = 8;
+  pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
+  strcpy(pSchema[cols].name, "create_time");
+  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  cols++;
+
+  pShow->bytes[cols] = 4;
+  pSchema[cols].type = TSDB_DATA_TYPE_INT;
+  strcpy(pSchema[cols].name, "code_len");
+  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  cols++;
+
+  pShow->bytes[cols] = 4;
+  pSchema[cols].type = TSDB_DATA_TYPE_INT;
+  strcpy(pSchema[cols].name, "bufsize");
+  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  cols++;
+
+  pMeta->numOfColumns = htons(cols);
+  strcpy(pMeta->tableFname, "show funcs");
+  pShow->numOfColumns = cols;
+
+  pShow->offset[0] = 0;
+  for (int32_t i = 1; i < cols; ++i) {
+    pShow->offset[i] = pShow->offset[i - 1] + pShow->bytes[i - 1];
+  }
+
+  pShow->numOfRows = mnodeGetFuncsNum();
+  pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
+
+  mnodeDecUserRef(pUser);
+
+  return 0;
+}
+
+static void* mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t len) {
+  char *msg = "unknown";
+  if (type >= sizeof(tDataTypes)/sizeof(tDataTypes[0])) {
+    return msg;
+  }
+  
+  if (type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BINARY) {
+    int32_t bytes = len > 0 ? (int)(len - VARSTR_HEADER_SIZE) : len;
+    
+    snprintf(buf, buflen - 1, "%s(%d)", tDataTypes[type].name, type == TSDB_DATA_TYPE_NCHAR ? bytes/4 : bytes);
+    buf[buflen - 1] = 0;
+
+    return buf;
+  }
+  
+  return tDataTypes[type].name;
+}
+
+static int32_t mnodeRetrieveFuncs(SShowObj *pShow, char *data, int32_t rows, void *pConn) {
+  int32_t   numOfRows = 0;
+  SFuncObj *pFunc    = NULL;
+  int32_t   cols      = 0;
+  char     *pWrite;
+  char      buf[TSDB_TYPE_STR_MAX_LEN];
+
+  while (numOfRows < rows) {
+    pShow->pIter = mnodeGetNextFunc(pShow->pIter, &pFunc);
+    if (pFunc == NULL) break;
+
+    cols = 0;
+
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->name, pShow->bytes[cols]);
+    cols++;
+
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, pFunc->path, pShow->bytes[cols]);
+    cols++;
+
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+    *(int32_t *)pWrite = pFunc->funcType == TSDB_UDF_TYPE_AGGREGATE ? 1 : 0;
+    cols++;
+
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+    STR_WITH_MAXSIZE_TO_VARSTR(pWrite, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->resType, pFunc->resBytes), pShow->bytes[cols]);
+    cols++;
+
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+    *(int64_t *)pWrite = pFunc->createdTime;
+    cols++;
+
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+    *(int32_t *)pWrite = pFunc->contLen;
+    cols++;
+
+    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+    *(int32_t *)pWrite = pFunc->bufSize;
+    cols++;
+
+    numOfRows++;
+    mnodeDecFuncRef(pFunc);
+  }
+
+  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
+  pShow->numOfReads += numOfRows;
+  return numOfRows;
+}
+
+static int32_t mnodeProcessCreateFuncMsg(SMnodeMsg *pMsg) {
+  SCreateFuncMsg *pCreate    = pMsg->rpcMsg.pCont;
+  pCreate->codeLen       = htonl(pCreate->codeLen);
+  pCreate->outputLen     = htons(pCreate->outputLen);
+  pCreate->funcType      = htonl(pCreate->funcType);
+  pCreate->bufSize       = htonl(pCreate->bufSize);
+
+  return mnodeCreateFunc(pMsg->pUser->pAcct, pCreate->name, pCreate->codeLen, pCreate->code, pCreate->path, pCreate->outputType, pCreate->outputLen, pCreate->funcType, pCreate->bufSize, pMsg);
+}
+
+static int32_t mnodeProcessDropFuncMsg(SMnodeMsg *pMsg) {
+  SDropFuncMsg *pDrop = pMsg->rpcMsg.pCont;
+
+  SFuncObj *pFunc = mnodeGetFunc(pDrop->name);
+  if (pFunc == NULL) {
+    return TSDB_CODE_MND_INVALID_FUNC;
+  }
+
+  return mnodeDropFunc(pFunc, pMsg);
+}
+
+static int32_t mnodeProcessRetrieveFuncImplMsg(SMnodeMsg *pMsg) {
+  SRetrieveFuncMsg *pInfo = pMsg->rpcMsg.pCont;
+  pInfo->num = htonl(pInfo->num);
+
+  int32_t t = sizeof(SUdfFuncMsg) + (sizeof(SFunctionInfoMsg) + TSDB_FUNC_CODE_LEN) * pInfo->num + 16384;
+
+  SUdfFuncMsg *pFuncMsg = rpcMallocCont(t);
+  pFuncMsg->num = htonl(pInfo->num);
+  char* pOutput = pFuncMsg->content;
+  tstr* name = (tstr*) pInfo->name;
+
+  for(int32_t i = 0; i < pInfo->num; ++i) {
+    char buf[TSDB_FUNC_NAME_LEN] = {0};
+    tstrncpy(buf, name->data, htons(name->len) + 1);
+
+    SFuncObj* pFuncObj = mnodeGetFunc(buf);
+    if (pFuncObj == NULL) {
+      mError("function %s does not exist", buf);
+      return TSDB_CODE_MND_INVALID_FUNC;
+    }
+    
+    SFunctionInfoMsg* pFuncInfo = (SFunctionInfoMsg*) pOutput;
+
+    strcpy(pFuncInfo->name, buf);
+    pFuncInfo->len = htonl(pFuncObj->contLen);
+    memcpy(pFuncInfo->content, pFuncObj->cont, pFuncObj->contLen);
+
+    pFuncInfo->funcType = htonl(pFuncObj->funcType);
+    pFuncInfo->resType = pFuncObj->resType;
+    pFuncInfo->resBytes = htons(pFuncObj->resBytes);
+    pFuncInfo->bufSize  = htonl(pFuncObj->bufSize);
+    
+    pOutput += sizeof(SFunctionInfoMsg) + pFuncObj->contLen;
+    name =(tstr *)((char *)name + sizeof(*name) + htons(name->len));
+  }
+
+  pMsg->rpcRsp.rsp = pFuncMsg;
+  pMsg->rpcRsp.len = (int32_t)(pOutput - (char*)pFuncMsg);
+  return TSDB_CODE_SUCCESS;
+}

src/mnode/src/mnodeMain.c

@@ -32,6 +32,7 @@
 #include "mnodeSdb.h"
 #include "mnodeVgroup.h"
 #include "mnodeUser.h"
+#include "mnodeFunc.h"
 #include "mnodeTable.h"
 #include "mnodeCluster.h"
 #include "mnodeShow.h"
@@ -46,6 +47,7 @@ static SStep tsMnodeSteps[] = {
   {"cluster", mnodeInitCluster, mnodeCleanupCluster},
   {"accts",   mnodeInitAccts,   mnodeCleanupAccts},
   {"users",   mnodeInitUsers,   mnodeCleanupUsers},
+  {"funcs",   mnodeInitFuncs,   mnodeCleanupFuncs},
   {"dnodes",  mnodeInitDnodes,  mnodeCleanupDnodes},
   {"dbs",     mnodeInitDbs,     mnodeCleanupDbs},
   {"vgroups", mnodeInitVgroups, mnodeCleanupVgroups},

src/mnode/src/mnodeTable.c

@@ -42,6 +42,7 @@
 #include "mnodeWrite.h"
 #include "mnodeRead.h"
 #include "mnodePeer.h"
+#include "mnodeFunc.h"
 
 #define ALTER_CTABLE_RETRY_TIMES  3
 #define CREATE_CTABLE_RETRY_TIMES 10
@@ -2926,6 +2927,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
 
   pInfo->numOfTables  = htonl(pInfo->numOfTables);
   pInfo->numOfVgroups = htonl(pInfo->numOfVgroups);
+  pInfo->numOfUdfs    = htonl(pInfo->numOfUdfs);
 
   int32_t contLen = pMsg->rpcMsg.contLen - sizeof(SMultiTableInfoMsg);
 
@@ -2934,9 +2936,9 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   char*   str      = strndup(pInfo->tableNames, contLen);
   char**  nameList = strsplit(str, ",", &num);
   SArray* pList    = taosArrayInit(4, POINTER_BYTES);
-  SMultiTableMeta *pMultiMeta = NULL;
 
-  if (num != pInfo->numOfTables + pInfo->numOfVgroups) {
+  SMultiTableMeta *pMultiMeta = NULL;
+  if (num != pInfo->numOfTables + pInfo->numOfVgroups + pInfo->numOfUdfs) {
     mError("msg:%p, app:%p, failed to get multi-tableMeta, msg inconsistent", pMsg, pMsg->rpcMsg.ahandle);
     code = TSDB_CODE_MND_INVALID_TABLE_NAME;
     goto _end;
@@ -3011,8 +3013,10 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
     }
   }
 
+  int32_t tableNum = pInfo->numOfTables + pInfo->numOfVgroups;
+
   // add the additional super table names that needs the vgroup info
-  for(;t < num; ++t) {
+  for(;t < tableNum; ++t) {
     taosArrayPush(pList, &nameList[t]);
   }
 
@@ -3043,6 +3047,36 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   pMultiMeta->contLen = (int32_t) (msg - (char*) pMultiMeta);
 
   pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
+
+  // add the user-defined-function information
+  for(int32_t i = 0; i < pInfo->numOfUdfs; ++i, ++t) {
+    char buf[TSDB_FUNC_NAME_LEN] = {0};
+    strcpy(buf, nameList[t]);
+
+    SFuncObj* pFuncObj = mnodeGetFunc(buf);
+    if (pFuncObj == NULL) {
+      mError("function %s does not exist", buf);
+      code = TSDB_CODE_MND_INVALID_FUNC;
+      goto _end;
+    }
+
+    SFunctionInfoMsg* pFuncInfo = (SFunctionInfoMsg*) msg;
+
+    strcpy(pFuncInfo->name, buf);
+    pFuncInfo->len = htonl(pFuncObj->contLen);
+    memcpy(pFuncInfo->content, pFuncObj->cont, pFuncObj->contLen);
+
+    pFuncInfo->funcType = htonl(pFuncObj->funcType);
+    pFuncInfo->resType  = pFuncObj->resType;
+    pFuncInfo->resBytes = htons(pFuncObj->resBytes);
+    pFuncInfo->bufSize  = htonl(pFuncObj->bufSize);
+
+    msg += sizeof(SFunctionInfoMsg) + pFuncObj->contLen;
+  }
+
+  pMultiMeta->contLen  = (int32_t) (msg - (char*) pMultiMeta);
+  pMultiMeta->numOfUdf = htonl(pInfo->numOfUdfs);
+
   pMsg->rpcRsp.rsp = pMultiMeta;
   pMsg->rpcRsp.len = pMultiMeta->contLen;
   code = TSDB_CODE_SUCCESS;
@@ -3053,11 +3087,12 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
     goto _end;
   }
 
-  int32_t len = tsCompressString(pMultiMeta->meta, (int32_t)pMultiMeta->contLen - sizeof(SMultiTableMeta), 1,
-      tmp + sizeof(SMultiTableMeta), (int32_t)pMultiMeta->contLen - sizeof(SMultiTableMeta) + 2, ONE_STAGE_COMP, NULL, 0);
+  int32_t dataLen = (int32_t)pMultiMeta->contLen - sizeof(SMultiTableMeta);
+  int32_t len = tsCompressString(pMultiMeta->meta, dataLen, 1, tmp + sizeof(SMultiTableMeta), (int32_t)dataLen + 2,
+                                 ONE_STAGE_COMP, NULL, 0);
 
   pMultiMeta->rawLen = pMultiMeta->contLen;
-  if (len == -1 || len + sizeof(SMultiTableMeta) >= pMultiMeta->contLen + 2) { // compress failed, do not compress this binary data
+  if (len == -1 || len >= dataLen + 2) { // compress failed, do not compress this binary data
     pMultiMeta->compressed = 0;
     memcpy(tmp, pMultiMeta, sizeof(SMultiTableMeta) + pMultiMeta->contLen);
   } else {

src/os/inc/os.h

@@ -37,6 +37,7 @@ extern "C" {
 #include "osSysinfo.h"
 #include "osTime.h"
 #include "osTimer.h"
+#include "osSystem.h"
 
 void osInit();
 

src/os/inc/osInc.h

@@ -77,6 +77,7 @@ extern "C" {
     #include "osEok.h"
   #else
     #include <argp.h>
+    #include <dlfcn.h>
     #include <endian.h>
     #include <linux/sysctl.h>
     #include <poll.h>

src/os/inc/osSystem.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_OS_SYSTEM_H
+#define TDENGINE_OS_SYSTEM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void* taosLoadDll(const char *filename);
+void* taosLoadSym(void* handle, char* name);
+void taosCloseDll(void *handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/os/src/darwin/darwinSystem.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tglobal.h"
+#include "tulog.h"
+
+void* taosLoadDll(const char *filename) {
+  return NULL;
+}
+
+void* taosLoadSym(void* handle, char* name) {
+  return NULL;
+}
+
+void taosCloseDll(void *handle) {
+}
+
+

src/os/src/linux/CMakeLists.txt

@@ -4,4 +4,4 @@ PROJECT(TDengine)
 AUX_SOURCE_DIRECTORY(. SRC)
 ADD_LIBRARY(oslinux ${SRC})
 
-TARGET_LINK_LIBRARIES(oslinux m rt z)
+TARGET_LINK_LIBRARIES(oslinux m rt z dl)
\ No newline at end of file

src/os/src/linux/osSystem.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tconfig.h"
+#include "tglobal.h"
+#include "tulog.h"
+
+void* taosLoadDll(const char *filename) {
+  void *handle = dlopen (filename, RTLD_LAZY);  
+  if (!handle) {  
+    uError("load dll:%s failed, error:%s", filename, dlerror());  
+    return NULL;  
+  }
+
+  uDebug("dll %s loaded", filename);
+
+  return handle;
+}
+
+void* taosLoadSym(void* handle, char* name) {
+	void* sym = dlsym(handle, name);
+  char* error = NULL;
+  
+	if ((error = dlerror()) != NULL)  {  
+    uWarn("load sym:%s failed, error:%s", name, dlerror());  
+		return NULL;  
+	} 
+
+  uDebug("sym %s loaded", name)
+
+  return sym;
+}
+
+void taosCloseDll(void *handle) {
+  if (handle) {
+    dlclose(handle);
+  }
+}
+
+

src/os/src/windows/wSystem.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "os.h"
+#include "tglobal.h"
+#include "tulog.h"
+
+void* taosLoadDll(const char *filename) {
+  return NULL;
+}
+
+void* taosLoadSym(void* handle, char* name) {
+  return NULL;
+}
+
+void taosCloseDll(void *handle) {
+}
+
+

src/plugins/http/inc/httpParser.h

@@ -17,7 +17,7 @@
 #define HTTP_PARSER_H
 #include "httpGzip.h"
 
-#define HTTP_MAX_URL 5  // http url stack size
+#define HTTP_MAX_URL 6  // http url stack size
 
 #define HTTP_CODE_CONTINUE                 100
 #define HTTP_CODE_SWITCHING_PROTOCOL       101

src/plugins/http/src/httpRestHandle.c

@@ -119,6 +119,90 @@ bool restProcessSqlRequest(HttpContext* pContext, int32_t timestampFmt) {
   return true;
 }
 
+#define REST_FUNC_URL_POS   2
+#define REST_OUTP_URL_POS   3
+#define REST_AGGR_URL_POS   4
+#define REST_BUFF_URL_POS   5
+
+#define HTTP_FUNC_LEN  32
+#define HTTP_OUTP_LEN  16
+#define HTTP_AGGR_LEN  2
+#define HTTP_BUFF_LEN  32
+
+static int udfSaveFile(const char *fname, const char *content, long len) {
+  int fd = open(fname, O_WRONLY | O_CREAT | O_EXCL | O_BINARY, 0755);
+  if (fd < 0)
+    return -1;
+  if (taosWrite(fd, (void *)content, len) < 0)
+    return -1;
+
+  return 0;
+}
+
+static bool restProcessUdfRequest(HttpContext* pContext) {
+  HttpParser* pParser = pContext->parser;
+  if (pParser->path[REST_FUNC_URL_POS].pos >= HTTP_FUNC_LEN || pParser->path[REST_FUNC_URL_POS].pos <= 0) {
+    return false;
+  }
+
+  if (pParser->path[REST_OUTP_URL_POS].pos >= HTTP_OUTP_LEN || pParser->path[REST_OUTP_URL_POS].pos <= 0) {
+    return false;
+  }
+
+  if (pParser->path[REST_AGGR_URL_POS].pos >= HTTP_AGGR_LEN || pParser->path[REST_AGGR_URL_POS].pos <= 0) {
+    return false;
+  }
+
+  if (pParser->path[REST_BUFF_URL_POS].pos >= HTTP_BUFF_LEN || pParser->path[REST_BUFF_URL_POS].pos <= 0) {
+    return false;
+  }
+
+  char* sql = pContext->parser->body.str;
+  int len = pContext->parser->body.pos;
+  if (sql == NULL) {
+    httpSendErrorResp(pContext, TSDB_CODE_HTTP_NO_SQL_INPUT);
+    return false;
+  }
+
+  char udfDir[256] = {0};
+  char buf[64] = "udf-";
+  char funcName[64] = {0};
+  int aggr = 0;
+  char outputType[16] = {0};
+  char buffSize[32] = {0};
+
+  tstrncpy(funcName, pParser->path[REST_FUNC_URL_POS].str, HTTP_FUNC_LEN);
+  tstrncpy(buf + 4, funcName, HTTP_FUNC_LEN);
+
+  if (pParser->path[REST_AGGR_URL_POS].str[0] != '0') {
+    aggr = 1;
+  }
+
+  tstrncpy(outputType, pParser->path[REST_OUTP_URL_POS].str, HTTP_OUTP_LEN);
+  tstrncpy(buffSize, pParser->path[REST_BUFF_URL_POS].str, HTTP_BUFF_LEN);
+
+  taosGetTmpfilePath(funcName, udfDir);
+
+  udfSaveFile(udfDir, sql, len);
+
+  tfree(sql);
+  pContext->parser->body.str = malloc(1024);
+  sql = pContext->parser->body.str;
+  int sqlLen = sprintf(sql, "create %s function %s as \"%s\" outputtype %s bufsize %s",
+          aggr == 1  ? "aggregate" : " ", funcName, udfDir, outputType, buffSize);
+
+  pContext->parser->body.pos = sqlLen;
+  pContext->parser->body.size = sqlLen + 1;
+
+  HttpSqlCmd* cmd = &(pContext->singleCmd);
+  cmd->nativSql = sql;
+
+  pContext->reqType = HTTP_REQTYPE_SINGLE_SQL;
+  pContext->encodeMethod = &restEncodeSqlLocalTimeStringMethod;
+
+  return true;
+}
+
 bool restProcessRequest(struct HttpContext* pContext) {
   if (httpUrlMatch(pContext, REST_ACTION_URL_POS, "login")) {
     restGetUserFromUrl(pContext);
@@ -138,6 +222,8 @@ bool restProcessRequest(struct HttpContext* pContext) {
     return restProcessSqlRequest(pContext, REST_TIMESTAMP_FMT_UTC_STRING);
   } else if (httpUrlMatch(pContext, REST_ACTION_URL_POS, "login")) {
     return restProcessLoginRequest(pContext);
+  } else if (httpUrlMatch(pContext, REST_ACTION_URL_POS, "udf")) {
+    return restProcessUdfRequest(pContext);
   } else {
   }
 

src/query/CMakeLists.txt

@@ -8,14 +8,14 @@ INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 ADD_LIBRARY(query ${SRC})
 SET_SOURCE_FILES_PROPERTIES(src/sql.c PROPERTIES COMPILE_FLAGS -w)
-TARGET_LINK_LIBRARIES(query tsdb tutil)
+TARGET_LINK_LIBRARIES(query tsdb tutil lua)
 
 IF (TD_LINUX)
-  TARGET_LINK_LIBRARIES(query m rt)
+  TARGET_LINK_LIBRARIES(query m rt lua)
   ADD_SUBDIRECTORY(tests)
 ENDIF ()
 
 IF (TD_DARWIN)
-  TARGET_LINK_LIBRARIES(query m)
+  TARGET_LINK_LIBRARIES(query m lua)
   ADD_SUBDIRECTORY(tests)
 ENDIF ()

src/query/inc/qAggMain.h

@@ -27,6 +27,7 @@ extern "C" {
 #include "trpc.h"
 #include "tvariant.h"
 #include "tsdb.h"
+#include "qUdf.h"
 
 #define TSDB_FUNC_INVALID_ID  -1
 #define TSDB_FUNC_COUNT        0
@@ -201,10 +202,8 @@ typedef struct SAggFunctionInfo {
   int8_t   stableFuncId;  // transfer function for super table query
   uint16_t status;
 
-  bool (*init)(SQLFunctionCtx *pCtx);  // setup the execute environment
-
+  bool (*init)(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultCellInfo);  // setup the execute environment
   void (*xFunction)(SQLFunctionCtx *pCtx);                     // blocks version function
-//  void (*xFunctionF)(SQLFunctionCtx *pCtx, int32_t position);  // single-row function version, todo merge with blockwise function
 
   // finalizer must be called after all xFunction has been executed to generated final result.
   void (*xFinalize)(SQLFunctionCtx *pCtx);
@@ -216,7 +215,7 @@ typedef struct SAggFunctionInfo {
 #define GET_RES_INFO(ctx) ((ctx)->resultInfo)
 
 int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionId, int32_t param, int16_t *type,
-                          int16_t *len, int32_t *interBytes, int16_t extLength, bool isSuperTable);
+                          int16_t *len, int32_t *interBytes, int16_t extLength, bool isSuperTable, SUdfInfo* pUdfInfo);
 int32_t isValidFunction(const char* name, int32_t len);
 
 #define IS_STREAM_QUERY_VALID(x)  (((x)&TSDB_FUNCSTATE_STREAM) != 0)

src/query/inc/qExecutor.h

@@ -29,6 +29,7 @@
 #include "tarray.h"
 #include "tlockfree.h"
 #include "tsdb.h"
+#include "qUdf.h"
 
 struct SColumnFilterElem;
 typedef bool (*__filter_func_t)(struct SColumnFilterElem* pFilter, const char* val1, const char* val2, int16_t type);
@@ -257,6 +258,7 @@ typedef struct SQueryAttr {
   SMemRef          memRef;
   STableGroupInfo  tableGroupInfo;       // table <tid, last_key> list  SArray<STableKeyInfo>
   int32_t          vgId;
+  SArray          *pUdfInfo;             // no need to free
 } SQueryAttr;
 
 typedef SSDataBlock* (*__operator_fn_t)(void* param, bool* newgroup);
@@ -297,6 +299,7 @@ typedef struct SQueryRuntimeEnv {
   STableQueryInfo      *current;
   SRspResultInfo        resultInfo;
   SHashObj             *pTableRetrieveTsMap;
+  SUdfInfo             *pUdfInfo;
 } SQueryRuntimeEnv;
 
 enum {
@@ -392,6 +395,7 @@ typedef struct SQueryParam {
   SGroupbyExpr *pGroupbyExpr;
   int32_t          tableScanOperator;
   SArray          *pOperator;
+  SUdfInfo        *pUdfInfo;
 } SQueryParam;
 
 typedef struct STableScanInfo {
@@ -531,6 +535,7 @@ typedef struct SMultiwayMergeInfo {
 
   bool                 hasPrev;
   bool                 groupMix;
+  SArray              *udfInfo;
 } SMultiwayMergeInfo;
 
 void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream);
@@ -553,8 +558,8 @@ SOperatorInfo* createDistinctOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperat
 SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
 SOperatorInfo* createMultiwaySortOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput,
                                               int32_t numOfRows, void* merger, bool groupMix);
+SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo);
 SOperatorInfo* createStatewindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
-SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param);
 SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* merger);
 SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
                                         int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
@@ -578,18 +583,19 @@ void setInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SSDataBlo
 int32_t getNumOfResult(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx* pCtx, int32_t numOfOutput);
 void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResultRowInfo* pResultRowInfo, int32_t* rowCellInfoOffset);
 void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOfInputRows);
+void clearOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity);
 
 void freeParam(SQueryParam *param);
 int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param);
 int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExprInfo** pExprInfo,
-                        SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg);
+                        SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg, SUdfInfo* pUdfInfo);
 
 int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo,
-                                           SSqlExpr **pExpr, SExprInfo *prevExpr);
+                                           SSqlExpr **pExpr, SExprInfo *prevExpr, SUdfInfo *pUdfInfo);
 
 SGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code);
 SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
-                        SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, int32_t vgId, char* sql, uint64_t qId);
+                        SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, int32_t vgId, char* sql, uint64_t qId, SUdfInfo* pUdfInfo);
 
 int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo* pQInfo, SQueryParam* param, char* start,
                   int32_t prevResultLen, void* merger);
@@ -608,6 +614,8 @@ bool doBuildResCheck(SQInfo* pQInfo);
 void setQueryStatus(SQueryRuntimeEnv *pRuntimeEnv, int8_t status);
 
 bool onlyQueryTags(SQueryAttr* pQueryAttr);
+void destroyUdfInfo(SUdfInfo* pUdfInfo);
+
 bool isValidQInfo(void *param);
 
 int32_t doDumpQueryResult(SQInfo *pQInfo, char *data);
@@ -625,4 +633,6 @@ void freeQueryAttr(SQueryAttr *pQuery);
 
 int32_t getMaximumIdleDurationSec();
 
+void doInvokeUdf(SUdfInfo* pUdfInfo, SQLFunctionCtx *pCtx, int32_t idx, int32_t type);
+
 #endif  // TDENGINE_QEXECUTOR_H

src/query/inc/qScript.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_QSCRIPT_H
+#define TDENGINE_QSCRIPT_H
+
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+
+#include "tutil.h"
+#include "hash.h"
+#include "tlist.h"
+#include "qUdf.h"
+
+#define MAX_FUNC_NAME 64
+
+#define USER_FUNC_NAME "funcName" 
+#define USER_FUNC_NAME_LIMIT 48
+
+enum ScriptState {
+  SCRIPT_STATE_INIT,
+  SCRIPT_STATE_ADD,
+  SCRIPT_STATE_MERGE,
+  SCRIPT_STATE_FINALIZE 
+};
+
+
+typedef struct {
+  SHashObj  *funcId;    //func already registed in lua_env, may be no use
+  lua_State *lua_state; // lua env 
+} ScriptEnv;   
+
+typedef struct ScriptCtx {
+  char        funcName[USER_FUNC_NAME_LIMIT]; 
+  int8_t      state; 
+  ScriptEnv  *pEnv;
+  int8_t      isAgg; // agg function or not
+  
+  // init value of udf script
+  int8_t      resType;
+  int16_t     resBytes; 
+
+  int32_t     numOfOutput; 
+  int32_t     offset;
+  
+} ScriptCtx;
+
+int taosLoadScriptInit(void *pInit);
+void taosLoadScriptNormal(void *pInit, char *pInput, int16_t iType, int16_t iBytes, int32_t numOfRows, 
+    int64_t *ptsList, int64_t key, char* pOutput, char *ptsOutput, int32_t *numOfOutput, int16_t oType, int16_t oBytes);
+void taosLoadScriptFinalize(void *pInit, int64_t key, char *pOutput, int32_t *output);
+void taosLoadScriptMerge(void *pCtx, char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput);
+void taosLoadScriptDestroy(void *pInit);
+
+typedef struct {
+  SList     *scriptEnvs; //  
+  int32_t   mSize;  // pool limit
+  int32_t   cSize;  // current available size
+  pthread_mutex_t mutex;
+} ScriptEnvPool;
+
+ScriptCtx* createScriptCtx(char *str, int8_t resType, int16_t resBytes);
+void       destroyScriptCtx(void *pScriptCtx);
+
+int32_t scriptEnvPoolInit();
+void    scriptEnvPoolCleanup();
+bool    isValidScript(char *script, int32_t len);
+
+#endif //TDENGINE_QSCRIPT_H 

src/query/inc/qSqlparser.h

@@ -182,6 +182,15 @@ typedef struct SCreateDbInfo {
   int16_t            partitions;
 } SCreateDbInfo;
 
+typedef struct SCreateFuncInfo {
+  SStrToken name;
+  SStrToken path;
+  int32_t   type;
+  int32_t   bufSize;
+  TAOS_FIELD output;
+} SCreateFuncInfo;
+
+
 typedef struct SCreateAcctInfo {
   int32_t            maxUsers;
   int32_t            maxDbs;
@@ -216,6 +225,7 @@ typedef struct SMiscInfo {
   union {
     SCreateDbInfo   dbOpt;
     SCreateAcctInfo acctOpt;
+    SCreateFuncInfo funcOpt;
     SShowInfo       showOpt;
     SStrToken       id;
   };
@@ -226,6 +236,7 @@ typedef struct SSqlInfo {
   bool               valid;
   SArray            *list;    // todo refactor
   char               msg[256];
+  SArray            *funcs;
   union {
     SCreateTableSql *pCreateTableInfo;
     SAlterTableInfo *pAlterInfo;
@@ -271,6 +282,7 @@ SRelationInfo *addSubqueryElem(SRelationInfo* pRelationInfo, SArray* pSub, SStrT
 // sql expr leaf node
 tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType);
 tSqlExpr *tSqlExprCreateFunction(SArray *pParam, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType);
+SArray *tStrTokenAppend(SArray *pList, SStrToken *pToken);
 
 tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType);
 tSqlExpr *tSqlExprClone(tSqlExpr *pSrc);

src/query/inc/qTableMeta.h

@@ -125,8 +125,12 @@ typedef struct SQueryInfo {
   int32_t          round;         // 0/1/....
   int32_t          bufLen;
   char*            buf;
-  struct SQInfo*          pQInfo;      // global merge operator
-  struct SQueryAttr*      pQueryAttr;     // query object
+
+  bool               udfCopy;
+  SArray            *pUdfInfo;
+
+  struct SQInfo     *pQInfo;      // global merge operator
+  struct SQueryAttr *pQueryAttr;     // query object
 
   struct SQueryInfo *sibling;     // sibling
   SArray            *pUpstream;   // SArray<struct SQueryInfo>
@@ -141,6 +145,7 @@ typedef struct SQueryInfo {
   bool               onlyTagQuery;
   bool               orderProjectQuery;
   bool               stateWindow;
+  bool               globalMerge;
 } SQueryInfo;
 
 /**

src/query/inc/qUdf.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_QUDF_H
+#define TDENGINE_QUDF_H
+
+enum { TSDB_UDF_FUNC_NORMAL = 0, TSDB_UDF_FUNC_INIT, TSDB_UDF_FUNC_FINALIZE, TSDB_UDF_FUNC_MERGE, TSDB_UDF_FUNC_DESTROY, TSDB_UDF_FUNC_MAX_NUM };
+
+
+
+typedef struct SUdfInit{
+ int32_t maybe_null;       /* 1 if function can return NULL */
+ uint32_t decimals;     /* for real functions */
+ uint64_t length;       /* For string functions */
+ char  *ptr;            /* free pointer for function data */
+ int32_t const_item;       /* 0 if result is independent of arguments */
+
+ // script like lua/javascript
+ void* script_ctx;
+ void (*destroyCtxFunc)(void *script_ctx);
+} SUdfInit;
+
+
+typedef struct SUdfInfo {
+  int32_t functionId;  // system assigned function id
+  int32_t funcType;    // scalar function or aggregate function
+  int8_t  resType;     // result type
+  int16_t resBytes;    // result byte
+  int32_t contLen;     // content length
+  int32_t bufSize;     //interbuf size
+  char   *name;        // function name
+  void   *handle;      // handle loaded in mem
+  void   *funcs[TSDB_UDF_FUNC_MAX_NUM];     // function ptr
+
+  // for script like lua/javascript only
+  int    isScript;
+  void   *pScriptCtx;
+
+  SUdfInit init;
+  char *content;
+  char *path;
+} SUdfInfo;
+
+//script 
+
+typedef int32_t (*scriptInitFunc)(void *pCtx);
+typedef void (*scriptNormalFunc)(void *pCtx, char* data, int16_t iType, int16_t iBytes, int32_t numOfRows,
+                                 int64_t* ptList, int64_t key, char* dataOutput, char* tsOutput, int32_t* numOfOutput, int16_t oType, int16_t oBytes);
+typedef void (*scriptFinalizeFunc)(void *pCtx, int64_t key, char* dataOutput, int32_t* numOfOutput);
+typedef void (*scriptMergeFunc)(void *pCtx, char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput);
+typedef void (*scriptDestroyFunc)(void* pCtx);
+
+// dynamic lib
+typedef void (*udfNormalFunc)(char* data, int16_t itype, int16_t iBytes, int32_t numOfRows, int64_t* ts, char* dataOutput, char* interBuf,
+  char* tsOutput, int32_t* numOfOutput, int16_t oType, int16_t oBytes, SUdfInit* buf);
+typedef int32_t (*udfInitFunc)(SUdfInit* data);
+typedef void (*udfFinalizeFunc)(char* dataOutput, char *interBuf, int32_t* numOfOutput, SUdfInit* buf);
+typedef void (*udfMergeFunc)(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf);
+typedef void (*udfDestroyFunc)(SUdfInit* buf);
+
+
+#endif  // TDENGINE_QUDF_H

src/query/inc/qUtil.h

@@ -105,4 +105,6 @@ int32_t getNumOfTotalRes(SGroupResInfo* pGroupResInfo);
 
 int32_t mergeIntoGroupResult(SGroupResInfo* pGroupResInfo, SQueryRuntimeEnv *pRuntimeEnv, int32_t* offset);
 
+int32_t initUdfInfo(SUdfInfo* pUdfInfo);
+
 #endif  // TDENGINE_QUERYUTIL_H

src/query/inc/sql.y

@@ -65,6 +65,7 @@ program ::= cmd.    {}
 //////////////////////////////////THE SHOW STATEMENT///////////////////////////////////////////
 cmd ::= SHOW DATABASES.  { setShowOptions(pInfo, TSDB_MGMT_TABLE_DB, 0, 0);}
 cmd ::= SHOW TOPICS.     { setShowOptions(pInfo, TSDB_MGMT_TABLE_TP, 0, 0);}
+cmd ::= SHOW FUNCTIONS.  { setShowOptions(pInfo, TSDB_MGMT_TABLE_FUNCTION, 0, 0);}
 cmd ::= SHOW MNODES.     { setShowOptions(pInfo, TSDB_MGMT_TABLE_MNODE, 0, 0);}
 cmd ::= SHOW DNODES.     { setShowOptions(pInfo, TSDB_MGMT_TABLE_DNODE, 0, 0);}
 cmd ::= SHOW ACCOUNTS.   { setShowOptions(pInfo, TSDB_MGMT_TABLE_ACCT, 0, 0);}
@@ -147,6 +148,7 @@ cmd ::= DROP STABLE ifexists(Y) ids(X) cpxName(Z).   {
 
 cmd ::= DROP DATABASE ifexists(Y) ids(X).    { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y, TSDB_DB_TYPE_DEFAULT, -1); }
 cmd ::= DROP TOPIC ifexists(Y) ids(X).    { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y, TSDB_DB_TYPE_TOPIC, -1); }
+cmd ::= DROP FUNCTION ids(X).    { setDropFuncInfo(pInfo, TSDB_SQL_DROP_FUNCTION, &X); }
 
 cmd ::= DROP DNODE ids(X).       { setDCLSqlElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &X);    }
 cmd ::= DROP USER ids(X).        { setDCLSqlElems(pInfo, TSDB_SQL_DROP_USER, 1, &X);     }
@@ -200,8 +202,13 @@ cmd ::= CREATE ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).
                                 { setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &X, &Y, &Z);}
 cmd ::= CREATE DATABASE ifnotexists(Z) ids(X) db_optr(Y).  { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
 cmd ::= CREATE TOPIC ifnotexists(Z) ids(X) topic_optr(Y).  { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
+cmd ::= CREATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize(B).   { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &X, &Y, &Z, &B, 1);}
+cmd ::= CREATE AGGREGATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) bufsize(B).   { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &X, &Y, &Z, &B, 2);}
 cmd ::= CREATE USER ids(X) PASS ids(Y).     { setCreateUserSql(pInfo, &X, &Y);}
 
+bufsize(Y) ::= .                                { Y.n = 0;   }
+bufsize(Y) ::= BUFSIZE INTEGER(X).              { Y = X;     }
+
 pps(Y) ::= .                                { Y.n = 0;   }
 pps(Y) ::= PPS INTEGER(X).                  { Y = X;     }
 
@@ -704,10 +711,10 @@ expr(A) ::= BOOL(X).             { A = tSqlExprCreateIdValue(&X, TK_BOOL);}
 expr(A) ::= NULL(X).             { A = tSqlExprCreateIdValue(&X, TK_NULL);}
 
 // ordinary functions: min(x), max(x), top(k, 20)
-expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = tSqlExprCreateFunction(Y, &X, &E, X.type); }
+expr(A) ::= ID(X) LP exprlist(Y) RP(E). { tStrTokenAppend(pInfo->funcs, &X); A = tSqlExprCreateFunction(Y, &X, &E, X.type); }
 
 // for parsing sql functions with wildcard for parameters. e.g., count(*)/first(*)/last(*) operation
-expr(A) ::= ID(X) LP STAR RP(Y).     { A = tSqlExprCreateFunction(NULL, &X, &Y, X.type); }
+expr(A) ::= ID(X) LP STAR RP(Y).     { tStrTokenAppend(pInfo->funcs, &X); A = tSqlExprCreateFunction(NULL, &X, &Y, X.type); }
 
 // is (not) null expression
 expr(A) ::= expr(X) IS NULL.           {A = tSqlExprCreate(X, NULL, TK_ISNULL);}

src/query/src/qAggMain.c

@@ -27,6 +27,7 @@
 #include "qPercentile.h"
 #include "qTsbuf.h"
 #include "queryLog.h"
+#include "qUdf.h"
 
 #define GET_INPUT_DATA_LIST(x) ((char *)((x)->pInput))
 #define GET_INPUT_DATA(x, y) (GET_INPUT_DATA_LIST(x) + (y) * (x)->inputBytes)
@@ -169,12 +170,13 @@ typedef struct SDerivInfo {
 } SDerivInfo;
 
 int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionId, int32_t param, int16_t *type,
-                          int16_t *bytes, int32_t *interBytes, int16_t extLength, bool isSuperTable) {
+                          int16_t *bytes, int32_t *interBytes, int16_t extLength, bool isSuperTable, SUdfInfo* pUdfInfo) {
   if (!isValidDataType(dataType)) {
     qError("Illegal data type %d or data type length %d", dataType, dataBytes);
     return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
+
   if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY || functionId == TSDB_FUNC_TAG_DUMMY ||
       functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_PRJ || functionId == TSDB_FUNC_TAGPRJ ||
       functionId == TSDB_FUNC_TAG || functionId == TSDB_FUNC_INTERP) {
@@ -234,6 +236,20 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
   }
 
   if (isSuperTable) {
+    if (functionId < 0) {
+      if (pUdfInfo->bufSize > 0) {
+        *type = TSDB_DATA_TYPE_BINARY;
+        *bytes = pUdfInfo->bufSize;
+        *interBytes = *bytes;
+      } else {
+        *type = pUdfInfo->resType;
+        *bytes = pUdfInfo->resBytes;
+        *interBytes = *bytes;
+      }
+
+      return TSDB_CODE_SUCCESS;
+    }
+
     if (functionId == TSDB_FUNC_MIN || functionId == TSDB_FUNC_MAX) {
       *type = TSDB_DATA_TYPE_BINARY;
       *bytes = (int16_t)(dataBytes + DATA_SET_FLAG_SIZE);
@@ -314,6 +330,19 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
     return TSDB_CODE_SUCCESS;
   }
 
+  if (functionId < 0) {
+    *type = pUdfInfo->resType;
+    *bytes = pUdfInfo->resBytes;
+
+    if (pUdfInfo->bufSize > 0) {
+      *interBytes = pUdfInfo->bufSize;
+    } else {
+      *interBytes = *bytes;
+    }
+
+    return TSDB_CODE_SUCCESS;
+  }
+
   if (functionId == TSDB_FUNC_AVG) {
     *type = TSDB_DATA_TYPE_DOUBLE;
     *bytes = sizeof(double);
@@ -390,14 +419,13 @@ int32_t isValidFunction(const char* name, int32_t len) {
   return -1;
 }
 
-static bool function_setup(SQLFunctionCtx *pCtx) {
-  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-  if (pResInfo->initialized) {
+static bool function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
+  if (pResultInfo->initialized) {
     return false;
   }
   
   memset(pCtx->pOutput, 0, (size_t)pCtx->outputBytes);
-  initResultInfo(pResInfo, pCtx->interBufBytes);
+  initResultInfo(pResultInfo, pCtx->interBufBytes);
   return true;
 }
 
@@ -985,8 +1013,8 @@ static void minMax_function(SQLFunctionCtx *pCtx, char *pOutput, int32_t isMin,
   }
 }
 
-static bool min_func_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool min_func_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
+  if (!function_setup(pCtx, pResultInfo)) {
     return false;  // not initialized since it has been initialized
   }
   
@@ -1030,8 +1058,8 @@ static bool min_func_setup(SQLFunctionCtx *pCtx) {
   return true;
 }
 
-static bool max_func_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool max_func_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
+  if (!function_setup(pCtx, pResultInfo)) {
     return false;  // not initialized since it has been initialized
   }
   
@@ -1435,8 +1463,8 @@ static void stddev_dst_finalizer(SQLFunctionCtx *pCtx) {
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
-static bool first_last_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool first_last_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
+  if (!function_setup(pCtx, pResInfo)) {
     return false;
   }
   
@@ -2073,14 +2101,13 @@ bool topbot_datablock_filter(SQLFunctionCtx *pCtx, const char *minval, const cha
   }
 }
 
-static bool top_bottom_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool top_bottom_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
+  if (!function_setup(pCtx, pResInfo)) {
     return false;
   }
   
   STopBotInfo *pInfo = getTopBotOutputInfo(pCtx);
   buildTopBotStruct(pInfo, pCtx);
-  
   return true;
 }
 
@@ -2229,14 +2256,13 @@ static void top_bottom_func_finalizer(SQLFunctionCtx *pCtx) {
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
-static bool percentile_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool percentile_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
+  if (!function_setup(pCtx, pResultInfo)) {
     return false;
   }
 
   // in the first round, get the min-max value of all involved data
-  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-  SPercentileInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
+  SPercentileInfo *pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
   SET_DOUBLE_VAL(&pInfo->minval, DBL_MAX);
   SET_DOUBLE_VAL(&pInfo->maxval, -DBL_MAX);
   pInfo->numOfElems = 0;
@@ -2367,8 +2393,8 @@ static SAPercentileInfo *getAPerctInfo(SQLFunctionCtx *pCtx) {
   return pInfo;
 }
 
-static bool apercentile_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool apercentile_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
+  if (!function_setup(pCtx, pResultInfo)) {
     return false;
   }
   
@@ -2477,12 +2503,11 @@ static void apercentile_finalizer(SQLFunctionCtx *pCtx) {
 }
 
 /////////////////////////////////////////////////////////////////////////////////
-static bool leastsquares_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool leastsquares_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
+  if (!function_setup(pCtx, pResInfo)) {
     return false;
   }
 
-  SResultRowCellInfo *     pResInfo = GET_RES_INFO(pCtx);
   SLeastsquaresInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   
   // 2*3 matrix
@@ -2706,8 +2731,8 @@ enum {
   INITIAL_VALUE_NOT_ASSIGNED = 0,
 };
 
-static bool diff_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool diff_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
+  if (!function_setup(pCtx, pResInfo)) {
     return false;
   }
   
@@ -2716,14 +2741,13 @@ static bool diff_function_setup(SQLFunctionCtx *pCtx) {
   return false;
 }
 
-static bool deriv_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool deriv_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResultInfo) {
+  if (!function_setup(pCtx, pResultInfo)) {
     return false;
   }
 
   // diff function require the value is set to -1
-  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-  SDerivInfo* pDerivInfo = GET_ROWCELL_INTERBUF(pResInfo);
+  SDerivInfo* pDerivInfo = GET_ROWCELL_INTERBUF(pResultInfo);
 
   pDerivInfo->ignoreNegative = pCtx->param[1].i64;
   pDerivInfo->prevTs   = -1;
@@ -3130,12 +3154,12 @@ static void arithmetic_function(SQLFunctionCtx *pCtx) {
   }
 
 /////////////////////////////////////////////////////////////////////////////////
-static bool spread_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool spread_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
+  if (!function_setup(pCtx, pResInfo)) {
     return false;
   }
   
-  SSpreadInfo *pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
+  SSpreadInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   
   // this is the server-side setup function in client-side, the secondary merge do not need this procedure
   if (pCtx->currentStage == MERGE_STAGE) {
@@ -3289,13 +3313,11 @@ void spread_function_finalizer(SQLFunctionCtx *pCtx) {
  * param[2]: end time
  * @param pCtx
  */
-static bool twa_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool twa_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
+  if (!function_setup(pCtx, pResInfo)) {
     return false;
   }
 
-  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-
   STwaInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   pInfo->p.key    = INT64_MIN;
   pInfo->win      = TSWINDOW_INITIALIZER;
@@ -3726,14 +3748,12 @@ static void interp_function(SQLFunctionCtx *pCtx) {
   }
 }
 
-static bool ts_comp_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool ts_comp_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
+  if (!function_setup(pCtx, pResInfo)) {
     return false;  // not initialized since it has been initialized
   }
 
-  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
   STSCompInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
-  
   pInfo->pTSBuf = tsBufCreate(false, pCtx->order);
   pInfo->pTSBuf->tsOrder = pCtx->order;
   return true;
@@ -3816,13 +3836,11 @@ static double do_calc_rate(const SRateInfo* pRateInfo, double tickPerSec) {
   return (duration > 0)? ((double)diff) / (duration/tickPerSec):0.0;
 }
 
-static bool rate_function_setup(SQLFunctionCtx *pCtx) {
-  if (!function_setup(pCtx)) {
+static bool rate_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo* pResInfo) {
+  if (!function_setup(pCtx, pResInfo)) {
     return false;
   }
   
-  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-
   SRateInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   pInfo->correctionValue = 0;
   pInfo->firstKey    = INT64_MIN;

src/query/src/qExecutor.c

@@ -29,6 +29,7 @@
 #include "ttype.h"
 #include "tcompare.h"
 #include "tscompression.h"
+#include "qScript.h"
 
 #define IS_MASTER_SCAN(runtime)        ((runtime)->scanFlag == MASTER_SCAN)
 #define IS_REVERSE_SCAN(runtime)       ((runtime)->scanFlag == REVERSE_SCAN)
@@ -780,6 +781,79 @@ static int32_t getNumOfRowsInTimeWindow(SQueryRuntimeEnv* pRuntimeEnv, SDataBloc
   return num;
 }
 
+void doInvokeUdf(SUdfInfo* pUdfInfo, SQLFunctionCtx *pCtx, int32_t idx, int32_t type) {
+  int32_t output = 0;
+
+  if (pUdfInfo == NULL || pUdfInfo->funcs[type] == NULL) {
+    qError("empty udf function, type:%d", type);
+    return;
+  }
+
+  qDebug("invoke udf function:%s,%p", pUdfInfo->name, pUdfInfo->funcs[type]);
+
+  switch (type) {
+    case TSDB_UDF_FUNC_NORMAL:
+      if (pUdfInfo->isScript) {
+        (*(scriptNormalFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL])(pUdfInfo->pScriptCtx,
+                     (char *)pCtx->pInput + idx * pCtx->inputType, pCtx->inputType, pCtx->inputBytes, pCtx->size, pCtx->ptsList, pCtx->startTs, pCtx->pOutput,
+                    (char *)pCtx->ptsOutputBuf, &output, pCtx->outputType, pCtx->outputBytes);
+      } else {
+        SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
+
+        void *interBuf = (void *)GET_ROWCELL_INTERBUF(pResInfo);
+
+        (*(udfNormalFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL])((char *)pCtx->pInput + idx * pCtx->inputType, pCtx->inputType, pCtx->inputBytes, pCtx->size, pCtx->ptsList,
+          pCtx->pOutput, interBuf, (char *)pCtx->ptsOutputBuf, &output, pCtx->outputType, pCtx->outputBytes, &pUdfInfo->init);
+      }
+
+      if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
+        pCtx->resultInfo->numOfRes = output;
+      } else {
+        pCtx->resultInfo->numOfRes += output;
+      }
+
+      if (pCtx->resultInfo->numOfRes > 0) {
+        pCtx->resultInfo->hasResult = DATA_SET_FLAG;
+      }
+
+      break;
+
+    case TSDB_UDF_FUNC_MERGE:
+      if (pUdfInfo->isScript) {
+        (*(scriptMergeFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_MERGE])(pUdfInfo->pScriptCtx, pCtx->pInput, pCtx->size, pCtx->pOutput, &output);
+      } else {
+        (*(udfMergeFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_MERGE])(pCtx->pInput, pCtx->size, pCtx->pOutput, &output, &pUdfInfo->init);
+      }
+
+      // set the output value exist
+      pCtx->resultInfo->numOfRes = output;
+      if (output > 0) {
+        pCtx->resultInfo->hasResult = DATA_SET_FLAG;
+      }
+
+      break;
+
+    case TSDB_UDF_FUNC_FINALIZE: {
+      SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
+      void *interBuf = (void *)GET_ROWCELL_INTERBUF(pResInfo);
+      if (pUdfInfo->isScript) {
+        (*(scriptFinalizeFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_FINALIZE])(pUdfInfo->pScriptCtx, pCtx->startTs, pCtx->pOutput, &output);
+      } else {
+        (*(udfFinalizeFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_FINALIZE])(pCtx->pOutput, interBuf, &output, &pUdfInfo->init);
+      }
+      // set the output value exist
+      pCtx->resultInfo->numOfRes = output;
+      if (output > 0) {
+        pCtx->resultInfo->hasResult = DATA_SET_FLAG;
+      }
+
+      break;
+      }
+  }
+
+  return;
+}
+
 static void doApplyFunctions(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx, STimeWindow* pWin, int32_t offset,
                              int32_t forwardStep, TSKEY* tsCol, int32_t numOfTotal, int32_t numOfOutput) {
   SQueryAttr *pQueryAttr = pRuntimeEnv->pQueryAttr;
@@ -789,7 +863,7 @@ static void doApplyFunctions(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx
     pCtx[k].size    = forwardStep;
     pCtx[k].startTs = pWin->skey;
 
-    // keep it temprarily
+    // keep it temporarialy
     char* start = pCtx[k].pInput;
 
     int32_t pos = (QUERY_IS_ASC_QUERY(pQueryAttr)) ? offset : offset - (forwardStep - 1);
@@ -807,8 +881,14 @@ static void doApplyFunctions(SQueryRuntimeEnv* pRuntimeEnv, SQLFunctionCtx* pCtx
       pCtx[k].preAggVals.isSet = false;
     }
 
+    int32_t functionId = pCtx[k].functionId;
     if (functionNeedToExecute(pRuntimeEnv, &pCtx[k])) {
-      aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
+      if (functionId < 0) { // load the script and exec, pRuntimeEnv->pUdfInfo
+        SUdfInfo* pUdfInfo = pRuntimeEnv->pUdfInfo;
+        doInvokeUdf(pUdfInfo, &pCtx[k], 0, TSDB_UDF_FUNC_NORMAL);
+      } else {
+        aAggs[functionId].xFunction(&pCtx[k]);
+      }
     }
 
     // restore it
@@ -1018,6 +1098,13 @@ static void doSetInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx,
         pCtx[i].pInput = p->pData;
         assert(p->info.colId == pColIndex->colId && pCtx[i].inputType == p->info.type);
 
+        if (pCtx[i].functionId < 0) {
+          SColumnInfoData* tsInfo = taosArrayGet(pBlock->pDataBlock, 0);
+          pCtx[i].ptsList = (int64_t*) tsInfo->pData;
+
+          continue;
+        }
+
         uint32_t status = aAggs[pCtx[i].functionId].status;
         if ((status & (TSDB_FUNCSTATE_SELECTIVITY | TSDB_FUNCSTATE_NEED_TS)) != 0) {
           SColumnInfoData* tsInfo = taosArrayGet(pBlock->pDataBlock, 0);
@@ -1050,7 +1137,14 @@ static void doAggregateImpl(SOperatorInfo* pOperator, TSKEY startTs, SQLFunction
   for (int32_t k = 0; k < pOperator->numOfOutput; ++k) {
     if (functionNeedToExecute(pRuntimeEnv, &pCtx[k])) {
       pCtx[k].startTs = startTs;// this can be set during create the struct
-      aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
+
+      int32_t functionId = pCtx[k].functionId;
+      if (functionId < 0) {
+        SUdfInfo* pUdfInfo = pRuntimeEnv->pUdfInfo;
+        doInvokeUdf(pUdfInfo, &pCtx[k], 0, TSDB_UDF_FUNC_NORMAL);
+      } else {
+        aAggs[functionId].xFunction(&pCtx[k]);
+      }
     }
   }
 }
@@ -1066,8 +1160,16 @@ static void projectApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx
       pCtx[k].order = TSDB_ORDER_ASC;
     }
 
+    pCtx[k].startTs = pQueryAttr->window.skey;
+
+    if (pCtx[k].functionId < 0) {
+      // load the script and exec
+      SUdfInfo* pUdfInfo = pRuntimeEnv->pUdfInfo;
+      doInvokeUdf(pUdfInfo, &pCtx[k], 0, TSDB_UDF_FUNC_NORMAL);
+    } else {
       aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
     }
+  }
 }
 
 void doTimeWindowInterpolation(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo, SArray* pDataBlock, TSKEY prevTs,
@@ -1953,7 +2055,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
 
       case OP_GlobalAggregate: {
         pRuntimeEnv->proot = createGlobalAggregateOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3,
-                                                               pQueryAttr->numOfExpr3, merger);
+                                                               pQueryAttr->numOfExpr3, merger, pQueryAttr->pUdfInfo);
         break;
       }
 
@@ -2024,6 +2126,8 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
     tfree(pRuntimeEnv->sasArray);
   }
 
+  destroyUdfInfo(pRuntimeEnv->pUdfInfo);
+
   destroyResultBuf(pRuntimeEnv->pResultBuf);
   doFreeQueryHandle(pRuntimeEnv);
 
@@ -2703,11 +2807,16 @@ static uint32_t doFilterByBlockTimeWindow(STableScanInfo* pTableScanInfo, SSData
     int32_t colId = pTableScanInfo->pExpr[i].base.colInfo.colId;
 
     // group by + first/last should not apply the first/last block filter
+    if (functionId < 0) {
+      status |= BLK_DATA_ALL_NEEDED;
+      return status;
+    } else {
       status |= aAggs[functionId].dataReqFunc(&pTableScanInfo->pCtx[i], &pBlock->info.window, colId);
       if ((status & BLK_DATA_ALL_NEEDED) == BLK_DATA_ALL_NEEDED) {
         return status;
       }
     }
+  }
 
   return status;
 }
@@ -3299,6 +3408,21 @@ void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOf
   }
 }
 
+void clearOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity) {
+  SSDataBlock* pDataBlock = pBInfo->pRes;
+
+  for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) {
+    SColumnInfoData *pColInfo = taosArrayGet(pDataBlock->pDataBlock, i);
+
+    int32_t functionId = pBInfo->pCtx[i].functionId;
+    if (functionId < 0) {
+      memset(pBInfo->pCtx[i].pOutput, 0, pColInfo->info.bytes * (*bufCapacity));
+    }
+  }
+}
+
+
+
 void initCtxOutputBuffer(SQLFunctionCtx* pCtx, int32_t size) {
   for (int32_t j = 0; j < size; ++j) {
     SResultRowCellInfo* pResInfo = GET_RES_INFO(&pCtx[j]);
@@ -3306,7 +3430,11 @@ void initCtxOutputBuffer(SQLFunctionCtx* pCtx, int32_t size) {
       continue;
     }
 
-    aAggs[pCtx[j].functionId].init(&pCtx[j]);
+    if (pCtx[j].functionId < 0) { // todo udf initialization
+      continue;
+    } else {
+      aAggs[pCtx[j].functionId].init(&pCtx[j], pCtx[j].resultInfo);
+    }
   }
 }
 
@@ -3361,8 +3489,14 @@ void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResult
       setResultOutputBuf(pRuntimeEnv, buf, pCtx, numOfOutput, rowCellInfoOffset);
 
       for (int32_t j = 0; j < numOfOutput; ++j) {
+        pCtx[j].startTs  = buf->win.skey;
+        if (pCtx[j].functionId < 0) {
+          doInvokeUdf(pRuntimeEnv->pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
+        } else {
           aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
         }
+      }
+
 
       /*
        * set the number of output results for group by normal columns, the number of output rows usually is 1 except
@@ -3373,9 +3507,13 @@ void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResult
 
   } else {
     for (int32_t j = 0; j < numOfOutput; ++j) {
+      if (pCtx[j].functionId < 0) {
+        doInvokeUdf(pRuntimeEnv->pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
+      } else {
         aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
       }
     }
+  }
 }
 
 static bool hasMainOutput(SQueryAttr *pQueryAttr) {
@@ -3459,12 +3597,16 @@ void setResultRowOutputBufInitCtx(SQueryRuntimeEnv *pRuntimeEnv, SResultRow *pRe
     offset += pCtx[i].outputBytes;
 
     int32_t functionId = pCtx[i].functionId;
-    if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_DERIVATIVE) {
+    if (functionId < 0) {
+      continue;
+    }
+
+    if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF) {
       pCtx[i].ptsOutputBuf = pCtx[0].pOutput;
     }
 
     if (!pResInfo->initialized) {
-      aAggs[functionId].init(&pCtx[i]);
+      aAggs[functionId].init(&pCtx[i], pResInfo);
     }
   }
 }
@@ -4923,7 +5065,7 @@ static void destroySlimitOperatorInfo(void* param, int32_t numOfOutput) {
 }
 
 SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream,
-                                                 SExprInfo* pExpr, int32_t numOfOutput, void* param) {
+                                                 SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo) {
   SMultiwayMergeInfo* pInfo = calloc(1, sizeof(SMultiwayMergeInfo));
 
   pInfo->resultRowFactor =
@@ -4933,6 +5075,7 @@ SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv,
 
   pInfo->pMerge = param;
   pInfo->bufCapacity = 4096;
+  pInfo->udfInfo   = pUdfInfo;
 
   pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pInfo->bufCapacity * pInfo->resultRowFactor);
   pInfo->binfo.pCtx = createSQLFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset);
@@ -6690,6 +6833,9 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
   pQueryMsg->sw.primaryColId = htonl(pQueryMsg->sw.primaryColId);
   pQueryMsg->tableScanOperator = htonl(pQueryMsg->tableScanOperator);
   pQueryMsg->numOfOperator = htonl(pQueryMsg->numOfOperator);
+  pQueryMsg->udfContentOffset = htonl(pQueryMsg->udfContentOffset);
+  pQueryMsg->udfContentLen    = htonl(pQueryMsg->udfContentLen);
+  pQueryMsg->udfNum           = htonl(pQueryMsg->udfNum);
 
   // query msg safety check
   if (!validateQueryMsg(pQueryMsg)) {
@@ -6933,6 +7079,33 @@ int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
     pMsg += sizeof(int32_t);
   }
 
+  if (pQueryMsg->udfContentLen > 0) {
+    param->pUdfInfo = calloc(1, sizeof(SUdfInfo));
+    param->pUdfInfo->contLen = pQueryMsg->udfContentLen;
+
+    pMsg = (char*)pQueryMsg + pQueryMsg->udfContentOffset;
+    param->pUdfInfo->resType = *(int8_t*) pMsg;
+    pMsg += sizeof(int8_t);
+
+    param->pUdfInfo->resBytes = htons(*(int16_t*)pMsg);
+    pMsg += sizeof(int16_t);
+
+    tstr* name = (tstr*)(pMsg);
+    param->pUdfInfo->name = strndup(name->data, name->len);
+
+    pMsg += varDataTLen(name);
+    param->pUdfInfo->funcType = htonl(*(int32_t*)pMsg);
+    pMsg += sizeof(int32_t);
+
+    param->pUdfInfo->bufSize = htonl(*(int32_t*)pMsg);
+    pMsg += sizeof(int32_t);
+
+    param->pUdfInfo->content = malloc(pQueryMsg->udfContentLen);
+    memcpy(param->pUdfInfo->content, pMsg, pQueryMsg->udfContentLen);
+
+    pMsg += pQueryMsg->udfContentLen;
+  }
+
   param->sql = strndup(pMsg, pQueryMsg->sqlstrLen);
 
   SQueriedTableInfo info = { .numOfTags = pQueryMsg->numOfTags, .numOfCols = pQueryMsg->numOfCols, .colList = pQueryMsg->tableCols};
@@ -7023,7 +7196,7 @@ static int32_t updateOutputBufForTopBotQuery(SQueriedTableInfo* pTableInfo, SCol
       } else {
         SColumnInfo* pCol = &pTableInfo->colList[j];
         int32_t ret = getResultDataInfo(pCol->type, pCol->bytes, functId, (int32_t)pExprs[i].base.param[0].i64,
-                                        &pExprs[i].base.resType, &pExprs[i].base.resBytes, &pExprs[i].base.interBytes, tagLen, superTable);
+                                        &pExprs[i].base.resType, &pExprs[i].base.resBytes, &pExprs[i].base.interBytes, tagLen, superTable, NULL);
         assert(ret == TSDB_CODE_SUCCESS);
       }
     }
@@ -7032,12 +7205,138 @@ static int32_t updateOutputBufForTopBotQuery(SQueriedTableInfo* pTableInfo, SCol
   return TSDB_CODE_SUCCESS;
 }
 
+void destroyUdfInfo(SUdfInfo* pUdfInfo) {
+  if (pUdfInfo == NULL) {
+    return;
+  }
+
+  if (pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY]) {
+    if (pUdfInfo->isScript) {
+      (*(scriptDestroyFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY])(pUdfInfo->pScriptCtx);
+      tfree(pUdfInfo->content);
+    }else{
+      (*(udfDestroyFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY])(&pUdfInfo->init);
+    }
+  }
+
+  tfree(pUdfInfo->name);
+
+  if (pUdfInfo->path) {
+    unlink(pUdfInfo->path);
+  }
+
+  tfree(pUdfInfo->path);
+  tfree(pUdfInfo->content);
+  taosCloseDll(pUdfInfo->handle);
+  tfree(pUdfInfo);
+}
+
+static char* getUdfFuncName(char* name, int type) {
+  char* funcname = calloc(1, TSDB_FUNCTIONS_NAME_MAX_LENGTH + 10);
+
+  switch (type) {
+    case TSDB_UDF_FUNC_NORMAL:
+      strcpy(funcname, name);
+      break;
+    case TSDB_UDF_FUNC_INIT:
+      sprintf(funcname, "%s_init", name);
+      break;
+    case TSDB_UDF_FUNC_FINALIZE:
+      sprintf(funcname, "%s_finalize", name);
+      break;
+    case TSDB_UDF_FUNC_MERGE:
+      sprintf(funcname, "%s_merge", name);
+      break;
+    case TSDB_UDF_FUNC_DESTROY:
+      sprintf(funcname, "%s_destroy", name);
+      break;
+    default:
+      assert(0);
+      break;
+  }
+
+  return funcname;
+}
+
+int32_t initUdfInfo(SUdfInfo* pUdfInfo) {
+  if (pUdfInfo == NULL) {
+    return TSDB_CODE_SUCCESS;
+  }
+  //qError("script len: %d", pUdfInfo->contLen);
+  if (isValidScript(pUdfInfo->content, pUdfInfo->contLen)) {
+    pUdfInfo->isScript   = 1;
+    pUdfInfo->pScriptCtx = createScriptCtx(pUdfInfo->content, pUdfInfo->resType, pUdfInfo->resBytes);
+    if (pUdfInfo->pScriptCtx == NULL) {
+      return TSDB_CODE_QRY_SYS_ERROR;
+    }
+    tfree(pUdfInfo->content);
+
+    pUdfInfo->funcs[TSDB_UDF_FUNC_INIT] = taosLoadScriptInit;
+    if (pUdfInfo->funcs[TSDB_UDF_FUNC_INIT] == NULL
+        || (*(scriptInitFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_INIT])(pUdfInfo->pScriptCtx) != TSDB_CODE_SUCCESS) {
+      return TSDB_CODE_QRY_SYS_ERROR;
+    }
+
+    pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL] = taosLoadScriptNormal;
+
+    if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
+      pUdfInfo->funcs[TSDB_UDF_FUNC_FINALIZE] =  taosLoadScriptFinalize;
+      pUdfInfo->funcs[TSDB_UDF_FUNC_MERGE]    =  taosLoadScriptMerge;
+    }
+    pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY] = taosLoadScriptDestroy;
+
+  } else {
+    char path[PATH_MAX] = {0};
+    taosGetTmpfilePath("script", path);
+
+    FILE* file = fopen(path, "w+");
+
+    // TODO check for failure of flush to disk
+    /*size_t t = */ fwrite(pUdfInfo->content, pUdfInfo->contLen, 1, file);
+    fclose(file);
+    tfree(pUdfInfo->content);
+
+    pUdfInfo->path = strdup(path);
+
+    pUdfInfo->handle = taosLoadDll(path);
+
+    if (NULL == pUdfInfo->handle) {
+      return TSDB_CODE_QRY_SYS_ERROR;
+    }
+
+    pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_NORMAL));
+    if (NULL == pUdfInfo->funcs[TSDB_UDF_FUNC_NORMAL]) {
+      return TSDB_CODE_QRY_SYS_ERROR;
+    }
+
+    pUdfInfo->funcs[TSDB_UDF_FUNC_INIT] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_INIT));
+
+    if (pUdfInfo->funcType == TSDB_UDF_TYPE_AGGREGATE) {
+      pUdfInfo->funcs[TSDB_UDF_FUNC_FINALIZE] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_FINALIZE));
+      pUdfInfo->funcs[TSDB_UDF_FUNC_MERGE] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_MERGE));
+    }
+
+    pUdfInfo->funcs[TSDB_UDF_FUNC_DESTROY] = taosLoadSym(pUdfInfo->handle, getUdfFuncName(pUdfInfo->name, TSDB_UDF_FUNC_DESTROY));
+
+    if (pUdfInfo->funcs[TSDB_UDF_FUNC_INIT]) {
+      return (*(udfInitFunc)pUdfInfo->funcs[TSDB_UDF_FUNC_INIT])(&pUdfInfo->init);
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 // TODO tag length should be passed from client, refactor
 int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExprInfo** pExprInfo,
-                        SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg) {
+                        SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg, SUdfInfo* pUdfInfo) {
   *pExprInfo = NULL;
   int32_t code = TSDB_CODE_SUCCESS;
 
+  code = initUdfInfo(pUdfInfo);
+  if (code) {
+    return code;
+  }
+
   SExprInfo *pExprs = (SExprInfo *)calloc(numOfOutput, sizeof(SExprInfo));
   if (pExprs == NULL) {
     return TSDB_CODE_QRY_OUT_OF_MEMORY;
@@ -7126,7 +7425,7 @@ int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExp
 
     // todo remove it
     if (getResultDataInfo(type, bytes, pExprs[i].base.functionId, param, &pExprs[i].base.resType, &pExprs[i].base.resBytes,
-                          &pExprs[i].base.interBytes, 0, isSuperTable) != TSDB_CODE_SUCCESS) {
+                          &pExprs[i].base.interBytes, 0, isSuperTable, pUdfInfo) != TSDB_CODE_SUCCESS) {
       tfree(pExprs);
       return TSDB_CODE_QRY_INVALID_MSG;
     }
@@ -7147,7 +7446,7 @@ int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExp
 
 // todo refactor
 int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg* pQueryMsg, int32_t numOfOutput, SExprInfo** pExprInfo,
-                                           SSqlExpr** pExpr, SExprInfo* prevExpr) {
+                                           SSqlExpr** pExpr, SExprInfo* prevExpr, SUdfInfo *pUdfInfo) {
   *pExprInfo = NULL;
   int32_t code = TSDB_CODE_SUCCESS;
 
@@ -7192,7 +7491,7 @@ int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg* pQueryMsg, int32_t nu
 
     int32_t param = (int32_t)pExprs[i].base.param[0].i64;
     if (getResultDataInfo(type, bytes, pExprs[i].base.functionId, param, &pExprs[i].base.resType, &pExprs[i].base.resBytes,
-                          &pExprs[i].base.interBytes, 0, isSuperTable) != TSDB_CODE_SUCCESS) {
+                          &pExprs[i].base.interBytes, 0, isSuperTable, pUdfInfo) != TSDB_CODE_SUCCESS) {
       tfree(pExprs);
       return TSDB_CODE_QRY_INVALID_MSG;
     }
@@ -7378,7 +7677,7 @@ FORCE_INLINE bool checkQIdEqual(void *qHandle, uint64_t qId) {
 
 SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, SExprInfo* pExprs,
                         SExprInfo* pSecExprs, STableGroupInfo* pTableGroupInfo, SColumnInfo* pTagCols, int32_t vgId,
-                        char* sql, uint64_t qId) {
+                        char* sql, uint64_t qId, SUdfInfo* pUdfInfo) {
   int16_t numOfCols = pQueryMsg->numOfCols;
   int16_t numOfOutput = pQueryMsg->numOfOutput;
 
@@ -7389,6 +7688,8 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
 
   pQInfo->qId = qId;
 
+  pQInfo->runtimeEnv.pUdfInfo = pUdfInfo;
+
   // to make sure third party won't overwrite this structure
   pQInfo->signature = pQInfo;
   SQueryAttr* pQueryAttr = &pQInfo->query;
@@ -7412,6 +7713,7 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
   pQueryAttr->prjInfo.vgroupLimit = pQueryMsg->vgroupLimit;
   pQueryAttr->prjInfo.ts      = (pQueryMsg->order == TSDB_ORDER_ASC)? INT64_MIN:INT64_MAX;
   pQueryAttr->sw              = pQueryMsg->sw;
+  pQueryAttr->vgId            = vgId;
 
   pQueryAttr->stableQuery     = pQueryMsg->stableQuery;
   pQueryAttr->topBotQuery     = pQueryMsg->topBotQuery;
@@ -7444,7 +7746,6 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
     }
   }
 
-  // calculate the result row size
   for (int16_t col = 0; col < numOfOutput; ++col) {
     assert(pExprs[col].base.resBytes > 0);
     pQueryAttr->resultRowSize += pExprs[col].base.resBytes;
@@ -7465,6 +7766,20 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
     goto _cleanup;
   }
 
+  if (pSecExprs != NULL) {
+    int32_t resultRowSize = 0;
+
+    // calculate the result row size
+    for (int16_t col = 0; col < pQueryAttr->numOfExpr2; ++col) {
+      assert(pSecExprs[col].base.resBytes > 0);
+      resultRowSize += pSecExprs[col].base.resBytes;
+    }
+
+    if (resultRowSize > pQueryAttr->resultRowSize) {
+      pQueryAttr->resultRowSize = resultRowSize;
+    }
+  }
+
   if (pQueryAttr->fillType != TSDB_FILL_NONE) {
     pQueryAttr->fillVal = malloc(sizeof(int64_t) * pQueryAttr->numOfOutput);
     if (pQueryAttr->fillVal == NULL) {

src/query/src/qScript.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "os.h"
+#include "qScript.h"
+#include "ttype.h"
+#include "tstrbuild.h"
+#include "queryLog.h"
+#include "ttokendef.h"
+
+static ScriptEnvPool *pool = NULL;  
+
+static ScriptEnv* getScriptEnvFromPool();
+static void addScriptEnvToPool(ScriptEnv *pEnv);
+
+static lua_State* createLuaEnv();
+static void destroyLuaEnv(lua_State *state);
+
+static void destroyScriptEnv(ScriptEnv *pEnv);
+
+static void luaValueToTaosType(lua_State *lua, char *interBuf, int32_t *numOfOutput, int16_t oType, int16_t oBytes);
+static void taosValueToLuaType(lua_State *lua, int32_t type, char *val);
+
+static bool hasBaseFuncDefinedInScript(lua_State *lua, const char *funcPrefix, int32_t len);
+
+static int userlib_exampleFunc(lua_State *lua) {
+  double op1 = luaL_checknumber(lua,1);
+  double op2 = luaL_checknumber(lua,2);
+  lua_pushnumber(lua, op1 * op2); 
+  return 1; 
+}  
+void luaRegisterLibFunc(lua_State *lua) {
+  lua_register(lua, "exampleFunc", userlib_exampleFunc);
+}
+
+void luaLoadLib(lua_State *lua, const char *libname, lua_CFunction luafunc) {
+  lua_pushcfunction(lua, luafunc);
+  lua_pushstring(lua, libname);
+  lua_call(lua, 1, 0);
+}
+
+LUALIB_API int (luaopen_cjson) (lua_State *L);
+LUALIB_API int (luaopen_struct) (lua_State *L);
+LUALIB_API int (luaopen_cmsgpack) (lua_State *L);
+LUALIB_API int (luaopen_bit) (lua_State *L);
+
+
+static void luaLoadLibraries(lua_State *lua) {
+  luaLoadLib(lua, "", luaopen_base);
+  luaLoadLib(lua, LUA_TABLIBNAME, luaopen_table);
+  luaLoadLib(lua, LUA_STRLIBNAME, luaopen_string);
+  luaLoadLib(lua, LUA_MATHLIBNAME, luaopen_math);
+  luaLoadLib(lua, LUA_DBLIBNAME, luaopen_debug);
+}
+static void luaRemoveUnsupportedFunctions(lua_State *lua) {
+  lua_pushnil(lua);
+  lua_setglobal(lua,"loadfile");
+  lua_pushnil(lua);
+  lua_setglobal(lua,"dofile");
+}
+void taosValueToLuaType(lua_State *lua, int32_t type, char *val) {
+  //TODO(dengyihao): handle more data type
+  if (IS_SIGNED_NUMERIC_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) {
+    int64_t v;
+    GET_TYPED_DATA(v, int64_t, type, val);
+    lua_pushnumber(lua, (lua_Number)v);  
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+    uint64_t v;
+    GET_TYPED_DATA(v, uint64_t, type, val);
+    lua_pushnumber(lua,(lua_Number)v);  
+  } else if (IS_FLOAT_TYPE(type)) {
+    double v; 
+    GET_TYPED_DATA(v, double, type, val);
+    lua_pushnumber(lua,v); 
+  } else if (type == TSDB_DATA_TYPE_BINARY) {
+    lua_pushlstring(lua, val, varDataLen(val));       
+  } else if (type == TSDB_DATA_TYPE_NCHAR) {
+  } 
+} 
+int taosLoadScriptInit(void* pInit) {
+  ScriptCtx *pCtx = pInit;   
+  char funcName[MAX_FUNC_NAME] = {0};
+  sprintf(funcName, "%s_init", pCtx->funcName);
+
+  lua_State* lua = pCtx->pEnv->lua_state;   
+  lua_getglobal(lua, funcName);
+  if (lua_pcall(lua, 0, -1, 0)) {
+    lua_pop(lua, -1);
+  }
+  lua_setglobal(lua, "global"); 
+  return 0;
+}
+void taosLoadScriptNormal(void *pInit, char *pInput, int16_t iType, int16_t iBytes, int32_t numOfRows, 
+    int64_t *ptsList, int64_t key, char* pOutput, char *ptsOutput, int32_t *numOfOutput, int16_t oType, int16_t oBytes) { 
+  ScriptCtx* pCtx = pInit;
+  char funcName[MAX_FUNC_NAME] = {0};
+  sprintf(funcName, "%s_add", pCtx->funcName);
+
+  lua_State* lua  = pCtx->pEnv->lua_state;   
+  lua_getglobal(lua, funcName);
+
+  // first param of script;
+  lua_newtable(lua); 
+  int32_t offset = 0;
+  for (int32_t i = 0; i < numOfRows; i++) {
+    taosValueToLuaType(lua, iType, pInput + offset); 
+    lua_rawseti(lua, -2, i+1);
+    offset += iBytes;
+  } 
+  int isGlobalState = false; 
+  lua_getglobal(lua, "global"); 
+  if (lua_istable(lua, -1)) {
+    isGlobalState = true; 
+  }
+  lua_pushnumber(lua, (lua_Number)key);
+  // do call lua script 
+  if (lua_pcall(lua, 3, 1, 0) != 0) {
+    qError("SCRIPT ERROR: %s", lua_tostring(lua, -1)); 
+    lua_pop(lua, -1);
+    return;
+  }
+  int tNumOfOutput = 0; 
+  if (isGlobalState == false) {
+    luaValueToTaosType(lua, pOutput, &tNumOfOutput, oType, oBytes);
+  } else {
+    lua_setglobal(lua, "global");
+  }
+  *numOfOutput = tNumOfOutput;
+}
+
+void taosLoadScriptMerge(void *pInit, char* data, int32_t numOfRows, char* pOutput, int32_t* numOfOutput) {
+  ScriptCtx *pCtx = pInit;
+  char funcName[MAX_FUNC_NAME] = {0};
+  sprintf(funcName, "%s_merge", pCtx->funcName);
+
+  lua_State* lua  = pCtx->pEnv->lua_state;   
+  lua_getglobal(lua, funcName);
+  if (!lua_isfunction(lua, -1)) {
+    qError("SCRIPT ERROR: %s", lua_tostring(lua, -1)); 
+    return;
+  }
+
+  lua_getglobal(lua, "global"); 
+  if (lua_pcall(lua, 1, 1, 0) != 0) {
+    qError("SCRIPT ERROR: %s", lua_tostring(lua, -1)); 
+    lua_pop(lua, -1);
+    return;
+  }
+  int tNumOfOutput = 0; 
+  luaValueToTaosType(lua, pOutput, &tNumOfOutput, pCtx->resType, pCtx->resBytes);
+  *numOfOutput = tNumOfOutput;
+}
+
+//do not support agg now
+void taosLoadScriptFinalize(void *pInit,int64_t key, char *pOutput, int32_t* numOfOutput) {
+  ScriptCtx *pCtx = pInit;
+  char funcName[MAX_FUNC_NAME] = {0};
+  sprintf(funcName, "%s_finalize", pCtx->funcName);
+  
+  lua_State* lua  = pCtx->pEnv->lua_state;   
+  lua_getglobal(lua, funcName);
+  if (!lua_isfunction(lua, -1)) {
+    qError("SCRIPT ERROR: %s", lua_tostring(lua, -1)); 
+    return;
+  }
+
+  lua_getglobal(lua, "global"); 
+
+  lua_pushnumber(lua, (lua_Number)key);
+  if (lua_pcall(lua, 2, 2, 0) != 0) {
+    qError("SCRIPT ERROR: %s", lua_tostring(lua, -1)); 
+    lua_pop(lua, -1);
+    return;
+  }
+  lua_setglobal(lua, "global"); 
+  int tNumOfOutput = 0; 
+  luaValueToTaosType(lua, pOutput, &tNumOfOutput, pCtx->resType, pCtx->resBytes);
+  *numOfOutput = tNumOfOutput;
+}
+
+void taosLoadScriptDestroy(void *pInit) {
+  destroyScriptCtx(pInit);
+}
+
+ScriptCtx* createScriptCtx(char *script, int8_t resType, int16_t resBytes) {
+  ScriptCtx *pCtx = (ScriptCtx *)calloc(1, sizeof(ScriptCtx)); 
+  pCtx->state = SCRIPT_STATE_INIT; 
+  pCtx->pEnv  = getScriptEnvFromPool();  //  
+  pCtx->resType  = resType;
+  pCtx->resBytes = resBytes; 
+  
+  if (pCtx->pEnv == NULL) {
+    destroyScriptCtx(pCtx);
+    return NULL;
+  } 
+
+  lua_State *lua = pCtx->pEnv->lua_state;
+  if (luaL_dostring(lua, script)) {
+    lua_pop(lua, 1);
+    qError("dynamic load script failed");
+    destroyScriptCtx(pCtx);
+    return NULL;
+  } 
+  lua_getglobal(lua, USER_FUNC_NAME);
+  const char *name = lua_tostring(lua, -1); 
+  if (name == NULL) {
+    lua_pop(lua, 1);
+    qError("SCRIPT ERROR: invalid script");
+    destroyScriptCtx(pCtx);
+    return NULL; 
+  }
+  memcpy(pCtx->funcName, name, strlen(name));
+  lua_pop(lua, 1);
+  
+  return pCtx;
+}
+void destroyScriptCtx(void *pCtx) {
+  if (pCtx == NULL) return;
+  addScriptEnvToPool(((ScriptCtx *)pCtx)->pEnv);
+  free(pCtx);
+}
+
+void luaValueToTaosType(lua_State *lua, char *interBuf, int32_t *numOfOutput, int16_t oType, int16_t oBytes) {
+  int t = lua_type(lua,-1); 
+  int32_t sz = 0;
+  switch (t) {
+    case LUA_TSTRING:
+      //TODO(yihaodeng): handle str type
+      {
+        const char *v = lua_tostring(lua, -1);
+        memcpy(interBuf, v, strlen(v));
+        sz = 1; 
+      }
+      break;
+    case LUA_TBOOLEAN: 
+      {
+        double v = lua_tonumber(lua, -1);
+        memcpy(interBuf, (char *)&v, oBytes);
+        sz = 1;
+      }
+      break;
+    case LUA_TNUMBER:
+      {
+        if (oType == TSDB_DATA_TYPE_FLOAT) {
+          float v = (float)lua_tonumber(lua, -1);
+          memcpy(interBuf, (char *)&v, oBytes);
+          sz = 1;
+        } else if (oType == TSDB_DATA_TYPE_DOUBLE) {
+          double v = (double)lua_tonumber(lua, -1);
+          memcpy(interBuf, (char *)&v, oBytes);
+          sz = 1;
+        } else if (oType == TSDB_DATA_TYPE_BIGINT) {
+          int64_t v = (int64_t)lua_tonumber(lua, -1);
+          memcpy(interBuf, (char *)&v, oBytes);
+          sz = 1;
+        } else if (oType <= TSDB_DATA_TYPE_INT) {
+          int32_t v = (int32_t)lua_tonumber(lua, -1);
+          memcpy(interBuf, (char *)&v, oBytes);
+          sz = 1;
+        }
+      }
+      break;
+    case LUA_TTABLE: 
+      {
+        lua_pushnil(lua);
+        int32_t offset = 0;
+        while(lua_next(lua, -2)) {
+          int32_t v = (int32_t)lua_tonumber(lua, -1); 
+          memcpy(interBuf + offset, (char *)&v, oBytes);
+          offset += oBytes;
+          lua_pop(lua, 1);
+          sz += 1;
+        }
+      }
+      break;
+    default:
+      setNull(interBuf, oType, oBytes);
+      sz = 1;
+      break; 
+  }
+  lua_pop(lua,1); // pop ret value from script  
+  *numOfOutput = sz; 
+}
+
+
+/*
+*Initialize the scripting environment.
+*/  
+lua_State* createLuaEnv() {
+  lua_State *lua = lua_open(); 
+  luaLoadLibraries(lua);
+  luaRemoveUnsupportedFunctions(lua);
+
+  // register func in external lib 
+  luaRegisterLibFunc(lua); 
+
+  {
+    char *errh_func = "local dbg = debug\n"
+                      "function __taos__err__handler(err)\n"
+                      "  local i = dbg.getinfo(2,'nSl')\n"
+                      "  if i and i.what == 'C' then\n"
+                      "    i = dbg.getinfo(3,'nSl')\n"
+                      "  end\n"
+                      "  if i then\n"
+                      "    return i.source .. ':' .. i.currentline .. ': ' .. err\n"
+                      "  else\n"
+                      "    return err\n"
+                      "  end\n"
+                      "end\n";
+    luaL_loadbuffer(lua,errh_func,strlen(errh_func),"@err_handler_def");
+    lua_pcall(lua,0,0,0);
+  }
+    
+  return lua;
+}
+
+void destroyLuaEnv(lua_State *lua) {
+  lua_close(lua); 
+}
+
+int32_t scriptEnvPoolInit() {
+  const int size = 10; // configure or not 
+  pool = malloc(sizeof(ScriptEnvPool));  
+  pthread_mutex_init(&pool->mutex, NULL);
+
+  pool->scriptEnvs = tdListNew(sizeof(ScriptEnv *));
+  for (int i = 0; i < size; i++) {
+    ScriptEnv *env = malloc(sizeof(ScriptEnv));
+    env->funcId = taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK);;  
+    env->lua_state = createLuaEnv(); 
+    tdListAppend(pool->scriptEnvs, (void *)(&env));  
+  }
+  pool->mSize = size;
+  pool->cSize = size;
+  return 0;  
+}
+
+void scriptEnvPoolCleanup() {
+  if (pool == NULL) return;
+  
+  SListNode *pNode = NULL; 
+  while ((pNode = tdListPopHead(pool->scriptEnvs)) != NULL) {
+    ScriptEnv *pEnv = NULL;
+    tdListNodeGetData(pool->scriptEnvs, pNode, (void *)(&pEnv));
+    destroyScriptEnv(pEnv);
+    listNodeFree(pNode); 
+  }  
+  tdListFree(pool->scriptEnvs);
+  pthread_mutex_destroy(&pool->mutex);
+  free(pool);
+}
+
+void destroyScriptEnv(ScriptEnv *pEnv) {
+  destroyLuaEnv(pEnv->lua_state);       
+  taosHashCleanup(pEnv->funcId); 
+  free(pEnv);
+} 
+
+ScriptEnv* getScriptEnvFromPool() {
+  ScriptEnv *pEnv = NULL;
+
+  pthread_mutex_lock(&pool->mutex); 
+  if (pool->cSize <= 0) {
+    pthread_mutex_unlock(&pool->mutex); 
+    return NULL;
+  }  
+  SListNode *pNode = tdListPopHead(pool->scriptEnvs);
+  tdListNodeGetData(pool->scriptEnvs, pNode, (void *)(&pEnv));
+  listNodeFree(pNode); 
+  
+  pool->cSize--;
+  pthread_mutex_unlock(&pool->mutex); 
+  return pEnv; 
+}
+
+void addScriptEnvToPool(ScriptEnv *pEnv) {
+  if (pEnv == NULL) {
+    return;
+  }
+  pthread_mutex_lock(&pool->mutex); 
+  lua_settop(pEnv->lua_state, 0);
+  tdListAppend(pool->scriptEnvs, (void *)(&pEnv));  
+  pool->cSize++;
+  pthread_mutex_unlock(&pool->mutex); 
+}
+
+bool hasBaseFuncDefinedInScript(lua_State *lua, const char *funcPrefix, int32_t len) {
+  bool ret = true;
+  char funcName[MAX_FUNC_NAME]; 
+  memcpy(funcName, funcPrefix, len); 
+
+  const char *base[] = {"_init", "_add"};
+  for (int i = 0; (i < sizeof(base)/sizeof(base[0])) && (ret == true); i++) {
+    memcpy(funcName + len, base[i], strlen(base[i])); 
+    memset(funcName + len + strlen(base[i]), 0, MAX_FUNC_NAME - len - strlen(base[i]));
+    lua_getglobal(lua, funcName);   
+    ret = lua_isfunction(lua, -1); // exsit function or not 
+    lua_pop(lua, 1);
+  }
+  return ret;
+} 
+
+bool isValidScript(char *script, int32_t len) {
+  ScriptEnv *pEnv = getScriptEnvFromPool();  //  
+  if (pEnv == NULL) {
+    return false;
+  }  
+  lua_State *lua = pEnv->lua_state; 
+  if (len < strlen(script)) {
+    script[len] = 0; 
+  }  
+  if (luaL_dostring(lua, script)) {
+    lua_pop(lua, 1);
+    addScriptEnvToPool(pEnv); 
+    qError("error at %s and %d", script, (int)(strlen(script)));
+    return false;
+  }
+  lua_getglobal(lua, USER_FUNC_NAME);
+  const char *name = lua_tostring(lua, -1);
+  if (name == NULL || strlen(name) >= USER_FUNC_NAME_LIMIT) {
+    lua_pop(lua, 1);
+    addScriptEnvToPool(pEnv); 
+    qError("error at %s name: %s, len = %d", script, name, (int)(strlen(name)));
+    return false;
+  } 
+  bool ret = hasBaseFuncDefinedInScript(lua, name, (int32_t)strlen(name));
+  lua_pop(lua, 1); // pop  
+  addScriptEnvToPool(pEnv); 
+  return ret;
+}
+

src/query/src/qSqlParser.c

@@ -28,6 +28,7 @@ SSqlInfo qSqlParse(const char *pStr) {
 
   SSqlInfo sqlInfo = {0};
   sqlInfo.valid = true;
+  sqlInfo.funcs = taosArrayInit(4, sizeof(SStrToken));
 
   int32_t i = 0;
   while (1) {
@@ -120,6 +121,19 @@ void tSqlExprListDestroy(SArray *pList) {
   taosArrayDestroyEx(pList, freeExprElem);
 }
 
+
+SArray *tStrTokenAppend(SArray *pList, SStrToken *pToken) {
+  if (pList == NULL) {
+    pList = taosArrayInit(4, sizeof(tVariantListItem));
+  }
+
+  if (pToken) {
+    taosArrayPush(pList, pToken);
+  }
+
+  return pList;
+}
+
 tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType) {
   tSqlExpr *pSqlExpr = calloc(1, sizeof(tSqlExpr));
 
@@ -922,8 +936,8 @@ void* destroyCreateTableSql(SCreateTableSql* pCreate) {
 }
 
 void SqlInfoDestroy(SSqlInfo *pInfo) {
-  if (pInfo == NULL) return;
-
+  if (pInfo == NULL) return;;
+  taosArrayDestroy(pInfo->funcs); 
   if (pInfo->type == TSDB_SQL_SELECT) {
     destroyAllSqlNode(pInfo->list);
   } else if (pInfo->type == TSDB_SQL_CREATE_TABLE) {
@@ -1018,6 +1032,18 @@ void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrTo
   pInfo->pMiscInfo->tableType = tableType;
 }
 
+void setDropFuncInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken) {
+  pInfo->type = type;
+
+  if (pInfo->pMiscInfo == NULL) {
+    pInfo->pMiscInfo = (SMiscInfo *)calloc(1, sizeof(SMiscInfo));
+    pInfo->pMiscInfo->a = taosArrayInit(4, sizeof(SStrToken));
+  }
+
+  taosArrayPush(pInfo->pMiscInfo->a, pToken);
+}
+
+
 void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken* pPatterns) {
   if (pInfo->pMiscInfo == NULL) {
     pInfo->pMiscInfo = calloc(1, sizeof(SMiscInfo));
@@ -1052,6 +1078,24 @@ void setCreateDbInfo(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDb
   pInfo->pMiscInfo->dbOpt.ignoreExists = pIgExists->n; // sql.y has: ifnotexists(X) ::= IF NOT EXISTS.   {X.n = 1;}
 }
 
+void setCreateFuncInfo(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPath, TAOS_FIELD *output, SStrToken* bufSize, int32_t funcType) {
+  pInfo->type = type;
+  if (pInfo->pMiscInfo == NULL) {
+    pInfo->pMiscInfo = calloc(1, sizeof(SMiscInfo));
+  }
+
+  pInfo->pMiscInfo->funcOpt.name = *pName;
+  pInfo->pMiscInfo->funcOpt.path = *pPath;
+  pInfo->pMiscInfo->funcOpt.output = *output;
+  pInfo->pMiscInfo->funcOpt.type = funcType;
+  if (bufSize->n > 0) {
+    pInfo->pMiscInfo->funcOpt.bufSize = strtol(bufSize->z, NULL, 10);
+  } else {
+    pInfo->pMiscInfo->funcOpt.bufSize = 0;  
+  }
+}
+
+
 void setCreateAcctSql(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPwd, SCreateAcctInfo *pAcctInfo) {
   pInfo->type = type;
   if (pInfo->pMiscInfo == NULL) {

src/query/src/queryMain.c

@@ -68,7 +68,7 @@ void freeParam(SQueryParam *param) {
   tfree(param->prevResult);
 }
 
-int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qinfo_t* pQInfo, uint64_t *qId) {
+int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qinfo_t* pQInfo, uint64_t qId) {
   assert(pQueryMsg != NULL && tsdb != NULL);
 
   int32_t code = TSDB_CODE_SUCCESS;
@@ -93,12 +93,12 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
 
   SQueriedTableInfo info = { .numOfTags = pQueryMsg->numOfTags, .numOfCols = pQueryMsg->numOfCols, .colList = pQueryMsg->tableCols};
   if ((code = createQueryFunc(&info, pQueryMsg->numOfOutput, &param.pExprs, param.pExpr, param.pTagColumnInfo,
-                              pQueryMsg->queryType, pQueryMsg)) != TSDB_CODE_SUCCESS) {
+                              pQueryMsg->queryType, pQueryMsg, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
     goto _over;
   }
 
   if (param.pSecExpr != NULL) {
-    if ((code = createIndirectQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->secondStageOutput, &param.pSecExprs, param.pSecExpr, param.pExprs)) != TSDB_CODE_SUCCESS) {
+    if ((code = createIndirectQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->secondStageOutput, &param.pSecExprs, param.pSecExpr, param.pExprs, param.pUdfInfo)) != TSDB_CODE_SUCCESS) {
       goto _over;
     }
   }
@@ -162,18 +162,14 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
 
   assert(pQueryMsg->stableQuery == isSTableQuery);
   (*pQInfo) = createQInfoImpl(pQueryMsg, param.pGroupbyExpr, param.pExprs, param.pSecExprs, &tableGroupInfo,
-                              param.pTagColumnInfo, vgId, param.sql, *qId);
+                              param.pTagColumnInfo, vgId, param.sql, qId, param.pUdfInfo);
 
   param.sql    = NULL;
   param.pExprs = NULL;
   param.pSecExprs = NULL;
   param.pGroupbyExpr = NULL;
   param.pTagColumnInfo = NULL;
-
-  if ((*pQInfo) == NULL) {
-    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
-    goto _over;
-  }
+  param.pUdfInfo = NULL;
 
   code = initQInfo(&pQueryMsg->tsBuf, tsdb, NULL, *pQInfo, &param, (char*)pQueryMsg, pQueryMsg->prevResultLen, NULL);
 
@@ -182,6 +178,8 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
     taosArrayDestroy(param.pGroupbyExpr->columnInfo);
   }
 
+  destroyUdfInfo(param.pUdfInfo);
+
   taosArrayDestroy(param.pTableIdList);
   param.pTableIdList = NULL;
 

src/query/src/sql.c

@@ -97,28 +97,28 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 271
+#define YYNOCODE 277
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  int yy112;
-  SCreateAcctInfo yy151;
-  tSqlExpr* yy166;
-  SCreateTableSql* yy182;
-  SSqlNode* yy236;
-  SRelationInfo* yy244;
+  TAOS_FIELD yy31;
+  int yy52;
+  SLimitVal yy126;
+  SWindowStateVal yy144;
+  SCreateTableSql* yy158;
+  SCreateDbInfo yy214;
   SSessionWindowVal yy259;
-  SIntervalVal yy340;
-  TAOS_FIELD yy343;
-  SWindowStateVal yy348;
-  int64_t yy369;
-  SCreateDbInfo yy382;
-  SLimitVal yy414;
-  SArray* yy441;
-  SCreatedTableInfo yy456;
+  tSqlExpr* yy370;
+  SRelationInfo* yy412;
+  SCreatedTableInfo yy432;
+  SSqlNode* yy464;
+  int64_t yy501;
   tVariant yy506;
+  SIntervalVal yy520;
+  SArray* yy525;
+  SCreateAcctInfo yy547;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -128,17 +128,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             347
-#define YYNRULE              283
-#define YYNTOKEN             190
-#define YY_MAX_SHIFT         346
-#define YY_MIN_SHIFTREDUCE   547
-#define YY_MAX_SHIFTREDUCE   829
-#define YY_ERROR_ACTION      830
-#define YY_ACCEPT_ACTION     831
-#define YY_NO_ACTION         832
-#define YY_MIN_REDUCE        833
-#define YY_MAX_REDUCE        1115
+#define YYNSTATE             362
+#define YYNRULE              289
+#define YYNTOKEN             195
+#define YY_MAX_SHIFT         361
+#define YY_MIN_SHIFTREDUCE   567
+#define YY_MAX_SHIFTREDUCE   855
+#define YY_ERROR_ACTION      856
+#define YY_ACCEPT_ACTION     857
+#define YY_NO_ACTION         858
+#define YY_MIN_REDUCE        859
+#define YY_MAX_REDUCE        1147
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -204,279 +204,288 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (731)
+#define YY_ACTTAB_COUNT (753)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */    23,  596, 1004,  596,  219,  344,  194,  831,  346,  597,
- /*    10 */   596,  597,  197,   54,   55,  225,   58,   59,  597,  982,
- /*    20 */   239,   48, 1091,   57,  302,   62,   60,   63,   61,  995,
- /*    30 */   995,  231,  233,   53,   52,  982,  982,   51,   50,   49,
- /*    40 */    54,   55,   35,   58,   59,  222,  223,  239,   48,  596,
- /*    50 */    57,  302,   62,   60,   63,   61,  995,  597,  152,  236,
- /*    60 */    53,   52,  235,  152,   51,   50,   49,   55, 1001,   58,
- /*    70 */    59,  770,  261,  239,   48,  240,   57,  302,   62,   60,
- /*    80 */    63,   61,   29,   83,  976,  221,   53,   52,  145,  979,
- /*    90 */    51,   50,   49,  548,  549,  550,  551,  552,  553,  554,
- /*   100 */   555,  556,  557,  558,  559,  560,  345,  771,  768,  220,
- /*   110 */    95,   77,   54,   55,   35,   58,   59,   42,  197,  239,
- /*   120 */    48,  197,   57,  302,   62,   60,   63,   61, 1092,  232,
- /*   130 */  1040, 1092,   53,   52,  197,   89,   51,   50,   49,   54,
- /*   140 */    56,  968,   58,   59, 1092,  970,  239,   48,  262,   57,
- /*   150 */   302,   62,   60,   63,   61,  268,  267,  229,   36,   53,
- /*   160 */    52,  979,  248,   51,   50,   49,   41,  298,  339,  338,
- /*   170 */   297,  296,  295,  337,  294,  293,  292,  336,  291,  335,
- /*   180 */   334,  944,  932,  933,  934,  935,  936,  937,  938,  939,
- /*   190 */   940,  941,  942,  943,  945,  946,   58,   59,   24,  980,
- /*   200 */   239,   48,   90,   57,  302,   62,   60,   63,   61,   51,
- /*   210 */    50,   49,  152,   53,   52,  205,   78,   51,   50,   49,
- /*   220 */    53,   52,  206,  300,   51,   50,   49,  129,  128,  204,
- /*   230 */   732,  238,  783,  307,   83,  772,  740,  775,   35,  778,
- /*   240 */   147,  238,  783,  116,  253,  772,   65,  775,   35,  778,
- /*   250 */   300,  332,  152,  257,  256,   35,  879,   62,   60,   63,
- /*   260 */    61,  179,  332,  217,  218,   53,   52,  303,   42,   51,
- /*   270 */    50,   49,  700,  217,  218,  697,  304,  698,   14,  699,
- /*   280 */    41,  230,  339,  338, 1041,  979,  280,  337,  340,  913,
- /*   290 */   260,  336,   75,  335,  334,  978,    1,  167,  311,  213,
- /*   300 */   628,  242,  979,  244,  245,  114,  108,  119,   94,   91,
- /*   310 */    64,  195,  118,  124,  127,  117,  952,   80,  950,  951,
- /*   320 */    64,  121,  282,  953,   88,   76,  247,  954,   35,  955,
- /*   330 */   956,    5,   38,  169,   92,    3,  180,   35,  168,  102,
- /*   340 */    97,  101,  784,  779,   35,   35,   35,   35,  716,  780,
- /*   350 */   676,  264,  784,  779,  188,  186,  184,  200,  967,  780,
- /*   360 */    35,  183,  132,  131,  130, 1088,  965,  966,   34,  969,
- /*   370 */  1087,  312,  243,  787,  241,  979,  310,  309,  322,  321,
- /*   380 */   313,  889,  701,  702,  979,   81,  179,  314,  318,  319,
- /*   390 */   320,  979,  979,  979,  979,  880,  774,  249,  777,  246,
- /*   400 */   179,  317,  316,  324,  773,  713,  776,  979,  343,  342,
- /*   410 */   137,  741,  143,  141,  140,  749,  750,   68,   71,  264,
- /*   420 */   686,   26,  237,  285,   16,  688,   15,  287,  720,  687,
- /*   430 */    36,  981,    9,   36,   33,   65,  804,   93,  785,   65,
- /*   440 */   595,   74,    6,  107, 1086,  106,   25,   18,   25,   17,
- /*   450 */    25,  705,  703,  706,  704,   20,  113,   19,  112,   72,
- /*   460 */    69,  215,   22,  288,   21,  126,  125,  216,  198,  675,
- /*   470 */   199,  201,  196,  202,  203,  208,  209,  210,  207,  193,
- /*   480 */  1111, 1103, 1051, 1050,  227, 1047, 1046,  228,  323,   45,
- /*   490 */   258,  144, 1003, 1014, 1011, 1012, 1016,  996,  142,  265,
- /*   500 */   146, 1033,  150,  274, 1032,  977,  163,  164,  269,  224,
- /*   510 */   781,  975,  165,  166,  892,  290,  731,   43,  782,  191,
- /*   520 */   283,  993,   39,  301,  154,  888,  308, 1110,  104, 1109,
- /*   530 */  1106,  170,  315,   73, 1102,  110,  271,  278,   70,  153,
- /*   540 */    47, 1101,  155, 1098,  281,  171,  910,   40,  279,  277,
- /*   550 */    37,  275,   44,  273,  192,  270,  156,  876,  120,  874,
- /*   560 */   122,  123,  872,  871,  250,  182,  869,  868,  867,  866,
- /*   570 */   865,  864,  185,  187,  861,  859,  857,  855,  189,  852,
- /*   580 */   190,  333,  263,   79,   46,   84,  115,  272, 1034,  325,
- /*   590 */   326,  327,  328,  329,  330,  331,  214,  341,  829,  234,
- /*   600 */   251,  252,  289,  828,  254,  255,  827,  211,  212,  809,
- /*   610 */    98,  810,   99,  259,  264,  284,   10,   82,  708,  266,
- /*   620 */    85,   30,  870,  174,  178,  863,  911,  172,  173,  175,
- /*   630 */   176,    4,  133,  177,  862,  912,  134,  135,  948,  136,
- /*   640 */   854,  733,  148,  853,  157,  158,  159,  160,  736,  161,
- /*   650 */   149,  162,  958,    2,   86,  226,  738,   87,  276,   31,
- /*   660 */   742,  151,   32,   13,   11,   27,  286,   28,   12,  641,
- /*   670 */    96,   94,  639,  638,  637,  635,  634,  633,  630,  299,
- /*   680 */   600,  100,    7,  305,  786,  788,    8,  306,  103,  105,
- /*   690 */    66,   67,  109,  111,  678,   36,  677,  674,  622,  620,
- /*   700 */   612,  618,  614,  616,  610,  608,  644,  643,  642,  640,
- /*   710 */   636,  632,  631,  181,  598,  564,  562,  833,  832,  832,
- /*   720 */   832,  832,  832,  832,  832,  832,  832,  832,  832,  138,
- /*   730 */   139,
+ /*     0 */   206,  618,  245,  618,  618,   97,  244,  228,  359,  619,
+ /*    10 */  1123,  619,  619,   56,   57,  152,   60,   61,  654, 1027,
+ /*    20 */   248,   50, 1036,   59,  317,   64,   62,   65,   63,  984,
+ /*    30 */   249,  982,  983,   55,   54,  231,  985,   53,   52,   51,
+ /*    40 */   986, 1002,  987,  988,   53,   52,   51,  568,  569,  570,
+ /*    50 */   571,  572,  573,  574,  575,  576,  577,  578,  579,  580,
+ /*    60 */   581,  360,  206,  257,  229,  159,  206,   56,   57,   37,
+ /*    70 */    60,   61, 1124,  174,  248,   50, 1124,   59,  317,   64,
+ /*    80 */    62,   65,   63,  277,  276,   29,   79,   55,   54, 1033,
+ /*    90 */   206,   53,   52,   51,   56,   57,  315,   60,   61,  234,
+ /*   100 */  1124,  248,   50, 1014,   59,  317,   64,   62,   65,   63,
+ /*   110 */   358,  357,  144,  230,   55,   54,   85, 1011,   53,   52,
+ /*   120 */    51,   56,   58,  240,   60,   61,  347, 1014,  248,   50,
+ /*   130 */    94,   59,  317,   64,   62,   65,   63,  794, 1073,  242,
+ /*   140 */   289,   55,   54, 1014,  618,   53,   52,   51,   57,   23,
+ /*   150 */    60,   61,  619,   44,  248,   50, 1000,   59,  317,   64,
+ /*   160 */    62,   65,   63,  997,  998,   34, 1001,   55,   54,  857,
+ /*   170 */   361,   53,   52,   51,   43,  313,  354,  353,  312,  311,
+ /*   180 */   310,  352,  309,  308,  307,  351,  306,  350,  349,  976,
+ /*   190 */   964,  965,  966,  967,  968,  969,  970,  971,  972,  973,
+ /*   200 */   974,  975,  977,  978,   60,   61,   24, 1008,  248,   50,
+ /*   210 */   257,   59,  317,   64,   62,   65,   63, 1027,  122, 1027,
+ /*   220 */   175,   55,   54,   37,  209,   53,   52,   51,  247,  809,
+ /*   230 */   347,  215,  798,  232,  801,  270,  804,  135,  134,  214,
+ /*   240 */   315,  247,  809,  322,   85,  798,   14,  801,   37,  804,
+ /*   250 */    93,  159,  726,  241,  203,  723,  800,  724,  803,  725,
+ /*   260 */   226,  227,  257,   16,  318,   15,   37,  238,    5,   40,
+ /*   270 */   178, 1011, 1012,  226,  227,  177,  103,  108,   99,  107,
+ /*   280 */    96,   44,  204,  253,  254,  210,   64,   62,   65,   63,
+ /*   290 */   355,  945,  159,  302,   55,   54, 1010,  251,   53,   52,
+ /*   300 */    51, 1013,   78,  269,  256,   77,  120,  114,  125,   66,
+ /*   310 */   239,  702,  222,  124, 1011,  130,  133,  123,   37,  197,
+ /*   320 */   195,  193,   66,  127, 1072,   37,  192,  139,  138,  137,
+ /*   330 */   136,  799,  159,  802,   37,   43,  999,  354,  353,  337,
+ /*   340 */   336,   37,  352,  262,  810,  805,  351,   37,  350,  349,
+ /*   350 */    37,  806,  266,  265,  742,   55,   54,  810,  805,   53,
+ /*   360 */    52,   51,  326,  291,  806,   90, 1011,  727,  728,  327,
+ /*   370 */    37,   37,  252, 1011,  250,  807,  325,  324,  328,  258,
+ /*   380 */    82,  255, 1011,  332,  331,  329,  150,  148,  147, 1011,
+ /*   390 */   907,  333,   83,  917,  334, 1011,  908,  188, 1011,  271,
+ /*   400 */   188,  739,   92,  188,   70,   91,    1,  176,    3,  189,
+ /*   410 */   775,  776,  758,   38,  335,  339,   80,  273, 1011, 1011,
+ /*   420 */   766,  767,   73,  712,  294,   33,  154,    9,  714,  273,
+ /*   430 */   296,  713,  796,  830,   67,   26,  246,   38,   38,  746,
+ /*   440 */   811,  319,   67,   76,   95,   67,   71,   25, 1120,  617,
+ /*   450 */   808,  132,  131,  113,   25,  112, 1119,    6,  297,   18,
+ /*   460 */  1118,   17,   74,   25,  731,  729,  732,  730,  797,   20,
+ /*   470 */  1083,   19,  119,  224,  118,  701,   22,  225,   21,  207,
+ /*   480 */   208,  211,  205,  212,  213,  217,  218,  219,  216,  202,
+ /*   490 */  1143, 1082, 1135,  236,  267, 1079, 1078,  237,  338,  151,
+ /*   500 */  1035, 1046,   47, 1065, 1043,  149, 1064, 1025, 1028, 1044,
+ /*   510 */   274, 1048,  153,  170,  157, 1009,  278,  283,  171, 1007,
+ /*   520 */   172,  233,  166,  280,  161,  757,  160,  173,  162,  922,
+ /*   530 */   163,  299,  300,  301,  304,  305,  287,  292,   45,  290,
+ /*   540 */    75,  200,  288,  813,  272,   41,   72,   49,  316,  164,
+ /*   550 */   916,  323, 1142,  110, 1141, 1138,  286,  179,  330, 1134,
+ /*   560 */   284,  116, 1133, 1130,  180,  282,  942,   42,   39,   46,
+ /*   570 */   201,  904,  279,  126,   48,  902,  128,  129,  900,  899,
+ /*   580 */   259,  191,  897,  896,  895,  894,  893,  892,  891,  194,
+ /*   590 */   196,  888,  886,  884,  882,  198,  879,  199,  303,   81,
+ /*   600 */    86,  348,  281, 1066,  121,  340,  341,  342,  343,  344,
+ /*   610 */   223,  345,  346,  356,  855,  243,  298,  260,  261,  854,
+ /*   620 */   263,  220,  221,  264,  853,  836,  104,  921,  920,  105,
+ /*   630 */   835,  268,  273,   10,  293,  734,  275,   84,   30,   87,
+ /*   640 */   898,  890,  182,  943,  186,  181,  184,  140,  183,  187,
+ /*   650 */   185,  141,  142,  889,    4,  143,  980,  881,  880,  944,
+ /*   660 */   759,  165,  167,  168,  155,  169,  762,  156,    2,  990,
+ /*   670 */    88,  235,  764,   89,  285,   31,  768,  158,   11,   12,
+ /*   680 */    13,   32,   27,  295,   28,   96,   98,  101,   35,  100,
+ /*   690 */   632,   36,  102,  667,  665,  664,  663,  661,  660,  659,
+ /*   700 */   656,  314,  622,  106,    7,  320,  812,  814,    8,  321,
+ /*   710 */   109,  111,   68,   69,  115,  704,  703,   38,  117,  700,
+ /*   720 */   648,  646,  638,  644,  640,  642,  636,  634,  670,  669,
+ /*   730 */   668,  666,  662,  658,  657,  190,  620,  585,  583,  859,
+ /*   740 */   858,  858,  858,  858,  858,  858,  858,  858,  858,  858,
+ /*   750 */   858,  145,  146,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   259,    1,  194,    1,  193,  194,  259,  191,  192,    9,
- /*    10 */     1,    9,  259,   13,   14,  238,   16,   17,    9,  242,
- /*    20 */    20,   21,  269,   23,   24,   25,   26,   27,   28,  240,
- /*    30 */   240,  238,  238,   33,   34,  242,  242,   37,   38,   39,
- /*    40 */    13,   14,  194,   16,   17,  256,  256,   20,   21,    1,
- /*    50 */    23,   24,   25,   26,   27,   28,  240,    9,  194,  200,
- /*    60 */    33,   34,  200,  194,   37,   38,   39,   14,  260,   16,
- /*    70 */    17,    1,  256,   20,   21,  200,   23,   24,   25,   26,
- /*    80 */    27,   28,   80,   80,  194,  237,   33,   34,  194,  241,
- /*    90 */    37,   38,   39,   45,   46,   47,   48,   49,   50,   51,
- /*   100 */    52,   53,   54,   55,   56,   57,   58,   37,   81,   61,
- /*   110 */   201,  111,   13,   14,  194,   16,   17,  114,  259,   20,
- /*   120 */    21,  259,   23,   24,   25,   26,   27,   28,  269,  239,
- /*   130 */   266,  269,   33,   34,  259,  266,   37,   38,   39,   13,
- /*   140 */    14,    0,   16,   17,  269,  236,   20,   21,   81,   23,
- /*   150 */    24,   25,   26,   27,   28,  261,  262,  237,   91,   33,
- /*   160 */    34,  241,  194,   37,   38,   39,   92,   93,   94,   95,
- /*   170 */    96,   97,   98,   99,  100,  101,  102,  103,  104,  105,
- /*   180 */   106,  215,  216,  217,  218,  219,  220,  221,  222,  223,
- /*   190 */   224,  225,  226,  227,  228,  229,   16,   17,   44,  231,
- /*   200 */    20,   21,  243,   23,   24,   25,   26,   27,   28,   37,
- /*   210 */    38,   39,  194,   33,   34,   61,  257,   37,   38,   39,
- /*   220 */    33,   34,   68,   82,   37,   38,   39,   73,   74,   75,
- /*   230 */    81,    1,    2,   79,   80,    5,   81,    7,  194,    9,
- /*   240 */    91,    1,    2,   76,  137,    5,   91,    7,  194,    9,
- /*   250 */    82,   84,  194,  146,  147,  194,  199,   25,   26,   27,
- /*   260 */    28,  204,   84,   33,   34,   33,   34,   37,  114,   37,
- /*   270 */    38,   39,    2,   33,   34,    5,   15,    7,   80,    9,
- /*   280 */    92,  237,   94,   95,  266,  241,  268,   99,  213,  214,
- /*   290 */   136,  103,  138,  105,  106,  241,  202,  203,  237,  145,
- /*   300 */     5,   68,  241,   33,   34,   62,   63,   64,  110,  111,
- /*   310 */    80,  259,   69,   70,   71,   72,  215,   81,  217,  218,
- /*   320 */    80,   78,  264,  222,  266,  201,   68,  226,  194,  228,
- /*   330 */   229,   62,   63,   64,  201,  197,  198,  194,   69,   70,
- /*   340 */    71,   72,  112,  113,  194,  194,  194,  194,   37,  119,
- /*   350 */     5,  115,  112,  113,   62,   63,   64,  259,  234,  119,
- /*   360 */   194,   69,   70,   71,   72,  259,  233,  234,  235,  236,
- /*   370 */   259,  237,  139,  112,  141,  241,  143,  144,   33,   34,
- /*   380 */   237,  199,  112,  113,  241,   81,  204,  237,  237,  237,
- /*   390 */   237,  241,  241,  241,  241,  199,    5,  139,    7,  141,
- /*   400 */   204,  143,  144,  237,    5,   91,    7,  241,   65,   66,
- /*   410 */    67,   81,   62,   63,   64,  127,  128,   91,   91,  115,
- /*   420 */    81,   91,   60,   81,  140,   81,  142,   81,  117,   81,
- /*   430 */    91,  242,  118,   91,   80,   91,   81,   91,   81,   91,
- /*   440 */    81,   80,   80,  140,  259,  142,   91,  140,   91,  142,
- /*   450 */    91,    5,    5,    7,    7,  140,  140,  142,  142,  132,
- /*   460 */   134,  259,  140,  109,  142,   76,   77,  259,  259,  108,
- /*   470 */   259,  259,  259,  259,  259,  259,  259,  259,  259,  259,
- /*   480 */   242,  242,  232,  232,  232,  232,  232,  232,  232,  258,
- /*   490 */   194,  194,  194,  194,  194,  194,  194,  240,   60,  240,
- /*   500 */   194,  267,  194,  194,  267,  240,  244,  194,  263,  263,
- /*   510 */   119,  194,  194,  194,  194,  194,  119,  194,  119,  194,
- /*   520 */   125,  255,  194,  194,  253,  194,  194,  194,  194,  194,
- /*   530 */   194,  194,  194,  131,  194,  194,  263,  263,  133,  254,
- /*   540 */   130,  194,  252,  194,  129,  194,  194,  194,  124,  123,
- /*   550 */   194,  122,  194,  121,  194,  120,  251,  194,  194,  194,
- /*   560 */   194,  194,  194,  194,  194,  194,  194,  194,  194,  194,
- /*   570 */   194,  194,  194,  194,  194,  194,  194,  194,  194,  194,
- /*   580 */   194,  107,  195,  195,  135,  195,   90,  195,  195,   89,
- /*   590 */    50,   86,   88,   54,   87,   85,  195,   82,    5,  195,
- /*   600 */   148,    5,  195,    5,  148,    5,    5,  195,  195,   93,
- /*   610 */   201,   94,  201,  137,  115,  109,   80,  116,   81,   91,
- /*   620 */    91,   80,  195,  206,  205,  195,  212,  211,  210,  209,
- /*   630 */   207,  197,  196,  208,  195,  214,  196,  196,  230,  196,
- /*   640 */   195,   81,   80,  195,  250,  249,  248,  247,   81,  246,
- /*   650 */    91,  245,  230,  202,   80,    1,   81,   80,   80,   91,
- /*   660 */    81,   80,   91,   80,  126,   80,  109,   80,  126,    9,
- /*   670 */    76,  110,    5,    5,    5,    5,    5,    5,    5,   15,
- /*   680 */    83,   76,   80,   24,   81,  112,   80,   58,  142,  142,
- /*   690 */    16,   16,  142,  142,    5,   91,    5,   81,    5,    5,
- /*   700 */     5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   710 */     5,    5,    5,   91,   83,   60,   59,    0,  270,  270,
- /*   720 */   270,  270,  270,  270,  270,  270,  270,  270,  270,   21,
- /*   730 */    21,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   740 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   750 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   760 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   770 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   780 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   790 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   800 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   810 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   820 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   830 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   840 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   850 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   860 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   870 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   880 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   890 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   900 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   910 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   920 */   270,
+ /*     0 */   265,    1,  205,    1,    1,  206,  205,  198,  199,    9,
+ /*    10 */   275,    9,    9,   13,   14,  199,   16,   17,    5,  246,
+ /*    20 */    20,   21,  199,   23,   24,   25,   26,   27,   28,  222,
+ /*    30 */   205,  224,  225,   33,   34,  262,  229,   37,   38,   39,
+ /*    40 */   233,  242,  235,  236,   37,   38,   39,   45,   46,   47,
+ /*    50 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
+ /*    60 */    58,   59,  265,  199,   62,  199,  265,   13,   14,  199,
+ /*    70 */    16,   17,  275,  209,   20,   21,  275,   23,   24,   25,
+ /*    80 */    26,   27,   28,  267,  268,   82,   86,   33,   34,  266,
+ /*    90 */   265,   37,   38,   39,   13,   14,   84,   16,   17,  244,
+ /*   100 */   275,   20,   21,  248,   23,   24,   25,   26,   27,   28,
+ /*   110 */    66,   67,   68,  243,   33,   34,   82,  247,   37,   38,
+ /*   120 */    39,   13,   14,  244,   16,   17,   90,  248,   20,   21,
+ /*   130 */   206,   23,   24,   25,   26,   27,   28,   83,  272,  244,
+ /*   140 */   274,   33,   34,  248,    1,   37,   38,   39,   14,  265,
+ /*   150 */    16,   17,    9,  119,   20,   21,    0,   23,   24,   25,
+ /*   160 */    26,   27,   28,  239,  240,  241,  242,   33,   34,  196,
+ /*   170 */   197,   37,   38,   39,   98,   99,  100,  101,  102,  103,
+ /*   180 */   104,  105,  106,  107,  108,  109,  110,  111,  112,  222,
+ /*   190 */   223,  224,  225,  226,  227,  228,  229,  230,  231,  232,
+ /*   200 */   233,  234,  235,  236,   16,   17,   44,  199,   20,   21,
+ /*   210 */   199,   23,   24,   25,   26,   27,   28,  246,   78,  246,
+ /*   220 */   209,   33,   34,  199,   62,   37,   38,   39,    1,    2,
+ /*   230 */    90,   69,    5,  262,    7,  262,    9,   75,   76,   77,
+ /*   240 */    84,    1,    2,   81,   82,    5,   82,    7,  199,    9,
+ /*   250 */    86,  199,    2,  245,  265,    5,    5,    7,    7,    9,
+ /*   260 */    33,   34,  199,  145,   37,  147,  199,  243,   63,   64,
+ /*   270 */    65,  247,  209,   33,   34,   70,   71,   72,   73,   74,
+ /*   280 */   116,  119,  265,   33,   34,  265,   25,   26,   27,   28,
+ /*   290 */   220,  221,  199,   88,   33,   34,  247,   69,   37,   38,
+ /*   300 */    39,  248,  206,  141,   69,  143,   63,   64,   65,   82,
+ /*   310 */   243,    5,  150,   70,  247,   72,   73,   74,  199,   63,
+ /*   320 */    64,   65,   82,   80,  272,  199,   70,   71,   72,   73,
+ /*   330 */    74,    5,  199,    7,  199,   98,  240,  100,  101,   33,
+ /*   340 */    34,  199,  105,  142,  117,  118,  109,  199,  111,  112,
+ /*   350 */   199,  124,  151,  152,   37,   33,   34,  117,  118,   37,
+ /*   360 */    38,   39,  243,  270,  124,  272,  247,  117,  118,  243,
+ /*   370 */   199,  199,  144,  247,  146,  124,  148,  149,  243,  144,
+ /*   380 */    83,  146,  247,  148,  149,  243,   63,   64,   65,  247,
+ /*   390 */   204,  243,   83,  204,  243,  247,  204,  211,  247,   83,
+ /*   400 */   211,   97,  249,  211,   97,  272,  207,  208,  202,  203,
+ /*   410 */   132,  133,   83,   97,  243,  243,  263,  120,  247,  247,
+ /*   420 */    83,   83,   97,   83,   83,   82,   97,  123,   83,  120,
+ /*   430 */    83,   83,    1,   83,   97,   97,   61,   97,   97,  122,
+ /*   440 */    83,   15,   97,   82,   97,   97,  139,   97,  265,   83,
+ /*   450 */   124,   78,   79,  145,   97,  147,  265,   82,  115,  145,
+ /*   460 */   265,  147,  137,   97,    5,    5,    7,    7,   37,  145,
+ /*   470 */   238,  147,  145,  265,  147,  114,  145,  265,  147,  265,
+ /*   480 */   265,  265,  265,  265,  265,  265,  265,  265,  265,  265,
+ /*   490 */   248,  238,  248,  238,  199,  238,  238,  238,  238,  199,
+ /*   500 */   199,  199,  264,  273,  199,   61,  273,  261,  246,  199,
+ /*   510 */   246,  199,  199,  250,  199,  246,  269,  199,  199,  199,
+ /*   520 */   199,  269,  254,  269,  259,  124,  260,  199,  258,  199,
+ /*   530 */   257,  199,  199,  199,  199,  199,  269,  130,  199,  134,
+ /*   540 */   136,  199,  129,  117,  200,  199,  138,  135,  199,  256,
+ /*   550 */   199,  199,  199,  199,  199,  199,  128,  199,  199,  199,
+ /*   560 */   127,  199,  199,  199,  199,  126,  199,  199,  199,  199,
+ /*   570 */   199,  199,  125,  199,  140,  199,  199,  199,  199,  199,
+ /*   580 */   199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
+ /*   590 */   199,  199,  199,  199,  199,  199,  199,  199,   89,  200,
+ /*   600 */   200,  113,  200,  200,   96,   95,   51,   92,   94,   55,
+ /*   610 */   200,   93,   91,   84,    5,  200,  200,  153,    5,    5,
+ /*   620 */   153,  200,  200,    5,    5,  100,  206,  210,  210,  206,
+ /*   630 */    99,  142,  120,   82,  115,   83,   97,  121,   82,   97,
+ /*   640 */   200,  200,  217,  219,  215,  218,  216,  201,  213,  212,
+ /*   650 */   214,  201,  201,  200,  202,  201,  237,  200,  200,  221,
+ /*   660 */    83,  255,  253,  252,   82,  251,   83,   97,  207,  237,
+ /*   670 */    82,    1,   83,   82,   82,   97,   83,   82,  131,  131,
+ /*   680 */    82,   97,   82,  115,   82,  116,   78,   71,   87,   86,
+ /*   690 */     5,   87,   86,    9,    5,    5,    5,    5,    5,    5,
+ /*   700 */     5,   15,   85,   78,   82,   24,   83,  117,   82,   59,
+ /*   710 */   147,  147,   16,   16,  147,    5,    5,   97,  147,   83,
+ /*   720 */     5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+ /*   730 */     5,    5,    5,    5,    5,   97,   85,   61,   60,    0,
+ /*   740 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   750 */   276,   21,   21,  276,  276,  276,  276,  276,  276,  276,
+ /*   760 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   770 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   780 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   790 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   800 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   810 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   820 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   830 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   840 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   850 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   860 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   870 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   880 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   890 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   900 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   910 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   920 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   930 */   276,  276,  276,  276,  276,  276,  276,  276,  276,  276,
+ /*   940 */   276,  276,  276,  276,  276,  276,  276,  276,
 };
-#define YY_SHIFT_COUNT    (346)
+#define YY_SHIFT_COUNT    (361)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (717)
+#define YY_SHIFT_MAX      (739)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   154,   74,   74,  188,  188,  168,  230,  240,  240,    2,
- /*    10 */     9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
- /*    20 */     9,    9,    9,    0,   48,  240,  270,  270,  270,    3,
- /*    30 */     3,    9,    9,    9,  141,    9,    9,  167,  168,  178,
- /*    40 */   178,  295,  731,  731,  731,  240,  240,  240,  240,  240,
+ /*     0 */   162,   76,   76,  237,  237,   12,  227,  240,  240,    3,
+ /*    10 */   143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
+ /*    20 */   143,  143,  143,    0,    2,  240,  250,  250,  250,   34,
+ /*    30 */    34,  143,  143,  143,  156,  143,  143,  143,  143,  140,
+ /*    40 */    12,   36,   36,   13,  753,  753,  753,  240,  240,  240,
  /*    50 */   240,  240,  240,  240,  240,  240,  240,  240,  240,  240,
- /*    60 */   240,  240,  240,  240,  240,  270,  270,  270,  345,  345,
- /*    70 */   345,  345,  345,  345,  345,    9,    9,    9,  311,    9,
- /*    80 */     9,    9,    3,    3,    9,    9,    9,    9,  288,  288,
- /*    90 */   314,    3,    9,    9,    9,    9,    9,    9,    9,    9,
- /*   100 */     9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
- /*   110 */     9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
- /*   120 */     9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
- /*   130 */     9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
- /*   140 */     9,    9,    9,    9,  438,  438,  438,  397,  397,  397,
- /*   150 */   438,  397,  438,  402,  405,  395,  410,  415,  424,  426,
- /*   160 */   429,  432,  435,  449,  438,  438,  438,  474,  168,  168,
- /*   170 */   438,  438,  496,  500,  540,  505,  504,  539,  507,  510,
- /*   180 */   474,  295,  438,  515,  515,  438,  515,  438,  515,  438,
- /*   190 */   438,  731,  731,   27,   99,   99,  126,   99,   53,  180,
- /*   200 */   232,  232,  232,  232,  243,  269,  292,  187,  187,  187,
- /*   210 */   187,  233,  258,  107,  198,  172,  172,  391,  399,  343,
- /*   220 */   350,   67,  236,  304,  149,  155,  330,  326,  327,  339,
- /*   230 */   342,  344,  346,  348,  354,  355,  357,   70,  362,  261,
- /*   240 */   359,  284,  303,  307,  446,  447,  315,  316,  361,  322,
- /*   250 */   389,  593,  452,  596,  598,  456,  600,  601,  517,  516,
- /*   260 */   476,  499,  506,  536,  501,  537,  541,  528,  529,  560,
- /*   270 */   562,  567,  559,  574,  575,  577,  654,  578,  579,  581,
- /*   280 */   568,  538,  571,  542,  583,  506,  585,  557,  587,  561,
- /*   290 */   594,  660,  667,  668,  669,  670,  671,  672,  673,  597,
- /*   300 */   664,  605,  602,  603,  573,  606,  659,  629,  674,  546,
- /*   310 */   547,  604,  604,  604,  604,  675,  550,  551,  604,  604,
- /*   320 */   604,  689,  691,  616,  604,  693,  694,  695,  696,  697,
- /*   330 */   698,  699,  700,  701,  702,  703,  704,  705,  706,  707,
- /*   340 */   622,  631,  708,  709,  655,  657,  717,
+ /*    60 */   240,  240,  240,  240,  240,  240,  240,  250,  250,  250,
+ /*    70 */   306,  306,  306,  306,  306,  306,  306,  143,  143,  143,
+ /*    80 */   317,  143,  143,  143,   34,   34,  143,  143,  143,  143,
+ /*    90 */   278,  278,  304,   34,  143,  143,  143,  143,  143,  143,
+ /*   100 */   143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
+ /*   110 */   143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
+ /*   120 */   143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
+ /*   130 */   143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
+ /*   140 */   143,  143,  143,  143,  143,  143,  143,  143,  143,  143,
+ /*   150 */   143,  444,  444,  444,  401,  401,  401,  444,  401,  444,
+ /*   160 */   404,  408,  407,  412,  405,  413,  428,  433,  439,  447,
+ /*   170 */   434,  444,  444,  444,  509,  509,  488,   12,   12,  444,
+ /*   180 */   444,  508,  510,  555,  515,  514,  554,  518,  521,  488,
+ /*   190 */    13,  444,  529,  529,  444,  529,  444,  529,  444,  444,
+ /*   200 */   753,  753,   54,   81,   81,  108,   81,  134,  188,  205,
+ /*   210 */   261,  261,  261,  261,  243,  256,  322,  322,  322,  322,
+ /*   220 */   228,  235,  201,  164,    7,    7,  251,  326,   44,  323,
+ /*   230 */   316,  297,  309,  329,  337,  338,  307,  325,  340,  341,
+ /*   240 */   345,  347,  348,  343,  350,  357,  431,  375,  426,  366,
+ /*   250 */   118,  308,  314,  459,  460,  324,  327,  361,  331,  373,
+ /*   260 */   609,  464,  613,  614,  467,  618,  619,  525,  531,  489,
+ /*   270 */   512,  519,  551,  516,  552,  556,  539,  542,  577,  582,
+ /*   280 */   583,  570,  588,  589,  591,  670,  592,  593,  595,  578,
+ /*   290 */   547,  584,  548,  598,  519,  600,  568,  602,  569,  608,
+ /*   300 */   601,  603,  616,  685,  604,  606,  684,  689,  690,  691,
+ /*   310 */   692,  693,  694,  695,  617,  686,  625,  622,  623,  590,
+ /*   320 */   626,  681,  650,  696,  563,  564,  620,  620,  620,  620,
+ /*   330 */   697,  567,  571,  620,  620,  620,  710,  711,  636,  620,
+ /*   340 */   715,  716,  717,  718,  719,  720,  721,  722,  723,  724,
+ /*   350 */   725,  726,  727,  728,  729,  638,  651,  730,  731,  676,
+ /*   360 */   678,  739,
 };
-#define YY_REDUCE_COUNT (192)
-#define YY_REDUCE_MIN   (-259)
-#define YY_REDUCE_MAX   (451)
+#define YY_REDUCE_COUNT (201)
+#define YY_REDUCE_MIN   (-265)
+#define YY_REDUCE_MAX   (461)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -184,  -34,  -34,  101,  101,  133, -141, -138, -125, -106,
- /*    10 */  -152,   18,   58,  -80,   44,   61,  134,  143,  150,  151,
- /*    20 */   152,  153,  166, -192, -189, -247, -223, -207, -206, -211,
- /*    30 */  -210, -136, -131, -110,  -91,  -32,   54,   57,  124,  182,
- /*    40 */   196,   75,  -41,   94,  138, -259, -253,   52,   98,  106,
- /*    50 */   111,  185,  202,  208,  209,  211,  212,  213,  214,  215,
- /*    60 */   216,  217,  218,  219,  220,  189,  238,  239,  250,  251,
- /*    70 */   252,  253,  254,  255,  256,  296,  297,  298,  231,  299,
- /*    80 */   300,  301,  257,  259,  302,  306,  308,  309,  234,  237,
- /*    90 */   262,  265,  313,  317,  318,  319,  320,  321,  323,  325,
- /*   100 */   328,  329,  331,  332,  333,  334,  335,  336,  337,  338,
- /*   110 */   340,  341,  347,  349,  351,  352,  353,  356,  358,  360,
- /*   120 */   363,  364,  365,  366,  367,  368,  369,  370,  371,  372,
- /*   130 */   373,  374,  375,  376,  377,  378,  379,  380,  381,  382,
- /*   140 */   383,  384,  385,  386,  387,  388,  390,  245,  246,  273,
- /*   150 */   392,  274,  393,  266,  285,  271,  290,  305,  394,  396,
- /*   160 */   398,  400,  403,  406,  401,  404,  407,  408,  409,  411,
- /*   170 */   412,  413,  414,  416,  418,  417,  420,  423,  425,  419,
- /*   180 */   422,  421,  427,  436,  440,  430,  441,  439,  443,  445,
- /*   190 */   448,  451,  434,
+ /*     0 */   -27,  -33,  -33, -193, -193,  -76, -203, -199, -175, -184,
+ /*    10 */  -130, -134,   93,   24,   67,  119,  126,  135,  142,  148,
+ /*    20 */   151,  171,  172, -177, -191, -265, -145, -121, -105, -227,
+ /*    30 */   -29,   52,  133,    8, -201, -136,   11,   63,   49,  186,
+ /*    40 */    96,  189,  192,   70,  153,  199,  206, -116,  -11,   17,
+ /*    50 */    20,  183,  191,  195,  208,  212,  214,  215,  216,  217,
+ /*    60 */   218,  219,  220,  221,  222,  223,  224,   53,  242,  244,
+ /*    70 */   232,  253,  255,  257,  258,  259,  260,  295,  300,  301,
+ /*    80 */   238,  302,  305,  310,  262,  264,  312,  313,  315,  318,
+ /*    90 */   230,  233,  263,  269,  319,  320,  321,  328,  330,  332,
+ /*   100 */   333,  334,  335,  336,  339,  342,  346,  349,  351,  352,
+ /*   110 */   353,  354,  355,  356,  358,  359,  360,  362,  363,  364,
+ /*   120 */   365,  367,  368,  369,  370,  371,  372,  374,  376,  377,
+ /*   130 */   378,  379,  380,  381,  382,  383,  384,  385,  386,  387,
+ /*   140 */   388,  389,  390,  391,  392,  393,  394,  395,  396,  397,
+ /*   150 */   398,  344,  399,  400,  247,  252,  254,  402,  267,  403,
+ /*   160 */   246,  266,  265,  270,  273,  293,  406,  268,  409,  411,
+ /*   170 */   414,  410,  415,  416,  417,  418,  419,  420,  423,  421,
+ /*   180 */   422,  424,  427,  425,  435,  430,  436,  429,  437,  432,
+ /*   190 */   438,  440,  446,  450,  441,  451,  453,  454,  457,  458,
+ /*   200 */   461,  452,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   830,  947,  890,  957,  877,  887, 1094, 1094, 1094,  830,
- /*    10 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*    20 */   830,  830,  830, 1005,  849, 1094,  830,  830,  830,  830,
- /*    30 */   830,  830,  830,  830,  887,  830,  830,  893,  887,  893,
- /*    40 */   893,  830, 1000,  931,  949,  830,  830,  830,  830,  830,
- /*    50 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*    60 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*    70 */   830,  830,  830,  830,  830,  830,  830,  830, 1007, 1013,
- /*    80 */  1010,  830,  830,  830, 1015,  830,  830,  830, 1037, 1037,
- /*    90 */   998,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*   100 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*   110 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*   120 */   875,  830,  873,  830,  830,  830,  830,  830,  830,  830,
- /*   130 */   830,  830,  830,  830,  830,  830,  830,  860,  830,  830,
- /*   140 */   830,  830,  830,  830,  851,  851,  851,  830,  830,  830,
- /*   150 */   851,  830,  851, 1044, 1048, 1030, 1042, 1038, 1029, 1025,
- /*   160 */  1023, 1021, 1020, 1052,  851,  851,  851,  891,  887,  887,
- /*   170 */   851,  851,  909,  907,  905,  897,  903,  899,  901,  895,
- /*   180 */   878,  830,  851,  885,  885,  851,  885,  851,  885,  851,
- /*   190 */   851,  931,  949,  830, 1053, 1043,  830, 1093, 1083, 1082,
- /*   200 */  1089, 1081, 1080, 1079,  830,  830,  830, 1075, 1078, 1077,
- /*   210 */  1076,  830,  830,  830,  830, 1085, 1084,  830,  830,  830,
- /*   220 */   830,  830,  830,  830,  830,  830,  830, 1049, 1045,  830,
- /*   230 */   830,  830,  830,  830,  830,  830,  830,  830, 1055,  830,
- /*   240 */   830,  830,  830,  830,  830,  830,  830,  830,  959,  830,
- /*   250 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*   260 */   830,  997,  830,  830,  830,  830,  830, 1009, 1008,  830,
- /*   270 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*   280 */  1039,  830, 1031,  830,  830,  971,  830,  830,  830,  830,
- /*   290 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*   300 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*   310 */   830, 1112, 1107, 1108, 1105,  830,  830,  830, 1104, 1099,
- /*   320 */  1100,  830,  830,  830, 1097,  830,  830,  830,  830,  830,
- /*   330 */   830,  830,  830,  830,  830,  830,  830,  830,  830,  830,
- /*   340 */   915,  830,  858,  856,  830,  847,  830,
+ /*     0 */   856,  979,  918,  989,  905,  915, 1126, 1126, 1126,  856,
+ /*    10 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*    20 */   856,  856,  856, 1037,  876, 1126,  856,  856,  856,  856,
+ /*    30 */   856,  856,  856,  856,  915,  856,  856,  856,  856,  925,
+ /*    40 */   915,  925,  925,  856, 1032,  963,  981,  856,  856,  856,
+ /*    50 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*    60 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*    70 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*    80 */  1039, 1045, 1042,  856,  856,  856, 1047,  856,  856,  856,
+ /*    90 */  1069, 1069, 1030,  856,  856,  856,  856,  856,  856,  856,
+ /*   100 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*   110 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*   120 */   856,  856,  856,  856,  856,  856,  903,  856,  901,  856,
+ /*   130 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*   140 */   856,  856,  856,  856,  887,  856,  856,  856,  856,  856,
+ /*   150 */   856,  878,  878,  878,  856,  856,  856,  878,  856,  878,
+ /*   160 */  1076, 1080, 1062, 1074, 1070, 1061, 1057, 1055, 1053, 1052,
+ /*   170 */  1084,  878,  878,  878,  923,  923,  919,  915,  915,  878,
+ /*   180 */   878,  941,  939,  937,  929,  935,  931,  933,  927,  906,
+ /*   190 */   856,  878,  913,  913,  878,  913,  878,  913,  878,  878,
+ /*   200 */   963,  981,  856, 1085, 1075,  856, 1125, 1115, 1114,  856,
+ /*   210 */  1121, 1113, 1112, 1111,  856,  856, 1107, 1110, 1109, 1108,
+ /*   220 */   856,  856,  856,  856, 1117, 1116,  856,  856,  856,  856,
+ /*   230 */   856,  856,  856,  856,  856,  856, 1081, 1077,  856,  856,
+ /*   240 */   856,  856,  856,  856,  856,  856,  856, 1087,  856,  856,
+ /*   250 */   856,  856,  856,  856,  856,  856,  856,  991,  856,  856,
+ /*   260 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*   270 */  1029,  856,  856,  856,  856,  856, 1041, 1040,  856,  856,
+ /*   280 */   856,  856,  856,  856,  856,  856,  856,  856,  856, 1071,
+ /*   290 */   856, 1063,  856,  856, 1003,  856,  856,  856,  856,  856,
+ /*   300 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*   310 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*   320 */   856,  856,  856,  856,  856,  856, 1144, 1139, 1140, 1137,
+ /*   330 */   856,  856,  856, 1136, 1131, 1132,  856,  856,  856, 1129,
+ /*   340 */   856,  856,  856,  856,  856,  856,  856,  856,  856,  856,
+ /*   350 */   856,  856,  856,  856,  856,  947,  856,  885,  883,  856,
+ /*   360 */   874,  856,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -543,6 +552,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*       SHOW => nothing */
     0,  /*  DATABASES => nothing */
     0,  /*     TOPICS => nothing */
+    0,  /*  FUNCTIONS => nothing */
     0,  /*     MNODES => nothing */
     0,  /*     DNODES => nothing */
     0,  /*   ACCOUNTS => nothing */
@@ -566,6 +576,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*    VGROUPS => nothing */
     0,  /*       DROP => nothing */
     0,  /*      TOPIC => nothing */
+    0,  /*   FUNCTION => nothing */
     0,  /*      DNODE => nothing */
     0,  /*       USER => nothing */
     0,  /*    ACCOUNT => nothing */
@@ -580,6 +591,10 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*         RP => nothing */
     0,  /*         IF => nothing */
     0,  /*     EXISTS => nothing */
+    0,  /*         AS => nothing */
+    0,  /* OUTPUTTYPE => nothing */
+    0,  /*  AGGREGATE => nothing */
+    0,  /*    BUFSIZE => nothing */
     0,  /*        PPS => nothing */
     0,  /*    TSERIES => nothing */
     0,  /*        DBS => nothing */
@@ -607,7 +622,6 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*   UNSIGNED => nothing */
     0,  /*       TAGS => nothing */
     0,  /*      USING => nothing */
-    0,  /*         AS => nothing */
     1,  /*       NULL => ID */
     1,  /*        NOW => ID */
     0,  /*     SELECT => nothing */
@@ -819,229 +833,235 @@ static const char *const yyTokenName[] = {
   /*   44 */ "SHOW",
   /*   45 */ "DATABASES",
   /*   46 */ "TOPICS",
-  /*   47 */ "MNODES",
-  /*   48 */ "DNODES",
-  /*   49 */ "ACCOUNTS",
-  /*   50 */ "USERS",
-  /*   51 */ "MODULES",
-  /*   52 */ "QUERIES",
-  /*   53 */ "CONNECTIONS",
-  /*   54 */ "STREAMS",
-  /*   55 */ "VARIABLES",
-  /*   56 */ "SCORES",
-  /*   57 */ "GRANTS",
-  /*   58 */ "VNODES",
-  /*   59 */ "IPTOKEN",
-  /*   60 */ "DOT",
-  /*   61 */ "CREATE",
-  /*   62 */ "TABLE",
-  /*   63 */ "STABLE",
-  /*   64 */ "DATABASE",
-  /*   65 */ "TABLES",
-  /*   66 */ "STABLES",
-  /*   67 */ "VGROUPS",
-  /*   68 */ "DROP",
-  /*   69 */ "TOPIC",
-  /*   70 */ "DNODE",
-  /*   71 */ "USER",
-  /*   72 */ "ACCOUNT",
-  /*   73 */ "USE",
-  /*   74 */ "DESCRIBE",
-  /*   75 */ "ALTER",
-  /*   76 */ "PASS",
-  /*   77 */ "PRIVILEGE",
-  /*   78 */ "LOCAL",
-  /*   79 */ "COMPACT",
-  /*   80 */ "LP",
-  /*   81 */ "RP",
-  /*   82 */ "IF",
-  /*   83 */ "EXISTS",
-  /*   84 */ "PPS",
-  /*   85 */ "TSERIES",
-  /*   86 */ "DBS",
-  /*   87 */ "STORAGE",
-  /*   88 */ "QTIME",
-  /*   89 */ "CONNS",
-  /*   90 */ "STATE",
-  /*   91 */ "COMMA",
-  /*   92 */ "KEEP",
-  /*   93 */ "CACHE",
-  /*   94 */ "REPLICA",
-  /*   95 */ "QUORUM",
-  /*   96 */ "DAYS",
-  /*   97 */ "MINROWS",
-  /*   98 */ "MAXROWS",
-  /*   99 */ "BLOCKS",
-  /*  100 */ "CTIME",
-  /*  101 */ "WAL",
-  /*  102 */ "FSYNC",
-  /*  103 */ "COMP",
-  /*  104 */ "PRECISION",
-  /*  105 */ "UPDATE",
-  /*  106 */ "CACHELAST",
-  /*  107 */ "PARTITIONS",
-  /*  108 */ "UNSIGNED",
-  /*  109 */ "TAGS",
-  /*  110 */ "USING",
-  /*  111 */ "AS",
-  /*  112 */ "NULL",
-  /*  113 */ "NOW",
-  /*  114 */ "SELECT",
-  /*  115 */ "UNION",
-  /*  116 */ "ALL",
-  /*  117 */ "DISTINCT",
-  /*  118 */ "FROM",
-  /*  119 */ "VARIABLE",
-  /*  120 */ "INTERVAL",
-  /*  121 */ "SESSION",
-  /*  122 */ "STATE_WINDOW",
-  /*  123 */ "FILL",
-  /*  124 */ "SLIDING",
-  /*  125 */ "ORDER",
-  /*  126 */ "BY",
-  /*  127 */ "ASC",
-  /*  128 */ "DESC",
-  /*  129 */ "GROUP",
-  /*  130 */ "HAVING",
-  /*  131 */ "LIMIT",
-  /*  132 */ "OFFSET",
-  /*  133 */ "SLIMIT",
-  /*  134 */ "SOFFSET",
-  /*  135 */ "WHERE",
-  /*  136 */ "RESET",
-  /*  137 */ "QUERY",
-  /*  138 */ "SYNCDB",
-  /*  139 */ "ADD",
-  /*  140 */ "COLUMN",
-  /*  141 */ "MODIFY",
-  /*  142 */ "TAG",
-  /*  143 */ "CHANGE",
-  /*  144 */ "SET",
-  /*  145 */ "KILL",
-  /*  146 */ "CONNECTION",
-  /*  147 */ "STREAM",
-  /*  148 */ "COLON",
-  /*  149 */ "ABORT",
-  /*  150 */ "AFTER",
-  /*  151 */ "ATTACH",
-  /*  152 */ "BEFORE",
-  /*  153 */ "BEGIN",
-  /*  154 */ "CASCADE",
-  /*  155 */ "CLUSTER",
-  /*  156 */ "CONFLICT",
-  /*  157 */ "COPY",
-  /*  158 */ "DEFERRED",
-  /*  159 */ "DELIMITERS",
-  /*  160 */ "DETACH",
-  /*  161 */ "EACH",
-  /*  162 */ "END",
-  /*  163 */ "EXPLAIN",
-  /*  164 */ "FAIL",
-  /*  165 */ "FOR",
-  /*  166 */ "IGNORE",
-  /*  167 */ "IMMEDIATE",
-  /*  168 */ "INITIALLY",
-  /*  169 */ "INSTEAD",
-  /*  170 */ "MATCH",
-  /*  171 */ "KEY",
-  /*  172 */ "OF",
-  /*  173 */ "RAISE",
-  /*  174 */ "REPLACE",
-  /*  175 */ "RESTRICT",
-  /*  176 */ "ROW",
-  /*  177 */ "STATEMENT",
-  /*  178 */ "TRIGGER",
-  /*  179 */ "VIEW",
-  /*  180 */ "SEMI",
-  /*  181 */ "NONE",
-  /*  182 */ "PREV",
-  /*  183 */ "LINEAR",
-  /*  184 */ "IMPORT",
-  /*  185 */ "TBNAME",
-  /*  186 */ "JOIN",
-  /*  187 */ "INSERT",
-  /*  188 */ "INTO",
-  /*  189 */ "VALUES",
-  /*  190 */ "error",
-  /*  191 */ "program",
-  /*  192 */ "cmd",
-  /*  193 */ "dbPrefix",
-  /*  194 */ "ids",
-  /*  195 */ "cpxName",
-  /*  196 */ "ifexists",
-  /*  197 */ "alter_db_optr",
-  /*  198 */ "alter_topic_optr",
-  /*  199 */ "acct_optr",
-  /*  200 */ "exprlist",
-  /*  201 */ "ifnotexists",
-  /*  202 */ "db_optr",
-  /*  203 */ "topic_optr",
-  /*  204 */ "pps",
-  /*  205 */ "tseries",
-  /*  206 */ "dbs",
-  /*  207 */ "streams",
-  /*  208 */ "storage",
-  /*  209 */ "qtime",
-  /*  210 */ "users",
-  /*  211 */ "conns",
-  /*  212 */ "state",
-  /*  213 */ "intitemlist",
-  /*  214 */ "intitem",
-  /*  215 */ "keep",
-  /*  216 */ "cache",
-  /*  217 */ "replica",
-  /*  218 */ "quorum",
-  /*  219 */ "days",
-  /*  220 */ "minrows",
-  /*  221 */ "maxrows",
-  /*  222 */ "blocks",
-  /*  223 */ "ctime",
-  /*  224 */ "wal",
-  /*  225 */ "fsync",
-  /*  226 */ "comp",
-  /*  227 */ "prec",
-  /*  228 */ "update",
-  /*  229 */ "cachelast",
-  /*  230 */ "partitions",
-  /*  231 */ "typename",
-  /*  232 */ "signed",
-  /*  233 */ "create_table_args",
-  /*  234 */ "create_stable_args",
-  /*  235 */ "create_table_list",
-  /*  236 */ "create_from_stable",
-  /*  237 */ "columnlist",
-  /*  238 */ "tagitemlist",
-  /*  239 */ "tagNamelist",
-  /*  240 */ "select",
-  /*  241 */ "column",
-  /*  242 */ "tagitem",
-  /*  243 */ "selcollist",
-  /*  244 */ "from",
-  /*  245 */ "where_opt",
-  /*  246 */ "interval_opt",
-  /*  247 */ "session_option",
-  /*  248 */ "windowstate_option",
-  /*  249 */ "fill_opt",
-  /*  250 */ "sliding_opt",
-  /*  251 */ "groupby_opt",
-  /*  252 */ "having_opt",
-  /*  253 */ "orderby_opt",
-  /*  254 */ "slimit_opt",
-  /*  255 */ "limit_opt",
-  /*  256 */ "union",
-  /*  257 */ "sclp",
-  /*  258 */ "distinct",
-  /*  259 */ "expr",
-  /*  260 */ "as",
-  /*  261 */ "tablelist",
-  /*  262 */ "sub",
-  /*  263 */ "tmvar",
-  /*  264 */ "sortlist",
-  /*  265 */ "sortitem",
-  /*  266 */ "item",
-  /*  267 */ "sortorder",
-  /*  268 */ "grouplist",
-  /*  269 */ "expritem",
+  /*   47 */ "FUNCTIONS",
+  /*   48 */ "MNODES",
+  /*   49 */ "DNODES",
+  /*   50 */ "ACCOUNTS",
+  /*   51 */ "USERS",
+  /*   52 */ "MODULES",
+  /*   53 */ "QUERIES",
+  /*   54 */ "CONNECTIONS",
+  /*   55 */ "STREAMS",
+  /*   56 */ "VARIABLES",
+  /*   57 */ "SCORES",
+  /*   58 */ "GRANTS",
+  /*   59 */ "VNODES",
+  /*   60 */ "IPTOKEN",
+  /*   61 */ "DOT",
+  /*   62 */ "CREATE",
+  /*   63 */ "TABLE",
+  /*   64 */ "STABLE",
+  /*   65 */ "DATABASE",
+  /*   66 */ "TABLES",
+  /*   67 */ "STABLES",
+  /*   68 */ "VGROUPS",
+  /*   69 */ "DROP",
+  /*   70 */ "TOPIC",
+  /*   71 */ "FUNCTION",
+  /*   72 */ "DNODE",
+  /*   73 */ "USER",
+  /*   74 */ "ACCOUNT",
+  /*   75 */ "USE",
+  /*   76 */ "DESCRIBE",
+  /*   77 */ "ALTER",
+  /*   78 */ "PASS",
+  /*   79 */ "PRIVILEGE",
+  /*   80 */ "LOCAL",
+  /*   81 */ "COMPACT",
+  /*   82 */ "LP",
+  /*   83 */ "RP",
+  /*   84 */ "IF",
+  /*   85 */ "EXISTS",
+  /*   86 */ "AS",
+  /*   87 */ "OUTPUTTYPE",
+  /*   88 */ "AGGREGATE",
+  /*   89 */ "BUFSIZE",
+  /*   90 */ "PPS",
+  /*   91 */ "TSERIES",
+  /*   92 */ "DBS",
+  /*   93 */ "STORAGE",
+  /*   94 */ "QTIME",
+  /*   95 */ "CONNS",
+  /*   96 */ "STATE",
+  /*   97 */ "COMMA",
+  /*   98 */ "KEEP",
+  /*   99 */ "CACHE",
+  /*  100 */ "REPLICA",
+  /*  101 */ "QUORUM",
+  /*  102 */ "DAYS",
+  /*  103 */ "MINROWS",
+  /*  104 */ "MAXROWS",
+  /*  105 */ "BLOCKS",
+  /*  106 */ "CTIME",
+  /*  107 */ "WAL",
+  /*  108 */ "FSYNC",
+  /*  109 */ "COMP",
+  /*  110 */ "PRECISION",
+  /*  111 */ "UPDATE",
+  /*  112 */ "CACHELAST",
+  /*  113 */ "PARTITIONS",
+  /*  114 */ "UNSIGNED",
+  /*  115 */ "TAGS",
+  /*  116 */ "USING",
+  /*  117 */ "NULL",
+  /*  118 */ "NOW",
+  /*  119 */ "SELECT",
+  /*  120 */ "UNION",
+  /*  121 */ "ALL",
+  /*  122 */ "DISTINCT",
+  /*  123 */ "FROM",
+  /*  124 */ "VARIABLE",
+  /*  125 */ "INTERVAL",
+  /*  126 */ "SESSION",
+  /*  127 */ "STATE_WINDOW",
+  /*  128 */ "FILL",
+  /*  129 */ "SLIDING",
+  /*  130 */ "ORDER",
+  /*  131 */ "BY",
+  /*  132 */ "ASC",
+  /*  133 */ "DESC",
+  /*  134 */ "GROUP",
+  /*  135 */ "HAVING",
+  /*  136 */ "LIMIT",
+  /*  137 */ "OFFSET",
+  /*  138 */ "SLIMIT",
+  /*  139 */ "SOFFSET",
+  /*  140 */ "WHERE",
+  /*  141 */ "RESET",
+  /*  142 */ "QUERY",
+  /*  143 */ "SYNCDB",
+  /*  144 */ "ADD",
+  /*  145 */ "COLUMN",
+  /*  146 */ "MODIFY",
+  /*  147 */ "TAG",
+  /*  148 */ "CHANGE",
+  /*  149 */ "SET",
+  /*  150 */ "KILL",
+  /*  151 */ "CONNECTION",
+  /*  152 */ "STREAM",
+  /*  153 */ "COLON",
+  /*  154 */ "ABORT",
+  /*  155 */ "AFTER",
+  /*  156 */ "ATTACH",
+  /*  157 */ "BEFORE",
+  /*  158 */ "BEGIN",
+  /*  159 */ "CASCADE",
+  /*  160 */ "CLUSTER",
+  /*  161 */ "CONFLICT",
+  /*  162 */ "COPY",
+  /*  163 */ "DEFERRED",
+  /*  164 */ "DELIMITERS",
+  /*  165 */ "DETACH",
+  /*  166 */ "EACH",
+  /*  167 */ "END",
+  /*  168 */ "EXPLAIN",
+  /*  169 */ "FAIL",
+  /*  170 */ "FOR",
+  /*  171 */ "IGNORE",
+  /*  172 */ "IMMEDIATE",
+  /*  173 */ "INITIALLY",
+  /*  174 */ "INSTEAD",
+  /*  175 */ "MATCH",
+  /*  176 */ "KEY",
+  /*  177 */ "OF",
+  /*  178 */ "RAISE",
+  /*  179 */ "REPLACE",
+  /*  180 */ "RESTRICT",
+  /*  181 */ "ROW",
+  /*  182 */ "STATEMENT",
+  /*  183 */ "TRIGGER",
+  /*  184 */ "VIEW",
+  /*  185 */ "SEMI",
+  /*  186 */ "NONE",
+  /*  187 */ "PREV",
+  /*  188 */ "LINEAR",
+  /*  189 */ "IMPORT",
+  /*  190 */ "TBNAME",
+  /*  191 */ "JOIN",
+  /*  192 */ "INSERT",
+  /*  193 */ "INTO",
+  /*  194 */ "VALUES",
+  /*  195 */ "error",
+  /*  196 */ "program",
+  /*  197 */ "cmd",
+  /*  198 */ "dbPrefix",
+  /*  199 */ "ids",
+  /*  200 */ "cpxName",
+  /*  201 */ "ifexists",
+  /*  202 */ "alter_db_optr",
+  /*  203 */ "alter_topic_optr",
+  /*  204 */ "acct_optr",
+  /*  205 */ "exprlist",
+  /*  206 */ "ifnotexists",
+  /*  207 */ "db_optr",
+  /*  208 */ "topic_optr",
+  /*  209 */ "typename",
+  /*  210 */ "bufsize",
+  /*  211 */ "pps",
+  /*  212 */ "tseries",
+  /*  213 */ "dbs",
+  /*  214 */ "streams",
+  /*  215 */ "storage",
+  /*  216 */ "qtime",
+  /*  217 */ "users",
+  /*  218 */ "conns",
+  /*  219 */ "state",
+  /*  220 */ "intitemlist",
+  /*  221 */ "intitem",
+  /*  222 */ "keep",
+  /*  223 */ "cache",
+  /*  224 */ "replica",
+  /*  225 */ "quorum",
+  /*  226 */ "days",
+  /*  227 */ "minrows",
+  /*  228 */ "maxrows",
+  /*  229 */ "blocks",
+  /*  230 */ "ctime",
+  /*  231 */ "wal",
+  /*  232 */ "fsync",
+  /*  233 */ "comp",
+  /*  234 */ "prec",
+  /*  235 */ "update",
+  /*  236 */ "cachelast",
+  /*  237 */ "partitions",
+  /*  238 */ "signed",
+  /*  239 */ "create_table_args",
+  /*  240 */ "create_stable_args",
+  /*  241 */ "create_table_list",
+  /*  242 */ "create_from_stable",
+  /*  243 */ "columnlist",
+  /*  244 */ "tagitemlist",
+  /*  245 */ "tagNamelist",
+  /*  246 */ "select",
+  /*  247 */ "column",
+  /*  248 */ "tagitem",
+  /*  249 */ "selcollist",
+  /*  250 */ "from",
+  /*  251 */ "where_opt",
+  /*  252 */ "interval_opt",
+  /*  253 */ "session_option",
+  /*  254 */ "windowstate_option",
+  /*  255 */ "fill_opt",
+  /*  256 */ "sliding_opt",
+  /*  257 */ "groupby_opt",
+  /*  258 */ "having_opt",
+  /*  259 */ "orderby_opt",
+  /*  260 */ "slimit_opt",
+  /*  261 */ "limit_opt",
+  /*  262 */ "union",
+  /*  263 */ "sclp",
+  /*  264 */ "distinct",
+  /*  265 */ "expr",
+  /*  266 */ "as",
+  /*  267 */ "tablelist",
+  /*  268 */ "sub",
+  /*  269 */ "tmvar",
+  /*  270 */ "sortlist",
+  /*  271 */ "sortitem",
+  /*  272 */ "item",
+  /*  273 */ "sortorder",
+  /*  274 */ "grouplist",
+  /*  275 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1052,286 +1072,292 @@ static const char *const yyRuleName[] = {
  /*   0 */ "program ::= cmd",
  /*   1 */ "cmd ::= SHOW DATABASES",
  /*   2 */ "cmd ::= SHOW TOPICS",
- /*   3 */ "cmd ::= SHOW MNODES",
- /*   4 */ "cmd ::= SHOW DNODES",
- /*   5 */ "cmd ::= SHOW ACCOUNTS",
- /*   6 */ "cmd ::= SHOW USERS",
- /*   7 */ "cmd ::= SHOW MODULES",
- /*   8 */ "cmd ::= SHOW QUERIES",
- /*   9 */ "cmd ::= SHOW CONNECTIONS",
- /*  10 */ "cmd ::= SHOW STREAMS",
- /*  11 */ "cmd ::= SHOW VARIABLES",
- /*  12 */ "cmd ::= SHOW SCORES",
- /*  13 */ "cmd ::= SHOW GRANTS",
- /*  14 */ "cmd ::= SHOW VNODES",
- /*  15 */ "cmd ::= SHOW VNODES IPTOKEN",
- /*  16 */ "dbPrefix ::=",
- /*  17 */ "dbPrefix ::= ids DOT",
- /*  18 */ "cpxName ::=",
- /*  19 */ "cpxName ::= DOT ids",
- /*  20 */ "cmd ::= SHOW CREATE TABLE ids cpxName",
- /*  21 */ "cmd ::= SHOW CREATE STABLE ids cpxName",
- /*  22 */ "cmd ::= SHOW CREATE DATABASE ids",
- /*  23 */ "cmd ::= SHOW dbPrefix TABLES",
- /*  24 */ "cmd ::= SHOW dbPrefix TABLES LIKE ids",
- /*  25 */ "cmd ::= SHOW dbPrefix STABLES",
- /*  26 */ "cmd ::= SHOW dbPrefix STABLES LIKE ids",
- /*  27 */ "cmd ::= SHOW dbPrefix VGROUPS",
- /*  28 */ "cmd ::= SHOW dbPrefix VGROUPS ids",
- /*  29 */ "cmd ::= DROP TABLE ifexists ids cpxName",
- /*  30 */ "cmd ::= DROP STABLE ifexists ids cpxName",
- /*  31 */ "cmd ::= DROP DATABASE ifexists ids",
- /*  32 */ "cmd ::= DROP TOPIC ifexists ids",
- /*  33 */ "cmd ::= DROP DNODE ids",
- /*  34 */ "cmd ::= DROP USER ids",
- /*  35 */ "cmd ::= DROP ACCOUNT ids",
- /*  36 */ "cmd ::= USE ids",
- /*  37 */ "cmd ::= DESCRIBE ids cpxName",
- /*  38 */ "cmd ::= ALTER USER ids PASS ids",
- /*  39 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
- /*  40 */ "cmd ::= ALTER DNODE ids ids",
- /*  41 */ "cmd ::= ALTER DNODE ids ids ids",
- /*  42 */ "cmd ::= ALTER LOCAL ids",
- /*  43 */ "cmd ::= ALTER LOCAL ids ids",
- /*  44 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
- /*  45 */ "cmd ::= ALTER TOPIC ids alter_topic_optr",
- /*  46 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
- /*  47 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
- /*  48 */ "cmd ::= COMPACT VNODES IN LP exprlist RP",
- /*  49 */ "ids ::= ID",
- /*  50 */ "ids ::= STRING",
- /*  51 */ "ifexists ::= IF EXISTS",
- /*  52 */ "ifexists ::=",
- /*  53 */ "ifnotexists ::= IF NOT EXISTS",
- /*  54 */ "ifnotexists ::=",
- /*  55 */ "cmd ::= CREATE DNODE ids",
- /*  56 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
- /*  57 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
- /*  58 */ "cmd ::= CREATE TOPIC ifnotexists ids topic_optr",
- /*  59 */ "cmd ::= CREATE USER ids PASS ids",
- /*  60 */ "pps ::=",
- /*  61 */ "pps ::= PPS INTEGER",
- /*  62 */ "tseries ::=",
- /*  63 */ "tseries ::= TSERIES INTEGER",
- /*  64 */ "dbs ::=",
- /*  65 */ "dbs ::= DBS INTEGER",
- /*  66 */ "streams ::=",
- /*  67 */ "streams ::= STREAMS INTEGER",
- /*  68 */ "storage ::=",
- /*  69 */ "storage ::= STORAGE INTEGER",
- /*  70 */ "qtime ::=",
- /*  71 */ "qtime ::= QTIME INTEGER",
- /*  72 */ "users ::=",
- /*  73 */ "users ::= USERS INTEGER",
- /*  74 */ "conns ::=",
- /*  75 */ "conns ::= CONNS INTEGER",
- /*  76 */ "state ::=",
- /*  77 */ "state ::= STATE ids",
- /*  78 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
- /*  79 */ "intitemlist ::= intitemlist COMMA intitem",
- /*  80 */ "intitemlist ::= intitem",
- /*  81 */ "intitem ::= INTEGER",
- /*  82 */ "keep ::= KEEP intitemlist",
- /*  83 */ "cache ::= CACHE INTEGER",
- /*  84 */ "replica ::= REPLICA INTEGER",
- /*  85 */ "quorum ::= QUORUM INTEGER",
- /*  86 */ "days ::= DAYS INTEGER",
- /*  87 */ "minrows ::= MINROWS INTEGER",
- /*  88 */ "maxrows ::= MAXROWS INTEGER",
- /*  89 */ "blocks ::= BLOCKS INTEGER",
- /*  90 */ "ctime ::= CTIME INTEGER",
- /*  91 */ "wal ::= WAL INTEGER",
- /*  92 */ "fsync ::= FSYNC INTEGER",
- /*  93 */ "comp ::= COMP INTEGER",
- /*  94 */ "prec ::= PRECISION STRING",
- /*  95 */ "update ::= UPDATE INTEGER",
- /*  96 */ "cachelast ::= CACHELAST INTEGER",
- /*  97 */ "partitions ::= PARTITIONS INTEGER",
- /*  98 */ "db_optr ::=",
- /*  99 */ "db_optr ::= db_optr cache",
- /* 100 */ "db_optr ::= db_optr replica",
- /* 101 */ "db_optr ::= db_optr quorum",
- /* 102 */ "db_optr ::= db_optr days",
- /* 103 */ "db_optr ::= db_optr minrows",
- /* 104 */ "db_optr ::= db_optr maxrows",
- /* 105 */ "db_optr ::= db_optr blocks",
- /* 106 */ "db_optr ::= db_optr ctime",
- /* 107 */ "db_optr ::= db_optr wal",
- /* 108 */ "db_optr ::= db_optr fsync",
- /* 109 */ "db_optr ::= db_optr comp",
- /* 110 */ "db_optr ::= db_optr prec",
- /* 111 */ "db_optr ::= db_optr keep",
- /* 112 */ "db_optr ::= db_optr update",
- /* 113 */ "db_optr ::= db_optr cachelast",
- /* 114 */ "topic_optr ::= db_optr",
- /* 115 */ "topic_optr ::= topic_optr partitions",
- /* 116 */ "alter_db_optr ::=",
- /* 117 */ "alter_db_optr ::= alter_db_optr replica",
- /* 118 */ "alter_db_optr ::= alter_db_optr quorum",
- /* 119 */ "alter_db_optr ::= alter_db_optr keep",
- /* 120 */ "alter_db_optr ::= alter_db_optr blocks",
- /* 121 */ "alter_db_optr ::= alter_db_optr comp",
- /* 122 */ "alter_db_optr ::= alter_db_optr update",
- /* 123 */ "alter_db_optr ::= alter_db_optr cachelast",
- /* 124 */ "alter_topic_optr ::= alter_db_optr",
- /* 125 */ "alter_topic_optr ::= alter_topic_optr partitions",
- /* 126 */ "typename ::= ids",
- /* 127 */ "typename ::= ids LP signed RP",
- /* 128 */ "typename ::= ids UNSIGNED",
- /* 129 */ "signed ::= INTEGER",
- /* 130 */ "signed ::= PLUS INTEGER",
- /* 131 */ "signed ::= MINUS INTEGER",
- /* 132 */ "cmd ::= CREATE TABLE create_table_args",
- /* 133 */ "cmd ::= CREATE TABLE create_stable_args",
- /* 134 */ "cmd ::= CREATE STABLE create_stable_args",
- /* 135 */ "cmd ::= CREATE TABLE create_table_list",
- /* 136 */ "create_table_list ::= create_from_stable",
- /* 137 */ "create_table_list ::= create_table_list create_from_stable",
- /* 138 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
- /* 139 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
- /* 140 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
- /* 141 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP",
- /* 142 */ "tagNamelist ::= tagNamelist COMMA ids",
- /* 143 */ "tagNamelist ::= ids",
- /* 144 */ "create_table_args ::= ifnotexists ids cpxName AS select",
- /* 145 */ "columnlist ::= columnlist COMMA column",
- /* 146 */ "columnlist ::= column",
- /* 147 */ "column ::= ids typename",
- /* 148 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 149 */ "tagitemlist ::= tagitem",
- /* 150 */ "tagitem ::= INTEGER",
- /* 151 */ "tagitem ::= FLOAT",
- /* 152 */ "tagitem ::= STRING",
- /* 153 */ "tagitem ::= BOOL",
- /* 154 */ "tagitem ::= NULL",
- /* 155 */ "tagitem ::= NOW",
- /* 156 */ "tagitem ::= MINUS INTEGER",
- /* 157 */ "tagitem ::= MINUS FLOAT",
- /* 158 */ "tagitem ::= PLUS INTEGER",
- /* 159 */ "tagitem ::= PLUS FLOAT",
- /* 160 */ "select ::= SELECT selcollist from where_opt interval_opt session_option windowstate_option fill_opt sliding_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt",
- /* 161 */ "select ::= LP select RP",
- /* 162 */ "union ::= select",
- /* 163 */ "union ::= union UNION ALL select",
- /* 164 */ "cmd ::= union",
- /* 165 */ "select ::= SELECT selcollist",
- /* 166 */ "sclp ::= selcollist COMMA",
- /* 167 */ "sclp ::=",
- /* 168 */ "selcollist ::= sclp distinct expr as",
- /* 169 */ "selcollist ::= sclp STAR",
- /* 170 */ "as ::= AS ids",
- /* 171 */ "as ::= ids",
- /* 172 */ "as ::=",
- /* 173 */ "distinct ::= DISTINCT",
- /* 174 */ "distinct ::=",
- /* 175 */ "from ::= FROM tablelist",
- /* 176 */ "from ::= FROM sub",
- /* 177 */ "sub ::= LP union RP",
- /* 178 */ "sub ::= LP union RP ids",
- /* 179 */ "sub ::= sub COMMA LP union RP ids",
- /* 180 */ "tablelist ::= ids cpxName",
- /* 181 */ "tablelist ::= ids cpxName ids",
- /* 182 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 183 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 184 */ "tmvar ::= VARIABLE",
- /* 185 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 186 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
- /* 187 */ "interval_opt ::=",
- /* 188 */ "session_option ::=",
- /* 189 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
- /* 190 */ "windowstate_option ::=",
- /* 191 */ "windowstate_option ::= STATE_WINDOW LP ids RP",
- /* 192 */ "fill_opt ::=",
- /* 193 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 194 */ "fill_opt ::= FILL LP ID RP",
- /* 195 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 196 */ "sliding_opt ::=",
- /* 197 */ "orderby_opt ::=",
- /* 198 */ "orderby_opt ::= ORDER BY sortlist",
- /* 199 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 200 */ "sortlist ::= item sortorder",
- /* 201 */ "item ::= ids cpxName",
- /* 202 */ "sortorder ::= ASC",
- /* 203 */ "sortorder ::= DESC",
- /* 204 */ "sortorder ::=",
- /* 205 */ "groupby_opt ::=",
- /* 206 */ "groupby_opt ::= GROUP BY grouplist",
- /* 207 */ "grouplist ::= grouplist COMMA item",
- /* 208 */ "grouplist ::= item",
- /* 209 */ "having_opt ::=",
- /* 210 */ "having_opt ::= HAVING expr",
- /* 211 */ "limit_opt ::=",
- /* 212 */ "limit_opt ::= LIMIT signed",
- /* 213 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 214 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 215 */ "slimit_opt ::=",
- /* 216 */ "slimit_opt ::= SLIMIT signed",
- /* 217 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 218 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 219 */ "where_opt ::=",
- /* 220 */ "where_opt ::= WHERE expr",
- /* 221 */ "expr ::= LP expr RP",
- /* 222 */ "expr ::= ID",
- /* 223 */ "expr ::= ID DOT ID",
- /* 224 */ "expr ::= ID DOT STAR",
- /* 225 */ "expr ::= INTEGER",
- /* 226 */ "expr ::= MINUS INTEGER",
- /* 227 */ "expr ::= PLUS INTEGER",
- /* 228 */ "expr ::= FLOAT",
- /* 229 */ "expr ::= MINUS FLOAT",
- /* 230 */ "expr ::= PLUS FLOAT",
- /* 231 */ "expr ::= STRING",
- /* 232 */ "expr ::= NOW",
- /* 233 */ "expr ::= VARIABLE",
- /* 234 */ "expr ::= PLUS VARIABLE",
- /* 235 */ "expr ::= MINUS VARIABLE",
- /* 236 */ "expr ::= BOOL",
- /* 237 */ "expr ::= NULL",
- /* 238 */ "expr ::= ID LP exprlist RP",
- /* 239 */ "expr ::= ID LP STAR RP",
- /* 240 */ "expr ::= expr IS NULL",
- /* 241 */ "expr ::= expr IS NOT NULL",
- /* 242 */ "expr ::= expr LT expr",
- /* 243 */ "expr ::= expr GT expr",
- /* 244 */ "expr ::= expr LE expr",
- /* 245 */ "expr ::= expr GE expr",
- /* 246 */ "expr ::= expr NE expr",
- /* 247 */ "expr ::= expr EQ expr",
- /* 248 */ "expr ::= expr BETWEEN expr AND expr",
- /* 249 */ "expr ::= expr AND expr",
- /* 250 */ "expr ::= expr OR expr",
- /* 251 */ "expr ::= expr PLUS expr",
- /* 252 */ "expr ::= expr MINUS expr",
- /* 253 */ "expr ::= expr STAR expr",
- /* 254 */ "expr ::= expr SLASH expr",
- /* 255 */ "expr ::= expr REM expr",
- /* 256 */ "expr ::= expr LIKE expr",
- /* 257 */ "expr ::= expr IN LP exprlist RP",
- /* 258 */ "exprlist ::= exprlist COMMA expritem",
- /* 259 */ "exprlist ::= expritem",
- /* 260 */ "expritem ::= expr",
- /* 261 */ "expritem ::=",
- /* 262 */ "cmd ::= RESET QUERY CACHE",
- /* 263 */ "cmd ::= SYNCDB ids REPLICA",
- /* 264 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 265 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 266 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
- /* 267 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 268 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 269 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 270 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 271 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
- /* 272 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
- /* 273 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
- /* 274 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
- /* 275 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
- /* 276 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
- /* 277 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
- /* 278 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
- /* 279 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
- /* 280 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 281 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 282 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /*   3 */ "cmd ::= SHOW FUNCTIONS",
+ /*   4 */ "cmd ::= SHOW MNODES",
+ /*   5 */ "cmd ::= SHOW DNODES",
+ /*   6 */ "cmd ::= SHOW ACCOUNTS",
+ /*   7 */ "cmd ::= SHOW USERS",
+ /*   8 */ "cmd ::= SHOW MODULES",
+ /*   9 */ "cmd ::= SHOW QUERIES",
+ /*  10 */ "cmd ::= SHOW CONNECTIONS",
+ /*  11 */ "cmd ::= SHOW STREAMS",
+ /*  12 */ "cmd ::= SHOW VARIABLES",
+ /*  13 */ "cmd ::= SHOW SCORES",
+ /*  14 */ "cmd ::= SHOW GRANTS",
+ /*  15 */ "cmd ::= SHOW VNODES",
+ /*  16 */ "cmd ::= SHOW VNODES IPTOKEN",
+ /*  17 */ "dbPrefix ::=",
+ /*  18 */ "dbPrefix ::= ids DOT",
+ /*  19 */ "cpxName ::=",
+ /*  20 */ "cpxName ::= DOT ids",
+ /*  21 */ "cmd ::= SHOW CREATE TABLE ids cpxName",
+ /*  22 */ "cmd ::= SHOW CREATE STABLE ids cpxName",
+ /*  23 */ "cmd ::= SHOW CREATE DATABASE ids",
+ /*  24 */ "cmd ::= SHOW dbPrefix TABLES",
+ /*  25 */ "cmd ::= SHOW dbPrefix TABLES LIKE ids",
+ /*  26 */ "cmd ::= SHOW dbPrefix STABLES",
+ /*  27 */ "cmd ::= SHOW dbPrefix STABLES LIKE ids",
+ /*  28 */ "cmd ::= SHOW dbPrefix VGROUPS",
+ /*  29 */ "cmd ::= SHOW dbPrefix VGROUPS ids",
+ /*  30 */ "cmd ::= DROP TABLE ifexists ids cpxName",
+ /*  31 */ "cmd ::= DROP STABLE ifexists ids cpxName",
+ /*  32 */ "cmd ::= DROP DATABASE ifexists ids",
+ /*  33 */ "cmd ::= DROP TOPIC ifexists ids",
+ /*  34 */ "cmd ::= DROP FUNCTION ids",
+ /*  35 */ "cmd ::= DROP DNODE ids",
+ /*  36 */ "cmd ::= DROP USER ids",
+ /*  37 */ "cmd ::= DROP ACCOUNT ids",
+ /*  38 */ "cmd ::= USE ids",
+ /*  39 */ "cmd ::= DESCRIBE ids cpxName",
+ /*  40 */ "cmd ::= ALTER USER ids PASS ids",
+ /*  41 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
+ /*  42 */ "cmd ::= ALTER DNODE ids ids",
+ /*  43 */ "cmd ::= ALTER DNODE ids ids ids",
+ /*  44 */ "cmd ::= ALTER LOCAL ids",
+ /*  45 */ "cmd ::= ALTER LOCAL ids ids",
+ /*  46 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
+ /*  47 */ "cmd ::= ALTER TOPIC ids alter_topic_optr",
+ /*  48 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
+ /*  49 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
+ /*  50 */ "cmd ::= COMPACT VNODES IN LP exprlist RP",
+ /*  51 */ "ids ::= ID",
+ /*  52 */ "ids ::= STRING",
+ /*  53 */ "ifexists ::= IF EXISTS",
+ /*  54 */ "ifexists ::=",
+ /*  55 */ "ifnotexists ::= IF NOT EXISTS",
+ /*  56 */ "ifnotexists ::=",
+ /*  57 */ "cmd ::= CREATE DNODE ids",
+ /*  58 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
+ /*  59 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
+ /*  60 */ "cmd ::= CREATE TOPIC ifnotexists ids topic_optr",
+ /*  61 */ "cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
+ /*  62 */ "cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
+ /*  63 */ "cmd ::= CREATE USER ids PASS ids",
+ /*  64 */ "bufsize ::=",
+ /*  65 */ "bufsize ::= BUFSIZE INTEGER",
+ /*  66 */ "pps ::=",
+ /*  67 */ "pps ::= PPS INTEGER",
+ /*  68 */ "tseries ::=",
+ /*  69 */ "tseries ::= TSERIES INTEGER",
+ /*  70 */ "dbs ::=",
+ /*  71 */ "dbs ::= DBS INTEGER",
+ /*  72 */ "streams ::=",
+ /*  73 */ "streams ::= STREAMS INTEGER",
+ /*  74 */ "storage ::=",
+ /*  75 */ "storage ::= STORAGE INTEGER",
+ /*  76 */ "qtime ::=",
+ /*  77 */ "qtime ::= QTIME INTEGER",
+ /*  78 */ "users ::=",
+ /*  79 */ "users ::= USERS INTEGER",
+ /*  80 */ "conns ::=",
+ /*  81 */ "conns ::= CONNS INTEGER",
+ /*  82 */ "state ::=",
+ /*  83 */ "state ::= STATE ids",
+ /*  84 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
+ /*  85 */ "intitemlist ::= intitemlist COMMA intitem",
+ /*  86 */ "intitemlist ::= intitem",
+ /*  87 */ "intitem ::= INTEGER",
+ /*  88 */ "keep ::= KEEP intitemlist",
+ /*  89 */ "cache ::= CACHE INTEGER",
+ /*  90 */ "replica ::= REPLICA INTEGER",
+ /*  91 */ "quorum ::= QUORUM INTEGER",
+ /*  92 */ "days ::= DAYS INTEGER",
+ /*  93 */ "minrows ::= MINROWS INTEGER",
+ /*  94 */ "maxrows ::= MAXROWS INTEGER",
+ /*  95 */ "blocks ::= BLOCKS INTEGER",
+ /*  96 */ "ctime ::= CTIME INTEGER",
+ /*  97 */ "wal ::= WAL INTEGER",
+ /*  98 */ "fsync ::= FSYNC INTEGER",
+ /*  99 */ "comp ::= COMP INTEGER",
+ /* 100 */ "prec ::= PRECISION STRING",
+ /* 101 */ "update ::= UPDATE INTEGER",
+ /* 102 */ "cachelast ::= CACHELAST INTEGER",
+ /* 103 */ "partitions ::= PARTITIONS INTEGER",
+ /* 104 */ "db_optr ::=",
+ /* 105 */ "db_optr ::= db_optr cache",
+ /* 106 */ "db_optr ::= db_optr replica",
+ /* 107 */ "db_optr ::= db_optr quorum",
+ /* 108 */ "db_optr ::= db_optr days",
+ /* 109 */ "db_optr ::= db_optr minrows",
+ /* 110 */ "db_optr ::= db_optr maxrows",
+ /* 111 */ "db_optr ::= db_optr blocks",
+ /* 112 */ "db_optr ::= db_optr ctime",
+ /* 113 */ "db_optr ::= db_optr wal",
+ /* 114 */ "db_optr ::= db_optr fsync",
+ /* 115 */ "db_optr ::= db_optr comp",
+ /* 116 */ "db_optr ::= db_optr prec",
+ /* 117 */ "db_optr ::= db_optr keep",
+ /* 118 */ "db_optr ::= db_optr update",
+ /* 119 */ "db_optr ::= db_optr cachelast",
+ /* 120 */ "topic_optr ::= db_optr",
+ /* 121 */ "topic_optr ::= topic_optr partitions",
+ /* 122 */ "alter_db_optr ::=",
+ /* 123 */ "alter_db_optr ::= alter_db_optr replica",
+ /* 124 */ "alter_db_optr ::= alter_db_optr quorum",
+ /* 125 */ "alter_db_optr ::= alter_db_optr keep",
+ /* 126 */ "alter_db_optr ::= alter_db_optr blocks",
+ /* 127 */ "alter_db_optr ::= alter_db_optr comp",
+ /* 128 */ "alter_db_optr ::= alter_db_optr update",
+ /* 129 */ "alter_db_optr ::= alter_db_optr cachelast",
+ /* 130 */ "alter_topic_optr ::= alter_db_optr",
+ /* 131 */ "alter_topic_optr ::= alter_topic_optr partitions",
+ /* 132 */ "typename ::= ids",
+ /* 133 */ "typename ::= ids LP signed RP",
+ /* 134 */ "typename ::= ids UNSIGNED",
+ /* 135 */ "signed ::= INTEGER",
+ /* 136 */ "signed ::= PLUS INTEGER",
+ /* 137 */ "signed ::= MINUS INTEGER",
+ /* 138 */ "cmd ::= CREATE TABLE create_table_args",
+ /* 139 */ "cmd ::= CREATE TABLE create_stable_args",
+ /* 140 */ "cmd ::= CREATE STABLE create_stable_args",
+ /* 141 */ "cmd ::= CREATE TABLE create_table_list",
+ /* 142 */ "create_table_list ::= create_from_stable",
+ /* 143 */ "create_table_list ::= create_table_list create_from_stable",
+ /* 144 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
+ /* 145 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
+ /* 146 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
+ /* 147 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP",
+ /* 148 */ "tagNamelist ::= tagNamelist COMMA ids",
+ /* 149 */ "tagNamelist ::= ids",
+ /* 150 */ "create_table_args ::= ifnotexists ids cpxName AS select",
+ /* 151 */ "columnlist ::= columnlist COMMA column",
+ /* 152 */ "columnlist ::= column",
+ /* 153 */ "column ::= ids typename",
+ /* 154 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 155 */ "tagitemlist ::= tagitem",
+ /* 156 */ "tagitem ::= INTEGER",
+ /* 157 */ "tagitem ::= FLOAT",
+ /* 158 */ "tagitem ::= STRING",
+ /* 159 */ "tagitem ::= BOOL",
+ /* 160 */ "tagitem ::= NULL",
+ /* 161 */ "tagitem ::= NOW",
+ /* 162 */ "tagitem ::= MINUS INTEGER",
+ /* 163 */ "tagitem ::= MINUS FLOAT",
+ /* 164 */ "tagitem ::= PLUS INTEGER",
+ /* 165 */ "tagitem ::= PLUS FLOAT",
+ /* 166 */ "select ::= SELECT selcollist from where_opt interval_opt session_option windowstate_option fill_opt sliding_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt",
+ /* 167 */ "select ::= LP select RP",
+ /* 168 */ "union ::= select",
+ /* 169 */ "union ::= union UNION ALL select",
+ /* 170 */ "cmd ::= union",
+ /* 171 */ "select ::= SELECT selcollist",
+ /* 172 */ "sclp ::= selcollist COMMA",
+ /* 173 */ "sclp ::=",
+ /* 174 */ "selcollist ::= sclp distinct expr as",
+ /* 175 */ "selcollist ::= sclp STAR",
+ /* 176 */ "as ::= AS ids",
+ /* 177 */ "as ::= ids",
+ /* 178 */ "as ::=",
+ /* 179 */ "distinct ::= DISTINCT",
+ /* 180 */ "distinct ::=",
+ /* 181 */ "from ::= FROM tablelist",
+ /* 182 */ "from ::= FROM sub",
+ /* 183 */ "sub ::= LP union RP",
+ /* 184 */ "sub ::= LP union RP ids",
+ /* 185 */ "sub ::= sub COMMA LP union RP ids",
+ /* 186 */ "tablelist ::= ids cpxName",
+ /* 187 */ "tablelist ::= ids cpxName ids",
+ /* 188 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 189 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 190 */ "tmvar ::= VARIABLE",
+ /* 191 */ "interval_opt ::= INTERVAL LP tmvar RP",
+ /* 192 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
+ /* 193 */ "interval_opt ::=",
+ /* 194 */ "session_option ::=",
+ /* 195 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
+ /* 196 */ "windowstate_option ::=",
+ /* 197 */ "windowstate_option ::= STATE_WINDOW LP ids RP",
+ /* 198 */ "fill_opt ::=",
+ /* 199 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 200 */ "fill_opt ::= FILL LP ID RP",
+ /* 201 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 202 */ "sliding_opt ::=",
+ /* 203 */ "orderby_opt ::=",
+ /* 204 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 205 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 206 */ "sortlist ::= item sortorder",
+ /* 207 */ "item ::= ids cpxName",
+ /* 208 */ "sortorder ::= ASC",
+ /* 209 */ "sortorder ::= DESC",
+ /* 210 */ "sortorder ::=",
+ /* 211 */ "groupby_opt ::=",
+ /* 212 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 213 */ "grouplist ::= grouplist COMMA item",
+ /* 214 */ "grouplist ::= item",
+ /* 215 */ "having_opt ::=",
+ /* 216 */ "having_opt ::= HAVING expr",
+ /* 217 */ "limit_opt ::=",
+ /* 218 */ "limit_opt ::= LIMIT signed",
+ /* 219 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 220 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 221 */ "slimit_opt ::=",
+ /* 222 */ "slimit_opt ::= SLIMIT signed",
+ /* 223 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 224 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 225 */ "where_opt ::=",
+ /* 226 */ "where_opt ::= WHERE expr",
+ /* 227 */ "expr ::= LP expr RP",
+ /* 228 */ "expr ::= ID",
+ /* 229 */ "expr ::= ID DOT ID",
+ /* 230 */ "expr ::= ID DOT STAR",
+ /* 231 */ "expr ::= INTEGER",
+ /* 232 */ "expr ::= MINUS INTEGER",
+ /* 233 */ "expr ::= PLUS INTEGER",
+ /* 234 */ "expr ::= FLOAT",
+ /* 235 */ "expr ::= MINUS FLOAT",
+ /* 236 */ "expr ::= PLUS FLOAT",
+ /* 237 */ "expr ::= STRING",
+ /* 238 */ "expr ::= NOW",
+ /* 239 */ "expr ::= VARIABLE",
+ /* 240 */ "expr ::= PLUS VARIABLE",
+ /* 241 */ "expr ::= MINUS VARIABLE",
+ /* 242 */ "expr ::= BOOL",
+ /* 243 */ "expr ::= NULL",
+ /* 244 */ "expr ::= ID LP exprlist RP",
+ /* 245 */ "expr ::= ID LP STAR RP",
+ /* 246 */ "expr ::= expr IS NULL",
+ /* 247 */ "expr ::= expr IS NOT NULL",
+ /* 248 */ "expr ::= expr LT expr",
+ /* 249 */ "expr ::= expr GT expr",
+ /* 250 */ "expr ::= expr LE expr",
+ /* 251 */ "expr ::= expr GE expr",
+ /* 252 */ "expr ::= expr NE expr",
+ /* 253 */ "expr ::= expr EQ expr",
+ /* 254 */ "expr ::= expr BETWEEN expr AND expr",
+ /* 255 */ "expr ::= expr AND expr",
+ /* 256 */ "expr ::= expr OR expr",
+ /* 257 */ "expr ::= expr PLUS expr",
+ /* 258 */ "expr ::= expr MINUS expr",
+ /* 259 */ "expr ::= expr STAR expr",
+ /* 260 */ "expr ::= expr SLASH expr",
+ /* 261 */ "expr ::= expr REM expr",
+ /* 262 */ "expr ::= expr LIKE expr",
+ /* 263 */ "expr ::= expr IN LP exprlist RP",
+ /* 264 */ "exprlist ::= exprlist COMMA expritem",
+ /* 265 */ "exprlist ::= expritem",
+ /* 266 */ "expritem ::= expr",
+ /* 267 */ "expritem ::=",
+ /* 268 */ "cmd ::= RESET QUERY CACHE",
+ /* 269 */ "cmd ::= SYNCDB ids REPLICA",
+ /* 270 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 271 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 272 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 273 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 274 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 275 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 276 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 277 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
+ /* 278 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
+ /* 279 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
+ /* 280 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 281 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
+ /* 282 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
+ /* 283 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
+ /* 284 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 285 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
+ /* 286 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 287 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 288 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1452,58 +1478,58 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 200: /* exprlist */
-    case 243: /* selcollist */
-    case 257: /* sclp */
+    case 205: /* exprlist */
+    case 249: /* selcollist */
+    case 263: /* sclp */
 {
-tSqlExprListDestroy((yypminor->yy441));
+tSqlExprListDestroy((yypminor->yy525));
 }
       break;
-    case 213: /* intitemlist */
-    case 215: /* keep */
-    case 237: /* columnlist */
-    case 238: /* tagitemlist */
-    case 239: /* tagNamelist */
-    case 249: /* fill_opt */
-    case 251: /* groupby_opt */
-    case 253: /* orderby_opt */
-    case 264: /* sortlist */
-    case 268: /* grouplist */
+    case 220: /* intitemlist */
+    case 222: /* keep */
+    case 243: /* columnlist */
+    case 244: /* tagitemlist */
+    case 245: /* tagNamelist */
+    case 255: /* fill_opt */
+    case 257: /* groupby_opt */
+    case 259: /* orderby_opt */
+    case 270: /* sortlist */
+    case 274: /* grouplist */
 {
-taosArrayDestroy((yypminor->yy441));
+taosArrayDestroy((yypminor->yy525));
 }
       break;
-    case 235: /* create_table_list */
+    case 241: /* create_table_list */
 {
-destroyCreateTableSql((yypminor->yy182));
+destroyCreateTableSql((yypminor->yy158));
 }
       break;
-    case 240: /* select */
+    case 246: /* select */
 {
-destroySqlNode((yypminor->yy236));
+destroySqlNode((yypminor->yy464));
 }
       break;
-    case 244: /* from */
-    case 261: /* tablelist */
-    case 262: /* sub */
+    case 250: /* from */
+    case 267: /* tablelist */
+    case 268: /* sub */
 {
-destroyRelationInfo((yypminor->yy244));
+destroyRelationInfo((yypminor->yy412));
 }
       break;
-    case 245: /* where_opt */
-    case 252: /* having_opt */
-    case 259: /* expr */
-    case 269: /* expritem */
+    case 251: /* where_opt */
+    case 258: /* having_opt */
+    case 265: /* expr */
+    case 275: /* expritem */
 {
-tSqlExprDestroy((yypminor->yy166));
+tSqlExprDestroy((yypminor->yy370));
 }
       break;
-    case 256: /* union */
+    case 262: /* union */
 {
-destroyAllSqlNode((yypminor->yy441));
+destroyAllSqlNode((yypminor->yy525));
 }
       break;
-    case 265: /* sortitem */
+    case 271: /* sortitem */
 {
 tVariantDestroy(&(yypminor->yy506));
 }
@@ -1799,289 +1825,295 @@ static const struct {
   YYCODETYPE lhs;       /* Symbol on the left-hand side of the rule */
   signed char nrhs;     /* Negative of the number of RHS symbols in the rule */
 } yyRuleInfo[] = {
-  {  191,   -1 }, /* (0) program ::= cmd */
-  {  192,   -2 }, /* (1) cmd ::= SHOW DATABASES */
-  {  192,   -2 }, /* (2) cmd ::= SHOW TOPICS */
-  {  192,   -2 }, /* (3) cmd ::= SHOW MNODES */
-  {  192,   -2 }, /* (4) cmd ::= SHOW DNODES */
-  {  192,   -2 }, /* (5) cmd ::= SHOW ACCOUNTS */
-  {  192,   -2 }, /* (6) cmd ::= SHOW USERS */
-  {  192,   -2 }, /* (7) cmd ::= SHOW MODULES */
-  {  192,   -2 }, /* (8) cmd ::= SHOW QUERIES */
-  {  192,   -2 }, /* (9) cmd ::= SHOW CONNECTIONS */
-  {  192,   -2 }, /* (10) cmd ::= SHOW STREAMS */
-  {  192,   -2 }, /* (11) cmd ::= SHOW VARIABLES */
-  {  192,   -2 }, /* (12) cmd ::= SHOW SCORES */
-  {  192,   -2 }, /* (13) cmd ::= SHOW GRANTS */
-  {  192,   -2 }, /* (14) cmd ::= SHOW VNODES */
-  {  192,   -3 }, /* (15) cmd ::= SHOW VNODES IPTOKEN */
-  {  193,    0 }, /* (16) dbPrefix ::= */
-  {  193,   -2 }, /* (17) dbPrefix ::= ids DOT */
-  {  195,    0 }, /* (18) cpxName ::= */
-  {  195,   -2 }, /* (19) cpxName ::= DOT ids */
-  {  192,   -5 }, /* (20) cmd ::= SHOW CREATE TABLE ids cpxName */
-  {  192,   -5 }, /* (21) cmd ::= SHOW CREATE STABLE ids cpxName */
-  {  192,   -4 }, /* (22) cmd ::= SHOW CREATE DATABASE ids */
-  {  192,   -3 }, /* (23) cmd ::= SHOW dbPrefix TABLES */
-  {  192,   -5 }, /* (24) cmd ::= SHOW dbPrefix TABLES LIKE ids */
-  {  192,   -3 }, /* (25) cmd ::= SHOW dbPrefix STABLES */
-  {  192,   -5 }, /* (26) cmd ::= SHOW dbPrefix STABLES LIKE ids */
-  {  192,   -3 }, /* (27) cmd ::= SHOW dbPrefix VGROUPS */
-  {  192,   -4 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS ids */
-  {  192,   -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
-  {  192,   -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
-  {  192,   -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */
-  {  192,   -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */
-  {  192,   -3 }, /* (33) cmd ::= DROP DNODE ids */
-  {  192,   -3 }, /* (34) cmd ::= DROP USER ids */
-  {  192,   -3 }, /* (35) cmd ::= DROP ACCOUNT ids */
-  {  192,   -2 }, /* (36) cmd ::= USE ids */
-  {  192,   -3 }, /* (37) cmd ::= DESCRIBE ids cpxName */
-  {  192,   -5 }, /* (38) cmd ::= ALTER USER ids PASS ids */
-  {  192,   -5 }, /* (39) cmd ::= ALTER USER ids PRIVILEGE ids */
-  {  192,   -4 }, /* (40) cmd ::= ALTER DNODE ids ids */
-  {  192,   -5 }, /* (41) cmd ::= ALTER DNODE ids ids ids */
-  {  192,   -3 }, /* (42) cmd ::= ALTER LOCAL ids */
-  {  192,   -4 }, /* (43) cmd ::= ALTER LOCAL ids ids */
-  {  192,   -4 }, /* (44) cmd ::= ALTER DATABASE ids alter_db_optr */
-  {  192,   -4 }, /* (45) cmd ::= ALTER TOPIC ids alter_topic_optr */
-  {  192,   -4 }, /* (46) cmd ::= ALTER ACCOUNT ids acct_optr */
-  {  192,   -6 }, /* (47) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-  {  192,   -6 }, /* (48) cmd ::= COMPACT VNODES IN LP exprlist RP */
-  {  194,   -1 }, /* (49) ids ::= ID */
-  {  194,   -1 }, /* (50) ids ::= STRING */
-  {  196,   -2 }, /* (51) ifexists ::= IF EXISTS */
-  {  196,    0 }, /* (52) ifexists ::= */
-  {  201,   -3 }, /* (53) ifnotexists ::= IF NOT EXISTS */
-  {  201,    0 }, /* (54) ifnotexists ::= */
-  {  192,   -3 }, /* (55) cmd ::= CREATE DNODE ids */
-  {  192,   -6 }, /* (56) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-  {  192,   -5 }, /* (57) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-  {  192,   -5 }, /* (58) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
-  {  192,   -5 }, /* (59) cmd ::= CREATE USER ids PASS ids */
-  {  204,    0 }, /* (60) pps ::= */
-  {  204,   -2 }, /* (61) pps ::= PPS INTEGER */
-  {  205,    0 }, /* (62) tseries ::= */
-  {  205,   -2 }, /* (63) tseries ::= TSERIES INTEGER */
-  {  206,    0 }, /* (64) dbs ::= */
-  {  206,   -2 }, /* (65) dbs ::= DBS INTEGER */
-  {  207,    0 }, /* (66) streams ::= */
-  {  207,   -2 }, /* (67) streams ::= STREAMS INTEGER */
-  {  208,    0 }, /* (68) storage ::= */
-  {  208,   -2 }, /* (69) storage ::= STORAGE INTEGER */
-  {  209,    0 }, /* (70) qtime ::= */
-  {  209,   -2 }, /* (71) qtime ::= QTIME INTEGER */
-  {  210,    0 }, /* (72) users ::= */
-  {  210,   -2 }, /* (73) users ::= USERS INTEGER */
-  {  211,    0 }, /* (74) conns ::= */
-  {  211,   -2 }, /* (75) conns ::= CONNS INTEGER */
-  {  212,    0 }, /* (76) state ::= */
-  {  212,   -2 }, /* (77) state ::= STATE ids */
-  {  199,   -9 }, /* (78) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-  {  213,   -3 }, /* (79) intitemlist ::= intitemlist COMMA intitem */
-  {  213,   -1 }, /* (80) intitemlist ::= intitem */
-  {  214,   -1 }, /* (81) intitem ::= INTEGER */
-  {  215,   -2 }, /* (82) keep ::= KEEP intitemlist */
-  {  216,   -2 }, /* (83) cache ::= CACHE INTEGER */
-  {  217,   -2 }, /* (84) replica ::= REPLICA INTEGER */
-  {  218,   -2 }, /* (85) quorum ::= QUORUM INTEGER */
-  {  219,   -2 }, /* (86) days ::= DAYS INTEGER */
-  {  220,   -2 }, /* (87) minrows ::= MINROWS INTEGER */
-  {  221,   -2 }, /* (88) maxrows ::= MAXROWS INTEGER */
-  {  222,   -2 }, /* (89) blocks ::= BLOCKS INTEGER */
-  {  223,   -2 }, /* (90) ctime ::= CTIME INTEGER */
-  {  224,   -2 }, /* (91) wal ::= WAL INTEGER */
-  {  225,   -2 }, /* (92) fsync ::= FSYNC INTEGER */
-  {  226,   -2 }, /* (93) comp ::= COMP INTEGER */
-  {  227,   -2 }, /* (94) prec ::= PRECISION STRING */
-  {  228,   -2 }, /* (95) update ::= UPDATE INTEGER */
-  {  229,   -2 }, /* (96) cachelast ::= CACHELAST INTEGER */
-  {  230,   -2 }, /* (97) partitions ::= PARTITIONS INTEGER */
-  {  202,    0 }, /* (98) db_optr ::= */
-  {  202,   -2 }, /* (99) db_optr ::= db_optr cache */
-  {  202,   -2 }, /* (100) db_optr ::= db_optr replica */
-  {  202,   -2 }, /* (101) db_optr ::= db_optr quorum */
-  {  202,   -2 }, /* (102) db_optr ::= db_optr days */
-  {  202,   -2 }, /* (103) db_optr ::= db_optr minrows */
-  {  202,   -2 }, /* (104) db_optr ::= db_optr maxrows */
-  {  202,   -2 }, /* (105) db_optr ::= db_optr blocks */
-  {  202,   -2 }, /* (106) db_optr ::= db_optr ctime */
-  {  202,   -2 }, /* (107) db_optr ::= db_optr wal */
-  {  202,   -2 }, /* (108) db_optr ::= db_optr fsync */
-  {  202,   -2 }, /* (109) db_optr ::= db_optr comp */
-  {  202,   -2 }, /* (110) db_optr ::= db_optr prec */
-  {  202,   -2 }, /* (111) db_optr ::= db_optr keep */
-  {  202,   -2 }, /* (112) db_optr ::= db_optr update */
-  {  202,   -2 }, /* (113) db_optr ::= db_optr cachelast */
-  {  203,   -1 }, /* (114) topic_optr ::= db_optr */
-  {  203,   -2 }, /* (115) topic_optr ::= topic_optr partitions */
-  {  197,    0 }, /* (116) alter_db_optr ::= */
-  {  197,   -2 }, /* (117) alter_db_optr ::= alter_db_optr replica */
-  {  197,   -2 }, /* (118) alter_db_optr ::= alter_db_optr quorum */
-  {  197,   -2 }, /* (119) alter_db_optr ::= alter_db_optr keep */
-  {  197,   -2 }, /* (120) alter_db_optr ::= alter_db_optr blocks */
-  {  197,   -2 }, /* (121) alter_db_optr ::= alter_db_optr comp */
-  {  197,   -2 }, /* (122) alter_db_optr ::= alter_db_optr update */
-  {  197,   -2 }, /* (123) alter_db_optr ::= alter_db_optr cachelast */
-  {  198,   -1 }, /* (124) alter_topic_optr ::= alter_db_optr */
-  {  198,   -2 }, /* (125) alter_topic_optr ::= alter_topic_optr partitions */
-  {  231,   -1 }, /* (126) typename ::= ids */
-  {  231,   -4 }, /* (127) typename ::= ids LP signed RP */
-  {  231,   -2 }, /* (128) typename ::= ids UNSIGNED */
-  {  232,   -1 }, /* (129) signed ::= INTEGER */
-  {  232,   -2 }, /* (130) signed ::= PLUS INTEGER */
-  {  232,   -2 }, /* (131) signed ::= MINUS INTEGER */
-  {  192,   -3 }, /* (132) cmd ::= CREATE TABLE create_table_args */
-  {  192,   -3 }, /* (133) cmd ::= CREATE TABLE create_stable_args */
-  {  192,   -3 }, /* (134) cmd ::= CREATE STABLE create_stable_args */
-  {  192,   -3 }, /* (135) cmd ::= CREATE TABLE create_table_list */
-  {  235,   -1 }, /* (136) create_table_list ::= create_from_stable */
-  {  235,   -2 }, /* (137) create_table_list ::= create_table_list create_from_stable */
-  {  233,   -6 }, /* (138) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
-  {  234,  -10 }, /* (139) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
-  {  236,  -10 }, /* (140) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
-  {  236,  -13 }, /* (141) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
-  {  239,   -3 }, /* (142) tagNamelist ::= tagNamelist COMMA ids */
-  {  239,   -1 }, /* (143) tagNamelist ::= ids */
-  {  233,   -5 }, /* (144) create_table_args ::= ifnotexists ids cpxName AS select */
-  {  237,   -3 }, /* (145) columnlist ::= columnlist COMMA column */
-  {  237,   -1 }, /* (146) columnlist ::= column */
-  {  241,   -2 }, /* (147) column ::= ids typename */
-  {  238,   -3 }, /* (148) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  238,   -1 }, /* (149) tagitemlist ::= tagitem */
-  {  242,   -1 }, /* (150) tagitem ::= INTEGER */
-  {  242,   -1 }, /* (151) tagitem ::= FLOAT */
-  {  242,   -1 }, /* (152) tagitem ::= STRING */
-  {  242,   -1 }, /* (153) tagitem ::= BOOL */
-  {  242,   -1 }, /* (154) tagitem ::= NULL */
-  {  242,   -1 }, /* (155) tagitem ::= NOW */
-  {  242,   -2 }, /* (156) tagitem ::= MINUS INTEGER */
-  {  242,   -2 }, /* (157) tagitem ::= MINUS FLOAT */
-  {  242,   -2 }, /* (158) tagitem ::= PLUS INTEGER */
-  {  242,   -2 }, /* (159) tagitem ::= PLUS FLOAT */
-  {  240,  -14 }, /* (160) select ::= SELECT selcollist from where_opt interval_opt session_option windowstate_option fill_opt sliding_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
-  {  240,   -3 }, /* (161) select ::= LP select RP */
-  {  256,   -1 }, /* (162) union ::= select */
-  {  256,   -4 }, /* (163) union ::= union UNION ALL select */
-  {  192,   -1 }, /* (164) cmd ::= union */
-  {  240,   -2 }, /* (165) select ::= SELECT selcollist */
-  {  257,   -2 }, /* (166) sclp ::= selcollist COMMA */
-  {  257,    0 }, /* (167) sclp ::= */
-  {  243,   -4 }, /* (168) selcollist ::= sclp distinct expr as */
-  {  243,   -2 }, /* (169) selcollist ::= sclp STAR */
-  {  260,   -2 }, /* (170) as ::= AS ids */
-  {  260,   -1 }, /* (171) as ::= ids */
-  {  260,    0 }, /* (172) as ::= */
-  {  258,   -1 }, /* (173) distinct ::= DISTINCT */
-  {  258,    0 }, /* (174) distinct ::= */
-  {  244,   -2 }, /* (175) from ::= FROM tablelist */
-  {  244,   -2 }, /* (176) from ::= FROM sub */
-  {  262,   -3 }, /* (177) sub ::= LP union RP */
-  {  262,   -4 }, /* (178) sub ::= LP union RP ids */
-  {  262,   -6 }, /* (179) sub ::= sub COMMA LP union RP ids */
-  {  261,   -2 }, /* (180) tablelist ::= ids cpxName */
-  {  261,   -3 }, /* (181) tablelist ::= ids cpxName ids */
-  {  261,   -4 }, /* (182) tablelist ::= tablelist COMMA ids cpxName */
-  {  261,   -5 }, /* (183) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  263,   -1 }, /* (184) tmvar ::= VARIABLE */
-  {  246,   -4 }, /* (185) interval_opt ::= INTERVAL LP tmvar RP */
-  {  246,   -6 }, /* (186) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-  {  246,    0 }, /* (187) interval_opt ::= */
-  {  247,    0 }, /* (188) session_option ::= */
-  {  247,   -7 }, /* (189) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
-  {  248,    0 }, /* (190) windowstate_option ::= */
-  {  248,   -4 }, /* (191) windowstate_option ::= STATE_WINDOW LP ids RP */
-  {  249,    0 }, /* (192) fill_opt ::= */
-  {  249,   -6 }, /* (193) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  249,   -4 }, /* (194) fill_opt ::= FILL LP ID RP */
-  {  250,   -4 }, /* (195) sliding_opt ::= SLIDING LP tmvar RP */
-  {  250,    0 }, /* (196) sliding_opt ::= */
-  {  253,    0 }, /* (197) orderby_opt ::= */
-  {  253,   -3 }, /* (198) orderby_opt ::= ORDER BY sortlist */
-  {  264,   -4 }, /* (199) sortlist ::= sortlist COMMA item sortorder */
-  {  264,   -2 }, /* (200) sortlist ::= item sortorder */
-  {  266,   -2 }, /* (201) item ::= ids cpxName */
-  {  267,   -1 }, /* (202) sortorder ::= ASC */
-  {  267,   -1 }, /* (203) sortorder ::= DESC */
-  {  267,    0 }, /* (204) sortorder ::= */
-  {  251,    0 }, /* (205) groupby_opt ::= */
-  {  251,   -3 }, /* (206) groupby_opt ::= GROUP BY grouplist */
-  {  268,   -3 }, /* (207) grouplist ::= grouplist COMMA item */
-  {  268,   -1 }, /* (208) grouplist ::= item */
-  {  252,    0 }, /* (209) having_opt ::= */
-  {  252,   -2 }, /* (210) having_opt ::= HAVING expr */
-  {  255,    0 }, /* (211) limit_opt ::= */
-  {  255,   -2 }, /* (212) limit_opt ::= LIMIT signed */
-  {  255,   -4 }, /* (213) limit_opt ::= LIMIT signed OFFSET signed */
-  {  255,   -4 }, /* (214) limit_opt ::= LIMIT signed COMMA signed */
-  {  254,    0 }, /* (215) slimit_opt ::= */
-  {  254,   -2 }, /* (216) slimit_opt ::= SLIMIT signed */
-  {  254,   -4 }, /* (217) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  254,   -4 }, /* (218) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  245,    0 }, /* (219) where_opt ::= */
-  {  245,   -2 }, /* (220) where_opt ::= WHERE expr */
-  {  259,   -3 }, /* (221) expr ::= LP expr RP */
-  {  259,   -1 }, /* (222) expr ::= ID */
-  {  259,   -3 }, /* (223) expr ::= ID DOT ID */
-  {  259,   -3 }, /* (224) expr ::= ID DOT STAR */
-  {  259,   -1 }, /* (225) expr ::= INTEGER */
-  {  259,   -2 }, /* (226) expr ::= MINUS INTEGER */
-  {  259,   -2 }, /* (227) expr ::= PLUS INTEGER */
-  {  259,   -1 }, /* (228) expr ::= FLOAT */
-  {  259,   -2 }, /* (229) expr ::= MINUS FLOAT */
-  {  259,   -2 }, /* (230) expr ::= PLUS FLOAT */
-  {  259,   -1 }, /* (231) expr ::= STRING */
-  {  259,   -1 }, /* (232) expr ::= NOW */
-  {  259,   -1 }, /* (233) expr ::= VARIABLE */
-  {  259,   -2 }, /* (234) expr ::= PLUS VARIABLE */
-  {  259,   -2 }, /* (235) expr ::= MINUS VARIABLE */
-  {  259,   -1 }, /* (236) expr ::= BOOL */
-  {  259,   -1 }, /* (237) expr ::= NULL */
-  {  259,   -4 }, /* (238) expr ::= ID LP exprlist RP */
-  {  259,   -4 }, /* (239) expr ::= ID LP STAR RP */
-  {  259,   -3 }, /* (240) expr ::= expr IS NULL */
-  {  259,   -4 }, /* (241) expr ::= expr IS NOT NULL */
-  {  259,   -3 }, /* (242) expr ::= expr LT expr */
-  {  259,   -3 }, /* (243) expr ::= expr GT expr */
-  {  259,   -3 }, /* (244) expr ::= expr LE expr */
-  {  259,   -3 }, /* (245) expr ::= expr GE expr */
-  {  259,   -3 }, /* (246) expr ::= expr NE expr */
-  {  259,   -3 }, /* (247) expr ::= expr EQ expr */
-  {  259,   -5 }, /* (248) expr ::= expr BETWEEN expr AND expr */
-  {  259,   -3 }, /* (249) expr ::= expr AND expr */
-  {  259,   -3 }, /* (250) expr ::= expr OR expr */
-  {  259,   -3 }, /* (251) expr ::= expr PLUS expr */
-  {  259,   -3 }, /* (252) expr ::= expr MINUS expr */
-  {  259,   -3 }, /* (253) expr ::= expr STAR expr */
-  {  259,   -3 }, /* (254) expr ::= expr SLASH expr */
-  {  259,   -3 }, /* (255) expr ::= expr REM expr */
-  {  259,   -3 }, /* (256) expr ::= expr LIKE expr */
-  {  259,   -5 }, /* (257) expr ::= expr IN LP exprlist RP */
-  {  200,   -3 }, /* (258) exprlist ::= exprlist COMMA expritem */
-  {  200,   -1 }, /* (259) exprlist ::= expritem */
-  {  269,   -1 }, /* (260) expritem ::= expr */
-  {  269,    0 }, /* (261) expritem ::= */
-  {  192,   -3 }, /* (262) cmd ::= RESET QUERY CACHE */
-  {  192,   -3 }, /* (263) cmd ::= SYNCDB ids REPLICA */
-  {  192,   -7 }, /* (264) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  192,   -7 }, /* (265) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  192,   -7 }, /* (266) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
-  {  192,   -7 }, /* (267) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  192,   -7 }, /* (268) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  192,   -8 }, /* (269) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  192,   -9 }, /* (270) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  192,   -7 }, /* (271) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
-  {  192,   -7 }, /* (272) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
-  {  192,   -7 }, /* (273) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
-  {  192,   -7 }, /* (274) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
-  {  192,   -7 }, /* (275) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
-  {  192,   -7 }, /* (276) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
-  {  192,   -8 }, /* (277) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
-  {  192,   -9 }, /* (278) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
-  {  192,   -7 }, /* (279) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
-  {  192,   -3 }, /* (280) cmd ::= KILL CONNECTION INTEGER */
-  {  192,   -5 }, /* (281) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  192,   -5 }, /* (282) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  196,   -1 }, /* (0) program ::= cmd */
+  {  197,   -2 }, /* (1) cmd ::= SHOW DATABASES */
+  {  197,   -2 }, /* (2) cmd ::= SHOW TOPICS */
+  {  197,   -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
+  {  197,   -2 }, /* (4) cmd ::= SHOW MNODES */
+  {  197,   -2 }, /* (5) cmd ::= SHOW DNODES */
+  {  197,   -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
+  {  197,   -2 }, /* (7) cmd ::= SHOW USERS */
+  {  197,   -2 }, /* (8) cmd ::= SHOW MODULES */
+  {  197,   -2 }, /* (9) cmd ::= SHOW QUERIES */
+  {  197,   -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
+  {  197,   -2 }, /* (11) cmd ::= SHOW STREAMS */
+  {  197,   -2 }, /* (12) cmd ::= SHOW VARIABLES */
+  {  197,   -2 }, /* (13) cmd ::= SHOW SCORES */
+  {  197,   -2 }, /* (14) cmd ::= SHOW GRANTS */
+  {  197,   -2 }, /* (15) cmd ::= SHOW VNODES */
+  {  197,   -3 }, /* (16) cmd ::= SHOW VNODES IPTOKEN */
+  {  198,    0 }, /* (17) dbPrefix ::= */
+  {  198,   -2 }, /* (18) dbPrefix ::= ids DOT */
+  {  200,    0 }, /* (19) cpxName ::= */
+  {  200,   -2 }, /* (20) cpxName ::= DOT ids */
+  {  197,   -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
+  {  197,   -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
+  {  197,   -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
+  {  197,   -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
+  {  197,   -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE ids */
+  {  197,   -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
+  {  197,   -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE ids */
+  {  197,   -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
+  {  197,   -4 }, /* (29) cmd ::= SHOW dbPrefix VGROUPS ids */
+  {  197,   -5 }, /* (30) cmd ::= DROP TABLE ifexists ids cpxName */
+  {  197,   -5 }, /* (31) cmd ::= DROP STABLE ifexists ids cpxName */
+  {  197,   -4 }, /* (32) cmd ::= DROP DATABASE ifexists ids */
+  {  197,   -4 }, /* (33) cmd ::= DROP TOPIC ifexists ids */
+  {  197,   -3 }, /* (34) cmd ::= DROP FUNCTION ids */
+  {  197,   -3 }, /* (35) cmd ::= DROP DNODE ids */
+  {  197,   -3 }, /* (36) cmd ::= DROP USER ids */
+  {  197,   -3 }, /* (37) cmd ::= DROP ACCOUNT ids */
+  {  197,   -2 }, /* (38) cmd ::= USE ids */
+  {  197,   -3 }, /* (39) cmd ::= DESCRIBE ids cpxName */
+  {  197,   -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */
+  {  197,   -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
+  {  197,   -4 }, /* (42) cmd ::= ALTER DNODE ids ids */
+  {  197,   -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */
+  {  197,   -3 }, /* (44) cmd ::= ALTER LOCAL ids */
+  {  197,   -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */
+  {  197,   -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
+  {  197,   -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
+  {  197,   -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
+  {  197,   -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+  {  197,   -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
+  {  199,   -1 }, /* (51) ids ::= ID */
+  {  199,   -1 }, /* (52) ids ::= STRING */
+  {  201,   -2 }, /* (53) ifexists ::= IF EXISTS */
+  {  201,    0 }, /* (54) ifexists ::= */
+  {  206,   -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
+  {  206,    0 }, /* (56) ifnotexists ::= */
+  {  197,   -3 }, /* (57) cmd ::= CREATE DNODE ids */
+  {  197,   -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+  {  197,   -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+  {  197,   -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
+  {  197,   -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  197,   -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  197,   -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
+  {  210,    0 }, /* (64) bufsize ::= */
+  {  210,   -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
+  {  211,    0 }, /* (66) pps ::= */
+  {  211,   -2 }, /* (67) pps ::= PPS INTEGER */
+  {  212,    0 }, /* (68) tseries ::= */
+  {  212,   -2 }, /* (69) tseries ::= TSERIES INTEGER */
+  {  213,    0 }, /* (70) dbs ::= */
+  {  213,   -2 }, /* (71) dbs ::= DBS INTEGER */
+  {  214,    0 }, /* (72) streams ::= */
+  {  214,   -2 }, /* (73) streams ::= STREAMS INTEGER */
+  {  215,    0 }, /* (74) storage ::= */
+  {  215,   -2 }, /* (75) storage ::= STORAGE INTEGER */
+  {  216,    0 }, /* (76) qtime ::= */
+  {  216,   -2 }, /* (77) qtime ::= QTIME INTEGER */
+  {  217,    0 }, /* (78) users ::= */
+  {  217,   -2 }, /* (79) users ::= USERS INTEGER */
+  {  218,    0 }, /* (80) conns ::= */
+  {  218,   -2 }, /* (81) conns ::= CONNS INTEGER */
+  {  219,    0 }, /* (82) state ::= */
+  {  219,   -2 }, /* (83) state ::= STATE ids */
+  {  204,   -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+  {  220,   -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
+  {  220,   -1 }, /* (86) intitemlist ::= intitem */
+  {  221,   -1 }, /* (87) intitem ::= INTEGER */
+  {  222,   -2 }, /* (88) keep ::= KEEP intitemlist */
+  {  223,   -2 }, /* (89) cache ::= CACHE INTEGER */
+  {  224,   -2 }, /* (90) replica ::= REPLICA INTEGER */
+  {  225,   -2 }, /* (91) quorum ::= QUORUM INTEGER */
+  {  226,   -2 }, /* (92) days ::= DAYS INTEGER */
+  {  227,   -2 }, /* (93) minrows ::= MINROWS INTEGER */
+  {  228,   -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
+  {  229,   -2 }, /* (95) blocks ::= BLOCKS INTEGER */
+  {  230,   -2 }, /* (96) ctime ::= CTIME INTEGER */
+  {  231,   -2 }, /* (97) wal ::= WAL INTEGER */
+  {  232,   -2 }, /* (98) fsync ::= FSYNC INTEGER */
+  {  233,   -2 }, /* (99) comp ::= COMP INTEGER */
+  {  234,   -2 }, /* (100) prec ::= PRECISION STRING */
+  {  235,   -2 }, /* (101) update ::= UPDATE INTEGER */
+  {  236,   -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
+  {  237,   -2 }, /* (103) partitions ::= PARTITIONS INTEGER */
+  {  207,    0 }, /* (104) db_optr ::= */
+  {  207,   -2 }, /* (105) db_optr ::= db_optr cache */
+  {  207,   -2 }, /* (106) db_optr ::= db_optr replica */
+  {  207,   -2 }, /* (107) db_optr ::= db_optr quorum */
+  {  207,   -2 }, /* (108) db_optr ::= db_optr days */
+  {  207,   -2 }, /* (109) db_optr ::= db_optr minrows */
+  {  207,   -2 }, /* (110) db_optr ::= db_optr maxrows */
+  {  207,   -2 }, /* (111) db_optr ::= db_optr blocks */
+  {  207,   -2 }, /* (112) db_optr ::= db_optr ctime */
+  {  207,   -2 }, /* (113) db_optr ::= db_optr wal */
+  {  207,   -2 }, /* (114) db_optr ::= db_optr fsync */
+  {  207,   -2 }, /* (115) db_optr ::= db_optr comp */
+  {  207,   -2 }, /* (116) db_optr ::= db_optr prec */
+  {  207,   -2 }, /* (117) db_optr ::= db_optr keep */
+  {  207,   -2 }, /* (118) db_optr ::= db_optr update */
+  {  207,   -2 }, /* (119) db_optr ::= db_optr cachelast */
+  {  208,   -1 }, /* (120) topic_optr ::= db_optr */
+  {  208,   -2 }, /* (121) topic_optr ::= topic_optr partitions */
+  {  202,    0 }, /* (122) alter_db_optr ::= */
+  {  202,   -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */
+  {  202,   -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */
+  {  202,   -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */
+  {  202,   -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */
+  {  202,   -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */
+  {  202,   -2 }, /* (128) alter_db_optr ::= alter_db_optr update */
+  {  202,   -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */
+  {  203,   -1 }, /* (130) alter_topic_optr ::= alter_db_optr */
+  {  203,   -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */
+  {  209,   -1 }, /* (132) typename ::= ids */
+  {  209,   -4 }, /* (133) typename ::= ids LP signed RP */
+  {  209,   -2 }, /* (134) typename ::= ids UNSIGNED */
+  {  238,   -1 }, /* (135) signed ::= INTEGER */
+  {  238,   -2 }, /* (136) signed ::= PLUS INTEGER */
+  {  238,   -2 }, /* (137) signed ::= MINUS INTEGER */
+  {  197,   -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */
+  {  197,   -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */
+  {  197,   -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */
+  {  197,   -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */
+  {  241,   -1 }, /* (142) create_table_list ::= create_from_stable */
+  {  241,   -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */
+  {  239,   -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+  {  240,  -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+  {  242,  -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+  {  242,  -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+  {  245,   -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */
+  {  245,   -1 }, /* (149) tagNamelist ::= ids */
+  {  239,   -5 }, /* (150) create_table_args ::= ifnotexists ids cpxName AS select */
+  {  243,   -3 }, /* (151) columnlist ::= columnlist COMMA column */
+  {  243,   -1 }, /* (152) columnlist ::= column */
+  {  247,   -2 }, /* (153) column ::= ids typename */
+  {  244,   -3 }, /* (154) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  244,   -1 }, /* (155) tagitemlist ::= tagitem */
+  {  248,   -1 }, /* (156) tagitem ::= INTEGER */
+  {  248,   -1 }, /* (157) tagitem ::= FLOAT */
+  {  248,   -1 }, /* (158) tagitem ::= STRING */
+  {  248,   -1 }, /* (159) tagitem ::= BOOL */
+  {  248,   -1 }, /* (160) tagitem ::= NULL */
+  {  248,   -1 }, /* (161) tagitem ::= NOW */
+  {  248,   -2 }, /* (162) tagitem ::= MINUS INTEGER */
+  {  248,   -2 }, /* (163) tagitem ::= MINUS FLOAT */
+  {  248,   -2 }, /* (164) tagitem ::= PLUS INTEGER */
+  {  248,   -2 }, /* (165) tagitem ::= PLUS FLOAT */
+  {  246,  -14 }, /* (166) select ::= SELECT selcollist from where_opt interval_opt session_option windowstate_option fill_opt sliding_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+  {  246,   -3 }, /* (167) select ::= LP select RP */
+  {  262,   -1 }, /* (168) union ::= select */
+  {  262,   -4 }, /* (169) union ::= union UNION ALL select */
+  {  197,   -1 }, /* (170) cmd ::= union */
+  {  246,   -2 }, /* (171) select ::= SELECT selcollist */
+  {  263,   -2 }, /* (172) sclp ::= selcollist COMMA */
+  {  263,    0 }, /* (173) sclp ::= */
+  {  249,   -4 }, /* (174) selcollist ::= sclp distinct expr as */
+  {  249,   -2 }, /* (175) selcollist ::= sclp STAR */
+  {  266,   -2 }, /* (176) as ::= AS ids */
+  {  266,   -1 }, /* (177) as ::= ids */
+  {  266,    0 }, /* (178) as ::= */
+  {  264,   -1 }, /* (179) distinct ::= DISTINCT */
+  {  264,    0 }, /* (180) distinct ::= */
+  {  250,   -2 }, /* (181) from ::= FROM tablelist */
+  {  250,   -2 }, /* (182) from ::= FROM sub */
+  {  268,   -3 }, /* (183) sub ::= LP union RP */
+  {  268,   -4 }, /* (184) sub ::= LP union RP ids */
+  {  268,   -6 }, /* (185) sub ::= sub COMMA LP union RP ids */
+  {  267,   -2 }, /* (186) tablelist ::= ids cpxName */
+  {  267,   -3 }, /* (187) tablelist ::= ids cpxName ids */
+  {  267,   -4 }, /* (188) tablelist ::= tablelist COMMA ids cpxName */
+  {  267,   -5 }, /* (189) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  269,   -1 }, /* (190) tmvar ::= VARIABLE */
+  {  252,   -4 }, /* (191) interval_opt ::= INTERVAL LP tmvar RP */
+  {  252,   -6 }, /* (192) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+  {  252,    0 }, /* (193) interval_opt ::= */
+  {  253,    0 }, /* (194) session_option ::= */
+  {  253,   -7 }, /* (195) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+  {  254,    0 }, /* (196) windowstate_option ::= */
+  {  254,   -4 }, /* (197) windowstate_option ::= STATE_WINDOW LP ids RP */
+  {  255,    0 }, /* (198) fill_opt ::= */
+  {  255,   -6 }, /* (199) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  255,   -4 }, /* (200) fill_opt ::= FILL LP ID RP */
+  {  256,   -4 }, /* (201) sliding_opt ::= SLIDING LP tmvar RP */
+  {  256,    0 }, /* (202) sliding_opt ::= */
+  {  259,    0 }, /* (203) orderby_opt ::= */
+  {  259,   -3 }, /* (204) orderby_opt ::= ORDER BY sortlist */
+  {  270,   -4 }, /* (205) sortlist ::= sortlist COMMA item sortorder */
+  {  270,   -2 }, /* (206) sortlist ::= item sortorder */
+  {  272,   -2 }, /* (207) item ::= ids cpxName */
+  {  273,   -1 }, /* (208) sortorder ::= ASC */
+  {  273,   -1 }, /* (209) sortorder ::= DESC */
+  {  273,    0 }, /* (210) sortorder ::= */
+  {  257,    0 }, /* (211) groupby_opt ::= */
+  {  257,   -3 }, /* (212) groupby_opt ::= GROUP BY grouplist */
+  {  274,   -3 }, /* (213) grouplist ::= grouplist COMMA item */
+  {  274,   -1 }, /* (214) grouplist ::= item */
+  {  258,    0 }, /* (215) having_opt ::= */
+  {  258,   -2 }, /* (216) having_opt ::= HAVING expr */
+  {  261,    0 }, /* (217) limit_opt ::= */
+  {  261,   -2 }, /* (218) limit_opt ::= LIMIT signed */
+  {  261,   -4 }, /* (219) limit_opt ::= LIMIT signed OFFSET signed */
+  {  261,   -4 }, /* (220) limit_opt ::= LIMIT signed COMMA signed */
+  {  260,    0 }, /* (221) slimit_opt ::= */
+  {  260,   -2 }, /* (222) slimit_opt ::= SLIMIT signed */
+  {  260,   -4 }, /* (223) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  260,   -4 }, /* (224) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  251,    0 }, /* (225) where_opt ::= */
+  {  251,   -2 }, /* (226) where_opt ::= WHERE expr */
+  {  265,   -3 }, /* (227) expr ::= LP expr RP */
+  {  265,   -1 }, /* (228) expr ::= ID */
+  {  265,   -3 }, /* (229) expr ::= ID DOT ID */
+  {  265,   -3 }, /* (230) expr ::= ID DOT STAR */
+  {  265,   -1 }, /* (231) expr ::= INTEGER */
+  {  265,   -2 }, /* (232) expr ::= MINUS INTEGER */
+  {  265,   -2 }, /* (233) expr ::= PLUS INTEGER */
+  {  265,   -1 }, /* (234) expr ::= FLOAT */
+  {  265,   -2 }, /* (235) expr ::= MINUS FLOAT */
+  {  265,   -2 }, /* (236) expr ::= PLUS FLOAT */
+  {  265,   -1 }, /* (237) expr ::= STRING */
+  {  265,   -1 }, /* (238) expr ::= NOW */
+  {  265,   -1 }, /* (239) expr ::= VARIABLE */
+  {  265,   -2 }, /* (240) expr ::= PLUS VARIABLE */
+  {  265,   -2 }, /* (241) expr ::= MINUS VARIABLE */
+  {  265,   -1 }, /* (242) expr ::= BOOL */
+  {  265,   -1 }, /* (243) expr ::= NULL */
+  {  265,   -4 }, /* (244) expr ::= ID LP exprlist RP */
+  {  265,   -4 }, /* (245) expr ::= ID LP STAR RP */
+  {  265,   -3 }, /* (246) expr ::= expr IS NULL */
+  {  265,   -4 }, /* (247) expr ::= expr IS NOT NULL */
+  {  265,   -3 }, /* (248) expr ::= expr LT expr */
+  {  265,   -3 }, /* (249) expr ::= expr GT expr */
+  {  265,   -3 }, /* (250) expr ::= expr LE expr */
+  {  265,   -3 }, /* (251) expr ::= expr GE expr */
+  {  265,   -3 }, /* (252) expr ::= expr NE expr */
+  {  265,   -3 }, /* (253) expr ::= expr EQ expr */
+  {  265,   -5 }, /* (254) expr ::= expr BETWEEN expr AND expr */
+  {  265,   -3 }, /* (255) expr ::= expr AND expr */
+  {  265,   -3 }, /* (256) expr ::= expr OR expr */
+  {  265,   -3 }, /* (257) expr ::= expr PLUS expr */
+  {  265,   -3 }, /* (258) expr ::= expr MINUS expr */
+  {  265,   -3 }, /* (259) expr ::= expr STAR expr */
+  {  265,   -3 }, /* (260) expr ::= expr SLASH expr */
+  {  265,   -3 }, /* (261) expr ::= expr REM expr */
+  {  265,   -3 }, /* (262) expr ::= expr LIKE expr */
+  {  265,   -5 }, /* (263) expr ::= expr IN LP exprlist RP */
+  {  205,   -3 }, /* (264) exprlist ::= exprlist COMMA expritem */
+  {  205,   -1 }, /* (265) exprlist ::= expritem */
+  {  275,   -1 }, /* (266) expritem ::= expr */
+  {  275,    0 }, /* (267) expritem ::= */
+  {  197,   -3 }, /* (268) cmd ::= RESET QUERY CACHE */
+  {  197,   -3 }, /* (269) cmd ::= SYNCDB ids REPLICA */
+  {  197,   -7 }, /* (270) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  197,   -7 }, /* (271) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  197,   -7 }, /* (272) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+  {  197,   -7 }, /* (273) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  197,   -7 }, /* (274) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  197,   -8 }, /* (275) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  197,   -9 }, /* (276) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  197,   -7 }, /* (277) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+  {  197,   -7 }, /* (278) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+  {  197,   -7 }, /* (279) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+  {  197,   -7 }, /* (280) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+  {  197,   -7 }, /* (281) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+  {  197,   -7 }, /* (282) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+  {  197,   -8 }, /* (283) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+  {  197,   -9 }, /* (284) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+  {  197,   -7 }, /* (285) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+  {  197,   -3 }, /* (286) cmd ::= KILL CONNECTION INTEGER */
+  {  197,   -5 }, /* (287) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  197,   -5 }, /* (288) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2162,9 +2194,9 @@ static void yy_reduce(
 /********** Begin reduce actions **********************************************/
         YYMINORTYPE yylhsminor;
       case 0: /* program ::= cmd */
-      case 132: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==132);
-      case 133: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==133);
-      case 134: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==134);
+      case 138: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==138);
+      case 139: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==139);
+      case 140: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==140);
 {}
         break;
       case 1: /* cmd ::= SHOW DATABASES */
@@ -2173,502 +2205,516 @@ static void yy_reduce(
       case 2: /* cmd ::= SHOW TOPICS */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_TP, 0, 0);}
         break;
-      case 3: /* cmd ::= SHOW MNODES */
+      case 3: /* cmd ::= SHOW FUNCTIONS */
+{ setShowOptions(pInfo, TSDB_MGMT_TABLE_FUNCTION, 0, 0);}
+        break;
+      case 4: /* cmd ::= SHOW MNODES */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_MNODE, 0, 0);}
         break;
-      case 4: /* cmd ::= SHOW DNODES */
+      case 5: /* cmd ::= SHOW DNODES */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_DNODE, 0, 0);}
         break;
-      case 5: /* cmd ::= SHOW ACCOUNTS */
+      case 6: /* cmd ::= SHOW ACCOUNTS */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_ACCT, 0, 0);}
         break;
-      case 6: /* cmd ::= SHOW USERS */
+      case 7: /* cmd ::= SHOW USERS */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_USER, 0, 0);}
         break;
-      case 7: /* cmd ::= SHOW MODULES */
+      case 8: /* cmd ::= SHOW MODULES */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_MODULE, 0, 0);  }
         break;
-      case 8: /* cmd ::= SHOW QUERIES */
+      case 9: /* cmd ::= SHOW QUERIES */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_QUERIES, 0, 0);  }
         break;
-      case 9: /* cmd ::= SHOW CONNECTIONS */
+      case 10: /* cmd ::= SHOW CONNECTIONS */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_CONNS, 0, 0);}
         break;
-      case 10: /* cmd ::= SHOW STREAMS */
+      case 11: /* cmd ::= SHOW STREAMS */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_STREAMS, 0, 0);  }
         break;
-      case 11: /* cmd ::= SHOW VARIABLES */
+      case 12: /* cmd ::= SHOW VARIABLES */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_VARIABLES, 0, 0);  }
         break;
-      case 12: /* cmd ::= SHOW SCORES */
+      case 13: /* cmd ::= SHOW SCORES */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_SCORES, 0, 0);   }
         break;
-      case 13: /* cmd ::= SHOW GRANTS */
+      case 14: /* cmd ::= SHOW GRANTS */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_GRANTS, 0, 0);   }
         break;
-      case 14: /* cmd ::= SHOW VNODES */
+      case 15: /* cmd ::= SHOW VNODES */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, 0, 0); }
         break;
-      case 15: /* cmd ::= SHOW VNODES IPTOKEN */
+      case 16: /* cmd ::= SHOW VNODES IPTOKEN */
 { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, &yymsp[0].minor.yy0, 0); }
         break;
-      case 16: /* dbPrefix ::= */
+      case 17: /* dbPrefix ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.type = 0;}
         break;
-      case 17: /* dbPrefix ::= ids DOT */
+      case 18: /* dbPrefix ::= ids DOT */
 {yylhsminor.yy0 = yymsp[-1].minor.yy0;  }
   yymsp[-1].minor.yy0 = yylhsminor.yy0;
         break;
-      case 18: /* cpxName ::= */
+      case 19: /* cpxName ::= */
 {yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 19: /* cpxName ::= DOT ids */
+      case 20: /* cpxName ::= DOT ids */
 {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n += 1;    }
         break;
-      case 20: /* cmd ::= SHOW CREATE TABLE ids cpxName */
+      case 21: /* cmd ::= SHOW CREATE TABLE ids cpxName */
 {
    yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
    setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_TABLE, 1, &yymsp[-1].minor.yy0);
 }
         break;
-      case 21: /* cmd ::= SHOW CREATE STABLE ids cpxName */
+      case 22: /* cmd ::= SHOW CREATE STABLE ids cpxName */
 {
    yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
    setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_STABLE, 1, &yymsp[-1].minor.yy0);
 }
         break;
-      case 22: /* cmd ::= SHOW CREATE DATABASE ids */
+      case 23: /* cmd ::= SHOW CREATE DATABASE ids */
 {
   setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_DATABASE, 1, &yymsp[0].minor.yy0);
 }
         break;
-      case 23: /* cmd ::= SHOW dbPrefix TABLES */
+      case 24: /* cmd ::= SHOW dbPrefix TABLES */
 {
     setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-1].minor.yy0, 0);
 }
         break;
-      case 24: /* cmd ::= SHOW dbPrefix TABLES LIKE ids */
+      case 25: /* cmd ::= SHOW dbPrefix TABLES LIKE ids */
 {
     setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0);
 }
         break;
-      case 25: /* cmd ::= SHOW dbPrefix STABLES */
+      case 26: /* cmd ::= SHOW dbPrefix STABLES */
 {
     setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &yymsp[-1].minor.yy0, 0);
 }
         break;
-      case 26: /* cmd ::= SHOW dbPrefix STABLES LIKE ids */
+      case 27: /* cmd ::= SHOW dbPrefix STABLES LIKE ids */
 {
     SStrToken token;
     tSetDbName(&token, &yymsp[-3].minor.yy0);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &token, &yymsp[0].minor.yy0);
 }
         break;
-      case 27: /* cmd ::= SHOW dbPrefix VGROUPS */
+      case 28: /* cmd ::= SHOW dbPrefix VGROUPS */
 {
     SStrToken token;
     tSetDbName(&token, &yymsp[-1].minor.yy0);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, 0);
 }
         break;
-      case 28: /* cmd ::= SHOW dbPrefix VGROUPS ids */
+      case 29: /* cmd ::= SHOW dbPrefix VGROUPS ids */
 {
     SStrToken token;
     tSetDbName(&token, &yymsp[-2].minor.yy0);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, &yymsp[0].minor.yy0);
 }
         break;
-      case 29: /* cmd ::= DROP TABLE ifexists ids cpxName */
+      case 30: /* cmd ::= DROP TABLE ifexists ids cpxName */
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, -1, -1);
 }
         break;
-      case 30: /* cmd ::= DROP STABLE ifexists ids cpxName */
+      case 31: /* cmd ::= DROP STABLE ifexists ids cpxName */
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, -1, TSDB_SUPER_TABLE);
 }
         break;
-      case 31: /* cmd ::= DROP DATABASE ifexists ids */
+      case 32: /* cmd ::= DROP DATABASE ifexists ids */
 { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0, TSDB_DB_TYPE_DEFAULT, -1); }
         break;
-      case 32: /* cmd ::= DROP TOPIC ifexists ids */
+      case 33: /* cmd ::= DROP TOPIC ifexists ids */
 { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0, TSDB_DB_TYPE_TOPIC, -1); }
         break;
-      case 33: /* cmd ::= DROP DNODE ids */
+      case 34: /* cmd ::= DROP FUNCTION ids */
+{ setDropFuncInfo(pInfo, TSDB_SQL_DROP_FUNCTION, &yymsp[0].minor.yy0); }
+        break;
+      case 35: /* cmd ::= DROP DNODE ids */
 { setDCLSqlElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &yymsp[0].minor.yy0);    }
         break;
-      case 34: /* cmd ::= DROP USER ids */
+      case 36: /* cmd ::= DROP USER ids */
 { setDCLSqlElems(pInfo, TSDB_SQL_DROP_USER, 1, &yymsp[0].minor.yy0);     }
         break;
-      case 35: /* cmd ::= DROP ACCOUNT ids */
+      case 37: /* cmd ::= DROP ACCOUNT ids */
 { setDCLSqlElems(pInfo, TSDB_SQL_DROP_ACCT, 1, &yymsp[0].minor.yy0);  }
         break;
-      case 36: /* cmd ::= USE ids */
+      case 38: /* cmd ::= USE ids */
 { setDCLSqlElems(pInfo, TSDB_SQL_USE_DB, 1, &yymsp[0].minor.yy0);}
         break;
-      case 37: /* cmd ::= DESCRIBE ids cpxName */
+      case 39: /* cmd ::= DESCRIBE ids cpxName */
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     setDCLSqlElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &yymsp[-1].minor.yy0);
 }
         break;
-      case 38: /* cmd ::= ALTER USER ids PASS ids */
+      case 40: /* cmd ::= ALTER USER ids PASS ids */
 { setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, NULL);    }
         break;
-      case 39: /* cmd ::= ALTER USER ids PRIVILEGE ids */
+      case 41: /* cmd ::= ALTER USER ids PRIVILEGE ids */
 { setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &yymsp[-2].minor.yy0, NULL, &yymsp[0].minor.yy0);}
         break;
-      case 40: /* cmd ::= ALTER DNODE ids ids */
+      case 42: /* cmd ::= ALTER DNODE ids ids */
 { setDCLSqlElems(pInfo, TSDB_SQL_CFG_DNODE, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
-      case 41: /* cmd ::= ALTER DNODE ids ids ids */
+      case 43: /* cmd ::= ALTER DNODE ids ids ids */
 { setDCLSqlElems(pInfo, TSDB_SQL_CFG_DNODE, 3, &yymsp[-2].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);      }
         break;
-      case 42: /* cmd ::= ALTER LOCAL ids */
+      case 44: /* cmd ::= ALTER LOCAL ids */
 { setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &yymsp[0].minor.yy0);              }
         break;
-      case 43: /* cmd ::= ALTER LOCAL ids ids */
+      case 45: /* cmd ::= ALTER LOCAL ids ids */
 { setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
-      case 44: /* cmd ::= ALTER DATABASE ids alter_db_optr */
-      case 45: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==45);
-{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy382, &t);}
+      case 46: /* cmd ::= ALTER DATABASE ids alter_db_optr */
+      case 47: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==47);
+{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy214, &t);}
         break;
-      case 46: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy151);}
+      case 48: /* cmd ::= ALTER ACCOUNT ids acct_optr */
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy547);}
         break;
-      case 47: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy151);}
+      case 49: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy547);}
         break;
-      case 48: /* cmd ::= COMPACT VNODES IN LP exprlist RP */
-{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy441);}
+      case 50: /* cmd ::= COMPACT VNODES IN LP exprlist RP */
+{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy525);}
         break;
-      case 49: /* ids ::= ID */
-      case 50: /* ids ::= STRING */ yytestcase(yyruleno==50);
+      case 51: /* ids ::= ID */
+      case 52: /* ids ::= STRING */ yytestcase(yyruleno==52);
 {yylhsminor.yy0 = yymsp[0].minor.yy0; }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 51: /* ifexists ::= IF EXISTS */
+      case 53: /* ifexists ::= IF EXISTS */
 { yymsp[-1].minor.yy0.n = 1;}
         break;
-      case 52: /* ifexists ::= */
-      case 54: /* ifnotexists ::= */ yytestcase(yyruleno==54);
-      case 174: /* distinct ::= */ yytestcase(yyruleno==174);
+      case 54: /* ifexists ::= */
+      case 56: /* ifnotexists ::= */ yytestcase(yyruleno==56);
+      case 180: /* distinct ::= */ yytestcase(yyruleno==180);
 { yymsp[1].minor.yy0.n = 0;}
         break;
-      case 53: /* ifnotexists ::= IF NOT EXISTS */
+      case 55: /* ifnotexists ::= IF NOT EXISTS */
 { yymsp[-2].minor.yy0.n = 1;}
         break;
-      case 55: /* cmd ::= CREATE DNODE ids */
+      case 57: /* cmd ::= CREATE DNODE ids */
 { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
-      case 56: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy151);}
+      case 58: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy547);}
+        break;
+      case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+      case 60: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==60);
+{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy214, &yymsp[-2].minor.yy0);}
+        break;
+      case 61: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy31, &yymsp[0].minor.yy0, 1);}
         break;
-      case 57: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-      case 58: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==58);
-{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy382, &yymsp[-2].minor.yy0);}
+      case 62: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy31, &yymsp[0].minor.yy0, 2);}
         break;
-      case 59: /* cmd ::= CREATE USER ids PASS ids */
+      case 63: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
         break;
-      case 60: /* pps ::= */
-      case 62: /* tseries ::= */ yytestcase(yyruleno==62);
-      case 64: /* dbs ::= */ yytestcase(yyruleno==64);
-      case 66: /* streams ::= */ yytestcase(yyruleno==66);
-      case 68: /* storage ::= */ yytestcase(yyruleno==68);
-      case 70: /* qtime ::= */ yytestcase(yyruleno==70);
-      case 72: /* users ::= */ yytestcase(yyruleno==72);
-      case 74: /* conns ::= */ yytestcase(yyruleno==74);
-      case 76: /* state ::= */ yytestcase(yyruleno==76);
+      case 64: /* bufsize ::= */
+      case 66: /* pps ::= */ yytestcase(yyruleno==66);
+      case 68: /* tseries ::= */ yytestcase(yyruleno==68);
+      case 70: /* dbs ::= */ yytestcase(yyruleno==70);
+      case 72: /* streams ::= */ yytestcase(yyruleno==72);
+      case 74: /* storage ::= */ yytestcase(yyruleno==74);
+      case 76: /* qtime ::= */ yytestcase(yyruleno==76);
+      case 78: /* users ::= */ yytestcase(yyruleno==78);
+      case 80: /* conns ::= */ yytestcase(yyruleno==80);
+      case 82: /* state ::= */ yytestcase(yyruleno==82);
 { yymsp[1].minor.yy0.n = 0;   }
         break;
-      case 61: /* pps ::= PPS INTEGER */
-      case 63: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==63);
-      case 65: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==65);
-      case 67: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==67);
-      case 69: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==69);
-      case 71: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==71);
-      case 73: /* users ::= USERS INTEGER */ yytestcase(yyruleno==73);
-      case 75: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==75);
-      case 77: /* state ::= STATE ids */ yytestcase(yyruleno==77);
+      case 65: /* bufsize ::= BUFSIZE INTEGER */
+      case 67: /* pps ::= PPS INTEGER */ yytestcase(yyruleno==67);
+      case 69: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==69);
+      case 71: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==71);
+      case 73: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==73);
+      case 75: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==75);
+      case 77: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==77);
+      case 79: /* users ::= USERS INTEGER */ yytestcase(yyruleno==79);
+      case 81: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==81);
+      case 83: /* state ::= STATE ids */ yytestcase(yyruleno==83);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;     }
         break;
-      case 78: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-{
-    yylhsminor.yy151.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy151.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy151.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy151.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy151.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy151.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy151.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy151.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy151.stat    = yymsp[0].minor.yy0;
-}
-  yymsp[-8].minor.yy151 = yylhsminor.yy151;
-        break;
-      case 79: /* intitemlist ::= intitemlist COMMA intitem */
-      case 148: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==148);
-{ yylhsminor.yy441 = tVariantListAppend(yymsp[-2].minor.yy441, &yymsp[0].minor.yy506, -1);    }
-  yymsp[-2].minor.yy441 = yylhsminor.yy441;
-        break;
-      case 80: /* intitemlist ::= intitem */
-      case 149: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==149);
-{ yylhsminor.yy441 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1); }
-  yymsp[0].minor.yy441 = yylhsminor.yy441;
-        break;
-      case 81: /* intitem ::= INTEGER */
-      case 150: /* tagitem ::= INTEGER */ yytestcase(yyruleno==150);
-      case 151: /* tagitem ::= FLOAT */ yytestcase(yyruleno==151);
-      case 152: /* tagitem ::= STRING */ yytestcase(yyruleno==152);
-      case 153: /* tagitem ::= BOOL */ yytestcase(yyruleno==153);
+      case 84: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+{
+    yylhsminor.yy547.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+    yylhsminor.yy547.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+    yylhsminor.yy547.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy547.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy547.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy547.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy547.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy547.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy547.stat    = yymsp[0].minor.yy0;
+}
+  yymsp[-8].minor.yy547 = yylhsminor.yy547;
+        break;
+      case 85: /* intitemlist ::= intitemlist COMMA intitem */
+      case 154: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==154);
+{ yylhsminor.yy525 = tVariantListAppend(yymsp[-2].minor.yy525, &yymsp[0].minor.yy506, -1);    }
+  yymsp[-2].minor.yy525 = yylhsminor.yy525;
+        break;
+      case 86: /* intitemlist ::= intitem */
+      case 155: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==155);
+{ yylhsminor.yy525 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1); }
+  yymsp[0].minor.yy525 = yylhsminor.yy525;
+        break;
+      case 87: /* intitem ::= INTEGER */
+      case 156: /* tagitem ::= INTEGER */ yytestcase(yyruleno==156);
+      case 157: /* tagitem ::= FLOAT */ yytestcase(yyruleno==157);
+      case 158: /* tagitem ::= STRING */ yytestcase(yyruleno==158);
+      case 159: /* tagitem ::= BOOL */ yytestcase(yyruleno==159);
 { toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy506 = yylhsminor.yy506;
         break;
-      case 82: /* keep ::= KEEP intitemlist */
-{ yymsp[-1].minor.yy441 = yymsp[0].minor.yy441; }
-        break;
-      case 83: /* cache ::= CACHE INTEGER */
-      case 84: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==84);
-      case 85: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==85);
-      case 86: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==86);
-      case 87: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==87);
-      case 88: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==88);
-      case 89: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==89);
-      case 90: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==90);
-      case 91: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==91);
-      case 92: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==92);
-      case 93: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==93);
-      case 94: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==94);
-      case 95: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==95);
-      case 96: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==96);
-      case 97: /* partitions ::= PARTITIONS INTEGER */ yytestcase(yyruleno==97);
+      case 88: /* keep ::= KEEP intitemlist */
+{ yymsp[-1].minor.yy525 = yymsp[0].minor.yy525; }
+        break;
+      case 89: /* cache ::= CACHE INTEGER */
+      case 90: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==90);
+      case 91: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==91);
+      case 92: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==92);
+      case 93: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==93);
+      case 94: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==94);
+      case 95: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==95);
+      case 96: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==96);
+      case 97: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==97);
+      case 98: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==98);
+      case 99: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==99);
+      case 100: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==100);
+      case 101: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==101);
+      case 102: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==102);
+      case 103: /* partitions ::= PARTITIONS INTEGER */ yytestcase(yyruleno==103);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
-      case 98: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy382); yymsp[1].minor.yy382.dbType = TSDB_DB_TYPE_DEFAULT;}
+      case 104: /* db_optr ::= */
+{setDefaultCreateDbOption(&yymsp[1].minor.yy214); yymsp[1].minor.yy214.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
-      case 99: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 105: /* db_optr ::= db_optr cache */
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 100: /* db_optr ::= db_optr replica */
-      case 117: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==117);
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 106: /* db_optr ::= db_optr replica */
+      case 123: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==123);
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 101: /* db_optr ::= db_optr quorum */
-      case 118: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==118);
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 107: /* db_optr ::= db_optr quorum */
+      case 124: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==124);
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 102: /* db_optr ::= db_optr days */
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 108: /* db_optr ::= db_optr days */
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 103: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 109: /* db_optr ::= db_optr minrows */
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 104: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 110: /* db_optr ::= db_optr maxrows */
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 105: /* db_optr ::= db_optr blocks */
-      case 120: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==120);
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 111: /* db_optr ::= db_optr blocks */
+      case 126: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==126);
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 106: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 112: /* db_optr ::= db_optr ctime */
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 107: /* db_optr ::= db_optr wal */
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 113: /* db_optr ::= db_optr wal */
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 108: /* db_optr ::= db_optr fsync */
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 114: /* db_optr ::= db_optr fsync */
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 109: /* db_optr ::= db_optr comp */
-      case 121: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==121);
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 115: /* db_optr ::= db_optr comp */
+      case 127: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==127);
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 110: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 116: /* db_optr ::= db_optr prec */
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.precision = yymsp[0].minor.yy0; }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 111: /* db_optr ::= db_optr keep */
-      case 119: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==119);
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.keep = yymsp[0].minor.yy441; }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 117: /* db_optr ::= db_optr keep */
+      case 125: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==125);
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.keep = yymsp[0].minor.yy525; }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 112: /* db_optr ::= db_optr update */
-      case 122: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==122);
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 118: /* db_optr ::= db_optr update */
+      case 128: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==128);
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 113: /* db_optr ::= db_optr cachelast */
-      case 123: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==123);
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 119: /* db_optr ::= db_optr cachelast */
+      case 129: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==129);
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 114: /* topic_optr ::= db_optr */
-      case 124: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==124);
-{ yylhsminor.yy382 = yymsp[0].minor.yy382; yylhsminor.yy382.dbType = TSDB_DB_TYPE_TOPIC; }
-  yymsp[0].minor.yy382 = yylhsminor.yy382;
+      case 120: /* topic_optr ::= db_optr */
+      case 130: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==130);
+{ yylhsminor.yy214 = yymsp[0].minor.yy214; yylhsminor.yy214.dbType = TSDB_DB_TYPE_TOPIC; }
+  yymsp[0].minor.yy214 = yylhsminor.yy214;
         break;
-      case 115: /* topic_optr ::= topic_optr partitions */
-      case 125: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==125);
-{ yylhsminor.yy382 = yymsp[-1].minor.yy382; yylhsminor.yy382.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy382 = yylhsminor.yy382;
+      case 121: /* topic_optr ::= topic_optr partitions */
+      case 131: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==131);
+{ yylhsminor.yy214 = yymsp[-1].minor.yy214; yylhsminor.yy214.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy214 = yylhsminor.yy214;
         break;
-      case 116: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy382); yymsp[1].minor.yy382.dbType = TSDB_DB_TYPE_DEFAULT;}
+      case 122: /* alter_db_optr ::= */
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy214); yymsp[1].minor.yy214.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
-      case 126: /* typename ::= ids */
+      case 132: /* typename ::= ids */
 { 
   yymsp[0].minor.yy0.type = 0;
-  tSetColumnType (&yylhsminor.yy343, &yymsp[0].minor.yy0);
+  tSetColumnType (&yylhsminor.yy31, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy343 = yylhsminor.yy343;
+  yymsp[0].minor.yy31 = yylhsminor.yy31;
         break;
-      case 127: /* typename ::= ids LP signed RP */
+      case 133: /* typename ::= ids LP signed RP */
 {
-  if (yymsp[-1].minor.yy369 <= 0) {
+  if (yymsp[-1].minor.yy501 <= 0) {
     yymsp[-3].minor.yy0.type = 0;
-    tSetColumnType(&yylhsminor.yy343, &yymsp[-3].minor.yy0);
+    tSetColumnType(&yylhsminor.yy31, &yymsp[-3].minor.yy0);
   } else {
-    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy369;  // negative value of name length
-    tSetColumnType(&yylhsminor.yy343, &yymsp[-3].minor.yy0);
+    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy501;  // negative value of name length
+    tSetColumnType(&yylhsminor.yy31, &yymsp[-3].minor.yy0);
   }
 }
-  yymsp[-3].minor.yy343 = yylhsminor.yy343;
+  yymsp[-3].minor.yy31 = yylhsminor.yy31;
         break;
-      case 128: /* typename ::= ids UNSIGNED */
+      case 134: /* typename ::= ids UNSIGNED */
 {
   yymsp[-1].minor.yy0.type = 0;
   yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z);
-  tSetColumnType (&yylhsminor.yy343, &yymsp[-1].minor.yy0);
+  tSetColumnType (&yylhsminor.yy31, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy343 = yylhsminor.yy343;
+  yymsp[-1].minor.yy31 = yylhsminor.yy31;
         break;
-      case 129: /* signed ::= INTEGER */
-{ yylhsminor.yy369 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy369 = yylhsminor.yy369;
+      case 135: /* signed ::= INTEGER */
+{ yylhsminor.yy501 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[0].minor.yy501 = yylhsminor.yy501;
         break;
-      case 130: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy369 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+      case 136: /* signed ::= PLUS INTEGER */
+{ yymsp[-1].minor.yy501 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
-      case 131: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy369 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+      case 137: /* signed ::= MINUS INTEGER */
+{ yymsp[-1].minor.yy501 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
-      case 135: /* cmd ::= CREATE TABLE create_table_list */
-{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy182;}
+      case 141: /* cmd ::= CREATE TABLE create_table_list */
+{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy158;}
         break;
-      case 136: /* create_table_list ::= create_from_stable */
+      case 142: /* create_table_list ::= create_from_stable */
 {
   SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql));
   pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
 
-  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy456);
+  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy432);
   pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
-  yylhsminor.yy182 = pCreateTable;
+  yylhsminor.yy158 = pCreateTable;
 }
-  yymsp[0].minor.yy182 = yylhsminor.yy182;
+  yymsp[0].minor.yy158 = yylhsminor.yy158;
         break;
-      case 137: /* create_table_list ::= create_table_list create_from_stable */
+      case 143: /* create_table_list ::= create_table_list create_from_stable */
 {
-  taosArrayPush(yymsp[-1].minor.yy182->childTableInfo, &yymsp[0].minor.yy456);
-  yylhsminor.yy182 = yymsp[-1].minor.yy182;
+  taosArrayPush(yymsp[-1].minor.yy158->childTableInfo, &yymsp[0].minor.yy432);
+  yylhsminor.yy158 = yymsp[-1].minor.yy158;
 }
-  yymsp[-1].minor.yy182 = yylhsminor.yy182;
+  yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 138: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+      case 144: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
 {
-  yylhsminor.yy182 = tSetCreateTableInfo(yymsp[-1].minor.yy441, NULL, NULL, TSQL_CREATE_TABLE);
-  setSqlInfo(pInfo, yylhsminor.yy182, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy158 = tSetCreateTableInfo(yymsp[-1].minor.yy525, NULL, NULL, TSQL_CREATE_TABLE);
+  setSqlInfo(pInfo, yylhsminor.yy158, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0);
 }
-  yymsp[-5].minor.yy182 = yylhsminor.yy182;
+  yymsp[-5].minor.yy158 = yylhsminor.yy158;
         break;
-      case 139: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+      case 145: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
 {
-  yylhsminor.yy182 = tSetCreateTableInfo(yymsp[-5].minor.yy441, yymsp[-1].minor.yy441, NULL, TSQL_CREATE_STABLE);
-  setSqlInfo(pInfo, yylhsminor.yy182, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy158 = tSetCreateTableInfo(yymsp[-5].minor.yy525, yymsp[-1].minor.yy525, NULL, TSQL_CREATE_STABLE);
+  setSqlInfo(pInfo, yylhsminor.yy158, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy182 = yylhsminor.yy182;
+  yymsp[-9].minor.yy158 = yylhsminor.yy158;
         break;
-      case 140: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+      case 146: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
 {
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
-  yylhsminor.yy456 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy441, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+  yylhsminor.yy432 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy525, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy456 = yylhsminor.yy456;
+  yymsp[-9].minor.yy432 = yylhsminor.yy432;
         break;
-      case 141: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+      case 147: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
 {
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n;
-  yylhsminor.yy456 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy441, yymsp[-1].minor.yy441, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
+  yylhsminor.yy432 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy525, yymsp[-1].minor.yy525, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
 }
-  yymsp[-12].minor.yy456 = yylhsminor.yy456;
+  yymsp[-12].minor.yy432 = yylhsminor.yy432;
         break;
-      case 142: /* tagNamelist ::= tagNamelist COMMA ids */
-{taosArrayPush(yymsp[-2].minor.yy441, &yymsp[0].minor.yy0); yylhsminor.yy441 = yymsp[-2].minor.yy441;  }
-  yymsp[-2].minor.yy441 = yylhsminor.yy441;
+      case 148: /* tagNamelist ::= tagNamelist COMMA ids */
+{taosArrayPush(yymsp[-2].minor.yy525, &yymsp[0].minor.yy0); yylhsminor.yy525 = yymsp[-2].minor.yy525;  }
+  yymsp[-2].minor.yy525 = yylhsminor.yy525;
         break;
-      case 143: /* tagNamelist ::= ids */
-{yylhsminor.yy441 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy441, &yymsp[0].minor.yy0);}
-  yymsp[0].minor.yy441 = yylhsminor.yy441;
+      case 149: /* tagNamelist ::= ids */
+{yylhsminor.yy525 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy525, &yymsp[0].minor.yy0);}
+  yymsp[0].minor.yy525 = yylhsminor.yy525;
         break;
-      case 144: /* create_table_args ::= ifnotexists ids cpxName AS select */
+      case 150: /* create_table_args ::= ifnotexists ids cpxName AS select */
 {
-  yylhsminor.yy182 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy236, TSQL_CREATE_STREAM);
-  setSqlInfo(pInfo, yylhsminor.yy182, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy158 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy464, TSQL_CREATE_STREAM);
+  setSqlInfo(pInfo, yylhsminor.yy158, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-3].minor.yy0.n += yymsp[-2].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-3].minor.yy0, &yymsp[-4].minor.yy0);
 }
-  yymsp[-4].minor.yy182 = yylhsminor.yy182;
+  yymsp[-4].minor.yy158 = yylhsminor.yy158;
         break;
-      case 145: /* columnlist ::= columnlist COMMA column */
-{taosArrayPush(yymsp[-2].minor.yy441, &yymsp[0].minor.yy343); yylhsminor.yy441 = yymsp[-2].minor.yy441;  }
-  yymsp[-2].minor.yy441 = yylhsminor.yy441;
+      case 151: /* columnlist ::= columnlist COMMA column */
+{taosArrayPush(yymsp[-2].minor.yy525, &yymsp[0].minor.yy31); yylhsminor.yy525 = yymsp[-2].minor.yy525;  }
+  yymsp[-2].minor.yy525 = yylhsminor.yy525;
         break;
-      case 146: /* columnlist ::= column */
-{yylhsminor.yy441 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy441, &yymsp[0].minor.yy343);}
-  yymsp[0].minor.yy441 = yylhsminor.yy441;
+      case 152: /* columnlist ::= column */
+{yylhsminor.yy525 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy525, &yymsp[0].minor.yy31);}
+  yymsp[0].minor.yy525 = yylhsminor.yy525;
         break;
-      case 147: /* column ::= ids typename */
+      case 153: /* column ::= ids typename */
 {
-  tSetColumnInfo(&yylhsminor.yy343, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy343);
+  tSetColumnInfo(&yylhsminor.yy31, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy31);
 }
-  yymsp[-1].minor.yy343 = yylhsminor.yy343;
+  yymsp[-1].minor.yy31 = yylhsminor.yy31;
         break;
-      case 154: /* tagitem ::= NULL */
+      case 160: /* tagitem ::= NULL */
 { yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy506 = yylhsminor.yy506;
         break;
-      case 155: /* tagitem ::= NOW */
+      case 161: /* tagitem ::= NOW */
 { yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0);}
   yymsp[0].minor.yy506 = yylhsminor.yy506;
         break;
-      case 156: /* tagitem ::= MINUS INTEGER */
-      case 157: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==157);
-      case 158: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==158);
-      case 159: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==159);
+      case 162: /* tagitem ::= MINUS INTEGER */
+      case 163: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==163);
+      case 164: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==164);
+      case 165: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==165);
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
@@ -2677,179 +2723,179 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy506 = yylhsminor.yy506;
         break;
-      case 160: /* select ::= SELECT selcollist from where_opt interval_opt session_option windowstate_option fill_opt sliding_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+      case 166: /* select ::= SELECT selcollist from where_opt interval_opt session_option windowstate_option fill_opt sliding_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy236 = tSetQuerySqlNode(&yymsp[-13].minor.yy0, yymsp[-12].minor.yy441, yymsp[-11].minor.yy244, yymsp[-10].minor.yy166, yymsp[-4].minor.yy441, yymsp[-2].minor.yy441, &yymsp[-9].minor.yy340, &yymsp[-8].minor.yy259, &yymsp[-7].minor.yy348, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy441, &yymsp[0].minor.yy414, &yymsp[-1].minor.yy414, yymsp[-3].minor.yy166);
+  yylhsminor.yy464 = tSetQuerySqlNode(&yymsp[-13].minor.yy0, yymsp[-12].minor.yy525, yymsp[-11].minor.yy412, yymsp[-10].minor.yy370, yymsp[-4].minor.yy525, yymsp[-2].minor.yy525, &yymsp[-9].minor.yy520, &yymsp[-8].minor.yy259, &yymsp[-7].minor.yy144, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy525, &yymsp[0].minor.yy126, &yymsp[-1].minor.yy126, yymsp[-3].minor.yy370);
 }
-  yymsp[-13].minor.yy236 = yylhsminor.yy236;
+  yymsp[-13].minor.yy464 = yylhsminor.yy464;
         break;
-      case 161: /* select ::= LP select RP */
-{yymsp[-2].minor.yy236 = yymsp[-1].minor.yy236;}
+      case 167: /* select ::= LP select RP */
+{yymsp[-2].minor.yy464 = yymsp[-1].minor.yy464;}
         break;
-      case 162: /* union ::= select */
-{ yylhsminor.yy441 = setSubclause(NULL, yymsp[0].minor.yy236); }
-  yymsp[0].minor.yy441 = yylhsminor.yy441;
+      case 168: /* union ::= select */
+{ yylhsminor.yy525 = setSubclause(NULL, yymsp[0].minor.yy464); }
+  yymsp[0].minor.yy525 = yylhsminor.yy525;
         break;
-      case 163: /* union ::= union UNION ALL select */
-{ yylhsminor.yy441 = appendSelectClause(yymsp[-3].minor.yy441, yymsp[0].minor.yy236); }
-  yymsp[-3].minor.yy441 = yylhsminor.yy441;
+      case 169: /* union ::= union UNION ALL select */
+{ yylhsminor.yy525 = appendSelectClause(yymsp[-3].minor.yy525, yymsp[0].minor.yy464); }
+  yymsp[-3].minor.yy525 = yylhsminor.yy525;
         break;
-      case 164: /* cmd ::= union */
-{ setSqlInfo(pInfo, yymsp[0].minor.yy441, NULL, TSDB_SQL_SELECT); }
+      case 170: /* cmd ::= union */
+{ setSqlInfo(pInfo, yymsp[0].minor.yy525, NULL, TSDB_SQL_SELECT); }
         break;
-      case 165: /* select ::= SELECT selcollist */
+      case 171: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy236 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy441, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy464 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy525, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy236 = yylhsminor.yy236;
+  yymsp[-1].minor.yy464 = yylhsminor.yy464;
         break;
-      case 166: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy441 = yymsp[-1].minor.yy441;}
-  yymsp[-1].minor.yy441 = yylhsminor.yy441;
+      case 172: /* sclp ::= selcollist COMMA */
+{yylhsminor.yy525 = yymsp[-1].minor.yy525;}
+  yymsp[-1].minor.yy525 = yylhsminor.yy525;
         break;
-      case 167: /* sclp ::= */
-      case 197: /* orderby_opt ::= */ yytestcase(yyruleno==197);
-{yymsp[1].minor.yy441 = 0;}
+      case 173: /* sclp ::= */
+      case 203: /* orderby_opt ::= */ yytestcase(yyruleno==203);
+{yymsp[1].minor.yy525 = 0;}
         break;
-      case 168: /* selcollist ::= sclp distinct expr as */
+      case 174: /* selcollist ::= sclp distinct expr as */
 {
-   yylhsminor.yy441 = tSqlExprListAppend(yymsp[-3].minor.yy441, yymsp[-1].minor.yy166,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+   yylhsminor.yy525 = tSqlExprListAppend(yymsp[-3].minor.yy525, yymsp[-1].minor.yy370,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-3].minor.yy441 = yylhsminor.yy441;
+  yymsp[-3].minor.yy525 = yylhsminor.yy525;
         break;
-      case 169: /* selcollist ::= sclp STAR */
+      case 175: /* selcollist ::= sclp STAR */
 {
    tSqlExpr *pNode = tSqlExprCreateIdValue(NULL, TK_ALL);
-   yylhsminor.yy441 = tSqlExprListAppend(yymsp[-1].minor.yy441, pNode, 0, 0);
+   yylhsminor.yy525 = tSqlExprListAppend(yymsp[-1].minor.yy525, pNode, 0, 0);
 }
-  yymsp[-1].minor.yy441 = yylhsminor.yy441;
+  yymsp[-1].minor.yy525 = yylhsminor.yy525;
         break;
-      case 170: /* as ::= AS ids */
+      case 176: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
         break;
-      case 171: /* as ::= ids */
+      case 177: /* as ::= ids */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;    }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 172: /* as ::= */
+      case 178: /* as ::= */
 { yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 173: /* distinct ::= DISTINCT */
+      case 179: /* distinct ::= DISTINCT */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;  }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 175: /* from ::= FROM tablelist */
-      case 176: /* from ::= FROM sub */ yytestcase(yyruleno==176);
-{yymsp[-1].minor.yy244 = yymsp[0].minor.yy244;}
+      case 181: /* from ::= FROM tablelist */
+      case 182: /* from ::= FROM sub */ yytestcase(yyruleno==182);
+{yymsp[-1].minor.yy412 = yymsp[0].minor.yy412;}
         break;
-      case 177: /* sub ::= LP union RP */
-{yymsp[-2].minor.yy244 = addSubqueryElem(NULL, yymsp[-1].minor.yy441, NULL);}
+      case 183: /* sub ::= LP union RP */
+{yymsp[-2].minor.yy412 = addSubqueryElem(NULL, yymsp[-1].minor.yy525, NULL);}
         break;
-      case 178: /* sub ::= LP union RP ids */
-{yymsp[-3].minor.yy244 = addSubqueryElem(NULL, yymsp[-2].minor.yy441, &yymsp[0].minor.yy0);}
+      case 184: /* sub ::= LP union RP ids */
+{yymsp[-3].minor.yy412 = addSubqueryElem(NULL, yymsp[-2].minor.yy525, &yymsp[0].minor.yy0);}
         break;
-      case 179: /* sub ::= sub COMMA LP union RP ids */
-{yylhsminor.yy244 = addSubqueryElem(yymsp[-5].minor.yy244, yymsp[-2].minor.yy441, &yymsp[0].minor.yy0);}
-  yymsp[-5].minor.yy244 = yylhsminor.yy244;
+      case 185: /* sub ::= sub COMMA LP union RP ids */
+{yylhsminor.yy412 = addSubqueryElem(yymsp[-5].minor.yy412, yymsp[-2].minor.yy525, &yymsp[0].minor.yy0);}
+  yymsp[-5].minor.yy412 = yylhsminor.yy412;
         break;
-      case 180: /* tablelist ::= ids cpxName */
+      case 186: /* tablelist ::= ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy244 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy412 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-1].minor.yy244 = yylhsminor.yy244;
+  yymsp[-1].minor.yy412 = yylhsminor.yy412;
         break;
-      case 181: /* tablelist ::= ids cpxName ids */
+      case 187: /* tablelist ::= ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy244 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy412 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-2].minor.yy244 = yylhsminor.yy244;
+  yymsp[-2].minor.yy412 = yylhsminor.yy412;
         break;
-      case 182: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 188: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy244 = setTableNameList(yymsp[-3].minor.yy244, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy412 = setTableNameList(yymsp[-3].minor.yy412, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-3].minor.yy244 = yylhsminor.yy244;
+  yymsp[-3].minor.yy412 = yylhsminor.yy412;
         break;
-      case 183: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 189: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy244 = setTableNameList(yymsp[-4].minor.yy244, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy412 = setTableNameList(yymsp[-4].minor.yy412, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-4].minor.yy244 = yylhsminor.yy244;
+  yymsp[-4].minor.yy412 = yylhsminor.yy412;
         break;
-      case 184: /* tmvar ::= VARIABLE */
+      case 190: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 185: /* interval_opt ::= INTERVAL LP tmvar RP */
-{yymsp[-3].minor.yy340.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy340.offset.n = 0;}
+      case 191: /* interval_opt ::= INTERVAL LP tmvar RP */
+{yymsp[-3].minor.yy520.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy520.offset.n = 0;}
         break;
-      case 186: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-{yymsp[-5].minor.yy340.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy340.offset = yymsp[-1].minor.yy0;}
+      case 192: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+{yymsp[-5].minor.yy520.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy520.offset = yymsp[-1].minor.yy0;}
         break;
-      case 187: /* interval_opt ::= */
-{memset(&yymsp[1].minor.yy340, 0, sizeof(yymsp[1].minor.yy340));}
+      case 193: /* interval_opt ::= */
+{memset(&yymsp[1].minor.yy520, 0, sizeof(yymsp[1].minor.yy520));}
         break;
-      case 188: /* session_option ::= */
+      case 194: /* session_option ::= */
 {yymsp[1].minor.yy259.col.n = 0; yymsp[1].minor.yy259.gap.n = 0;}
         break;
-      case 189: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+      case 195: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
 {
    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
    yymsp[-6].minor.yy259.col = yymsp[-4].minor.yy0;
    yymsp[-6].minor.yy259.gap = yymsp[-1].minor.yy0;
 }
         break;
-      case 190: /* windowstate_option ::= */
-{ yymsp[1].minor.yy348.col.n = 0; yymsp[1].minor.yy348.col.z = NULL;}
+      case 196: /* windowstate_option ::= */
+{ yymsp[1].minor.yy144.col.n = 0; yymsp[1].minor.yy144.col.z = NULL;}
         break;
-      case 191: /* windowstate_option ::= STATE_WINDOW LP ids RP */
-{ yymsp[-3].minor.yy348.col = yymsp[-1].minor.yy0; }
+      case 197: /* windowstate_option ::= STATE_WINDOW LP ids RP */
+{ yymsp[-3].minor.yy144.col = yymsp[-1].minor.yy0; }
         break;
-      case 192: /* fill_opt ::= */
-{ yymsp[1].minor.yy441 = 0;     }
+      case 198: /* fill_opt ::= */
+{ yymsp[1].minor.yy525 = 0;     }
         break;
-      case 193: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 199: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
     tVariant A = {0};
     toTSDBType(yymsp[-3].minor.yy0.type);
     tVariantCreate(&A, &yymsp[-3].minor.yy0);
 
-    tVariantListInsert(yymsp[-1].minor.yy441, &A, -1, 0);
-    yymsp[-5].minor.yy441 = yymsp[-1].minor.yy441;
+    tVariantListInsert(yymsp[-1].minor.yy525, &A, -1, 0);
+    yymsp[-5].minor.yy525 = yymsp[-1].minor.yy525;
 }
         break;
-      case 194: /* fill_opt ::= FILL LP ID RP */
+      case 200: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy441 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+    yymsp[-3].minor.yy525 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 195: /* sliding_opt ::= SLIDING LP tmvar RP */
+      case 201: /* sliding_opt ::= SLIDING LP tmvar RP */
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 196: /* sliding_opt ::= */
+      case 202: /* sliding_opt ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 198: /* orderby_opt ::= ORDER BY sortlist */
-{yymsp[-2].minor.yy441 = yymsp[0].minor.yy441;}
+      case 204: /* orderby_opt ::= ORDER BY sortlist */
+{yymsp[-2].minor.yy525 = yymsp[0].minor.yy525;}
         break;
-      case 199: /* sortlist ::= sortlist COMMA item sortorder */
+      case 205: /* sortlist ::= sortlist COMMA item sortorder */
 {
-    yylhsminor.yy441 = tVariantListAppend(yymsp[-3].minor.yy441, &yymsp[-1].minor.yy506, yymsp[0].minor.yy112);
+    yylhsminor.yy525 = tVariantListAppend(yymsp[-3].minor.yy525, &yymsp[-1].minor.yy506, yymsp[0].minor.yy52);
 }
-  yymsp[-3].minor.yy441 = yylhsminor.yy441;
+  yymsp[-3].minor.yy525 = yylhsminor.yy525;
         break;
-      case 200: /* sortlist ::= item sortorder */
+      case 206: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy441 = tVariantListAppend(NULL, &yymsp[-1].minor.yy506, yymsp[0].minor.yy112);
+  yylhsminor.yy525 = tVariantListAppend(NULL, &yymsp[-1].minor.yy506, yymsp[0].minor.yy52);
 }
-  yymsp[-1].minor.yy441 = yylhsminor.yy441;
+  yymsp[-1].minor.yy525 = yylhsminor.yy525;
         break;
-      case 201: /* item ::= ids cpxName */
+      case 207: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
@@ -2858,227 +2904,227 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy506 = yylhsminor.yy506;
         break;
-      case 202: /* sortorder ::= ASC */
-{ yymsp[0].minor.yy112 = TSDB_ORDER_ASC; }
+      case 208: /* sortorder ::= ASC */
+{ yymsp[0].minor.yy52 = TSDB_ORDER_ASC; }
         break;
-      case 203: /* sortorder ::= DESC */
-{ yymsp[0].minor.yy112 = TSDB_ORDER_DESC;}
+      case 209: /* sortorder ::= DESC */
+{ yymsp[0].minor.yy52 = TSDB_ORDER_DESC;}
         break;
-      case 204: /* sortorder ::= */
-{ yymsp[1].minor.yy112 = TSDB_ORDER_ASC; }
+      case 210: /* sortorder ::= */
+{ yymsp[1].minor.yy52 = TSDB_ORDER_ASC; }
         break;
-      case 205: /* groupby_opt ::= */
-{ yymsp[1].minor.yy441 = 0;}
+      case 211: /* groupby_opt ::= */
+{ yymsp[1].minor.yy525 = 0;}
         break;
-      case 206: /* groupby_opt ::= GROUP BY grouplist */
-{ yymsp[-2].minor.yy441 = yymsp[0].minor.yy441;}
+      case 212: /* groupby_opt ::= GROUP BY grouplist */
+{ yymsp[-2].minor.yy525 = yymsp[0].minor.yy525;}
         break;
-      case 207: /* grouplist ::= grouplist COMMA item */
+      case 213: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy441 = tVariantListAppend(yymsp[-2].minor.yy441, &yymsp[0].minor.yy506, -1);
+  yylhsminor.yy525 = tVariantListAppend(yymsp[-2].minor.yy525, &yymsp[0].minor.yy506, -1);
 }
-  yymsp[-2].minor.yy441 = yylhsminor.yy441;
+  yymsp[-2].minor.yy525 = yylhsminor.yy525;
         break;
-      case 208: /* grouplist ::= item */
+      case 214: /* grouplist ::= item */
 {
-  yylhsminor.yy441 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1);
+  yylhsminor.yy525 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1);
 }
-  yymsp[0].minor.yy441 = yylhsminor.yy441;
+  yymsp[0].minor.yy525 = yylhsminor.yy525;
         break;
-      case 209: /* having_opt ::= */
-      case 219: /* where_opt ::= */ yytestcase(yyruleno==219);
-      case 261: /* expritem ::= */ yytestcase(yyruleno==261);
-{yymsp[1].minor.yy166 = 0;}
+      case 215: /* having_opt ::= */
+      case 225: /* where_opt ::= */ yytestcase(yyruleno==225);
+      case 267: /* expritem ::= */ yytestcase(yyruleno==267);
+{yymsp[1].minor.yy370 = 0;}
         break;
-      case 210: /* having_opt ::= HAVING expr */
-      case 220: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==220);
-{yymsp[-1].minor.yy166 = yymsp[0].minor.yy166;}
+      case 216: /* having_opt ::= HAVING expr */
+      case 226: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==226);
+{yymsp[-1].minor.yy370 = yymsp[0].minor.yy370;}
         break;
-      case 211: /* limit_opt ::= */
-      case 215: /* slimit_opt ::= */ yytestcase(yyruleno==215);
-{yymsp[1].minor.yy414.limit = -1; yymsp[1].minor.yy414.offset = 0;}
+      case 217: /* limit_opt ::= */
+      case 221: /* slimit_opt ::= */ yytestcase(yyruleno==221);
+{yymsp[1].minor.yy126.limit = -1; yymsp[1].minor.yy126.offset = 0;}
         break;
-      case 212: /* limit_opt ::= LIMIT signed */
-      case 216: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==216);
-{yymsp[-1].minor.yy414.limit = yymsp[0].minor.yy369;  yymsp[-1].minor.yy414.offset = 0;}
+      case 218: /* limit_opt ::= LIMIT signed */
+      case 222: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==222);
+{yymsp[-1].minor.yy126.limit = yymsp[0].minor.yy501;  yymsp[-1].minor.yy126.offset = 0;}
         break;
-      case 213: /* limit_opt ::= LIMIT signed OFFSET signed */
-{ yymsp[-3].minor.yy414.limit = yymsp[-2].minor.yy369;  yymsp[-3].minor.yy414.offset = yymsp[0].minor.yy369;}
+      case 219: /* limit_opt ::= LIMIT signed OFFSET signed */
+{ yymsp[-3].minor.yy126.limit = yymsp[-2].minor.yy501;  yymsp[-3].minor.yy126.offset = yymsp[0].minor.yy501;}
         break;
-      case 214: /* limit_opt ::= LIMIT signed COMMA signed */
-{ yymsp[-3].minor.yy414.limit = yymsp[0].minor.yy369;  yymsp[-3].minor.yy414.offset = yymsp[-2].minor.yy369;}
+      case 220: /* limit_opt ::= LIMIT signed COMMA signed */
+{ yymsp[-3].minor.yy126.limit = yymsp[0].minor.yy501;  yymsp[-3].minor.yy126.offset = yymsp[-2].minor.yy501;}
         break;
-      case 217: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
-{yymsp[-3].minor.yy414.limit = yymsp[-2].minor.yy369;  yymsp[-3].minor.yy414.offset = yymsp[0].minor.yy369;}
+      case 223: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
+{yymsp[-3].minor.yy126.limit = yymsp[-2].minor.yy501;  yymsp[-3].minor.yy126.offset = yymsp[0].minor.yy501;}
         break;
-      case 218: /* slimit_opt ::= SLIMIT signed COMMA signed */
-{yymsp[-3].minor.yy414.limit = yymsp[0].minor.yy369;  yymsp[-3].minor.yy414.offset = yymsp[-2].minor.yy369;}
+      case 224: /* slimit_opt ::= SLIMIT signed COMMA signed */
+{yymsp[-3].minor.yy126.limit = yymsp[0].minor.yy501;  yymsp[-3].minor.yy126.offset = yymsp[-2].minor.yy501;}
         break;
-      case 221: /* expr ::= LP expr RP */
-{yylhsminor.yy166 = yymsp[-1].minor.yy166; yylhsminor.yy166->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy166->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 227: /* expr ::= LP expr RP */
+{yylhsminor.yy370 = yymsp[-1].minor.yy370; yylhsminor.yy370->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy370->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 222: /* expr ::= ID */
-{ yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 228: /* expr ::= ID */
+{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy370 = yylhsminor.yy370;
         break;
-      case 223: /* expr ::= ID DOT ID */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 229: /* expr ::= ID DOT ID */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 224: /* expr ::= ID DOT STAR */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 230: /* expr ::= ID DOT STAR */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 225: /* expr ::= INTEGER */
-{ yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 231: /* expr ::= INTEGER */
+{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy370 = yylhsminor.yy370;
         break;
-      case 226: /* expr ::= MINUS INTEGER */
-      case 227: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==227);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy166 = yylhsminor.yy166;
+      case 232: /* expr ::= MINUS INTEGER */
+      case 233: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==233);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy370 = yylhsminor.yy370;
         break;
-      case 228: /* expr ::= FLOAT */
-{ yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 234: /* expr ::= FLOAT */
+{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy370 = yylhsminor.yy370;
         break;
-      case 229: /* expr ::= MINUS FLOAT */
-      case 230: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==230);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy166 = yylhsminor.yy166;
+      case 235: /* expr ::= MINUS FLOAT */
+      case 236: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==236);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);}
+  yymsp[-1].minor.yy370 = yylhsminor.yy370;
         break;
-      case 231: /* expr ::= STRING */
-{ yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 237: /* expr ::= STRING */
+{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy370 = yylhsminor.yy370;
         break;
-      case 232: /* expr ::= NOW */
-{ yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 238: /* expr ::= NOW */
+{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy370 = yylhsminor.yy370;
         break;
-      case 233: /* expr ::= VARIABLE */
-{ yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 239: /* expr ::= VARIABLE */
+{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy370 = yylhsminor.yy370;
         break;
-      case 234: /* expr ::= PLUS VARIABLE */
-      case 235: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==235);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);}
-  yymsp[-1].minor.yy166 = yylhsminor.yy166;
+      case 240: /* expr ::= PLUS VARIABLE */
+      case 241: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==241);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);}
+  yymsp[-1].minor.yy370 = yylhsminor.yy370;
         break;
-      case 236: /* expr ::= BOOL */
-{ yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 242: /* expr ::= BOOL */
+{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy370 = yylhsminor.yy370;
         break;
-      case 237: /* expr ::= NULL */
-{ yylhsminor.yy166 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);}
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 243: /* expr ::= NULL */
+{ yylhsminor.yy370 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);}
+  yymsp[0].minor.yy370 = yylhsminor.yy370;
         break;
-      case 238: /* expr ::= ID LP exprlist RP */
-{ yylhsminor.yy166 = tSqlExprCreateFunction(yymsp[-1].minor.yy441, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy166 = yylhsminor.yy166;
+      case 244: /* expr ::= ID LP exprlist RP */
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy370 = tSqlExprCreateFunction(yymsp[-1].minor.yy525, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy370 = yylhsminor.yy370;
         break;
-      case 239: /* expr ::= ID LP STAR RP */
-{ yylhsminor.yy166 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy166 = yylhsminor.yy166;
+      case 245: /* expr ::= ID LP STAR RP */
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy370 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy370 = yylhsminor.yy370;
         break;
-      case 240: /* expr ::= expr IS NULL */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, NULL, TK_ISNULL);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 246: /* expr ::= expr IS NULL */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, NULL, TK_ISNULL);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 241: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-3].minor.yy166, NULL, TK_NOTNULL);}
-  yymsp[-3].minor.yy166 = yylhsminor.yy166;
+      case 247: /* expr ::= expr IS NOT NULL */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-3].minor.yy370, NULL, TK_NOTNULL);}
+  yymsp[-3].minor.yy370 = yylhsminor.yy370;
         break;
-      case 242: /* expr ::= expr LT expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_LT);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 248: /* expr ::= expr LT expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_LT);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 243: /* expr ::= expr GT expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_GT);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 249: /* expr ::= expr GT expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_GT);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 244: /* expr ::= expr LE expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_LE);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 250: /* expr ::= expr LE expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_LE);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 245: /* expr ::= expr GE expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_GE);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 251: /* expr ::= expr GE expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_GE);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 246: /* expr ::= expr NE expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_NE);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 252: /* expr ::= expr NE expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_NE);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 247: /* expr ::= expr EQ expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_EQ);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 253: /* expr ::= expr EQ expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_EQ);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 248: /* expr ::= expr BETWEEN expr AND expr */
-{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy166); yylhsminor.yy166 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy166, yymsp[-2].minor.yy166, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy166, TK_LE), TK_AND);}
-  yymsp[-4].minor.yy166 = yylhsminor.yy166;
+      case 254: /* expr ::= expr BETWEEN expr AND expr */
+{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy370); yylhsminor.yy370 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy370, yymsp[-2].minor.yy370, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy370, TK_LE), TK_AND);}
+  yymsp[-4].minor.yy370 = yylhsminor.yy370;
         break;
-      case 249: /* expr ::= expr AND expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_AND);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 255: /* expr ::= expr AND expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_AND);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 250: /* expr ::= expr OR expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_OR); }
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 256: /* expr ::= expr OR expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_OR); }
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 251: /* expr ::= expr PLUS expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_PLUS);  }
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 257: /* expr ::= expr PLUS expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_PLUS);  }
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 252: /* expr ::= expr MINUS expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_MINUS); }
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 258: /* expr ::= expr MINUS expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_MINUS); }
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 253: /* expr ::= expr STAR expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_STAR);  }
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 259: /* expr ::= expr STAR expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_STAR);  }
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 254: /* expr ::= expr SLASH expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_DIVIDE);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 260: /* expr ::= expr SLASH expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_DIVIDE);}
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 255: /* expr ::= expr REM expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_REM);   }
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 261: /* expr ::= expr REM expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_REM);   }
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 256: /* expr ::= expr LIKE expr */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-2].minor.yy166, yymsp[0].minor.yy166, TK_LIKE);  }
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 262: /* expr ::= expr LIKE expr */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-2].minor.yy370, yymsp[0].minor.yy370, TK_LIKE);  }
+  yymsp[-2].minor.yy370 = yylhsminor.yy370;
         break;
-      case 257: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy166 = tSqlExprCreate(yymsp[-4].minor.yy166, (tSqlExpr*)yymsp[-1].minor.yy441, TK_IN); }
-  yymsp[-4].minor.yy166 = yylhsminor.yy166;
+      case 263: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy370 = tSqlExprCreate(yymsp[-4].minor.yy370, (tSqlExpr*)yymsp[-1].minor.yy525, TK_IN); }
+  yymsp[-4].minor.yy370 = yylhsminor.yy370;
         break;
-      case 258: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy441 = tSqlExprListAppend(yymsp[-2].minor.yy441,yymsp[0].minor.yy166,0, 0);}
-  yymsp[-2].minor.yy441 = yylhsminor.yy441;
+      case 264: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy525 = tSqlExprListAppend(yymsp[-2].minor.yy525,yymsp[0].minor.yy370,0, 0);}
+  yymsp[-2].minor.yy525 = yylhsminor.yy525;
         break;
-      case 259: /* exprlist ::= expritem */
-{yylhsminor.yy441 = tSqlExprListAppend(0,yymsp[0].minor.yy166,0, 0);}
-  yymsp[0].minor.yy441 = yylhsminor.yy441;
+      case 265: /* exprlist ::= expritem */
+{yylhsminor.yy525 = tSqlExprListAppend(0,yymsp[0].minor.yy370,0, 0);}
+  yymsp[0].minor.yy525 = yylhsminor.yy525;
         break;
-      case 260: /* expritem ::= expr */
-{yylhsminor.yy166 = yymsp[0].minor.yy166;}
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 266: /* expritem ::= expr */
+{yylhsminor.yy370 = yymsp[0].minor.yy370;}
+  yymsp[0].minor.yy370 = yylhsminor.yy370;
         break;
-      case 262: /* cmd ::= RESET QUERY CACHE */
+      case 268: /* cmd ::= RESET QUERY CACHE */
 { setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 263: /* cmd ::= SYNCDB ids REPLICA */
+      case 269: /* cmd ::= SYNCDB ids REPLICA */
 { setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);}
         break;
-      case 264: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 270: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy441, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 265: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 271: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3089,21 +3135,21 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 266: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+      case 272: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy441, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 267: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 273: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy441, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 268: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 274: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3114,7 +3160,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 269: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 275: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3128,7 +3174,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 270: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 276: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
@@ -3140,21 +3186,21 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 271: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+      case 277: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy441, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 272: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+      case 278: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy441, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 273: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+      case 279: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3165,21 +3211,21 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 274: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+      case 280: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy441, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 275: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+      case 281: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy441, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 276: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+      case 282: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3190,7 +3236,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 277: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+      case 283: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3204,7 +3250,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 278: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+      case 284: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
@@ -3216,20 +3262,20 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 279: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+      case 285: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy441, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 280: /* cmd ::= KILL CONNECTION INTEGER */
+      case 286: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 281: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 287: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);}
         break;
-      case 282: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 288: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
         break;
       default:

src/util/src/terror.c

@@ -109,11 +109,12 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TSC_SQL_SYNTAX_ERROR,         "Syntax error in SQL")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DB_NOT_SELECTED,          "Database not specified or available")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TABLE_NAME,       "Table does not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_EXCEED_SQL_LIMIT,         "SQL statement too long, check maxSQLLength config")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_FILE_EMPTY,               "File is empty")
 
 // mnode
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_MSG_NOT_PROCESSED,        "Message not processed")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_IN_PROGRESS,       "Message is progressing")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_NEED_REPROCESSED,  "Messag need to be reprocessed")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_NEED_REPROCESSED,  "Message need to be reprocessed")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_RIGHTS,                "Insufficient privilege for operation")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_APP_ERROR,                "Unexpected generic error in mnode")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CONNECTION,       "Invalid message connection")
@@ -183,6 +184,13 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_NOT_EXIST,          "Field does not exist"
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STABLE_NAME,      "Super table does not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CREATE_TABLE_MSG, "Invalid create table message")
 
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_NAME,        "Invalid func name")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_LEN,         "Invalid func length")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_CODE,        "Invalid func code")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_FUNC_ALREADY_EXIST,       "Func already exists")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC,             "Invalid func")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_BUFSIZE,     "Invalid func bufSize")
+
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_SELECTED,          "Database not specified or available")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_ALREADY_EXIST,         "Database already exists")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION,        "Invalid database options")
@@ -269,6 +277,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_QRY_IN_EXEC,                  "Multiple retrieval of
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW,      "Too many time window in query")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_NOT_ENOUGH_BUFFER,        "Query buffer limit has reached")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INCONSISTAN,              "File inconsistance in replica")
+TAOS_DEFINE_ERROR(TSDB_CODE_QRY_SYS_ERROR,                "System error")
 
 
 // grant

src/util/src/tskiplist.c

@@ -546,7 +546,6 @@ static FORCE_INLINE int32_t getSkipListNodeRandomHeight(SSkipList *pSkipList) {
   const uint32_t factor = 4;
 
   int32_t n = 1;
-
 #if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
   while ((rand() % factor) == 0 && n <= pSkipList->maxLevel) {
 #else

src/util/src/ttokenizer.c

@@ -220,7 +220,12 @@ static SKeyword keywordTable[] = {
     {"TOPIC",        TK_TOPIC},
     {"TOPICS",       TK_TOPICS},
     {"COMPACT",      TK_COMPACT},
-    {"MODIFY",       TK_MODIFY}
+    {"MODIFY",       TK_MODIFY},
+    {"FUNCTION",     TK_FUNCTION},
+    {"FUNCTIONS",    TK_FUNCTIONS},
+    {"OUTPUTTYPE",   TK_OUTPUTTYPE},
+    {"AGGREGATE",    TK_AGGREGATE},
+    {"BUFSIZE",      TK_BUFSIZE},
 };
 
 static const char isIdChar[] = {

src/vnode/src/vnodeRead.c

@@ -231,7 +231,7 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
   if (contLen != 0) {
     qinfo_t pQInfo = NULL;
     uint64_t qId = genQueryId();
-    code = qCreateQueryInfo(pVnode->tsdb, pVnode->vgId, pQueryTableMsg, &pQInfo, &qId);
+    code = qCreateQueryInfo(pVnode->tsdb, pVnode->vgId, pQueryTableMsg, &pQInfo, qId);
 
     SQueryTableRsp *pRsp = (SQueryTableRsp *)rpcMallocCont(sizeof(SQueryTableRsp));
     pRsp->code = code;

tests/examples/c/CMakeLists.txt

@@ -8,13 +8,13 @@ IF (TD_LINUX)
   ADD_EXECUTABLE(subscribe subscribe.c)
   TARGET_LINK_LIBRARIES(subscribe taos_static trpc tutil pthread )
   ADD_EXECUTABLE(epoll epoll.c)
-  TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread )
+  TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
 ENDIF ()
 IF (TD_DARWIN)
   INCLUDE_DIRECTORIES(. ${TD_COMMUNITY_DIR}/src/inc ${TD_COMMUNITY_DIR}/src/client/inc  ${TD_COMMUNITY_DIR}/inc)
   AUX_SOURCE_DIRECTORY(. SRC)
   ADD_EXECUTABLE(demo demo.c)
-  TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread )
+  TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread lua)
   ADD_EXECUTABLE(epoll epoll.c)
-  TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread )
+  TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
 ENDIF ()

tests/script/general/parser/testSuite.sim

@@ -12,7 +12,7 @@ run general/parser/create_tb.sim
 run general/parser/dbtbnameValidate.sim
 run general/parser/fill.sim
 run general/parser/fill_stb.sim
-run general/parser/fill_us.sim
+#run general/parser/fill_us.sim               #
 run general/parser/first_last.sim
 run general/parser/import_commit1.sim
 run general/parser/import_commit2.sim
@@ -39,7 +39,6 @@ run general/parser/slimit1.sim
 run general/parser/slimit_alter_tags.sim
 run general/parser/tbnameIn.sim
 run general/parser/join.sim
-#run general/parser/join_multitables.sim
 run general/parser/join_multivnode.sim
 run general/parser/join_manyblocks.sim
 run general/parser/projection_limit_offset.sim
@@ -61,5 +60,9 @@ run general/parser/slimit_alter_tags.sim
 run general/parser/binary_escapeCharacter.sim
 run general/parser/between_and.sim
 run general/parser/last_cache.sim
+run general/parser/slimit_alter_tags.sim
+run general/parser/udf.sim
+run general/parser/udf_dll.sim
+run general/parser/udf_dll_stable.sim
 run general/parser/nestquery.sim
 run general/parser/precision_ns.sim

tests/script/general/parser/udf.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
+system sh/exec.sh -n dnode1 -s start
+system sh/prepare_udf.sh
+
+sleep 100
+sql connect
+print ======================== dnode1 start
+
+sql create function n01 as '/tmp/normal' outputtype int;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n01 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != INT then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n01;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+sql create function n02 as '/tmp/normal' outputtype bool;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n02 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != BOOL then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n02;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+sql create function n03 as '/tmp/normal' outputtype TINYINT;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n03 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != TINYINT then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n03;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+
+sql create function n04 as '/tmp/normal' outputtype SMALLINT;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n04 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != SMALLINT then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n04;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+
+
+sql create function n05 as '/tmp/normal' outputtype INT;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n05 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != INT then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n05;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+
+
+
+
+
+
+sql create function n06 as '/tmp/normal' outputtype BIGINT;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n06 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != BIGINT then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n06;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+
+
+
+
+sql create function n07 as '/tmp/normal' outputtype FLOAT;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n07 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != FLOAT then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n07;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+
+
+
+sql create function n08 as '/tmp/normal' outputtype DOUBLE;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n08 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != DOUBLE then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n08;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+
+
+
+sql create function n09 as '/tmp/normal' outputtype BINARY;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n09 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != BINARY(0) then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n09;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+sql create function n10 as '/tmp/normal' outputtype BINARY(10);
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n10 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != BINARY(10) then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n10;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+sql create function n11 as '/tmp/normal' outputtype TIMESTAMP;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n11 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != TIMESTAMP then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n11;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+sql create function n12 as '/tmp/normal' outputtype NCHAR;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n12 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != NCHAR(0) then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n12;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+sql create function n13 as '/tmp/normal' outputtype NCHAR(10);
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n13 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data03 != NCHAR(10) then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n13;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+sql create function n14 as '/tmp/normal' outputtype TINYINT UNSIGNED;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n14 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n14;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+sql create function n15 as '/tmp/normal' outputtype SMALLINT UNSIGNED;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n15 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n15;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+sql create function n16 as '/tmp/normal' outputtype INT UNSIGNED;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n16 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n16;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+sql create function n17 as '/tmp/normal' outputtype BIGINT UNSIGNED;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n17 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 0 then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n17;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+sql create aggregate function n18 as '/tmp/normal' outputtype BIGINT UNSIGNED;
+sql show functions;
+if $rows != 1 then
+  return -1
+endi
+
+
+if $data00 != n18 then 
+  return -1
+endi
+if $data01 != /tmp/normal then 
+  return -1
+endi
+if $data02 != 1 then 
+  return -1
+endi
+if $data05 != 5 then 
+  return -1
+endi
+
+sql drop function n18;
+
+sql show functions;
+if $rows != 0 then
+  return -1
+endi
+
+
+
+sql create function t01 as '/tmp/normal' outputtype INT;
+sql_error create function t01 as '/tmp/normal' outputtype SMALLINT;
+sql drop function t01;
+sql create function t01 as '/tmp/normal' outputtype INT;
+sql create function t02 as '/tmp/normal' outputtype SMALLINT;
+sql show functions;
+if $rows != 2 then
+  return -1
+endi
+
+
+
+
+
+
+sql_error create function e1 as '/tmp/normal';
+sql_error create function e2 as '/tmp/normal' outputtype;
+sql_error create function e3 as '/tmp/normal' a;
+sql_error create function e4 as '/tmp/normal' outputtype a;
+sql_error create function e5 as '/tmp/normal' outputtype bool int;
+sql_error create function as '/tmp/normal' outputtype;
+sql_error create function e6 as '/tmp/empty' outputtype int;
+sql_error create function e7 as '/tmp/big' outputtype int;
+sql_error create function e8 as '/tmp/noexistfile' outputtype int;
+sql_error create function e0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456 as '/tmp/normal' outputtype int;
+sql_error create function e9 as outputtype int;
+
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/general/parser/udf_dll.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
+system sh/exec.sh -n dnode1 -s start
+system sh/prepare_udf.sh
+
+sleep 100
+sql connect
+print ======================== dnode1 start
+
+sql create function add_one as '/tmp/add_one.so' outputtype int;
+sql create aggregate function sum_double as '/tmp/sum_double.so' outputtype int;
+sql show functions;
+if $rows != 2 then
+  return -1
+endi
+
+sql create database db;
+sql use db;
+sql create table tb1 (ts timestamp, f1 int, f2 bool, f3 binary(10));
+sql insert into tb1 values ('2021-03-23 17:17:19.660', 1, true, 'tb1-1');
+sql insert into tb1 values ('2021-03-23 19:23:28.595', 2, false, 'tb1-2');
+sql insert into tb1 values ('2021-03-23 19:33:39.070', 3, true, 'tb1-3');
+sql insert into tb1 values ('2021-03-23 19:34:37.670', 4, false, 'tb1-4');
+sql insert into tb1 values ('2021-03-24 19:08:06.609', 5, true, 'tb1-5');
+sql insert into tb1 values ('2021-03-24 19:26:38.231', 6, false, 'tb1-6');
+sql insert into tb1 values ('2021-03-25 10:03:17.688', 7, true, 'tb1-7');
+
+sql select add_one(f1) from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data10 != 3 then 
+   return -1
+endi
+if $data20 != 4 then 
+   return -1
+endi
+if $data30 != 5 then 
+   return -1
+endi
+if $data40 != 6 then 
+   return -1
+endi
+if $data50 != 7 then 
+   return -1
+endi
+if $data60 != 8 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from tb1;
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 56 then 
+   return -1
+endi
+
+
+sql select ts,add_one(f1),f1 from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:17:19.660@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data02 != 1 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:23:28.595@ then 
+   return -1
+endi
+if $data11 != 3 then 
+   return -1
+endi
+if $data12 != 2 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data22 != 3 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:34:37.670@ then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data32 != 4 then 
+   return -1
+endi
+if $data40 != @21-03-24 19:08:06.609@ then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data42 != 5 then 
+   return -1
+endi
+if $data50 != @21-03-24 19:26:38.231@ then 
+   return -1
+endi
+if $data51 != 7 then 
+   return -1
+endi
+if $data52 != 6 then 
+   return -1
+endi
+if $data60 != @21-03-25 10:03:17.688@ then 
+   return -1
+endi
+if $data61 != 8 then 
+   return -1
+endi
+if $data62 != 7 then 
+   return -1
+endi
+
+
+
+
+sql select add_one(f1),add_one(f1) from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != 3 then 
+   return -1
+endi
+if $data11 != 3 then 
+   return -1
+endi
+if $data20 != 4 then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data30 != 5 then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data40 != 6 then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data50 != 7 then 
+   return -1
+endi
+if $data51 != 7 then 
+   return -1
+endi
+if $data60 != 8 then 
+   return -1
+endi
+if $data61 != 8 then 
+   return -1
+endi
+
+
+sql select add_one(f1)+1 from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 3.000000000 then 
+   return -1
+endi
+if $data10 != 4.000000000 then 
+   return -1
+endi
+if $data20 != 5.000000000 then 
+   return -1
+endi
+if $data30 != 6.000000000 then 
+   return -1
+endi
+if $data40 != 7.000000000 then 
+   return -1
+endi
+if $data50 != 8.000000000 then 
+   return -1
+endi
+if $data60 != 9.000000000 then 
+   return -1
+endi
+
+
+sql select sum_double(f1)+1 from tb1;
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 57.000000000 then 
+   return -1
+endi
+
+
+sql select add_one(f1)+1,f1 from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 3.000000000 then 
+   return -1
+endi
+if $data01 != 1 then 
+   return -1
+endi
+if $data10 != 4.000000000 then 
+   return -1
+endi
+if $data11 != 2 then 
+   return -1
+endi
+if $data20 != 5.000000000 then 
+   return -1
+endi
+if $data21 != 3 then 
+   return -1
+endi
+if $data30 != 6.000000000 then 
+   return -1
+endi
+if $data31 != 4 then 
+   return -1
+endi
+if $data40 != 7.000000000 then 
+   return -1
+endi
+if $data41 != 5 then 
+   return -1
+endi
+if $data50 != 8.000000000 then 
+   return -1
+endi
+if $data51 != 6 then 
+   return -1
+endi
+if $data60 != 9.000000000 then 
+   return -1
+endi
+if $data61 != 7 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from tb1 interval (10a);
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:17:19.660@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:23:28.590@ then 
+   return -1
+endi
+if $data11 != 4 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data21 != 6 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:34:37.670@ then 
+   return -1
+endi
+if $data31 != 8 then 
+   return -1
+endi
+if $data40 != @21-03-24 19:08:06.600@ then 
+   return -1
+endi
+if $data41 != 10 then 
+   return -1
+endi
+if $data50 != @21-03-24 19:26:38.230@ then 
+   return -1
+endi
+if $data51 != 12 then 
+   return -1
+endi
+if $data60 != @21-03-25 10:03:17.680@ then 
+   return -1
+endi
+if $data61 != 14 then 
+   return -1
+endi
+
+sql select ts,add_one(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000";
+if $rows != 6 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:17:19.660@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:23:28.595@ then 
+   return -1
+endi
+if $data11 != 3 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:34:37.670@ then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data40 != @21-03-24 19:08:06.609@ then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data50 != @21-03-24 19:26:38.231@ then 
+   return -1
+endi
+if $data51 != 7 then 
+   return -1
+endi
+
+sql select sum_double(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000" interval (1h);
+if $rows != 3 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:00:00.000@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:00:00.000@ then 
+   return -1
+endi
+if $data11 != 18 then 
+   return -1
+endi
+if $data20 != @21-03-24 19:00:00.000@ then 
+   return -1
+endi
+if $data21 != 22 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000" interval (1h) fill(value,999);
+if $rows != 28 then
+  return -1
+endi
+
+sql_error select add_one(f1) from tb1 group by f1;
+
+sql select sum_double(f1) from tb1 group by f1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data10 != 4 then 
+   return -1
+endi
+if $data20 != 6 then 
+   return -1
+endi
+if $data30 != 8 then 
+   return -1
+endi
+if $data40 != 10 then 
+   return -1
+endi
+if $data50 != 12 then 
+   return -1
+endi
+if $data60 != 14 then 
+   return -1
+endi
+
+sql select sum_double(f1) from tb1 interval (1h) order by ts desc;
+if $rows != 4 then
+  return -1
+endi
+
+if $data00 != @21-03-25 10:00:00.000@ then 
+   return -1
+endi
+if $data01 != 14 then 
+   return -1
+endi
+if $data10 != @21-03-24 19:00:00.000@ then 
+   return -1
+endi
+if $data11 != 22 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:00:00.000@ then 
+   return -1
+endi
+if $data21 != 18 then 
+   return -1
+endi
+if $data30 != @21-03-23 17:00:00.000@ then 
+   return -1
+endi
+if $data31 != 2 then 
+   return -1
+endi
+
+
+sql select add_one(f1) from tb1 limit 2;
+if $rows != 2 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data10 != 3 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from tb1 interval (1d) limit 2;
+if $rows != 2 then
+  return -1
+endi
+
+if $data00 != @21-03-23 00:00:00.000@ then 
+   return -1
+endi
+if $data01 != 20 then 
+   return -1
+endi
+if $data10 != @21-03-24 00:00:00.000@ then 
+   return -1
+endi
+if $data11 != 22 then 
+   return -1
+endi
+
+
+sql_error select ts,sum_double(f1),f1 from tb1;
+sql_error select add_one(f1),count(f1) from tb1;
+sql_error select sum_double(f1),count(f1) from tb1;
+sql_error select add_one(f1),top(f1,3) from tb1;
+sql_error select add_one(f1) from tb1 interval(10a);
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/general/parser/udf_dll_stable.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 1
+system sh/exec.sh -n dnode1 -s start
+system sh/prepare_udf.sh
+
+sleep 100
+sql connect
+print ======================== dnode1 start
+
+sql create function add_one as '/tmp/add_one.so' outputtype int;
+sql create aggregate function sum_double as '/tmp/sum_double.so' outputtype int;
+sql show functions;
+if $rows != 2 then
+  return -1
+endi
+
+sql create database db;
+sql use db;
+sql create stable stb1 (ts timestamp, f1 int, f2 bool, f3 binary(10)) tags(id1 int);
+sql create table tb1 using stb1 tags(1);
+sql insert into tb1 values ('2021-03-23 17:17:19.660', 1, true, 'tb1-1');
+sql insert into tb1 values ('2021-03-23 19:23:28.595', 2, false, 'tb1-2');
+sql insert into tb1 values ('2021-03-23 19:33:39.070', 3, true, 'tb1-3');
+sql insert into tb1 values ('2021-03-23 19:34:37.670', 4, false, 'tb1-4');
+sql insert into tb1 values ('2021-03-24 19:08:06.609', 5, true, 'tb1-5');
+sql insert into tb1 values ('2021-03-24 19:26:38.231', 6, false, 'tb1-6');
+sql insert into tb1 values ('2021-03-25 10:03:17.688', 7, true, 'tb1-7');
+sql create table tb2 using stb1 tags(2);
+sql create table tb3 using stb1 tags(3);
+sql create table tb4 using stb1 tags(4);
+sql create table tb5 using stb1 tags(5);
+sql create table tb6 using stb1 tags(6);
+sql create table tb7 using stb1 tags(7);
+sql create table tb8 using stb1 tags(8);
+sql create table tb9 using stb1 tags(9);
+sql insert into tb2 values ('2021-03-03 17:17:19.660', 1, true, 'tb2-1');
+sql insert into tb2 values ('2021-03-13 19:23:28.595', 2, false, 'tb2-2');
+sql insert into tb3 values ('2021-03-23 19:33:39.070', 3, true, 'tb3-1');
+sql insert into tb3 values ('2021-03-24 19:34:37.670', 4, false, 'tb3-2');
+sql insert into tb5 values ('2021-03-25 19:08:06.609', 1, true, 'tb5-1');
+sql insert into tb5 values ('2021-04-01 19:26:38.231', 2, false, 'tb5-2');
+sql insert into tb5 values ('2021-04-08 10:03:17.688', 3, true, 'tb5-3');
+sql insert into tb6 values ('2021-04-08 11:03:17.688', 1, true, 'tb6-1');
+sql insert into tb6 values ('2021-04-08 12:03:17.688', 2, true, 'tb6-2');
+sql insert into tb9 values ('2021-04-08 16:03:17.688', 4, true, 'tb9-1');
+
+sql select add_one(f1) from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data10 != 3 then 
+   return -1
+endi
+if $data20 != 4 then 
+   return -1
+endi
+if $data30 != 5 then 
+   return -1
+endi
+if $data40 != 6 then 
+   return -1
+endi
+if $data50 != 7 then 
+   return -1
+endi
+if $data60 != 8 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from tb1;
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 56 then 
+   return -1
+endi
+
+
+sql select ts,add_one(f1),f1 from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:17:19.660@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data02 != 1 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:23:28.595@ then 
+   return -1
+endi
+if $data11 != 3 then 
+   return -1
+endi
+if $data12 != 2 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data22 != 3 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:34:37.670@ then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data32 != 4 then 
+   return -1
+endi
+if $data40 != @21-03-24 19:08:06.609@ then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data42 != 5 then 
+   return -1
+endi
+if $data50 != @21-03-24 19:26:38.231@ then 
+   return -1
+endi
+if $data51 != 7 then 
+   return -1
+endi
+if $data52 != 6 then 
+   return -1
+endi
+if $data60 != @21-03-25 10:03:17.688@ then 
+   return -1
+endi
+if $data61 != 8 then 
+   return -1
+endi
+if $data62 != 7 then 
+   return -1
+endi
+
+
+
+
+sql select add_one(f1),add_one(f1) from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != 3 then 
+   return -1
+endi
+if $data11 != 3 then 
+   return -1
+endi
+if $data20 != 4 then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data30 != 5 then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data40 != 6 then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data50 != 7 then 
+   return -1
+endi
+if $data51 != 7 then 
+   return -1
+endi
+if $data60 != 8 then 
+   return -1
+endi
+if $data61 != 8 then 
+   return -1
+endi
+
+
+sql select add_one(f1)+1 from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 3.000000000 then 
+   return -1
+endi
+if $data10 != 4.000000000 then 
+   return -1
+endi
+if $data20 != 5.000000000 then 
+   return -1
+endi
+if $data30 != 6.000000000 then 
+   return -1
+endi
+if $data40 != 7.000000000 then 
+   return -1
+endi
+if $data50 != 8.000000000 then 
+   return -1
+endi
+if $data60 != 9.000000000 then 
+   return -1
+endi
+
+
+sql select sum_double(f1)+1 from tb1;
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 57.000000000 then 
+   return -1
+endi
+
+
+sql select add_one(f1)+1,f1 from tb1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 3.000000000 then 
+   return -1
+endi
+if $data01 != 1 then 
+   return -1
+endi
+if $data10 != 4.000000000 then 
+   return -1
+endi
+if $data11 != 2 then 
+   return -1
+endi
+if $data20 != 5.000000000 then 
+   return -1
+endi
+if $data21 != 3 then 
+   return -1
+endi
+if $data30 != 6.000000000 then 
+   return -1
+endi
+if $data31 != 4 then 
+   return -1
+endi
+if $data40 != 7.000000000 then 
+   return -1
+endi
+if $data41 != 5 then 
+   return -1
+endi
+if $data50 != 8.000000000 then 
+   return -1
+endi
+if $data51 != 6 then 
+   return -1
+endi
+if $data60 != 9.000000000 then 
+   return -1
+endi
+if $data61 != 7 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from tb1 interval (10a);
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:17:19.660@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:23:28.590@ then 
+   return -1
+endi
+if $data11 != 4 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data21 != 6 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:34:37.670@ then 
+   return -1
+endi
+if $data31 != 8 then 
+   return -1
+endi
+if $data40 != @21-03-24 19:08:06.600@ then 
+   return -1
+endi
+if $data41 != 10 then 
+   return -1
+endi
+if $data50 != @21-03-24 19:26:38.230@ then 
+   return -1
+endi
+if $data51 != 12 then 
+   return -1
+endi
+if $data60 != @21-03-25 10:03:17.680@ then 
+   return -1
+endi
+if $data61 != 14 then 
+   return -1
+endi
+
+sql select ts,add_one(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000";
+if $rows != 6 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:17:19.660@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:23:28.595@ then 
+   return -1
+endi
+if $data11 != 3 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:34:37.670@ then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data40 != @21-03-24 19:08:06.609@ then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data50 != @21-03-24 19:26:38.231@ then 
+   return -1
+endi
+if $data51 != 7 then 
+   return -1
+endi
+
+sql select sum_double(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000" interval (1h);
+if $rows != 3 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:00:00.000@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:00:00.000@ then 
+   return -1
+endi
+if $data11 != 18 then 
+   return -1
+endi
+if $data20 != @21-03-24 19:00:00.000@ then 
+   return -1
+endi
+if $data21 != 22 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000" interval (1h) fill(value,999);
+if $rows != 28 then
+  return -1
+endi
+
+sql_error select add_one(f1) from tb1 group by f1;
+
+sql select sum_double(f1) from tb1 group by f1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data10 != 4 then 
+   return -1
+endi
+if $data20 != 6 then 
+   return -1
+endi
+if $data30 != 8 then 
+   return -1
+endi
+if $data40 != 10 then 
+   return -1
+endi
+if $data50 != 12 then 
+   return -1
+endi
+if $data60 != 14 then 
+   return -1
+endi
+
+sql select sum_double(f1) from tb1 interval (1h) order by ts desc;
+if $rows != 4 then
+  return -1
+endi
+
+if $data00 != @21-03-25 10:00:00.000@ then 
+   return -1
+endi
+if $data01 != 14 then 
+   return -1
+endi
+if $data10 != @21-03-24 19:00:00.000@ then 
+   return -1
+endi
+if $data11 != 22 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:00:00.000@ then 
+   return -1
+endi
+if $data21 != 18 then 
+   return -1
+endi
+if $data30 != @21-03-23 17:00:00.000@ then 
+   return -1
+endi
+if $data31 != 2 then 
+   return -1
+endi
+
+
+sql select add_one(f1) from tb1 limit 2;
+if $rows != 2 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data10 != 3 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from tb1 interval (1d) limit 2;
+if $rows != 2 then
+  return -1
+endi
+
+if $data00 != @21-03-23 00:00:00.000@ then 
+   return -1
+endi
+if $data01 != 20 then 
+   return -1
+endi
+if $data10 != @21-03-24 00:00:00.000@ then 
+   return -1
+endi
+if $data11 != 22 then 
+   return -1
+endi
+
+
+sql_error select ts,sum_double(f1),f1 from tb1;
+sql_error select add_one(f1),count(f1) from tb1;
+sql_error select sum_double(f1),count(f1) from tb1;
+sql_error select add_one(f1),top(f1,3) from tb1;
+sql_error select add_one(f1) from tb1 interval(10a);
+
+
+sql select add_one(f1) from stb1;
+if $rows != 17 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data10 != 3 then 
+   return -1
+endi
+if $data20 != 4 then 
+   return -1
+endi
+if $data30 != 5 then 
+   return -1
+endi
+if $data40 != 6 then 
+   return -1
+endi
+if $data50 != 7 then 
+   return -1
+endi
+if $data60 != 8 then 
+   return -1
+endi
+if $data70 != 2 then 
+   return -1
+endi
+if $data80 != 3 then 
+   return -1
+endi
+if $data90 != 4 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from stb1;
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 102 then 
+   return -1
+endi
+
+
+sql select ts,add_one(f1),f1 from stb1;
+if $rows != 17 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:17:19.660@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data02 != 1 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:23:28.595@ then 
+   return -1
+endi
+if $data11 != 3 then 
+   return -1
+endi
+if $data12 != 2 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data22 != 3 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:34:37.670@ then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data32 != 4 then 
+   return -1
+endi
+if $data40 != @21-03-24 19:08:06.609@ then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data42 != 5 then 
+   return -1
+endi
+if $data50 != @21-03-24 19:26:38.231@ then 
+   return -1
+endi
+if $data51 != 7 then 
+   return -1
+endi
+if $data52 != 6 then 
+   return -1
+endi
+if $data60 != @21-03-25 10:03:17.688@ then 
+   return -1
+endi
+if $data61 != 8 then 
+   return -1
+endi
+if $data62 != 7 then 
+   return -1
+endi
+
+
+
+
+sql select add_one(f1),add_one(f1) from stb1;
+if $rows != 17 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != 3 then 
+   return -1
+endi
+if $data11 != 3 then 
+   return -1
+endi
+if $data20 != 4 then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data30 != 5 then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data40 != 6 then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data50 != 7 then 
+   return -1
+endi
+if $data51 != 7 then 
+   return -1
+endi
+if $data60 != 8 then 
+   return -1
+endi
+if $data61 != 8 then 
+   return -1
+endi
+
+sql select add_one(f1)+1 from stb1;
+if $rows != 17 then
+  return -1
+endi
+
+if $data00 != 3.000000000 then 
+   return -1
+endi
+if $data10 != 4.000000000 then 
+   return -1
+endi
+if $data20 != 5.000000000 then 
+   return -1
+endi
+if $data30 != 6.000000000 then 
+   return -1
+endi
+if $data40 != 7.000000000 then 
+   return -1
+endi
+if $data50 != 8.000000000 then 
+   return -1
+endi
+if $data60 != 9.000000000 then 
+   return -1
+endi
+
+
+sql select sum_double(f1)+1 from stb1;
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 103.000000000 then 
+   return -1
+endi
+
+
+sql select add_one(f1)+1,f1 from stb1;
+if $rows != 17 then
+  return -1
+endi
+
+if $data00 != 3.000000000 then 
+   return -1
+endi
+if $data01 != 1 then 
+   return -1
+endi
+if $data10 != 4.000000000 then 
+   return -1
+endi
+if $data11 != 2 then 
+   return -1
+endi
+if $data20 != 5.000000000 then 
+   return -1
+endi
+if $data21 != 3 then 
+   return -1
+endi
+if $data30 != 6.000000000 then 
+   return -1
+endi
+if $data31 != 4 then 
+   return -1
+endi
+if $data40 != 7.000000000 then 
+   return -1
+endi
+if $data41 != 5 then 
+   return -1
+endi
+if $data50 != 8.000000000 then 
+   return -1
+endi
+if $data51 != 6 then 
+   return -1
+endi
+if $data60 != 9.000000000 then 
+   return -1
+endi
+if $data61 != 7 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from stb1 interval (10a);
+if $rows != 16 then
+  return -1
+endi
+
+if $data00 != @21-03-03 17:17:19.660@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-13 19:23:28.590@ then 
+   return -1
+endi
+if $data11 != 4 then 
+   return -1
+endi
+if $data20 != @21-03-23 17:17:19.660@ then 
+   return -1
+endi
+if $data21 != 2 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:23:28.590@ then 
+   return -1
+endi
+if $data31 != 4 then 
+   return -1
+endi
+if $data40 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data41 != 12 then 
+   return -1
+endi
+if $data50 != @21-03-23 19:34:37.670@ then 
+   return -1
+endi
+if $data51 != 8 then 
+   return -1
+endi
+if $data60 != @21-03-24 19:08:06.600@ then 
+   return -1
+endi
+if $data61 != 10 then 
+   return -1
+endi
+if $data70 != @21-03-24 19:26:38.230@ then 
+   return -1
+endi
+if $data71 != 12 then 
+   return -1
+endi
+if $data80 != @21-03-24 19:34:37.670@ then 
+   return -1
+endi
+if $data81 != 8 then 
+   return -1
+endi
+if $data90 != @21-03-25 10:03:17.680@ then 
+   return -1
+endi
+if $data91 != 14 then 
+   return -1
+endi
+
+
+sql select ts,add_one(f1) from stb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000";
+if $rows != 8 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:17:19.660@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:23:28.595@ then 
+   return -1
+endi
+if $data11 != 3 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:34:37.670@ then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data40 != @21-03-24 19:08:06.609@ then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data50 != @21-03-24 19:26:38.231@ then 
+   return -1
+endi
+if $data51 != 7 then 
+   return -1
+endi
+if $data60 != @21-03-23 19:33:39.070@ then 
+   return -1
+endi
+if $data61 != 4 then 
+   return -1
+endi
+if $data70 != @21-03-24 19:34:37.670@ then 
+   return -1
+endi
+if $data71 != 5 then 
+   return -1
+endi
+
+sql select sum_double(f1) from stb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000" interval (1h);
+if $rows != 3 then
+  return -1
+endi
+
+if $data00 != @21-03-23 17:00:00.000@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 19:00:00.000@ then 
+   return -1
+endi
+if $data11 != 24 then 
+   return -1
+endi
+if $data20 != @21-03-24 19:00:00.000@ then 
+   return -1
+endi
+if $data21 != 30 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from stb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000" interval (1h) fill(value,999);
+if $rows != 28 then
+  return -1
+endi
+if $data00 != @21-03-23 17:00:00.000@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 18:00:00.000@ then 
+   return -1
+endi
+if $data11 != 999 then 
+   return -1
+endi
+if $data20 != @21-03-23 19:00:00.000@ then 
+   return -1
+endi
+if $data21 != 24 then 
+   return -1
+endi
+
+sql_error select add_one(f1) from stb1 group by f1;
+
+sql select sum_double(f1) from stb1 group by f1;
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != 8 then 
+   return -1
+endi
+if $data10 != 16 then 
+   return -1
+endi
+if $data20 != 18 then 
+   return -1
+endi
+if $data30 != 24 then 
+   return -1
+endi
+if $data40 != 10 then 
+   return -1
+endi
+if $data50 != 12 then 
+   return -1
+endi
+if $data60 != 14 then 
+   return -1
+endi
+
+sql select sum_double(f1) from stb1 interval (1h) order by ts desc;
+if $rows != 12 then
+  return -1
+endi
+
+if $data00 != @21-04-08 16:00:00.000@ then 
+   return -1
+endi
+if $data01 != 8 then 
+   return -1
+endi
+if $data10 != @21-04-08 12:00:00.000@ then 
+   return -1
+endi
+if $data11 != 4 then 
+   return -1
+endi
+if $data20 != @21-04-08 11:00:00.000@ then 
+   return -1
+endi
+if $data21 != 2 then 
+   return -1
+endi
+if $data30 != @21-04-08 10:00:00.000@ then 
+   return -1
+endi
+if $data31 != 6 then 
+   return -1
+endi
+if $data40 != @21-04-01 19:00:00.000@ then 
+   return -1
+endi
+if $data41 != 4 then 
+   return -1
+endi
+if $data50 != @21-03-25 19:00:00.000@ then 
+   return -1
+endi
+if $data51 != 2 then 
+   return -1
+endi
+if $data60 != @21-03-25 10:00:00.000@ then 
+   return -1
+endi
+if $data61 != 14 then 
+   return -1
+endi
+if $data70 != @21-03-24 19:00:00.000@ then 
+   return -1
+endi
+if $data71 != 30 then 
+   return -1
+endi
+if $data80 != @21-03-23 19:00:00.000@ then 
+   return -1
+endi
+if $data81 != 24 then 
+   return -1
+endi
+if $data90 != @21-03-23 17:00:00.000@ then 
+   return -1
+endi
+if $data91 != 2 then 
+   return -1
+endi
+
+
+sql select add_one(f1) from stb1 limit 2;
+if $rows != 2 then
+  return -1
+endi
+
+if $data00 != 2 then 
+   return -1
+endi
+if $data10 != 3 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from stb1 interval (1d) limit 2;
+if $rows != 2 then
+  return -1
+endi
+
+if $data00 != @21-03-03 00:00:00.000@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-13 00:00:00.000@ then 
+   return -1
+endi
+if $data11 != 4 then 
+   return -1
+endi
+
+sql select sum_double(f1) from stb1 group by id1;
+
+if $rows != 6 then
+  return -1
+endi
+
+if $data00 != 56 then 
+   return -1
+endi
+if $data01 != 1 then 
+   return -1
+endi
+if $data10 != 6 then 
+   return -1
+endi
+if $data11 != 2 then 
+   return -1
+endi
+if $data20 != 14 then 
+   return -1
+endi
+if $data21 != 3 then 
+   return -1
+endi
+if $data30 != 12 then 
+   return -1
+endi
+if $data31 != 5 then 
+   return -1
+endi
+if $data40 != 6 then 
+   return -1
+endi
+if $data41 != 6 then 
+   return -1
+endi
+if $data50 != 8 then 
+   return -1
+endi
+if $data51 != 9 then 
+   return -1
+endi
+
+
+sql select sum_double(f1) from tb1 where ts>="2021-03-23 17:00:00.000" and ts<="2021-03-24 20:00:00.000" interval (1h) sliding (30m);
+if $rows != 7 then
+  return -1
+endi
+
+if $data00 != @21-03-23 16:30:00.000@ then 
+   return -1
+endi
+if $data01 != 2 then 
+   return -1
+endi
+if $data10 != @21-03-23 17:00:00.000@ then 
+   return -1
+endi
+if $data11 != 2 then 
+   return -1
+endi
+if $data20 != @21-03-23 18:30:00.000@ then 
+   return -1
+endi
+if $data21 != 4 then 
+   return -1
+endi
+if $data30 != @21-03-23 19:00:00.000@ then 
+   return -1
+endi
+if $data31 != 18 then 
+   return -1
+endi
+if $data40 != @21-03-23 19:30:00.000@ then 
+   return -1
+endi
+if $data41 != 14 then 
+   return -1
+endi
+if $data50 != @21-03-24 18:30:00.000@ then 
+   return -1
+endi
+if $data51 != 22 then 
+   return -1
+endi
+if $data60 != @21-03-24 19:00:00.000@ then 
+   return -1
+endi
+if $data61 != 22 then 
+   return -1
+endi
+
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+
+
+
+
+
+

tests/script/sh/abs_max.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct SUdfInit{
+ int maybe_null;       /* 1 if function can return NULL */
+ int decimals;     /* for real functions */
+ long long length;       /* For string functions */
+ char  *ptr;            /* free pointer for function data */
+ int const_item;       /* 0 if result is independent of arguments */
+} SUdfInit;
+
+
+#define TSDB_DATA_INT_NULL              0x80000000L
+#define TSDB_DATA_BIGINT_NULL           0x8000000000000000L
+
+void abs_max(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBuf, char* tsOutput,
+                        int* numOfOutput, short otype, short obytes, SUdfInit* buf) {
+   int i;
+   int r = 0;
+   printf("abs_max input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, tsOutput, numOfOutput, buf);
+   if (itype == 5) {
+     r=*(long *)dataOutput;
+     *numOfOutput=0;
+
+     for(i=0;i<numOfRows;++i) {
+       if (*((long *)data + i) == TSDB_DATA_BIGINT_NULL) {
+         continue;
+       }
+
+       *numOfOutput=1;
+       long v = abs(*((long *)data + i));
+       if (v > r) {
+          r = v;
+       }
+     }
+
+     *(long *)dataOutput=r;
+
+     printf("abs_max out, dataoutput:%ld, numOfOutput:%d\n", *(long *)dataOutput, *numOfOutput);
+   }
+}
+
+
+
+void abs_max_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf) {
+   int i;
+   int r = 0;
+   printf("abs_max_finalize dataoutput:%p:%d, numOfOutput:%d, buf:%p\n", dataOutput, *dataOutput, *numOfOutput, buf);
+   *numOfOutput=1;
+   printf("abs_max finalize, dataoutput:%ld, numOfOutput:%d\n", *(long *)dataOutput, *numOfOutput);
+}
+
+void abs_max_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf) {
+   int r = 0;
+   
+   if (numOfRows > 0) {
+      r = *((long *)data);
+   }
+   printf("abs_max_merge numOfRows:%d, dataoutput:%p, buf:%p\n", numOfRows, dataOutput, buf);
+   for (int i = 1; i < numOfRows; ++i) {
+     printf("abs_max_merge %d - %ld\n", i, *((long *)data + i));
+     if (*((long*)data + i) > r) {
+        r= *((long*)data + i);
+     }
+   }
+   
+   *(long*)dataOutput=r;
+   if (numOfRows > 0) {
+     *numOfOutput=1;
+   } else {
+     *numOfOutput=0;
+   }
+   
+   printf("abs_max_merge, dataoutput:%ld, numOfOutput:%d\n", *(long *)dataOutput, *numOfOutput);
+}
+
+
+int abs_max_init(SUdfInit* buf) {
+   printf("abs_max init\n");
+   return 0;
+}
+
+
+void abs_max_destroy(SUdfInit* buf) {
+   printf("abs_max destroy\n");
+}
+

tests/script/sh/add_one.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct SUdfInit{
+ int maybe_null;       /* 1 if function can return NULL */
+ int decimals;     /* for real functions */
+ long long length;       /* For string functions */
+ char  *ptr;            /* free pointer for function data */
+ int const_item;       /* 0 if result is independent of arguments */
+} SUdfInit;
+
+void add_one(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBUf, char* tsOutput,
+                        int* numOfOutput, short otype, short obytes, SUdfInit* buf) {
+   int i;
+   int r = 0;
+   printf("add_one input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, tsOutput, numOfOutput, buf);
+   if (itype == 4) {
+     for(i=0;i<numOfRows;++i) {
+       printf("input %d - %d", i, *((int *)data + i));
+       *((int *)dataOutput+i)=*((int *)data + i) + 1;
+       printf(", output %d\n", *((int *)dataOutput+i));
+       if (tsOutput) {
+         *(long long*)tsOutput=1000000;
+       }
+     }
+     *numOfOutput=numOfRows;
+
+     printf("add_one out, numOfOutput:%d\n", *numOfOutput);
+   }
+}
+
+

tests/script/sh/demo.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct SUdfInit{
+ int maybe_null;       /* 1 if function can return NULL */
+ int decimals;     /* for real functions */
+ long long length;       /* For string functions */
+ char  *ptr;            /* free pointer for function data */
+ int const_item;       /* 0 if result is independent of arguments */
+} SUdfInit;
+
+typedef struct SDemo{
+  double sum;
+  int num;
+  short otype;
+}SDemo;
+
+#define FLOAT_NULL            0x7FF00000              // it is an NAN
+#define DOUBLE_NULL           0x7FFFFF0000000000L     // it is an NAN
+
+
+void demo(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBuf, char* tsOutput,
+                        int* numOfOutput, short otype, short obytes, SUdfInit* buf) {
+   int i;
+   double r = 0;
+   SDemo *p = (SDemo *)interBuf;
+   SDemo *q = (SDemo *)dataOutput;
+   printf("demo input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, interBUf:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, interBuf, tsOutput, numOfOutput, buf);
+
+   for(i=0;i<numOfRows;++i) {
+     if (itype == 4) {
+       r=*((int *)data+i);
+     } else if (itype == 6) {
+       r=*((float *)data+i);
+     } else if (itype == 7) {
+       r=*((double *)data+i);
+     }
+
+     p->sum += r*r;
+   }
+
+   p->otype = otype;
+   p->num += numOfRows;
+
+   q->sum = p->sum;
+   q->num = p->num;
+   q->otype = p->otype;
+
+   *numOfOutput=1;
+
+   printf("demo out, sum:%f, num:%d, numOfOutput:%d\n", p->sum, p->num, *numOfOutput);
+}
+
+
+void demo_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf) {
+   int i;
+   SDemo *p = (SDemo *)data;
+   SDemo res = {0};
+   printf("demo_merge input data:%p, rows:%d, dataoutput:%p, numOfOutput:%p, buf:%p\n", data, numOfRows, dataOutput, numOfOutput, buf);
+
+   for(i=0;i<numOfRows;++i) {
+     res.sum += p->sum * p->sum;
+     res.num += p->num;
+     p++;
+   }
+
+   p->sum = res.sum;
+   p->num = res.num;
+
+   *numOfOutput=1;
+
+   printf("demo out, sum:%f, num:%d, numOfOutput:%d\n", p->sum, p->num, *numOfOutput);
+}
+
+
+
+void demo_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf) {
+   SDemo *p = (SDemo *)interBuf;
+   printf("demo_finalize interbuf:%p, numOfOutput:%p, buf:%p, sum:%f, num:%d\n", interBuf, numOfOutput, buf, p->sum, p->num);
+   if (p->otype == 6) {
+     if (p->num != 30000) {
+       *(unsigned int *)dataOutput = FLOAT_NULL;  
+     } else {
+       *(float *)dataOutput = (float)(p->sum / p->num);  
+     }
+     printf("finalize values:%f\n", *(float *)dataOutput);
+   } else if (p->otype == 7) {
+     if (p->num != 30000) {
+       *(unsigned long long *)dataOutput = DOUBLE_NULL;  
+     } else {    
+       *(double *)dataOutput = (double)(p->sum / p->num);
+     }
+     printf("finalize values:%f\n", *(double *)dataOutput);
+   }
+
+   *numOfOutput=1;
+
+   printf("demo finalize, numOfOutput:%d\n", *numOfOutput);
+}
+
+
+int demo_init(SUdfInit* buf) {
+   printf("demo init\n");
+   return 0;
+}
+
+
+void demo_destroy(SUdfInit* buf) {
+   printf("demo destroy\n");
+}
+

tests/script/sh/demo.lua

+funcName = "test"
+
+global =  {} 
+
+function test_init()
+  return global  
+end
+
+function test_add(rows, ans, key)
+  t = {}
+  t["sum"] = 0.0
+  t["num"] = 0
+  for i=1, #rows do
+    t["sum"] = t["sum"] + rows[i] * rows[i]  
+  end
+  t["num"] = #rows  
+
+
+  if (ans[key] ~= nil)    
+  then
+    ans[key]["sum"] = ans[key]["sum"] + t["sum"]
+    ans[key]["num"] = ans[key]["num"] + t["num"]
+  else 
+    ans[key] = t
+  end
+  
+  return ans; 
+end
+
+function test_finalize(ans, key) 
+  local ret = 0.0 
+
+  if (ans[key] ~= nil and ans[key]["num"] == 30000)    
+  then
+    ret = ans[key]["sum"]/ans[key]["num"]
+    ans[key]["sum"] = 0.0 
+    ans[key]["num"] = 0
+  else 
+    ret = inf 
+  end
+  
+  return ret, ans
+end  

tests/script/sh/prepare_udf.sh

+#!/bin/sh
+
+echo -n "hello" > /tmp/normal
+echo -n "" > /tmp/empty
+dd if=/dev/zero bs=3584 of=/tmp/big count=1
+
+rm -rf /tmp/sum_double.so /tmp/add_one.so
+
+gcc -g -O0 -fPIC -shared sh/sum_double.c -o /tmp/sum_double.so
+gcc -g -O0 -fPIC -shared sh/add_one.c -o /tmp/add_one.so
+gcc -g -O0 -fPIC -shared sh/demo.c -o /tmp/demo.so
+gcc -g -O0 -fPIC -shared sh/abs_max.c -o /tmp/abs_max.so

tests/script/sh/scalar_demo.lua

+funcName = "test"
+
+ans = 1 
+
+function test_init()
+  return ans  
+end
+
+function test_add(rows, ans)
+  for i=1, #rows do
+    rows[i] = rows[i] + ans  
+  end
+  return rows 
+end

tests/script/sh/sum_double.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct SUdfInit{
+ int maybe_null;       /* 1 if function can return NULL */
+ int decimals;     /* for real functions */
+ long long length;       /* For string functions */
+ char  *ptr;            /* free pointer for function data */
+ int const_item;       /* 0 if result is independent of arguments */
+} SUdfInit;
+
+#define TSDB_DATA_INT_NULL              0x80000000L
+
+
+void sum_double(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBuf, char* tsOutput,
+                        int* numOfOutput, short otype, short obytes, SUdfInit* buf) {
+   int i;
+   int r = 0;
+   printf("sum_double input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, tsOutput, numOfOutput, buf);
+   if (itype == 4) {
+     r=*(int *)dataOutput;
+     *numOfOutput=0;
+
+     for(i=0;i<numOfRows;++i) {
+       if (*((int *)data + i) == TSDB_DATA_INT_NULL) {
+         continue;
+       }
+
+       *numOfOutput=1;
+       r+=*((int *)data + i);
+       *(int *)dataOutput=r;
+     }
+
+     printf("sum_double out, dataoutput:%d, numOfOutput:%d\n", *(int *)dataOutput, *numOfOutput);
+   }
+}
+
+
+
+void sum_double_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf) {
+   int i;
+   int r = 0;
+   printf("sum_double_finalize dataoutput:%p:%d, numOfOutput:%d, buf:%p\n", dataOutput, *dataOutput, *numOfOutput, buf);
+   *numOfOutput=1;
+   *(int*)(buf->ptr)=*(int*)dataOutput*2;
+   *(int*)dataOutput=*(int*)(buf->ptr);
+   printf("sum_double finalize, dataoutput:%d, numOfOutput:%d\n", *(int *)dataOutput, *numOfOutput);
+}
+
+void sum_double_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf) {
+   int r = 0;
+   int sum = 0;
+   
+   printf("sum_double_merge numOfRows:%d, dataoutput:%p, buf:%p\n", numOfRows, dataOutput, buf);
+   for (int i = 0; i < numOfRows; ++i) {
+     printf("sum_double_merge %d - %d\n", i, *((int*)data + i));
+     sum +=*((int*)data + i);
+   }
+   
+   *(int*)dataOutput+=sum;
+   if (numOfRows > 0) {
+     *numOfOutput=1;
+   } else {
+     *numOfOutput=0;
+   }
+   
+   printf("sum_double_merge, dataoutput:%d, numOfOutput:%d\n", *(int *)dataOutput, *numOfOutput);
+}
+
+
+int sum_double_init(SUdfInit* buf) {
+   buf->maybe_null=1;
+   buf->ptr = malloc(sizeof(int));
+   printf("sum_double init\n");
+   return 0;
+}
+
+
+void sum_double_destroy(SUdfInit* buf) {
+   free(buf->ptr);
+   printf("sum_double destroy\n");
+}
+