Merge pull request #10031 from taosdata/feature/3.0_wxy

TD-13197 SELECT statement syntax definition

.gitignore

@@ -86,6 +86,7 @@ tests/comparisonTest/opentsdb/opentsdbtest/.settings/
 tests/examples/JDBC/JDBCDemo/.classpath
 tests/examples/JDBC/JDBCDemo/.project
 tests/examples/JDBC/JDBCDemo/.settings/
+source/libs/parser/inc/new_sql.*
 
 # Emacs
 # -*- mode: gitignore; -*-
@@ -101,4 +102,4 @@ TAGS
 
 contrib/*
 !contrib/CMakeLists.txt
-!contrib/test
\ No newline at end of file
+!contrib/test

include/common/ttokendef.h

@@ -207,6 +207,36 @@
 #define TK_INTO                           189
 #define TK_VALUES                         190
 
+#define NEW_TK_UNION                            1
+#define NEW_TK_ALL                              2
+#define NEW_TK_MINUS                            3
+#define NEW_TK_EXCEPT                           4
+#define NEW_TK_INTERSECT                        5
+#define NEW_TK_NK_PLUS                          6
+#define NEW_TK_NK_MINUS                         7
+#define NEW_TK_NK_STAR                          8
+#define NEW_TK_NK_SLASH                         9
+#define NEW_TK_SHOW                            10
+#define NEW_TK_DATABASES                       11
+#define NEW_TK_NK_ID                           12
+#define NEW_TK_NK_LP                           13
+#define NEW_TK_NK_RP                           14
+#define NEW_TK_NK_COMMA                        15
+#define NEW_TK_NK_LITERAL                      16
+#define NEW_TK_NK_DOT                          17
+#define NEW_TK_SELECT                          18
+#define NEW_TK_DISTINCT                        19
+#define NEW_TK_AS                              20
+#define NEW_TK_FROM                            21
+#define NEW_TK_WITH                            22
+#define NEW_TK_RECURSIVE                       23
+#define NEW_TK_ORDER                           24
+#define NEW_TK_BY                              25
+#define NEW_TK_ASC                             26
+#define NEW_TK_DESC                            27
+#define NEW_TK_NULLS                           28
+#define NEW_TK_FIRST                           29
+#define NEW_TK_LAST                            30
 
 #define TK_SPACE                          300
 #define TK_COMMENT                        301

include/libs/parser/parsenodes.h

@@ -35,7 +35,7 @@ typedef struct SQueryNode {
   int16_t type;
 } SQueryNode;
 
-#define nodeType(nodeptr) (((const SQueryNode*)(nodeptr))->type)
+#define queryNodeType(nodeptr) (((const SQueryNode*)(nodeptr))->type)
 
 typedef struct SField {
   char     name[TSDB_COL_NAME_LEN];

include/nodes/nodes.h

@@ -20,7 +20,6 @@
 extern "C" {
 #endif
 
-#include "tarray.h"
 #include "tdef.h"
 
 typedef enum ENodeType {
@@ -35,12 +34,14 @@ typedef enum ENodeType {
   QUERY_NODE_JOIN_TABLE,
   QUERY_NODE_GROUPING_SET,
   QUERY_NODE_ORDER_BY_EXPR,
+  QUERY_NODE_LIMIT,
   QUERY_NODE_STATE_WINDOW,
   QUERY_NODE_SESSION_WINDOW,
   QUERY_NODE_INTERVAL_WINDOW,
 
   QUERY_NODE_SET_OPERATOR,
-  QUERY_NODE_SELECT_STMT
+  QUERY_NODE_SELECT_STMT,
+  QUERY_NODE_SHOW_STMT
 } ENodeType;
 
 /**
@@ -52,6 +53,27 @@ typedef struct SNode {
 } SNode;
 
 #define nodeType(nodeptr) (((const SNode*)(nodeptr))->type)
+#define setNodeType(nodeptr, type) (((SNode*)(nodeptr))->type = (type))
+
+typedef struct SListCell {
+  SNode* pNode;
+  struct SListCell* pNext;
+} SListCell;
+
+typedef struct SNodeList {
+  int16_t length;
+  SListCell* pHeader;
+} SNodeList;
+
+#define LIST_LENGTH(l) (NULL != (l) ? (l)->length : 0)
+
+#define FOREACH(node, list)	\
+  for (SListCell* cell = (NULL != (list) ? (list)->pHeader : NULL); (NULL != cell ? (node = cell->pNode, true) : (node = NULL, false)); cell = cell->pNext)
+
+#define FORBOTH(node1, list1, node2, list2) \
+  for (SListCell* cell1 = (NULL != (list1) ? (list1)->pHeader : NULL), *cell2 = (NULL != (list2) ? (list2)->pHeader : NULL); \
+    (NULL == cell1 ? (node1 = NULL, false) : (node1 = cell1->pNode, true)), (NULL == cell2 ? (node2 = NULL, false) : (node2 = cell2->pNode, true)), (node1 != NULL && node2 != NULL); \
+    cell1 = cell1->pNext, cell2 = cell2->pNext)
 
 typedef struct SDataType {
   uint8_t type;
@@ -128,7 +150,7 @@ typedef enum ELogicConditionType {
 typedef struct SLogicConditionNode {
   ENodeType type; // QUERY_NODE_LOGIC_CONDITION
   ELogicConditionType condType;
-  SArray* pParameterList;
+  SNodeList* pParameterList;
 } SLogicConditionNode;
 
 typedef struct SIsNullCondNode {
@@ -141,7 +163,7 @@ typedef struct SFunctionNode {
   SExprNode type; // QUERY_NODE_FUNCTION
   char functionName[TSDB_FUNC_NAME_LEN];
   int32_t funcId;
-  SArray* pParameterList; // SNode
+  SNodeList* pParameterList; // SNode
 } SFunctionNode;
 
 typedef struct STableNode {
@@ -151,12 +173,12 @@ typedef struct STableNode {
 } STableNode;
 
 typedef struct SRealTableNode {
-  STableNode type; // QUERY_NODE_REAL_TABLE
+  STableNode table; // QUERY_NODE_REAL_TABLE
   char dbName[TSDB_DB_NAME_LEN];
 } SRealTableNode;
 
 typedef struct STempTableNode {
-  STableNode type; // QUERY_NODE_TEMP_TABLE
+  STableNode table; // QUERY_NODE_TEMP_TABLE
   SNode* pSubquery;
 } STempTableNode;
 
@@ -165,7 +187,7 @@ typedef enum EJoinType {
 } EJoinType;
 
 typedef struct SJoinTableNode {
-  STableNode type; // QUERY_NODE_JOIN_TABLE
+  STableNode table; // QUERY_NODE_JOIN_TABLE
   EJoinType joinType;
   SNode* pLeft;
   SNode* pRight;
@@ -179,7 +201,7 @@ typedef enum EGroupingSetType {
 typedef struct SGroupingSetNode {
   ENodeType type; // QUERY_NODE_GROUPING_SET
   EGroupingSetType groupingSetType;
-  SArray* pParameterList; 
+  SNodeList* pParameterList; 
 } SGroupingSetNode;
 
 typedef enum EOrder {
@@ -188,7 +210,8 @@ typedef enum EOrder {
 } EOrder;
 
 typedef enum ENullOrder {
-  NULL_ORDER_FIRST = 1,
+  NULL_ORDER_DEFAULT = 1,
+  NULL_ORDER_FIRST,
   NULL_ORDER_LAST
 } ENullOrder;
 
@@ -199,10 +222,11 @@ typedef struct SOrderByExprNode {
   ENullOrder nullOrder;
 } SOrderByExprNode;
 
-typedef struct SLimitInfo {
+typedef struct SLimitNode {
+  ENodeType type; // QUERY_NODE_LIMIT
   uint64_t limit;
   uint64_t offset;
-} SLimitInfo;
+} SLimitNode;
 
 typedef struct SStateWindowNode {
   ENodeType type; // QUERY_NODE_STATE_WINDOW
@@ -225,15 +249,16 @@ typedef struct SIntervalWindowNode {
 typedef struct SSelectStmt {
   ENodeType type; // QUERY_NODE_SELECT_STMT
   bool isDistinct;
-  SArray* pProjectionList; // SNode
+  bool isStar;
+  SNodeList* pProjectionList; // SNode
   SNode* pFromTable;
   SNode* pWhereCond;
-  SArray* pPartitionByList; // SNode
+  SNodeList* pPartitionByList; // SNode
   SNode* pWindowClause;
-  SArray* pGroupByList; // SGroupingSetNode
-  SArray* pOrderByList; // SOrderByExprNode
-  SLimitInfo limit;
-  SLimitInfo slimit;
+  SNodeList* pGroupByList; // SGroupingSetNode
+  SNodeList* pOrderByList; // SOrderByExprNode
+  SLimitNode limit;
+  SLimitNode slimit;
 } SSelectStmt;
 
 typedef enum ESetOperatorType {
@@ -249,20 +274,24 @@ typedef struct SSetOperator {
 
 typedef bool (*FQueryNodeWalker)(SNode* pNode, void* pContext);
 
-bool nodeArrayWalker(SArray* pArray, FQueryNodeWalker walker, void* pContext);
-bool nodeTreeWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext);
+bool nodesWalkNode(SNode* pNode, FQueryNodeWalker walker, void* pContext);
+bool nodesWalkNodeList(SNodeList* pNodeList, FQueryNodeWalker walker, void* pContext);
+
+bool nodesWalkStmt(SNode* pNode, FQueryNodeWalker walker, void* pContext);
 
-bool stmtWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext);
+bool nodesEqualNode(const SNode* a, const SNode* b);
 
-bool nodeEqual(const SNode* a, const SNode* b);
+void nodesCloneNode(const SNode* pNode);
 
-void cloneNode(const SNode* pNode);
+int32_t nodesNodeToString(const SNode* pNode, char** pStr, int32_t* pLen);
+int32_t nodesStringToNode(const char* pStr, SNode** pNode);
 
-int32_t nodeToString(const SNode* pNode, char** pStr, int32_t* pLen);
-int32_t stringToNode(const char* pStr, SNode** pNode);
+bool nodesIsTimeorderQuery(const SNode* pQuery);
+bool nodesIsTimelineQuery(const SNode* pQuery);
 
-bool isTimeorderQuery(const SNode* pQuery);
-bool isTimelineQuery(const SNode* pQuery);
+SNode* nodesMakeNode(ENodeType type);
+void nodesDestroyNode(SNode* pNode);
+void nodesDestroyNodeList(SNodeList* pList);
 
 #ifdef __cplusplus
 }

include/nodes/nodesShowStmts.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_NODES_SHOW_STMTS_H_
+#define _TD_NODES_SHOW_STMTS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "nodes.h"
+
+typedef enum EShowStmtType {
+  SHOW_TYPE_DATABASE = 1
+} EShowStmtType;
+
+typedef struct SShowStmt {
+  ENodeType type; // QUERY_NODE_SHOW_STMT
+  EShowStmtType showType;
+} SShowStmt;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_NODES_SHOW_STMTS_H_*/

