support update multi tag
This commit is contained in:
yihaoDeng
parent
868a1ce80c
commit
3027e377fa
|
|
@ -178,6 +178,7 @@ typedef enum _mgmt_table {
|
|||
#define TSDB_ALTER_TABLE_DROP_TAG_INDEX 12
|
||||
#define TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS 13
|
||||
#define TSDB_ALTER_TABLE_ADD_COLUMN_WITH_COMPRESS_OPTION 14
|
||||
#define TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL 15
|
||||
|
||||
#define TSDB_FILL_NONE 0
|
||||
#define TSDB_FILL_NULL 1
|
||||
|
|
@ -351,6 +352,7 @@ typedef enum ENodeType {
|
|||
QUERY_NODE_CREATE_ANODE_STMT,
|
||||
QUERY_NODE_DROP_ANODE_STMT,
|
||||
QUERY_NODE_UPDATE_ANODE_STMT,
|
||||
QUERY_NODE_ALTER_TABLE_MULTI_STMT,
|
||||
|
||||
// show statement nodes
|
||||
// see 'sysTableShowAdapter', 'SYSTABLE_SHOW_TYPE_OFFSET'
|
||||
|
|
@ -985,7 +987,6 @@ typedef struct SEpSet {
|
|||
SEp eps[TSDB_MAX_REPLICA];
|
||||
} SEpSet;
|
||||
|
||||
|
||||
int32_t tEncodeSEpSet(SEncoder* pEncoder, const SEpSet* pEp);
|
||||
int32_t tDecodeSEpSet(SDecoder* pDecoder, SEpSet* pEp);
|
||||
int32_t taosEncodeSEpSet(void** buf, const SEpSet* pEp);
|
||||
|
|
@ -3259,6 +3260,16 @@ int32_t tEncodeSVDropTbBatchRsp(SEncoder* pCoder, const SVDropTbBatchRsp* pRsp);
|
|||
int32_t tDecodeSVDropTbBatchRsp(SDecoder* pCoder, SVDropTbBatchRsp* pRsp);
|
||||
|
||||
// TDMT_VND_ALTER_TABLE =====================
|
||||
typedef struct SMultiTagUpateVal {
|
||||
char* tagName;
|
||||
int32_t colId;
|
||||
int8_t tagType;
|
||||
int8_t tagFree;
|
||||
uint32_t nTagVal;
|
||||
uint8_t* pTagVal;
|
||||
int8_t isNull;
|
||||
SArray* pTagArray;
|
||||
} SMultiTagUpateVal;
|
||||
typedef struct {
|
||||
char* tbName;
|
||||
int8_t action;
|
||||
|
|
@ -3288,6 +3299,7 @@ typedef struct {
|
|||
int64_t ctimeMs; // fill by vnode
|
||||
int8_t source; // TD_REQ_FROM_TAOX-taosX or TD_REQ_FROM_APP-taosClient
|
||||
uint32_t compress; // TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS
|
||||
SArray* pMultiTag; // TSDB_ALTER_TABLE_ADD_MULTI_TAGS
|
||||
} SVAlterTbReq;
|
||||
|
||||
int32_t tEncodeSVAlterTbReq(SEncoder* pEncoder, const SVAlterTbReq* pReq);
|
||||
|
|
|
|||
|
|
@ -264,8 +264,30 @@ typedef struct SAlterTableStmt {
|
|||
SDataType dataType;
|
||||
SValueNode* pVal;
|
||||
SColumnOptions* pColOptions;
|
||||
SNodeList* pNodeListTagValue;
|
||||
} SAlterTableStmt;
|
||||
|
||||
|
||||
typedef struct SAlterTableStmt2 {
|
||||
ENodeType type;
|
||||
int8_t alterType;
|
||||
char colName[TSDB_COL_NAME_LEN];
|
||||
STableOptions* pOptions;
|
||||
SDataType dataType;
|
||||
SValueNode* pVal;
|
||||
SColumnOptions* pColOptions;
|
||||
|
||||
} SAlterTableStmt2;
|
||||
|
||||
typedef struct SAlterTableMultiStmt {
|
||||
ENodeType type;
|
||||
char dbName[TSDB_DB_NAME_LEN];
|
||||
char tableName[TSDB_TABLE_NAME_LEN];
|
||||
int8_t alterType;
|
||||
|
||||
SNodeList* pNodeListTagValue;
|
||||
} SAlterTableMultiStmt;
|
||||
|
||||
typedef struct SCreateUserStmt {
|
||||
ENodeType type;
|
||||
char userName[TSDB_USER_LEN];
|
||||
|
|
|
|||
|
|
@ -10511,6 +10511,20 @@ int32_t tEncodeSVAlterTbReq(SEncoder *pEncoder, const SVAlterTbReq *pReq) {
|
|||
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pReq->pTagVal, pReq->nTagVal));
|
||||
}
|
||||
break;
|
||||
case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL:
|
||||
int32_t nTags = taosArrayGetSize(pReq->pMultiTag);
|
||||
TAOS_CHECK_EXIT(tEncodeI32v(pEncoder, nTags));
|
||||
for (int32_t i = 0; i < nTags; i++) {
|
||||
SMultiTagUpateVal *pTag = taosArrayGet(pReq->pMultiTag, i);
|
||||
TAOS_CHECK_EXIT(tEncodeI32v(pEncoder, pTag->colId));
|
||||
TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, pTag->tagName));
|
||||
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTag->isNull));
|
||||
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pTag->tagType));
|
||||
if (!pTag->isNull) {
|
||||
TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pTag->pTagVal, pReq->nTagVal));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case TSDB_ALTER_TABLE_UPDATE_OPTIONS:
|
||||
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pReq->updateTTL));
|
||||
if (pReq->updateTTL) {
|
||||
|
|
@ -10577,6 +10591,27 @@ static int32_t tDecodeSVAlterTbReqCommon(SDecoder *pDecoder, SVAlterTbReq *pReq)
|
|||
TAOS_CHECK_EXIT(tDecodeBinary(pDecoder, &pReq->pTagVal, &pReq->nTagVal));
|
||||
}
|
||||
break;
|
||||
case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL:
|
||||
int32_t nTags;
|
||||
TAOS_CHECK_EXIT(tDecodeI32v(pDecoder, &nTags));
|
||||
pReq->pMultiTag = taosArrayInit(nTags, sizeof(SMultiTagUpateVal));
|
||||
if (pReq->pMultiTag == NULL) {
|
||||
TAOS_CHECK_EXIT(terrno);
|
||||
}
|
||||
for (int32_t i = 0; i < nTags; i++) {
|
||||
SMultiTagUpateVal tag;
|
||||
TAOS_CHECK_EXIT(tDecodeI32v(pDecoder, &tag.colId));
|
||||
TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &tag.tagName));
|
||||
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &tag.isNull));
|
||||
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &tag.tagType));
|
||||
if (!tag.isNull) {
|
||||
TAOS_CHECK_EXIT(tDecodeBinary(pDecoder, &tag.pTagVal, &tag.nTagVal));
|
||||
}
|
||||
if (taosArrayPush(pReq->pMultiTag, &tag) == NULL) {
|
||||
TAOS_CHECK_EXIT(terrno);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case TSDB_ALTER_TABLE_UPDATE_OPTIONS:
|
||||
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->updateTTL));
|
||||
if (pReq->updateTTL) {
|
||||
|
|
|
|||
|
|
@ -2011,6 +2011,7 @@ _err:
|
|||
return terrno != 0 ? terrno : TSDB_CODE_FAILED;
|
||||
}
|
||||
|
||||
static int metaUpdateTableMultiTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) { return 0; }
|
||||
static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
|
||||
SMetaEntry ctbEntry = {0};
|
||||
SMetaEntry stbEntry = {0};
|
||||
|
|
@ -2736,6 +2737,9 @@ int metaAlterTable(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMeta
|
|||
return metaAlterTableColumn(pMeta, version, pReq, pMetaRsp);
|
||||
case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:
|
||||
return metaUpdateTableTagVal(pMeta, version, pReq);
|
||||
case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL:
|
||||
return metaUpdateTableMultiTagVal(pMeta, version, pReq);
|
||||
return terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION;
|
||||
case TSDB_ALTER_TABLE_UPDATE_OPTIONS:
|
||||
return metaUpdateTableOptions(pMeta, version, pReq);
|
||||
case TSDB_ALTER_TABLE_ADD_TAG_INDEX:
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@
|
|||
*/
|
||||
|
||||
#include "cmdnodes.h"
|
||||
#include "functionMgt.h"
|
||||
#include "nodesUtil.h"
|
||||
#include "plannodes.h"
|
||||
#include "querynodes.h"
|
||||
|
|
@ -22,7 +23,6 @@
|
|||
#include "tdatablock.h"
|
||||
#include "thash.h"
|
||||
#include "tref.h"
|
||||
#include "functionMgt.h"
|
||||
|
||||
typedef struct SNodeMemChunk {
|
||||
int32_t availableSize;
|
||||
|
|
@ -59,12 +59,10 @@ char* getFullJoinTypeString(EJoinType type, EJoinSubType stype) {
|
|||
{"INNER", "INNER", "INNER", "INNER", "INNER", "INNER ANY", "INNER", "INNER"},
|
||||
{"LEFT", "LEFT", "LEFT OUTER", "LEFT SEMI", "LEFT ANTI", "LEFT ANY", "LEFT ASOF", "LEFT WINDOW"},
|
||||
{"RIGHT", "RIGHT", "RIGHT OUTER", "RIGHT SEMI", "RIGHT ANTI", "RIGHT ANY", "RIGHT ASOF", "RIGHT WINDOW"},
|
||||
{"FULL", "FULL", "FULL OUTER", "FULL", "FULL", "FULL ANY", "FULL", "FULL"}
|
||||
};
|
||||
{"FULL", "FULL", "FULL OUTER", "FULL", "FULL", "FULL ANY", "FULL", "FULL"}};
|
||||
return joinFullType[type][stype];
|
||||
}
|
||||
|
||||
|
||||
int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) {
|
||||
if (NULL == *ppSrc) {
|
||||
return TSDB_CODE_SUCCESS;
|
||||
|
|
@ -74,14 +72,16 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) {
|
|||
*ppSrc = NULL;
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
|
||||
if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) &&
|
||||
((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
|
||||
TSWAP(*ppDst, *ppSrc);
|
||||
}
|
||||
int32_t code = 0;
|
||||
if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppDst)) {
|
||||
SLogicConditionNode* pDst = (SLogicConditionNode*)*ppDst;
|
||||
if (pDst->condType == LOGIC_COND_TYPE_AND) {
|
||||
if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
|
||||
if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) &&
|
||||
((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {
|
||||
code = nodesListStrictAppendList(pDst->pParameterList, ((SLogicConditionNode*)(*ppSrc))->pParameterList);
|
||||
((SLogicConditionNode*)(*ppSrc))->pParameterList = NULL;
|
||||
} else {
|
||||
|
|
@ -115,7 +115,6 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) {
|
|||
return code;
|
||||
}
|
||||
|
||||
|
||||
static int32_t callocNodeChunk(SNodeAllocator* pAllocator, SNodeMemChunk** pOutChunk) {
|
||||
SNodeMemChunk* pNewChunk = taosMemoryCalloc(1, sizeof(SNodeMemChunk) + pAllocator->chunkSize);
|
||||
if (NULL == pNewChunk) {
|
||||
|
|
@ -155,7 +154,8 @@ static int32_t nodesCallocImpl(int32_t size, void** pOut) {
|
|||
void* p = g_pNodeAllocator->pCurrChunk->pBuf + g_pNodeAllocator->pCurrChunk->usedSize;
|
||||
g_pNodeAllocator->pCurrChunk->usedSize += size;
|
||||
*pOut = p;
|
||||
return TSDB_CODE_SUCCESS;;
|
||||
return TSDB_CODE_SUCCESS;
|
||||
;
|
||||
}
|
||||
|
||||
static int32_t nodesCalloc(int32_t num, int32_t size, void** pOut) {
|
||||
|
|
@ -237,7 +237,8 @@ void nodesDestroyAllocatorSet() {
|
|||
refId = pAllocator->self;
|
||||
int32_t code = taosRemoveRef(g_allocatorReqRefPool, refId);
|
||||
if (TSDB_CODE_SUCCESS != code) {
|
||||
nodesError("failed to remove ref at: %s:%d, rsetId:%d, refId:%"PRId64, __func__, __LINE__, g_allocatorReqRefPool, refId);
|
||||
nodesError("failed to remove ref at: %s:%d, rsetId:%d, refId:%" PRId64, __func__, __LINE__,
|
||||
g_allocatorReqRefPool, refId);
|
||||
}
|
||||
pAllocator = taosIterateRef(g_allocatorReqRefPool, refId);
|
||||
}
|
||||
|
|
@ -333,7 +334,8 @@ void nodesDestroyAllocator(int64_t allocatorId) {
|
|||
|
||||
int32_t code = taosRemoveRef(g_allocatorReqRefPool, allocatorId);
|
||||
if (TSDB_CODE_SUCCESS != code) {
|
||||
nodesError("failed to remove ref at: %s:%d, rsetId:%d, refId:%"PRId64, __func__, __LINE__, g_allocatorReqRefPool, allocatorId);
|
||||
nodesError("failed to remove ref at: %s:%d, rsetId:%d, refId:%" PRId64, __func__, __LINE__, g_allocatorReqRefPool,
|
||||
allocatorId);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -352,198 +354,293 @@ int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut) {
|
|||
int32_t code = 0;
|
||||
switch (type) {
|
||||
case QUERY_NODE_COLUMN:
|
||||
code = makeNode(type, sizeof(SColumnNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SColumnNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_VALUE:
|
||||
code = makeNode(type, sizeof(SValueNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SValueNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_OPERATOR:
|
||||
code = makeNode(type, sizeof(SOperatorNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SOperatorNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_CONDITION:
|
||||
code = makeNode(type, sizeof(SLogicConditionNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SLogicConditionNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_FUNCTION:
|
||||
code = makeNode(type, sizeof(SFunctionNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SFunctionNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_REAL_TABLE:
|
||||
code = makeNode(type, sizeof(SRealTableNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SRealTableNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_TEMP_TABLE:
|
||||
code = makeNode(type, sizeof(STempTableNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(STempTableNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_JOIN_TABLE:
|
||||
code = makeNode(type, sizeof(SJoinTableNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SJoinTableNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_GROUPING_SET:
|
||||
code = makeNode(type, sizeof(SGroupingSetNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SGroupingSetNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_ORDER_BY_EXPR:
|
||||
code = makeNode(type, sizeof(SOrderByExprNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SOrderByExprNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LIMIT:
|
||||
code = makeNode(type, sizeof(SLimitNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SLimitNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_STATE_WINDOW:
|
||||
code = makeNode(type, sizeof(SStateWindowNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStateWindowNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SESSION_WINDOW:
|
||||
code = makeNode(type, sizeof(SSessionWindowNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSessionWindowNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_INTERVAL_WINDOW:
|
||||
code = makeNode(type, sizeof(SIntervalWindowNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SIntervalWindowNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_NODE_LIST:
|
||||
code = makeNode(type, sizeof(SNodeListNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SNodeListNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_FILL:
|
||||
code = makeNode(type, sizeof(SFillNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SFillNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_RAW_EXPR:
|
||||
code = makeNode(type, sizeof(SRawExprNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SRawExprNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_TARGET:
|
||||
code = makeNode(type, sizeof(STargetNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(STargetNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DATABLOCK_DESC:
|
||||
code = makeNode(type, sizeof(SDataBlockDescNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDataBlockDescNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SLOT_DESC:
|
||||
code = makeNode(type, sizeof(SSlotDescNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSlotDescNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_COLUMN_DEF:
|
||||
code = makeNode(type, sizeof(SColumnDefNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SColumnDefNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DOWNSTREAM_SOURCE:
|
||||
code = makeNode(type, sizeof(SDownstreamSourceNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDownstreamSourceNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DATABASE_OPTIONS:
|
||||
code = makeNode(type, sizeof(SDatabaseOptions), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDatabaseOptions), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_TABLE_OPTIONS:
|
||||
code = makeNode(type, sizeof(STableOptions), &pNode); break;
|
||||
code = makeNode(type, sizeof(STableOptions), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_COLUMN_OPTIONS:
|
||||
code = makeNode(type, sizeof(SColumnOptions), &pNode); break;
|
||||
code = makeNode(type, sizeof(SColumnOptions), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_INDEX_OPTIONS:
|
||||
code = makeNode(type, sizeof(SIndexOptions), &pNode); break;
|
||||
code = makeNode(type, sizeof(SIndexOptions), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_EXPLAIN_OPTIONS:
|
||||
code = makeNode(type, sizeof(SExplainOptions), &pNode); break;
|
||||
code = makeNode(type, sizeof(SExplainOptions), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_STREAM_OPTIONS:
|
||||
code = makeNode(type, sizeof(SStreamOptions), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamOptions), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LEFT_VALUE:
|
||||
code = makeNode(type, sizeof(SLeftValueNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SLeftValueNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_COLUMN_REF:
|
||||
code = makeNode(type, sizeof(SColumnRefNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SColumnRefNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_WHEN_THEN:
|
||||
code = makeNode(type, sizeof(SWhenThenNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SWhenThenNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CASE_WHEN:
|
||||
code = makeNode(type, sizeof(SCaseWhenNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCaseWhenNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_EVENT_WINDOW:
|
||||
code = makeNode(type, sizeof(SEventWindowNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SEventWindowNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_COUNT_WINDOW:
|
||||
code = makeNode(type, sizeof(SCountWindowNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCountWindowNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_ANOMALY_WINDOW:
|
||||
code = makeNode(type, sizeof(SAnomalyWindowNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAnomalyWindowNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_HINT:
|
||||
code = makeNode(type, sizeof(SHintNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SHintNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_VIEW:
|
||||
code = makeNode(type, sizeof(SViewNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SViewNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_WINDOW_OFFSET:
|
||||
code = makeNode(type, sizeof(SWindowOffsetNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SWindowOffsetNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SET_OPERATOR:
|
||||
code = makeNode(type, sizeof(SSetOperator), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSetOperator), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SELECT_STMT:
|
||||
code = makeNode(type, sizeof(SSelectStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSelectStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_VNODE_MODIFY_STMT:
|
||||
code = makeNode(type, sizeof(SVnodeModifyOpStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SVnodeModifyOpStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(SCreateDatabaseStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateDatabaseStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(SDropDatabaseStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropDatabaseStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_ALTER_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(SAlterDatabaseStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAlterDatabaseStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_FLUSH_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(SFlushDatabaseStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SFlushDatabaseStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_TRIM_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(STrimDatabaseStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(STrimDatabaseStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_S3MIGRATE_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(SS3MigrateDatabaseStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SS3MigrateDatabaseStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_TABLE_STMT:
|
||||
code = makeNode(type, sizeof(SCreateTableStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateTableStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_SUBTABLE_CLAUSE:
|
||||
code = makeNode(type, sizeof(SCreateSubTableClause), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateSubTableClause), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE:
|
||||
code = makeNode(type, sizeof(SCreateSubTableFromFileClause), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateSubTableFromFileClause), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_MULTI_TABLES_STMT:
|
||||
code = makeNode(type, sizeof(SCreateMultiTablesStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateMultiTablesStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_TABLE_CLAUSE:
|
||||
code = makeNode(type, sizeof(SDropTableClause), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropTableClause), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_TABLE_STMT:
|
||||
code = makeNode(type, sizeof(SDropTableStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropTableStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_SUPER_TABLE_STMT:
|
||||
code = makeNode(type, sizeof(SDropSuperTableStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropSuperTableStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_ALTER_TABLE_STMT:
|
||||
case QUERY_NODE_ALTER_SUPER_TABLE_STMT:
|
||||
code = makeNode(type, sizeof(SAlterTableStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAlterTableStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_ALTER_TABLE_MULTI_STMT:
|
||||
code = makeNode(type, sizeof(SAlterTableMultiStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_USER_STMT:
|
||||
code = makeNode(type, sizeof(SCreateUserStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateUserStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_ALTER_USER_STMT:
|
||||
code = makeNode(type, sizeof(SAlterUserStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAlterUserStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_USER_STMT:
|
||||
code = makeNode(type, sizeof(SDropUserStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropUserStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_USE_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(SUseDatabaseStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SUseDatabaseStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_DNODE_STMT:
|
||||
code = makeNode(type, sizeof(SCreateDnodeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateDnodeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_DNODE_STMT:
|
||||
code = makeNode(type, sizeof(SDropDnodeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropDnodeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_ALTER_DNODE_STMT:
|
||||
code = makeNode(type, sizeof(SAlterDnodeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAlterDnodeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_ANODE_STMT:
|
||||
code = makeNode(type, sizeof(SCreateAnodeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateAnodeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_ANODE_STMT:
|
||||
code = makeNode(type, sizeof(SDropAnodeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropAnodeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_UPDATE_ANODE_STMT:
|
||||
code = makeNode(type, sizeof(SUpdateAnodeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SUpdateAnodeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_INDEX_STMT:
|
||||
code = makeNode(type, sizeof(SCreateIndexStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateIndexStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_INDEX_STMT:
|
||||
code = makeNode(type, sizeof(SDropIndexStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropIndexStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_QNODE_STMT:
|
||||
case QUERY_NODE_CREATE_BNODE_STMT:
|
||||
case QUERY_NODE_CREATE_SNODE_STMT:
|
||||
case QUERY_NODE_CREATE_MNODE_STMT:
|
||||
code = makeNode(type, sizeof(SCreateComponentNodeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateComponentNodeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_QNODE_STMT:
|
||||
case QUERY_NODE_DROP_BNODE_STMT:
|
||||
case QUERY_NODE_DROP_SNODE_STMT:
|
||||
case QUERY_NODE_DROP_MNODE_STMT:
|
||||
code = makeNode(type, sizeof(SDropComponentNodeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropComponentNodeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_TOPIC_STMT:
|
||||
code = makeNode(type, sizeof(SCreateTopicStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateTopicStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_TOPIC_STMT:
|
||||
code = makeNode(type, sizeof(SDropTopicStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropTopicStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_CGROUP_STMT:
|
||||
code = makeNode(type, sizeof(SDropCGroupStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropCGroupStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_ALTER_LOCAL_STMT:
|
||||
code = makeNode(type, sizeof(SAlterLocalStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAlterLocalStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_EXPLAIN_STMT:
|
||||
code = makeNode(type, sizeof(SExplainStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SExplainStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DESCRIBE_STMT:
|
||||
code = makeNode(type, sizeof(SDescribeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDescribeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_RESET_QUERY_CACHE_STMT:
|
||||
code = makeNode(type, sizeof(SNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_COMPACT_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(SCompactDatabaseStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCompactDatabaseStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_FUNCTION_STMT:
|
||||
code = makeNode(type, sizeof(SCreateFunctionStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateFunctionStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_FUNCTION_STMT:
|
||||
code = makeNode(type, sizeof(SDropFunctionStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropFunctionStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_STREAM_STMT:
|
||||
code = makeNode(type, sizeof(SCreateStreamStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateStreamStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_STREAM_STMT:
|
||||
code = makeNode(type, sizeof(SDropStreamStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropStreamStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PAUSE_STREAM_STMT:
|
||||
code = makeNode(type, sizeof(SPauseStreamStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SPauseStreamStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_RESUME_STREAM_STMT:
|
||||
code = makeNode(type, sizeof(SResumeStreamStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SResumeStreamStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_BALANCE_VGROUP_STMT:
|
||||
code = makeNode(type, sizeof(SBalanceVgroupStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SBalanceVgroupStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT:
|
||||
code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_MERGE_VGROUP_STMT:
|
||||
code = makeNode(type, sizeof(SMergeVgroupStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SMergeVgroupStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:
|
||||
code = makeNode(type, sizeof(SRedistributeVgroupStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SRedistributeVgroupStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SPLIT_VGROUP_STMT:
|
||||
code = makeNode(type, sizeof(SSplitVgroupStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSplitVgroupStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SYNCDB_STMT:
|
||||
break;
|
||||
case QUERY_NODE_GRANT_STMT:
|
||||
code = makeNode(type, sizeof(SGrantStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SGrantStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_REVOKE_STMT:
|
||||
code = makeNode(type, sizeof(SRevokeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SRevokeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_ALTER_CLUSTER_STMT:
|
||||
code = makeNode(type, sizeof(SAlterClusterStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAlterClusterStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_DNODES_STMT:
|
||||
case QUERY_NODE_SHOW_MNODES_STMT:
|
||||
case QUERY_NODE_SHOW_MODULES_STMT:
|
||||
|
|
@ -583,191 +680,280 @@ int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut) {
|
|||
case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT:
|
||||
case QUERY_NODE_SHOW_ENCRYPTIONS_STMT:
|
||||
case QUERY_NODE_SHOW_TSMAS_STMT:
|
||||
code = makeNode(type, sizeof(SShowStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_TABLE_TAGS_STMT:
|
||||
code = makeNode(type, sizeof(SShowTableTagsStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowTableTagsStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT:
|
||||
code = makeNode(type, sizeof(SShowDnodeVariablesStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowDnodeVariablesStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
|
||||
code = makeNode(type, sizeof(SShowCreateDatabaseStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowCreateDatabaseStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_DB_ALIVE_STMT:
|
||||
case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT:
|
||||
code = makeNode(type, sizeof(SShowAliveStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowAliveStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
|
||||
case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
|
||||
code = makeNode(type, sizeof(SShowCreateTableStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowCreateTableStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_CREATE_VIEW_STMT:
|
||||
code = makeNode(type, sizeof(SShowCreateViewStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowCreateViewStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:
|
||||
code = makeNode(type, sizeof(SShowTableDistributedStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowTableDistributedStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_COMPACTS_STMT:
|
||||
code = makeNode(type, sizeof(SShowCompactsStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowCompactsStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_SHOW_COMPACT_DETAILS_STMT:
|
||||
code = makeNode(type, sizeof(SShowCompactDetailsStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SShowCompactDetailsStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_KILL_QUERY_STMT:
|
||||
code = makeNode(type, sizeof(SKillQueryStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SKillQueryStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_KILL_TRANSACTION_STMT:
|
||||
case QUERY_NODE_KILL_CONNECTION_STMT:
|
||||
case QUERY_NODE_KILL_COMPACT_STMT:
|
||||
code = makeNode(type, sizeof(SKillStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SKillStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DELETE_STMT:
|
||||
code = makeNode(type, sizeof(SDeleteStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDeleteStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_INSERT_STMT:
|
||||
code = makeNode(type, sizeof(SInsertStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SInsertStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_QUERY:
|
||||
code = makeNode(type, sizeof(SQuery), &pNode); break;
|
||||
code = makeNode(type, sizeof(SQuery), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_RESTORE_DNODE_STMT:
|
||||
case QUERY_NODE_RESTORE_QNODE_STMT:
|
||||
case QUERY_NODE_RESTORE_MNODE_STMT:
|
||||
case QUERY_NODE_RESTORE_VNODE_STMT:
|
||||
code = makeNode(type, sizeof(SRestoreComponentNodeStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SRestoreComponentNodeStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_VIEW_STMT:
|
||||
code = makeNode(type, sizeof(SCreateViewStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateViewStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_VIEW_STMT:
|
||||
code = makeNode(type, sizeof(SDropViewStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropViewStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_CREATE_TSMA_STMT:
|
||||
code = makeNode(type, sizeof(SCreateTSMAStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCreateTSMAStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_DROP_TSMA_STMT:
|
||||
code = makeNode(type, sizeof(SDropTSMAStmt), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDropTSMAStmt), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_TSMA_OPTIONS:
|
||||
code = makeNode(type, sizeof(STSMAOptions), &pNode); break;
|
||||
code = makeNode(type, sizeof(STSMAOptions), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_SCAN:
|
||||
code = makeNode(type, sizeof(SScanLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SScanLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_JOIN:
|
||||
code = makeNode(type, sizeof(SJoinLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SJoinLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_AGG:
|
||||
code = makeNode(type, sizeof(SAggLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAggLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_PROJECT:
|
||||
code = makeNode(type, sizeof(SProjectLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SProjectLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY:
|
||||
code = makeNode(type, sizeof(SVnodeModifyLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SVnodeModifyLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_EXCHANGE:
|
||||
code = makeNode(type, sizeof(SExchangeLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SExchangeLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_MERGE:
|
||||
code = makeNode(type, sizeof(SMergeLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SMergeLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_WINDOW:
|
||||
code = makeNode(type, sizeof(SWindowLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SWindowLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_FILL:
|
||||
code = makeNode(type, sizeof(SFillLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SFillLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_SORT:
|
||||
code = makeNode(type, sizeof(SSortLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSortLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_PARTITION:
|
||||
code = makeNode(type, sizeof(SPartitionLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SPartitionLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC:
|
||||
code = makeNode(type, sizeof(SIndefRowsFuncLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SIndefRowsFuncLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC:
|
||||
code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_FORECAST_FUNC:
|
||||
code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE:
|
||||
code = makeNode(type, sizeof(SGroupCacheLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SGroupCacheLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL:
|
||||
code = makeNode(type, sizeof(SDynQueryCtrlLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDynQueryCtrlLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_SUBPLAN:
|
||||
code = makeNode(type, sizeof(SLogicSubplan), &pNode); break;
|
||||
code = makeNode(type, sizeof(SLogicSubplan), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_LOGIC_PLAN:
|
||||
code = makeNode(type, sizeof(SQueryLogicPlan), &pNode); break;
|
||||
code = makeNode(type, sizeof(SQueryLogicPlan), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
|
||||
code = makeNode(type, sizeof(STagScanPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(STagScanPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
|
||||
code = makeNode(type, sizeof(STableScanPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(STableScanPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:
|
||||
code = makeNode(type, sizeof(STableSeqScanPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(STableSeqScanPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
|
||||
code = makeNode(type, sizeof(STableMergeScanPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(STableMergeScanPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
|
||||
code = makeNode(type, sizeof(SStreamScanPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamScanPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:
|
||||
code = makeNode(type, sizeof(SSystemTableScanPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSystemTableScanPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:
|
||||
code = makeNode(type, sizeof(SBlockDistScanPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SBlockDistScanPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:
|
||||
code = makeNode(type, sizeof(SLastRowScanPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SLastRowScanPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN:
|
||||
code = makeNode(type, sizeof(STableCountScanPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(STableCountScanPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_PROJECT:
|
||||
code = makeNode(type, sizeof(SProjectPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SProjectPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:
|
||||
code = makeNode(type, sizeof(SSortMergeJoinPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSortMergeJoinPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:
|
||||
code = makeNode(type, sizeof(SHashJoinPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SHashJoinPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:
|
||||
code = makeNode(type, sizeof(SAggPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAggPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:
|
||||
code = makeNode(type, sizeof(SExchangePhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SExchangePhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_MERGE:
|
||||
code = makeNode(type, sizeof(SMergePhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SMergePhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_SORT:
|
||||
code = makeNode(type, sizeof(SSortPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSortPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT:
|
||||
code = makeNode(type, sizeof(SGroupSortPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SGroupSortPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:
|
||||
code = makeNode(type, sizeof(SIntervalPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SIntervalPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL:
|
||||
code = makeNode(type, sizeof(SMergeIntervalPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SMergeIntervalPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL:
|
||||
code = makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
|
||||
code = makeNode(type, sizeof(SStreamIntervalPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamIntervalPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
|
||||
code = makeNode(type, sizeof(SStreamFinalIntervalPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamFinalIntervalPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
|
||||
code = makeNode(type, sizeof(SStreamSemiIntervalPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamSemiIntervalPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL:
|
||||
code = makeNode(type, sizeof(SStreamMidIntervalPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamMidIntervalPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_FILL:
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:
|
||||
code = makeNode(type, sizeof(SFillPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SFillPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:
|
||||
code = makeNode(type, sizeof(SSessionWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSessionWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION:
|
||||
code = makeNode(type, sizeof(SStreamSessionWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamSessionWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION:
|
||||
code = makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION:
|
||||
code = makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:
|
||||
code = makeNode(type, sizeof(SStateWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStateWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE:
|
||||
code = makeNode(type, sizeof(SStreamStateWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamStateWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:
|
||||
code = makeNode(type, sizeof(SEventWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SEventWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT:
|
||||
code = makeNode(type, sizeof(SStreamEventWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamEventWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:
|
||||
code = makeNode(type, sizeof(SCountWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SCountWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_MERGE_ANOMALY:
|
||||
code = makeNode(type, sizeof(SAnomalyWindowPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SAnomalyWindowPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT:
|
||||
code = makeNode(type, sizeof(SStreamCountWinodwPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamCountWinodwPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_PARTITION:
|
||||
code = makeNode(type, sizeof(SPartitionPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SPartitionPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION:
|
||||
code = makeNode(type, sizeof(SStreamPartitionPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamPartitionPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:
|
||||
code = makeNode(type, sizeof(SIndefRowsFuncPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SIndefRowsFuncPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:
|
||||
code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_FORECAST_FUNC:
|
||||
code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:
|
||||
code = makeNode(type, sizeof(SDataDispatcherNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDataDispatcherNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_INSERT:
|
||||
code = makeNode(type, sizeof(SDataInserterNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDataInserterNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:
|
||||
code = makeNode(type, sizeof(SQueryInserterNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SQueryInserterNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_DELETE:
|
||||
code = makeNode(type, sizeof(SDataDeleterNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDataDeleterNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:
|
||||
code = makeNode(type, sizeof(SGroupCachePhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SGroupCachePhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:
|
||||
code = makeNode(type, sizeof(SDynQueryCtrlPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SDynQueryCtrlPhysiNode), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_SUBPLAN:
|
||||
code = makeNode(type, sizeof(SSubplan), &pNode); break;
|
||||
code = makeNode(type, sizeof(SSubplan), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN:
|
||||
code = makeNode(type, sizeof(SQueryPlan), &pNode); break;
|
||||
code = makeNode(type, sizeof(SQueryPlan), &pNode);
|
||||
break;
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERP_FUNC:
|
||||
code = makeNode(type, sizeof(SStreamInterpFuncPhysiNode), &pNode); break;
|
||||
code = makeNode(type, sizeof(SStreamInterpFuncPhysiNode), &pNode);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
@ -1176,6 +1362,13 @@ void nodesDestroyNode(SNode* pNode) {
|
|||
nodesDestroyNode((SNode*)pStmt->pVal);
|
||||
break;
|
||||
}
|
||||
case QUERY_NODE_ALTER_TABLE_MULTI_STMT: {
|
||||
SAlterTableMultiStmt* pStmt = (SAlterTableMultiStmt*)pNode;
|
||||
// nodesDestroyList(pStmt->pTables);
|
||||
// nodesDestroyNode((SNode*)pStmt->pOptions);
|
||||
// nodesDestroyNode((SNode*)pStmt->pVal);
|
||||
break;
|
||||
}
|
||||
case QUERY_NODE_CREATE_USER_STMT: {
|
||||
SCreateUserStmt* pStmt = (SCreateUserStmt*)pNode;
|
||||
taosMemoryFree(pStmt->pIpRanges);
|
||||
|
|
@ -1891,7 +2084,6 @@ int32_t nodesListStrictAppendList(SNodeList* pTarget, SNodeList* pSrc) {
|
|||
return code;
|
||||
}
|
||||
|
||||
|
||||
int32_t nodesListMakeStrictAppendList(SNodeList** pTarget, SNodeList* pSrc) {
|
||||
if (NULL == *pTarget) {
|
||||
int32_t code = nodesMakeList(pTarget);
|
||||
|
|
@ -2350,7 +2542,8 @@ static EDealRes doCollect(SCollectColumnsCxt* pCxt, SColumnNode* pCol, SNode* pN
|
|||
static bool isCollectType(ECollectColType collectType, EColumnType colType) {
|
||||
return COLLECT_COL_TYPE_ALL == collectType
|
||||
? true
|
||||
: (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType : (COLUMN_TYPE_TAG != colType && COLUMN_TYPE_TBNAME != colType));
|
||||
: (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType
|
||||
: (COLUMN_TYPE_TAG != colType && COLUMN_TYPE_TBNAME != colType));
|
||||
}
|
||||
|
||||
static EDealRes collectColumns(SNode* pNode, void* pContext) {
|
||||
|
|
@ -2370,7 +2563,9 @@ static EDealRes collectColumnsExt(SNode* pNode, void* pContext) {
|
|||
if (QUERY_NODE_COLUMN == nodeType(pNode)) {
|
||||
SColumnNode* pCol = (SColumnNode*)pNode;
|
||||
if (isCollectType(pCxt->collectType, pCol->colType) && 0 != strcmp(pCol->colName, "*") &&
|
||||
(NULL == pCxt->pMultiTableAlias || NULL != (pCxt->pTableAlias = tSimpleHashGet(pCxt->pMultiTableAlias, pCol->tableAlias, strlen(pCol->tableAlias))))) {
|
||||
(NULL == pCxt->pMultiTableAlias ||
|
||||
NULL != (pCxt->pTableAlias =
|
||||
tSimpleHashGet(pCxt->pMultiTableAlias, pCol->tableAlias, strlen(pCol->tableAlias))))) {
|
||||
return doCollect(pCxt, pCol, pNode);
|
||||
}
|
||||
}
|
||||
|
|
@ -2414,8 +2609,8 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char*
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t nodesCollectColumnsExt(SSelectStmt* pSelect, ESqlClause clause, SSHashObj* pMultiTableAlias, ECollectColType type,
|
||||
SNodeList** pCols) {
|
||||
int32_t nodesCollectColumnsExt(SSelectStmt* pSelect, ESqlClause clause, SSHashObj* pMultiTableAlias,
|
||||
ECollectColType type, SNodeList** pCols) {
|
||||
if (NULL == pSelect || NULL == pCols) {
|
||||
return TSDB_CODE_FAILED;
|
||||
}
|
||||
|
|
@ -2543,21 +2738,21 @@ static int32_t funcNodeEqual(const void* pLeft, const void* pRight, size_t len)
|
|||
return nodesEqualNode(*(const SNode**)pLeft, *(const SNode**)pRight) ? 0 : 1;
|
||||
}
|
||||
|
||||
int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList* pFuncs) {
|
||||
int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier,
|
||||
SNodeList* pFuncs) {
|
||||
if (NULL == pSelect || NULL == pFuncs) {
|
||||
return TSDB_CODE_FAILED;
|
||||
}
|
||||
|
||||
SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS,
|
||||
.classifier = classifier,
|
||||
.tableAlias = tableAlias,
|
||||
.pFuncs = pFuncs};
|
||||
SCollectFuncsCxt cxt = {
|
||||
.errCode = TSDB_CODE_SUCCESS, .classifier = classifier, .tableAlias = tableAlias, .pFuncs = pFuncs};
|
||||
|
||||
nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt);
|
||||
return cxt.errCode;
|
||||
}
|
||||
|
||||
int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs) {
|
||||
int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier,
|
||||
SNodeList** pFuncs) {
|
||||
if (NULL == pSelect || NULL == pFuncs) {
|
||||
return TSDB_CODE_FAILED;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -165,6 +165,7 @@ SNode* createInterpTimeRange(SAstCreateContext* pCxt, SNode* pStart, SNode*
|
|||
SNode* createInterpTimePoint(SAstCreateContext* pCxt, SNode* pPoint);
|
||||
SNode* createWhenThenNode(SAstCreateContext* pCxt, SNode* pWhen, SNode* pThen);
|
||||
SNode* createCaseWhenNode(SAstCreateContext* pCxt, SNode* pCase, SNodeList* pWhenThenList, SNode* pElse);
|
||||
SNode* createAlterSingleTagColumnNode(SAstCreateContext* pCtx, SToken* token, SNode* pVal);
|
||||
|
||||
SNode* addWhereClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pWhere);
|
||||
SNode* addPartitionByClause(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pPartitionByList);
|
||||
|
|
@ -228,6 +229,7 @@ SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_
|
|||
SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pOldColName,
|
||||
SToken* pNewColName);
|
||||
SNode* createAlterTableSetTag(SAstCreateContext* pCxt, SNode* pRealTable, SToken* pTagName, SNode* pVal);
|
||||
SNode* createAlterTableSetMultiTagValue(SAstCreateContext* pCxt, SNode* pRealTable, SNodeList* singleNode);
|
||||
SNode* setAlterSuperTableType(SNode* pStmt);
|
||||
SNode* createUseDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName);
|
||||
SNode* setShowKind(SAstCreateContext* pCxt, SNode* pStmt, EShowKind showKind);
|
||||
|
|
|
|||
|
|
@ -370,6 +370,7 @@ cmd ::= DROP STABLE with_opt(A) exists_opt(B) full_table_name(C).
|
|||
cmd ::= ALTER TABLE alter_table_clause(A). { pCxt->pRootNode = A; }
|
||||
cmd ::= ALTER STABLE alter_table_clause(A). { pCxt->pRootNode = setAlterSuperTableType(A); }
|
||||
|
||||
|
||||
alter_table_clause(A) ::= full_table_name(B) alter_table_options(C). { A = createAlterTableModifyOptions(pCxt, B, C); }
|
||||
alter_table_clause(A) ::=
|
||||
full_table_name(B) ADD COLUMN column_name(C) type_name(D) column_options(E). { A = createAlterTableAddModifyColOptions2(pCxt, B, TSDB_ALTER_TABLE_ADD_COLUMN, &C, D, E); }
|
||||
|
|
@ -387,8 +388,16 @@ alter_table_clause(A) ::=
|
|||
full_table_name(B) MODIFY TAG column_name(C) type_name(D). { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &C, D); }
|
||||
alter_table_clause(A) ::=
|
||||
full_table_name(B) RENAME TAG column_name(C) column_name(D). { A = createAlterTableRenameCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &C, &D); }
|
||||
|
||||
|
||||
%type column_eq_value_list { SNodeList* }
|
||||
%destructor column_eq_value_list { nodesDestroyList($$); }
|
||||
column_eq_value(A) ::= column_name(C) NK_EQ tags_literal(D). { A = createAlterSingleTagColumnNode(pCxt, &C, D); }
|
||||
column_eq_value_list(A) ::= column_eq_value(B). { A = createNodeList(pCxt, B); }
|
||||
column_eq_value_list(A) ::= column_eq_value_list(B) NK_COMMA column_eq_value(C). { A = addNodeToList(pCxt, B, C);}
|
||||
|
||||
alter_table_clause(A) ::=
|
||||
full_table_name(B) SET TAG column_name(C) NK_EQ tags_literal(D). { A = createAlterTableSetTag(pCxt, B, &C, D); }
|
||||
full_table_name(B) SET TAG column_eq_value_list(C). { A = createAlterTableSetMultiTagValue(pCxt, B, C); }
|
||||
|
||||
%type multi_create_clause { SNodeList* }
|
||||
%destructor multi_create_clause { nodesDestroyList($$); }
|
||||
|
|
|
|||
|
|
@ -2427,6 +2427,12 @@ static SNode* createAlterTableStmtFinalize(SNode* pRealTable, SAlterTableStmt* p
|
|||
nodesDestroyNode(pRealTable);
|
||||
return (SNode*)pStmt;
|
||||
}
|
||||
static SNode* createAlterTableMultiStmtFinalize(SNode* pRealTable, SAlterTableMultiStmt* pStmt) {
|
||||
strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName);
|
||||
strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName);
|
||||
nodesDestroyNode(pRealTable);
|
||||
return (SNode*)pStmt;
|
||||
}
|
||||
|
||||
SNode* createAlterTableModifyOptions(SAstCreateContext* pCxt, SNode* pRealTable, SNode* pOptions) {
|
||||
CHECK_PARSER_STATUS(pCxt);
|
||||
|
|
@ -2541,6 +2547,19 @@ _err:
|
|||
return NULL;
|
||||
}
|
||||
|
||||
SNode* createAlterSingleTagColumnNode(SAstCreateContext* pCtx, SToken* pTagName, SNode* pVal) {
|
||||
CHECK_PARSER_STATUS(pCtx);
|
||||
SAlterTableStmt* pStmt = NULL;
|
||||
pCtx->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt);
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
pStmt->alterType = TSDB_ALTER_TABLE_UPDATE_TAG_VAL;
|
||||
COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pTagName);
|
||||
pStmt->pVal = (SValueNode*)pVal;
|
||||
return (SNode*)pStmt;
|
||||
_err:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
SNode* createAlterTableSetTag(SAstCreateContext* pCxt, SNode* pRealTable, SToken* pTagName, SNode* pVal) {
|
||||
CHECK_PARSER_STATUS(pCxt);
|
||||
CHECK_NAME(checkColumnName(pCxt, pTagName));
|
||||
|
|
@ -2557,6 +2576,19 @@ _err:
|
|||
return NULL;
|
||||
}
|
||||
|
||||
SNode* createAlterTableSetMultiTagValue(SAstCreateContext* pCxt, SNode* pRealTable, SNodeList* pList) {
|
||||
CHECK_PARSER_STATUS(pCxt);
|
||||
SAlterTableStmt* pStmt = NULL;
|
||||
pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt);
|
||||
|
||||
CHECK_MAKE_NODE(pStmt);
|
||||
pStmt->alterType = TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL;
|
||||
pStmt->pNodeListTagValue = pList;
|
||||
return createAlterTableStmtFinalize(pRealTable, pStmt);
|
||||
_err:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
SNode* setAlterSuperTableType(SNode* pStmt) {
|
||||
if (!pStmt) return NULL;
|
||||
setNodeType(pStmt, QUERY_NODE_ALTER_SUPER_TABLE_STMT);
|
||||
|
|
|
|||
|
|
@ -239,7 +239,8 @@ static EDealRes collectMetaKeyFromOperator(SCollectMetaKeyFromExprCxt* pCxt, SOp
|
|||
if (TSDB_CODE_SUCCESS != code) return DEAL_RES_CONTINUE;
|
||||
if (pTableName) {
|
||||
SSelectStmt* pSelect = (SSelectStmt*)pCxt->pComCxt->pStmt;
|
||||
pCxt->errCode = collectMetaKeyFromRealTableImpl(pCxt->pComCxt, ((SRealTableNode*)pSelect->pFromTable)->table.dbName, pTableName, AUTH_TYPE_READ);
|
||||
pCxt->errCode = collectMetaKeyFromRealTableImpl(pCxt->pComCxt, ((SRealTableNode*)pSelect->pFromTable)->table.dbName,
|
||||
pTableName, AUTH_TYPE_READ);
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_CONTINUE : DEAL_RES_ERROR;
|
||||
|
|
@ -969,6 +970,7 @@ static int32_t collectMetaKeyFromQuery(SCollectMetaKeyCxt* pCxt, SNode* pStmt) {
|
|||
case QUERY_NODE_DROP_SUPER_TABLE_STMT:
|
||||
return collectMetaKeyFromDropStable(pCxt, (SDropSuperTableStmt*)pStmt);
|
||||
case QUERY_NODE_ALTER_TABLE_STMT:
|
||||
case QUERY_NODE_ALTER_TABLE_MULTI_STMT:
|
||||
return collectMetaKeyFromAlterTable(pCxt, (SAlterTableStmt*)pStmt);
|
||||
case QUERY_NODE_ALTER_SUPER_TABLE_STMT:
|
||||
return collectMetaKeyFromAlterStable(pCxt, (SAlterTableStmt*)pStmt);
|
||||
|
|
|
|||
|
|
@ -97,6 +97,7 @@ static const SSysTableShowAdapter sysTableShowAdapter[] = {
|
|||
.showType = QUERY_NODE_SHOW_DNODES_STMT,
|
||||
.pDbName = TSDB_INFORMATION_SCHEMA_DB,
|
||||
.pTableName = TSDB_INS_TABLE_DNODES,
|
||||
|
||||
.numOfShowCols = 1,
|
||||
.pShowCols = {"*"}
|
||||
},
|
||||
|
|
@ -1876,9 +1877,8 @@ static EDealRes translateColumnInGroupByClause(STranslateContext* pCxt, SColumnN
|
|||
} else {
|
||||
bool found = false;
|
||||
res = translateColumnWithoutPrefix(pCxt, pCol);
|
||||
if (!(*pCol)->node.asParam &&
|
||||
res != DEAL_RES_CONTINUE &&
|
||||
res != DEAL_RES_END && pCxt->errCode != TSDB_CODE_PAR_AMBIGUOUS_COLUMN) {
|
||||
if (!(*pCol)->node.asParam && res != DEAL_RES_CONTINUE && res != DEAL_RES_END &&
|
||||
pCxt->errCode != TSDB_CODE_PAR_AMBIGUOUS_COLUMN) {
|
||||
res = translateColumnUseAlias(pCxt, pCol, &found);
|
||||
*translateAsAlias = true;
|
||||
}
|
||||
|
|
@ -3321,9 +3321,11 @@ static int32_t selectCommonType(SDataType* commonType, const SDataType* newType)
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
if ((resultType == TSDB_DATA_TYPE_VARCHAR) && (IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) {
|
||||
if ((resultType == TSDB_DATA_TYPE_VARCHAR) &&
|
||||
(IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) {
|
||||
commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), QUERY_NUMBER_MAX_DISPLAY_LEN);
|
||||
} else if ((resultType == TSDB_DATA_TYPE_NCHAR) && (IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) {
|
||||
} else if ((resultType == TSDB_DATA_TYPE_NCHAR) &&
|
||||
(IS_MATHABLE_TYPE(commonType->type) || IS_MATHABLE_TYPE(newType->type))) {
|
||||
commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), QUERY_NUMBER_MAX_DISPLAY_LEN * TSDB_NCHAR_SIZE);
|
||||
} else {
|
||||
commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), TYPE_BYTES[resultType]);
|
||||
|
|
@ -5528,8 +5530,7 @@ static int32_t translateGroupByList(STranslateContext* pCxt, SSelectStmt* pSelec
|
|||
if (NULL == pSelect->pGroupByList) {
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
SReplaceGroupByAliasCxt cxt = {
|
||||
.pTranslateCxt = pCxt, .pProjectionList = pSelect->pProjectionList};
|
||||
SReplaceGroupByAliasCxt cxt = {.pTranslateCxt = pCxt, .pProjectionList = pSelect->pProjectionList};
|
||||
nodesRewriteExprsPostOrder(pSelect->pGroupByList, translateGroupPartitionByImpl, &cxt);
|
||||
|
||||
return pCxt->errCode;
|
||||
|
|
@ -5540,8 +5541,7 @@ static int32_t translatePartitionByList(STranslateContext* pCxt, SSelectStmt* pS
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
SReplaceGroupByAliasCxt cxt = {
|
||||
.pTranslateCxt = pCxt, .pProjectionList = pSelect->pProjectionList};
|
||||
SReplaceGroupByAliasCxt cxt = {.pTranslateCxt = pCxt, .pProjectionList = pSelect->pProjectionList};
|
||||
nodesRewriteExprsPostOrder(pSelect->pPartitionByList, translateGroupPartitionByImpl, &cxt);
|
||||
|
||||
return pCxt->errCode;
|
||||
|
|
@ -9495,7 +9495,8 @@ static int32_t checkAlterSuperTableBySchema(STranslateContext* pCxt, SAlterTable
|
|||
}
|
||||
|
||||
static int32_t checkAlterSuperTable(STranslateContext* pCxt, SAlterTableStmt* pStmt) {
|
||||
if (TSDB_ALTER_TABLE_UPDATE_TAG_VAL == pStmt->alterType) {
|
||||
if (TSDB_ALTER_TABLE_UPDATE_TAG_VAL == pStmt->alterType ||
|
||||
TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL == pStmt->alterType) {
|
||||
return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE,
|
||||
"Set tag value only available for child table");
|
||||
}
|
||||
|
|
@ -10521,7 +10522,8 @@ static void getSourceDatabase(SNode* pStmt, int32_t acctId, char* pDbFName) {
|
|||
(void)tNameGetFullDbName(&name, pDbFName);
|
||||
}
|
||||
|
||||
static void getStreamQueryFirstProjectAliasName(SHashObj* pUserAliasSet, char* aliasName, int32_t len, char* defaultName[]) {
|
||||
static void getStreamQueryFirstProjectAliasName(SHashObj* pUserAliasSet, char* aliasName, int32_t len,
|
||||
char* defaultName[]) {
|
||||
for (int32_t i = 0; defaultName[i] != NULL; i++) {
|
||||
if (NULL == taosHashGet(pUserAliasSet, defaultName[i], strlen(defaultName[i]))) {
|
||||
snprintf(aliasName, len, "%s", defaultName[i]);
|
||||
|
|
@ -10547,8 +10549,8 @@ static int32_t setColumnDefNodePrimaryKey(SColumnDefNode* pNode, bool isPk) {
|
|||
return code;
|
||||
}
|
||||
|
||||
static int32_t addIrowTsToCreateStreamQueryImpl(STranslateContext* pCxt, SSelectStmt* pSelect,
|
||||
SHashObj* pUserAliasSet, SNodeList* pCols, SCMCreateStreamReq* pReq) {
|
||||
static int32_t addIrowTsToCreateStreamQueryImpl(STranslateContext* pCxt, SSelectStmt* pSelect, SHashObj* pUserAliasSet,
|
||||
SNodeList* pCols, SCMCreateStreamReq* pReq) {
|
||||
SNode* pProj = nodesListGetNode(pSelect->pProjectionList, 0);
|
||||
if (!pSelect->hasInterpFunc ||
|
||||
(QUERY_NODE_FUNCTION == nodeType(pProj) && 0 == strcmp("_irowts", ((SFunctionNode*)pProj)->functionName))) {
|
||||
|
|
@ -10990,20 +10992,17 @@ static int32_t checkStreamQuery(STranslateContext* pCxt, SCreateStreamStmt* pStm
|
|||
|
||||
if (pStmt->pOptions->triggerType == STREAM_TRIGGER_FORCE_WINDOW_CLOSE) {
|
||||
if (pStmt->pOptions->fillHistory) {
|
||||
return generateSyntaxErrMsgExt(
|
||||
&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
|
||||
return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
|
||||
"When trigger was force window close, Stream unsupported Fill history");
|
||||
}
|
||||
|
||||
if (pStmt->pOptions->ignoreExpired != 1) {
|
||||
return generateSyntaxErrMsgExt(
|
||||
&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
|
||||
return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
|
||||
"When trigger was force window close, Stream must not set ignore expired 0");
|
||||
}
|
||||
|
||||
if (pStmt->pOptions->ignoreUpdate != 1) {
|
||||
return generateSyntaxErrMsgExt(
|
||||
&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
|
||||
return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY,
|
||||
"When trigger was force window close, Stream must not set ignore update 0");
|
||||
}
|
||||
|
||||
|
|
@ -15183,24 +15182,90 @@ static int32_t rewriteDropSuperTable(STranslateContext* pCxt, SQuery* pQuery) {
|
|||
TAOS_RETURN(0);
|
||||
}
|
||||
|
||||
static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
|
||||
SVAlterTbReq* pReq) {
|
||||
SName tbName = {0};
|
||||
SArray* pTsmas = NULL;
|
||||
static int32_t buildUpdateTagValReqImpl2(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
|
||||
char* colName, SMultiTagUpateVal* pReq) {
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
if (pCxt->pMetaCache) {
|
||||
toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName);
|
||||
code = getTableTsmasFromCache(pCxt->pMetaCache, &tbName, &pTsmas);
|
||||
if (code != TSDB_CODE_SUCCESS) return code;
|
||||
if (pTsmas && pTsmas->size > 0) return TSDB_CODE_TSMA_MUST_BE_DROPPED;
|
||||
if (NULL == pReq->tagName) {
|
||||
return terrno;
|
||||
}
|
||||
|
||||
SSchema* pSchema = getTagSchema(pTableMeta, pStmt->colName);
|
||||
SSchema* pSchema = getTagSchema(pTableMeta, colName);
|
||||
if (NULL == pSchema) {
|
||||
return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE, "Invalid tag name: %s",
|
||||
pStmt->colName);
|
||||
return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE, "Invalid tag name: %s", colName);
|
||||
}
|
||||
pReq->tagName = taosStrdup(pStmt->colName);
|
||||
|
||||
pReq->tagName = taosStrdup(colName);
|
||||
if (NULL == pReq->tagName) {
|
||||
return terrno;
|
||||
}
|
||||
pReq->pTagArray = taosArrayInit(1, sizeof(STagVal));
|
||||
if (NULL == pReq->pTagArray) {
|
||||
return terrno;
|
||||
}
|
||||
pReq->colId = pSchema->colId;
|
||||
pReq->tagType = pSchema->type;
|
||||
|
||||
STag* pTag = NULL;
|
||||
SToken token;
|
||||
char tokenBuf[TSDB_MAX_TAGS_LEN];
|
||||
const char* tagStr = pStmt->pVal->literal;
|
||||
NEXT_TOKEN_WITH_PREV(tagStr, token);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = checkAndTrimValue(&token, tokenBuf, &pCxt->msgBuf, pSchema->type);
|
||||
if (TSDB_CODE_SUCCESS == code && TK_NK_VARIABLE == token.type) {
|
||||
code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values", token.z);
|
||||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = parseTagValue(&pCxt->msgBuf, &tagStr, pTableMeta->tableInfo.precision, pSchema, &token, NULL,
|
||||
pReq->pTagArray, &pTag);
|
||||
if (pSchema->type == TSDB_DATA_TYPE_JSON && token.type == TK_NULL && code == TSDB_CODE_SUCCESS) {
|
||||
pReq->tagFree = true;
|
||||
}
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code && tagStr) {
|
||||
NEXT_VALID_TOKEN(tagStr, token);
|
||||
if (token.n != 0) {
|
||||
code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values", token.z);
|
||||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
if (pSchema->type == TSDB_DATA_TYPE_JSON) {
|
||||
code = buildSyntaxErrMsg(&pCxt->msgBuf, "not expected tags values ", token.z);
|
||||
} else {
|
||||
STagVal* pTagVal = taosArrayGet(pReq->pTagArray, 0);
|
||||
if (pTagVal) {
|
||||
pReq->isNull = false;
|
||||
if (IS_VAR_DATA_TYPE(pSchema->type)) {
|
||||
pReq->nTagVal = pTagVal->nData;
|
||||
pReq->pTagVal = pTagVal->pData;
|
||||
} else {
|
||||
pReq->nTagVal = pSchema->bytes;
|
||||
pReq->pTagVal = (uint8_t*)&pTagVal->i64;
|
||||
}
|
||||
} else {
|
||||
pReq->isNull = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
static int32_t buildUpdateTagValReqImpl(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
|
||||
char* colName, SVAlterTbReq* pReq) {
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
// if (NULL == pReq->tagName) {
|
||||
// return terrno;
|
||||
// }
|
||||
|
||||
SSchema* pSchema = getTagSchema(pTableMeta, colName);
|
||||
if (NULL == pSchema) {
|
||||
return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE, "Invalid tag name: %s", colName);
|
||||
}
|
||||
|
||||
pReq->tagName = taosStrdup(colName);
|
||||
if (NULL == pReq->tagName) {
|
||||
return terrno;
|
||||
}
|
||||
|
|
@ -15261,6 +15326,62 @@ static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pS
|
|||
|
||||
return code;
|
||||
}
|
||||
static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
|
||||
SVAlterTbReq* pReq) {
|
||||
SName tbName = {0};
|
||||
SArray* pTsmas = NULL;
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
if (pCxt->pMetaCache) {
|
||||
toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName);
|
||||
code = getTableTsmasFromCache(pCxt->pMetaCache, &tbName, &pTsmas);
|
||||
if (code != TSDB_CODE_SUCCESS) return code;
|
||||
if (pTsmas && pTsmas->size > 0) return TSDB_CODE_TSMA_MUST_BE_DROPPED;
|
||||
}
|
||||
return buildUpdateTagValReqImpl(pCxt, pStmt, pTableMeta, pStmt->colName, pReq);
|
||||
}
|
||||
|
||||
static int32_t buildUpdateMultiTagValReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
|
||||
SVAlterTbReq* pReq) {
|
||||
SName tbName = {0};
|
||||
SArray* pTsmas = NULL;
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
if (pCxt->pMetaCache) {
|
||||
toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName);
|
||||
code = getTableTsmasFromCache(pCxt->pMetaCache, &tbName, &pTsmas);
|
||||
if (code != TSDB_CODE_SUCCESS) return code;
|
||||
if (pTsmas && pTsmas->size > 0) return TSDB_CODE_TSMA_MUST_BE_DROPPED;
|
||||
}
|
||||
SNodeList* pNodeList = pStmt->pNodeListTagValue;
|
||||
if (pNodeList == NULL) {
|
||||
return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE);
|
||||
}
|
||||
|
||||
int32_t nTagValues = pNodeList->length;
|
||||
if (nTagValues == 1) {
|
||||
SAlterTableStmt* head = (SAlterTableStmt*)pNodeList->pHead->pNode;
|
||||
pReq->action = TSDB_ALTER_TABLE_UPDATE_TAG_VAL;
|
||||
return buildUpdateTagValReqImpl(pCxt, head, pTableMeta, head->colName, pReq);
|
||||
} else {
|
||||
pReq->pMultiTag = taosArrayInit(nTagValues, sizeof(SMultiTagUpateVal));
|
||||
if (NULL == pReq->pTagArray) {
|
||||
return terrno;
|
||||
}
|
||||
|
||||
SAlterTableStmt* pTagStmt = NULL;
|
||||
SNode* pNode = NULL;
|
||||
FOREACH(pNode, pNodeList) {
|
||||
SMultiTagUpateVal val;
|
||||
pTagStmt = (SAlterTableStmt*)pNode;
|
||||
code = buildUpdateTagValReqImpl2(pCxt, pTagStmt, pTableMeta, pTagStmt->colName, &val);
|
||||
if (TSDB_CODE_SUCCESS != code) {
|
||||
return code;
|
||||
}
|
||||
TAOS_UNUSED(taosArrayPush(pReq->pMultiTag, &val));
|
||||
}
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
static int32_t buildAddColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
|
||||
SVAlterTbReq* pReq) {
|
||||
|
|
@ -15449,6 +15570,8 @@ static int32_t buildAlterTbReq(STranslateContext* pCxt, SAlterTableStmt* pStmt,
|
|||
case TSDB_ALTER_TABLE_UPDATE_TAG_NAME:
|
||||
case TSDB_ALTER_TABLE_UPDATE_TAG_BYTES:
|
||||
return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE);
|
||||
case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL:
|
||||
return buildUpdateMultiTagValReq(pCxt, pStmt, pTableMeta, pReq);
|
||||
case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:
|
||||
return buildUpdateTagValReq(pCxt, pStmt, pTableMeta, pReq);
|
||||
case TSDB_ALTER_TABLE_ADD_COLUMN:
|
||||
|
|
@ -16254,6 +16377,7 @@ static int32_t rewriteQuery(STranslateContext* pCxt, SQuery* pQuery) {
|
|||
case QUERY_NODE_DROP_SUPER_TABLE_STMT:
|
||||
code = rewriteDropSuperTable(pCxt, pQuery);
|
||||
break;
|
||||
case QUERY_NODE_ALTER_TABLE_MULTI_STMT:
|
||||
case QUERY_NODE_ALTER_TABLE_STMT:
|
||||
code = rewriteAlterTable(pCxt, pQuery);
|
||||
break;
|
||||
|
|
|
|||
Loading…
Reference in New Issue