[td-225]refactor

src/client/src/tscParseInsert.c

@@ -1359,7 +1359,7 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
       }
     }
   } else {
-    SSqlInfo SQLInfo = qSQLParse(pSql->sqlstr);
+    SSqlInfo SQLInfo = qSqlParse(pSql->sqlstr);
     ret = tscToSQLCmd(pSql, &SQLInfo);
     if (ret == TSDB_CODE_TSC_INVALID_SQL && pSql->parseRetry == 0 && SQLInfo.type == TSDB_SQL_NULL) {
       tscResetSqlCmd(pCmd, true);

src/client/src/tscServer.c

@@ -1350,7 +1350,7 @@ int tscEstimateCreateTableMsgLength(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &(pSql->cmd);
   int32_t size = minMsgSize() + sizeof(SCMCreateTableMsg) + sizeof(SCreateTableMsg);
 
-  SCreateTableSQL *pCreateTableInfo = pInfo->pCreateTableInfo;
+  SCreateTableSql *pCreateTableInfo = pInfo->pCreateTableInfo;
   if (pCreateTableInfo->type == TSQL_CREATE_TABLE_FROM_STABLE) {
     int32_t numOfTables = (int32_t)taosArrayGetSize(pInfo->pCreateTableInfo->childTableInfo);
     size += numOfTables * (sizeof(SCreateTableMsg) + TSDB_MAX_TAGS_LEN);
@@ -1359,7 +1359,7 @@ int tscEstimateCreateTableMsgLength(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   if (pCreateTableInfo->pSelect != NULL) {
-    size += (pCreateTableInfo->pSelect->selectToken.n + 1);
+    size += (pCreateTableInfo->pSelect->sqlstr.n + 1);
   }
 
   return size + TSDB_EXTRA_PAYLOAD_SIZE;
@@ -1417,7 +1417,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pCreateMsg->tableName);
     assert(code == 0);
 
-    SCreateTableSQL *pCreateTable = pInfo->pCreateTableInfo;
+    SCreateTableSql *pCreateTable = pInfo->pCreateTableInfo;
 
     pCreateMsg->igExists = pCreateTable->existCheck ? 1 : 0;
     pCreateMsg->numOfColumns = htons(pCmd->numOfCols);
@@ -1440,11 +1440,11 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
     pMsg = (char *)pSchema;
     if (type == TSQL_CREATE_STREAM) {  // check if it is a stream sql
-      SQuerySQL *pQuerySql = pInfo->pCreateTableInfo->pSelect;
+      SQuerySqlNode *pQuerySql = pInfo->pCreateTableInfo->pSelect;
 
-      strncpy(pMsg, pQuerySql->selectToken.z, pQuerySql->selectToken.n + 1);
-      pCreateMsg->sqlLen = htons(pQuerySql->selectToken.n + 1);
-      pMsg += pQuerySql->selectToken.n + 1;
+      strncpy(pMsg, pQuerySql->sqlstr.z, pQuerySql->sqlstr.n + 1);
+      pCreateMsg->sqlLen = htons(pQuerySql->sqlstr.n + 1);
+      pMsg += pQuerySql->sqlstr.n + 1;
     }
   }
 

src/query/inc/qSqlparser.h

@@ -27,6 +27,18 @@ extern "C" {
 #include "tvariant.h"
 
 #define ParseTOKENTYPE SStrToken
+
+#define NON_ARITHMEIC_EXPR 0
+#define NORMAL_ARITHMETIC  1
+#define AGG_ARIGHTMEIC     2
+
+enum SQL_NODE_TYPE {
+  SQL_NODE_TABLE_COLUMN= 1,
+  SQL_NODE_SQLFUNCTION = 2,
+  SQL_NODE_VALUE       = 3,
+  SQL_NODE_EXPR        = 4,
+};
+
 extern char tTokenTypeSwitcher[13];
 
 #define toTSDBType(x)                          \
@@ -63,20 +75,20 @@ typedef struct SSessionWindowVal {
   SStrToken gap;
 } SSessionWindowVal;
 
-typedef struct SQuerySQL {
-  struct tSQLExprList *pSelection;   // select clause
-  SArray *             from;         // from clause  SArray<tVariantListItem>
-  struct tSQLExpr *    pWhere;       // where clause [optional]
-  SArray *             pGroupby;     // groupby clause, only for tags[optional], SArray<tVariantListItem>
-  SArray *             pSortOrder;   // orderby [optional], SArray<tVariantListItem>
-  SIntervalVal         interval;     // (interval, interval_offset) [optional]
-  SSessionWindowVal    sessionVal;   // session window [optional]
-  SStrToken            sliding;      // sliding window [optional]
-  SLimitVal            limit;        // limit offset [optional]
-  SLimitVal            slimit;       // group limit offset [optional]
-  SArray *             fillType;     // fill type[optional], SArray<tVariantListItem>
-  SStrToken            selectToken;  // sql string
-} SQuerySQL;
+typedef struct SQuerySqlNode {
+  struct SArray     *pSelectList;  // select clause
+  SArray            *from;         // from clause  SArray<SQuerySqlNode>
+  struct tSqlExpr   *pWhere;       // where clause [optional]
+  SArray            *pGroupby;     // groupby clause, only for tags[optional], SArray<tVariantListItem>
+  SArray            *pSortOrder;   // orderby [optional], SArray<tVariantListItem>
+  SIntervalVal      *interval;     // (interval, interval_offset) [optional]
+  SSessionWindowVal *sessionVal;   // session window [optional]
+  SStrToken         *sliding;      // sliding window [optional]
+  SLimitVal         *limit;        // limit offset [optional]
+  SLimitVal         *slimit;       // group limit offset [optional]
+  SArray            *fillType;     // fill type[optional], SArray<tVariantListItem>
+  SStrToken          sqlstr;       // sql string in select clause
+} SQuerySqlNode;
 
 typedef struct SCreatedTableInfo {
   SStrToken  name;        // table name token
@@ -88,7 +100,7 @@ typedef struct SCreatedTableInfo {
   int8_t     igExist;     // ignore if exists
 } SCreatedTableInfo;
 
-typedef struct SCreateTableSQL {
+typedef struct SCreateTableSql {
   SStrToken    name;  // table name, create table [name] xxx
   int8_t       type;  // create normal table/from super table/ stream
   bool         existCheck;
@@ -99,16 +111,16 @@ typedef struct SCreateTableSQL {
   } colInfo;
 
   SArray      *childTableInfo;        // SArray<SCreatedTableInfo>
-  SQuerySQL   *pSelect;
-} SCreateTableSQL;
+  SQuerySqlNode   *pSelect;
+} SCreateTableSql;
 
 typedef struct SAlterTableInfo {
-  SStrToken     name;
-  int16_t       tableType;
-  int16_t       type;
-  STagData      tagData;
-  SArray       *pAddColumns; // SArray<TAOS_FIELD>
-  SArray       *varList;  // set t=val or: change src dst, SArray<tVariantListItem>
+  SStrToken  name;
+  int16_t    tableType;
+  int16_t    type;
+  STagData   tagData;
+  SArray    *pAddColumns; // SArray<TAOS_FIELD>
+  SArray    *varList;     // set t=val or: change src dst, SArray<tVariantListItem>
 } SAlterTableInfo;
 
 typedef struct SCreateDbInfo {
@@ -147,9 +159,9 @@ typedef struct SCreateAcctInfo {
 } SCreateAcctInfo;
 
 typedef struct SShowInfo {
-  uint8_t showType;
-  SStrToken prefix;
-  SStrToken pattern;
+  uint8_t    showType;
+  SStrToken  prefix;
+  SStrToken  pattern;
 } SShowInfo;
 
 typedef struct SUserInfo {
@@ -174,7 +186,7 @@ typedef struct SMiscInfo {
 } SMiscInfo;
 
 typedef struct SSubclauseInfo {  // "UNION" multiple select sub-clause
-  SQuerySQL **pClause;
+  SQuerySqlNode **pClause;
   int32_t     numOfClause;
 } SSubclauseInfo;
 
@@ -184,26 +196,15 @@ typedef struct SSqlInfo {
   SSubclauseInfo     subclauseInfo;
   char               msg[256];
   union {
-    SCreateTableSQL  *pCreateTableInfo;
+    SCreateTableSql  *pCreateTableInfo;
     SAlterTableInfo  *pAlterInfo;
     SMiscInfo        *pMiscInfo;
   };
 } SSqlInfo;
 
-#define NON_ARITHMEIC_EXPR 0
-#define NORMAL_ARITHMETIC  1
-#define AGG_ARIGHTMEIC     2
-
-enum SQL_NODE_TYPE {
-  SQL_NODE_TABLE_COLUMN= 1,
-  SQL_NODE_SQLFUNCTION = 2,
-  SQL_NODE_VALUE       = 3,
-  SQL_NODE_EXPR        = 4,
-};
-
-typedef struct tSQLExpr {
+typedef struct tSqlExpr {
   uint16_t         type;       // sql node type
-  uint32_t         tokenId;    // TK_FUNCTION: sql function, TK_LE: less than(binary expr)
+  uint32_t         tokenId;    // TK_LE: less than(binary expr)
 
   // the whole string of the function(col, param), while the function name is kept in token
   SStrToken        operand;
@@ -213,70 +214,47 @@ typedef struct tSQLExpr {
   tVariant         value;       // the use input value
   SStrToken        token;       // original sql expr string
 
-  struct tSQLExpr *pLeft;       // left child
-  struct tSQLExpr *pRight;      // right child
-  struct tSQLExprList *pParam;  // function parameters list
-} tSQLExpr;
+  struct tSqlExpr *pLeft;       // left child
+  struct tSqlExpr *pRight;      // right child
+  struct SArray   *pParam;      // function parameters list
+} tSqlExpr;
 
-// used in select clause. select <tSQLExprList> from xxx
+// used in select clause. select <SArray> from xxx
 typedef struct tSqlExprItem {
-  tSQLExpr *pNode;      // The list of expressions
+  tSqlExpr *pNode;      // The list of expressions
   char *    aliasName;  // alias name, null-terminated string
   bool      distinct;
 } tSqlExprItem;
 
-// todo refactor by using SArray
-typedef struct tSQLExprList {
-  int32_t       nExpr;  /* Number of expressions on the list */
-  int32_t       nAlloc; /* Number of entries allocated below */
-  tSqlExprItem *a;      /* One entry for each expression */
-} tSQLExprList;
-
-/**
- *
- * @param yyp      The parser
- * @param yymajor  The major token code number
- * @param yyminor  The value for the token
- */
-void Parse(void *yyp, int yymajor, ParseTOKENTYPE yyminor, SSqlInfo *);
-
-/**
- *
- * @param p         The parser to be deleted
- * @param freeProc  Function used to reclaim memory
- */
-void ParseFree(void *p, void (*freeProc)(void *));
-
 SArray *tVariantListAppend(SArray *pList, tVariant *pVar, uint8_t sortOrder);
 SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int32_t index);
 SArray *tVariantListAppendToken(SArray *pList, SStrToken *pAliasToken, uint8_t sortOrder);
 
-tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType);
+// sql expr leaf node
+tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType);
+tSqlExpr *tSqlExprCreateFunction(SArray *pParam, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType);
 
-tSQLExpr *tSqlExprClone(tSQLExpr *pSrc);
+tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType);
+tSqlExpr *tSqlExprClone(tSqlExpr *pSrc);
+void      tSqlExprDestroy(tSqlExpr *pExpr);
+SArray   *tSqlExprListAppend(SArray *pList, tSqlExpr *pNode, SStrToken *pDistinct, SStrToken *pToken);
+void      tSqlExprListDestroy(SArray *pList);
 
-void tSqlExprDestroy(tSQLExpr *pExpr);
+SQuerySqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelectList, SArray *pFrom, tSqlExpr *pWhere,
+                                SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
+                                SSessionWindowVal *pSession, SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit,
+                                SLimitVal *pGLimit);
 
-tSQLExprList *tSqlExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken *pDistinct, SStrToken *pToken);
+SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SQuerySqlNode *pSelect, int32_t type);
 
-void tSqlExprListDestroy(tSQLExprList *pList);
-
-SQuerySQL *tSetQuerySqlNode(SStrToken *pSelectToken, tSQLExprList *pSelection, SArray *pFrom, tSQLExpr *pWhere,
-                             SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval, SSessionWindowVal *pSession,
-                             SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit);
-
-SCreateTableSQL *tSetCreateSqlElems(SArray *pCols, SArray *pTags, SQuerySQL *pSelect, int32_t type);
-
-void tSqlExprNodeDestroy(tSQLExpr *pExpr);
-
-SAlterTableInfo *  tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type, int16_t tableTable);
+SAlterTableInfo *tSetAlterTableInfo(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type, int16_t tableTable);
 SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagNames, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists);
 
 void destroyAllSelectClause(SSubclauseInfo *pSql);