source/libs/parser/CMakeLists.txt

@@ -8,7 +8,7 @@ target_include_directories(
 
 target_link_libraries(
         parser
-        PRIVATE os util catalog function transport qcom
+        PRIVATE os util nodes catalog function transport qcom
 )
 
 if(${BUILD_TEST})

source/libs/parser/inc/astCreateContext.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_AST_CREATER_H_
+#define _TD_AST_CREATER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "nodes.h"
+#include "parser.h"
+
+typedef struct SAstCreateContext {
+  SParseContext* pQueryCxt;
+  bool notSupport;
+  bool valid;
+  SNode* pRootNode;
+} SAstCreateContext;
+
+int32_t createAstCreateContext(const SParseContext* pQueryCxt, SAstCreateContext* pCxt);
+int32_t destroyAstCreateContext(SAstCreateContext* pCxt);
+
+void* acquireRaii(SAstCreateContext* pCxt, void* p);
+void* releaseRaii(SAstCreateContext* pCxt, void* p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_AST_CREATER_H_*/

source/libs/parser/inc/astCreateFuncs.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "nodes.h"
+#include "nodesShowStmts.h"
+#include "astCreateContext.h"
+#include "ttoken.h"
+
+#ifndef _TD_AST_CREATE_FUNCS_H_
+#define _TD_AST_CREATE_FUNCS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool checkTableName(const SToken* pTableName);
+SNodeList* addNodeToList(SAstCreateContext* pCxt, SNodeList* pList, SNode* pNode);
+SNode* addOrderByList(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pOrderByList);
+SNode* addSlimit(SAstCreateContext* pCxt, SNode* pStmt, SNode* pSlimit);
+SNode* addLimit(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit);
+SNode* createColumnNode(SAstCreateContext* pCxt, const SToken* pTableName, const SToken* pColumnName);
+SNode* createLimitNode(SAstCreateContext* pCxt, const SToken* pLimit, const SToken* pOffset);
+SNodeList* createNodeList(SAstCreateContext* pCxt, SNode* pNode);
+SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder);
+SNode* createRealTableNode(SAstCreateContext* pCxt, const SToken* pDbName, const SToken* pTableName);
+SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable);
+SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight);
+SNode* createShowStmt(SAstCreateContext* pCxt, EShowStmtType type);
+SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* pAlias);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_AST_CREATE_FUNCS_H_*/

