• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

taosdata / TDengine / #4701

29 Aug 2025 06:36AM UTC coverage: 59.056% (+0.7%) from 58.335%
#4701

push

travis-ci

web-flow
fix(gpt): fix race-condition in preparing tmp files (#32800)

135452 of 291873 branches covered (46.41%)

Branch coverage included in aggregate %.

5 of 34 new or added lines in 6 files covered. (14.71%)

210 existing lines in 3 files now uncovered.

204379 of 283561 relevant lines covered (72.08%)

30267354.1 hits per line

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

73.84
/source/libs/executor/src/querytask.c
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 "filter.h"
17
#include "function.h"
18
#include "functionMgt.h"
19
#include "os.h"
20
#include "querynodes.h"
21
#include "tfill.h"
22
#include "tname.h"
23

24
#include "tdatablock.h"
25
#include "tmsg.h"
26

27
#include "executorInt.h"
28
#include "index.h"
29
#include "operator.h"
30
#include "query.h"
31
#include "querytask.h"
32
#include "storageapi.h"
33
#include "thash.h"
34
#include "ttypes.h"
35

36
#define CLEAR_QUERY_STATUS(q, st) ((q)->status &= (~(st)))
37

38
int32_t doCreateTask(uint64_t queryId, uint64_t taskId, int32_t vgId, EOPTR_EXEC_MODEL model, SStorageAPI* pAPI,
20,859,551✔
39
                     SExecTaskInfo** pTaskInfo) {
40
  if (pTaskInfo == NULL) {
20,859,551!
41
    return TSDB_CODE_SUCCESS;
×
42
  }
43

44
  SExecTaskInfo* p = taosMemoryCalloc(1, sizeof(SExecTaskInfo));
20,859,551!
45
  if (p == NULL) {
20,856,700!
46
    return terrno;
×
47
  }
48

49
  setTaskStatus(p, TASK_NOT_COMPLETED);
20,856,700✔
50
  p->cost.created = taosGetTimestampUs();
20,870,828✔
51

52
  p->execModel = model;
20,870,828✔
53
  p->stopInfo.pStopInfo = taosArrayInit(4, sizeof(SExchangeOpStopInfo));
20,870,828✔
54
  p->pResultBlockList = taosArrayInit(128, POINTER_BYTES);
20,872,117✔
55
  if (p->stopInfo.pStopInfo == NULL || p->pResultBlockList == NULL) {
20,853,720!
56
    doDestroyTask(p);
×
57
    return terrno;
×
58
  }
59

60
  p->storageAPI = *pAPI;
20,856,356✔
61
  taosInitRWLatch(&p->lock);
20,856,356✔
62

63
  p->id.vgId = vgId;
20,878,040✔
64
  p->id.queryId = queryId;
20,878,040✔
65
  p->id.taskId = taskId;
20,878,040✔
66
  p->id.str = taosMemoryMalloc(64);
20,878,040!
67
  if (p->id.str == NULL) {
20,872,871!
68
    doDestroyTask(p);
×
69
    return terrno;
×
70
  }
71

72
  buildTaskId(taskId, queryId, p->id.str, 64);
20,872,871✔
73
  p->schemaInfos = taosArrayInit(1, sizeof(SSchemaInfo));
20,870,172✔
74
  if (p->id.str == NULL || p->schemaInfos == NULL) {
20,862,398!
75
    doDestroyTask(p);
×
76
    return terrno;
×
77
  }
78

79
  *pTaskInfo = p;
20,864,022✔
80
  return TSDB_CODE_SUCCESS;
20,864,022✔
81
}
82

83
bool isTaskKilled(void* pTaskInfo) { return (0 != ((SExecTaskInfo*)pTaskInfo)->code); }
130,032,051✔
84

85
void setTaskKilled(SExecTaskInfo* pTaskInfo, int32_t rspCode) {
4,912✔
86
  pTaskInfo->code = rspCode;
4,912✔
87
  (void)stopTableScanOperator(pTaskInfo->pRoot, pTaskInfo->id.str, &pTaskInfo->storageAPI);
4,912✔
88
}
4,910✔
89

90
void setTaskStatus(SExecTaskInfo* pTaskInfo, int8_t status) {
65,438,775✔
91
  if (status == TASK_NOT_COMPLETED) {
65,438,775✔
92
    pTaskInfo->status = status;
20,859,285✔
93
  } else {
94
    // QUERY_NOT_COMPLETED is not compatible with any other status, so clear its position first
95
    CLEAR_QUERY_STATUS(pTaskInfo, TASK_NOT_COMPLETED);
44,579,490✔
96
    pTaskInfo->status |= status;
44,579,490✔
97
  }
98
}
65,438,775✔
99

100
int32_t createExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SReadHandle* pHandle, uint64_t taskId,
20,860,171✔
101
                           int32_t vgId, char* sql, EOPTR_EXEC_MODEL model) {
102
  int32_t code = doCreateTask(pPlan->id.queryId, taskId, vgId, model, &pHandle->api, pTaskInfo);
20,860,171✔
103
  if (*pTaskInfo == NULL || code != 0) {
20,864,200!
104
    nodesDestroyNode((SNode*)pPlan);
×
105
    return code;
×
106
  }
107

108
  (*pTaskInfo)->pSubplan = pPlan;
20,866,005✔
109

110
  if (pHandle) {
20,866,005✔
111
    if (pHandle->pStateBackend) {
20,863,397!
112
      (*pTaskInfo)->streamInfo.pState = pHandle->pStateBackend;
×
113
      (*pTaskInfo)->streamInfo.pOtherState = pHandle->pOtherBackend;
×
114
    }
115
  }
116

117
  if (NULL != sql) {
20,866,005✔
118
    (*pTaskInfo)->sql = taosStrdup(sql);
20,712,495!
119
    if (NULL == (*pTaskInfo)->sql) {
20,692,583!
120
      code = terrno;
×
121
      doDestroyTask(*pTaskInfo);
×
122
      (*pTaskInfo) = NULL;
×
123
      return code;
×
124
    }
125
  }
126

127
  (*pTaskInfo)->pWorkerCb = pHandle->pWorkerCb;
20,846,093✔
128
  (*pTaskInfo)->pStreamRuntimeInfo = pHandle->streamRtInfo;
20,846,093✔
129
  code = createOperator(pPlan->pNode, *pTaskInfo, pHandle, pPlan->pTagCond, pPlan->pTagIndexCond, pPlan->user,
20,846,093✔
130
                        pPlan->dbFName, &((*pTaskInfo)->pRoot), model);
20,846,093✔
131

132
  if (NULL == (*pTaskInfo)->pRoot || code != 0) {
20,852,262!
133
    doDestroyTask(*pTaskInfo);
×
134
    (*pTaskInfo) = NULL;
37✔
135
  }
136
  return code;
20,871,621✔
137
}
138