-void doDestroyQuerySql(SQuerySQL *pSql);
+void doDestroyQuerySql(SQuerySqlNode *pSql);
 void freeCreateTableInfo(void* p);
 
-SSqlInfo       *      setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type);
+SSqlInfo       *setSqlInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type);
 SSubclauseInfo *setSubclause(SSubclauseInfo *pClause, void *pSqlExprInfo);
 
 SSubclauseInfo *appendSelectClause(SSubclauseInfo *pInfo, void *pSubclause);
@@ -285,7 +263,7 @@ void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken
 
 void SqlInfoDestroy(SSqlInfo *pInfo);
 
-void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParams, ...);
+void setDCLSqlElems(SSqlInfo *pInfo, int32_t type, int32_t nParams, ...);
 void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck,int16_t dbType,int16_t tableType);
 void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken* pPatterns);
 
@@ -300,19 +278,39 @@ void setDefaultCreateDbOption(SCreateDbInfo *pDBInfo);
 void setDefaultCreateTopicOption(SCreateDbInfo *pDBInfo);
 
 // prefix show db.tables;
-void setDbName(SStrToken *pCpxName, SStrToken *pDb);
+void tSetDbName(SStrToken *pCpxName, SStrToken *pDb);
 
-tSQLExpr *tSqlExprIdValueCreate(SStrToken *pToken, int32_t optrType);
+void tSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType);
+void tSetColumnType(TAOS_FIELD *pField, SStrToken *type);
 
