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

fix: some problems of planner

include/libs/nodes/querynodes.h

@@ -418,8 +418,6 @@ void    nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
 
 char*   nodesGetFillModeString(EFillMode mode);
 int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc);
-int32_t nodesPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagIndexCond, SNode** pTagCond,
-                           SNode** pOtherCond);
 
 #ifdef __cplusplus
 }

include/libs/scalar/filter.h

@@ -46,6 +46,10 @@ extern int32_t filterFreeNcharColumns(SFilterInfo *pFilterInfo);
 extern void    filterFreeInfo(SFilterInfo *info);
 extern bool    filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32_t numOfCols, int32_t numOfRows);
 
+/* condition split interface */
+int32_t filterPartitionCond(SNode **pCondition, SNode **pPrimaryKeyCond, SNode **pTagIndexCond, SNode **pTagCond,
+                            SNode **pOtherCond);
+
 #ifdef __cplusplus
 }
 #endif

include/libs/scalar/scalar.h

@@ -25,7 +25,7 @@ extern "C" {
 
 typedef struct SFilterInfo SFilterInfo;
 
-int32_t scalarGetOperatorResultType(SOperatorNode* pOp);
+int32_t scalarGetOperatorResultType(SOperatorNode *pOp);
 
 /*
 pNode will be freed in API;
@@ -43,7 +43,7 @@ int32_t scalarGetOperatorParamNum(EOperatorType type);
 int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type);
 
 int32_t vectorGetConvertType(int32_t type1, int32_t type2);
-int32_t vectorConvertImpl(const SScalarParam* pIn, SScalarParam* pOut, int32_t* overflow);
+int32_t vectorConvertImpl(const SScalarParam *pIn, SScalarParam *pOut, int32_t *overflow);
 
 /* Math functions */
 int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
@@ -86,7 +86,7 @@ int32_t nowFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu
 int32_t todayFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t timezoneFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
-bool getTimePseudoFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
+bool getTimePseudoFuncEnv(struct SFunctionNode *pFunc, SFuncExecEnv *pEnv);
 
 int32_t winStartTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t winEndTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);

source/libs/nodes/src/nodesCodeFuncs.c

@@ -2684,6 +2684,7 @@ static int32_t jsonToDataType(const SJson* pJson, void* pObj) {
 
 static const char* jkExprDataType = "DataType";
 static const char* jkExprAliasName = "AliasName";
+static const char* jkExprUserAlias = "UserAlias";
 
 static int32_t exprNodeToJson(const void* pObj, SJson* pJson) {
   const SExprNode* pNode = (const SExprNode*)pObj;
@@ -2692,6 +2693,9 @@ static int32_t exprNodeToJson(const void* pObj, SJson* pJson) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonAddStringToObject(pJson, jkExprAliasName, pNode->aliasName);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddStringToObject(pJson, jkExprUserAlias, pNode->userAlias);
+  }
 
   return code;
 }
@@ -2703,6 +2707,9 @@ static int32_t jsonToExprNode(const SJson* pJson, void* pObj) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonGetStringValue(pJson, jkExprAliasName, pNode->aliasName);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetStringValue(pJson, jkExprUserAlias, pNode->userAlias);
+  }
 
   return code;
 }

source/libs/nodes/src/nodesUtilFuncs.c