139
void cleanupQueriedTableScanInfo(void* p) {
12,075,356✔
140
  SSchemaInfo* pSchemaInfo = p;
12,075,356✔
141

142
  taosMemoryFreeClear(pSchemaInfo->dbname);
12,075,356!
143
  taosMemoryFreeClear(pSchemaInfo->tablename);
12,075,985!
144
  tDeleteSchemaWrapper(pSchemaInfo->sw);
12,076,173!
145
  tDeleteSchemaWrapper(pSchemaInfo->qsw);
12,077,330✔
146
}
12,076,857✔
147

148
int32_t initQueriedTableSchemaInfo(SReadHandle* pHandle, SScanPhysiNode* pScanNode, const char* dbName,
12,064,908✔
149
                                   SExecTaskInfo* pTaskInfo) {
150
  SMetaReader mr = {0};
12,064,908✔
151
  if (pHandle == NULL) {
12,064,908!
152
    return TSDB_CODE_INVALID_PARA;
×
153
  }
154

155
  SStorageAPI* pAPI = &pTaskInfo->storageAPI;
12,064,908✔
156

157
  pAPI->metaReaderFn.initReader(&mr, pHandle->vnode, META_READER_LOCK, &pAPI->metaFn);
12,064,908✔
158
  int32_t code = pAPI->metaReaderFn.getEntryGetUidCache(&mr, pScanNode->uid);
12,074,313✔
159
  if (code != TSDB_CODE_SUCCESS) {
12,053,999!
160
    qError("failed to get the table meta, uid:0x%" PRIx64 ", suid:0x%" PRIx64 ", %s", pScanNode->uid, pScanNode->suid,
×
161
           GET_TASKID(pTaskInfo));
162

163
    pAPI->metaReaderFn.clearReader(&mr);
×
164
    return code;
×
165
  }
166

167
  SSchemaInfo schemaInfo = {0};
12,053,999✔
168

169
  schemaInfo.tablename = taosStrdup(mr.me.name);
12,053,999✔
170
  schemaInfo.dbname = taosStrdup(dbName);
12,057,653!
171
  if (schemaInfo.tablename == NULL || schemaInfo.dbname == NULL) {
12,068,300✔
172
    pAPI->metaReaderFn.clearReader(&mr);
5,060✔
173
    cleanupQueriedTableScanInfo(&schemaInfo);
×
174
    return terrno;
×
175
  }
176

177
  if (mr.me.type == TSDB_VIRTUAL_NORMAL_TABLE || mr.me.type == TSDB_VIRTUAL_CHILD_TABLE) {
12,063,240!
178
    schemaInfo.rversion = mr.me.colRef.version;
18✔
179
  }
180

181
  if (mr.me.type == TSDB_SUPER_TABLE) {
12,063,240✔
182
    schemaInfo.sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow);
10,840,218✔
183
    schemaInfo.tversion = mr.me.stbEntry.schemaTag.version;
10,840,218✔
184
  } else if (mr.me.type == TSDB_CHILD_TABLE || mr.me.type == TSDB_VIRTUAL_CHILD_TABLE) {
1,227,192✔
185
    tDecoderClear(&mr.coder);
786,801✔
186

187
    tb_uid_t suid = mr.me.ctbEntry.suid;
776,259✔
188
    code = pAPI->metaReaderFn.getEntryGetUidCache(&mr, suid);
776,259✔
189
    if (code != TSDB_CODE_SUCCESS) {
776,242!
190
      pAPI->metaReaderFn.clearReader(&mr);
×
191
      cleanupQueriedTableScanInfo(&schemaInfo);
×
192
      return code;
×
193
    }
194

195
    schemaInfo.sw = tCloneSSchemaWrapper(&mr.me.stbEntry.schemaRow);
776,236✔
196
    schemaInfo.tversion = mr.me.stbEntry.schemaTag.version;
776,236✔
197
  } else {
198
    schemaInfo.sw = tCloneSSchemaWrapper(&mr.me.ntbEntry.schemaRow);
440,401✔
199
  }