source/libs/parser/inc/new_sql.y

+//lemon parser file to generate sql parse by using finite-state-machine code used to parse sql
+//usage: lemon sql.y
+
+%name NewParse
+
+%token_prefix NEW_TK_
+%token_type { SToken }
+%default_type { SNode* }
+%default_destructor { nodesDestroyNode($$); }
+
+%extra_argument { SAstCreateContext* pCxt }
+
+%include {
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdbool.h>
+
+#include "nodes.h"
+#include "ttoken.h"
+#include "ttokendef.h"
+#include "astCreateFuncs.h"
+
+#define PARSER_TRACE printf("rule = %s\n", yyRuleName[yyruleno])
+}
+
+%syntax_error {  
+  if(TOKEN.z) {
+    char msg[] = "syntax error near \"%s\"";
+    int32_t sqlLen = strlen(&TOKEN.z[0]);
+
+    if (sqlLen + sizeof(msg)/sizeof(msg[0]) + 1 > pCxt->pQueryCxt->msgLen) {
+        char tmpstr[128] = {0};
+        memcpy(tmpstr, &TOKEN.z[0], sizeof(tmpstr)/sizeof(tmpstr[0]) - 1);
+        sprintf(pCxt->pQueryCxt->pMsg, msg, tmpstr);
+    } else {
+        sprintf(pCxt->pQueryCxt->pMsg, msg, &TOKEN.z[0]);
+    }
+  } else {
+    sprintf(pCxt->pQueryCxt->pMsg, "Incomplete SQL statement");
+  }
+  pCxt->valid = false;
+}
+
+%parse_accept       { printf("parsing complete!\n" );}
+
+//%left OR.
+//%left AND.
+//%right NOT.
+%left UNION ALL MINUS EXCEPT INTERSECT.
+//%left EQ NE ISNULL NOTNULL IS LIKE MATCH NMATCH GLOB BETWEEN IN.
+//%left GT GE LT LE.
+//%left BITAND BITOR LSHIFT RSHIFT.
+%left NK_PLUS NK_MINUS.
+//%left DIVIDE TIMES.
+%left NK_STAR NK_SLASH. //REM.
+//%left CONCAT.
+//%right UMINUS UPLUS BITNOT.
+
+cmd ::= SHOW DATABASES.  { PARSER_TRACE; createShowStmt(pCxt, SHOW_TYPE_DATABASE); }
+
+cmd ::= query_expression(A). { PARSER_TRACE; pCxt->pRootNode = A; }
+
+//////////////////////// value_function /////////////////////////////////
+value_function ::= NK_ID NK_LP value_expression NK_RP.
+value_function ::= NK_ID NK_LP value_expression NK_COMMA value_expression NK_RP.
+
+//////////////////////// value_expression_primary /////////////////////////////////
+value_expression_primary ::= NK_LP value_expression NK_RP.
+value_expression_primary ::= nonparenthesized_value_expression_primary.
+
+nonparenthesized_value_expression_primary ::= literal.
+// ?
+nonparenthesized_value_expression_primary ::= column_reference.
+
+literal ::= NK_LITERAL.
+
+column_reference(A) ::= NK_ID(B).                      { PARSER_TRACE; A = createColumnNode(pCxt, NULL, &B); }
+column_reference(A) ::= table_name(B) NK_DOT NK_ID(C). { PARSER_TRACE; A = createColumnNode(pCxt, &B, &C); }
+
+//////////////////////// value_expression /////////////////////////////////
+value_expression ::= common_value_expression.
+
+common_value_expression ::= numeric_value_expression.
+
+numeric_value_expression ::= numeric_primary.
+numeric_value_expression ::= NK_PLUS numeric_primary.
+numeric_value_expression ::= NK_MINUS numeric_primary.
+numeric_value_expression ::= numeric_value_expression NK_PLUS numeric_value_expression.
+numeric_value_expression ::= numeric_value_expression NK_MINUS numeric_value_expression.
+numeric_value_expression ::= numeric_value_expression NK_STAR numeric_value_expression.
+numeric_value_expression ::= numeric_value_expression NK_SLASH numeric_value_expression.
+
+numeric_primary ::= value_expression_primary.
+numeric_primary ::= value_function.
+
+//////////////////////// query_specification /////////////////////////////////
+query_specification(A) ::= SELECT set_quantifier_opt(B) select_list(C) from_clause(D). { PARSER_TRACE; A = createSelectStmt(pCxt, B, C, D); }
+
+%type set_quantifier_opt { bool }
+%destructor set_quantifier_opt {}
+set_quantifier_opt(A) ::= .         { PARSER_TRACE; A = false; }
+set_quantifier_opt(A) ::= DISTINCT. { PARSER_TRACE; A = true; }
+set_quantifier_opt(A) ::= ALL.      { PARSER_TRACE; A = false; }
+
+%type select_list { SNodeList* }
+%destructor select_list { nodesDestroyNodeList($$); }
+select_list(A) ::= NK_STAR.           { PARSER_TRACE; A = NULL; }
+select_list(A) ::= select_sublist(B). { PARSER_TRACE; A = B; }
+
+%type select_sublist { SNodeList* }
+%destructor select_sublist { nodesDestroyNodeList($$); }
+select_sublist(A) ::= select_item(B).                            { PARSER_TRACE; A = createNodeList(pCxt, B); }
+select_sublist(A) ::= select_sublist(B) NK_COMMA select_item(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); }
+
+select_item(A) ::= value_expression(B).                     { PARSER_TRACE; A = B; }
+select_item(A) ::= value_expression(B) AS NK_ID(C).         { PARSER_TRACE; A = setProjectionAlias(pCxt, B, &C); }
+select_item(A) ::= table_name(B) NK_DOT NK_STAR(C).                 { PARSER_TRACE; A = createColumnNode(pCxt, &B, &C); }
+
+from_clause(A) ::= FROM table_reference_list(B). { PARSER_TRACE; A = B; }
+
+//%type table_reference_list { SNodeList* }
+//%destructor table_reference_list { nodesDestroyNodeList($$); }
+table_reference_list(A) ::= table_reference(B).                               { PARSER_TRACE; A = B; }
+//table_reference_list(A) ::= table_reference_list(B) NK_COMMA table_reference(C). { PARSER_TRACE; A = createJoinTableNode(pCxt, B, C); }
+
+//table_reference(A) ::= NK_ID(B). { PARSER_TRACE; A = createRealTableNode(pCxt, ); }
+table_reference(A) ::= table_factor(B). { PARSER_TRACE; A = B; }
+//table_reference ::= joined_table.
+
+table_factor(A) ::= table_primary(B). { PARSER_TRACE; A = B; }
+
+table_primary(A) ::= table_name(B).                   { PARSER_TRACE; A = createRealTableNode(pCxt, NULL, &B); }
+table_primary(A) ::= db_name(B) NK_DOT table_name(C). { PARSER_TRACE; A = createRealTableNode(pCxt, &B, &C); }
+table_primary ::= derived_table.
+
+derived_table ::= table_subquery.
+
+%type db_name { SToken }
+db_name(A) ::= NK_ID(B).    { PARSER_TRACE; A = B; }
+%type table_name { SToken }
+table_name(A) ::= NK_ID(B). { PARSER_TRACE; A = B; }
+
+//////////////////////// subquery /////////////////////////////////
+subquery ::= NK_LR query_expression NK_RP.
+
+table_subquery ::= subquery.
+
+// query_expression
+query_expression(A) ::= with_clause_opt query_expression_body(B) order_by_clause_opt(C) slimit_clause_opt(D) limit_clause_opt(E). { 
+                                                                                                                                    PARSER_TRACE;
+                                                                                                                                    addOrderByList(pCxt, B, C);
+                                                                                                                                    addSlimit(pCxt, B, D);
+                                                                                                                                    addLimit(pCxt, B, E);
+                                                                                                                                    A = B;  
+                                                                                                                                  }
+
+// WITH AS 
+with_clause_opt ::= .                                                                                                             {}
+
+query_expression_body(A) ::= query_primary(B).                                                                                    { PARSER_TRACE; A = B; }
+query_expression_body(A) ::= query_expression_body(B) UNION ALL query_expression_body(D).                                         { PARSER_TRACE; A = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, B, D); }
+
+query_primary(A) ::= query_specification(B).                                                                                      { PARSER_TRACE; A = B; }
+query_primary(A) ::= NK_LP query_expression_body(B) order_by_clause_opt limit_clause_opt slimit_clause_opt NK_RP.                 { PARSER_TRACE; A = B;}
+
+%type order_by_clause_opt { SNodeList* }
+%destructor order_by_clause_opt { nodesDestroyNodeList($$); }
+order_by_clause_opt(A) ::= .                                                                                                      { PARSER_TRACE; A = NULL; }
+order_by_clause_opt(A) ::= ORDER BY sort_specification_list(B).                                                                   { PARSER_TRACE; A = B; }
+
+slimit_clause_opt(A) ::= .                                                                                                        { A = NULL; }
+slimit_clause_opt(A) ::= SLIMIT NK_INTEGER(B) SOFFSET NK_INTEGER(C).                                                              { A = createLimitNode(pCxt, &B, &C); }
+slimit_clause_opt(A) ::= SLIMIT NK_INTEGER(C) NK_COMMA NK_INTEGER(B).                                                             { A = createLimitNode(pCxt, &B, &C); }
+
+limit_clause_opt(A) ::= .                                                                                                         { A = NULL; }
+limit_clause_opt(A) ::= LIMIT NK_INTEGER(B) OFFSET NK_INTEGER(C).                                                                 { A = createLimitNode(pCxt, &B, &C); }
+limit_clause_opt(A) ::= LIMIT NK_INTEGER(C) NK_COMMA NK_INTEGER(B).                                                               { A = createLimitNode(pCxt, &B, &C); }
+
+//////////////////////// sort_specification_list /////////////////////////////////
+%type sort_specification_list { SNodeList* }
+%destructor sort_specification_list { nodesDestroyNodeList($$); }
+sort_specification_list(A) ::= sort_specification(B).                                     { PARSER_TRACE; A = createNodeList(pCxt, B); }
+sort_specification_list(A) ::= sort_specification_list(B) NK_COMMA sort_specification(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); }
+
+sort_specification(A) ::= value_expression(B) ordering_specification_opt(C) null_ordering_opt(D). { PARSER_TRACE; A = createOrderByExprNode(pCxt, B, C, D); }
+
+%type ordering_specification_opt EOrder
+%destructor ordering_specification_opt {}
+ordering_specification_opt(A) ::= .     { PARSER_TRACE; A = ORDER_ASC; }
+ordering_specification_opt(A) ::= ASC.  { PARSER_TRACE; A = ORDER_ASC; }
+ordering_specification_opt(A) ::= DESC. { PARSER_TRACE; A = ORDER_DESC; }
+
+%type null_ordering_opt ENullOrder
+%destructor null_ordering_opt {}
+null_ordering_opt(A) ::= .            { PARSER_TRACE; A = NULL_ORDER_DEFAULT; }
+null_ordering_opt(A) ::= NULLS FIRST. { PARSER_TRACE; A = NULL_ORDER_FIRST; }
+null_ordering_opt(A) ::= NULLS LAST.  { PARSER_TRACE; A = NULL_ORDER_LAST; }

source/nodes/src/nodesCode.c → source/libs/parser/inc/parserImpl.h

@@ -14,11 +14,23 @@
  */
 
 #include "nodes.h"
+#include "parser.h"
 
-int32_t nodeToString(const SNode* pNode, char** pStr, int32_t* pLen) {
+#ifndef _TD_AST_CREATE_FUNCS_H_
+#define _TD_AST_CREATE_FUNCS_H_
 
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SQuery {
+  SNode* pRoot;
+} SQuery;
 
-int32_t stringToNode(const char* pStr, SNode** pNode) {
+int32_t doParse(SParseContext* pParseCxt, SQuery* pQuery);
 
+#ifdef __cplusplus
 }
+#endif
+
+#endif /*_TD_AST_CREATE_FUNCS_H_*/

source/libs/parser/src/astCreateContext.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ttoken.h"
+#include "astCreateContext.h"
+
+void* acquireRaii(SAstCreateContext* pCxt, void* p) {
+  if (NULL == p) {
+    return NULL;
+  }
+  return p;
+}
+
+void* releaseRaii(SAstCreateContext* pCxt, void* p) {
+  if (NULL == p) {
+    return NULL;
+  }
+  return p;
+}
+
+int32_t createAstCreater(const SParseContext* pQueryCxt, SAstCreateContext* pCxt) {
+
+}
+
+int32_t destroyAstCreater(SAstCreateContext* pCxt) {
+
+}
+

source/libs/parser/src/astCreateFuncs.c

+
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "astCreateFuncs.h"
+
+#include "astCreateContext.h"
+
+bool checkTableName(const SToken* pTableName) {
+  printf("%p : %d, %d, %s\n", pTableName, pTableName->type, pTableName->n, pTableName->z);
+  return pTableName->n < TSDB_TABLE_NAME_LEN ? true : false;
+}
+
+SNodeList* addNodeToList(SAstCreateContext* pCxt, SNodeList* pList, SNode* pNode) {
+
+}
+
+SNode* addOrderByList(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pOrderByList) {
+
+}
+
+SNode* addSlimit(SAstCreateContext* pCxt, SNode* pStmt, SNode* pSlimit) {
+
+}
+
+SNode* addLimit(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit) {
+
+}
+
+SNode* createColumnNode(SAstCreateContext* pCxt, const SToken* pTableName, const SToken* pColumnName) {
+
+}
+
+SNode* createLimitNode(SAstCreateContext* pCxt, const SToken* pLimit, const SToken* pOffset) {
+
+}
+
+SNodeList* createNodeList(SAstCreateContext* pCxt, SNode* pNode) {
+
+}
+
+SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder) {
+
+}
+
+SNode* createRealTableNode(SAstCreateContext* pCxt, const SToken* pDbName, const SToken* pTableName) {
+  SRealTableNode* realTable = (SRealTableNode*)nodesMakeNode(QUERY_NODE_REAL_TABLE);
+  if (NULL != pDbName) {
+    printf("DbName %p : %d, %d, %s\n", pDbName, pDbName->type, pDbName->n, pDbName->z);
+    strncpy(realTable->dbName, pDbName->z, pDbName->n);
+  }
+  printf("TableName %p : %d, %d, %s\n", pTableName, pTableName->type, pTableName->n, pTableName->z);
+  strncpy(realTable->table.tableName, pTableName->z, pTableName->n);
+  return acquireRaii(pCxt, realTable);
+}
+
+SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable) {
+  SSelectStmt* select = (SSelectStmt*)nodesMakeNode(QUERY_NODE_SELECT_STMT);
+  select->isDistinct = isDistinct;
+  if (NULL == pProjectionList) {
+    select->isStar = true;
+  }
+  select->pProjectionList = releaseRaii(pCxt, pProjectionList);
+  printf("pTable = %p, name = %s\n", pTable, ((SRealTableNode*)pTable)->table.tableName);
+  select->pFromTable = releaseRaii(pCxt, pTable);
+  return acquireRaii(pCxt, select);
+}
+
+SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight) {
+
+}
+
+SNode* createShowStmt(SAstCreateContext* pCxt, EShowStmtType type) {
+
+}
+
+SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* pAlias) {
+
+}

