#5011

Committed 03 Apr 2026 03:59PM UTC coverage: 72.3% (+0.008%) from 72.292%

Build # #5011

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

merge: from main to 3.0 branch #35067

Coverage Stats

4053 of 5985 new or added lines in 68 files covered. (67.72%)

732 existing lines in 143 files now uncovered.

257430 of 356056 relevant lines covered (72.3%)

131834103.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.55

/source/libs/nodes/src/nodesEqualFuncs.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 "functionMgt.h"
#include "querynodes.h"

static bool nodeListNodeEqual(const SNodeListNode* a, const SNodeListNode* b);

#define COMPARE_SCALAR_FIELD(fldname)           \
  do {                                          \
    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_VARDATA(a, b)                                                                                   \
  (((a) != NULL && (b) != NULL)                                                                                 \
       ? (varDataLen((a)) == varDataLen((b)) && memcmp(varDataVal((a)), varDataVal((b)), varDataLen((a))) == 0) \
       : (a) == (b))
#define COMPARE_BLOBDATA(a, b)                                                                                       \
  (((a) != NULL && (b) != NULL)                                                                                      \
       ? (blobDataLen((a)) == blobDataLen((b)) && memcmp(blobDataVal((a)), blobDataVal((b)), blobDataLen((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_BLOBDATA_FIELD(fldname)                          \
  do {                                                           \
    if (!COMPARE_BLOBDATA(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; \
  } while (0)

#define COMPARE_NODE_LIST_FIELD(fldname)                          \
  do {                                                            \
    if (!nodeNodeListEqual(a->fldname, b->fldname)) return false; \
  } while (0)

static bool nodeNodeListEqual(const SNodeList* a, const SNodeList* b) {
  if (a == b) {
    return true;
  }

  if (NULL == a || NULL == b) {
    return false;
  }

  if (LIST_LENGTH(a) != LIST_LENGTH(b)) {
    return false;
  }

  SNode *na, *nb;
  FORBOTH(na, a, nb, b) {
    if (!nodesEqualNode(na, nb)) {
      return false;
    }
  }
  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);
  COMPARE_STRING_FIELD(colName);
  COMPARE_STRING_FIELD(tableAlias);
  return true;
}

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:
    case TSDB_DATA_TYPE_GEOMETRY:
      COMPARE_VARDATA_FIELD(datum.p);
      break;
    case TSDB_DATA_TYPE_JSON:
      return false;
    case TSDB_DATA_TYPE_DECIMAL:
      return false;
    case TSDB_DATA_TYPE_BLOB:
      COMPARE_BLOBDATA_FIELD(datum.p);
    default:
      break;
  }
  return true;
}

static bool operatorNodeEqual(const SOperatorNode* a, const SOperatorNode* b) {
  COMPARE_SCALAR_FIELD(opType);
  COMPARE_SCALAR_FIELD(flag);
  COMPARE_NODE_FIELD(pLeft);
  COMPARE_NODE_FIELD(pRight);
  return true;
}

static bool logicConditionNodeEqual(const SLogicConditionNode* a, const SLogicConditionNode* b) {
  COMPARE_SCALAR_FIELD(condType);
  COMPARE_NODE_LIST_FIELD(pParameterList);
  return true;
}

static bool functionNodeEqual(const SFunctionNode* a, const SFunctionNode* b) {
  COMPARE_SCALAR_FIELD(funcId);
  COMPARE_STRING_FIELD(functionName);
  COMPARE_NODE_LIST_FIELD(pParameterList);
  if (a->funcType == FUNCTION_TYPE_SELECT_VALUE) {
    if ((a->node.relatedTo != b->node.relatedTo)) return false;
  } else {
    // select cols(cols(first(c0), ts),  first(c0) from meters;
    if ((a->node.bindExprID != b->node.bindExprID)) {
      return false;
    }
  }

  return true;
}

static bool whenThenNodeEqual(const SWhenThenNode* a, const SWhenThenNode* b) {
  COMPARE_NODE_FIELD(pWhen);
  COMPARE_NODE_FIELD(pThen);
  return true;
}

static bool caseWhenNodeEqual(const SCaseWhenNode* a, const SCaseWhenNode* b) {
  COMPARE_NODE_FIELD(pCase);
  COMPARE_NODE_FIELD(pElse);
  COMPARE_NODE_LIST_FIELD(pWhenThenList);
  return true;
}

static bool groupingSetNodeEqual(const SGroupingSetNode* a, const SGroupingSetNode* b) {
  COMPARE_SCALAR_FIELD(groupingSetType);
  COMPARE_NODE_LIST_FIELD(pParameterList);
  return true;
}

static bool remoteValueNodeEqual(const SRemoteValueNode* a, const SRemoteValueNode* b) {
  COMPARE_SCALAR_FIELD(subQIdx);
  return valueNodeEqual(&a->val, &b->val);
}

static bool remoteValueNodeListEqual(const SRemoteValueListNode* a, const SRemoteValueListNode* b) {
  COMPARE_OBJECT_FIELD(node.resType, dataTypeEqual);
  COMPARE_SCALAR_FIELD(subQIdx);
  return true;
}

static bool remoteRowNodeEqual(const SRemoteRowNode* a, const SRemoteRowNode* b) {
  COMPARE_SCALAR_FIELD(valSet);
  COMPARE_SCALAR_FIELD(hasValue);
  COMPARE_SCALAR_FIELD(hasNull);
  COMPARE_SCALAR_FIELD(subQIdx);
  return valueNodeEqual(&a->val, &b->val);
}

static bool remoteZeroRowsNodeEqual(const SRemoteZeroRowsNode* a, const SRemoteZeroRowsNode* b) {
  return remoteValueNodeEqual((const SRemoteValueNode*)a, (const SRemoteValueNode*)b);
}

static bool remoteTableNodeEqual(const SRemoteTableNode* a, const SRemoteTableNode* b) {
  COMPARE_SCALAR_FIELD(resCols);
  COMPARE_SCALAR_FIELD(subQIdx);
  return true;
}

static bool nodeListNodeEqual(const SNodeListNode* a, const SNodeListNode* b) {
  if (LIST_LENGTH(a->pNodeList) != LIST_LENGTH(b->pNodeList)) {
    return false;
  }

  COMPARE_NODE_LIST_FIELD(pNodeList);
  return true;
}


bool nodesEqualNode(const SNode* a, const SNode* b) {
  if (a == b) {
    return true;
  }

  if (NULL == a || NULL == b) {
    return false;
  }

  if (nodeType(a) != nodeType(b)) {
    return false;
  }

  switch (nodeType(a)) {
    case QUERY_NODE_COLUMN:
      return columnNodeEqual((const SColumnNode*)a, (const SColumnNode*)b);
    case QUERY_NODE_VALUE:
      return valueNodeEqual((const SValueNode*)a, (const SValueNode*)b);
    case QUERY_NODE_OPERATOR:
      return operatorNodeEqual((const SOperatorNode*)a, (const SOperatorNode*)b);
    case QUERY_NODE_LOGIC_CONDITION:
      return logicConditionNodeEqual((const SLogicConditionNode*)a, (const SLogicConditionNode*)b);
    case QUERY_NODE_FUNCTION:
      return functionNodeEqual((const SFunctionNode*)a, (const SFunctionNode*)b);
    case QUERY_NODE_WHEN_THEN:
      return whenThenNodeEqual((const SWhenThenNode*)a, (const SWhenThenNode*)b);
    case QUERY_NODE_CASE_WHEN:
      return caseWhenNodeEqual((const SCaseWhenNode*)a, (const SCaseWhenNode*)b);
    case QUERY_NODE_GROUPING_SET:
      return groupingSetNodeEqual((const SGroupingSetNode*)a, (const SGroupingSetNode*)b);
    case QUERY_NODE_NODE_LIST:
      return nodeListNodeEqual((const SNodeListNode*)a, (const SNodeListNode*)b);
    case QUERY_NODE_REAL_TABLE:
    case QUERY_NODE_VIRTUAL_TABLE:
    case QUERY_NODE_TEMP_TABLE:
    case QUERY_NODE_JOIN_TABLE:
    case QUERY_NODE_ORDER_BY_EXPR:
    case QUERY_NODE_LIMIT:
      return false;
    case QUERY_NODE_REMOTE_VALUE:
      return remoteValueNodeEqual((const SRemoteValueNode*)a, (const SRemoteValueNode*)b);
    case QUERY_NODE_REMOTE_VALUE_LIST:
      return remoteValueNodeListEqual((const SRemoteValueListNode*)a, (const SRemoteValueListNode*)b);
    case QUERY_NODE_REMOTE_ROW:
      return remoteRowNodeEqual((const SRemoteRowNode*)a, (const SRemoteRowNode*)b);
    case QUERY_NODE_REMOTE_ZERO_ROWS:
      return remoteZeroRowsNodeEqual((const SRemoteZeroRowsNode*)a, (const SRemoteZeroRowsNode*)b);
    case QUERY_NODE_REMOTE_TABLE:
      return remoteTableNodeEqual((const SRemoteTableNode*)a, (const SRemoteTableNode*)b);
    default:
      break;
  }

  return false;
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	*/
15
16	#include "functionMgt.h"
17	#include "querynodes.h"
18
19	static bool nodeListNodeEqual(const SNodeListNode* a, const SNodeListNode* b);
20
21	#define COMPARE_SCALAR_FIELD(fldname) \
22	do { \
23	if (a->fldname != b->fldname) return false; \
24	} while (0)
25
26	#define COMPARE_STRING(a, b) (((a) != NULL && (b) != NULL) ? (strcmp((a), (b)) == 0) : (a) == (b))
27
28	#define COMPARE_VARDATA(a, b) \
29	(((a) != NULL && (b) != NULL) \
30	? (varDataLen((a)) == varDataLen((b)) && memcmp(varDataVal((a)), varDataVal((b)), varDataLen((a))) == 0) \
31	: (a) == (b))
32	#define COMPARE_BLOBDATA(a, b) \
33	(((a) != NULL && (b) != NULL) \
34	? (blobDataLen((a)) == blobDataLen((b)) && memcmp(blobDataVal((a)), blobDataVal((b)), blobDataLen((a))) == 0) \
35	: (a) == (b))
36	#define COMPARE_STRING_FIELD(fldname) \
37	do { \
38	if (!COMPARE_STRING(a->fldname, b->fldname)) return false; \
39	} while (0)
40
41	#define COMPARE_VARDATA_FIELD(fldname) \
42	do { \
43	if (!COMPARE_VARDATA(a->fldname, b->fldname)) return false; \
44	} while (0)
45
46	#define COMPARE_BLOBDATA_FIELD(fldname) \
47	do { \
48	if (!COMPARE_BLOBDATA(a->fldname, b->fldname)) return false; \
49	} while (0)
50
51	#define COMPARE_OBJECT_FIELD(fldname, equalFunc) \
52	do { \
53	if (!equalFunc(a->fldname, b->fldname)) return false; \
54	} while (0)
55
56	#define COMPARE_NODE_FIELD(fldname) \
57	do { \
58	if (!nodesEqualNode(a->fldname, b->fldname)) return false; \
59	} while (0)
60
61	#define COMPARE_NODE_LIST_FIELD(fldname) \
62	do { \
63	if (!nodeNodeListEqual(a->fldname, b->fldname)) return false; \
64	} while (0)
65
66	static bool nodeNodeListEqual(const SNodeList* a, const SNodeList* b) {	2,147,483,647✔
67	if (a == b) {	2,147,483,647✔
68	return true;	127,680,146✔
69	}
70
71	if (NULL == a \|\| NULL == b) {	2,147,483,647✔
72	return false;	2,249,925✔
73	}
74
75	if (LIST_LENGTH(a) != LIST_LENGTH(b)) {	2,147,483,647✔
76	return false;	172,805✔
77	}
78
79	SNode na, nb;
80	FORBOTH(na, a, nb, b) {	2,147,483,647✔
81	if (!nodesEqualNode(na, nb)) {	2,147,483,647✔
82	return false;	2,058,622,658✔
83	}
84	}
85	return true;	478,531,155✔
86	}
87
88	static bool dataTypeEqual(SDataType a, SDataType b) {	199,770,205✔
89	return a.type == b.type && a.bytes == b.bytes && a.precision == b.precision && a.scale == b.scale;	199,770,205✔
90	}
91
92	static bool columnNodeEqual(const SColumnNode* a, const SColumnNode* b) {	2,147,483,647✔
93	COMPARE_STRING_FIELD(dbName);	2,147,483,647✔
94	COMPARE_STRING_FIELD(tableName);	2,147,483,647✔
95	COMPARE_STRING_FIELD(colName);	2,147,483,647✔
96	COMPARE_STRING_FIELD(tableAlias);	749,684,212✔
97	return true;	748,896,880✔
98	}
99
100	static bool valueNodeEqual(const SValueNode* a, const SValueNode* b) {	198,580,513✔
101	COMPARE_OBJECT_FIELD(node.resType, dataTypeEqual);	198,580,513✔
102	COMPARE_STRING_FIELD(literal);	197,800,715✔
103	switch (a->node.resType.type) {	197,608,863✔
104	case TSDB_DATA_TYPE_BOOL:	180,544,661✔
105	case TSDB_DATA_TYPE_TINYINT:
106	case TSDB_DATA_TYPE_SMALLINT:
107	case TSDB_DATA_TYPE_INT:
108	case TSDB_DATA_TYPE_BIGINT:
109	case TSDB_DATA_TYPE_UTINYINT:
110	case TSDB_DATA_TYPE_USMALLINT:
111	case TSDB_DATA_TYPE_UINT:
112	case TSDB_DATA_TYPE_UBIGINT:
113	case TSDB_DATA_TYPE_FLOAT:
114	case TSDB_DATA_TYPE_DOUBLE:
115	case TSDB_DATA_TYPE_TIMESTAMP:
116	COMPARE_SCALAR_FIELD(typeData);	180,544,661✔
117	break;	180,539,813✔
118	case TSDB_DATA_TYPE_VARCHAR:	14,660,334✔
119	case TSDB_DATA_TYPE_VARBINARY:
120	case TSDB_DATA_TYPE_NCHAR:
121	case TSDB_DATA_TYPE_GEOMETRY:
122	COMPARE_VARDATA_FIELD(datum.p);	14,660,334✔
123	break;	14,660,334✔
124	case TSDB_DATA_TYPE_JSON:	×
125	return false;	×
126	case TSDB_DATA_TYPE_DECIMAL:	×
127	return false;	×
128	case TSDB_DATA_TYPE_BLOB:	×
129	COMPARE_BLOBDATA_FIELD(datum.p);	×
130	default:
131	break;	2,403,868✔
132	}
133	return true;	197,604,015✔
134	}
135
136	static bool operatorNodeEqual(const SOperatorNode* a, const SOperatorNode* b) {	84,159,329✔
137	COMPARE_SCALAR_FIELD(opType);	84,159,329✔
138	COMPARE_SCALAR_FIELD(flag);	82,006,175✔
139	COMPARE_NODE_FIELD(pLeft);	82,006,175✔
140	COMPARE_NODE_FIELD(pRight);	81,984,838✔
141	return true;	81,936,592✔
142	}
143
144	static bool logicConditionNodeEqual(const SLogicConditionNode* a, const SLogicConditionNode* b) {	38,151✔
145	COMPARE_SCALAR_FIELD(condType);	38,151✔
146	COMPARE_NODE_LIST_FIELD(pParameterList);	38,151✔
147	return true;	38,151✔
148	}
149
150	static bool functionNodeEqual(const SFunctionNode* a, const SFunctionNode* b) {	2,147,483,647✔
151	COMPARE_SCALAR_FIELD(funcId);	2,147,483,647✔
152	COMPARE_STRING_FIELD(functionName);	2,147,483,647✔
153	COMPARE_NODE_LIST_FIELD(pParameterList);	2,147,483,647✔
154	if (a->funcType == FUNCTION_TYPE_SELECT_VALUE) {	596,365,707✔
155	if ((a->node.relatedTo != b->node.relatedTo)) return false;	11,952,882✔
156	} else {
157	// select cols(cols(first(c0), ts), first(c0) from meters;
158	if ((a->node.bindExprID != b->node.bindExprID)) {	584,412,280✔
159	return false;	678,368✔
160	}
161	}
162
163	return true;	595,171,021✔
164	}
165
166	static bool whenThenNodeEqual(const SWhenThenNode* a, const SWhenThenNode* b) {	9,783,221✔
167	COMPARE_NODE_FIELD(pWhen);	9,783,221✔
168	COMPARE_NODE_FIELD(pThen);	9,782,252✔
169	return true;	9,782,527✔
170	}
171
172	static bool caseWhenNodeEqual(const SCaseWhenNode* a, const SCaseWhenNode* b) {	9,778,566✔
173	COMPARE_NODE_FIELD(pCase);	9,778,566✔
174	COMPARE_NODE_FIELD(pElse);	9,781,216✔
175	COMPARE_NODE_LIST_FIELD(pWhenThenList);	9,780,445✔
176	return true;	9,779,134✔
177	}
178
179	static bool groupingSetNodeEqual(const SGroupingSetNode* a, const SGroupingSetNode* b) {	3,714,963✔
180	COMPARE_SCALAR_FIELD(groupingSetType);	3,714,963✔
181	COMPARE_NODE_LIST_FIELD(pParameterList);	3,714,963✔
182	return true;	12,461✔
183	}
184
185	static bool remoteValueNodeEqual(const SRemoteValueNode* a, const SRemoteValueNode* b) {	31,825,574✔
186	COMPARE_SCALAR_FIELD(subQIdx);	31,825,574✔
187	return valueNodeEqual(&a->val, &b->val);	29,063,396✔
188	}
189
190	static bool remoteValueNodeListEqual(const SRemoteValueListNode* a, const SRemoteValueListNode* b) {	1,189,293✔
191	COMPARE_OBJECT_FIELD(node.resType, dataTypeEqual);	1,189,293✔
192	COMPARE_SCALAR_FIELD(subQIdx);	1,189,386✔
193	return true;	1,189,386✔
194	}
195
196	static bool remoteRowNodeEqual(const SRemoteRowNode* a, const SRemoteRowNode* b) {	661,788✔
197	COMPARE_SCALAR_FIELD(valSet);	661,788✔
198	COMPARE_SCALAR_FIELD(hasValue);	661,788✔
199	COMPARE_SCALAR_FIELD(hasNull);	661,788✔
200	COMPARE_SCALAR_FIELD(subQIdx);	661,788✔
201	return valueNodeEqual(&a->val, &b->val);	661,788✔
202	}
203
204	static bool remoteZeroRowsNodeEqual(const SRemoteZeroRowsNode* a, const SRemoteZeroRowsNode* b) {	365,711✔
205	return remoteValueNodeEqual((const SRemoteValueNode)a, (const SRemoteValueNode)b);	365,711✔
206	}
207
NEW 208	static bool remoteTableNodeEqual(const SRemoteTableNode* a, const SRemoteTableNode* b) {	×
NEW 209	COMPARE_SCALAR_FIELD(resCols);	×
NEW 210	COMPARE_SCALAR_FIELD(subQIdx);	×
NEW 211	return true;	×
212	}
213
214	static bool nodeListNodeEqual(const SNodeListNode* a, const SNodeListNode* b) {	3,008✔
215	if (LIST_LENGTH(a->pNodeList) != LIST_LENGTH(b->pNodeList)) {	3,008✔
216	return false;	×
217	}
218
219	COMPARE_NODE_LIST_FIELD(pNodeList);	3,008✔
220	return true;	3,008✔
221	}
222
223
224	bool nodesEqualNode(const SNode* a, const SNode* b) {	2,147,483,647✔
225	if (a == b) {	2,147,483,647✔
226	return true;	164,359,645✔
227	}
228
229	if (NULL == a \|\| NULL == b) {	2,147,483,647✔
230	return false;	×
231	}
232
233	if (nodeType(a) != nodeType(b)) {	2,147,483,647✔
234	return false;	1,072,396,367✔
235	}
236
237	switch (nodeType(a)) {	2,147,483,647✔
238	case QUERY_NODE_COLUMN:	2,147,483,647✔
239	return columnNodeEqual((const SColumnNode)a, (const SColumnNode)b);	2,147,483,647✔
240	case QUERY_NODE_VALUE:	168,858,659✔
241	return valueNodeEqual((const SValueNode)a, (const SValueNode)b);	168,858,659✔
242	case QUERY_NODE_OPERATOR:	84,168,808✔
243	return operatorNodeEqual((const SOperatorNode)a, (const SOperatorNode)b);	84,168,808✔
244	case QUERY_NODE_LOGIC_CONDITION:	38,151✔
245	return logicConditionNodeEqual((const SLogicConditionNode)a, (const SLogicConditionNode)b);	38,151✔
246	case QUERY_NODE_FUNCTION:	2,147,483,647✔
247	return functionNodeEqual((const SFunctionNode)a, (const SFunctionNode)b);	2,147,483,647✔
248	case QUERY_NODE_WHEN_THEN:	9,786,577✔
249	return whenThenNodeEqual((const SWhenThenNode)a, (const SWhenThenNode)b);	9,786,577✔
250	case QUERY_NODE_CASE_WHEN:	9,779,982✔
251	return caseWhenNodeEqual((const SCaseWhenNode)a, (const SCaseWhenNode)b);	9,779,982✔
252	case QUERY_NODE_GROUPING_SET:	3,716,137✔
253	return groupingSetNodeEqual((const SGroupingSetNode)a, (const SGroupingSetNode)b);	3,716,137✔
254	case QUERY_NODE_NODE_LIST:	3,008✔
255	return nodeListNodeEqual((const SNodeListNode)a, (const SNodeListNode)b);	3,008✔
256	case QUERY_NODE_REAL_TABLE:	×
257	case QUERY_NODE_VIRTUAL_TABLE:
258	case QUERY_NODE_TEMP_TABLE:
259	case QUERY_NODE_JOIN_TABLE:
260	case QUERY_NODE_ORDER_BY_EXPR:
261	case QUERY_NODE_LIMIT:
262	return false;	×
263	case QUERY_NODE_REMOTE_VALUE:	31,463,860✔
264	return remoteValueNodeEqual((const SRemoteValueNode)a, (const SRemoteValueNode)b);	31,463,860✔
265	case QUERY_NODE_REMOTE_VALUE_LIST:	1,189,652✔
266	return remoteValueNodeListEqual((const SRemoteValueListNode)a, (const SRemoteValueListNode)b);	1,189,652✔
267	case QUERY_NODE_REMOTE_ROW:	662,056✔
268	return remoteRowNodeEqual((const SRemoteRowNode)a, (const SRemoteRowNode)b);	662,056✔
269	case QUERY_NODE_REMOTE_ZERO_ROWS:	365,711✔
270	return remoteZeroRowsNodeEqual((const SRemoteZeroRowsNode)a, (const SRemoteZeroRowsNode)b);	365,711✔
271	case QUERY_NODE_REMOTE_TABLE:	13,340✔
272	return remoteTableNodeEqual((const SRemoteTableNode)a, (const SRemoteTableNode)b);	13,340✔
273	default:	16,944,933✔
274	break;	16,944,933✔
275	}
276
277	return false;	16,944,933✔
278	}

taosdata / TDengine / #5011

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous