test coverage for planner/nodes

source/libs/nodes/test/nodesTestMain.cpp

@@ -128,6 +128,86 @@ TEST(NodesTest, sort) {
   nodesDestroyList(l);
 }
 
+TEST(NodesTest, match) {
+  SNode* pOperator = NULL;
+  int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOperator);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  SOperatorNode* pOp = (SOperatorNode*)pOperator;
+  SOperatorNode* pLeft = NULL;
+  ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pLeft));
+  ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, &pLeft->pLeft));
+  ((SValueNode*)(pLeft->pLeft))->literal = taosStrdup("10");
+  ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, &pLeft->pRight));
+  ((SValueNode*)(pLeft->pRight))->literal = taosStrdup("5");
+  pOp->pLeft = (SNode*)pLeft;
+  ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, &pOp->pRight));
+  ((SValueNode*)(pOp->pRight))->literal = taosStrdup("3");
+  pOp->opType = OP_TYPE_GREATER_THAN;
+
+  SNode* pOperatorClone = NULL;
+  code = nodesCloneNode(pOperator, &pOperatorClone);
+  ASSERT_TRUE(nodesMatchNode(pOperator, pOperatorClone));
+
+  SNode* pValue = NULL;
+  code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValue);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  ((SValueNode*)pValue)->literal = taosStrdup("10");
+  ASSERT_FALSE(nodesMatchNode(pOperator, pValue));
+
+  SNode* pValueClone = NULL;
+  code = nodesCloneNode(pValue, &pValueClone);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  ASSERT_TRUE(nodesMatchNode(pValue, pValueClone));
+  nodesDestroyNode(pValue);
+  nodesDestroyNode(pValueClone);
+
+  SNode* pColumn = NULL, *pColumnClone = NULL;
+  code = nodesMakeNode(QUERY_NODE_COLUMN, &pColumn);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  strcpy(((SColumnNode*)pColumn)->colName, "column");
+  strcpy(((SColumnNode*)pColumn)->tableName, "table");
+  strcpy(((SColumnNode*)pColumn)->dbName, "db");
+  strcpy(((SColumnNode*)pColumn)->node.aliasName, "column");
+  ASSERT_FALSE(nodesMatchNode(pOperator, pColumn));
+  code = nodesCloneNode(pColumn, &pColumnClone);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  ASSERT_TRUE(nodesMatchNode(pColumn, pColumnClone));
+  nodesDestroyNode(pColumn);
+  nodesDestroyNode(pColumnClone);
+
+  SNode* pFunction = NULL, *pFunctionClone = NULL;
+  code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunction);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  ((SFunctionNode*)pFunction)->funcId = 1;
+  strcpy(((SFunctionNode*)pFunction)->functionName, "now");
+  ASSERT_FALSE(nodesMatchNode(pOperator, pFunction));
+  code = nodesCloneNode(pFunction, &pFunctionClone);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  ASSERT_TRUE(nodesMatchNode(pFunction, pFunctionClone));
+  nodesDestroyNode(pFunctionClone);
+  nodesDestroyNode(pFunction);
+
+  SNode* pLogicCondition = NULL, *pLogicConditionClone = NULL;
+  code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCondition);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  ((SLogicConditionNode*)pLogicCondition)->condType = LOGIC_COND_TYPE_AND;
+  ((SLogicConditionNode*)pLogicCondition)->pParameterList = NULL;
+  code = nodesMakeList(&((SLogicConditionNode*)pLogicCondition)->pParameterList);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  code = nodesListAppend((SNodeList*)((SLogicConditionNode*)pLogicCondition)->pParameterList, pOperator);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  code = nodesListAppend(((SLogicConditionNode*)pLogicCondition)->pParameterList, pOperatorClone);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+
+  code = nodesCloneNode(pLogicCondition, &pLogicConditionClone);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  ASSERT_TRUE(nodesMatchNode(pLogicCondition, pLogicConditionClone));
+  ASSERT_FALSE(nodesMatchNode(pLogicCondition, pFunctionClone));
+  
+  nodesDestroyNode(pLogicCondition);
+  nodesDestroyNode(pLogicConditionClone);
+}
+
 int main(int argc, char* argv[]) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();

source/libs/planner/src/planValidator.c

@@ -55,16 +55,10 @@ int32_t validateQueryPlanNode(SValidatePlanContext* pCxt, SQueryPlan* pPlan) {
     SNode* pSubNode = NULL;
     SNodeListNode* pSubplans = (SNodeListNode*)pNode;
     FOREACH(pSubNode, pSubplans->pNodeList) {
-      if (QUERY_NODE_PHYSICAL_SUBPLAN != nodeType(pNode)) {
-        code = TSDB_CODE_PLAN_INTERNAL_ERROR;
-        break;
-      }
-      
       code = doValidatePhysiNode(pCxt, pSubNode);
-      if (code) {
+      if (code) break;
-        break;
-      }
     }
+    if (code) break;
   }
 
   return code;
@@ -142,24 +136,7 @@ int32_t validateQueryPlan(SPlanContext* pCxt, SQueryPlan* pPlan) {
 
   int32_t code = TSDB_CODE_SUCCESS;
   SNode* pNode = NULL;
-  FOREACH(pNode, pPlan->pSubplans) {
+  code = validateQueryPlanNode(&cxt, pPlan);
-    if (QUERY_NODE_NODE_LIST != nodeType(pNode)) {
-      code = TSDB_CODE_PLAN_INTERNAL_ERROR;
-      break;
-    }
-
-    SNode* pSubNode = NULL;
-    SNodeListNode* pSubplans = (SNodeListNode*)pNode;
-    FOREACH(pSubNode, pSubplans->pNodeList) {
-      code = doValidatePhysiNode(&cxt, pSubNode);
-      if (code) {
-        break;
-      }
-    }
-    if (code) {
-      break;
-    }
-  }
 
   destoryValidatePlanContext(&cxt);
   return code;

tests/system-test/2-query/union.py

@@ -406,6 +406,14 @@ class TDTestCase:
         tdSql.checkRows(6)
         ##tdSql.execute("drop database ep_iot")
 
+    def test_case_for_nodes_match_node(self):
+        sql = "create table nt (ts timestamp, c1 int primary key, c2 int)"
+        tdSql.execute(sql, queryTimes=1)
+        sql = 'select diff (ts) from (select * from tt union select * from tt order by c1, case when ts < now - 1h then ts + 1h else ts end) partition by c1, case when ts < now - 1h then ts + 1h else ts end'
+        tdSql.error(sql, -2147473917)
+
+        pass
+
     def run(self):
         tdSql.prepare()
         self.test_TS_5630()
@@ -427,6 +435,7 @@ class TDTestCase:
         tdLog.printNoPrefix("==========step4:after wal, all check again ")
         self.all_test()
         self.test_TD_33137()
+        self.test_case_for_nodes_match_node()
     
     def test_TD_33137(self):
         sql = "select 'asd' union all select 'asdasd'"