@@ -1502,7 +1502,7 @@ static EDealRes collectColumns(SNode* pNode, void* pContext) {
   SCollectColumnsCxt* pCxt = (SCollectColumnsCxt*)pContext;
   if (QUERY_NODE_COLUMN == nodeType(pNode)) {
     SColumnNode* pCol = (SColumnNode*)pNode;
-    if (isCollectType(pCxt->collectType, pCol->colType) &&
+    if (isCollectType(pCxt->collectType, pCol->colType) && 0 != strcmp(pCol->colName, "*") &&
         (NULL == pCxt->pTableAlias || 0 == strcmp(pCxt->pTableAlias, pCol->tableAlias))) {
       return doCollect(pCxt, pCol, pNode);
     }
@@ -1816,187 +1816,3 @@ int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc) {
 
   return TSDB_CODE_SUCCESS;
 }
-
-typedef struct SClassifyConditionCxt {
-  bool hasPrimaryKey;
-  bool hasTagIndexCol;
-  bool hasTagCol;
-  bool hasOtherCol;
-} SClassifyConditionCxt;
-
-static EDealRes classifyConditionImpl(SNode* pNode, void* pContext) {
-  SClassifyConditionCxt* pCxt = (SClassifyConditionCxt*)pContext;
-  if (QUERY_NODE_COLUMN == nodeType(pNode)) {
-    SColumnNode* pCol = (SColumnNode*)pNode;
-    if (PRIMARYKEY_TIMESTAMP_COL_ID == pCol->colId && TSDB_SYSTEM_TABLE != pCol->tableType) {
-      pCxt->hasPrimaryKey = true;
-    } else if (pCol->hasIndex) {
-      pCxt->hasTagIndexCol = true;
-      pCxt->hasTagCol = true;
-    } else if (COLUMN_TYPE_TAG == pCol->colType || COLUMN_TYPE_TBNAME == pCol->colType) {
-      pCxt->hasTagCol = true;
-    } else {
-      pCxt->hasOtherCol = true;
-    }
-  }
-  return DEAL_RES_CONTINUE;
-}
-
-typedef enum EConditionType {
-  COND_TYPE_PRIMARY_KEY = 1,
-  COND_TYPE_TAG_INDEX,
-  COND_TYPE_TAG,
-  COND_TYPE_NORMAL
-} EConditionType;
-
-static EConditionType classifyCondition(SNode* pNode) {
-  SClassifyConditionCxt cxt = {.hasPrimaryKey = false, .hasTagIndexCol = false, .hasOtherCol = false};
-  nodesWalkExpr(pNode, classifyConditionImpl, &cxt);
-  return cxt.hasOtherCol ? COND_TYPE_NORMAL
-                         : (cxt.hasPrimaryKey && cxt.hasTagCol
-                                ? COND_TYPE_NORMAL
-                                : (cxt.hasPrimaryKey ? COND_TYPE_PRIMARY_KEY
-                                                     : (cxt.hasTagIndexCol ? COND_TYPE_TAG_INDEX : COND_TYPE_TAG)));
-}
-
-static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagIndexCond, SNode** pTagCond,
-                                  SNode** pOtherCond) {
-  SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(*pCondition);
-
-  int32_t code = TSDB_CODE_SUCCESS;
-
-  SNodeList* pPrimaryKeyConds = NULL;
-  SNodeList* pTagIndexConds = NULL;
-  SNodeList* pTagConds = NULL;
-  SNodeList* pOtherConds = NULL;
-  SNode*     pCond = NULL;
-  FOREACH(pCond, pLogicCond->pParameterList) {
-    switch (classifyCondition(pCond)) {
-      case COND_TYPE_PRIMARY_KEY:
-        if (NULL != pPrimaryKeyCond) {
-          code = nodesListMakeAppend(&pPrimaryKeyConds, nodesCloneNode(pCond));
-        }
-        break;
-      case COND_TYPE_TAG_INDEX:
-        if (NULL != pTagIndexCond) {
-          code = nodesListMakeAppend(&pTagIndexConds, nodesCloneNode(pCond));
-        }
-        if (NULL != pTagCond) {
-          code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
-        }
-        break;
-      case COND_TYPE_TAG:
-        if (NULL != pTagCond) {
-          code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
-        }
-        break;
-      case COND_TYPE_NORMAL:
-      default:
-        if (NULL != pOtherCond) {
-          code = nodesListMakeAppend(&pOtherConds, nodesCloneNode(pCond));
-        }
-        break;
-    }
-    if (TSDB_CODE_SUCCESS != code) {
-      break;
-    }
-  }
-
-  SNode* pTempPrimaryKeyCond = NULL;
-  SNode* pTempTagIndexCond = NULL;
-  SNode* pTempTagCond = NULL;
-  SNode* pTempOtherCond = NULL;
-  if (TSDB_CODE_SUCCESS == code) {
-    code = nodesMergeConds(&pTempPrimaryKeyCond, &pPrimaryKeyConds);
-  }
-  if (TSDB_CODE_SUCCESS == code) {
-    code = nodesMergeConds(&pTempTagIndexCond, &pTagIndexConds);
-  }
-  if (TSDB_CODE_SUCCESS == code) {
-    code = nodesMergeConds(&pTempTagCond, &pTagConds);
-  }
-  if (TSDB_CODE_SUCCESS == code) {
-    code = nodesMergeConds(&pTempOtherCond, &pOtherConds);
-  }
-
-  if (TSDB_CODE_SUCCESS == code) {
-    if (NULL != pPrimaryKeyCond) {
-      *pPrimaryKeyCond = pTempPrimaryKeyCond;
-    }
-    if (NULL != pTagIndexCond) {
-      *pTagIndexCond = pTempTagIndexCond;
-    }
-    if (NULL != pTagCond) {
-      *pTagCond = pTempTagCond;
-    }
-    if (NULL != pOtherCond) {
-      *pOtherCond = pTempOtherCond;
-    }
-    nodesDestroyNode(*pCondition);
-    *pCondition = NULL;
-  } else {
-    nodesDestroyList(pPrimaryKeyConds);
-    nodesDestroyList(pTagIndexConds);
-    nodesDestroyList(pTagConds);
-    nodesDestroyList(pOtherConds);
-    nodesDestroyNode(pTempPrimaryKeyCond);
-    nodesDestroyNode(pTempTagIndexCond);
-    nodesDestroyNode(pTempTagCond);
-    nodesDestroyNode(pTempOtherCond);
-  }
-
-  return code;
-}
-
-int32_t nodesPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagIndexCond, SNode** pTagCond,
-                           SNode** pOtherCond) {
-  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*pCondition) &&
-      LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)*pCondition)->condType) {
-    return partitionLogicCond(pCondition, pPrimaryKeyCond, pTagIndexCond, pTagCond, pOtherCond);
-  }
-
-  bool needOutput = false;
-  switch (classifyCondition(*pCondition)) {
-    case COND_TYPE_PRIMARY_KEY:
-      if (NULL != pPrimaryKeyCond) {
-        *pPrimaryKeyCond = *pCondition;
-        needOutput = true;
-      }
-      break;
-    case COND_TYPE_TAG_INDEX:
-      if (NULL != pTagIndexCond) {
-        *pTagIndexCond = *pCondition;
-        needOutput = true;
-      }
-      if (NULL != pTagCond) {
-        SNode* pTempCond = *pCondition;
-        if (NULL != pTagIndexCond) {
-          pTempCond = nodesCloneNode(*pCondition);
-          if (NULL == pTempCond) {
-            return TSDB_CODE_OUT_OF_MEMORY;
-          }
-        }
-        *pTagCond = pTempCond;
-        needOutput = true;
-      }
-      break;
-    case COND_TYPE_TAG:
-      if (NULL != pTagCond) {
-        *pTagCond = *pCondition;
-        needOutput = true;
-      }
-      break;
-    case COND_TYPE_NORMAL:
-    default:
-      if (NULL != pOtherCond) {
-        *pOtherCond = *pCondition;
-        needOutput = true;
-      }
-      break;
-  }
-  if (needOutput) {
-    *pCondition = NULL;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}

source/libs/parser/src/parAstCreater.c

@@ -233,18 +233,22 @@ SNode* createRawExprNodeExt(SAstCreateContext* pCxt, const SToken* pStart, const
 SNode* releaseRawExprNode(SAstCreateContext* pCxt, SNode* pNode) {
   CHECK_PARSER_STATUS(pCxt);
   SRawExprNode* pRawExpr = (SRawExprNode*)pNode;
-  SNode*        pExpr = pRawExpr->pNode;
-  if (nodesIsExprNode(pExpr)) {
+  SNode*        pRealizedExpr = pRawExpr->pNode;
+  if (nodesIsExprNode(pRealizedExpr)) {
+    SExprNode* pExpr = (SExprNode*)pRealizedExpr;
     if (QUERY_NODE_COLUMN == nodeType(pExpr)) {
-      strcpy(((SExprNode*)pExpr)->aliasName, ((SColumnNode*)pExpr)->colName);
+      strcpy(pExpr->aliasName, ((SColumnNode*)pExpr)->colName);
+      strcpy(pExpr->userAlias, ((SColumnNode*)pExpr)->colName);
     } else {
-      int32_t len = TMIN(sizeof(((SExprNode*)pExpr)->aliasName) - 1, pRawExpr->n);
-      strncpy(((SExprNode*)pExpr)->aliasName, pRawExpr->p, len);
-      ((SExprNode*)pExpr)->aliasName[len] = '\0';
+      int32_t len = TMIN(sizeof(pExpr->aliasName) - 1, pRawExpr->n);
+      strncpy(pExpr->aliasName, pRawExpr->p, len);
+      pExpr->aliasName[len] = '\0';
+      strncpy(pExpr->userAlias, pRawExpr->p, len);
+      pExpr->userAlias[len] = '\0';
     }
   }
   taosMemoryFreeClear(pNode);
-  return pExpr;
+  return pRealizedExpr;
 }
 
 SToken getTokenFromRawExprNode(SAstCreateContext* pCxt, SNode* pNode) {
@@ -641,11 +645,12 @@ SNode* createInterpTimeRange(SAstCreateContext* pCxt, SNode* pStart, SNode* pEnd
 SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, SToken* pAlias) {
   CHECK_PARSER_STATUS(pCxt);
   trimEscape(pAlias);
-  int32_t len = TMIN(sizeof(((SExprNode*)pNode)->aliasName) - 1, pAlias->n);
-  strncpy(((SExprNode*)pNode)->aliasName, pAlias->z, len);
-  ((SExprNode*)pNode)->aliasName[len] = '\0';
-  strncpy(((SExprNode*)pNode)->userAlias, pAlias->z, len);
-  ((SExprNode*)pNode)->userAlias[len] = '\0';
+  SExprNode* pExpr = (SExprNode*)pNode;
+  int32_t    len = TMIN(sizeof(pExpr->aliasName) - 1, pAlias->n);
+  strncpy(pExpr->aliasName, pAlias->z, len);
+  pExpr->aliasName[len] = '\0';
+  strncpy(pExpr->userAlias, pAlias->z, len);
+  pExpr->userAlias[len] = '\0';
   return pNode;
 }
 
@@ -766,13 +771,21 @@ SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pPr
   return (SNode*)select;
 }
 
+static void setSubquery(SNode* pStmt) {
+  if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
+    ((SSelectStmt*)pStmt)->isSubquery = true;
+  }
+}
+
 SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight) {
   CHECK_PARSER_STATUS(pCxt);
   SSetOperator* setOp = (SSetOperator*)nodesMakeNode(QUERY_NODE_SET_OPERATOR);
   CHECK_OUT_OF_MEM(setOp);
   setOp->opType = type;
   setOp->pLeft = pLeft;
+  setSubquery(setOp->pLeft);
   setOp->pRight = pRight;
+  setSubquery(setOp->pRight);
   sprintf(setOp->stmtName, "%p", setOp);
   return (SNode*)setOp;
 }

source/libs/parser/src/parTranslater.c

@@ -523,6 +523,9 @@ static void setColumnInfoBySchema(const SRealTableNode* pTable, const SSchema* p
   if ('\0' == pCol->node.aliasName[0]) {
     strcpy(pCol->node.aliasName, pColSchema->name);
   }
+  if ('\0' == pCol->node.userAlias[0]) {
+    strcpy(pCol->node.userAlias, pColSchema->name);
+  }
   pCol->tableId = pTable->pMeta->uid;
   pCol->tableType = pTable->pMeta->tableType;
   pCol->colId = pColSchema->colId;
@@ -549,6 +552,9 @@ static void setColumnInfoByExpr(STempTableNode* pTable, SExprNode* pExpr, SColum
   if ('\0' == pCol->node.aliasName[0]) {
     strcpy(pCol->node.aliasName, pCol->colName);
   }
+  if ('\0' == pCol->node.userAlias[0]) {
+    strcpy(pCol->node.userAlias, pCol->colName);
+  }
   pCol->node.resType = pExpr->resType;
 }
 
@@ -691,7 +697,7 @@ static EDealRes translateColumnUseAlias(STranslateContext* pCxt, SColumnNode** p
   SNode*     pNode;
   FOREACH(pNode, pProjectionList) {
     SExprNode* pExpr = (SExprNode*)pNode;
-    if (0 == strcmp((*pCol)->colName, pExpr->aliasName)) {
+    if (0 == strcmp((*pCol)->colName, pExpr->userAlias)) {
       SColumnRefNode* pColRef = (SColumnRefNode*)nodesMakeNode(QUERY_NODE_COLUMN_REF);
       if (NULL == pColRef) {
         pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
@@ -1535,6 +1541,7 @@ static EDealRes rewriteColToSelectValFunc(STranslateContext* pCxt, SNode** pNode
   }
   strcpy(pFunc->functionName, "_select_value");
   strcpy(pFunc->node.aliasName, ((SExprNode*)*pNode)->aliasName);
+  strcpy(pFunc->node.userAlias, ((SExprNode*)*pNode)->userAlias);
   pCxt->errCode = nodesListMakeAppend(&pFunc->pParameterList, *pNode);
   if (TSDB_CODE_SUCCESS == pCxt->errCode) {
     pCxt->errCode = getFuncInfo(pCxt, pFunc);
@@ -2171,12 +2178,51 @@ static int32_t translateFillValues(STranslateContext* pCxt, SSelectStmt* pSelect
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t rewriteProjectAlias(SNodeList* pProjectionList) {
+  int32_t no = 1;
+  SNode*  pProject = NULL;
+  FOREACH(pProject, pProjectionList) {
+    SExprNode* pExpr = (SExprNode*)pProject;
+    if ('\0' == pExpr->userAlias[0]) {
+      strcpy(pExpr->userAlias, pExpr->aliasName);
+    }
+    sprintf(pExpr->aliasName, "#expr_%d", no++);
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t checkProjectAlias(STranslateContext* pCxt, SNodeList* pProjectionList) {
+  SHashObj* pUserAliasSet = taosHashInit(LIST_LENGTH(pProjectionList),
+                                         taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+  SNode*    pProject = NULL;
+  FOREACH(pProject, pProjectionList) {
+    SExprNode* pExpr = (SExprNode*)pProject;
+    if (NULL != taosHashGet(pUserAliasSet, pExpr->userAlias, strlen(pExpr->userAlias))) {
+      taosHashCleanup(pUserAliasSet);
+      return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_AMBIGUOUS_COLUMN, pExpr->userAlias);
+    }
+    taosHashPut(pUserAliasSet, pExpr->userAlias, strlen(pExpr->userAlias), &pExpr, POINTER_BYTES);
+  }
+  taosHashCleanup(pUserAliasSet);
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t translateProjectionList(STranslateContext* pCxt, SSelectStmt* pSelect) {
+  if (pSelect->isSubquery) {
+    return checkProjectAlias(pCxt, pSelect->pProjectionList);
+  }
+  return rewriteProjectAlias(pSelect->pProjectionList);
+}
+
 static int32_t translateSelectList(STranslateContext* pCxt, SSelectStmt* pSelect) {
   pCxt->currClause = SQL_CLAUSE_SELECT;
   int32_t code = translateExprList(pCxt, pSelect->pProjectionList);
   if (TSDB_CODE_SUCCESS == code) {
     code = translateStar(pCxt, pSelect);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = translateProjectionList(pCxt, pSelect);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = checkExprListForGroupBy(pCxt, pSelect, pSelect->pProjectionList);
   }
@@ -2232,7 +2278,7 @@ static int32_t getQueryTimeRange(STranslateContext* pCxt, SNode* pWhere, STimeWi
   }
 
   SNode* pPrimaryKeyCond = NULL;
-  nodesPartitionCond(&pCond, &pPrimaryKeyCond, NULL, NULL, NULL);
+  filterPartitionCond(&pCond, &pPrimaryKeyCond, NULL, NULL, NULL);
 
   int32_t code = TSDB_CODE_SUCCESS;
   if (NULL != pPrimaryKeyCond) {
@@ -2699,6 +2745,7 @@ static SNode* createSetOperProject(const char* pTableAlias, SNode* pNode) {
   strcpy(pCol->tableAlias, pTableAlias);
   strcpy(pCol->colName, ((SExprNode*)pNode)->aliasName);
   strcpy(pCol->node.aliasName, pCol->colName);
+  strcpy(pCol->node.userAlias, ((SExprNode*)pNode)->userAlias);
   return (SNode*)pCol;
 }
 
@@ -2810,7 +2857,7 @@ static int32_t partitionDeleteWhere(STranslateContext* pCxt, SDeleteStmt* pDelet
 
   SNode*  pPrimaryKeyCond = NULL;
   SNode*  pOtherCond = NULL;
-  int32_t code = nodesPartitionCond(&pDelete->pWhere, &pPrimaryKeyCond, NULL, &pDelete->pTagCond, &pOtherCond);
+  int32_t code = filterPartitionCond(&pDelete->pWhere, &pPrimaryKeyCond, NULL, &pDelete->pTagCond, &pOtherCond);
   if (TSDB_CODE_SUCCESS == code && NULL != pOtherCond) {
     code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_DELETE_WHERE);
   }
@@ -4983,7 +5030,7 @@ static int32_t translateSubquery(STranslateContext* pCxt, SNode* pNode) {
   SNode*     pCurrStmt = pCxt->pCurrStmt;
   int32_t    currLevel = pCxt->currLevel;
   pCxt->currLevel = ++(pCxt->levelNo);
-  int32_t    code = translateQuery(pCxt, pNode);
+  int32_t code = translateQuery(pCxt, pNode);
   pCxt->currClause = currClause;
   pCxt->pCurrStmt = pCurrStmt;
   pCxt->currLevel = currLevel;

source/libs/parser/test/parSelectTest.cpp

@@ -70,6 +70,8 @@ TEST_F(ParserSelectTest, condition) {
   run("SELECT c1 FROM t1 WHERE NOT ts in (true, false)");
 
   run("SELECT * FROM t1 WHERE c1 > 10 and c1 is not null");
+
+  run("SELECT * FROM t1 WHERE TBNAME like 'fda%' or TS > '2021-05-05 18:19:01.000'");
 }
 
 TEST_F(ParserSelectTest, pseudoColumn) {

source/libs/planner/src/planOptimizer.c

@@ -436,7 +436,7 @@ static int32_t pushDownCondOptDealScan(SOptimizeContext* pCxt, SScanLogicNode* p
 
   SNode*  pPrimaryKeyCond = NULL;
   SNode*  pOtherCond = NULL;
-  int32_t code = nodesPartitionCond(&pScan->node.pConditions, &pPrimaryKeyCond, &pScan->pTagIndexCond, &pScan->pTagCond,
+  int32_t code = filterPartitionCond(&pScan->node.pConditions, &pPrimaryKeyCond, &pScan->pTagIndexCond, &pScan->pTagCond,
                                     &pOtherCond);
   if (TSDB_CODE_SUCCESS == code && NULL != pScan->pTagCond) {
     code = pushDownCondOptRebuildTbanme(&pScan->pTagCond);

source/libs/planner/src/planSpliter.c

@@ -763,6 +763,8 @@ static SNode* stbSplCreateColumnNode(SExprNode* pExpr) {
     return NULL;
   }
   if (QUERY_NODE_COLUMN == nodeType(pExpr)) {
+    strcpy(pCol->dbName, ((SColumnNode*)pExpr)->dbName);
+    strcpy(pCol->tableName, ((SColumnNode*)pExpr)->tableName);
     strcpy(pCol->tableAlias, ((SColumnNode*)pExpr)->tableAlias);
   }
   strcpy(pCol->colName, pExpr->aliasName);

source/libs/planner/test/planOrderByTest.cpp

@@ -39,6 +39,8 @@ TEST_F(PlanOrderByTest, expr) {
   useDb("root", "test");
 
   run("SELECT * FROM t1 ORDER BY c1 + 10, c2");
+
+  run("SELECT c1 FROM st1 ORDER BY ts, _C0");
 }
 
 TEST_F(PlanOrderByTest, nullsOrder) {

source/libs/planner/test/planSubqueryTest.cpp

@@ -73,3 +73,9 @@ TEST_F(PlanSubqeuryTest, outerInterval) {
 
   run("SELECT COUNT(*) FROM (SELECT ts, TOP(c1, 10) FROM st1s1) INTERVAL(5s)");
 }
+
+TEST_F(PlanSubqeuryTest, outerPartition) {
+  useDb("root", "test");
+
+  run("SELECT c1, COUNT(*) FROM (SELECT ts, c1 FROM st1) PARTITION BY c1");
+}

source/libs/scalar/src/filter.c

@@ -22,6 +22,7 @@
 #include "tcompare.h"
 #include "tdatablock.h"
 #include "ttime.h"
+#include "functionMgt.h"
 
 OptrStr gOptrStr[] = {
   {0,                                      "invalid"},
@@ -3877,4 +3878,195 @@ bool filterExecute(SFilterInfo *info, SSDataBlock *pSrc, int8_t** p, SColumnData
 }
 
 
+typedef struct SClassifyConditionCxt {
+  bool hasPrimaryKey;
+  bool hasTagIndexCol;
+  bool hasTagCol;
+  bool hasOtherCol;
+} SClassifyConditionCxt;
+
+static EDealRes classifyConditionImpl(SNode* pNode, void* pContext) {
+  SClassifyConditionCxt* pCxt = (SClassifyConditionCxt*)pContext;
+  if (QUERY_NODE_COLUMN == nodeType(pNode)) {
+    SColumnNode* pCol = (SColumnNode*)pNode;
+    if (PRIMARYKEY_TIMESTAMP_COL_ID == pCol->colId && TSDB_SYSTEM_TABLE != pCol->tableType) {
+      pCxt->hasPrimaryKey = true;
+    } else if (pCol->hasIndex) {
+      pCxt->hasTagIndexCol = true;
+      pCxt->hasTagCol = true;
+    } else if (COLUMN_TYPE_TAG == pCol->colType || COLUMN_TYPE_TBNAME == pCol->colType) {
+      pCxt->hasTagCol = true;
+    } else {
+      pCxt->hasOtherCol = true;
+    }
+  } else if (QUERY_NODE_FUNCTION == nodeType(pNode)) {
+    SFunctionNode* pFunc = (SFunctionNode*)pNode;
+    if (fmIsPseudoColumnFunc(pFunc->funcId)) {
+      if (FUNCTION_TYPE_TBNAME==pFunc->funcType) {
+        pCxt->hasTagCol = true;
+      } else {
+        pCxt->hasOtherCol = true;
+      }
+    }
+  }
+  return DEAL_RES_CONTINUE;
+}
+
+typedef enum EConditionType {
+  COND_TYPE_PRIMARY_KEY = 1,
+  COND_TYPE_TAG_INDEX,
+  COND_TYPE_TAG,
+  COND_TYPE_NORMAL
+} EConditionType;
 
+static EConditionType classifyCondition(SNode* pNode) {
+  SClassifyConditionCxt cxt = {.hasPrimaryKey = false, .hasTagIndexCol = false, .hasOtherCol = false};
+  nodesWalkExpr(pNode, classifyConditionImpl, &cxt);
+  return cxt.hasOtherCol ? COND_TYPE_NORMAL
+                         : (cxt.hasPrimaryKey && cxt.hasTagCol
+                                ? COND_TYPE_NORMAL
+                                : (cxt.hasPrimaryKey ? COND_TYPE_PRIMARY_KEY
+                                                     : (cxt.hasTagIndexCol ? COND_TYPE_TAG_INDEX : COND_TYPE_TAG)));
+}
+
+static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagIndexCond, SNode** pTagCond,
+                                  SNode** pOtherCond) {
+  SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(*pCondition);
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SNodeList* pPrimaryKeyConds = NULL;
+  SNodeList* pTagIndexConds = NULL;
+  SNodeList* pTagConds = NULL;
+  SNodeList* pOtherConds = NULL;
+  SNode*     pCond = NULL;
+  FOREACH(pCond, pLogicCond->pParameterList) {
+    switch (classifyCondition(pCond)) {
+      case COND_TYPE_PRIMARY_KEY:
+        if (NULL != pPrimaryKeyCond) {
+          code = nodesListMakeAppend(&pPrimaryKeyConds, nodesCloneNode(pCond));
+        }
+        break;
+      case COND_TYPE_TAG_INDEX:
+        if (NULL != pTagIndexCond) {
+          code = nodesListMakeAppend(&pTagIndexConds, nodesCloneNode(pCond));
+        }
+        if (NULL != pTagCond) {
+          code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
+        }
+        break;
+      case COND_TYPE_TAG:
+        if (NULL != pTagCond) {
+          code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
+        }
+        break;
+      case COND_TYPE_NORMAL:
+      default:
+        if (NULL != pOtherCond) {
+          code = nodesListMakeAppend(&pOtherConds, nodesCloneNode(pCond));
+        }
+        break;
+    }
+    if (TSDB_CODE_SUCCESS != code) {
+      break;
+    }
+  }
+
+  SNode* pTempPrimaryKeyCond = NULL;
+  SNode* pTempTagIndexCond = NULL;
+  SNode* pTempTagCond = NULL;
+  SNode* pTempOtherCond = NULL;
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesMergeConds(&pTempPrimaryKeyCond, &pPrimaryKeyConds);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesMergeConds(&pTempTagIndexCond, &pTagIndexConds);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesMergeConds(&pTempTagCond, &pTagConds);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesMergeConds(&pTempOtherCond, &pOtherConds);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    if (NULL != pPrimaryKeyCond) {
+      *pPrimaryKeyCond = pTempPrimaryKeyCond;
+    }
+    if (NULL != pTagIndexCond) {
+      *pTagIndexCond = pTempTagIndexCond;
+    }
+    if (NULL != pTagCond) {
+      *pTagCond = pTempTagCond;
+    }
+    if (NULL != pOtherCond) {
+      *pOtherCond = pTempOtherCond;
+    }
+    nodesDestroyNode(*pCondition);
+    *pCondition = NULL;
+  } else {
+    nodesDestroyList(pPrimaryKeyConds);
+    nodesDestroyList(pTagIndexConds);
+    nodesDestroyList(pTagConds);
+    nodesDestroyList(pOtherConds);
+    nodesDestroyNode(pTempPrimaryKeyCond);
+    nodesDestroyNode(pTempTagIndexCond);
+    nodesDestroyNode(pTempTagCond);
+    nodesDestroyNode(pTempOtherCond);
+  }
+
+  return code;
+}
+
+int32_t filterPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagIndexCond, SNode** pTagCond,
+                           SNode** pOtherCond) {
+  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*pCondition) &&
+      LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)*pCondition)->condType) {
+    return partitionLogicCond(pCondition, pPrimaryKeyCond, pTagIndexCond, pTagCond, pOtherCond);
+  }
+
+  bool needOutput = false;
+  switch (classifyCondition(*pCondition)) {
+    case COND_TYPE_PRIMARY_KEY:
+      if (NULL != pPrimaryKeyCond) {
+        *pPrimaryKeyCond = *pCondition;
+        needOutput = true;
+      }
+      break;
+    case COND_TYPE_TAG_INDEX:
+      if (NULL != pTagIndexCond) {
+        *pTagIndexCond = *pCondition;
+        needOutput = true;
+      }
+      if (NULL != pTagCond) {
+        SNode* pTempCond = *pCondition;
+        if (NULL != pTagIndexCond) {
+          pTempCond = nodesCloneNode(*pCondition);
+          if (NULL == pTempCond) {
+            return TSDB_CODE_OUT_OF_MEMORY;
+          }
+        }
+        *pTagCond = pTempCond;
+        needOutput = true;
+      }
+      break;
+    case COND_TYPE_TAG:
+      if (NULL != pTagCond) {
+        *pTagCond = *pCondition;
+        needOutput = true;
+      }
+      break;
+    case COND_TYPE_NORMAL:
+    default:
+      if (NULL != pOtherCond) {
+        *pOtherCond = *pCondition;
+        needOutput = true;
+      }
+      break;
+  }
+  if (needOutput) {
+    *pCondition = NULL;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}

tests/script/tsim/parser/condition_query.sim

@@ -2631,7 +2631,7 @@ sql_error select tb1.ts,tb1.c1,tb2_1.u1 from tb1, tb2_1 where tb1.ts=tb2_1.ts or
 
 
 print "ts&tbname test"
-sql_error select count(*) from stb1 where ts > 0 or tbname like 'tb%';
+sql select count(*) from stb1 where ts > 0 or tbname like 'tb%';
 
 print "ts&tag test"
 sql select count(*) from stb1 where ts > 0 or t1 > 0;
@@ -2717,9 +2717,9 @@ print "tbname&tag&join test"
 
 
 print "column&ts&tbname&tag test"
-sql_error select * from stb1 where (tbname like 'tb%' or ts > '2021-05-05 18:19:01.000') and (t1 > 5 or t1 < 4) and c1 > 0;
+sql select * from stb1 where (tbname like 'tb%' or ts > '2021-05-05 18:19:01.000') and (t1 > 5 or t1 < 4) and c1 > 0;
 sql select * from stb1 where (ts > '2021-05-05 18:19:01.000') and (ts > '2021-05-05 18:19:02.000' or t1 > 3) and (t1 > 5 or t1 < 4) and c1 > 0;
-sql_error select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:03.000' or ts > '2021-05-05 18:19:20.000' and col > 0 and t1 > 0;
+sql select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:03.000' or ts > '2021-05-05 18:19:20.000' and c1 > 0 and t1 > 0;
 
 
 print "column&ts&tbname&join test"