-tSQLExpr *tSqlExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType);
-
-void tSqlSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType);
+/**
+ *
+ * @param yyp      The parser
+ * @param yymajor  The major token code number
+ * @param yyminor  The value for the token
+ */
+void Parse(void *yyp, int yymajor, ParseTOKENTYPE yyminor, SSqlInfo *);
 
-void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type);
+/**
+ *
+ * @param p         The parser to be deleted
+ * @param freeProc  Function used to reclaim memory
+ */
+void ParseFree(void *p, void (*freeProc)(void *));
 
+/**
+ *
+ * @param mallocProc  The parser allocator
+ * @return
+ */
 void *ParseAlloc(void *(*mallocProc)(size_t));
 
-SSqlInfo qSQLParse(const char *str);
+/**
+ *
+ * @param str sql string
+ * @return sql ast
+ */
+SSqlInfo qSqlParse(const char *str);
 
 #ifdef __cplusplus
 }

src/query/src/qParserImpl.c → src/query/src/qSqlParser.c

@@ -23,7 +23,7 @@
 #include "ttokendef.h"
 #include "tutil.h"
 
-SSqlInfo qSQLParse(const char *pStr) {
+SSqlInfo qSqlParse(const char *pStr) {
   void *pParser = ParseAlloc(malloc);
 
   SSqlInfo sqlInfo = {0};
@@ -80,53 +80,48 @@ abort_parse:
   return sqlInfo;
 }
 
-tSQLExprList *tSqlExprListAppend(tSQLExprList *pList, tSQLExpr *pNode, SStrToken *pDistinct, SStrToken *pToken) {
+SArray *tSqlExprListAppend(SArray *pList, tSqlExpr *pNode, SStrToken *pDistinct, SStrToken *pToken) {
   if (pList == NULL) {
-    pList = calloc(1, sizeof(tSQLExprList));
+    pList = taosArrayInit(4, sizeof(tSqlExprItem));
   }
 
-  if (pList->nAlloc <= pList->nExpr) {
-    pList->nAlloc = (pList->nAlloc << 1u) + 4;
-    pList->a = realloc(pList->a, pList->nAlloc * sizeof(pList->a[0]));
-    if (pList->a == 0) {
-      pList->nExpr = pList->nAlloc = 0;
-      return pList;
-    }
-  }
-  assert(pList->a != 0);
-
   if (pNode || pToken) {
-    struct tSqlExprItem *pItem = &pList->a[pList->nExpr++];
-    memset(pItem, 0, sizeof(*pItem));
-    pItem->pNode = pNode;
+    struct tSqlExprItem item = {0};
+
+    item.pNode = pNode;
+    item.distinct = (pDistinct != NULL);
+
     if (pToken) {  // set the as clause
-      pItem->aliasName = malloc(pToken->n + 1);
-      strncpy(pItem->aliasName, pToken->z, pToken->n);
-      pItem->aliasName[pToken->n] = 0;
+      item.aliasName = malloc(pToken->n + 1);
+      strncpy(item.aliasName, pToken->z, pToken->n);
+      item.aliasName[pToken->n] = 0;
 
-      strdequote(pItem->aliasName);
+      strdequote(item.aliasName);
     }
-    pItem->distinct = (pDistinct != NULL);
+
+    taosArrayPush(pList, &item);
   }
+
   return pList;
 }
 
-void tSqlExprListDestroy(tSQLExprList *pList) {
-  if (pList == NULL) return;
+static void freeExprElem(void* item) {
+  tSqlExprItem* exprItem = item;
 
-  for (int32_t i = 0; i < pList->nExpr; ++i) {
-    if (pList->a[i].aliasName != NULL) {
-      free(pList->a[i].aliasName);
-    }
-    tSqlExprDestroy(pList->a[i].pNode);
+  tfree(exprItem->aliasName);
+  tSqlExprDestroy(exprItem->pNode);
+}
+
+void tSqlExprListDestroy(SArray *pList) {
+  if (pList == NULL) {
+    return;
   }
 
-  free(pList->a);
-  free(pList);
+  taosArrayDestroyEx(pList, freeExprElem);
 }
 
-tSQLExpr *tSqlExprIdValueCreate(SStrToken *pToken, int32_t optrType) {
-  tSQLExpr *pSqlExpr = calloc(1, sizeof(tSQLExpr));
+tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType) {
+  tSqlExpr *pSqlExpr = calloc(1, sizeof(tSqlExpr));
 
   if (pToken != NULL) {
     pSqlExpr->token = *pToken;
@@ -171,15 +166,15 @@ tSQLExpr *tSqlExprIdValueCreate(SStrToken *pToken, int32_t optrType) {
  * pList is the parameters for function with id(optType)
  * function name is denoted by pFunctionToken
  */
-tSQLExpr *tSqlExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType) {
+tSqlExpr *tSqlExprCreateFunction(SArray *pParam, SStrToken *pFuncToken, SStrToken *endToken, int32_t optType) {
   if (pFuncToken == NULL) {
     return NULL;
   }
 
-  tSQLExpr *pExpr = calloc(1, sizeof(tSQLExpr));
+  tSqlExpr *pExpr = calloc(1, sizeof(tSqlExpr));
   pExpr->tokenId = optType;
   pExpr->type    = SQL_NODE_SQLFUNCTION;
-  pExpr->pParam  = pList;
+  pExpr->pParam  = pParam;
 
   int32_t len = (int32_t)((endToken->z + endToken->n) - pFuncToken->z);
   pExpr->operand = (*pFuncToken);
@@ -193,10 +188,10 @@ tSQLExpr *tSqlExprCreateFunction(tSQLExprList *pList, SStrToken *pFuncToken, SSt
 
 /*
  * create binary expression in this procedure
- * if the expr is arithmetic, calculate the result and set it to tSQLExpr Object
+ * if the expr is arithmetic, calculate the result and set it to tSqlExpr Object
  */
-tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
-  tSQLExpr *pExpr = calloc(1, sizeof(tSQLExpr));
+tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType) {
+  tSqlExpr *pExpr = calloc(1, sizeof(tSqlExpr));
 
   pExpr->type = SQL_NODE_EXPR;
   if (pLeft != NULL && pRight != NULL && (optrType != TK_IN)) {
@@ -291,9 +286,9 @@ tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
     pExpr->tokenId = optrType;
     pExpr->pLeft = pLeft;
 
-    tSQLExpr *pRSub = calloc(1, sizeof(tSQLExpr));
+    tSqlExpr *pRSub = calloc(1, sizeof(tSqlExpr));
     pRSub->tokenId = TK_SET;  // TODO refactor .....
-    pRSub->pParam = (tSQLExprList *)pRight;
+    pRSub->pParam = (SArray *)pRight;
 
     pExpr->pRight = pRSub;
   } else {
@@ -301,7 +296,7 @@ tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
     pExpr->pLeft = pLeft;
 
     if (pLeft != NULL && pRight == NULL) {
-      pRight = calloc(1, sizeof(tSQLExpr));
+      pRight = calloc(1, sizeof(tSqlExpr));
     }
 
     pExpr->pRight = pRight;
@@ -312,8 +307,8 @@ tSQLExpr *tSqlExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
 
 
 
-tSQLExpr *tSqlExprClone(tSQLExpr *pSrc) {
-  tSQLExpr *pExpr = calloc(1, sizeof(tSQLExpr));
+tSqlExpr *tSqlExprClone(tSqlExpr *pSrc) {
+  tSqlExpr *pExpr = calloc(1, sizeof(tSqlExpr));
 
   memcpy(pExpr, pSrc, sizeof(*pSrc));
   
@@ -332,7 +327,7 @@ tSQLExpr *tSqlExprClone(tSQLExpr *pSrc) {
 }
 
 
-void tSqlExprNodeDestroy(tSQLExpr *pExpr) {
+void doDestroySqlExprNode(tSqlExpr *pExpr) {
   if (pExpr == NULL) {
     return;
   }
@@ -342,11 +337,10 @@ void tSqlExprNodeDestroy(tSQLExpr *pExpr) {
   }
 
   tSqlExprListDestroy(pExpr->pParam);
-
   free(pExpr);
 }
 
-void tSqlExprDestroy(tSQLExpr *pExpr) {
+void tSqlExprDestroy(tSqlExpr *pExpr) {
   if (pExpr == NULL) {
     return;
   }
@@ -355,7 +349,8 @@ void tSqlExprDestroy(tSQLExpr *pExpr) {
   pExpr->pLeft = NULL;
   tSqlExprDestroy(pExpr->pRight);
   pExpr->pRight = NULL;
-  tSqlExprNodeDestroy(pExpr);
+
+  doDestroySqlExprNode(pExpr);
 }
 
 SArray *tVariantListAppendToken(SArray *pList, SStrToken *pToken, uint8_t order) {
@@ -411,13 +406,13 @@ SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int
   return pList;
 }
 
-void setDbName(SStrToken *pCpxName, SStrToken *pDb) {
+void tSetDbName(SStrToken *pCpxName, SStrToken *pDb) {
   pCpxName->type = pDb->type;
   pCpxName->z = pDb->z;
   pCpxName->n = pDb->n;
 }
 
-void tSqlSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType) {
+void tSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType) {
   int32_t maxLen = sizeof(pField->name) / sizeof(pField->name[0]);
   
   // truncate the column name
@@ -485,7 +480,7 @@ static int32_t tryParseNameTwoParts(SStrToken *type) {
   }
 }
 
-void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
+void tSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
   // set the field type invalid
   pField->type = -1;
   pField->name[0] = 0;
@@ -550,39 +545,39 @@ void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
 /*
  * extract the select info out of sql string
  */
-SQuerySQL *tSetQuerySqlNode(SStrToken *pSelectToken, tSQLExprList *pSelection, SArray *pFrom, tSQLExpr *pWhere,
+SQuerySqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelectList, SArray *pFrom, tSqlExpr *pWhere,
                              SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval, SSessionWindowVal *pSession,
                              SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit) {
-  assert(pSelection != NULL);
+  assert(pSelectList != NULL);
 
-  SQuerySQL *pQuery = calloc(1, sizeof(SQuerySQL));
-  pQuery->selectToken = *pSelectToken;
-  pQuery->selectToken.n = (uint32_t)strlen(pQuery->selectToken.z);  // all later sql string are belonged to the stream sql
+  SQuerySqlNode *pQuery = calloc(1, sizeof(SQuerySqlNode));
+  pQuery->sqlstr = *pSelectToken;
+  pQuery->sqlstr.n = (uint32_t)strlen(pQuery->sqlstr.z);  // all later sql string are belonged to the stream sql
 
-  pQuery->pSelection = pSelection;
+  pQuery->pSelectList = pSelectList;
   pQuery->from = pFrom;
   pQuery->pGroupby = pGroupby;
   pQuery->pSortOrder = pSortOrder;
   pQuery->pWhere = pWhere;
 
   if (pLimit != NULL) {
-    pQuery->limit = *pLimit;
+    pQuery->limit = pLimit;
   }
 
   if (pGLimit != NULL) {
-    pQuery->slimit = *pGLimit;
+    pQuery->slimit = pGLimit;
   }
 
   if (pInterval != NULL) {
-    pQuery->interval = *pInterval;
+    pQuery->interval = pInterval;
   }
 
   if (pSliding != NULL) {
-    pQuery->sliding = *pSliding;
+    pQuery->sliding = pSliding;
   }
 
   if (pSession != NULL) {
-    pQuery->sessionVal = *pSession;
+    pQuery->sessionVal = pSession;
   }
 
   pQuery->fillType = pFill;
@@ -602,14 +597,14 @@ void freeCreateTableInfo(void* p) {
   tfree(pInfo->tagdata.data);
 }
 
-void doDestroyQuerySql(SQuerySQL *pQuerySql) {
+void doDestroyQuerySql(SQuerySqlNode *pQuerySql) {
   if (pQuerySql == NULL) {
     return;
   }
 
-  tSqlExprListDestroy(pQuerySql->pSelection);
+  tSqlExprListDestroy(pQuerySql->pSelectList);
   
-  pQuerySql->pSelection = NULL;
+  pQuerySql->pSelectList = NULL;
 
   tSqlExprDestroy(pQuerySql->pWhere);
   pQuerySql->pWhere = NULL;
@@ -635,15 +630,15 @@ void destroyAllSelectClause(SSubclauseInfo *pClause) {
   }
 
   for(int32_t i = 0; i < pClause->numOfClause; ++i) {
-    SQuerySQL *pQuerySql = pClause->pClause[i];
+    SQuerySqlNode *pQuerySql = pClause->pClause[i];
     doDestroyQuerySql(pQuerySql);
   }
   
   tfree(pClause->pClause);
 }
 
-SCreateTableSQL *tSetCreateSqlElems(SArray *pCols, SArray *pTags, SQuerySQL *pSelect, int32_t type) {
-  SCreateTableSQL *pCreate = calloc(1, sizeof(SCreateTableSQL));
+SCreateTableSql *tSetCreateTableInfo(SArray *pCols, SArray *pTags, SQuerySqlNode *pSelect, int32_t type) {
+  SCreateTableSql *pCreate = calloc(1, sizeof(SCreateTableSql));
 
   switch (type) {
     case TSQL_CREATE_TABLE: {
@@ -687,7 +682,7 @@ SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagNam
   return info;
 }
 
-SAlterTableInfo *tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type, int16_t tableType) {
+SAlterTableInfo *tSetAlterTableInfo(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type, int16_t tableType) {
   SAlterTableInfo *pAlterTable = calloc(1, sizeof(SAlterTableInfo));
   
   pAlterTable->name = *pTableName;
@@ -709,7 +704,7 @@ SAlterTableInfo *tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArra
   return pAlterTable;
 }
 
-void* destroyCreateTableSql(SCreateTableSQL* pCreate) {
+void* destroyCreateTableSql(SCreateTableSql* pCreate) {
   doDestroyQuerySql(pCreate->pSelect);
 
   taosArrayDestroy(pCreate->colInfo.pColumns);
@@ -757,7 +752,7 @@ SSubclauseInfo* setSubclause(SSubclauseInfo* pSubclause, void *pSqlExprInfo) {
     return pSubclause;
   }
   
-  pSubclause->pClause = (SQuerySQL**) tmp;
+  pSubclause->pClause = (SQuerySqlNode**) tmp;
   
   pSubclause->pClause[newSize - 1] = pSqlExprInfo;
   pSubclause->numOfClause++;
@@ -788,7 +783,7 @@ SSubclauseInfo* appendSelectClause(SSubclauseInfo *pQueryInfo, void *pSubclause)
     return pQueryInfo;
   }
   
-  pQueryInfo->pClause = (SQuerySQL**) tmp;
+  pQueryInfo->pClause = (SQuerySqlNode**) tmp;
   pQueryInfo->pClause[pQueryInfo->numOfClause++] = pSubclause;
   
   return pQueryInfo;
@@ -799,7 +794,7 @@ void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken
   pInfo->pCreateTableInfo->existCheck = (pIfNotExists->n != 0);
 }
 
-void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParam, ...) {
+void setDCLSqlElems(SSqlInfo *pInfo, int32_t type, int32_t nParam, ...) {
   pInfo->type = type;
   if (nParam == 0) {
     return;