diff --git a/cmake/define.inc b/cmake/define.inc
index 96a406cfb4..6c466fee02 100755
--- a/cmake/define.inc
+++ b/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)
diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt
index bdd42cb457..b84525dedb 100644
--- a/src/client/CMakeLists.txt
+++ b/src/client/CMakeLists.txt
@@ -21,7 +21,7 @@ IF (TD_LINUX)
   IF (TD_LINUX_64)
     TARGET_LINK_LIBRARIES(taos lua)
   ENDIF ()
-  
+
   SET_TARGET_PROPERTIES(taos PROPERTIES CLEAN_DIRECT_OUTPUT 1)
 
   #set version of .so
@@ -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)
 
diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index dbb31f4634..806d5a62df 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -107,6 +107,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);
@@ -261,6 +262,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);
@@ -310,7 +312,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);
 
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index efc9914c28..bab335154f 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -146,6 +146,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;
diff --git a/src/client/src/tscGlobalmerge.c b/src/client/src/tscGlobalmerge.c
index ffec03b65a..8ca8c688f0 100644
--- a/src/client/src/tscGlobalmerge.c
+++ b/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]);
     }
 
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 59807d1e2e..3166b47ae8 100644
--- a/src/client/src/tscSQLParser.c
+++ b/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);
 
@@ -177,15 +179,15 @@ bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType,
     // check all the exprToken type in expr list same or not
     if (firstVarType != var->nType) {
       break;
-    }  
+    }
     if ((colType == TSDB_DATA_TYPE_BOOL || IS_SIGNED_NUMERIC_TYPE(colType))) {
       if (var->nType != TSDB_DATA_TYPE_BOOL && !IS_SIGNED_NUMERIC_TYPE(var->nType)) {
         break;
-      }  
-      tbufWriteInt64(&bw, var->i64);        
+      }
+      tbufWriteInt64(&bw, var->i64);
     } else if (IS_UNSIGNED_NUMERIC_TYPE(colType)) {
       if (IS_SIGNED_NUMERIC_TYPE(var->nType) || IS_UNSIGNED_NUMERIC_TYPE(var->nType)) {
-        tbufWriteUint64(&bw, var->u64);        
+        tbufWriteUint64(&bw, var->u64);
       } else {
         break;
       }
@@ -216,19 +218,19 @@ bool serializeExprListToVariant(SArray* pList, tVariant **dst, int16_t colType,
     } else if (colType == TSDB_DATA_TYPE_TIMESTAMP) {
       if (var->nType == TSDB_DATA_TYPE_BINARY) {
          if (convertTimestampStrToInt64(var, precision) < 0) {
-           break; 
-         } 
-         tbufWriteInt64(&bw, var->i64);        
+           break;
+         }
+         tbufWriteInt64(&bw, var->i64);
        } else if (var->nType == TSDB_DATA_TYPE_BIGINT) {
-         tbufWriteInt64(&bw, var->i64);        
+         tbufWriteInt64(&bw, var->i64);
        } else {
          break;
-       }      
+       }
     } else {
-      break; 
+      break;
     }
     if (i == (int32_t)(pList->size - 1)) { ret = true;}
-  }   
+  }
   if (ret == true) {
     if ((*dst = calloc(1, sizeof(tVariant))) != NULL) {
       tVariantCreateFromBinary(*dst, tbufGetData(&bw, false), tbufTell(&bw), TSDB_DATA_TYPE_BINARY);
@@ -327,7 +329,7 @@ static int setColumnFilterInfoForTimestamp(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
   STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
   if (convertTimestampStrToInt64(pVar, tinfo.precision) < -1) {
    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
-  }  
+  }
   return TSDB_CODE_SUCCESS;
 }
 
@@ -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;
+
         }
       }
 
@@ -1018,7 +1169,7 @@ static int32_t validateStateWindowNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SS
   }
 
   SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, index.columnIndex);
-  if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP || pSchema->type == TSDB_DATA_TYPE_FLOAT 
+  if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP || pSchema->type == TSDB_DATA_TYPE_FLOAT
       || pSchema->type == TSDB_DATA_TYPE_DOUBLE || pSchema->type == TSDB_DATA_TYPE_NCHAR
       || pSchema->type == TSDB_DATA_TYPE_BINARY) {
     return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
@@ -1809,6 +1960,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);
@@ -1841,12 +2055,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) {
-        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
+        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) {
@@ -2101,7 +2321,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;
@@ -2117,7 +2338,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));
 
@@ -2189,18 +2410,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;
 
@@ -2349,7 +2571,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;
       }
 
@@ -2483,7 +2705,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;
               }
             }
@@ -2506,7 +2729,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;
             }
           }
@@ -2531,7 +2754,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++;
@@ -2602,7 +2826,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
@@ -2715,7 +2940,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;
@@ -2739,7 +2964,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};
 
@@ -2757,10 +2983,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
@@ -2795,8 +3075,7 @@ static bool isTablenameToken(SStrToken* token) {
   SStrToken tableToken = {0};
 
   extractTableNameFromToken(&tmpToken, &tableToken);
-
-  return (strncasecmp(TSQL_TBNAME_L, tmpToken.z, tmpToken.n) == 0 && tmpToken.n == strlen(TSQL_TBNAME_L));
+  return (tmpToken.n == strlen(TSQL_TBNAME_L) && strncasecmp(TSQL_TBNAME_L, tmpToken.z, tmpToken.n) == 0);
 }
 
 static int16_t doGetColumnIndex(SQueryInfo* pQueryInfo, int32_t index, SStrToken* pToken) {
@@ -2827,8 +3106,11 @@ int32_t doGetColumnIndexByName(SStrToken* pToken, SQueryInfo* pQueryInfo, SColum
 
   if (isTablenameToken(pToken)) {
     pIndex->columnIndex = TSDB_TBNAME_COLUMN_INDEX;
-  } else if (strncasecmp(pToken->z, DEFAULT_PRIMARY_TIMESTAMP_COL_NAME, pToken->n) == 0) {
-    pIndex->columnIndex = PRIMARYKEY_TIMESTAMP_COL_INDEX;
+  } else if (strlen(DEFAULT_PRIMARY_TIMESTAMP_COL_NAME) == pToken->n && 
+            strncasecmp(pToken->z, DEFAULT_PRIMARY_TIMESTAMP_COL_NAME, pToken->n) == 0) {
+    pIndex->columnIndex = PRIMARYKEY_TIMESTAMP_COL_INDEX; // just make runtime happy, need fix java test case InsertSpecialCharacterJniTest
+  } else if (pToken->n == 0) {
+    pIndex->columnIndex = PRIMARYKEY_TIMESTAMP_COL_INDEX; // just make runtime happy, need fix java test case InsertSpecialCharacterJniTest
   } else {
     // not specify the table name, try to locate the table index by column name
     if (pIndex->tableIndex == COLUMN_INDEX_INITIAL_VAL) {
@@ -3072,7 +3354,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;
       }
 
@@ -3103,6 +3385,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;
     }
@@ -3114,9 +3400,9 @@ void tscRestoreFuncForSTableQuery(SQueryInfo* pQueryInfo) {
     } else if (functionId == TSDB_FUNC_STDDEV_DST) {
       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);
   }
 }
 
@@ -3129,6 +3415,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;
@@ -3173,45 +3463,54 @@ 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 (functionCompatList[functionId] != factor) {
-      return false;
+    if (factor == INT32_MAX) {
+      factor = functionCompatList[functionId];
     } else {
-      if (factor == -1) { // two functions with the same -1 flag
+      if (functionCompatList[functionId] != factor) {
         return false;
+      } else {
+        if (factor == -1) { // two functions with the same -1 flag
+          return false;
+        }
       }
     }
 
@@ -3220,6 +3519,18 @@ static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool
     }
   }
 
+  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;
 }
 
@@ -3285,7 +3596,7 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
 
     pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-  
+
     if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
       pSchema = tGetTbnameColumnSchema();
     } else {
@@ -3294,7 +3605,7 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
 
     int32_t numOfCols = tscGetNumOfColumns(pTableMeta);
     bool groupTag = (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX || index.columnIndex >= numOfCols);
-  
+
     if (groupTag) {
       if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
@@ -3393,7 +3704,14 @@ static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
   if (IS_NUMERIC_TYPE(pRight->value.nType)) {
     bufLen = 60;
   } else {
-    bufLen = pRight->value.nLen + 1;
+    /*
+     * make memory sanitizer happy;
+     */
+    if (pRight->value.nLen == 0) {
+      bufLen = pRight->value.nLen + 2; 
+    } else {
+      bufLen = pRight->value.nLen + 1; 
+    }
   }
 
   if (pExpr->tokenId == TK_LE || pExpr->tokenId == TK_LT) {
@@ -3408,7 +3726,7 @@ static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
     pColumnFilter->pz  = (int64_t)calloc(1, pVal->nLen + 1);
     pColumnFilter->len = pVal->nLen;
     pColumnFilter->filterstr = 1;
-    memcpy((char *)(pColumnFilter->pz), (char *)(pVal->pz), pVal->nLen);  
+    memcpy((char *)(pColumnFilter->pz), (char *)(pVal->pz), pVal->nLen);
 
     tVariantDestroy(pVal);
     free(pVal);
@@ -3821,7 +4139,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;
     }
 
@@ -4832,7 +5150,7 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
 
   int32_t type = 0;
   if ((ret = getQueryCondExpr(&pSql->cmd, pQueryInfo, pExpr, &condExpr, &type, (*pExpr)->tokenId)) != TSDB_CODE_SUCCESS) {
-    return ret;
+    goto PARSE_WHERE_EXIT; 
   }
 
   tSqlExprCompact(pExpr);
@@ -4842,7 +5160,7 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
 
   // 1. check if it is a join query
   if ((ret = validateJoinExpr(&pSql->cmd, pQueryInfo, &condExpr)) != TSDB_CODE_SUCCESS) {
-    return ret;
+    goto PARSE_WHERE_EXIT; 
   }
 
   // 2. get the query time range
@@ -4864,7 +5182,7 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
   if ((ret = getColumnQueryCondInfo(&pSql->cmd, pQueryInfo, condExpr.pColumnCond, TK_AND)) != TSDB_CODE_SUCCESS) {
     goto PARSE_WHERE_EXIT;
   }
-  
+
   if (taosArrayGetSize(pQueryInfo->pUpstream) > 0 ) {
     if ((ret = getColumnQueryCondInfo(&pSql->cmd, pQueryInfo, condExpr.pTimewindow, TK_AND)) != TSDB_CODE_SUCCESS) {
       goto PARSE_WHERE_EXIT;
@@ -5043,7 +5361,8 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
   size_t numOfFields = tscNumOfFields(pQueryInfo);
   
   if (pQueryInfo->fillVal == NULL) {
-    pQueryInfo->fillVal = calloc(numOfFields, sizeof(int64_t));
+    pQueryInfo->fillVal      = calloc(numOfFields, sizeof(int64_t));
+    pQueryInfo->numOfFillVal = (int32_t)numOfFields;
     if (pQueryInfo->fillVal == NULL) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
@@ -5223,14 +5542,14 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
     if (PRIMARYKEY_TIMESTAMP_COL_INDEX == index.columnIndex) {
       orderByTS = true;
     }
-    
+
     SArray *columnInfo = pQueryInfo->groupbyExpr.columnInfo;
     if (columnInfo != NULL && taosArrayGetSize(columnInfo) > 0) {
       SColIndex* pColIndex = taosArrayGet(columnInfo, 0);
       if (PRIMARYKEY_TIMESTAMP_COL_INDEX != index.columnIndex && pColIndex->colIndex == index.columnIndex) {
-        orderByGroupbyCol = true; 
+        orderByGroupbyCol = true;
       }
-    } 
+    }
     if (!(orderByTags || orderByTS || orderByGroupbyCol) && !isTopBottomQuery(pQueryInfo)) {
       return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     } else {  // order by top/bottom result value column is not supported in case of interval query.
@@ -5314,15 +5633,15 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
       SArray *columnInfo = pQueryInfo->groupbyExpr.columnInfo;
       if (columnInfo != NULL && taosArrayGetSize(columnInfo) > 0) {
         SColIndex* pColIndex = taosArrayGet(columnInfo, 0);
-        validOrder = (pColIndex->colIndex == index.columnIndex); 
-      }  
+        validOrder = (pColIndex->colIndex == index.columnIndex);
+      }
       if (!validOrder) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
-      }     
+      }
       tVariantListItem* p1 = taosArrayGet(pSqlNode->pSortOrder, 0);
-      pQueryInfo->groupbyExpr.orderIndex = pSchema[index.columnIndex].colId; 
-      pQueryInfo->groupbyExpr.orderType = p1->sortOrder; 
-      
+      pQueryInfo->groupbyExpr.orderIndex = pSchema[index.columnIndex].colId;
+      pQueryInfo->groupbyExpr.orderType = p1->sortOrder;
+
     }
 
     if (isTopBottomQuery(pQueryInfo)) {
@@ -5330,7 +5649,7 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
       SArray *columnInfo = pQueryInfo->groupbyExpr.columnInfo;
       if (columnInfo != NULL && taosArrayGetSize(columnInfo) > 0) {
         SColIndex* pColIndex = taosArrayGet(columnInfo, 0);
-        validOrder = (pColIndex->colIndex == index.columnIndex); 
+        validOrder = (pColIndex->colIndex == index.columnIndex);
       } else {
         /* order of top/bottom query in interval is not valid  */
         SExprInfo* pExpr = tscExprGet(pQueryInfo, 0);
@@ -5340,16 +5659,16 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
         if (pExpr->base.colInfo.colIndex != index.columnIndex && index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
           return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
         }
-        validOrder = true; 
-      }       
+        validOrder = true;
+      }
 
       if (!validOrder) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
-      }     
+      }
 
       tVariantListItem* pItem = taosArrayGet(pSqlNode->pSortOrder, 0);
       pQueryInfo->order.order = pItem->sortOrder;
-      
+
       pQueryInfo->order.orderColId = pSchema[index.columnIndex].colId;
       return TSDB_CODE_SUCCESS;
     }
@@ -5761,6 +6080,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;
@@ -5780,6 +6109,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;
     }
   }
 
@@ -6265,11 +6595,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);
     }
   }
 }
@@ -6397,6 +6731,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++;
@@ -6624,6 +6966,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);
@@ -6632,13 +6978,13 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, char*
               return invalidOperationMsg(msg, msg6);
             }
           } else if (!TSDB_COL_IS_TAG(pColIndex->flag)) {
-              return invalidOperationMsg(msg, msg6);
+            return invalidOperationMsg(msg, msg6);
           }
         }
       }
 
-      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);
       }
 
@@ -6665,6 +7011,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";
@@ -6843,9 +7190,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;
 
@@ -6937,7 +7292,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
   const int32_t STABLE_INDEX = 1;
 
   STableMetaInfo* pStableMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
-  
+
   // super table name, create table by using dst
   int32_t numOfTables = (int32_t) taosArrayGetSize(pCreateTable->childTableInfo);
   for(int32_t j = 0; j < numOfTables; ++j) {
@@ -7023,7 +7378,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
                   return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
                 }
               } else if (pItem->pVar.nType == TSDB_DATA_TYPE_TIMESTAMP) {
-                pItem->pVar.i64 = convertTimePrecision(pItem->pVar.i64, TSDB_TIME_PRECISION_NANO, tinfo.precision);  
+                pItem->pVar.i64 = convertTimePrecision(pItem->pVar.i64, TSDB_TIME_PRECISION_NANO, tinfo.precision);
               }
             }
 
@@ -7078,10 +7433,10 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
               return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
             }
           } else if (pItem->pVar.nType == TSDB_DATA_TYPE_TIMESTAMP) {
-            pItem->pVar.i64 = convertTimePrecision(pItem->pVar.i64, TSDB_TIME_PRECISION_NANO, tinfo.precision);  
+            pItem->pVar.i64 = convertTimePrecision(pItem->pVar.i64, TSDB_TIME_PRECISION_NANO, tinfo.precision);
           }
         }
-        
+
 
         ret = tVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
 
@@ -7374,7 +7729,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;
   }
 
@@ -7664,6 +8019,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);
 
@@ -7725,20 +8081,59 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         taosArrayPush(pVgroupList, &t);
       }
 
-      STableMeta* pMeta = tscTableMetaDup(pTableMeta);
-      STableMetaVgroupInfo p = { .pTableMeta = pMeta };
+      //STableMeta* pMeta = tscTableMetaDup(pTableMeta);
+      //STableMetaVgroupInfo p = { .pTableMeta = pMeta };
 
+      //const char* px = tNameGetTableName(pname);
+      //taosHashPut(pCmd->pTableMetaMap, px, strlen(px), &p, sizeof(STableMetaVgroupInfo));
+      // avoid mem leak, may should update pTableMeta
       const char* px = tNameGetTableName(pname);
-      taosHashPut(pCmd->pTableMetaMap, px, strlen(px), &p, sizeof(STableMetaVgroupInfo));
+      if (taosHashGet(pCmd->pTableMetaMap, px, strlen(px)) == NULL) {
+        STableMeta* pMeta = tscTableMetaDup(pTableMeta); 
+        STableMetaVgroupInfo p = { .pTableMeta = pMeta,  .pVgroupInfo = NULL};
+        taosHashPut(pCmd->pTableMetaMap, px, strlen(px), &p, sizeof(STableMetaVgroupInfo));
+      }
     } else {  // add to the retrieve table meta array list.
       char* t = strdup(name);
       taosArrayPush(plist, &t);
     }
   }
 
+  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:
@@ -7871,8 +8266,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;
   }
@@ -8185,7 +8587,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
 
     // in case of join query, time range is required.
     if (QUERY_IS_JOIN_QUERY(pQueryInfo->type)) {
-      int64_t timeRange = ABS(pQueryInfo->window.skey - pQueryInfo->window.ekey);
+      uint64_t timeRange = (uint64_t)pQueryInfo->window.ekey - pQueryInfo->window.skey;
       if (timeRange == 0 && pQueryInfo->window.skey == 0) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
@@ -8209,11 +8611,12 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
   }
 
   { // set the query info
-    pQueryInfo->projectionQuery   = tscIsProjectionQuery(pQueryInfo);
-    pQueryInfo->hasFilter         = tscHasColumnFilter(pQueryInfo);
-    pQueryInfo->simpleAgg         = isSimpleAggregateRv(pQueryInfo);
-    pQueryInfo->onlyTagQuery      = onlyTagPrjFunction(pQueryInfo);
-    pQueryInfo->groupbyColumn     = tscGroupbyColumn(pQueryInfo);
+    pQueryInfo->projectionQuery = tscIsProjectionQuery(pQueryInfo);
+    pQueryInfo->hasFilter = tscHasColumnFilter(pQueryInfo);
+    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);
@@ -8227,6 +8630,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     }
 
     taosArrayAddBatch(pQueryInfo->exprList1, (void*) p, numOfExpr);
+    tfree(p); 
   }
 
 #if 0
@@ -8268,7 +8672,7 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
     assert(pSqlExpr->pRight == NULL);
 
     if (pSqlExpr->type == SQL_NODE_VALUE) {
-      int32_t ret = TSDB_CODE_SUCCESS;  
+      int32_t ret = TSDB_CODE_SUCCESS;
       *pExpr = calloc(1, sizeof(tExprNode));
       (*pExpr)->nodeType = TSQL_NODE_VALUE;
       (*pExpr)->pVal = calloc(1, sizeof(tVariant));
@@ -8278,12 +8682,12 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
       if (pCols != NULL && taosArrayGetSize(pCols) > 0) {
         SColIndex* idx = taosArrayGet(pCols, 0);
         SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, idx->colIndex);
-        // convert time by precision 
+        // convert time by precision
         if (pSchema != NULL && TSDB_DATA_TYPE_TIMESTAMP == pSchema->type && TSDB_DATA_TYPE_BINARY == (*pExpr)->pVal->nType) {
           ret = setColumnFilterInfoForTimestamp(pCmd, pQueryInfo, (*pExpr)->pVal);
         }
       }
-      return ret;  
+      return ret;
     } else if (pSqlExpr->type == SQL_NODE_SQLFUNCTION) {
       // arithmetic expression on the results of aggregation functions
       *pExpr = calloc(1, sizeof(tExprNode));
@@ -8442,9 +8846,7 @@ void normalizeSqlNode(SSqlNode* pSqlNode, const char* dbName) {
 //  2. pSqlNode->pWhere
 //  3. pSqlNode->pHaving
 //  4. pSqlNode->pSortOrder
-
 //  pSqlNode->from
-
 }
 
 #endif
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 657d8b7848..4abea9fed8 100644
--- a/src/client/src/tscServer.c
+++ b/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,11 +1346,19 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  SShowMsg *pShowMsg = (SShowMsg *)pCmd->payload;
+  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);
 
-  if (tNameIsEmpty(&pTableMetaInfo->name)) {    
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (tNameIsEmpty(&pTableMetaInfo->name)) {
     pthread_mutex_lock(&pObj->mutex);
     tstrncpy(pShowMsg->db, pObj->db, sizeof(pShowMsg->db));  
     pthread_mutex_unlock(&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);
 
@@ -2076,6 +2210,7 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
     STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
     if (!tIsValidSchema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->tableInfo.numOfTags)) {
       tscError("0x%"PRIx64" invalid table meta from mnode, name:%s", pSql->self, pMetaMsg->tableFname);
+      tfree(pTableMeta);
       taosHashCleanup(pSet);
       taosReleaseRef(tscObjRef, pParentSql->self);
 
@@ -2119,10 +2254,45 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
     assert(p != NULL);
 
     int32_t size = 0;
+    if (p->pVgroupInfo!= NULL) {
+      tscVgroupInfoClear(p->pVgroupInfo);
+      //tfree(p->pTableMeta);
+    }
     p->pVgroupInfo = createVgroupInfoFromMsg(pMsg, &size, pSql->self);
     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);
@@ -2513,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);
@@ -2526,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);
@@ -2537,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);
@@ -2553,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);
@@ -2562,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;
@@ -2638,6 +2821,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
@@ -2739,6 +2976,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;
@@ -2747,6 +2985,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;
@@ -2762,6 +3001,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;
@@ -2780,6 +3020,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.
@@ -2809,3 +3050,4 @@ void tscInitMsgsFp() {
   tscKeepConn[TSDB_SQL_FETCH] = 1;
   tscKeepConn[TSDB_SQL_HB] = 1;
 }
+
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 60261368f4..9250a1bbc3 100644
--- a/src/client/src/tscSql.c
+++ b/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;
   }
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index f10646e3a3..4a9ceeca70 100644
--- a/src/client/src/tscSubquery.c
+++ b/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) {
@@ -107,6 +108,9 @@ bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
   subState->states[idx] = 1;
 
   bool done = allSubqueryDone(pParentSql);
+  if (!done) {
+    tscDebug("0x%"PRIx64" sub:%p,%d completed, total:%d", pParentSql->self, pSql, idx, pParentSql->subState.numOfSub);
+  }
   pthread_mutex_unlock(&subState->mutex);
   return done;
 }
@@ -416,7 +420,9 @@ static void tscDestroyJoinSupporter(SJoinSupporter* pSupporter) {
   }
 
 //  tscFieldInfoClear(&pSupporter->fieldsInfo);