200

201
  pAPI->metaReaderFn.clearReader(&mr);
12,056,855✔
202

203
  if (schemaInfo.sw == NULL) {
12,069,460!
204
    cleanupQueriedTableScanInfo(&schemaInfo);
×
205
    return terrno;
×
206
  }
207

208
  schemaInfo.qsw = extractQueriedColumnSchema(pScanNode);
12,069,460✔
209
  if (schemaInfo.qsw == NULL) {
12,061,417!
210
    cleanupQueriedTableScanInfo(&schemaInfo);
×
211
    return terrno;
×
212
  }
213

214
  void* p = taosArrayPush(pTaskInfo->schemaInfos, &schemaInfo);
12,061,417✔
215
  if (p == NULL) {
12,057,682!
216
    cleanupQueriedTableScanInfo(&schemaInfo);
×
217
    return terrno;
×
218
  }
219

220
  return code;
12,057,682✔
221
}
222

223
SSchemaWrapper* extractQueriedColumnSchema(SScanPhysiNode* pScanNode) {
12,054,953✔
224
  int32_t numOfCols = LIST_LENGTH(pScanNode->pScanCols);
12,054,953✔
225
  int32_t numOfTags = LIST_LENGTH(pScanNode->pScanPseudoCols);
12,054,953✔
226

227
  SSchemaWrapper* pqSw = taosMemoryCalloc(1, sizeof(SSchemaWrapper));
12,054,953!
228
  if (pqSw == NULL) {
12,070,444!
229
    return NULL;
×
230
  }
231

232
  pqSw->pSchema = taosMemoryCalloc(numOfCols + numOfTags, sizeof(SSchema));
12,070,444✔
233
  if (pqSw->pSchema == NULL) {
12,058,634!
234
    taosMemoryFree(pqSw);
×
235
    return NULL;
×
236
  }
237

238
  for (int32_t i = 0; i < numOfCols; ++i) {
75,632,321✔
239
    STargetNode* pNode = (STargetNode*)nodesListGetNode(pScanNode->pScanCols, i);
63,571,915✔
240
    SColumnNode* pColNode = (SColumnNode*)pNode->pExpr;
63,573,687✔
241

242
    SSchema* pSchema = &pqSw->pSchema[pqSw->nCols++];
63,573,687✔
243
    pSchema->colId = pColNode->colId;
63,573,687✔
244
    pSchema->type = pColNode->node.resType.type;
63,573,687✔
245
    pSchema->bytes = pColNode->node.resType.bytes;
63,573,687✔
246
    tstrncpy(pSchema->name, pColNode->colName, tListLen(pSchema->name));
63,573,687✔
247
  }
248

249
  // this the tags and pseudo function columns, we only keep the tag columns
250
  for (int32_t i = 0; i < numOfTags; ++i) {
30,151,231✔
251
    STargetNode* pNode = (STargetNode*)nodesListGetNode(pScanNode->pScanPseudoCols, i);
18,099,870✔
252

253
    int32_t type = nodeType(pNode->pExpr);
18,090,825✔
254
    if (type == QUERY_NODE_COLUMN) {
18,090,825✔
255
      SColumnNode* pColNode = (SColumnNode*)pNode->pExpr;
16,479,357✔
256

257
      SSchema* pSchema = &pqSw->pSchema[pqSw->nCols++];
16,479,357✔
258
      pSchema->colId = pColNode->colId;
16,479,357✔
259
      pSchema->type = pColNode->node.resType.type;
16,479,357✔
260
      pSchema->bytes = pColNode->node.resType.bytes;
16,479,357✔
261
      tstrncpy(pSchema->name, pColNode->colName, tListLen(pSchema->name));
16,479,357✔
262
    }
263
  }
264

265
  return pqSw;
12,051,361✔
266
}
267

