Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
taosdata
TDengine
提交
8b7f0f3a
TDengine
项目概览
taosdata
/
TDengine
12 个月 前同步成功
通知
1180
Star
22014
Fork
4786
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
1
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
TDengine
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
1
Issue
1
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
8b7f0f3a
编写于
5月 17, 2022
作者:
S
Shengliang Guan
浏览文件
操作
浏览文件
下载
差异文件
Merge remote-tracking branch 'origin/3.0' into fix/mnode
上级
75fd35c9
9093c04a
变更
11
隐藏空白更改
内联
并排
Showing
11 changed file
with
471 addition
and
246 deletion
+471
-246
include/libs/nodes/nodes.h
include/libs/nodes/nodes.h
+1
-0
include/libs/nodes/querynodes.h
include/libs/nodes/querynodes.h
+2
-1
source/libs/executor/src/scanoperator.c
source/libs/executor/src/scanoperator.c
+11
-5
source/libs/nodes/src/nodesCloneFuncs.c
source/libs/nodes/src/nodesCloneFuncs.c
+114
-89
source/libs/nodes/src/nodesEqualFuncs.c
source/libs/nodes/src/nodesEqualFuncs.c
+48
-1
source/libs/nodes/src/nodesUtilFuncs.c
source/libs/nodes/src/nodesUtilFuncs.c
+108
-108
source/libs/parser/src/parAstCreater.c
source/libs/parser/src/parAstCreater.c
+2
-0
source/libs/parser/src/parTranslater.c
source/libs/parser/src/parTranslater.c
+5
-1
source/libs/parser/src/parser.c
source/libs/parser/src/parser.c
+40
-1
source/libs/planner/test/planStmtTest.cpp
source/libs/planner/test/planStmtTest.cpp
+119
-21
source/libs/planner/test/planTestUtil.cpp
source/libs/planner/test/planTestUtil.cpp
+21
-19
未找到文件。
include/libs/nodes/nodes.h
浏览文件 @
8b7f0f3a
...
...
@@ -240,6 +240,7 @@ typedef struct SNodeList {
#define SNodeptr void*
int32_t
nodesNodeSize
(
ENodeType
type
);
SNodeptr
nodesMakeNode
(
ENodeType
type
);
void
nodesDestroyNode
(
SNodeptr
pNode
);
...
...
include/libs/nodes/querynodes.h
浏览文件 @
8b7f0f3a
...
...
@@ -48,6 +48,7 @@ typedef struct SExprNode {
ENodeType
type
;
SDataType
resType
;
char
aliasName
[
TSDB_COL_NAME_LEN
];
char
userAlias
[
TSDB_COL_NAME_LEN
];
SArray
*
pAssociation
;
}
SExprNode
;
...
...
@@ -325,7 +326,7 @@ typedef struct SQuery {
bool
showRewrite
;
int32_t
placeholderNum
;
SArray
*
pPlaceholderValues
;
SNode
*
p
ContainPlaceholder
Root
;
SNode
*
p
Prepare
Root
;
}
SQuery
;
void
nodesWalkSelectStmt
(
SSelectStmt
*
pSelect
,
ESqlClause
clause
,
FNodeWalker
walker
,
void
*
pContext
);
...
...
source/libs/executor/src/scanoperator.c
浏览文件 @
8b7f0f3a
...
...
@@ -658,12 +658,18 @@ static SSDataBlock* getUpdateDataBlock(SStreamBlockScanInfo* pInfo, bool inverti
// p->info.type = STREAM_INVERT;
// taosArrayClear(pInfo->tsArray);
// return p;
SSDataBlock
*
p
=
createOneDataBlock
(
pInfo
->
pRes
,
false
);
taosArraySet
(
p
->
pDataBlock
,
0
,
pInfo
->
tsArray
);
p
->
info
.
rows
=
size
;
p
->
info
.
type
=
STREAM_REPROCESS
;
SSDataBlock
*
pDataBlock
=
createOneDataBlock
(
pInfo
->
pRes
,
false
);
SColumnInfoData
*
pCol
=
(
SColumnInfoData
*
)
taosArrayGet
(
pDataBlock
->
pDataBlock
,
0
);
ASSERT
(
pCol
->
info
.
type
==
TSDB_DATA_TYPE_TIMESTAMP
);
colInfoDataEnsureCapacity
(
pCol
,
0
,
size
);
for
(
int32_t
i
=
0
;
i
<
size
;
i
++
)
{
TSKEY
*
pTs
=
(
TSKEY
*
)
taosArrayGet
(
pInfo
->
tsArray
,
i
);
colDataAppend
(
pCol
,
i
,
(
char
*
)
pTs
,
false
);
}
pDataBlock
->
info
.
rows
=
size
;
pDataBlock
->
info
.
type
=
STREAM_REPROCESS
;
taosArrayClear
(
pInfo
->
tsArray
);
return
p
;
return
p
DataBlock
;
}
return
NULL
;
}
...
...
source/libs/nodes/src/nodesCloneFuncs.c
浏览文件 @
8b7f0f3a
...
...
@@ -19,21 +19,6 @@
#include "taos.h"
#include "taoserror.h"
#define COPY_ALL_SCALAR_FIELDS \
do { \
memcpy((pDst), (pSrc), sizeof(*pSrc)); \
} while (0)
#define COPY_SCALAR_FIELD(fldname) \
do { \
(pDst)->fldname = (pSrc)->fldname; \
} while (0)
#define COPY_CHAR_ARRAY_FIELD(fldname) \
do { \
strcpy((pDst)->fldname, (pSrc)->fldname); \
} while (0)
#define COPY_CHAR_POINT_FIELD(fldname) \
do { \
if (NULL == (pSrc)->fldname) { \
...
...
@@ -85,34 +70,22 @@
} \
} while (0)
static
void
dataTypeCopy
(
const
SDataType
*
pSrc
,
SDataType
*
pDst
)
{
COPY_SCALAR_FIELD
(
type
);
COPY_SCALAR_FIELD
(
precision
);
COPY_SCALAR_FIELD
(
scale
);
COPY_SCALAR_FIELD
(
bytes
);
}
static
void
dataTypeCopy
(
const
SDataType
*
pSrc
,
SDataType
*
pDst
)
{}
static
void
exprNodeCopy
(
const
SExprNode
*
pSrc
,
SExprNode
*
pDst
)
{
static
SNode
*
exprNodeCopy
(
const
SExprNode
*
pSrc
,
SExprNode
*
pDst
)
{
dataTypeCopy
(
&
pSrc
->
resType
,
&
pDst
->
resType
);
COPY_CHAR_ARRAY_FIELD
(
aliasName
);
pDst
->
pAssociation
=
NULL
;
return
(
SNode
*
)
pDst
;
}
static
SNode
*
columnNodeCopy
(
const
SColumnNode
*
pSrc
,
SColumnNode
*
pDst
)
{
exprNodeCopy
((
const
SExprNode
*
)
pSrc
,
(
SExprNode
*
)
pDst
);
COPY_SCALAR_FIELD
(
colId
);
COPY_SCALAR_FIELD
(
colType
);
COPY_CHAR_ARRAY_FIELD
(
dbName
);
COPY_CHAR_ARRAY_FIELD
(
tableName
);
COPY_CHAR_ARRAY_FIELD
(
tableAlias
);
COPY_CHAR_ARRAY_FIELD
(
colName
);
COPY_SCALAR_FIELD
(
dataBlockId
);
COPY_SCALAR_FIELD
(
slotId
);
COPY_BASE_OBJECT_FIELD
(
node
,
exprNodeCopy
);
pDst
->
pProjectRef
=
NULL
;
return
(
SNode
*
)
pDst
;
}
static
SNode
*
valueNodeCopy
(
const
SValueNode
*
pSrc
,
SValueNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
exprNodeCopy
((
const
SExprNode
*
)
pSrc
,
(
SExprNode
*
)
pDst
);
COPY_BASE_OBJECT_FIELD
(
node
,
exprNodeCopy
);
COPY_CHAR_POINT_FIELD
(
literal
);
if
(
!
pSrc
->
translate
)
{
return
(
SNode
*
)
pDst
;
...
...
@@ -139,57 +112,114 @@ static SNode* valueNodeCopy(const SValueNode* pSrc, SValueNode* pDst) {
}
static
SNode
*
operatorNodeCopy
(
const
SOperatorNode
*
pSrc
,
SOperatorNode
*
pDst
)
{
exprNodeCopy
((
const
SExprNode
*
)
pSrc
,
(
SExprNode
*
)
pDst
);
COPY_SCALAR_FIELD
(
opType
);
COPY_BASE_OBJECT_FIELD
(
node
,
exprNodeCopy
);
CLONE_NODE_FIELD
(
pLeft
);
CLONE_NODE_FIELD
(
pRight
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
logicConditionNodeCopy
(
const
SLogicConditionNode
*
pSrc
,
SLogicConditionNode
*
pDst
)
{
exprNodeCopy
((
const
SExprNode
*
)
pSrc
,
(
SExprNode
*
)
pDst
);
COPY_SCALAR_FIELD
(
condType
);
COPY_BASE_OBJECT_FIELD
(
node
,
exprNodeCopy
);
CLONE_NODE_LIST_FIELD
(
pParameterList
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
functionNodeCopy
(
const
SFunctionNode
*
pSrc
,
SFunctionNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
exprNodeCopy
((
const
SExprNode
*
)
pSrc
,
(
SExprNode
*
)
pDst
);
COPY_CHAR_ARRAY_FIELD
(
functionName
);
COPY_SCALAR_FIELD
(
funcId
);
COPY_SCALAR_FIELD
(
funcType
);
COPY_BASE_OBJECT_FIELD
(
node
,
exprNodeCopy
);
CLONE_NODE_LIST_FIELD
(
pParameterList
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
tableNodeCopy
(
const
STableNode
*
pSrc
,
STableNode
*
pDst
)
{
COPY_BASE_OBJECT_FIELD
(
node
,
exprNodeCopy
);
return
(
SNode
*
)
pDst
;
}
static
STableMeta
*
tableMetaClone
(
const
STableMeta
*
pSrc
)
{
int32_t
len
=
TABLE_META_SIZE
(
pSrc
);
STableMeta
*
pDst
=
taosMemoryMalloc
(
len
);
if
(
NULL
==
pDst
)
{
return
NULL
;
}
memcpy
(
pDst
,
pSrc
,
len
);
return
pDst
;
}
static
SVgroupsInfo
*
vgroupsInfoClone
(
const
SVgroupsInfo
*
pSrc
)
{
int32_t
len
=
VGROUPS_INFO_SIZE
(
pSrc
);
SVgroupsInfo
*
pDst
=
taosMemoryMalloc
(
len
);
if
(
NULL
==
pDst
)
{
return
NULL
;
}
memcpy
(
pDst
,
pSrc
,
len
);
return
pDst
;
}
static
SNode
*
realTableNodeCopy
(
const
SRealTableNode
*
pSrc
,
SRealTableNode
*
pDst
)
{
COPY_BASE_OBJECT_FIELD
(
table
,
tableNodeCopy
);
CLONE_OBJECT_FIELD
(
pMeta
,
tableMetaClone
);
CLONE_OBJECT_FIELD
(
pVgroupList
,
vgroupsInfoClone
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
tempTableNodeCopy
(
const
STempTableNode
*
pSrc
,
STempTableNode
*
pDst
)
{
COPY_BASE_OBJECT_FIELD
(
table
,
tableNodeCopy
);
CLONE_NODE_FIELD
(
pSubquery
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
joinTableNodeCopy
(
const
SJoinTableNode
*
pSrc
,
SJoinTableNode
*
pDst
)
{
COPY_BASE_OBJECT_FIELD
(
table
,
tableNodeCopy
);
CLONE_NODE_FIELD
(
pLeft
);
CLONE_NODE_FIELD
(
pRight
);
CLONE_NODE_FIELD
(
pOnCond
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
targetNodeCopy
(
const
STargetNode
*
pSrc
,
STargetNode
*
pDst
)
{
COPY_SCALAR_FIELD
(
dataBlockId
);
COPY_SCALAR_FIELD
(
slotId
);
CLONE_NODE_FIELD
(
pExpr
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
groupingSetNodeCopy
(
const
SGroupingSetNode
*
pSrc
,
SGroupingSetNode
*
pDst
)
{
COPY_SCALAR_FIELD
(
groupingSetType
);
CLONE_NODE_LIST_FIELD
(
pParameterList
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
orderByExprNodeCopy
(
const
SOrderByExprNode
*
pSrc
,
SOrderByExprNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
CLONE_NODE_FIELD
(
pExpr
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
limitNodeCopy
(
const
SLimitNode
*
pSrc
,
SLimitNode
*
pDst
)
{
return
(
SNode
*
)
pDst
;
}
static
SNode
*
stateWindowNodeCopy
(
const
SStateWindowNode
*
pSrc
,
SStateWindowNode
*
pDst
)
{
CLONE_NODE_FIELD
(
pCol
);
CLONE_NODE_FIELD
(
pExpr
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
sessionWindowNodeCopy
(
const
SSessionWindowNode
*
pSrc
,
SSessionWindowNode
*
pDst
)
{
CLONE_NODE_FIELD
(
pCol
);
CLONE_NODE_FIELD
(
pGap
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
intervalWindowNodeCopy
(
const
SIntervalWindowNode
*
pSrc
,
SIntervalWindowNode
*
pDst
)
{
CLONE_NODE_FIELD
(
pCol
);
CLONE_NODE_FIELD
(
pInterval
);
CLONE_NODE_FIELD
(
pOffset
);
CLONE_NODE_FIELD
(
pSliding
);
CLONE_NODE_FIELD
(
pFill
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
nodeListNodeCopy
(
const
SNodeListNode
*
pSrc
,
SNodeListNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
CLONE_NODE_LIST_FIELD
(
pNodeList
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
fillNodeCopy
(
const
SFillNode
*
pSrc
,
SFillNode
*
pDst
)
{
COPY_SCALAR_FIELD
(
mode
);
CLONE_NODE_FIELD
(
pValues
);
CLONE_NODE_FIELD
(
pWStartTs
);
return
(
SNode
*
)
pDst
;
...
...
@@ -199,31 +229,11 @@ static SNode* logicNodeCopy(const SLogicNode* pSrc, SLogicNode* pDst) {
CLONE_NODE_LIST_FIELD
(
pTargets
);
CLONE_NODE_FIELD
(
pConditions
);
CLONE_NODE_LIST_FIELD
(
pChildren
);
pDst
->
pParent
=
NULL
;
return
(
SNode
*
)
pDst
;
}
static
STableMeta
*
tableMetaClone
(
const
STableMeta
*
pSrc
)
{
int32_t
len
=
TABLE_META_SIZE
(
pSrc
);
STableMeta
*
pDst
=
taosMemoryMalloc
(
len
);
if
(
NULL
==
pDst
)
{
return
NULL
;
}
memcpy
(
pDst
,
pSrc
,
len
);
return
pDst
;
}
static
SVgroupsInfo
*
vgroupsInfoClone
(
const
SVgroupsInfo
*
pSrc
)
{
int32_t
len
=
VGROUPS_INFO_SIZE
(
pSrc
);
SVgroupsInfo
*
pDst
=
taosMemoryMalloc
(
len
);
if
(
NULL
==
pDst
)
{
return
NULL
;
}
memcpy
(
pDst
,
pSrc
,
len
);
return
pDst
;
}
static
SNode
*
logicScanCopy
(
const
SScanLogicNode
*
pSrc
,
SScanLogicNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
COPY_BASE_OBJECT_FIELD
(
node
,
logicNodeCopy
);
CLONE_NODE_LIST_FIELD
(
pScanCols
);
CLONE_NODE_LIST_FIELD
(
pScanPseudoCols
);
...
...
@@ -234,7 +244,6 @@ static SNode* logicScanCopy(const SScanLogicNode* pSrc, SScanLogicNode* pDst) {
}
static
SNode
*
logicJoinCopy
(
const
SJoinLogicNode
*
pSrc
,
SJoinLogicNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
COPY_BASE_OBJECT_FIELD
(
node
,
logicNodeCopy
);
CLONE_NODE_FIELD
(
pOnConditions
);
return
(
SNode
*
)
pDst
;
...
...
@@ -248,7 +257,6 @@ static SNode* logicAggCopy(const SAggLogicNode* pSrc, SAggLogicNode* pDst) {
}
static
SNode
*
logicProjectCopy
(
const
SProjectLogicNode
*
pSrc
,
SProjectLogicNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
COPY_BASE_OBJECT_FIELD
(
node
,
logicNodeCopy
);
CLONE_NODE_LIST_FIELD
(
pProjections
);
return
(
SNode
*
)
pDst
;
...
...
@@ -256,18 +264,17 @@ static SNode* logicProjectCopy(const SProjectLogicNode* pSrc, SProjectLogicNode*
static
SNode
*
logicVnodeModifCopy
(
const
SVnodeModifLogicNode
*
pSrc
,
SVnodeModifLogicNode
*
pDst
)
{
COPY_BASE_OBJECT_FIELD
(
node
,
logicNodeCopy
);
COPY_SCALAR_FIELD
(
msgType
);
pDst
->
pDataBlocks
=
NULL
;
pDst
->
pVgDataBlocks
=
NULL
;
return
(
SNode
*
)
pDst
;
}
static
SNode
*
logicExchangeCopy
(
const
SExchangeLogicNode
*
pSrc
,
SExchangeLogicNode
*
pDst
)
{
COPY_BASE_OBJECT_FIELD
(
node
,
logicNodeCopy
);
COPY_SCALAR_FIELD
(
srcGroupId
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
logicWindowCopy
(
const
SWindowLogicNode
*
pSrc
,
SWindowLogicNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
COPY_BASE_OBJECT_FIELD
(
node
,
logicNodeCopy
);
CLONE_NODE_LIST_FIELD
(
pFuncs
);
CLONE_NODE_FIELD
(
pTspk
);
...
...
@@ -275,7 +282,6 @@ static SNode* logicWindowCopy(const SWindowLogicNode* pSrc, SWindowLogicNode* pD
}
static
SNode
*
logicFillCopy
(
const
SFillLogicNode
*
pSrc
,
SFillLogicNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
COPY_BASE_OBJECT_FIELD
(
node
,
logicNodeCopy
);
CLONE_NODE_FIELD
(
pWStartTs
);
CLONE_NODE_FIELD
(
pValues
);
...
...
@@ -296,29 +302,37 @@ static SNode* logicPartitionCopy(const SPartitionLogicNode* pSrc, SPartitionLogi
static
SNode
*
logicSubplanCopy
(
const
SLogicSubplan
*
pSrc
,
SLogicSubplan
*
pDst
)
{
CLONE_NODE_FIELD
(
pNode
);
COPY_SCALAR_FIELD
(
subplanType
);
pDst
->
pChildren
=
NULL
;
pDst
->
pParents
=
NULL
;
pDst
->
pVgroupList
=
NULL
;
return
(
SNode
*
)
pDst
;
}
static
SNode
*
dataBlockDescCopy
(
const
SDataBlockDescNode
*
pSrc
,
SDataBlockDescNode
*
pDst
)
{
COPY_ALL_SCALAR_FIELDS
;
CLONE_NODE_LIST_FIELD
(
pSlots
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
slotDescCopy
(
const
SSlotDescNode
*
pSrc
,
SSlotDescNode
*
pDst
)
{
COPY_SCALAR_FIELD
(
slotId
);
dataTypeCopy
(
&
pSrc
->
dataType
,
&
pDst
->
dataType
);
COPY_SCALAR_FIELD
(
reserve
);
COPY_SCALAR_FIELD
(
output
);
COPY_SCALAR_FIELD
(
tag
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
downstreamSourceCopy
(
const
SDownstreamSourceNode
*
pSrc
,
SDownstreamSourceNode
*
pDst
)
{
COPY_SCALAR_FIELD
(
addr
);
COPY_SCALAR_FIELD
(
taskId
);
COPY_SCALAR_FIELD
(
schedId
);
return
(
SNode
*
)
pDst
;
}
static
SNode
*
selectStmtCopy
(
const
SSelectStmt
*
pSrc
,
SSelectStmt
*
pDst
)
{
CLONE_NODE_LIST_FIELD
(
pProjectionList
);
CLONE_NODE_FIELD
(
pFromTable
);
CLONE_NODE_FIELD
(
pWhere
);
CLONE_NODE_LIST_FIELD
(
pPartitionByList
);
CLONE_NODE_FIELD
(
pWindow
);
CLONE_NODE_LIST_FIELD
(
pGroupByList
);
CLONE_NODE_FIELD
(
pHaving
);
CLONE_NODE_LIST_FIELD
(
pOrderByList
);
CLONE_NODE_FIELD
(
pLimit
);
CLONE_NODE_FIELD
(
pLimit
);
return
(
SNode
*
)
pDst
;
}
...
...
@@ -331,6 +345,7 @@ SNodeptr nodesCloneNode(const SNodeptr pNode) {
terrno
=
TSDB_CODE_OUT_OF_MEMORY
;
return
NULL
;
}
memcpy
(
pDst
,
pNode
,
nodesNodeSize
(
nodeType
(
pNode
)));
switch
(
nodeType
(
pNode
))
{
case
QUERY_NODE_COLUMN
:
return
columnNodeCopy
((
const
SColumnNode
*
)
pNode
,
(
SColumnNode
*
)
pDst
);
...
...
@@ -342,28 +357,38 @@ SNodeptr nodesCloneNode(const SNodeptr pNode) {
return
logicConditionNodeCopy
((
const
SLogicConditionNode
*
)
pNode
,
(
SLogicConditionNode
*
)
pDst
);
case
QUERY_NODE_FUNCTION
:
return
functionNodeCopy
((
const
SFunctionNode
*
)
pNode
,
(
SFunctionNode
*
)
pDst
);
case
QUERY_NODE_TARGET
:
return
targetNodeCopy
((
const
STargetNode
*
)
pNode
,
(
STargetNode
*
)
pDst
);
case
QUERY_NODE_REAL_TABLE
:
return
realTableNodeCopy
((
const
SRealTableNode
*
)
pNode
,
(
SRealTableNode
*
)
pDst
);
case
QUERY_NODE_TEMP_TABLE
:
return
tempTableNodeCopy
((
const
STempTableNode
*
)
pNode
,
(
STempTableNode
*
)
pDst
);
case
QUERY_NODE_JOIN_TABLE
:
break
;
return
joinTableNodeCopy
((
const
SJoinTableNode
*
)
pNode
,
(
SJoinTableNode
*
)
pDst
)
;
case
QUERY_NODE_GROUPING_SET
:
return
groupingSetNodeCopy
((
const
SGroupingSetNode
*
)
pNode
,
(
SGroupingSetNode
*
)
pDst
);
case
QUERY_NODE_ORDER_BY_EXPR
:
return
orderByExprNodeCopy
((
const
SOrderByExprNode
*
)
pNode
,
(
SOrderByExprNode
*
)
pDst
);
case
QUERY_NODE_LIMIT
:
break
;
return
limitNodeCopy
((
const
SLimitNode
*
)
pNode
,
(
SLimitNode
*
)
pDst
);
case
QUERY_NODE_STATE_WINDOW
:
return
stateWindowNodeCopy
((
const
SStateWindowNode
*
)
pNode
,
(
SStateWindowNode
*
)
pDst
);
case
QUERY_NODE_SESSION_WINDOW
:
return
sessionWindowNodeCopy
((
const
SSessionWindowNode
*
)
pNode
,
(
SSessionWindowNode
*
)
pDst
);
case
QUERY_NODE_INTERVAL_WINDOW
:
return
intervalWindowNodeCopy
((
const
SIntervalWindowNode
*
)
pNode
,
(
SIntervalWindowNode
*
)
pDst
);
case
QUERY_NODE_NODE_LIST
:
return
nodeListNodeCopy
((
const
SNodeListNode
*
)
pNode
,
(
SNodeListNode
*
)
pDst
);
case
QUERY_NODE_FILL
:
return
fillNodeCopy
((
const
SFillNode
*
)
pNode
,
(
SFillNode
*
)
pDst
);
case
QUERY_NODE_TARGET
:
return
targetNodeCopy
((
const
STargetNode
*
)
pNode
,
(
STargetNode
*
)
pDst
);
case
QUERY_NODE_DATABLOCK_DESC
:
return
dataBlockDescCopy
((
const
SDataBlockDescNode
*
)
pNode
,
(
SDataBlockDescNode
*
)
pDst
);
case
QUERY_NODE_SLOT_DESC
:
return
slotDescCopy
((
const
SSlotDescNode
*
)
pNode
,
(
SSlotDescNode
*
)
pDst
);
case
QUERY_NODE_DOWNSTREAM_SOURCE
:
return
downstreamSourceCopy
((
const
SDownstreamSourceNode
*
)
pNode
,
(
SDownstreamSourceNode
*
)
pDst
);
case
QUERY_NODE_SELECT_STMT
:
return
selectStmtCopy
((
const
SSelectStmt
*
)
pNode
,
(
SSelectStmt
*
)
pDst
);
case
QUERY_NODE_LOGIC_PLAN_SCAN
:
return
logicScanCopy
((
const
SScanLogicNode
*
)
pNode
,
(
SScanLogicNode
*
)
pDst
);
case
QUERY_NODE_LOGIC_PLAN_JOIN
:
...
...
source/libs/nodes/src/nodesEqualFuncs.c
浏览文件 @
8b7f0f3a
...
...
@@ -20,13 +20,28 @@
if (a->fldname != b->fldname) return false; \
} while (0)
#define COMPARE_STRING(a, b) (((a) != NULL && (b) != NULL) ? (strcmp(a, b) == 0) : (a) == (b))
#define COMPARE_STRING(a, b) (((a) != NULL && (b) != NULL) ? (strcmp((a), (b)) == 0) : (a) == (b))
#define COMPARE_VARDATA(a, b) \
(((a) != NULL && (b) != NULL) \
? (varDataLen((a)) == varDataLen((b)) && memcmp(varDataVal((a)), varDataVal((b)), varDataLen((a))) == 0) \
: (a) == (b))
#define COMPARE_STRING_FIELD(fldname) \
do { \
if (!COMPARE_STRING(a->fldname, b->fldname)) return false; \
} while (0)
#define COMPARE_VARDATA_FIELD(fldname) \
do { \
if (!COMPARE_VARDATA(a->fldname, b->fldname)) return false; \
} while (0)
#define COMPARE_OBJECT_FIELD(fldname, equalFunc) \
do { \
if (!equalFunc(a->fldname, b->fldname)) return false; \
} while (0)
#define COMPARE_NODE_FIELD(fldname) \
do { \
if (!nodesEqualNode(a->fldname, b->fldname)) return false; \
...
...
@@ -59,6 +74,10 @@ static bool nodeNodeListEqual(const SNodeList* a, const SNodeList* b) {
return
true
;
}
static
bool
dataTypeEqual
(
SDataType
a
,
SDataType
b
)
{
return
a
.
type
==
b
.
type
&&
a
.
bytes
==
b
.
bytes
&&
a
.
precision
==
b
.
precision
&&
a
.
scale
==
b
.
scale
;
}
static
bool
columnNodeEqual
(
const
SColumnNode
*
a
,
const
SColumnNode
*
b
)
{
COMPARE_STRING_FIELD
(
dbName
);
COMPARE_STRING_FIELD
(
tableName
);
...
...
@@ -67,7 +86,35 @@ static bool columnNodeEqual(const SColumnNode* a, const SColumnNode* b) {
}
static
bool
valueNodeEqual
(
const
SValueNode
*
a
,
const
SValueNode
*
b
)
{
COMPARE_OBJECT_FIELD
(
node
.
resType
,
dataTypeEqual
);
COMPARE_STRING_FIELD
(
literal
);
switch
(
a
->
node
.
resType
.
type
)
{
case
TSDB_DATA_TYPE_BOOL
:
case
TSDB_DATA_TYPE_TINYINT
:
case
TSDB_DATA_TYPE_SMALLINT
:
case
TSDB_DATA_TYPE_INT
:
case
TSDB_DATA_TYPE_BIGINT
:
case
TSDB_DATA_TYPE_UTINYINT
:
case
TSDB_DATA_TYPE_USMALLINT
:
case
TSDB_DATA_TYPE_UINT
:
case
TSDB_DATA_TYPE_UBIGINT
:
case
TSDB_DATA_TYPE_FLOAT
:
case
TSDB_DATA_TYPE_DOUBLE
:
case
TSDB_DATA_TYPE_TIMESTAMP
:
COMPARE_SCALAR_FIELD
(
typeData
);
break
;
case
TSDB_DATA_TYPE_VARCHAR
:
case
TSDB_DATA_TYPE_VARBINARY
:
case
TSDB_DATA_TYPE_NCHAR
:
COMPARE_VARDATA_FIELD
(
datum
.
p
);
break
;
case
TSDB_DATA_TYPE_JSON
:
case
TSDB_DATA_TYPE_DECIMAL
:
case
TSDB_DATA_TYPE_BLOB
:
return
false
;
default:
break
;
}
return
true
;
}
...
...
source/libs/nodes/src/nodesUtilFuncs.c
浏览文件 @
8b7f0f3a
...
...
@@ -21,156 +21,147 @@
#include "taoserror.h"
#include "thash.h"
static
SNode
*
makeNode
(
ENodeType
type
,
size_t
size
)
{
SNode
*
p
=
taosMemoryCalloc
(
1
,
size
);
if
(
NULL
==
p
)
{
return
NULL
;
}
setNodeType
(
p
,
type
);
return
p
;
}
SNodeptr
nodesMakeNode
(
ENodeType
type
)
{
int32_t
nodesNodeSize
(
ENodeType
type
)
{
switch
(
type
)
{
case
QUERY_NODE_COLUMN
:
return
makeNode
(
type
,
sizeof
(
SColumnNode
)
);
return
sizeof
(
SColumnNode
);
case
QUERY_NODE_VALUE
:
return
makeNode
(
type
,
sizeof
(
SValueNode
)
);
return
sizeof
(
SValueNode
);
case
QUERY_NODE_OPERATOR
:
return
makeNode
(
type
,
sizeof
(
SOperatorNode
)
);
return
sizeof
(
SOperatorNode
);
case
QUERY_NODE_LOGIC_CONDITION
:
return
makeNode
(
type
,
sizeof
(
SLogicConditionNode
)
);
return
sizeof
(
SLogicConditionNode
);
case
QUERY_NODE_FUNCTION
:
return
makeNode
(
type
,
sizeof
(
SFunctionNode
)
);
return
sizeof
(
SFunctionNode
);
case
QUERY_NODE_REAL_TABLE
:
return
makeNode
(
type
,
sizeof
(
SRealTableNode
)
);
return
sizeof
(
SRealTableNode
);
case
QUERY_NODE_TEMP_TABLE
:
return
makeNode
(
type
,
sizeof
(
STempTableNode
)
);
return
sizeof
(
STempTableNode
);
case
QUERY_NODE_JOIN_TABLE
:
return
makeNode
(
type
,
sizeof
(
SJoinTableNode
)
);
return
sizeof
(
SJoinTableNode
);
case
QUERY_NODE_GROUPING_SET
:
return
makeNode
(
type
,
sizeof
(
SGroupingSetNode
)
);
return
sizeof
(
SGroupingSetNode
);
case
QUERY_NODE_ORDER_BY_EXPR
:
return
makeNode
(
type
,
sizeof
(
SOrderByExprNode
)
);
return
sizeof
(
SOrderByExprNode
);
case
QUERY_NODE_LIMIT
:
return
makeNode
(
type
,
sizeof
(
SLimitNode
)
);
return
sizeof
(
SLimitNode
);
case
QUERY_NODE_STATE_WINDOW
:
return
makeNode
(
type
,
sizeof
(
SStateWindowNode
)
);
return
sizeof
(
SStateWindowNode
);
case
QUERY_NODE_SESSION_WINDOW
:
return
makeNode
(
type
,
sizeof
(
SSessionWindowNode
)
);
return
sizeof
(
SSessionWindowNode
);
case
QUERY_NODE_INTERVAL_WINDOW
:
return
makeNode
(
type
,
sizeof
(
SIntervalWindowNode
)
);
return
sizeof
(
SIntervalWindowNode
);
case
QUERY_NODE_NODE_LIST
:
return
makeNode
(
type
,
sizeof
(
SNodeListNode
)
);
return
sizeof
(
SNodeListNode
);
case
QUERY_NODE_FILL
:
return
makeNode
(
type
,
sizeof
(
SFillNode
)
);
return
sizeof
(
SFillNode
);
case
QUERY_NODE_RAW_EXPR
:
return
makeNode
(
type
,
sizeof
(
SRawExprNode
)
);
return
sizeof
(
SRawExprNode
);
case
QUERY_NODE_TARGET
:
return
makeNode
(
type
,
sizeof
(
STargetNode
)
);
return
sizeof
(
STargetNode
);
case
QUERY_NODE_DATABLOCK_DESC
:
return
makeNode
(
type
,
sizeof
(
SDataBlockDescNode
)
);
return
sizeof
(
SDataBlockDescNode
);
case
QUERY_NODE_SLOT_DESC
:
return
makeNode
(
type
,
sizeof
(
SSlotDescNode
)
);
return
sizeof
(
SSlotDescNode
);
case
QUERY_NODE_COLUMN_DEF
:
return
makeNode
(
type
,
sizeof
(
SColumnDefNode
)
);
return
sizeof
(
SColumnDefNode
);
case
QUERY_NODE_DOWNSTREAM_SOURCE
:
return
makeNode
(
type
,
sizeof
(
SDownstreamSourceNode
)
);
return
sizeof
(
SDownstreamSourceNode
);
case
QUERY_NODE_DATABASE_OPTIONS
:
return
makeNode
(
type
,
sizeof
(
SDatabaseOptions
)
);
return
sizeof
(
SDatabaseOptions
);
case
QUERY_NODE_TABLE_OPTIONS
:
return
makeNode
(
type
,
sizeof
(
STableOptions
)
);
return
sizeof
(
STableOptions
);
case
QUERY_NODE_INDEX_OPTIONS
:
return
makeNode
(
type
,
sizeof
(
SIndexOptions
)
);
return
sizeof
(
SIndexOptions
);
case
QUERY_NODE_EXPLAIN_OPTIONS
:
return
makeNode
(
type
,
sizeof
(
SExplainOptions
)
);
return
sizeof
(
SExplainOptions
);
case
QUERY_NODE_STREAM_OPTIONS
:
return
makeNode
(
type
,
sizeof
(
SStreamOptions
)
);
return
sizeof
(
SStreamOptions
);
case
QUERY_NODE_TOPIC_OPTIONS
:
return
makeNode
(
type
,
sizeof
(
STopicOptions
)
);
return
sizeof
(
STopicOptions
);
case
QUERY_NODE_SET_OPERATOR
:
return
makeNode
(
type
,
sizeof
(
SSetOperator
)
);
return
sizeof
(
SSetOperator
);
case
QUERY_NODE_SELECT_STMT
:
return
makeNode
(
type
,
sizeof
(
SSelectStmt
)
);
return
sizeof
(
SSelectStmt
);
case
QUERY_NODE_VNODE_MODIF_STMT
:
return
makeNode
(
type
,
sizeof
(
SVnodeModifOpStmt
)
);
return
sizeof
(
SVnodeModifOpStmt
);
case
QUERY_NODE_CREATE_DATABASE_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateDatabaseStmt
)
);
return
sizeof
(
SCreateDatabaseStmt
);
case
QUERY_NODE_DROP_DATABASE_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropDatabaseStmt
)
);
return
sizeof
(
SDropDatabaseStmt
);
case
QUERY_NODE_ALTER_DATABASE_STMT
:
return
makeNode
(
type
,
sizeof
(
SAlterDatabaseStmt
)
);
return
sizeof
(
SAlterDatabaseStmt
);
case
QUERY_NODE_CREATE_TABLE_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateTableStmt
)
);
return
sizeof
(
SCreateTableStmt
);
case
QUERY_NODE_CREATE_SUBTABLE_CLAUSE
:
return
makeNode
(
type
,
sizeof
(
SCreateSubTableClause
)
);
return
sizeof
(
SCreateSubTableClause
);
case
QUERY_NODE_CREATE_MULTI_TABLE_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateMultiTableStmt
)
);
return
sizeof
(
SCreateMultiTableStmt
);
case
QUERY_NODE_DROP_TABLE_CLAUSE
:
return
makeNode
(
type
,
sizeof
(
SDropTableClause
)
);
return
sizeof
(
SDropTableClause
);
case
QUERY_NODE_DROP_TABLE_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropTableStmt
)
);
return
sizeof
(
SDropTableStmt
);
case
QUERY_NODE_DROP_SUPER_TABLE_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropSuperTableStmt
)
);
return
sizeof
(
SDropSuperTableStmt
);
case
QUERY_NODE_ALTER_TABLE_STMT
:
return
makeNode
(
type
,
sizeof
(
SAlterTableStmt
)
);
return
sizeof
(
SAlterTableStmt
);
case
QUERY_NODE_CREATE_USER_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateUserStmt
)
);
return
sizeof
(
SCreateUserStmt
);
case
QUERY_NODE_ALTER_USER_STMT
:
return
makeNode
(
type
,
sizeof
(
SAlterUserStmt
)
);
return
sizeof
(
SAlterUserStmt
);
case
QUERY_NODE_DROP_USER_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropUserStmt
)
);
return
sizeof
(
SDropUserStmt
);
case
QUERY_NODE_USE_DATABASE_STMT
:
return
makeNode
(
type
,
sizeof
(
SUseDatabaseStmt
)
);
return
sizeof
(
SUseDatabaseStmt
);
case
QUERY_NODE_CREATE_DNODE_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateDnodeStmt
)
);
return
sizeof
(
SCreateDnodeStmt
);
case
QUERY_NODE_DROP_DNODE_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropDnodeStmt
)
);
return
sizeof
(
SDropDnodeStmt
);
case
QUERY_NODE_ALTER_DNODE_STMT
:
return
makeNode
(
type
,
sizeof
(
SAlterDnodeStmt
)
);
return
sizeof
(
SAlterDnodeStmt
);
case
QUERY_NODE_CREATE_INDEX_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateIndexStmt
)
);
return
sizeof
(
SCreateIndexStmt
);
case
QUERY_NODE_DROP_INDEX_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropIndexStmt
)
);
return
sizeof
(
SDropIndexStmt
);
case
QUERY_NODE_CREATE_QNODE_STMT
:
case
QUERY_NODE_CREATE_BNODE_STMT
:
case
QUERY_NODE_CREATE_SNODE_STMT
:
case
QUERY_NODE_CREATE_MNODE_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateComponentNodeStmt
)
);
return
sizeof
(
SCreateComponentNodeStmt
);
case
QUERY_NODE_DROP_QNODE_STMT
:
case
QUERY_NODE_DROP_BNODE_STMT
:
case
QUERY_NODE_DROP_SNODE_STMT
:
case
QUERY_NODE_DROP_MNODE_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropComponentNodeStmt
)
);
return
sizeof
(
SDropComponentNodeStmt
);
case
QUERY_NODE_CREATE_TOPIC_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateTopicStmt
)
);
return
sizeof
(
SCreateTopicStmt
);
case
QUERY_NODE_DROP_TOPIC_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropTopicStmt
)
);
return
sizeof
(
SDropTopicStmt
);
case
QUERY_NODE_EXPLAIN_STMT
:
return
makeNode
(
type
,
sizeof
(
SExplainStmt
)
);
return
sizeof
(
SExplainStmt
);
case
QUERY_NODE_DESCRIBE_STMT
:
return
makeNode
(
type
,
sizeof
(
SDescribeStmt
)
);
return
sizeof
(
SDescribeStmt
);
case
QUERY_NODE_RESET_QUERY_CACHE_STMT
:
return
makeNode
(
type
,
sizeof
(
SNode
)
);
return
sizeof
(
SNode
);
case
QUERY_NODE_COMPACT_STMT
:
break
;
case
QUERY_NODE_CREATE_FUNCTION_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateFunctionStmt
)
);
return
sizeof
(
SCreateFunctionStmt
);
case
QUERY_NODE_DROP_FUNCTION_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropFunctionStmt
)
);
return
sizeof
(
SDropFunctionStmt
);
case
QUERY_NODE_CREATE_STREAM_STMT
:
return
makeNode
(
type
,
sizeof
(
SCreateStreamStmt
)
);
return
sizeof
(
SCreateStreamStmt
);
case
QUERY_NODE_DROP_STREAM_STMT
:
return
makeNode
(
type
,
sizeof
(
SDropStreamStmt
)
);
return
sizeof
(
SDropStreamStmt
);
case
QUERY_NODE_MERGE_VGROUP_STMT
:
case
QUERY_NODE_REDISTRIBUTE_VGROUP_STMT
:
case
QUERY_NODE_SPLIT_VGROUP_STMT
:
case
QUERY_NODE_SYNCDB_STMT
:
break
;
case
QUERY_NODE_GRANT_STMT
:
return
makeNode
(
type
,
sizeof
(
SGrantStmt
)
);
return
sizeof
(
SGrantStmt
);
case
QUERY_NODE_REVOKE_STMT
:
return
makeNode
(
type
,
sizeof
(
SRevokeStmt
)
);
return
sizeof
(
SRevokeStmt
);
case
QUERY_NODE_SHOW_DNODES_STMT
:
case
QUERY_NODE_SHOW_MNODES_STMT
:
case
QUERY_NODE_SHOW_MODULES_STMT
:
...
...
@@ -201,80 +192,89 @@ SNodeptr nodesMakeNode(ENodeType type) {
case
QUERY_NODE_SHOW_CREATE_TABLE_STMT
:
case
QUERY_NODE_SHOW_CREATE_STABLE_STMT
:
case
QUERY_NODE_SHOW_TRANSACTIONS_STMT
:
return
makeNode
(
type
,
sizeof
(
SShowStmt
)
);
return
sizeof
(
SShowStmt
);
case
QUERY_NODE_KILL_CONNECTION_STMT
:
case
QUERY_NODE_KILL_QUERY_STMT
:
case
QUERY_NODE_KILL_TRANSACTION_STMT
:
return
makeNode
(
type
,
sizeof
(
SKillStmt
)
);
return
sizeof
(
SKillStmt
);
case
QUERY_NODE_LOGIC_PLAN_SCAN
:
return
makeNode
(
type
,
sizeof
(
SScanLogicNode
)
);
return
sizeof
(
SScanLogicNode
);
case
QUERY_NODE_LOGIC_PLAN_JOIN
:
return
makeNode
(
type
,
sizeof
(
SJoinLogicNode
)
);
return
sizeof
(
SJoinLogicNode
);
case
QUERY_NODE_LOGIC_PLAN_AGG
:
return
makeNode
(
type
,
sizeof
(
SAggLogicNode
)
);
return
sizeof
(
SAggLogicNode
);
case
QUERY_NODE_LOGIC_PLAN_PROJECT
:
return
makeNode
(
type
,
sizeof
(
SProjectLogicNode
)
);
return
sizeof
(
SProjectLogicNode
);
case
QUERY_NODE_LOGIC_PLAN_VNODE_MODIF
:
return
makeNode
(
type
,
sizeof
(
SVnodeModifLogicNode
)
);
return
sizeof
(
SVnodeModifLogicNode
);
case
QUERY_NODE_LOGIC_PLAN_EXCHANGE
:
return
makeNode
(
type
,
sizeof
(
SExchangeLogicNode
)
);
return
sizeof
(
SExchangeLogicNode
);
case
QUERY_NODE_LOGIC_PLAN_WINDOW
:
return
makeNode
(
type
,
sizeof
(
SWindowLogicNode
)
);
return
sizeof
(
SWindowLogicNode
);
case
QUERY_NODE_LOGIC_PLAN_FILL
:
return
makeNode
(
type
,
sizeof
(
SFillLogicNode
)
);
return
sizeof
(
SFillLogicNode
);
case
QUERY_NODE_LOGIC_PLAN_SORT
:
return
makeNode
(
type
,
sizeof
(
SSortLogicNode
)
);
return
sizeof
(
SSortLogicNode
);
case
QUERY_NODE_LOGIC_PLAN_PARTITION
:
return
makeNode
(
type
,
sizeof
(
SPartitionLogicNode
)
);
return
sizeof
(
SPartitionLogicNode
);
case
QUERY_NODE_LOGIC_SUBPLAN
:
return
makeNode
(
type
,
sizeof
(
SLogicSubplan
)
);
return
sizeof
(
SLogicSubplan
);
case
QUERY_NODE_LOGIC_PLAN
:
return
makeNode
(
type
,
sizeof
(
SQueryLogicPlan
)
);
return
sizeof
(
SQueryLogicPlan
);
case
QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN
:
return
makeNode
(
type
,
sizeof
(
STagScanPhysiNode
)
);
return
sizeof
(
STagScanPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN
:
return
makeNode
(
type
,
sizeof
(
STableScanPhysiNode
)
);
return
sizeof
(
STableScanPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN
:
return
makeNode
(
type
,
sizeof
(
STableSeqScanPhysiNode
)
);
return
sizeof
(
STableSeqScanPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN
:
return
makeNode
(
type
,
sizeof
(
SStreamScanPhysiNode
)
);
return
sizeof
(
SStreamScanPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN
:
return
makeNode
(
type
,
sizeof
(
SSystemTableScanPhysiNode
)
);
return
sizeof
(
SSystemTableScanPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_PROJECT
:
return
makeNode
(
type
,
sizeof
(
SProjectPhysiNode
)
);
return
sizeof
(
SProjectPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_JOIN
:
return
makeNode
(
type
,
sizeof
(
SJoinPhysiNode
)
);
return
sizeof
(
SJoinPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_AGG
:
return
makeNode
(
type
,
sizeof
(
SAggPhysiNode
)
);
return
sizeof
(
SAggPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_EXCHANGE
:
return
makeNode
(
type
,
sizeof
(
SExchangePhysiNode
)
);
return
sizeof
(
SExchangePhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_SORT
:
return
makeNode
(
type
,
sizeof
(
SSortPhysiNode
)
);
return
sizeof
(
SSortPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_INTERVAL
:
return
makeNode
(
type
,
sizeof
(
SIntervalPhysiNode
)
);
return
sizeof
(
SIntervalPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL
:
return
makeNode
(
type
,
sizeof
(
SStreamIntervalPhysiNode
)
);
return
sizeof
(
SStreamIntervalPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_FILL
:
return
makeNode
(
type
,
sizeof
(
SFillPhysiNode
)
);
return
sizeof
(
SFillPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_SESSION_WINDOW
:
return
makeNode
(
type
,
sizeof
(
SSessionWinodwPhysiNode
)
);
return
sizeof
(
SSessionWinodwPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_STATE_WINDOW
:
return
makeNode
(
type
,
sizeof
(
SStateWinodwPhysiNode
)
);
return
sizeof
(
SStateWinodwPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_PARTITION
:
return
makeNode
(
type
,
sizeof
(
SPartitionPhysiNode
)
);
return
sizeof
(
SPartitionPhysiNode
);
case
QUERY_NODE_PHYSICAL_PLAN_DISPATCH
:
return
makeNode
(
type
,
sizeof
(
SDataDispatcherNode
)
);
return
sizeof
(
SDataDispatcherNode
);
case
QUERY_NODE_PHYSICAL_PLAN_INSERT
:
return
makeNode
(
type
,
sizeof
(
SDataInserterNode
)
);
return
sizeof
(
SDataInserterNode
);
case
QUERY_NODE_PHYSICAL_SUBPLAN
:
return
makeNode
(
type
,
sizeof
(
SSubplan
)
);
return
sizeof
(
SSubplan
);
case
QUERY_NODE_PHYSICAL_PLAN
:
return
makeNode
(
type
,
sizeof
(
SQueryPlan
)
);
return
sizeof
(
SQueryPlan
);
default:
break
;
}
nodesError
(
"nodesMakeNode unknown node = %s"
,
nodesNodeName
(
type
));
return
NULL
;
return
0
;
}
SNodeptr
nodesMakeNode
(
ENodeType
type
)
{
SNode
*
p
=
taosMemoryCalloc
(
1
,
nodesNodeSize
(
type
));
if
(
NULL
==
p
)
{
return
NULL
;
}
setNodeType
(
p
,
type
);
return
p
;
}
static
void
destroyVgDataBlockArray
(
SArray
*
pArray
)
{
...
...
source/libs/parser/src/parAstCreater.c
浏览文件 @
8b7f0f3a
...
...
@@ -559,6 +559,8 @@ SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* p
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'
;
return
pNode
;
}
...
...
source/libs/parser/src/parTranslater.c
浏览文件 @
8b7f0f3a
...
...
@@ -3446,7 +3446,11 @@ static int32_t extractQueryResultSchema(const SNodeList* pProjections, int32_t*
(
*
pSchema
)[
index
].
type
=
pExpr
->
resType
.
type
;
(
*
pSchema
)[
index
].
bytes
=
pExpr
->
resType
.
bytes
;
(
*
pSchema
)[
index
].
colId
=
index
+
1
;
strcpy
((
*
pSchema
)[
index
].
name
,
pExpr
->
aliasName
);
if
(
'\0'
!=
pExpr
->
userAlias
[
0
])
{
strcpy
((
*
pSchema
)[
index
].
name
,
pExpr
->
userAlias
);
}
else
{
strcpy
((
*
pSchema
)[
index
].
name
,
pExpr
->
aliasName
);
}
index
+=
1
;
}
...
...
source/libs/parser/src/parser.c
浏览文件 @
8b7f0f3a
...
...
@@ -41,7 +41,7 @@ static int32_t parseSqlIntoAst(SParseContext* pCxt, SQuery** pQuery) {
}
if
(
TSDB_CODE_SUCCESS
==
code
&&
(
*
pQuery
)
->
placeholderNum
>
0
)
{
// TSWAP((*pQuery)->pContainPlaceholder
Root, (*pQuery)->pRoot);
TSWAP
((
*
pQuery
)
->
pPrepare
Root
,
(
*
pQuery
)
->
pRoot
);
return
TSDB_CODE_SUCCESS
;
}
...
...
@@ -137,6 +137,36 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
return
TSDB_CODE_SUCCESS
;
}
static
EDealRes
rewriteQueryExprAliasImpl
(
SNode
*
pNode
,
void
*
pContext
)
{
if
(
nodesIsExprNode
(
pNode
)
&&
QUERY_NODE_COLUMN
!=
nodeType
(
pNode
)
&&
'\0'
==
((
SExprNode
*
)
pNode
)
->
userAlias
[
0
])
{
strcpy
(((
SExprNode
*
)
pNode
)
->
userAlias
,
((
SExprNode
*
)
pNode
)
->
aliasName
);
sprintf
(((
SExprNode
*
)
pNode
)
->
aliasName
,
"#%d"
,
*
(
int32_t
*
)
pContext
);
++
(
*
(
int32_t
*
)
pContext
);
}
return
DEAL_RES_CONTINUE
;
}
static
void
rewriteQueryExprAlias
(
SNode
*
pRoot
,
int32_t
*
pNo
)
{
switch
(
nodeType
(
pRoot
))
{
case
QUERY_NODE_SELECT_STMT
:
nodesWalkSelectStmt
((
SSelectStmt
*
)
pRoot
,
SQL_CLAUSE_FROM
,
rewriteQueryExprAliasImpl
,
pNo
);
break
;
case
QUERY_NODE_SET_OPERATOR
:
{
SSetOperator
*
pSetOper
=
(
SSetOperator
*
)
pRoot
;
rewriteQueryExprAlias
(
pSetOper
->
pLeft
,
pNo
);
rewriteQueryExprAlias
(
pSetOper
->
pRight
,
pNo
);
break
;
}
default:
break
;
}
}
static
void
rewriteExprAlias
(
SNode
*
pRoot
)
{
int32_t
no
=
1
;
rewriteQueryExprAlias
(
pRoot
,
&
no
);
}
int32_t
qParseSql
(
SParseContext
*
pCxt
,
SQuery
**
pQuery
)
{
int32_t
code
=
TSDB_CODE_SUCCESS
;
if
(
isInsertSql
(
pCxt
->
pSql
,
pCxt
->
sqlLen
))
{
...
...
@@ -169,6 +199,15 @@ int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx
code
=
setValueByBindParam
((
SValueNode
*
)
taosArrayGetP
(
pQuery
->
pPlaceholderValues
,
colIdx
),
pParams
);
}
if
(
TSDB_CODE_SUCCESS
==
code
&&
(
colIdx
<
0
||
colIdx
+
1
==
pQuery
->
placeholderNum
))
{
pQuery
->
pRoot
=
nodesCloneNode
(
pQuery
->
pPrepareRoot
);
if
(
NULL
==
pQuery
->
pRoot
)
{
code
=
TSDB_CODE_OUT_OF_MEMORY
;
}
}
if
(
TSDB_CODE_SUCCESS
==
code
)
{
rewriteExprAlias
(
pQuery
->
pRoot
);
}
return
code
;
}
...
...
source/libs/planner/test/planStmtTest.cpp
浏览文件 @
8b7f0f3a
...
...
@@ -20,49 +20,147 @@ using namespace std;
class
PlanStmtTest
:
public
PlannerTestBase
{
public:
void
buildParam
(
TAOS_MULTI_BIND
*
pBindParams
,
int32_t
index
,
void
*
pVal
,
int32_t
type
,
int32_t
bytes
=
0
)
{
TAOS_MULTI_BIND
*
pBindParam
=
pBindParams
+
index
;
pBindParam
->
buffer_type
=
type
;
pBindParam
->
num
=
1
;
pBindParam
->
buffer_length
=
bytes
>
0
?
bytes
:
tDataTypes
[
type
].
bytes
;
pBindParam
->
buffer
=
taosMemoryCalloc
(
1
,
pBindParam
->
buffer_length
);
pBindParam
->
length
=
(
int32_t
*
)
taosMemoryCalloc
(
1
,
sizeof
(
int32_t
));
pBindParam
->
is_null
=
(
char
*
)
taosMemoryCalloc
(
1
,
sizeof
(
char
));
*
(
pBindParam
->
length
)
=
bytes
>
0
?
bytes
:
tDataTypes
[
type
].
bytes
;
*
(
pBindParam
->
is_null
)
=
0
;
TAOS_MULTI_BIND
*
createBindParams
(
int32_t
nParams
)
{
return
(
TAOS_MULTI_BIND
*
)
taosMemoryCalloc
(
nParams
,
sizeof
(
TAOS_MULTI_BIND
));
}
TAOS_MULTI_BIND
*
buildIntegerParam
(
TAOS_MULTI_BIND
*
pBindParams
,
int32_t
index
,
int64_t
val
,
int32_t
type
)
{
TAOS_MULTI_BIND
*
pBindParam
=
initParam
(
pBindParams
,
index
,
type
,
0
);
switch
(
type
)
{
case
TSDB_DATA_TYPE_BOOL
:
*
((
bool
*
)
pBindParam
->
buffer
)
=
*
(
bool
*
)
pV
al
;
*
((
bool
*
)
pBindParam
->
buffer
)
=
v
al
;
break
;
case
TSDB_DATA_TYPE_TINYINT
:
*
((
int8_t
*
)
pBindParam
->
buffer
)
=
*
(
int64_t
*
)
pV
al
;
*
((
int8_t
*
)
pBindParam
->
buffer
)
=
v
al
;
break
;
case
TSDB_DATA_TYPE_SMALLINT
:
*
((
int16_t
*
)
pBindParam
->
buffer
)
=
val
;
break
;
case
TSDB_DATA_TYPE_INT
:
*
((
int32_t
*
)
pBindParam
->
buffer
)
=
val
;
break
;
case
TSDB_DATA_TYPE_BIGINT
:
case
TSDB_DATA_TYPE_FLOAT
:
case
TSDB_DATA_TYPE_DOUBLE
:
case
TSDB_DATA_TYPE_VARCHAR
:
*
((
int64_t
*
)
pBindParam
->
buffer
)
=
val
;
break
;
case
TSDB_DATA_TYPE_TIMESTAMP
:
case
TSDB_DATA_TYPE_NCHAR
:
*
((
int64_t
*
)
pBindParam
->
buffer
)
=
val
;
break
;
default:
break
;
}
return
pBindParam
;
}
TAOS_MULTI_BIND
*
buildUIntegerParam
(
TAOS_MULTI_BIND
*
pBindParams
,
int32_t
index
,
uint64_t
val
,
int32_t
type
)
{
TAOS_MULTI_BIND
*
pBindParam
=
initParam
(
pBindParams
,
index
,
type
,
0
);
switch
(
type
)
{
case
TSDB_DATA_TYPE_UTINYINT
:
*
((
uint8_t
*
)
pBindParam
->
buffer
)
=
val
;
break
;
case
TSDB_DATA_TYPE_USMALLINT
:
*
((
uint16_t
*
)
pBindParam
->
buffer
)
=
val
;
break
;
case
TSDB_DATA_TYPE_UINT
:
*
((
uint32_t
*
)
pBindParam
->
buffer
)
=
val
;
break
;
case
TSDB_DATA_TYPE_UBIGINT
:
case
TSDB_DATA_TYPE_JSON
:
*
((
uint64_t
*
)
pBindParam
->
buffer
)
=
val
;
break
;
default:
break
;
}
return
pBindParam
;
}
TAOS_MULTI_BIND
*
buildDoubleParam
(
TAOS_MULTI_BIND
*
pBindParams
,
int32_t
index
,
double
val
,
int32_t
type
)
{
TAOS_MULTI_BIND
*
pBindParam
=
initParam
(
pBindParams
,
index
,
type
,
0
);
switch
(
type
)
{
case
TSDB_DATA_TYPE_FLOAT
:
*
((
float
*
)
pBindParam
->
buffer
)
=
val
;
break
;
case
TSDB_DATA_TYPE_DOUBLE
:
*
((
double
*
)
pBindParam
->
buffer
)
=
val
;
break
;
default:
break
;
}
return
pBindParam
;
}
TAOS_MULTI_BIND
*
buildStringParam
(
TAOS_MULTI_BIND
*
pBindParams
,
int32_t
index
,
const
char
*
pVal
,
int32_t
type
,
int32_t
bytes
)
{
TAOS_MULTI_BIND
*
pBindParam
=
initParam
(
pBindParams
,
index
,
type
,
bytes
);
switch
(
type
)
{
case
TSDB_DATA_TYPE_VARCHAR
:
case
TSDB_DATA_TYPE_VARBINARY
:
case
TSDB_DATA_TYPE_DECIMAL
:
case
TSDB_DATA_TYPE_BLOB
:
case
TSDB_DATA_TYPE_MEDIUMBLOB
:
strncpy
((
char
*
)
pBindParam
->
buffer
,
pVal
,
bytes
);
break
;
case
TSDB_DATA_TYPE_TIMESTAMP
:
case
TSDB_DATA_TYPE_NCHAR
:
default:
break
;
}
return
pBindParam
;
}
private:
TAOS_MULTI_BIND
*
initParam
(
TAOS_MULTI_BIND
*
pBindParams
,
int32_t
index
,
int32_t
type
,
int32_t
bytes
)
{
TAOS_MULTI_BIND
*
pBindParam
=
pBindParams
+
index
;
pBindParam
->
buffer_type
=
type
;
pBindParam
->
num
=
1
;
pBindParam
->
buffer_length
=
bytes
>
0
?
bytes
:
tDataTypes
[
type
].
bytes
;
pBindParam
->
buffer
=
taosMemoryCalloc
(
1
,
pBindParam
->
buffer_length
);
pBindParam
->
length
=
(
int32_t
*
)
taosMemoryCalloc
(
1
,
sizeof
(
int32_t
));
pBindParam
->
is_null
=
(
char
*
)
taosMemoryCalloc
(
1
,
sizeof
(
char
));
*
(
pBindParam
->
length
)
=
bytes
>
0
?
bytes
:
tDataTypes
[
type
].
bytes
;
*
(
pBindParam
->
is_null
)
=
0
;
return
pBindParam
;
}
};
TEST_F
(
PlanStmtTest
,
stmt
)
{
TEST_F
(
PlanStmtTest
,
basic
)
{
useDb
(
"root"
,
"test"
);
prepare
(
"SELECT * FROM t1 WHERE c1 = ?"
);
bindParams
(
buildIntegerParam
(
createBindParams
(
1
),
0
,
10
,
TSDB_DATA_TYPE_INT
),
0
);
exec
();
{
prepare
(
"SELECT * FROM t1 WHERE c1 = ? AND c2 = ?"
);
TAOS_MULTI_BIND
*
pBindParams
=
createBindParams
(
2
);
buildIntegerParam
(
pBindParams
,
0
,
10
,
TSDB_DATA_TYPE_INT
);
buildStringParam
(
pBindParams
,
1
,
"abc"
,
TSDB_DATA_TYPE_VARCHAR
,
strlen
(
"abc"
));
bindParams
(
pBindParams
,
-
1
);
exec
();
taosMemoryFreeClear
(
pBindParams
);
}
{
prepare
(
"SELECT MAX(?), MAX(?) FROM t1"
);
TAOS_MULTI_BIND
*
pBindParams
=
createBindParams
(
2
);
buildIntegerParam
(
pBindParams
,
0
,
10
,
TSDB_DATA_TYPE_TINYINT
);
buildIntegerParam
(
pBindParams
,
1
,
20
,
TSDB_DATA_TYPE_INT
);
bindParams
(
pBindParams
,
-
1
);
exec
();
taosMemoryFreeClear
(
pBindParams
);
}
}
TEST_F
(
PlanStmtTest
,
multiExec
)
{
useDb
(
"root"
,
"test"
);
prepare
(
"SELECT * FROM t1 WHERE c1 = ?"
);
bindParams
(
buildIntegerParam
(
createBindParams
(
1
),
0
,
10
,
TSDB_DATA_TYPE_INT
),
0
);
exec
();
bindParams
(
buildIntegerParam
(
createBindParams
(
1
),
0
,
20
,
TSDB_DATA_TYPE_INT
),
0
);
exec
();
bindParams
(
buildIntegerParam
(
createBindParams
(
1
),
0
,
30
,
TSDB_DATA_TYPE_INT
),
0
);
exec
();
}
TEST_F
(
PlanStmtTest
,
allDataType
)
{
useDb
(
"root"
,
"test"
);
}
source/libs/planner/test/planTestUtil.cpp
浏览文件 @
8b7f0f3a
...
...
@@ -112,8 +112,6 @@ class PlannerTestBaseImpl {
reset
();
try
{
doParseSql
(
sql
,
&
stmtEnv_
.
pQuery_
,
true
);
dump
(
g_dumpModule
);
}
catch
(...)
{
dump
(
DUMP_MODULE_ALL
);
throw
;
...
...
@@ -123,6 +121,15 @@ class PlannerTestBaseImpl {
void
bindParams
(
TAOS_MULTI_BIND
*
pParams
,
int32_t
colIdx
)
{
try
{
doBindParams
(
stmtEnv_
.
pQuery_
,
pParams
,
colIdx
);
}
catch
(...)
{
dump
(
DUMP_MODULE_ALL
);
throw
;
}
}
void
exec
()
{
try
{
doParseBoundSql
(
stmtEnv_
.
pQuery_
);
SPlanContext
cxt
=
{
0
};
setPlanContext
(
stmtEnv_
.
pQuery_
,
&
cxt
);
...
...
@@ -148,17 +155,6 @@ class PlannerTestBaseImpl {
}
}
void
exec
()
{
try
{
doParseBoundSql
(
stmtEnv_
.
pQuery_
);
dump
(
g_dumpModule
);
}
catch
(...)
{
dump
(
DUMP_MODULE_ALL
);
throw
;
}
}
private:
struct
caseEnv
{
string
acctId_
;
...
...
@@ -208,11 +204,17 @@ class PlannerTestBaseImpl {
cout
<<
"==========================================sql : ["
<<
stmtEnv_
.
sql_
<<
"]"
<<
endl
;
if
(
DUMP_MODULE_ALL
==
module
||
DUMP_MODULE_PARSER
==
module
)
{
cout
<<
"syntax tree : "
<<
endl
;
cout
<<
res_
.
ast_
<<
endl
;
cout
<<
"bound syntax tree : "
<<
endl
;
cout
<<
res_
.
boundAst_
<<
endl
;
if
(
res_
.
prepareAst_
.
empty
())
{
cout
<<
"syntax tree : "
<<
endl
;
cout
<<
res_
.
ast_
<<
endl
;
}
else
{
cout
<<
"prepare syntax tree : "
<<
endl
;
cout
<<
res_
.
prepareAst_
<<
endl
;
cout
<<
"bound syntax tree : "
<<
endl
;
cout
<<
res_
.
boundAst_
<<
endl
;
cout
<<
"syntax tree : "
<<
endl
;
cout
<<
res_
.
ast_
<<
endl
;
}
}
if
(
DUMP_MODULE_ALL
==
module
||
DUMP_MODULE_LOGIC
==
module
)
{
...
...
@@ -262,7 +264,7 @@ class PlannerTestBaseImpl {
DO_WITH_THROW
(
qParseSql
,
&
cxt
,
pQuery
);
if
(
prepare
)
{
res_
.
prepareAst_
=
toString
((
*
pQuery
)
->
pRoot
);
res_
.
prepareAst_
=
toString
((
*
pQuery
)
->
p
Prepare
Root
);
}
else
{
res_
.
ast_
=
toString
((
*
pQuery
)
->
pRoot
);
}
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录