source/nodes/src/nodesUtil.c → source/libs/parser/src/astTranslate.c

@@ -13,12 +13,6 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "nodes.h"
+// int32_t doTranslate() {
 
-bool isTimeorderQuery(const SNode* pQuery) {
-
-}
-
-bool isTimelineQuery(const SNode* pQuery) {
-
-}
+// }

source/libs/parser/src/parser.c

@@ -249,7 +249,7 @@ void qDestroyQuery(SQueryNode* pQueryNode) {
     return;
   }
 
-  int32_t type = nodeType(pQueryNode);
+  int32_t type = queryNodeType(pQueryNode);
   if (type == TSDB_SQL_INSERT || type == TSDB_SQL_CREATE_TABLE) {
     SVnodeModifOpStmtInfo* pModifInfo = (SVnodeModifOpStmtInfo*)pQueryNode;
     taosArrayDestroy(pModifInfo->pDataBlocks);

source/libs/parser/src/parserImpl.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "parserImpl.h"
+
+#include "ttoken.h"
+#include "astCreateContext.h"
+
+typedef void* (*FMalloc)(size_t);
+typedef void (*FFree)(void*);
+
+extern void* NewParseAlloc(FMalloc);
+extern void NewParse(void*, int, SToken, void*);
+extern void NewParseFree(void*, FFree);
+
+uint32_t toNewTokenId(uint32_t tokenId) {
+  switch (tokenId) {
+    case TK_UNION:
+      return NEW_TK_UNION;
+    case TK_ALL:
+      return NEW_TK_ALL;
+    case TK_MINUS:
+      return NEW_TK_NK_MINUS;
+    case TK_PLUS:
+      return NEW_TK_NK_PLUS;
+    case TK_STAR:
+      return NEW_TK_NK_STAR;
+    case TK_SLASH:
+      return NEW_TK_NK_SLASH;
+    case TK_SHOW:
+      return NEW_TK_SHOW;
+    case TK_DATABASES:
+      return NEW_TK_DATABASES;
+    case TK_ID:
+      return NEW_TK_NK_ID;
+    case TK_LP:
+      return NEW_TK_NK_LP;
+    case TK_RP:
+      return NEW_TK_NK_RP;
+    case TK_COMMA:
+      return NEW_TK_NK_COMMA;
+    case TK_DOT:
+      return NEW_TK_NK_DOT;
+    case TK_SELECT:
+      return NEW_TK_SELECT;
+    case TK_DISTINCT:
+      return NEW_TK_DISTINCT;
+    case TK_AS:
+      return NEW_TK_AS;
+    case TK_FROM:
+      return NEW_TK_FROM;
+    case TK_ORDER:
+      return NEW_TK_ORDER;
+    case TK_BY:
+      return NEW_TK_BY;
+    case TK_ASC:
+      return NEW_TK_ASC;
+    case TK_DESC:
+      return NEW_TK_DESC;
+  }
+  return tokenId;
+}
+
+uint32_t getToken(const char* z, uint32_t* tokenId) {
+  uint32_t n = tGetToken(z, tokenId);
+  *tokenId = toNewTokenId(*tokenId);
+  return n;
+}
+
+int32_t doParse(SParseContext* pParseCxt, SQuery* pQuery) {
+  SAstCreateContext cxt = { .pQueryCxt = pParseCxt, .valid = true, .pRootNode = NULL };
+  void *pParser = NewParseAlloc(malloc);
+  int32_t i = 0;
+  while (1) {
+    SToken t0 = {0};
+    printf("===========================\n");
+    if (cxt.pQueryCxt->pSql[i] == 0) {
+      NewParse(pParser, 0, t0, &cxt);
+      goto abort_parse;
+    }
+    printf("input: [%s]\n", cxt.pQueryCxt->pSql + i);
+    t0.n = getToken((char *)&cxt.pQueryCxt->pSql[i], &t0.type);
+    t0.z = (char *)(cxt.pQueryCxt->pSql + i);
+    printf("token %p : %d %d [%s]\n", &t0, t0.type, t0.n, t0.z);
+    i += t0.n;
+
+    switch (t0.type) {
+      case TK_SPACE:
+      case TK_COMMENT: {
+        break;
+      }
+      case TK_SEMI: {
+        NewParse(pParser, 0, t0, &cxt);
+        goto abort_parse;
+      }
+
+      case TK_QUESTION:
+      case TK_ILLEGAL: {
+        snprintf(cxt.pQueryCxt->pMsg, cxt.pQueryCxt->msgLen, "unrecognized token: \"%s\"", t0.z);
+        cxt.valid = false;
+        goto abort_parse;
+      }
+
+      case TK_HEX:
+      case TK_OCT:
+      case TK_BIN: {
+        snprintf(cxt.pQueryCxt->pMsg, cxt.pQueryCxt->msgLen, "unsupported token: \"%s\"", t0.z);
+        cxt.valid = false;
+        goto abort_parse;
+      }
+
+      default:
+        NewParse(pParser, t0.type, t0, &cxt);
+        if (!cxt.valid) {
+          goto abort_parse;
+        }
+    }
+  }
+
+abort_parse:
+  NewParseFree(pParser, free);
+  pQuery->pRoot = cxt.pRootNode;
+  return cxt.valid ? TSDB_CODE_SUCCESS : TSDB_CODE_FAILED;
+}

source/libs/parser/test/CMakeLists.txt

@@ -15,5 +15,5 @@ TARGET_INCLUDE_DIRECTORIES(
 
 TARGET_LINK_LIBRARIES(
         parserTest
-        PUBLIC os util common parser catalog transport gtest function planner qcom
+        PUBLIC os util common nodes parser catalog transport gtest function planner qcom
 )

source/libs/parser/test/newParserTest.cpp

+/*
+ * 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 <gtest/gtest.h>
+
+#include "parserImpl.h"
+
+using namespace std;
+using namespace testing;
+
+class NewParserTest : public Test {
+protected:
+  void setDatabase(const string& acctId, const string& db) {
+    acctId_ = acctId;
+    db_ = db;
+  }
+
+  void bind(const char* sql) {
+    reset();
+    cxt_.acctId = atoi(acctId_.c_str());
+    cxt_.db = (char*) db_.c_str();
+    strcpy(sqlBuf_, sql);
+    cxt_.sqlLen = strlen(sql);
+    sqlBuf_[cxt_.sqlLen] = '\0';
+    cxt_.pSql = sqlBuf_;
+
+  }
+
+  int32_t run() {
+    int32_t code = doParse(&cxt_, &query_);
+    if (code != TSDB_CODE_SUCCESS) {
+      cout << "code:" << tstrerror(code) << ", msg:" << errMagBuf_ << endl;
+      return code;
+    }
+    cout << nodeType(query_.pRoot) << endl;
+    if (NULL != query_.pRoot && QUERY_NODE_SELECT_STMT == nodeType(query_.pRoot)) {
+  // SNode* pWhereCond;
+  // SNodeList* pPartitionByList; // SNode
+  // SNode* pWindowClause;
+  // SNodeList* pGroupByList; // SGroupingSetNode
+  // SNodeList* pOrderByList; // SOrderByExprNode
+  // SLimitNode limit;
+  // SLimitNode slimit;
+
+      SSelectStmt* select = (SSelectStmt*)query_.pRoot;
+      string sql("SELECT ");
+      if (select->isDistinct) {
+        sql.append("DISTINCT ");
+      }
+      if (nullptr == select->pProjectionList) {
+        sql.append("* ");
+      } else {
+        nodeListToSql(select->pProjectionList, sql);
+      }
+      sql.append("FROM ");
+      tableToSql(select->pFromTable, sql);
+      cout << sql << endl;
+    }
+    // char* pStr = NULL;
+    // int32_t len = 0;
+    // code = nodesNodeToString(query_.pRoot, &pStr, &len);
+    // if (code != TSDB_CODE_SUCCESS) {
+    //   cout << "code:" << tstrerror(code) << ", msg:" << errMagBuf_ << endl;
+    //   return code;
+    // }
+    // cout << "node tree:\n" << pStr << endl;
+    return TSDB_CODE_SUCCESS;
+  }
+
+private:
+  static const int max_err_len = 1024;
+  static const int max_sql_len = 1024 * 1024;
+
+  void tableToSql(const SNode* node, string& sql) {
+    const STableNode* table = (const STableNode*)node;
+    cout << "node : " << nodeType(node) << endl;
+    switch (nodeType(node)) {
+      case QUERY_NODE_REAL_TABLE: {
+        SRealTableNode* realTable = (SRealTableNode*)table;
+        if ('\0' != realTable->dbName[0]) {
+          sql.append(realTable->dbName);
+          sql.append(".");
+        }
+        sql.append(realTable->table.tableName);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  void nodeListToSql(const SNodeList* nodelist, string& sql, const string& seq = ",") {
+    SNode* node = nullptr;
+    bool firstNode = true;
+    FOREACH(node, nodelist) {
+      if (!firstNode) {
+        sql.append(", ");
+      }
+      switch (nodeType(node)) {
+        case QUERY_NODE_COLUMN:
+          sql.append(((SColumnNode*)node)->colName);
+          break;
+      }
+    }
+  }
+
+  void reset() {
+    memset(&cxt_, 0, sizeof(cxt_));
+    memset(errMagBuf_, 0, max_err_len);
+    cxt_.pMsg = errMagBuf_;
+    cxt_.msgLen = max_err_len;
+  }
+
+  string acctId_;
+  string db_;
+  char errMagBuf_[max_err_len];
+  char sqlBuf_[max_sql_len];
+  SParseContext cxt_;
+  SQuery query_;
+};
+
+// SELECT * FROM t1
+TEST_F(NewParserTest, selectStar) {
+  setDatabase("root", "test");
+
+  bind("SELECT * FROM t1");
+  ASSERT_EQ(run(), TSDB_CODE_SUCCESS);
+
+  bind("SELECT * FROM test.t1");
+  ASSERT_EQ(run(), TSDB_CODE_SUCCESS);
+}

source/libs/planner/src/logicPlan.c

@@ -74,7 +74,7 @@ int32_t createSelectPlan(const SQueryStmtInfo* pSelect, SQueryPlanNode** pQueryP
 }
 
 int32_t createQueryPlan(const SQueryNode* pNode, SQueryPlanNode** pQueryPlan) {
-  switch (nodeType(pNode)) {
+  switch (queryNodeType(pNode)) {
     case TSDB_SQL_SELECT: {
       return createSelectPlan((const SQueryStmtInfo*)pNode, pQueryPlan);
     }
@@ -395,7 +395,7 @@ SArray* createQueryPlanImpl(const SQueryStmtInfo* pQueryInfo) {
 }
 
 static void doDestroyQueryNode(SQueryPlanNode* pQueryNode) {
-  int32_t type = nodeType(pQueryNode);
+  int32_t type = queryNodeType(pQueryNode);
   if (type == QNODE_MODIFY) {
     SDataPayloadInfo* pInfo = pQueryNode->pExtInfo;
 

source/libs/planner/src/physicalPlan.c

@@ -461,7 +461,7 @@ static void destroyDataSinkNode(SDataSink* pSinkNode) {
     return;
   }
 
-  if (nodeType(pSinkNode) == DSINK_Dispatch) {
+  if (queryNodeType(pSinkNode) == DSINK_Dispatch) {
     SDataDispatcher* pDdSink = (SDataDispatcher*)pSinkNode;
     tfree(pDdSink->sink.schema.pSchema);
   }

source/nodes/src/nodesClone.c → source/nodes/src/nodesCloneFuncs.c

@@ -15,6 +15,6 @@
 
 #include "nodes.h"
 
-void cloneNode(const SNode* pNode) {
+void nodesCloneNode(const SNode* pNode) {
 
 }

source/nodes/src/nodesCodeFuncs.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "nodes.h"
+
+int32_t nodesNodeToString(const SNode* pNode, char** pStr, int32_t* pLen) {
+  switch (nodeType(pNode)) {
+    case QUERY_NODE_COLUMN:
+    case QUERY_NODE_VALUE:
+    case QUERY_NODE_OPERATOR:
+    case QUERY_NODE_LOGIC_CONDITION:
+    case QUERY_NODE_IS_NULL_CONDITION:
+    case QUERY_NODE_FUNCTION:
+    case QUERY_NODE_REAL_TABLE:
+    case QUERY_NODE_TEMP_TABLE:
+    case QUERY_NODE_JOIN_TABLE:
+    case QUERY_NODE_GROUPING_SET:
+    case QUERY_NODE_ORDER_BY_EXPR:
+    case QUERY_NODE_LIMIT:
+    case QUERY_NODE_STATE_WINDOW:
+    case QUERY_NODE_SESSION_WINDOW:
+    case QUERY_NODE_INTERVAL_WINDOW:
+    case QUERY_NODE_SET_OPERATOR:
+    case QUERY_NODE_SELECT_STMT:
+    case QUERY_NODE_SHOW_STMT:
+    default:
+      break;
+  }
+}
+
+int32_t nodesStringToNode(const char* pStr, SNode** pNode) {
+
+}

source/nodes/src/nodesEqual.c → source/nodes/src/nodesEqualFuncs.c

@@ -32,17 +32,17 @@
 
 #define COMPARE_NODE_FIELD(fldname) \
 	do { \
-		if (!nodeEqual(a->fldname, b->fldname)) \
+		if (!nodesEqualNode(a->fldname, b->fldname)) \
 			return false; \
 	} while (0)
 
-#define COMPARE_ARRAY_FIELD(fldname) \
+#define COMPARE_NODE_LIST_FIELD(fldname) \
 	do { \
-		if (!nodeArrayEqual(a->fldname, b->fldname)) \
+		if (!nodeNodeListEqual(a->fldname, b->fldname)) \
 			return false; \
 	} while (0)
 
-static bool nodeArrayEqual(const SArray* a, const SArray* b) {
+static bool nodeNodeListEqual(const SNodeList* a, const SNodeList* b) {
   if (a == b) {
     return true;
   }
@@ -51,13 +51,13 @@ static bool nodeArrayEqual(const SArray* a, const SArray* b) {
     return false;
   }
 
-  if (taosArrayGetSize(a) != taosArrayGetSize(b)) {
+  if (LIST_LENGTH(a) != LIST_LENGTH(b)) {
     return false;
   }
 
-  size_t size = taosArrayGetSize(a);
-  for (size_t i = 0; i < size; ++i) {
-    if (!nodeEqual((SNode*)taosArrayGetP(a, i), (SNode*)taosArrayGetP(b, i))) {
+  SNode* na, *nb;
+  FORBOTH(na, a, nb, b) {
+    if (!nodesEqualNode(na, nb)) {
       return false;
     }
   }
@@ -85,7 +85,7 @@ static bool operatorNodeEqual(const SOperatorNode* a, const SOperatorNode* b) {
 
 static bool logicConditionNodeEqual(const SLogicConditionNode* a, const SLogicConditionNode* b) {
   COMPARE_SCALAR_FIELD(condType);
-  COMPARE_ARRAY_FIELD(pParameterList);
+  COMPARE_NODE_LIST_FIELD(pParameterList);
   return true;
 }
 
@@ -97,11 +97,11 @@ static bool isNullConditionNodeEqual(const SIsNullCondNode* a, const SIsNullCond
 
 static bool functionNodeEqual(const SFunctionNode* a, const SFunctionNode* b) {
   COMPARE_SCALAR_FIELD(funcId);
-  COMPARE_ARRAY_FIELD(pParameterList);
+  COMPARE_NODE_LIST_FIELD(pParameterList);
   return true;
 }
 
-bool nodeEqual(const SNode* a, const SNode* b) {
+bool nodesEqualNode(const SNode* a, const SNode* b) {
   if (a == b) {
     return true;
   }
@@ -132,6 +132,7 @@ bool nodeEqual(const SNode* a, const SNode* b) {
     case QUERY_NODE_JOIN_TABLE:
     case QUERY_NODE_GROUPING_SET:
     case QUERY_NODE_ORDER_BY_EXPR:
+    case QUERY_NODE_LIMIT:
       return false; // todo
     default:
       break;

source/nodes/src/nodesTraverse.c → source/nodes/src/nodesTraverseFuncs.c

@@ -17,17 +17,17 @@
 
 typedef bool (*FQueryNodeWalker)(SNode* pNode, void* pContext);
 
-bool nodeArrayWalker(SArray* pArray, FQueryNodeWalker walker, void* pContext) {
-    size_t size = taosArrayGetSize(pArray);
-    for (size_t i = 0; i < size; ++i) {
-      if (!nodeTreeWalker((SNode*)taosArrayGetP(pArray, i), walker, pContext)) {
-        return false;
-      }
+bool nodesWalkNodeList(SNodeList* pNodeList, FQueryNodeWalker walker, void* pContext) {
+  SNode* node;
+  FOREACH(node, pNodeList) {
+    if (!nodesWalkNode(node, walker, pContext)) {
+      return false;
     }
-    return true;
+  }
+  return true;
 }
 
-bool nodeTreeWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
+bool nodesWalkNode(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
   if (NULL == pNode) {
     return true;
   }
@@ -39,38 +39,39 @@ bool nodeTreeWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
   switch (nodeType(pNode)) {
     case QUERY_NODE_COLUMN:
     case QUERY_NODE_VALUE:
+    case QUERY_NODE_LIMIT:
       // these node types with no subnodes
       return true;
     case QUERY_NODE_OPERATOR: {
       SOperatorNode* pOpNode = (SOperatorNode*)pNode;
-      if (!nodeTreeWalker(pOpNode->pLeft, walker, pContext)) {
+      if (!nodesWalkNode(pOpNode->pLeft, walker, pContext)) {
         return false;
       }
-      return nodeTreeWalker(pOpNode->pRight, walker, pContext);
+      return nodesWalkNode(pOpNode->pRight, walker, pContext);
     }
     case QUERY_NODE_LOGIC_CONDITION:
-      return nodeArrayWalker(((SLogicConditionNode*)pNode)->pParameterList, walker, pContext);
+      return nodesWalkNodeList(((SLogicConditionNode*)pNode)->pParameterList, walker, pContext);
     case QUERY_NODE_IS_NULL_CONDITION:
-      return nodeTreeWalker(((SIsNullCondNode*)pNode)->pExpr, walker, pContext);
+      return nodesWalkNode(((SIsNullCondNode*)pNode)->pExpr, walker, pContext);
     case QUERY_NODE_FUNCTION:
-      return nodeArrayWalker(((SFunctionNode*)pNode)->pParameterList, walker, pContext);
+      return nodesWalkNodeList(((SFunctionNode*)pNode)->pParameterList, walker, pContext);
     case QUERY_NODE_REAL_TABLE:
     case QUERY_NODE_TEMP_TABLE:
       return true; // todo
     case QUERY_NODE_JOIN_TABLE: {
       SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
-      if (!nodeTreeWalker(pJoinTableNode->pLeft, walker, pContext)) {
+      if (!nodesWalkNode(pJoinTableNode->pLeft, walker, pContext)) {
         return false;
       }
-      if (!nodeTreeWalker(pJoinTableNode->pRight, walker, pContext)) {
+      if (!nodesWalkNode(pJoinTableNode->pRight, walker, pContext)) {
         return false;
       }
-      return nodeTreeWalker(pJoinTableNode->pOnCond, walker, pContext);
+      return nodesWalkNode(pJoinTableNode->pOnCond, walker, pContext);
     }
     case QUERY_NODE_GROUPING_SET:
-      return nodeArrayWalker(((SGroupingSetNode*)pNode)->pParameterList, walker, pContext);
+      return nodesWalkNodeList(((SGroupingSetNode*)pNode)->pParameterList, walker, pContext);
     case QUERY_NODE_ORDER_BY_EXPR:
-      return nodeTreeWalker(((SOrderByExprNode*)pNode)->pExpr, walker, pContext);
+      return nodesWalkNode(((SOrderByExprNode*)pNode)->pExpr, walker, pContext);
     default:
       break;
   }
@@ -78,6 +79,6 @@ bool nodeTreeWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
   return false;
 }
 
-bool stmtWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
+bool nodesWalkStmt(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
 
 }

source/nodes/src/nodesUtilFuncs.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "nodes.h"
+#include "nodesShowStmts.h"
+
+bool nodesIsTimeorderQuery(const SNode* pQuery) {
+
+}
+
+bool nodesIsTimelineQuery(const SNode* pQuery) {
+
+}
+
+static SNode* makeNode(ENodeType type, size_t size) {
+  SNode* p = calloc(1, size);
+  setNodeType(p, type);
+  return p;
+}
+
+SNode* nodesMakeNode(ENodeType type) {
+  switch (type) {
+    case QUERY_NODE_COLUMN:
+      return makeNode(type, sizeof(SColumnNode));
+    case QUERY_NODE_VALUE:
+      return makeNode(type, sizeof(SValueNode));
+    case QUERY_NODE_OPERATOR:
+      return makeNode(type, sizeof(SOperatorNode));
+    case QUERY_NODE_LOGIC_CONDITION:
+      return makeNode(type, sizeof(SLogicConditionNode));
+    case QUERY_NODE_IS_NULL_CONDITION:
+      return makeNode(type, sizeof(SIsNullCondNode));
+    case QUERY_NODE_FUNCTION:
+      return makeNode(type, sizeof(SFunctionNode));
+    case QUERY_NODE_REAL_TABLE:
+      return makeNode(type, sizeof(SRealTableNode));
+    case QUERY_NODE_TEMP_TABLE:
+      return makeNode(type, sizeof(STempTableNode));
+    case QUERY_NODE_JOIN_TABLE:
+      return makeNode(type, sizeof(SJoinTableNode));
+    case QUERY_NODE_GROUPING_SET:
+      return makeNode(type, sizeof(SGroupingSetNode));
+    case QUERY_NODE_ORDER_BY_EXPR:
+      return makeNode(type, sizeof(SOrderByExprNode));
+    case QUERY_NODE_LIMIT:
+      return makeNode(type, sizeof(SLimitNode));
+    case QUERY_NODE_STATE_WINDOW:
+      return makeNode(type, sizeof(SStateWindowNode));
+    case QUERY_NODE_SESSION_WINDOW:
+      return makeNode(type, sizeof(SSessionWindowNode));
+    case QUERY_NODE_INTERVAL_WINDOW:
+      return makeNode(type, sizeof(SIntervalWindowNode));
+    case QUERY_NODE_SET_OPERATOR:
+      return makeNode(type, sizeof(SSetOperator));
+    case QUERY_NODE_SELECT_STMT:
+      return makeNode(type, sizeof(SSelectStmt));
+    case QUERY_NODE_SHOW_STMT:
+      return makeNode(type, sizeof(SShowStmt));
+    default:
+      break;
+  }
+  return NULL;
+}
+
+void nodesDestroyNode(SNode* pNode) {
+
+}
+
+void nodesDestroyNodeList(SNodeList* pList) {
+
+}