268
static void cleanupStreamInfo(SStreamTaskInfo* pStreamInfo) {
20,885,000✔
269
  tDeleteSchemaWrapper(pStreamInfo->schema);
20,885,000✔
270
  tOffsetDestroy(&pStreamInfo->currentOffset);
20,885,213✔
271
  tDeleteSchemaWrapper(pStreamInfo->notifyResultSchema);
20,886,556!
272
  taosMemoryFree(pStreamInfo->stbFullName);
20,883,453!
273
}
20,885,054✔
274

275
static void freeBlock(void* pParam) {
27,080,368✔
276
  SSDataBlock* pBlock = *(SSDataBlock**)pParam;
27,080,368✔
277
  blockDataDestroy(pBlock);
27,080,368✔
278
}
27,081,982✔
279

280
void doDestroyTask(SExecTaskInfo* pTaskInfo) {
20,882,594✔
281
  qDebug("%s execTask is freed", GET_TASKID(pTaskInfo));
20,882,594✔
282
  destroyOperator(pTaskInfo->pRoot);
20,882,595✔
283
  pTaskInfo->pRoot = NULL;
20,886,651✔
284

285
  taosArrayDestroyEx(pTaskInfo->schemaInfos, cleanupQueriedTableScanInfo);
20,886,651✔
286
  cleanupStreamInfo(&pTaskInfo->streamInfo);
20,887,470✔
287

288
  if (!pTaskInfo->localFetch.localExec) {
20,884,829!
289
    nodesDestroyNode((SNode*)pTaskInfo->pSubplan);
20,885,286✔
290
    pTaskInfo->pSubplan = NULL;
20,887,337✔
291
  }
292

293
  taosArrayDestroyEx(pTaskInfo->pResultBlockList, freeBlock);
20,886,880✔
294
  taosArrayDestroy(pTaskInfo->stopInfo.pStopInfo);
20,886,891✔
295
  if (!pTaskInfo->paramSet) {
20,887,884✔
296
    freeOperatorParam(pTaskInfo->pOpParam, OP_GET_PARAM);
20,886,905✔
297
    pTaskInfo->pOpParam = NULL;
20,885,241✔
298
  }
299
  taosMemoryFreeClear(pTaskInfo->sql);
20,886,220!
300
  taosMemoryFreeClear(pTaskInfo->id.str);
20,885,229!
301
  taosMemoryFreeClear(pTaskInfo);
20,886,385!
302
}
20,886,334✔
303

304
void buildTaskId(uint64_t taskId, uint64_t queryId, char* dst, int32_t len) {
20,916,216✔
305
  int32_t ret = snprintf(dst, len, "TID:0x%" PRIx64 " QID:0x%" PRIx64, taskId, queryId);
20,916,216✔
306
  if (ret < 0) {
20,916,216!
NEW
307
    qError("TID:0x%"PRIx64" QID:0x%"PRIx64" create task id failed,  ignore and continue", taskId, queryId);
×
308
  }
309
}
20,916,216✔
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc