mirror of
https://github.com/taosdata/TDengine
synced 2026-05-24 10:09:01 +00:00
c2256e9443
Add the AUTO keyword, which allows automatic determination of the INTERVAL OFFSET based on the WHERE condition. It simplifies usage by allowing users to rely on the system to infer the correct offset without manual specification.
334 lines
12 KiB
C++
334 lines
12 KiB
C++
/*
|
|
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
|
*
|
|
* This program is free software: you can use, redistribute, AND/or modify
|
|
* it under the terms of the GNU Affero General Public License, version 3
|
|
* or later ("AGPL"), as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "nodes.h"
|
|
#include "plannodes.h"
|
|
#include "querynodes.h"
|
|
|
|
class NodesCloneTest : public testing::Test {
|
|
public:
|
|
void registerCheckFunc(const std::function<void(const SNode*, const SNode*)>& func) { checkFunc_ = func; }
|
|
|
|
void run(const SNode* pSrc) {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesCloneNode(pSrc, &pNew);
|
|
std::unique_ptr<SNode, void (*)(SNode*)> pDst(pNew, nodesDestroyNode);
|
|
checkFunc_(pSrc, pDst.get());
|
|
}
|
|
|
|
private:
|
|
std::function<void(const SNode*, const SNode*)> checkFunc_;
|
|
};
|
|
|
|
TEST_F(NodesCloneTest, tempTable) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
STempTableNode* pSrcNode = (STempTableNode*)pSrc;
|
|
STempTableNode* pDstNode = (STempTableNode*)pDst;
|
|
ASSERT_EQ(nodeType(pSrcNode->pSubquery), nodeType(pDstNode->pSubquery));
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_TEMP_TABLE, &pNew);
|
|
srcNode.reset(pNew);
|
|
STempTableNode* pNode = (STempTableNode*)srcNode.get();
|
|
pNew = NULL;
|
|
code = nodesMakeNode(QUERY_NODE_SELECT_STMT, &pNew);
|
|
pNode->pSubquery = pNew;
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, joinTable) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SJoinTableNode* pSrcNode = (SJoinTableNode*)pSrc;
|
|
SJoinTableNode* pDstNode = (SJoinTableNode*)pDst;
|
|
ASSERT_EQ(pSrcNode->joinType, pDstNode->joinType);
|
|
ASSERT_EQ(nodeType(pSrcNode->pLeft), nodeType(pDstNode->pLeft));
|
|
ASSERT_EQ(nodeType(pSrcNode->pRight), nodeType(pDstNode->pRight));
|
|
if (NULL != pSrcNode->pOnCond) {
|
|
ASSERT_EQ(nodeType(pSrcNode->pOnCond), nodeType(pDstNode->pOnCond));
|
|
}
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_JOIN_TABLE, &pNew);
|
|
srcNode.reset(pNew);
|
|
SJoinTableNode* pNode = (SJoinTableNode*)srcNode.get();
|
|
pNode->joinType = JOIN_TYPE_INNER;
|
|
code = nodesMakeNode(QUERY_NODE_REAL_TABLE, &pNode->pLeft);
|
|
code = nodesMakeNode(QUERY_NODE_REAL_TABLE, &pNode->pRight);
|
|
code = nodesMakeNode(QUERY_NODE_OPERATOR, &pNode->pOnCond);
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, stateWindow) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SStateWindowNode* pSrcNode = (SStateWindowNode*)pSrc;
|
|
SStateWindowNode* pDstNode = (SStateWindowNode*)pDst;
|
|
ASSERT_EQ(nodeType(pSrcNode->pCol), nodeType(pDstNode->pCol));
|
|
ASSERT_EQ(nodeType(pSrcNode->pExpr), nodeType(pDstNode->pExpr));
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_STATE_WINDOW, &pNew);
|
|
srcNode.reset(pNew);
|
|
SStateWindowNode* pNode = (SStateWindowNode*)srcNode.get();
|
|
code = nodesMakeNode(QUERY_NODE_COLUMN, &pNode->pCol);
|
|
code = nodesMakeNode(QUERY_NODE_OPERATOR, &pNode->pExpr);
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, sessionWindow) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SSessionWindowNode* pSrcNode = (SSessionWindowNode*)pSrc;
|
|
SSessionWindowNode* pDstNode = (SSessionWindowNode*)pDst;
|
|
ASSERT_EQ(nodeType(pSrcNode->pCol), nodeType(pDstNode->pCol));
|
|
ASSERT_EQ(nodeType(pSrcNode->pGap), nodeType(pDstNode->pGap));
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_SESSION_WINDOW, &pNew);
|
|
srcNode.reset(pNew);
|
|
SSessionWindowNode* pNode = (SSessionWindowNode*)srcNode.get();
|
|
code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pNode->pCol);
|
|
code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pNode->pGap);
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, intervalWindow) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SIntervalWindowNode* pSrcNode = (SIntervalWindowNode*)pSrc;
|
|
SIntervalWindowNode* pDstNode = (SIntervalWindowNode*)pDst;
|
|
ASSERT_EQ(nodeType(pSrcNode->pInterval), nodeType(pDstNode->pInterval));
|
|
if (NULL != pSrcNode->pOffset) {
|
|
ASSERT_EQ(nodeType(pSrcNode->pOffset), nodeType(pDstNode->pOffset));
|
|
}
|
|
if (NULL != pSrcNode->pSliding) {
|
|
ASSERT_EQ(nodeType(pSrcNode->pSliding), nodeType(pDstNode->pSliding));
|
|
}
|
|
if (NULL != pSrcNode->pFill) {
|
|
ASSERT_EQ(nodeType(pSrcNode->pFill), nodeType(pDstNode->pFill));
|
|
}
|
|
ASSERT_EQ(pSrcNode->timeRange.skey, pDstNode->timeRange.skey);
|
|
ASSERT_EQ(pSrcNode->timeRange.ekey, pDstNode->timeRange.ekey);
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW, &pNew);
|
|
srcNode.reset(pNew);
|
|
SIntervalWindowNode* pNode = (SIntervalWindowNode*)srcNode.get();
|
|
code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pInterval);
|
|
code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pOffset);
|
|
code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pSliding);
|
|
code = nodesMakeNode(QUERY_NODE_FILL, &pNode->pFill);
|
|
pNode->timeRange.skey = 1666756692907;
|
|
pNode->timeRange.ekey = 1666756699907;
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, fill) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SFillNode* pSrcNode = (SFillNode*)pSrc;
|
|
SFillNode* pDstNode = (SFillNode*)pDst;
|
|
ASSERT_EQ(pSrcNode->mode, pDstNode->mode);
|
|
if (NULL != pSrcNode->pValues) {
|
|
ASSERT_EQ(nodeType(pSrcNode->pValues), nodeType(pDstNode->pValues));
|
|
}
|
|
ASSERT_EQ(nodeType(pSrcNode->pWStartTs), nodeType(pDstNode->pWStartTs));
|
|
ASSERT_EQ(pSrcNode->timeRange.skey, pDstNode->timeRange.skey);
|
|
ASSERT_EQ(pSrcNode->timeRange.ekey, pDstNode->timeRange.ekey);
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_FILL, &pNew);
|
|
srcNode.reset(pNew);
|
|
SFillNode* pNode = (SFillNode*)srcNode.get();
|
|
pNode->mode = FILL_MODE_VALUE;
|
|
code = nodesMakeNode(QUERY_NODE_NODE_LIST, &pNode->pValues);
|
|
code = nodesMakeNode(QUERY_NODE_COLUMN, &pNode->pWStartTs);
|
|
pNode->timeRange.skey = 1666756692907;
|
|
pNode->timeRange.ekey = 1666756699907;
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, logicSubplan) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SLogicSubplan* pSrcNode = (SLogicSubplan*)pSrc;
|
|
SLogicSubplan* pDstNode = (SLogicSubplan*)pDst;
|
|
ASSERT_EQ(pSrcNode->subplanType, pDstNode->subplanType);
|
|
ASSERT_EQ(pSrcNode->level, pDstNode->level);
|
|
ASSERT_EQ(pSrcNode->splitFlag, pDstNode->splitFlag);
|
|
ASSERT_EQ(pSrcNode->numOfComputeNodes, pDstNode->numOfComputeNodes);
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, &pNew);
|
|
srcNode.reset(pNew);
|
|
SLogicSubplan* pNode = (SLogicSubplan*)srcNode.get();
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, physiScan) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
STagScanPhysiNode* pSrcNode = (STagScanPhysiNode*)pSrc;
|
|
STagScanPhysiNode* pDstNode = (STagScanPhysiNode*)pDst;
|
|
ASSERT_EQ(pSrcNode->scan.uid, pDstNode->scan.uid);
|
|
ASSERT_EQ(pSrcNode->scan.suid, pDstNode->scan.suid);
|
|
ASSERT_EQ(pSrcNode->scan.tableType, pDstNode->scan.tableType);
|
|
ASSERT_EQ(pSrcNode->onlyMetaCtbIdx, pDstNode->onlyMetaCtbIdx);
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = nullptr;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, &pNew);
|
|
srcNode.reset(pNew);
|
|
STagScanPhysiNode* pNode = (STagScanPhysiNode*)srcNode.get();
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, physiSystemTableScan) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SSystemTableScanPhysiNode* pSrcNode = (SSystemTableScanPhysiNode*)pSrc;
|
|
SSystemTableScanPhysiNode* pDstNode = (SSystemTableScanPhysiNode*)pDst;
|
|
ASSERT_EQ(pSrcNode->showRewrite, pDstNode->showRewrite);
|
|
ASSERT_EQ(pSrcNode->accountId, pDstNode->accountId);
|
|
ASSERT_EQ(pSrcNode->sysInfo, pDstNode->sysInfo);
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN, &pNew);
|
|
srcNode.reset(pNew);
|
|
SSystemTableScanPhysiNode* pNode = (SSystemTableScanPhysiNode*)srcNode.get();
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, physiStreamSemiSessionWinodw) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SStreamSemiSessionWinodwPhysiNode* pSrcNode = (SStreamSemiSessionWinodwPhysiNode*)pSrc;
|
|
SStreamSemiSessionWinodwPhysiNode* pDstNode = (SStreamSemiSessionWinodwPhysiNode*)pDst;
|
|
ASSERT_EQ(pSrcNode->gap, pDstNode->gap);
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION, &pNew);
|
|
srcNode.reset(pNew);
|
|
SStreamSemiSessionWinodwPhysiNode* pNode = (SStreamSemiSessionWinodwPhysiNode*)srcNode.get();
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, physiStreamFinalSessionWinodw) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SStreamFinalSessionWinodwPhysiNode* pSrcNode = (SStreamFinalSessionWinodwPhysiNode*)pSrc;
|
|
SStreamFinalSessionWinodwPhysiNode* pDstNode = (SStreamFinalSessionWinodwPhysiNode*)pDst;
|
|
ASSERT_EQ(pSrcNode->gap, pDstNode->gap);
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION, &pNew);
|
|
srcNode.reset(pNew);
|
|
SStreamFinalSessionWinodwPhysiNode* pNode = (SStreamFinalSessionWinodwPhysiNode*)srcNode.get();
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, physiStreamPartition) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SStreamPartitionPhysiNode* pSrcNode = (SStreamPartitionPhysiNode*)pSrc;
|
|
SStreamPartitionPhysiNode* pDstNode = (SStreamPartitionPhysiNode*)pDst;
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION, &pNew);
|
|
srcNode.reset(pNew);
|
|
SStreamPartitionPhysiNode* pNode = (SStreamPartitionPhysiNode*)srcNode.get();
|
|
return srcNode.get();
|
|
}());
|
|
}
|
|
|
|
TEST_F(NodesCloneTest, physiPartition) {
|
|
registerCheckFunc([](const SNode* pSrc, const SNode* pDst) {
|
|
ASSERT_EQ(nodeType(pSrc), nodeType(pDst));
|
|
SPartitionPhysiNode* pSrcNode = (SPartitionPhysiNode*)pSrc;
|
|
SPartitionPhysiNode* pDstNode = (SPartitionPhysiNode*)pDst;
|
|
});
|
|
|
|
std::unique_ptr<SNode, void (*)(SNode*)> srcNode(nullptr, nodesDestroyNode);
|
|
|
|
run([&]() {
|
|
SNode* pNew = NULL;
|
|
int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_PARTITION, &pNew);
|
|
srcNode.reset(pNew);
|
|
SPartitionPhysiNode* pNode = (SPartitionPhysiNode*)srcNode.get();
|
|
return srcNode.get();
|
|
}());
|
|
}
|