-
+  if (pSupporter->fieldsInfo.internalField != NULL) {
+    taosArrayDestroy(pSupporter->fieldsInfo.internalField);
+  }
   if (pSupporter->pTSBuf != NULL) {
     tsBufDestroy(pSupporter->pTSBuf);
     pSupporter->pTSBuf = NULL;
@@ -430,7 +436,8 @@ static void tscDestroyJoinSupporter(SJoinSupporter* pSupporter) {
   }
 
   if (pSupporter->pVgroupTables != NULL) {
-    taosArrayDestroy(pSupporter->pVgroupTables);
+    //taosArrayDestroy(pSupporter->pVgroupTables);
+    tscFreeVgroupTableInfo(pSupporter->pVgroupTables); 
     pSupporter->pVgroupTables = NULL;
   }
 
@@ -889,7 +896,9 @@ static int32_t getIntersectionOfTableTuple(SQueryInfo* pQueryInfo, SSqlObj* pPar
     tscDebug("Join %d - num:%d", i, p->num);
 
     // sort according to the tag valu
-    qsort(p->pIdTagList, p->num, p->tagSize, tagValCompar);
+    if (p->pIdTagList != NULL) {
+      qsort(p->pIdTagList, p->num, p->tagSize, tagValCompar);
+    }
 
     if (!checkForDuplicateTagVal(pColSchema, p, pParentSql)) {
       for (int32_t j = 0; j <= i; j++) {
@@ -1173,7 +1182,7 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   // no data exists in next vnode, mark the <tid, tags> query completed
   // only when there is no subquery exits any more, proceeds to get the intersect of the <tid, tags> tuple sets.
   if (!subAndCheckDone(pSql, pParentSql, pSupporter->subqueryIndex)) {
-    tscDebug("0x%"PRIx64" tagRetrieve:%p,%d completed, total:%d", pParentSql->self, tres, pSupporter->subqueryIndex, pParentSql->subState.numOfSub);
+    //tscDebug("0x%"PRIx64" tagRetrieve:%p,%d completed, total:%d", pParentSql->self, tres, pSupporter->subqueryIndex, pParentSql->subState.numOfSub);
     return;
   }  
 
@@ -1441,7 +1450,7 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
   }
 
   if (!subAndCheckDone(pSql, pParentSql, pSupporter->subqueryIndex)) {
-    tscDebug("0x%"PRIx64" sub:0x%"PRIx64",%d completed, total:%d", pParentSql->self, pSql->self, pSupporter->subqueryIndex, pState->numOfSub);
+    //tscDebug("0x%"PRIx64" sub:0x%"PRIx64",%d completed, total:%d", pParentSql->self, pSql->self, pSupporter->subqueryIndex, pState->numOfSub);
     return;
   }
 
@@ -1888,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;
@@ -2793,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 {
@@ -3047,9 +3078,10 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
       pParentObj->cmd.insertParam.schemaAttached = 1;
     }
   }
-
+  
   if (!subAndCheckDone(tres, pParentObj, pSupporter->index)) {
-    tscDebug("0x%"PRIx64" insert:%p,%d completed, total:%d", pParentObj->self, tres, pSupporter->index, pParentObj->subState.numOfSub);
+    // concurrency problem, other thread already release pParentObj 
+    //tscDebug("0x%"PRIx64" insert:%p,%d completed, total:%d", pParentObj->self, tres, suppIdx, pParentObj->subState.numOfSub);
     return;
   }
 
@@ -3460,20 +3492,20 @@ static UNUSED_FUNC bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql) {
   SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   if (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
     bool allSubqueryExhausted = true;
-    
+
     for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
       if (pSql->pSubs[i] == NULL) {
         continue;
       }
-      
+
       SSqlRes *pRes1 = &pSql->pSubs[i]->res;
       SSqlCmd *pCmd1 = &pSql->pSubs[i]->cmd;
-      
+
       SQueryInfo *pQueryInfo1 = tscGetQueryInfo(pCmd1);
       assert(pQueryInfo1->numOfTables == 1);
-      
+
       STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo1, 0);
-      
+
       /*
        * if the global limitation is not reached, and current result has not exhausted, or next more vnodes are
        * available, goes on
@@ -3484,14 +3516,14 @@ static UNUSED_FUNC bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql) {
         break;
       }
     }
-    
+
     hasData = !allSubqueryExhausted;
   } else {  // otherwise, in case inner join, if any subquery exhausted, query completed.
     for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
       if (pSql->pSubs[i] == 0) {
         continue;
       }
-      
+
       SSqlRes *   pRes1 = &pSql->pSubs[i]->res;
       SQueryInfo *pQueryInfo1 = tscGetQueryInfo(&pSql->pSubs[i]->cmd);
       
diff --git a/src/client/src/tscSystem.c b/src/client/src/tscSystem.c
index 87296c7055..7b8f24a093 100644
--- a/src/client/src/tscSystem.c
+++ b/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;
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 0f29f3c178..e4ddff1c90 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -34,54 +34,54 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo);
 
 int32_t converToStr(char *str, int type, void *buf, int32_t bufSize, int32_t *len) {
   int32_t n = 0;
-  
+
   switch (type) {
     case TSDB_DATA_TYPE_NULL:
       n = sprintf(str, "null");
       break;
-  
+
     case TSDB_DATA_TYPE_BOOL:
       n = sprintf(str, (*(int8_t*)buf) ? "true" : "false");
       break;
-  
+
     case TSDB_DATA_TYPE_TINYINT:
       n = sprintf(str, "%d", *(int8_t*)buf);
       break;
-  
+
     case TSDB_DATA_TYPE_SMALLINT:
       n = sprintf(str, "%d", *(int16_t*)buf);
       break;
-  
+
     case TSDB_DATA_TYPE_INT:
       n = sprintf(str, "%d", *(int32_t*)buf);
       break;
-  
+
     case TSDB_DATA_TYPE_BIGINT:
     case TSDB_DATA_TYPE_TIMESTAMP:
       n = sprintf(str, "%" PRId64, *(int64_t*)buf);
       break;
-  
+
     case TSDB_DATA_TYPE_FLOAT:
       n = sprintf(str, "%f", GET_FLOAT_VAL(buf));
       break;
-  
+
     case TSDB_DATA_TYPE_DOUBLE:
       n = sprintf(str, "%f", GET_DOUBLE_VAL(buf));
       break;
-  
+
     case TSDB_DATA_TYPE_BINARY:
     case TSDB_DATA_TYPE_NCHAR:
       if (bufSize < 0) {
         tscError("invalid buf size");
         return TSDB_CODE_TSC_INVALID_VALUE;
       }
-      
+
       *str = '"';
       memcpy(str + 1, buf, bufSize);
       *(str + bufSize + 1) = '"';
       n = bufSize + 2;
       break;
-  
+
     default:
       tscError("unsupported type:%d", type);
       return TSDB_CODE_TSC_INVALID_VALUE;
@@ -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;
@@ -297,7 +316,7 @@ bool tscHasColumnFilter(SQueryInfo* pQueryInfo) {
 
   size_t size = taosArrayGetSize(pQueryInfo->colList);
   for (int32_t i = 0; i < size; ++i) {
-    SColumn* pCol = taosArrayGet(pQueryInfo->colList, i);
+    SColumn* pCol = taosArrayGetP(pQueryInfo->colList, i);
     if (pCol->info.flist.numOfFilters > 0) {
       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;
     }
@@ -1186,7 +1218,7 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
     SOperatorInfo* pSourceOperator = createDummyInputOperator(pSqlObjList[0], pSchema, numOfCol1, pFilterInfo, numOfFilterCols);
 
     pOutput->precision = pSqlObjList[0]->res.precision;
-    
+
     SSchema* schema = NULL;
     if (px->numOfTables > 1) {
       SOperatorInfo** p = calloc(px->numOfTables, POINTER_BYTES);
@@ -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);
 
@@ -1535,6 +1573,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;
@@ -1782,7 +1861,7 @@ static void extractTableNameList(SInsertStatementParam *pInsertParam, bool freeB
 }
 
 int32_t tscMergeTableDataBlocks(SInsertStatementParam *pInsertParam, bool freeBlockMap) {
-  const int INSERT_HEAD_SIZE = sizeof(SMsgDesc) + sizeof(SSubmitMsg); 
+  const int INSERT_HEAD_SIZE = sizeof(SMsgDesc) + sizeof(SSubmitMsg);
 
   void* pVnodeDataBlockHashList = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
   SArray* pVnodeDataBlockList = taosArrayInit(8, POINTER_BYTES);
@@ -2126,7 +2205,7 @@ void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc, const SArr
         assert(pfield->pExpr->pExpr != NULL);
         p.pExpr = calloc(1, sizeof(SExprInfo));
         tscExprAssign(p.pExpr, pfield->pExpr);
-      }    
+      }
 
       taosArrayPush(pFieldInfo->internalField, &p);
     }
@@ -2985,8 +3064,9 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
   pQueryInfo->tsBuf          = NULL;
   pQueryInfo->fillType       = pSrc->fillType;
   pQueryInfo->fillVal        = NULL;
+  pQueryInfo->numOfFillVal   = 0;;
   pQueryInfo->clauseLimit    = pSrc->clauseLimit;
-  pQueryInfo->prjOffset      = pSrc->prjOffset;  
+  pQueryInfo->prjOffset      = pSrc->prjOffset;
   pQueryInfo->numOfTables    = 0;
   pQueryInfo->window         = pSrc->window;
   pQueryInfo->sessionWindow  = pSrc->sessionWindow;
@@ -3020,11 +3100,12 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
   }
 
   if (pSrc->fillType != TSDB_FILL_NONE) {
-    pQueryInfo->fillVal = malloc(pSrc->fieldsInfo.numOfOutput * sizeof(int64_t));
+    pQueryInfo->fillVal = calloc(1, pSrc->fieldsInfo.numOfOutput * sizeof(int64_t));
     if (pQueryInfo->fillVal == NULL) {
       code = TSDB_CODE_TSC_OUT_OF_MEMORY;
       goto _error;
     }
+    pQueryInfo->numOfFillVal = pSrc->fieldsInfo.numOfOutput;
 
     memcpy(pQueryInfo->fillVal, pSrc->fillVal, pSrc->fieldsInfo.numOfOutput * sizeof(int64_t));
   }
@@ -3056,6 +3137,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;
 }
@@ -3102,7 +3191,9 @@ void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo) {
     info->vgInfo.epAddr[j].fqdn = strdup(pInfo->vgInfo.epAddr[j].fqdn);
   }
 
-  info->itemList = taosArrayDup(pInfo->itemList);
+  if (pInfo->itemList) {
+    info->itemList = taosArrayDup(pInfo->itemList);
+  }
 }
 
 SArray* tscVgroupTableInfoDup(SArray* pVgroupTables) {
@@ -3353,6 +3444,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;
 
@@ -3366,11 +3462,13 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
   pNewQueryInfo->tsBuf  = NULL;
   pNewQueryInfo->fillType = pQueryInfo->fillType;
   pNewQueryInfo->fillVal  = NULL;
+  pNewQueryInfo->numOfFillVal = 0;
   pNewQueryInfo->clauseLimit = pQueryInfo->clauseLimit;
   pNewQueryInfo->prjOffset = pQueryInfo->prjOffset;
   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;
@@ -3396,11 +3494,14 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
   }
 
   if (pQueryInfo->fillType != TSDB_FILL_NONE) {
-    pNewQueryInfo->fillVal = malloc(pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
+    //just make memory memory sanitizer happy  
+    //refator later
+    pNewQueryInfo->fillVal = calloc(1, pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
     if (pNewQueryInfo->fillVal == NULL) {
       terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
       goto _error;
     }
+    pNewQueryInfo->numOfFillVal = pQueryInfo->fieldsInfo.numOfOutput;
 
     memcpy(pNewQueryInfo->fillVal, pQueryInfo->fillVal, pQueryInfo->fieldsInfo.numOfOutput * sizeof(int64_t));
   }
@@ -4210,7 +4311,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;
 
@@ -4277,8 +4378,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);
     }
   }
 
@@ -4354,7 +4461,8 @@ 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;
   } else {
@@ -4420,7 +4528,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
 
   if (pQueryAttr->fillType != TSDB_FILL_NONE) {
     pQueryAttr->fillVal = calloc(pQueryAttr->numOfOutput, sizeof(int64_t));
-    memcpy(pQueryAttr->fillVal, pQueryInfo->fillVal, pQueryAttr->numOfOutput * sizeof(int64_t));
+    memcpy(pQueryAttr->fillVal, pQueryInfo->fillVal, pQueryInfo->numOfFillVal * sizeof(int64_t));
   }
 
   pQueryAttr->srcRowSize = 0;
diff --git a/src/common/inc/tcmdtype.h b/src/common/inc/tcmdtype.h
index 4331ddbf89..bd2c2e46f8 100644
--- a/src/common/inc/tcmdtype.h
+++ b/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" ) 
diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h
index e3989a1deb..4f04a82f0a 100644
--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -31,6 +31,14 @@ extern "C" {
     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); \
diff --git a/src/common/src/tarithoperator.c b/src/common/src/tarithoperator.c
index b37e358b9c..3779303e1a 100644
--- a/src/common/src/tarithoperator.c
+++ b/src/common/src/tarithoperator.c
@@ -18,7 +18,58 @@
 #include "ttype.h"
 #include "tutil.h"
 #include "tarithoperator.h"
+#include "tcompare.h"
 
+//GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i]));                                
+#define ARRAY_LIST_OP_DIV(left, right, _left_type, _right_type, len1, len2, out, op, _res_type, _ord) \
+  {                                                                                                   \
+    int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;                                 \
+    int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1;                                               \
+                                                                                                      \
+    if ((len1) == (len2)) {                                                                           \
+      for (; i < (len2) && i >= 0; i += step, (out) += 1) {                                           \
+        if (isNull((char *)&((left)[i]), _left_type) || isNull((char *)&((right)[i]), _right_type)) { \
+          SET_DOUBLE_NULL(out);                                                                       \
+          continue;                                                                                   \
+        }                                                                                             \
+        double v, z = 0.0;                                                                            \
+        GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i]));                                \
+        if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) {                                   \
+          SET_DOUBLE_NULL(out);                                                                       \
+          continue;                                                                                   \
+        }                                                                                             \
+        *(out) = (double)(left)[i] op(right)[i];                                                      \
+      }                                                                                               \
+    } else if ((len1) == 1) {                                                                         \
+      for (; i >= 0 && i < (len2); i += step, (out) += 1) {                                           \
+        if (isNull((char *)(left), _left_type) || isNull((char *)&(right)[i], _right_type)) {         \
+          SET_DOUBLE_NULL(out);                                                                       \
+          continue;                                                                                   \
+        }                                                                                             \
+        double v, z = 0.0;                                                                            \
+        GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i]));                                \
+        if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) {                                   \
+          SET_DOUBLE_NULL(out);                                                                       \
+          continue;                                                                                   \
+        }                                                                                             \
+        *(out) = (double)(left)[0] op(right)[i];                                                      \
+      }                                                                                               \
+    } else if ((len2) == 1) {                                                                         \
+      for (; i >= 0 && i < (len1); i += step, (out) += 1) {                                           \
+        if (isNull((char *)&(left)[i], _left_type) || isNull((char *)(right), _right_type)) {         \
+          SET_DOUBLE_NULL(out);                                                                       \
+          continue;                                                                                   \
+        }                                                                                             \
+        double v, z = 0.0;                                                                            \
+        GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[0]));                                \
+        if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) {                                   \
+          SET_DOUBLE_NULL(out);                                                                       \
+          continue;                                                                                   \
+        }                                                                                             \
+        *(out) = (double)(left)[i] op(right)[0];                                                      \
+      }                                                                                               \
+    }                                                                                                 \
+  } 
 #define ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, op, _res_type, _ord)     \
   {                                                                                                   \
     int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;                                 \
@@ -62,6 +113,12 @@
           SET_DOUBLE_NULL(out);                                                                       \
           continue;                                                                                   \
         }                                                                                             \
+        double v, z = 0.0;                                                                            \
+        GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i]));                                \
+        if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) {                                   \
+          SET_DOUBLE_NULL(out);                                                                       \
+          continue;                                                                                   \
+        }                                                                                             \
         *(out) = (double)(left)[i] - ((int64_t)(((double)(left)[i]) / (right)[i])) * (right)[i];      \
       }                                                                                               \
     } else if (len1 == 1) {                                                                           \
@@ -70,6 +127,12 @@
           SET_DOUBLE_NULL(out);                                                                       \
           continue;                                                                                   \
         }                                                                                             \
+        double v, z = 0.0;                                                                            \
+        GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[i]));                                \
+        if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) {                                   \
+          SET_DOUBLE_NULL(out);                                                                       \
+          continue;                                                                                   \
+        }                                                                                             \
         *(out) = (double)(left)[0] - ((int64_t)(((double)(left)[0]) / (right)[i])) * (right)[i];      \
       }                                                                                               \
     } else if ((len2) == 1) {                                                                         \
@@ -78,6 +141,12 @@
           SET_DOUBLE_NULL(out);                                                                       \
           continue;                                                                                   \
         }                                                                                             \
+        double v, z = 0.0;                                                                            \
+        GET_TYPED_DATA(v, double, _right_type, (char *)&((right)[0]));                                \
+        if (getComparFunc(TSDB_DATA_TYPE_DOUBLE, 0)(&v, &z) == 0) {                                   \
+          SET_DOUBLE_NULL(out);                                                                       \
+          continue;                                                                                   \
+        }                                                                                             \
         *(out) = (double)(left)[i] - ((int64_t)(((double)(left)[i]) / (right)[0])) * (right)[0];      \
       }                                                                                               \
     }                                                                                                 \
@@ -90,7 +159,7 @@
 #define ARRAY_LIST_MULTI(left, right, _left_type, _right_type, len1, len2, out, _ord) \
   ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, *, TSDB_DATA_TYPE_DOUBLE, _ord)
 #define ARRAY_LIST_DIV(left, right, _left_type, _right_type, len1, len2, out, _ord) \
-  ARRAY_LIST_OP(left, right, _left_type, _right_type, len1, len2, out, /, TSDB_DATA_TYPE_DOUBLE, _ord)
+  ARRAY_LIST_OP_DIV(left, right, _left_type, _right_type, len1, len2, out, /, TSDB_DATA_TYPE_DOUBLE, _ord)
 #define ARRAY_LIST_REM(left, right, _left_type, _right_type, len1, len2, out, _ord) \
   ARRAY_LIST_OP_REM(left, right, _left_type, _right_type, len1, len2, out, %, TSDB_DATA_TYPE_DOUBLE, _ord)
 
diff --git a/src/connector/go b/src/connector/go
index b8f76da4a7..7a26c432f8 160000
--- a/src/connector/go
+++ b/src/connector/go
@@ -1 +1 @@
-Subproject commit b8f76da4a708d158ec3cc4b844571dc4414e36b4
+Subproject commit 7a26c432f8b4203e42344ff3290b9b9b01b983d5
diff --git a/src/connector/grafanaplugin b/src/connector/grafanaplugin
index 3530c6df09..23cf0b9335 160000
--- a/src/connector/grafanaplugin
+++ b/src/connector/grafanaplugin
@@ -1 +1 @@
-Subproject commit 3530c6df097134a410bacec6b3cd013ef38a61aa
+Subproject commit 23cf0b933510af5e87b61bace0f6ff2f06d8eaac
diff --git a/src/connector/hivemq-tdengine-extension b/src/connector/hivemq-tdengine-extension
index ce52010141..b62a26ecc1 160000
--- a/src/connector/hivemq-tdengine-extension
+++ b/src/connector/hivemq-tdengine-extension
@@ -1 +1 @@
-Subproject commit ce5201014136503d34fecbd56494b67b4961056c
+Subproject commit b62a26ecc164a310104df57691691b237e091c89
diff --git a/src/dnode/CMakeLists.txt b/src/dnode/CMakeLists.txt
index e7ac1be5b1..47186130ea 100644
--- a/src/dnode/CMakeLists.txt
+++ b/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)
diff --git a/src/dnode/src/dnodeMain.c b/src/dnode/src/dnodeMain.c
index 61b11579bf..7723b6221b 100644
--- a/src/dnode/src/dnodeMain.c
+++ b/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[] = {
@@ -266,7 +268,7 @@ static int32_t dnodeInitStorage() {
       return -1;
     }
   }
-  //TODO(dengyihao): no need to init here 
+  //TODO(dengyihao): no need to init here
   if (dnodeCreateDir(tsMnodeDir) < 0) {
    dError("failed to create dir: %s, reason: %s", tsMnodeDir, strerror(errno));
    return -1;
diff --git a/src/dnode/src/dnodeShell.c b/src/dnode/src/dnodeShell.c
index 2f83e5f6dc..5606681f0f 100644
--- a/src/dnode/src/dnodeShell.c
+++ b/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;
 
diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c
index bbf257ff95..ff2d12f001 100644
--- a/src/dnode/src/dnodeVWrite.c
+++ b/src/dnode/src/dnodeVWrite.c
@@ -202,12 +202,12 @@ static void *dnodeProcessVWriteQueue(void *wparam) {
     for (int32_t i = 0; i < numOfMsgs; ++i) {
       taosGetQitem(pWorker->qall, &qtype, (void **)&pWrite);
       dTrace("msg:%p, app:%p type:%s will be processed in vwrite queue, qtype:%s hver:%" PRIu64, pWrite,
-             pWrite->rpcMsg.ahandle, taosMsg[pWrite->pHead.msgType], qtypeStr[qtype], pWrite->pHead.version);
+             pWrite->rpcMsg.ahandle, taosMsg[pWrite->walHead.msgType], qtypeStr[qtype], pWrite->walHead.version);
 
-      pWrite->code = vnodeProcessWrite(pVnode, &pWrite->pHead, qtype, pWrite);
+      pWrite->code = vnodeProcessWrite(pVnode, &pWrite->walHead, qtype, pWrite);
       if (pWrite->code <= 0) atomic_add_fetch_32(&pWrite->processedCount, 1);
       if (pWrite->code > 0) pWrite->code = 0;
-      if (pWrite->code == 0 && pWrite->pHead.msgType != TSDB_MSG_TYPE_SUBMIT) forceFsync = true;
+      if (pWrite->code == 0 && pWrite->walHead.msgType != TSDB_MSG_TYPE_SUBMIT) forceFsync = true;
 
       dTrace("msg:%p is processed in vwrite queue, code:0x%x", pWrite, pWrite->code);
     }
@@ -222,7 +222,7 @@ static void *dnodeProcessVWriteQueue(void *wparam) {
         dnodeSendRpcVWriteRsp(pVnode, pWrite, pWrite->code);
       } else {
         if (qtype == TAOS_QTYPE_FWD) {
-          vnodeConfirmForward(pVnode, pWrite->pHead.version, pWrite->code, pWrite->pHead.msgType != TSDB_MSG_TYPE_SUBMIT);
+          vnodeConfirmForward(pVnode, pWrite->walHead.version, pWrite->code, pWrite->walHead.msgType != TSDB_MSG_TYPE_SUBMIT);
         }
         if (pWrite->rspRet.rsp) {
           rpcFreeCont(pWrite->rspRet.rsp);
diff --git a/src/inc/query.h b/src/inc/query.h
index 38078cf21f..fb9cbff858 100644
--- a/src/inc/query.h
+++ b/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);
 
 
 /**
diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index d5c13885d5..56118b0a76 100644
--- a/src/inc/taosdef.h
+++ b/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
@@ -332,6 +336,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
diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index fe8671e105..0645f2e8b3 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -100,7 +100,8 @@ 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_LINE_SYNTAX_ERROR         TAOS_DEF_ERROR_CODE(0, 0x0220)  //"Syntax error in Line")
+#define TSDB_CODE_TSC_FILE_EMPTY                TAOS_DEF_ERROR_CODE(0, 0x021A)  //"File is empty")
+#define TSDB_CODE_TSC_LINE_SYNTAX_ERROR         TAOS_DEF_ERROR_CODE(0, 0x021B)  //"Syntax error in Line")
 
 // mnode
 #define TSDB_CODE_MND_MSG_NOT_PROCESSED         TAOS_DEF_ERROR_CODE(0, 0x0300)  //"Message not processed")
@@ -175,6 +176,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")
@@ -262,6 +270,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
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 4e76b6dcc1..1ad4e18bd0 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -77,8 +77,10 @@ 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_DROP_DB, "drop-db" )	  
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_USE_DB, "use-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" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_CREATE_TABLE, "create-table" )
@@ -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;
 
@@ -760,12 +802,13 @@ typedef struct STableMetaMsg {
 } STableMetaMsg;
 
 typedef struct SMultiTableMeta {
-  int32_t  numOfTables;
-  int32_t  numOfVgroup;
-  uint32_t contLen:31;
-  uint8_t  compressed:1;      // denote if compressed or not
-  uint32_t rawLen;            // size before compress
-  char     meta[];
+  int32_t       numOfTables;
+  int32_t       numOfVgroup;
+  int32_t       numOfUdf;
+  int32_t       contLen;
+  uint8_t       compressed;      // denote if compressed or not
+  uint32_t      rawLen;          // size before compress
+  char          meta[];
 } SMultiTableMeta;
 
 typedef struct {
diff --git a/src/inc/tcq.h b/src/inc/tcq.h
index 7549c3d498..27c043f960 100644
--- a/src/inc/tcq.h
+++ b/src/inc/tcq.h
@@ -27,7 +27,7 @@ typedef struct {
   int32_t  vgId;
   char     user[TSDB_USER_LEN];
   char     pass[TSDB_KEY_LEN];
-  char     db[TSDB_DB_NAME_LEN];
+  char     db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
   FCqWrite cqWrite;
 } SCqCfg;
 
diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index d15f044b65..e89fed6282 100644
--- a/src/inc/ttokendef.h
+++ b/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
diff --git a/src/inc/ttype.h b/src/inc/ttype.h
index 9949f31c59..8eaa52f90a 100644
--- a/src/inc/ttype.h
+++ b/src/inc/ttype.h
@@ -28,6 +28,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)
 
diff --git a/src/inc/vnode.h b/src/inc/vnode.h
index f31a5e36e8..b3291645c0 100644
--- a/src/inc/vnode.h
+++ b/src/inc/vnode.h
@@ -49,7 +49,7 @@ typedef struct {
   SRpcMsg  rpcMsg;
   SRspRet  rspRet;
   char     reserveForSync[24];
-  SWalHead pHead;
+  SWalHead walHead;
 } SVWriteMsg;
 
 // vnodeStatus
diff --git a/src/kit/shell/CMakeLists.txt b/src/kit/shell/CMakeLists.txt
index 794ca5e2de..bf2bbca14d 100644
--- a/src/kit/shell/CMakeLists.txt
+++ b/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)
diff --git a/src/kit/taosdemo/CMakeLists.txt b/src/kit/taosdemo/CMakeLists.txt
index 584de34094..2034093ad5 100644
--- a/src/kit/taosdemo/CMakeLists.txt
+++ b/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 ()
 
diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 0327df5a62..9e8526bfe4 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -106,9 +106,9 @@ enum TEST_MODE {
 
 
 typedef enum CREATE_SUB_TALBE_MOD_EN {
-  PRE_CREATE_SUBTBL,
-  AUTO_CREATE_SUBTBL,
-  NO_CREATE_SUBTBL
+    PRE_CREATE_SUBTBL,
+    AUTO_CREATE_SUBTBL,
+    NO_CREATE_SUBTBL
 } CREATE_SUB_TALBE_MOD_EN;
 
 typedef enum TALBE_EXISTS_EN {
@@ -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",
-                  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);
-          prompt();
-          g_Dbs.db[i].superTbls[j].interlaceRows = g_args.num_of_RPR;
+
+        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_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_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;
 
-    retLen = generateData(data, data_type,
-            startTime + getTSRandTail(
-                (int64_t) DEFAULT_TIMESTAMP_STEP, k,
-                g_args.disorderRatio,
-                g_args.disorderRange),
-            lenOfBinary);
+    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;
@@ -5200,14 +5216,14 @@ static int32_t generateStbDataTail(
 
   bool tsRand;
   if (0 == strncasecmp(superTblInfo->dataSource, "rand", strlen("rand"))) {
-      tsRand = true;
+     tsRand = true;
   } else {
-      tsRand = false;
+     tsRand = false;
   }
   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;
-        *bind_ts = startTime + getTSRandTail(
-                (int64_t)DEFAULT_TIMESTAMP_STEP, k,
-                g_args.disorderRatio,
-                g_args.disorderRange);
+
+        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(
@@ -5992,7 +6051,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 +6068,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 +6297,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 +6727,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",
diff --git a/src/mnode/inc/mnodeDef.h b/src/mnode/inc/mnodeDef.h
index e8cf7e30ac..e974251d2e 100644
--- a/src/mnode/inc/mnodeDef.h
+++ b/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];
diff --git a/src/mnode/inc/mnodeFunc.h b/src/mnode/inc/mnodeFunc.h
new file mode 100644
index 0000000000..e33f3fb567
--- /dev/null
+++ b/src/mnode/inc/mnodeFunc.h
@@ -0,0 +1,40 @@
+/*
+ * 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
diff --git a/src/mnode/inc/mnodeSdb.h b/src/mnode/inc/mnodeSdb.h
index 2ae0c47902..25b841ef34 100644
--- a/src/mnode/inc/mnodeSdb.h
+++ b/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 {
@@ -112,4 +113,4 @@ int32_t mnodeCompactWal();
 }
 #endif
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c
index f4fc88476f..9602e16483 100644
--- a/src/mnode/src/mnodeDb.c
+++ b/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;
 
diff --git a/src/mnode/src/mnodeFunc.c b/src/mnode/src/mnodeFunc.c
new file mode 100644
index 0000000000..253958efbe
--- /dev/null
+++ b/src/mnode/src/mnodeFunc.c
@@ -0,0 +1,485 @@
+/*
+ * 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;
+}
diff --git a/src/mnode/src/mnodeMain.c b/src/mnode/src/mnodeMain.c
index 8ce798c8ec..df3c49165c 100644
--- a/src/mnode/src/mnodeMain.c
+++ b/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},
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 6dc2f8ad28..c76a00b8cf 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/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
@@ -104,6 +105,20 @@ static void mnodeDestroyChildTable(SCTableObj *pTable) {
   tfree(pTable);
 }
 
+static char* mnodeGetTableShowPattern(SShowObj *pShow) {
+  char* pattern = NULL;
+  if (pShow != NULL && pShow->payloadLen > 0) {
+    pattern = (char*)malloc(pShow->payloadLen + 1);
+    if (pattern == NULL) {
+      terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
+      return NULL;
+    }
+    memcpy(pattern, pShow->payload, pShow->payloadLen);
+    pattern[pShow->payloadLen] = 0;
+  }
+  return pattern;
+}
+
 static int32_t mnodeChildTableActionDestroy(SSdbRow *pRow) {
   mnodeDestroyChildTable(pRow->pObj);
   return TSDB_CODE_SUCCESS;
@@ -1620,6 +1635,11 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
   SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
   char stableName[TSDB_TABLE_NAME_LEN] = {0};
 
+  char* pattern = mnodeGetTableShowPattern(pShow);
+  if (pShow->payloadLen > 0 && pattern == NULL) {
+    return 0;
+  }
+
   while (numOfRows < rows) {
     pShow->pIter = mnodeGetNextSuperTable(pShow->pIter, &pTable);
     if (pTable == NULL) break;
@@ -1631,7 +1651,7 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
     memset(stableName, 0, tListLen(stableName));
     mnodeExtractTableName(pTable->info.tableId, stableName);
 
-    if (pShow->payloadLen > 0 && patternMatch(pShow->payload, stableName, sizeof(stableName) - 1, &info) != TSDB_PATTERN_MATCH) {
+    if (pShow->payloadLen > 0 && patternMatch(pattern, stableName, sizeof(stableName) - 1, &info) != TSDB_PATTERN_MATCH) {
       mnodeDecTableRef(pTable);
       continue;
     }
@@ -1671,6 +1691,7 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
 
   mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   mnodeDecDbRef(pDb);
+  free(pattern);
 
   return numOfRows;
 }
@@ -2906,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);
 
@@ -2914,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;
@@ -2991,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]);
   }
 
@@ -3023,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;
@@ -3033,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 {
@@ -3157,15 +3212,9 @@ static int32_t mnodeRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows
   char prefix[64] = {0};
   int32_t prefixLen = (int32_t)tableIdPrefix(pDb->name, prefix, 64);
 
-  char* pattern = NULL;
-  if (pShow->payloadLen > 0) {
-    pattern = (char*)malloc(pShow->payloadLen + 1);
-    if (pattern == NULL) {
-      terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
-      return 0;
-    }
-    memcpy(pattern, pShow->payload, pShow->payloadLen);
-    pattern[pShow->payloadLen] = 0;
+  char* pattern = mnodeGetTableShowPattern(pShow);
+  if (pShow->payloadLen > 0 && pattern == NULL) {
+    return 0;
   }
 
   while (numOfRows < rows) {
@@ -3397,6 +3446,11 @@ static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t ro
   strcat(prefix, TS_PATH_DELIMITER);
   int32_t prefixLen = (int32_t)strlen(prefix);
 
+  char* pattern = mnodeGetTableShowPattern(pShow);
+  if (pShow->payloadLen > 0 && pattern == NULL) {
+    return 0;
+  }
+
   while (numOfRows < rows) {
     pShow->pIter = mnodeGetNextChildTable(pShow->pIter, &pTable);
     if (pTable == NULL) break;
@@ -3412,7 +3466,7 @@ static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t ro
     // pattern compare for table name
     mnodeExtractTableName(pTable->info.tableId, tableName);
 
-    if (pShow->payloadLen > 0 && patternMatch(pShow->payload, tableName, sizeof(tableName) - 1, &info) != TSDB_PATTERN_MATCH) {
+    if (pShow->payloadLen > 0 && patternMatch(pattern, tableName, sizeof(tableName) - 1, &info) != TSDB_PATTERN_MATCH) {
       mnodeDecTableRef(pTable);
       continue;
     }
@@ -3444,6 +3498,7 @@ static int32_t mnodeRetrieveStreamTables(SShowObj *pShow, char *data, int32_t ro
 
   mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   mnodeDecDbRef(pDb);
+  free(pattern);
 
   return numOfRows;
 }
diff --git a/src/os/inc/os.h b/src/os/inc/os.h
index 903e80d5c7..e91edaab0f 100644
--- a/src/os/inc/os.h
+++ b/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();
 
diff --git a/src/os/inc/osArm32.h b/src/os/inc/osArm32.h
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/os/inc/osArm64.h b/src/os/inc/osArm64.h
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/os/inc/osInc.h b/src/os/inc/osInc.h
index 6a3c754dcc..340ff34635 100644
--- a/src/os/inc/osInc.h
+++ b/src/os/inc/osInc.h
@@ -76,7 +76,8 @@ extern "C" {
     #include <dispatch/dispatch.h>
     #include "osEok.h"
   #else
-    #include <argp.h> 
+    #include <argp.h>
+    #include <dlfcn.h>
     #include <endian.h>
     #include <linux/sysctl.h>
     #include <poll.h>
diff --git a/src/os/inc/osLinux32.h b/src/os/inc/osLinux32.h
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/os/inc/osLinux64.h b/src/os/inc/osLinux64.h
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/os/inc/osSystem.h b/src/os/inc/osSystem.h
new file mode 100644
index 0000000000..e7a3ec13ae
--- /dev/null
+++ b/src/os/inc/osSystem.h
@@ -0,0 +1,31 @@
+/*
+ * 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
diff --git a/src/os/src/darwin/darwinSystem.c b/src/os/src/darwin/darwinSystem.c
new file mode 100644
index 0000000000..17cafdd664
--- /dev/null
+++ b/src/os/src/darwin/darwinSystem.c
@@ -0,0 +1,32 @@
+/*
+ * 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) {
+}
+
+
diff --git a/src/os/src/linux/CMakeLists.txt b/src/os/src/linux/CMakeLists.txt
index d1d95b0096..f60c10b65a 100644
--- a/src/os/src/linux/CMakeLists.txt
+++ b/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)
\ No newline at end of file
+TARGET_LINK_LIBRARIES(oslinux m rt z dl)
\ No newline at end of file
diff --git a/src/os/src/linux/osSystem.c b/src/os/src/linux/osSystem.c
new file mode 100644
index 0000000000..052b7a22a8
--- /dev/null
+++ b/src/os/src/linux/osSystem.c
@@ -0,0 +1,54 @@
+/*
+ * 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);
+  }
+}
+
+
diff --git a/src/os/src/windows/wSystem.c b/src/os/src/windows/wSystem.c
new file mode 100644
index 0000000000..17cafdd664
--- /dev/null
+++ b/src/os/src/windows/wSystem.c
@@ -0,0 +1,32 @@
+/*
+ * 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) {
+}
+
+
diff --git a/src/plugins/http/inc/httpParser.h b/src/plugins/http/inc/httpParser.h
index c7cf7a9608..fbe1ecee7e 100644
--- a/src/plugins/http/inc/httpParser.h
+++ b/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
diff --git a/src/plugins/http/src/httpRestHandle.c b/src/plugins/http/src/httpRestHandle.c
index 8728b9e37a..a285670d20 100644
--- a/src/plugins/http/src/httpRestHandle.c
+++ b/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 {
   }
 
diff --git a/src/query/CMakeLists.txt b/src/query/CMakeLists.txt
index d2411d47b5..fd730adee5 100644
--- a/src/query/CMakeLists.txt
+++ b/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 ()
diff --git a/src/query/inc/qAggMain.h b/src/query/inc/qAggMain.h
index 044c538f47..d4116fbfb2 100644
--- a/src/query/inc/qAggMain.h
+++ b/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)
@@ -262,9 +261,9 @@ bool topbot_datablock_filter(SQLFunctionCtx *pCtx, const char *minval, const cha
 static FORCE_INLINE void initResultInfo(SResultRowCellInfo *pResInfo, int32_t bufLen) {
   pResInfo->initialized = true;  // the this struct has been initialized flag
   
-  pResInfo->complete = false;
+  pResInfo->complete  = false;
   pResInfo->hasResult = false;
-  pResInfo->numOfRes = 0;
+  pResInfo->numOfRes  = 0;
   
   memset(GET_ROWCELL_INTERBUF(pResInfo), 0, bufLen);
 }
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index c4276bfe37..4581ba258d 100644
--- a/src/query/inc/qExecutor.h
+++ b/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
diff --git a/src/query/inc/qScript.h b/src/query/inc/qScript.h
new file mode 100644
index 0000000000..574bb51368
--- /dev/null
+++ b/src/query/inc/qScript.h
@@ -0,0 +1,82 @@
+/*
+ * 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 
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index f9a9992b81..f2ab2182a1 100644
--- a/src/query/inc/qSqlparser.h
+++ b/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;
@@ -214,10 +223,11 @@ typedef struct SMiscInfo {
   int16_t            tableType;
   SUserInfo          user;
   union {
-    SCreateDbInfo    dbOpt;
-    SCreateAcctInfo  acctOpt;
-    SShowInfo        showOpt;
-    SStrToken        id;
+    SCreateDbInfo   dbOpt;
+    SCreateAcctInfo acctOpt;
+    SCreateFuncInfo funcOpt;
+    SShowInfo       showOpt;
+    SStrToken       id;
   };
 } SMiscInfo;
 
@@ -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);
diff --git a/src/query/inc/qTableMeta.h b/src/query/inc/qTableMeta.h
index 7ec6dfbcf9..56eea6429f 100644
--- a/src/query/inc/qTableMeta.h
+++ b/src/query/inc/qTableMeta.h
@@ -106,11 +106,14 @@ typedef struct SQueryInfo {
   STagCond         tagCond;
 
   SOrderVal        order;
-  int16_t          fillType;      // final result fill type
   int16_t          numOfTables;
   STableMetaInfo **pTableMetaInfo;
   struct STSBuf   *tsBuf;
+
+  int16_t          fillType;      // final result fill type
   int64_t *        fillVal;       // default value for fill
+  int32_t          numOfFillVal;  // fill value size
+
   char *           msg;           // pointer to the pCmd->payload to keep error message temporarily
   int64_t          clauseLimit;   // limit for current sub clause
 
@@ -122,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>
@@ -138,6 +145,7 @@ typedef struct SQueryInfo {
   bool               onlyTagQuery;
   bool               orderProjectQuery;
   bool               stateWindow;
+  bool               globalMerge;
 } SQueryInfo;
 
 /**
diff --git a/src/query/inc/qUdf.h b/src/query/inc/qUdf.h
new file mode 100644
index 0000000000..1083b1e698
--- /dev/null
+++ b/src/query/inc/qUdf.h
@@ -0,0 +1,74 @@
+/*
+ * 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
diff --git a/src/query/inc/qUtil.h b/src/query/inc/qUtil.h
index c8741030c0..b31a93fd2d 100644
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
@@ -104,4 +104,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
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index abd7d06b60..ecdde4f707 100644
--- a/src/query/inc/sql.y
+++ b/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);}
diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index 7412b5f021..93e6de3821 100644
--- a/src/query/src/qAggMain.c
+++ b/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);
@@ -288,7 +304,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
       return TSDB_CODE_SUCCESS;
     }
   }
-  
+
   if (functionId == TSDB_FUNC_SUM) {
     if (IS_SIGNED_NUMERIC_TYPE(dataType)) {
       *type = TSDB_DATA_TYPE_BIGINT;
@@ -313,7 +329,20 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
     *interBytes = sizeof(STwaInfo);
     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;
   }
   
@@ -1606,7 +1634,7 @@ static void last_function(SQLFunctionCtx *pCtx) {
       break;
     }
   }
-  
+
   SET_VAL(pCtx, notNullElems, 1);
 }
 
@@ -2007,7 +2035,7 @@ static void buildTopBotStruct(STopBotInfo *pTopBotInfo, SQLFunctionCtx *pCtx) {
   char *tmp = (char *)pTopBotInfo + sizeof(STopBotInfo);
   pTopBotInfo->res = (tValuePair**) tmp;
   tmp += POINTER_BYTES * pCtx->param[0].i64;
-  
+
   size_t size = sizeof(tValuePair) + pCtx->tagInfo.tagsLen;
 
   for (int32_t i = 0; i < pCtx->param[0].i64; ++i) {
@@ -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,12 +3313,10 @@ 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;
@@ -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;
@@ -3920,7 +3938,7 @@ static void irate_function(SQLFunctionCtx *pCtx) {
   int32_t    notNullElems = 0;
   SRateInfo *pRateInfo    = (SRateInfo *)GET_ROWCELL_INTERBUF(pResInfo);
   TSKEY     *primaryKey   = GET_TS_LIST(pCtx);
-  
+
   for (int32_t i = pCtx->size - 1; i >= 0; --i) {
     char *pData = GET_INPUT_DATA(pCtx, i);
     if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index ecbfe36ee3..0f3d56515d 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -29,10 +29,11 @@
 #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)
-#define IS_REPEAT_SCAN(runtime)        ((runtime)->scanFlag == REPEAT_SCAN) 
+#define IS_REPEAT_SCAN(runtime)        ((runtime)->scanFlag == REPEAT_SCAN)
 #define SET_MASTER_SCAN_FLAG(runtime)  ((runtime)->scanFlag = MASTER_SCAN)
 #define SET_REVERSE_SCAN_FLAG(runtime) ((runtime)->scanFlag = REVERSE_SCAN)
 
@@ -212,24 +213,24 @@ SArray* getOrderCheckColumns(SQueryAttr* pQuery);
 
 
 typedef struct SRowCompSupporter {
-  SQueryRuntimeEnv *pRuntimeEnv; 
+  SQueryRuntimeEnv *pRuntimeEnv;
   int16_t           dataOffset;
-  __compar_fn_t     comFunc; 
+  __compar_fn_t     comFunc;
 } SRowCompSupporter;
 
 static int compareRowData(const void *a, const void *b, const void *userData) {
-  const SResultRow *pRow1 = (const SResultRow *)a; 
+  const SResultRow *pRow1 = (const SResultRow *)a;
   const SResultRow *pRow2 = (const SResultRow *)b;
 
-  SRowCompSupporter *supporter  = (SRowCompSupporter *)userData; 
-  SQueryRuntimeEnv* pRuntimeEnv =  supporter->pRuntimeEnv;   
-  
+  SRowCompSupporter *supporter  = (SRowCompSupporter *)userData;
+  SQueryRuntimeEnv* pRuntimeEnv =  supporter->pRuntimeEnv;
+
   tFilePage *page1 = getResBufPage(pRuntimeEnv->pResultBuf, pRow1->pageId);
   tFilePage *page2 = getResBufPage(pRuntimeEnv->pResultBuf, pRow2->pageId);
 
-  int16_t offset = supporter->dataOffset; 
+  int16_t offset = supporter->dataOffset;
   char *in1  = getPosInResultPage(pRuntimeEnv->pQueryAttr, page1, pRow1->offset, offset);
-  char *in2  = getPosInResultPage(pRuntimeEnv->pQueryAttr, page2, pRow2->offset, offset);   
+  char *in2  = getPosInResultPage(pRuntimeEnv->pQueryAttr, page2, pRow2->offset, offset);
 
   return (in1 != NULL && in2 != NULL) ? supporter->comFunc(in1, in2) : 0;
 }
@@ -250,7 +251,7 @@ static void sortGroupResByOrderList(SGroupResInfo *pGroupResInfo, SQueryRuntimeE
 
   bool found = false;
   int16_t dataOffset = 0;
-   
+
   for (int32_t j = 0; j < pDataBlock->info.numOfCols; ++j) {
     SColumnInfoData* pColInfoData = (SColumnInfoData *)taosArrayGet(pDataBlock->pDataBlock, j);
     if (orderId == j) {
@@ -259,15 +260,15 @@ static void sortGroupResByOrderList(SGroupResInfo *pGroupResInfo, SQueryRuntimeE
     }
 
     dataOffset += pColInfoData->info.bytes;
-  }  
+  }
 
   if (found == false) {
     return;
   }
 
   int16_t type = pRuntimeEnv->pQueryAttr->pExpr1[orderId].base.resType;
-   
-  SRowCompSupporter support = {.pRuntimeEnv = pRuntimeEnv, .dataOffset = dataOffset, .comFunc = getComparFunc(type, 0)};  
+
+  SRowCompSupporter support = {.pRuntimeEnv = pRuntimeEnv, .dataOffset = dataOffset, .comFunc = getComparFunc(type, 0)};
   taosArraySortPWithExt(pGroupResInfo->pRows, compareRowData, &support);
 }
 
@@ -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
@@ -951,7 +1031,9 @@ static TSKEY getStartTsKey(SQueryAttr* pQueryAttr, STimeWindow* win, const TSKEY
 static void setArithParams(SArithmeticSupport* sas, SExprInfo *pExprInfo, SSDataBlock* pSDataBlock) {
   sas->numOfCols = (int32_t) pSDataBlock->info.numOfCols;
   sas->pExprInfo = pExprInfo;
-
+  if (sas->colList != NULL) {
+    return;
+  }
   sas->colList = calloc(1, pSDataBlock->info.numOfCols*sizeof(SColumnInfo));
   for(int32_t i = 0; i < sas->numOfCols; ++i) {
     SColumnInfoData* pColData = taosArrayGet(pSDataBlock->pDataBlock, i);
@@ -1016,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);
@@ -1048,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]);
+      }
     }
   }
 }
@@ -1064,7 +1160,15 @@ static void projectApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx
       pCtx[k].order = TSDB_ORDER_ASC;
     }
 
-    aAggs[pCtx[k].functionId].xFunction(&pCtx[k]);
+    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]);
+    }
   }
 }
 
@@ -1951,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;
       }
 
@@ -2022,6 +2126,8 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
     tfree(pRuntimeEnv->sasArray);
   }
 
+  destroyUdfInfo(pRuntimeEnv->pUdfInfo);
+
   destroyResultBuf(pRuntimeEnv->pResultBuf);
   doFreeQueryHandle(pRuntimeEnv);
 
@@ -2232,7 +2338,7 @@ static bool onlyFirstQuery(SQueryAttr *pQueryAttr) { return onlyOneQueryType(pQu
 
 static bool onlyLastQuery(SQueryAttr *pQueryAttr) { return onlyOneQueryType(pQueryAttr, TSDB_FUNC_LAST, TSDB_FUNC_LAST_DST); }
 
-static bool notContainSessionOrStateWindow(SQueryAttr *pQueryAttr) { return !(pQueryAttr->sw.gap > 0 || pQueryAttr->stateWindow); }  
+static bool notContainSessionOrStateWindow(SQueryAttr *pQueryAttr) { return !(pQueryAttr->sw.gap > 0 || pQueryAttr->stateWindow); }
 
 static int32_t updateBlockLoadStatus(SQueryAttr *pQuery, int32_t status) {
   bool hasFirstLastFunc = false;
@@ -2442,14 +2548,14 @@ static bool doFilterByBlockStatistics(SQueryRuntimeEnv* pRuntimeEnv, SDataStatis
     }
 
     SDataStatis* pDataBlockst = &pDataStatis[index];
-    
+
     if (pFilterInfo->info.type == TSDB_DATA_TYPE_FLOAT) {
       float minval = (float)(*(double *)(&pDataBlockst->min));
       float maxval = (float)(*(double *)(&pDataBlockst->max));
-       
+
       for (int32_t i = 0; i < pFilterInfo->numOfFilters; ++i) {
         if (pFilterInfo->pFilters[i].filterInfo.lowerRelOptr == TSDB_RELATION_IN) {
-           continue;   
+           continue;
         }
         ret &= pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&minval, (char *)&maxval, TSDB_DATA_TYPE_FLOAT);
         if (ret == false) {
@@ -2459,9 +2565,9 @@ static bool doFilterByBlockStatistics(SQueryRuntimeEnv* pRuntimeEnv, SDataStatis
     } else {
       for (int32_t i = 0; i < pFilterInfo->numOfFilters; ++i) {
         if (pFilterInfo->pFilters[i].filterInfo.lowerRelOptr == TSDB_RELATION_IN) {
-           continue; 
+           continue;
         }
-        ret &= pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&pDataBlockst->min, (char *)&pDataBlockst->max, pFilterInfo->info.type); 
+        ret &= pFilterInfo->pFilters[i].fp(&pFilterInfo->pFilters[i], (char *)&pDataBlockst->min, (char *)&pDataBlockst->max, pFilterInfo->info.type);
         if (ret == false) {
           return false;
         }
@@ -2701,9 +2807,14 @@ 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
-    status |= aAggs[functionId].dataReqFunc(&pTableScanInfo->pCtx[i], &pBlock->info.window, colId);
-    if ((status & BLK_DATA_ALL_NEEDED) == BLK_DATA_ALL_NEEDED) {
+    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;
+      }
     }
   }
 
@@ -3008,8 +3119,8 @@ void setTagValue(SOperatorInfo* pOperatorInfo, void *pTable, SQLFunctionCtx* pCt
       doSetTagValueInParam(pTable, pLocalExprInfo->base.colInfo.colId, &pCtx[idx].tag, pLocalExprInfo->base.resType,
                            pLocalExprInfo->base.resBytes);
 
-      if (IS_NUMERIC_TYPE(pLocalExprInfo->base.resType) 
-          || pLocalExprInfo->base.resType == TSDB_DATA_TYPE_BOOL 
+      if (IS_NUMERIC_TYPE(pLocalExprInfo->base.resType)
+          || pLocalExprInfo->base.resType == TSDB_DATA_TYPE_BOOL
           || pLocalExprInfo->base.resType == TSDB_DATA_TYPE_TIMESTAMP) {
         memcpy(pRuntimeEnv->tagVal + offset, &pCtx[idx].tag.i64, pLocalExprInfo->base.resBytes);
       } else {
@@ -3297,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]);
@@ -3304,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);
+    }
   }
 }
 
@@ -3359,9 +3489,15 @@ void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResult
       setResultOutputBuf(pRuntimeEnv, buf, pCtx, numOfOutput, rowCellInfoOffset);
 
       for (int32_t j = 0; j < numOfOutput; ++j) {
-        aAggs[pCtx[j].functionId].xFinalize(&pCtx[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
        * the top and bottom query
@@ -3371,7 +3507,11 @@ void finalizeQueryResult(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx, SResult
 
   } else {
     for (int32_t j = 0; j < numOfOutput; ++j) {
-      aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
+      if (pCtx[j].functionId < 0) {
+        doInvokeUdf(pRuntimeEnv->pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
+      } else {
+        aAggs[pCtx[j].functionId].xFinalize(&pCtx[j]);
+      }
     }
   }
 }
@@ -3457,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);
     }
   }
 }
@@ -3949,7 +4093,7 @@ void calculateOperatorProfResults(SQInfo* pQInfo) {
     qDebug("QInfo:0x%"PRIx64" operator prof results hash is null", pQInfo->qId);
     return;
   }
-  
+
   SArray* opStack = taosArrayInit(32, sizeof(SOperatorStackItem));
   if (opStack == NULL) {
     return;
@@ -4801,7 +4945,7 @@ void setTableScanFilterOperatorInfo(STableScanInfo* pTableScanInfo, SOperatorInf
     pTableScanInfo->pResultRowInfo = &pInfo->binfo.resultRowInfo;
     pTableScanInfo->rowCellInfoOffset = pInfo->binfo.rowCellInfoOffset;
   } else if (pDownstream->operatorType == OP_StateWindow) {
-    SStateWindowOperatorInfo* pInfo = pDownstream->info; 
+    SStateWindowOperatorInfo* pInfo = pDownstream->info;
 
     pTableScanInfo->pCtx = pInfo->binfo.pCtx;
     pTableScanInfo->pResultRowInfo = &pInfo->binfo.resultRowInfo;
@@ -4921,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 =
@@ -4931,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);
@@ -5460,7 +5605,7 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI
   TSKEY* tsList = (TSKEY*)pTsColInfoData->pData;
   if (IS_REPEAT_SCAN(pRuntimeEnv) && !pInfo->reptScan) {
     pInfo->reptScan = true;
-    tfree(pInfo->prevData); 
+    tfree(pInfo->prevData);
   }
 
   pInfo->numOfRows = 0;
@@ -5470,17 +5615,17 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI
       continue;
     }
     if (pInfo->prevData == NULL) {
-      pInfo->prevData = malloc(bytes); 
+      pInfo->prevData = malloc(bytes);
       memcpy(pInfo->prevData, val, bytes);
       pInfo->numOfRows = 1;
       pInfo->curWindow.skey = tsList[j];
       pInfo->curWindow.ekey = tsList[j];
-      pInfo->start = j; 
-      
+      pInfo->start = j;
+
     } else if (memcmp(pInfo->prevData, val, bytes) == 0) {
       pInfo->curWindow.ekey = tsList[j];
       pInfo->numOfRows += 1;
-      //pInfo->start = j;   
+      //pInfo->start = j;
       if (j == 0 && pInfo->start != 0) {
         pInfo->numOfRows = 1;
         pInfo->start = 0;
@@ -5502,7 +5647,7 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI
       memcpy(pInfo->prevData, val, bytes);
       pInfo->numOfRows = 1;
       pInfo->start = j;
-       
+
     }
   }
 
@@ -5555,10 +5700,10 @@ static SSDataBlock* doStateWindowAgg(void *param, bool* newgroup) {
     setInputDataBlock(pOperator, pBInfo->pCtx, pBlock, pQueryAttr->order.order);
     if (pWindowInfo->colIndex == -1) {
       pWindowInfo->colIndex = getGroupbyColumnIndex(pRuntimeEnv->pQueryAttr->pGroupbyExpr, pBlock);
-    } 
+    }
     doStateWindowAggImpl(pOperator,  pWindowInfo, pBlock);
   }
-  
+
   // restore the value
   pQueryAttr->order.order = order;
   pQueryAttr->window = win;
@@ -5576,7 +5721,7 @@ static SSDataBlock* doStateWindowAgg(void *param, bool* newgroup) {
   }
 
   return pBInfo->pRes->info.rows == 0? NULL:pBInfo->pRes;
-} 
+}
 static SSDataBlock* doSessionWindowAgg(void* param, bool* newgroup) {
   SOperatorInfo* pOperator = (SOperatorInfo*) param;
   if (pOperator->status == OP_EXEC_DONE) {
@@ -5691,7 +5836,7 @@ static SSDataBlock* hashGroupbyAggregate(void* param, bool* newgroup) {
     sortGroupResByOrderList(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pInfo->binfo.pRes);
   }
   toSSDataBlock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pInfo->binfo.pRes);
-  
+
   if (pInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) {
     pOperator->status = OP_EXEC_DONE;
   }
@@ -5984,8 +6129,13 @@ SColumnInfo* extractColumnFilterInfo(SExprInfo* pExpr, int32_t numOfOutput, int3
     pCols[i].colId = pExpr[i].base.resColId;
 
     pCols[i].flist.numOfFilters = pExpr[i].base.flist.numOfFilters;
-    pCols[i].flist.filterInfo = calloc(pCols[i].flist.numOfFilters, sizeof(SColumnFilterInfo));
-    memcpy(pCols[i].flist.filterInfo, pExpr[i].base.flist.filterInfo, pCols[i].flist.numOfFilters * sizeof(SColumnFilterInfo));
+    if (pCols[i].flist.numOfFilters != 0) { 
+      pCols[i].flist.filterInfo   = calloc(pCols[i].flist.numOfFilters, sizeof(SColumnFilterInfo));
+      memcpy(pCols[i].flist.filterInfo, pExpr[i].base.flist.filterInfo, pCols[i].flist.numOfFilters * sizeof(SColumnFilterInfo));
+    } else {
+      // avoid runtime error
+      pCols[i].flist.filterInfo   = NULL; 
+    }
   }
 
   assert(numOfFilter > 0);
@@ -6081,8 +6231,8 @@ SOperatorInfo* createStatewindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOpe
   pOperator->cleanup      = destroyStateWindowOperatorInfo;
 
   appendUpstream(pOperator, upstream);
-  return pOperator; 
-  
+  return pOperator;
+
 }
 SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput) {
   SSWindowOperatorInfo* pInfo = calloc(1, sizeof(SSWindowOperatorInfo));
@@ -6092,7 +6242,7 @@ SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperato
   initResultRowInfo(&pInfo->binfo.resultRowInfo, 8, TSDB_DATA_TYPE_INT);
 
   pInfo->prevTs   = INT64_MIN;
-  pInfo->reptScan = false; 
+  pInfo->reptScan = false;
   SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
 
   pOperator->name         = "SessionWindowAggOperator";
@@ -6444,10 +6594,10 @@ static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
       if (isNull(val, type)) {
         continue;
       }
-
+      int dummy; 
       void* res = taosHashGet(pInfo->pSet, val, bytes);
       if (res == NULL) {
-        taosHashPut(pInfo->pSet, val, bytes, NULL, 0);
+        taosHashPut(pInfo->pSet, val, bytes, &dummy, sizeof(dummy));
         char* start = pResultColInfoData->pData + bytes * pInfo->pRes->info.rows;
         memcpy(start, val, bytes);
         pRes->info.rows += 1;
@@ -6683,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)) {
@@ -6926,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};
@@ -7016,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);
       }
     }
@@ -7025,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;
@@ -7119,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;
     }
@@ -7140,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;
 
@@ -7185,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;
     }
@@ -7371,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;
 
@@ -7382,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;
@@ -7405,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;
@@ -7437,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;
@@ -7458,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) {
@@ -7603,8 +7925,8 @@ int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo*
 
   SArray* prevResult = NULL;
   if (prevResultLen > 0) {
-    prevResult = interResFromBinary(param->prevResult, prevResultLen);    
-    
+    prevResult = interResFromBinary(param->prevResult, prevResultLen);
+
     pRuntimeEnv->prevResult = prevResult;
   }
 
diff --git a/src/query/src/qScript.c b/src/query/src/qScript.c
new file mode 100644
index 0000000000..261164a84c
--- /dev/null
+++ b/src/query/src/qScript.c
@@ -0,0 +1,443 @@
+/*
+ * 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;
+}
+
diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c
index 4d23a9685c..af59a5e417 100644
--- a/src/query/src/qSqlParser.c
+++ b/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) {
diff --git a/src/query/src/queryMain.c b/src/query/src/queryMain.c
index d4aa523bf8..0d140d5ffb 100644
--- a/src/query/src/queryMain.c
+++ b/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;
 
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 7d5748e29f..7a9183ac06 100644
--- a/src/query/src/sql.c
+++ b/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 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 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 59: /* cmd ::= CREATE USER ids PASS ids */
+      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 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 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 */
+      case 84: /* 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;
+    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.yy151 = yylhsminor.yy151;
+  yymsp[-8].minor.yy547 = yylhsminor.yy547;
         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;
+      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 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;
+      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 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 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; }
+      case 88: /* keep ::= KEEP intitemlist */
+{ yymsp[-1].minor.yy525 = yymsp[0].minor.yy525; }
         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 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:
diff --git a/src/util/src/terror.c b/src/util/src/terror.c
index 6cb508ebae..e36ab94844 100644
--- a/src/util/src/terror.c
+++ b/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
diff --git a/src/util/src/tqueue.c b/src/util/src/tqueue.c
index 7caa1a6c37..6a37f11ece 100644
--- a/src/util/src/tqueue.c
+++ b/src/util/src/tqueue.c
@@ -173,10 +173,12 @@ int taosReadAllQitems(taos_queue param, taos_qall p2) {
   STaosQueue *queue = (STaosQueue *)param;
   STaosQall  *qall = (STaosQall *)p2;
   int         code = 0;
+  bool        empty;
 
   pthread_mutex_lock(&queue->mutex);
 
-  if (queue->head) {
+  empty = queue->head == NULL;
+  if (!empty) {
     memset(qall, 0, sizeof(STaosQall));
     qall->current = queue->head;
     qall->start = queue->head;
@@ -188,11 +190,17 @@ int taosReadAllQitems(taos_queue param, taos_qall p2) {
     queue->tail = NULL;
     queue->numOfItems = 0;
     if (queue->qset) atomic_sub_fetch_32(&queue->qset->numOfItems, qall->numOfItems);
-  } 
+  }
 
   pthread_mutex_unlock(&queue->mutex);
-  
-  return code; 
+
+  // if source queue is empty, we set destination qall to empty too.
+  if (empty) {
+    qall->current = NULL;
+    qall->start = NULL;
+    qall->numOfItems = 0;
+  }
+  return code;
 }
 
 int taosGetQitem(taos_qall param, int *type, void **pitem) {
@@ -423,10 +431,22 @@ int taosReadAllQitemsFromQset(taos_qset param, taos_qall p2, void **phandle) {
 
 int taosGetQueueItemsNumber(taos_queue param) {
   STaosQueue *queue = (STaosQueue *)param;
-  return queue->numOfItems;
+  if (!queue) return 0;
+
+  int num;
+  pthread_mutex_lock(&queue->mutex);
+  num = queue->numOfItems;
+  pthread_mutex_unlock(&queue->mutex);
+  return num;
 }
 
 int taosGetQsetItemsNumber(taos_qset param) {
   STaosQset *qset = (STaosQset *)param;
-  return qset->numOfItems;
+  if (!qset) return 0;
+
+  int num = 0;
+  pthread_mutex_lock(&qset->mutex);
+  num = qset->numOfItems;
+  pthread_mutex_unlock(&qset->mutex);
+  return num;
 }
diff --git a/src/util/src/tskiplist.c b/src/util/src/tskiplist.c
index 842ded19a6..a88fee51d7 100644
--- a/src/util/src/tskiplist.c
+++ b/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
diff --git a/src/util/src/ttokenizer.c b/src/util/src/ttokenizer.c
index 88c2a3369b..c4d05b2d5a 100644
--- a/src/util/src/ttokenizer.c
+++ b/src/util/src/ttokenizer.c
@@ -219,8 +219,13 @@ static SKeyword keywordTable[] = {
     {"PARTITIONS",   TK_PARTITIONS},
     {"TOPIC",        TK_TOPIC},
     {"TOPICS",       TK_TOPICS},
-    {"COMPACT",       TK_COMPACT},
-    {"MODIFY",       TK_MODIFY}
+    {"COMPACT",      TK_COMPACT},
+    {"MODIFY",       TK_MODIFY},
+    {"FUNCTION",     TK_FUNCTION},
+    {"FUNCTIONS",    TK_FUNCTIONS},
+    {"OUTPUTTYPE",   TK_OUTPUTTYPE},
+    {"AGGREGATE",    TK_AGGREGATE},
+    {"BUFSIZE",      TK_BUFSIZE},
 };
 
 static const char isIdChar[] = {
@@ -269,7 +274,7 @@ static int32_t tKeywordCode(const char* z, int n) {
   if (keywordHashTable == NULL) {
     return TK_ILLEGAL;
   }
-  
+
   SKeyword** pKey = (SKeyword**)taosHashGet(keywordHashTable, key, n);
   return (pKey != NULL)? (*pKey)->type:TK_ID;
 }
diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index 3964975e35..6bc009209b 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/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;
diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c
index a7c418711d..743398d834 100644
--- a/src/vnode/src/vnodeWrite.c
+++ b/src/vnode/src/vnodeWrite.c
@@ -90,7 +90,7 @@ int32_t vnodeProcessWrite(void *vparam, void *wparam, int32_t qtype, void *rpara
 
   // forward to peers, even it is WAL/FWD, it shall be called to update version in sync
   int32_t syncCode = 0;
-  bool    force = (pWrite == NULL ? false : pWrite->pHead.msgType != TSDB_MSG_TYPE_SUBMIT);
+  bool    force = (pWrite == NULL ? false : pWrite->walHead.msgType != TSDB_MSG_TYPE_SUBMIT);
   syncCode = syncForwardToPeer(pVnode->sync, pHead, pWrite, qtype, force);
   if (syncCode < 0) {
     pHead->version = 0;
@@ -237,7 +237,7 @@ static SVWriteMsg *vnodeBuildVWriteMsg(SVnodeObj *pVnode, SWalHead *pHead, int32
     return NULL;
   }
 
-  int32_t size = sizeof(SVWriteMsg) + sizeof(SWalHead) + pHead->len;
+  int32_t size = sizeof(SVWriteMsg) + pHead->len;
   SVWriteMsg *pWrite = taosAllocateQitem(size);
   if (pWrite == NULL) {
     terrno = TSDB_CODE_VND_OUT_OF_MEMORY;
@@ -248,7 +248,7 @@ static SVWriteMsg *vnodeBuildVWriteMsg(SVnodeObj *pVnode, SWalHead *pHead, int32
     pWrite->rpcMsg = *pRpcMsg;
   }
 
-  memcpy(&pWrite->pHead, pHead, sizeof(SWalHead) + pHead->len);
+  memcpy(&pWrite->walHead, pHead, sizeof(SWalHead) + pHead->len);
   pWrite->pVnode = pVnode;
   pWrite->qtype = qtype;
 
@@ -286,7 +286,7 @@ static int32_t vnodeWriteToWQueueImp(SVWriteMsg *pWrite) {
   }
 
   int32_t queued = atomic_add_fetch_32(&pVnode->queuedWMsg, 1);
-  int64_t queuedSize = atomic_add_fetch_64(&pVnode->queuedWMsgSize, pWrite->pHead.len);
+  int64_t queuedSize = atomic_add_fetch_64(&pVnode->queuedWMsgSize, pWrite->walHead.len);
 
   if (queued > MAX_QUEUED_MSG_NUM || queuedSize > MAX_QUEUED_MSG_SIZE) {
     int32_t ms = (queued / MAX_QUEUED_MSG_NUM) * 10 + 3;
@@ -330,7 +330,7 @@ void vnodeFreeFromWQueue(void *vparam, SVWriteMsg *pWrite) {
   SVnodeObj *pVnode = vparam;
   if (pVnode) {
     int32_t queued = atomic_sub_fetch_32(&pVnode->queuedWMsg, 1);
-    int64_t queuedSize = atomic_sub_fetch_64(&pVnode->queuedWMsgSize, pWrite->pHead.len);
+    int64_t queuedSize = atomic_sub_fetch_64(&pVnode->queuedWMsgSize, pWrite->walHead.len);
 
     vTrace("vgId:%d, msg:%p, app:%p, free from vwqueue, queued:%d size:%" PRId64, pVnode->vgId, pWrite,
            pWrite->rpcMsg.ahandle, queued, queuedSize);
diff --git a/src/wal/src/walMgmt.c b/src/wal/src/walMgmt.c
index 55ab9b031b..9bd5cdf175 100644
--- a/src/wal/src/walMgmt.c
+++ b/src/wal/src/walMgmt.c
@@ -36,9 +36,16 @@ static int32_t  walInitObj(SWal *pWal);
 static void     walFreeObj(void *pWal);
 
 int32_t walInit() {
+  int32_t code = 0;
   tsWal.refId = taosOpenRef(TSDB_MIN_VNODES, walFreeObj);
 
-  int32_t code = walCreateThread();
+  code = pthread_mutex_init(&tsWal.mutex, NULL);
+  if (code) {
+    wError("failed to init wal mutex since %s", tstrerror(code));
+    return code;
+  }
+
+  code = walCreateThread();
   if (code != TSDB_CODE_SUCCESS) {
     wError("failed to init wal module since %s", tstrerror(code));
     return code;
@@ -51,6 +58,7 @@ int32_t walInit() {
 void walCleanUp() {
   walStopThread();
   taosCloseRef(tsWal.refId);
+  pthread_mutex_destroy(&tsWal.mutex);
   wInfo("wal module is cleaned up");
 }
 
@@ -183,10 +191,15 @@ static void walFsyncAll() {
 }
 
 static void *walThreadFunc(void *param) {
+  int stop = 0;
   while (1) {
     walUpdateSeq();
     walFsyncAll();
-    if (tsWal.stop) break;
+
+    pthread_mutex_lock(&tsWal.mutex);
+    stop = tsWal.stop;
+    pthread_mutex_unlock(&tsWal.mutex);
+    if (stop) break;
   }
 
   return NULL;
@@ -209,7 +222,10 @@ static int32_t walCreateThread() {
 }
 
 static void walStopThread() {
+  pthread_mutex_lock(&tsWal.mutex);
   tsWal.stop = 1;
+  pthread_mutex_unlock(&tsWal.mutex);
+
   if (taosCheckPthreadValid(tsWal.thread)) {
     pthread_join(tsWal.thread, NULL);
   }
diff --git a/tests/examples/c/CMakeLists.txt b/tests/examples/c/CMakeLists.txt
index 7f941b8c87..906ca2dd41 100644
--- a/tests/examples/c/CMakeLists.txt
+++ b/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 ()
diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index d802db1f48..2195e84c31 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -241,6 +241,7 @@ python3 ./test.py -f query/nestedQuery/queryInterval.py
 python3 ./test.py -f query/queryStateWindow.py
 python3 ./test.py -f query/nestedQuery/queryWithOrderLimit.py
 python3 ./test.py -f query/nestquery_last_row.py
+python3 ./test.py -f query/queryCnameDisplay.py
 
 
 #stream
diff --git a/tests/pytest/query/queryCnameDisplay.py b/tests/pytest/query/queryCnameDisplay.py
new file mode 100644
index 0000000000..8864c0e376
--- /dev/null
+++ b/tests/pytest/query/queryCnameDisplay.py
@@ -0,0 +1,104 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+import string
+import random
+import sys
+import taos
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+    def getLongName(self, len, mode = "mixed"):
+        """
+            generate long str
+        """    
+        chars = ''.join(random.choice(string.ascii_letters.lower()) for i in range(len))
+        return chars
+    
+    def checkRegularTableCname(self):
+        """
+            check regular table cname
+        """
+        # len(colName) <=64, generate cname list and make first param = 63 and second param = 65
+        cname_list = []
+        for i in range(10):
+            cname_list.append(self.getLongName(64))
+        cname_list[0] = self.getLongName(63)
+        cname_list[1] = self.getLongName(65)
+        # create table and insert data
+        tdSql.execute("CREATE TABLE regular_table_cname_check (ts timestamp, pi1 int, pi2 bigint, pf1 float, pf2 double, ps1 binary(10), pi3 smallint, pi4 tinyint, pb1 bool, ps2 nchar(20))")
+        tdSql.execute('insert into regular_table_cname_check values (now, 1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");')
+        tdSql.execute('insert into regular_table_cname_check values (now, 2, 3, 1.2, 2.3, "b", 2, 1, false, "aa");')
+        tdSql.execute('insert into regular_table_cname_check values (now, 3, 4, 1.3, 2.4, "c", 1, 3, true, "bb");')
+
+        # select as cname with cname_list
+        sql_seq = f'select count(ts) as {cname_list[0]}, sum(pi1) as {cname_list[1]}, avg(pi2) as {cname_list[2]}, count(pf1) as {cname_list[3]}, count(pf2) as {cname_list[4]}, count(ps1) as {cname_list[5]}, min(pi3) as {cname_list[6]}, max(pi4) as {cname_list[7]}, count(pb1) as {cname_list[8]}, count(ps2) as {cname_list[9]} from regular_table_cname_check'
+        sql_seq_no_as = sql_seq.replace('as ', '')
+        res = tdSql.getColNameList(sql_seq)
+        res_no_as = tdSql.getColNameList(sql_seq_no_as)
+        
+        # cname[1] > 64, it is expected to be equal to 64
+        cname_list_1_expected = cname_list[1][:-1]
+        cname_list[1] = cname_list_1_expected
+        checkColNameList = tdSql.checkColNameList(res, cname_list)
+        checkColNameList = tdSql.checkColNameList(res_no_as, cname_list)
+
+    def checkSuperTableCname(self):
+        """
+            check super table cname
+        """
+        # len(colName) <=64, generate cname list and make first param = 63 and second param = 65
+        cname_list = []
+        for i in range(19):
+            cname_list.append(self.getLongName(64))
+        cname_list[0] = self.getLongName(63)
+        cname_list[1] = self.getLongName(65)
+
+        # create table and insert data
+        tdSql.execute("create table super_table_cname_check (ts timestamp, pi1 int, pi2 bigint, pf1 float, pf2 double, ps1 binary(10), pi3 smallint, pi4 tinyint, pb1 bool, ps2 nchar(20)) tags (si1 int, si2 bigint, sf1 float, sf2 double, ss1 binary(10), si3 smallint, si4 tinyint, sb1 bool, ss2 nchar(20));")
+        tdSql.execute('create table st1 using super_table_cname_check tags (1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");')
+        tdSql.execute('insert into st1 values (now, 1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");')
+        tdSql.execute('insert into st1 values (now, 1, 1, 1.4, 2.3, "b", 3, 2, true, "aa");')
+        tdSql.execute('insert into st1 values (now, 1, 2, 1.1, 2.2, "a", 1, 1, false, "bb");')
+
+        # select as cname with cname_list
+        sql_seq = f'select count(ts) as {cname_list[0]}, sum(pi1) as {cname_list[1]}, avg(pi2) as {cname_list[2]}, count(pf1) as {cname_list[3]}, count(pf2) as {cname_list[4]}, count(ps1) as {cname_list[5]}, min(pi3) as {cname_list[6]}, max(pi4) as {cname_list[7]}, count(pb1) as {cname_list[8]}, count(ps2) as {cname_list[9]}, count(si1) as {cname_list[10]}, count(si2) as {cname_list[11]}, count(sf1) as {cname_list[12]}, count(sf2) as {cname_list[13]}, count(ss1) as {cname_list[14]}, count(si3) as {cname_list[15]}, count(si4) as {cname_list[16]}, count(sb1) as {cname_list[17]}, count(ss2) as {cname_list[18]} from super_table_cname_check'
+        sql_seq_no_as = sql_seq.replace('as ', '')
+        res = tdSql.getColNameList(sql_seq)
+        res_no_as = tdSql.getColNameList(sql_seq_no_as)
+
+        # cname[1] > 64, it is expected to be equal to 64
+        cname_list_1_expected = cname_list[1][:-1]
+        cname_list[1] = cname_list_1_expected
+        checkColNameList = tdSql.checkColNameList(res, cname_list)
+        checkColNameList = tdSql.checkColNameList(res_no_as, cname_list)
+        
+    def run(self):
+        tdSql.prepare()
+        self.checkRegularTableCname()
+        self.checkSuperTableCname()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
+
diff --git a/tests/pytest/util/sql.py b/tests/pytest/util/sql.py
index 913c158d05..4eb0c8f857 100644
--- a/tests/pytest/util/sql.py
+++ b/tests/pytest/util/sql.py
@@ -79,6 +79,21 @@ class TDSql:
             raise Exception(repr(e))
         return self.queryRows
 
+    def getColNameList(self, sql):
+        self.sql = sql
+        try:
+            col_name_list = []
+            self.cursor.execute(sql)
+            self.queryCols = self.cursor.description
+            for query_col in self.queryCols:
+                col_name_list.append(query_col[0])
+        except Exception as e:
+            caller = inspect.getframeinfo(inspect.stack()[1][0])
+            args = (caller.filename, caller.lineno, sql, repr(e))
+            tdLog.notice("%s(%d) failed: sql:%s, %s" % args)
+            raise Exception(repr(e))
+        return col_name_list
+
     def waitedQuery(self, sql, expectRows, timeout):
         tdLog.info("sql: %s, try to retrieve %d rows in %d seconds" % (sql, expectRows, timeout))
         self.sql = sql
@@ -209,6 +224,14 @@ class TDSql:
 
         tdLog.info("sql:%s, affectedRows:%d == expect:%d" % (self.sql, self.affectedRows, expectAffectedRows))
 
+    def checkColNameList(self, col_name_list, expect_col_name_list):
+        if col_name_list == expect_col_name_list:
+            tdLog.info("sql:%s, col_name_list:%s == expect_col_name_list:%s" % (self.sql, col_name_list, expect_col_name_list))
+        else:
+            caller = inspect.getframeinfo(inspect.stack()[1][0])
+            args = (caller.filename, caller.lineno, self.sql, col_name_list, expect_col_name_list)
+            tdLog.exit("%s(%d) failed: sql:%s, col_name_list:%s != expect_col_name_list:%s" % args)
+
     def taosdStatus(self, state):
         tdLog.sleep(5)
         pstate = 0
diff --git a/tests/robust/cluster.sh b/tests/robust/cluster.sh
new file mode 100644
index 0000000000..166014fefb
--- /dev/null
+++ b/tests/robust/cluster.sh
@@ -0,0 +1,324 @@
+#!/bin/bash 
+stty erase '^H'
+stty erase '^?'
+
+# 运行前需要安装expect; apt install expect
+# 运行方式:
+# ./cluster.sh -c xxx.cfg
+# cfg文件内格式: 每行代表一个节点 第一列为external ip、第二列为密码、第三列为用户名、第四列为hostname、第五列为interal ip
+# 注意：列与列直接用空格隔开
+# 例子:
+# 51.143.97.155 tbase125! root node5 10.2.0.10
+# 20.94.253.116 tbase125! root node2 10.2.0.12
+# 20.94.250.236 tbase125! root node3 10.2.0.13
+# 20.98.72.51 tbase125! root node4 10.2.0.14
+
+menu(){
+    echo "=============================="
+    echo "-------------Target-----------"
+    echo "=============================="
+    echo "1 cluster"
+    echo "=============================="
+    echo "2 dnode"
+    echo "=============================="
+    echo "3 arbitrator"
+    echo "=============================="
+    echo "4 exit"
+    echo "=============================="
+}
+
+cluster_menu(){
+    echo "=============================="
+    echo "----------Operation-----------"
+    echo "=============================="
+    echo "1 start cluster"
+    echo "=============================="
+    echo "2 stop cluster"
+    echo "=============================="
+    echo "3 exit"
+    echo "=============================="
+}
+
+dnode_menu(){
+    echo "=============================="
+    echo "----------Operation-----------"
+    echo "=============================="
+    echo "1 start dnode"
+    echo "=============================="
+    echo "2 stop dnode"
+    echo "=============================="
+    echo "3 add dnode"
+    echo "=============================="
+    echo "4 drop dnode"
+    echo "=============================="
+    echo "5 exit"
+    echo "=============================="
+}
+
+arbitrator_menu(){
+    echo "=============================="
+    echo "----------Operation-----------"
+    echo "=============================="
+    echo "1 start arbitrator"
+    echo "=============================="
+    echo "2 stop arbitrator"
+    echo "=============================="
+    echo "3 exit"
+    echo "=============================="
+}
+
+print_cfg() {
+    echo "=============================="
+    echo "-------Configure file---------"
+    echo "=============================="
+    echo "Id |   IP address   |  hostname"
+    i=1
+    while read line || [[ -n ${line} ]]
+    do
+        arr=($line)
+        echo " $i | ${arr[0]} | ${arr[3]}" 
+        i=`expr $i + 1`;
+    done < $1
+    echo "=============================="
+}
+
+update(){
+    expect -c "
+        set timeout -1;
+        spawn ssh $3@$1;
+        expect {
+            *yes/no* { send \"yes\r\"; exp_continue }
+            *assword:* { send \"$2\r\" }
+        }
+        expect {
+            *#* { send \"systemctl $4 taosd\r\" }
+        }
+        expect {
+            *#* { send \"exit\r\" }
+        }
+        expect eof;
+    "
+    echo -e "\033[32mdnode successfully $4 \033[0m"
+}
+
+update_dnode(){
+    i=1
+    while read line || [[ -n ${line} ]]
+    do
+        if [[ $1 -eq $i ]]; then
+        arr=($line)
+        update ${arr[0]} ${arr[1]} ${arr[2]} $2
+        break;
+        fi
+        i=`expr $i + 1`;
+    done < $3
+}
+
+add_hosts() {
+    expect -c "
+        set timeout -1;
+        spawn ssh $3@$1;
+        expect {
+            *yes/no* { send \"yes\r\"; exp_continue }
+            *assword:* { send \"$2\r\" }
+        }
+        expect {
+            *#* { send \"echo $4 $5 >> /etc/hosts\r\" }
+        }
+        expect {
+            *#* { send \"exit\r\" }
+        }
+        expect eof;
+        "
+    echo -e "\033[32mSuccessfully add to /etc/hosts in $1\033[0m"
+}
+
+remove_hosts() {
+    expect -c "
+        set timeout -1;
+        spawn ssh $3@$1;
+        expect {
+            *yes/no* { send \"yes\r\"; exp_continue }
+            *assword:* { send \"$2\r\" }
+        }
+        expect {
+            *#* { send \"sed -i '/$4/d\' /etc/hosts\r\" }
+        }
+        expect {
+            *#* { send \"exit\r\" }
+        }
+        expect eof;
+        "
+    echo -e "\033[32mSuccessfully remove from /etc/hosts in $1\033[0m"
+}
+
+remove_varlibtaos() {
+    expect -c "
+        set timeout -1;
+        spawn ssh $3@$1;
+        expect {
+            *yes/no* { send \"yes\r\"; exp_continue }
+            *assword:* { send \"$2\r\" }
+        }
+        expect {
+            *#* { send \"rm -rf /var/lib/taos/*\r\" }
+        }
+        expect {
+            *#* { send \"exit\r\" }
+        }
+        expect eof;
+        "
+    echo -e "\033[32mSuccessfully remove /var/lib/taos/* in $1\033[0m"
+}
+
+scp_cfg() {
+    expect -c "
+        set timeout -1;
+        spawn scp /etc/taos/taos.cfg $3@$1:/etc/taos;
+        expect {
+            *yes/no* { send \"yes\r\"; exp_continue }
+            *assword:* { send \"$2\r\" }
+        }
+        expect eof;
+        "
+    echo -e "\033[32mSuccessfully scp /etc/taos/taos.cfg to $1\033[0m"
+}
+
+manage_dnode(){
+    i=1
+    while read line || [[ -n ${line} ]]
+    do
+        if [[ $1 -eq $i ]]; then
+        arr=($line)
+        scp_cfg ${arr[0]} ${arr[1]} ${arr[2]}
+        ip=${arr[0]}
+        pd=${arr[1]}
+        user=${arr[2]}
+        j=1
+        while read line2 || [[ -n ${line2} ]]
+        do
+            arr2=($line2)
+            if [[ $1 -ne $j ]]; then
+                if [ $3 == "create" ];then
+                echo "$3"
+                add_hosts $ip $pd $user ${arr2[4]} ${arr2[3]}
+                else
+                remove_hosts $ip $pd $user ${arr2[4]} ${arr2[3]}
+                fi
+            fi
+            j=`expr $j + 1`;
+        done < $2
+        remove_varlibtaos $ip $pd $user
+        if [ $3 == "create" ];then
+            update $ip $pd $user "start"
+        else
+            update $ip $pd $user "stop"
+        fi
+        taos -s "$3 dnode \"${arr[3]}:6030\""
+        break;
+        fi
+        i=`expr $i + 1`;
+    done < $2
+    echo -e "\033[32mSuccessfully $3 dnode id $1\033[0m"
+}
+
+update_cluster() {
+    while read line || [[ -n ${line} ]]
+    do
+        arr=($line)
+        if [ $1 == "start" ]; then
+        scp_cfg ${arr[0]} ${arr[1]} ${arr[2]}
+        fi
+        update ${arr[0]} ${arr[1]} ${arr[2]} $1
+    done < $2
+}
+
+while :
+do
+    clear
+    menu
+    read -p "select mode: " n
+    case $n in
+    1)
+        clear
+        print_cfg $2
+        cluster_menu
+        read -p "select operation: " c
+        case $c in
+        1)
+            update_cluster "start" $2 
+            break
+        ;;
+        2)
+            update_cluster "stop" $2 
+            break
+        ;;
+        3)
+            break
+        ;;
+        esac
+    ;;
+    2)
+        clear
+        print_cfg $2
+        dnode_menu
+        read -p "select operation: " d
+        case $d in
+        1)
+            clear
+            print_cfg $2
+            read -p "select dnode: " id
+            update_dnode $id "start" $2
+            break
+        ;;
+        2)
+            clear
+            print_cfg $2
+            read -p "select dnode: " id
+            update_dnode $id "stop" $2
+            break
+        ;;
+        3)
+            clear
+            print_cfg $2
+            read -p "select dnode: " id
+            manage_dnode $id $2 "create"
+            break
+        ;;
+        4)
+            clear
+            print_cfg $2
+            read -p "select dnode: " id
+            manage_dnode $id $2 "drop"
+            break
+        ;;
+        5)
+            break
+        ;;
+        esac
+    ;;
+    3)
+        clear
+        arbitrator_menu
+        read -p "select operation: " m
+        case $m in
+        1)
+            nohup /usr/local/taos/bin/tarbitrator >/dev/null 2>&1 &
+            echo -e "\033[32mSuccessfully start arbitrator $3 \033[0m"
+            break
+        ;;
+        2)
+            var=`ps -ef | grep tarbitrator | awk '{print $2}' | head -n 1`
+            kill -9 $var
+            break
+        ;;
+        3)
+            break
+        ;;
+        esac
+    ;;
+    4)
+        break
+    ;;
+    esac
+done
diff --git a/tests/script/general/parser/col_arithmetic_query.sim b/tests/script/general/parser/col_arithmetic_query.sim
index 191f56fcfb..17ae6cfd6b 100644
--- a/tests/script/general/parser/col_arithmetic_query.sim
+++ b/tests/script/general/parser/col_arithmetic_query.sim
@@ -193,7 +193,7 @@ if $data02 != 0.000000000 then
   return -1
 endi
 
-if $data03 != 0.000000000 then
+if $data03 != NULL then
   return -1
 endi
 
@@ -444,7 +444,7 @@ if $data02 != 8.077777778 then
   return -1
 endi
 
-if $data03 != inf then
+if $data03 != NULL then
   return -1
 endi
 
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index d7f06769a8..fcd9d49fe5 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/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
diff --git a/tests/script/general/parser/udf.sim b/tests/script/general/parser/udf.sim
new file mode 100644
index 0000000000..c048a7c37a
--- /dev/null
+++ b/tests/script/general/parser/udf.sim
@@ -0,0 +1,637 @@
+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
diff --git a/tests/script/general/parser/udf_dll.sim b/tests/script/general/parser/udf_dll.sim
new file mode 100644
index 0000000000..0f9436762a
--- /dev/null
+++ b/tests/script/general/parser/udf_dll.sim
@@ -0,0 +1,494 @@
+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
diff --git a/tests/script/general/parser/udf_dll_stable.sim b/tests/script/general/parser/udf_dll_stable.sim
new file mode 100644
index 0000000000..b8da57467e
--- /dev/null
+++ b/tests/script/general/parser/udf_dll_stable.sim
@@ -0,0 +1,1163 @@
+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
+
+
+
+
+
+
diff --git a/tests/script/sh/abs_max.c b/tests/script/sh/abs_max.c
new file mode 100644
index 0000000000..cd8ba0ff15
--- /dev/null
+++ b/tests/script/sh/abs_max.c
@@ -0,0 +1,88 @@
+#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");
+}
+
diff --git a/tests/script/sh/add_one.c b/tests/script/sh/add_one.c
new file mode 100644
index 0000000000..e12cf8f26f
--- /dev/null
+++ b/tests/script/sh/add_one.c
@@ -0,0 +1,33 @@
+#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);
+   }
+}
+
+
diff --git a/tests/script/sh/demo.c b/tests/script/sh/demo.c
new file mode 100644
index 0000000000..23d2174448
--- /dev/null
+++ b/tests/script/sh/demo.c
@@ -0,0 +1,112 @@
+#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");
+}
+
diff --git a/tests/script/sh/demo.lua b/tests/script/sh/demo.lua
new file mode 100644
index 0000000000..c5e5582fc3
--- /dev/null
+++ b/tests/script/sh/demo.lua
@@ -0,0 +1,43 @@
+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  
diff --git a/tests/script/sh/prepare_udf.sh b/tests/script/sh/prepare_udf.sh
new file mode 100644
index 0000000000..ecfc53660e
--- /dev/null
+++ b/tests/script/sh/prepare_udf.sh
@@ -0,0 +1,12 @@
+#!/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
diff --git a/tests/script/sh/scalar_demo.lua b/tests/script/sh/scalar_demo.lua
new file mode 100644
index 0000000000..cecaff90b0
--- /dev/null
+++ b/tests/script/sh/scalar_demo.lua
@@ -0,0 +1,14 @@
+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
diff --git a/tests/script/sh/sum_double.c b/tests/script/sh/sum_double.c
new file mode 100644
index 0000000000..b4b0b81a06
--- /dev/null
+++ b/tests/script/sh/sum_double.c
@@ -0,0 +1,84 @@
+#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");
+}
+