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

taosdata / TDengine / #5106

17 May 2026 01:15AM UTC coverage: 73.299% (+0.1%) from 73.193%
#5106

push

travis-ci

web-flow
feat (TDgpt): Dynamic Model Synchronization Enhancements (#35344)

* refactor: do some internal refactor.

* fix: fix multiprocess sync issue.

* feat: add dynamic anomaly detection and forecasting services

* fix: log error message for undeploying model in exception handling

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* fix: handle undeploy when model exists only on disk

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/286aafa0-c3ce-4c27-b803-2707571e9dc1

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: guard dynamic registry concurrent access

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/5e4db858-6458-40f4-ac28-d1b1b7f97c18

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: tighten service list locking scope

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/5e4db858-6458-40f4-ac28-d1b1b7f97c18

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: restore prophet support and update tests per review feedback

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/92298ae1-7da6-4d07-b20e-101c7cd0b26b

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: improve test name and move copy inside lock scope

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/92298ae1-7da6-4d07-b20e-101c7cd0b26b

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* Potential fix for pull request finding

Co-au... (continued)

281317 of 383795 relevant lines covered (73.3%)

131962094.41 hits per line

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

82.81
/source/libs/function/src/functionMgt.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 "functionMgt.h"
17

18
#include "builtins.h"
19
#include "builtinsimpl.h"
20
#include "functionMgtInt.h"
21
#include "nodes.h"
22
#include "querynodes.h"
23
#include "taos.h"
24
#include "taoserror.h"
25
#include "thash.h"
26
#include "tudf.h"
27

28
typedef struct SFuncMgtService {
29
  SHashObj* pFuncNameHashTable;
30
} SFuncMgtService;
31

32
static SFuncMgtService gFunMgtService;
33
static TdThreadOnce    functionHashTableInit = PTHREAD_ONCE_INIT;
34
static int32_t         initFunctionCode = 0;
35

36
static void InitSpecialFuncId() {
1,691,696 ✔
37
  // just to make sure the funcId of these functions are initialized before used.
38
  (void)fmGetTwstartFuncId();
1,691,696 ✔
39
  (void)fmGetTwendFuncId();
1,691,696 ✔
40
  (void)fmGetTwdurationFuncId();
1,691,696 ✔
41
  (void)fmGetExternalWindowColumnFuncId();
1,691,696 ✔
42
}
1,691,696 ✔
43

44
static void doInitFunctionTable() {
1,691,696 ✔
45
  gFunMgtService.pFuncNameHashTable =
1,691,696 ✔
46
      taosHashInit(funcMgtBuiltinsNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
1,691,696 ✔
47
  if (NULL == gFunMgtService.pFuncNameHashTable) {
1,691,696 ✔
48
    initFunctionCode = terrno;
×
49
    return;
×
50
  }
51

52
  for (int32_t i = 0; i < funcMgtBuiltinsNum; ++i) {
394,165,168 ✔
53
    if (TSDB_CODE_SUCCESS != taosHashPut(gFunMgtService.pFuncNameHashTable, funcMgtBuiltins[i].name,
392,473,472 ✔
54
                                         strlen(funcMgtBuiltins[i].name), &i, sizeof(int32_t))) {
392,473,472 ✔
55
      initFunctionCode = terrno;
×
56
      return;
×
57
    }
58
  }
59
  InitSpecialFuncId();
1,691,696 ✔
60
}
61

62
static bool isSpecificClassifyFunc(int32_t funcId, uint64_t classification) {
2,147,483,647 ✔
63
  if (fmIsUserDefinedFunc(funcId)) {
2,147,483,647 ✔
64
    return FUNC_MGT_AGG_FUNC == classification
65
               ? FUNC_AGGREGATE_UDF_ID == funcId
66
               : (FUNC_MGT_SCALAR_FUNC == classification ? FUNC_SCALAR_UDF_ID == funcId : false);
9,887,788 ✔
67
  }
68
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
2,147,483,647 ✔
69
    return false;
2,147,483,647 ✔
70
  }
71
  return FUNC_MGT_TEST_MASK(funcMgtBuiltins[funcId].classification, classification);
2,147,483,647 ✔
72
}
73

74
int32_t fmFuncMgtInit() {
1,691,696 ✔
75
  (void)taosThreadOnce(&functionHashTableInit, doInitFunctionTable);
1,691,696 ✔
76
  return initFunctionCode;
1,691,696 ✔
77
}
78

79
int32_t fmGetFuncInfo(SFunctionNode* pFunc, char* pMsg, int32_t msgLen) {
887,158,159 ✔
80
  if (NULL != gFunMgtService.pFuncNameHashTable) {
887,158,159 ✔
81
    void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, pFunc->functionName, strlen(pFunc->functionName));
886,982,281 ✔
82
    if (NULL != pVal) {
887,001,043 ✔
83
      pFunc->funcId = *(int32_t*)pVal;
886,776,710 ✔
84
      pFunc->funcType = funcMgtBuiltins[pFunc->funcId].type;
886,776,761 ✔
85
      return funcMgtBuiltins[pFunc->funcId].translateFunc(pFunc, pMsg, msgLen);
886,776,420 ✔
86
    }
87
    return TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION;
224,333 ✔
88
  }
89
  for (int32_t i = 0; i < funcMgtBuiltinsNum; ++i) {
3,446,778 ✔
90
    if (0 == strcmp(funcMgtBuiltins[i].name, pFunc->functionName)) {
3,446,936 ✔
91
      pFunc->funcId = i;
185,248 ✔
92
      pFunc->funcType = funcMgtBuiltins[pFunc->funcId].type;
185,248 ✔
93
      return funcMgtBuiltins[pFunc->funcId].translateFunc(pFunc, pMsg, msgLen);
185,248 ✔
94
    }
95
  }
96
  return TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION;
×
97
}
98

99
EFuncReturnRows fmGetFuncReturnRows(SFunctionNode* pFunc) {
19,325,686 ✔
100
  if (NULL != funcMgtBuiltins[pFunc->funcId].estimateReturnRowsFunc) {
19,325,686 ✔
101
    return funcMgtBuiltins[pFunc->funcId].estimateReturnRowsFunc(pFunc);
13,654,525 ✔
102
  }
103
  return (fmIsIndefiniteRowsFunc(pFunc->funcId) || fmIsMultiRowsFunc(pFunc->funcId)) ? FUNC_RETURN_ROWS_INDEFINITE
5,670,592 ✔
104
                                                                                     : FUNC_RETURN_ROWS_NORMAL;
5,670,592 ✔
105
}
106

107
bool canCoexistIndefiniteRowsFunc(int32_t funcId1, int32_t funcId2) {
193,025 ✔
108
  if (fmIsUserDefinedFunc(funcId1) || funcId1 < 0 || funcId1 >= funcMgtBuiltinsNum ||
386,050 ✔
109
      fmIsUserDefinedFunc(funcId2) || funcId2 < 0 || funcId2 >= funcMgtBuiltinsNum) {
386,050 ✔
110
    return false;
×
111
  }
112
  if (funcId1 == funcId2) {
193,025 ✔
113
    return true;
176,313 ✔
114
  }
115
  if ((funcMgtBuiltins[funcId1].type == FUNCTION_TYPE_LAG || funcMgtBuiltins[funcId1].type == FUNCTION_TYPE_LEAD) &&
16,712 ✔
116
      (funcMgtBuiltins[funcId2].type == FUNCTION_TYPE_LAG || funcMgtBuiltins[funcId2].type == FUNCTION_TYPE_LEAD)) {
16,233 ✔
117
    return true;
16,233 ✔
118
  }
119
  return false;
479 ✔
120
}
121

122
bool fmIsBuiltinFunc(const char* pFunc) {
18,322 ✔
123
  return NULL != taosHashGet(gFunMgtService.pFuncNameHashTable, pFunc, strlen(pFunc));
18,322 ✔
124
}
125

126
EFunctionType fmGetFuncType(const char* pFunc) {
644,857,143 ✔
127
  void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, pFunc, strlen(pFunc));
644,857,143 ✔
128
  if (NULL != pVal) {
644,877,672 ✔
129
    return funcMgtBuiltins[*(int32_t*)pVal].type;
644,650,527 ✔
130
  }
131
  return FUNCTION_TYPE_UDF;
227,145 ✔
132
}
133

134
EFunctionType fmGetFuncTypeFromId(int32_t funcId) {
26,055,771 ✔
135
  if (funcId >= 0 && funcId < funcMgtBuiltinsNum) {
26,055,771 ✔
136
    return funcMgtBuiltins[funcId].type;
26,055,771 ✔
137
  }
138
  return FUNCTION_TYPE_UDF;
×
139
}
140

141
EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow) {
42,717,365 ✔
142
  if (fmIsUserDefinedFunc(pFunc->funcId) || pFunc->funcId < 0 || pFunc->funcId >= funcMgtBuiltinsNum) {
42,717,365 ✔
143
    return FUNC_DATA_REQUIRED_DATA_LOAD;
1,902 ✔
144
  }
145
  if (NULL == funcMgtBuiltins[pFunc->funcId].dataRequiredFunc) {
42,718,891 ✔
146
    return FUNC_DATA_REQUIRED_DATA_LOAD;
×
147
  }
148
  return funcMgtBuiltins[pFunc->funcId].dataRequiredFunc(pFunc, pTimeWindow);
42,718,836 ✔
149
}
150

151
EFuncDataRequired fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo) {
2,147,483,647 ✔
152
  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {
2,147,483,647 ✔
153
    return FUNC_DATA_REQUIRED_DATA_LOAD;
9,240 ✔
154
  }
155

156
  const char* name = funcMgtBuiltins[funcId].name;
2,147,483,647 ✔
157
  if ((strcmp(name, "_group_key") == 0) || (strcmp(name, "_select_value") == 0)) {
2,147,483,647 ✔
158
    return FUNC_DATA_REQUIRED_NOT_LOAD;
7,051,015 ✔
159
    ;
160
  }
161

162
  if (funcMgtBuiltins[funcId].dynDataRequiredFunc == NULL) {
2,147,483,647 ✔
163
    return FUNC_DATA_REQUIRED_DATA_LOAD;
187,362,976 ✔
164
  } else {
165
    return funcMgtBuiltins[funcId].dynDataRequiredFunc(pRes, pBlockInfo);
2,147,483,647 ✔
166
  }
167
}
168

169
int32_t fmGetFuncExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet) {
340,156,968 ✔
170
  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {
340,156,968 ✔
171
    return TSDB_CODE_FAILED;
18,882 ✔
172
  }
173
  pFpSet->getEnv = funcMgtBuiltins[funcId].getEnvFunc;
340,147,692 ✔
174
  pFpSet->init = funcMgtBuiltins[funcId].initFunc;
340,141,296 ✔
175
  pFpSet->process = funcMgtBuiltins[funcId].processFunc;
340,153,054 ✔
176
  pFpSet->finalize = funcMgtBuiltins[funcId].finalizeFunc;
340,130,545 ✔
177
  pFpSet->combine = funcMgtBuiltins[funcId].combineFunc;
340,135,692 ✔
178
  pFpSet->processFuncByRow = funcMgtBuiltins[funcId].processFuncByRow;
340,134,878 ✔
179
  pFpSet->cleanup = funcMgtBuiltins[funcId].cleanupFunc;
340,149,262 ✔
180
  return TSDB_CODE_SUCCESS;
340,132,174 ✔
181
}
182

183
int32_t fmGetUdafExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet) {
52,272 ✔
184
#ifdef USE_UDF
185
  if (!fmIsUserDefinedFunc(funcId)) {
52,272 ✔
186
    return TSDB_CODE_FAILED;
×
187
  }
188
  pFpSet->getEnv = udfAggGetEnv;
52,272 ✔
189
  pFpSet->init = udfAggInit;
52,272 ✔
190
  pFpSet->process = udfAggProcess;
52,272 ✔
191
  pFpSet->finalize = udfAggFinalize;
52,272 ✔
192
  return TSDB_CODE_SUCCESS;
52,272 ✔
193
#else
194
  TAOS_RETURN(TSDB_CODE_OPS_NOT_SUPPORT);
195
#endif
196
}
197

198
int32_t fmGetScalarFuncExecFuncs(int32_t funcId, SScalarFuncExecFuncs* pFpSet) {
999,459,195 ✔
199
  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {
999,459,195 ✔
200
    return TSDB_CODE_FAILED;
106,390 ✔
201
  }
202
  pFpSet->process = funcMgtBuiltins[funcId].sprocessFunc;
999,455,492 ✔
203
  pFpSet->getEnv = funcMgtBuiltins[funcId].getEnvFunc;
999,474,813 ✔
204
  return TSDB_CODE_SUCCESS;
999,493,000 ✔
205
}
206

207
bool fmIsAggFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_AGG_FUNC); }
2,147,483,647 ✔
208

209
bool fmIsScalarFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SCALAR_FUNC); }
2,147,483,647 ✔
210

211
bool fmIsVectorFunc(int32_t funcId) { return !fmIsScalarFunc(funcId) && !fmIsPseudoColumnFunc(funcId); }
1,379,836,101 ✔
212

213
bool fmIsSelectColsFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SELECT_COLS_FUNC); }
161,282,856 ✔
214

215
bool fmIsSelectFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SELECT_FUNC); }
2,080,778,426 ✔
216

217
bool fmIsTimelineFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_TIMELINE_FUNC); }
1,249,530,773 ✔
218

219
bool fmIsDateTimeFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_DATETIME_FUNC); }
632,129,138 ✔
220

221
bool fmIsPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_PSEUDO_COLUMN_FUNC); }
2,147,483,647 ✔
222

223
bool fmIsScanPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SCAN_PC_FUNC); }
2,147,483,647 ✔
224

225
bool fmIsWindowPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_WINDOW_PC_FUNC); }
1,569,644,142 ✔
226

227
bool fmIsWindowClauseFunc(int32_t funcId) { return fmIsAggFunc(funcId) || fmIsWindowPseudoColumnFunc(funcId); }
64,295,753 ✔
228

229
bool fmIsWindowIndefRowsFunc(int32_t funcId) { return fmIsVectorFunc(funcId) || fmIsWindowPseudoColumnFunc(funcId); }
427,920 ✔
230

231
bool fmIsStreamWindowClauseFunc(int32_t funcId) { return fmIsWindowClauseFunc(funcId) || fmIsPlaceHolderFunc(funcId); }
1,222,857 ✔
232

233
bool fmIsStreamVectorFunc(int32_t funcId) { return fmIsVectorFunc(funcId) || fmIsPlaceHolderFunc(funcId); }
10,727 ✔
234

235
bool fmIsIndefiniteRowsFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_INDEFINITE_ROWS_FUNC); }
1,712,805,560 ✔
236

237
bool fmIsSpecialDataRequiredFunc(int32_t funcId) {
97,806,244 ✔
238
  return isSpecificClassifyFunc(funcId, FUNC_MGT_SPECIAL_DATA_REQUIRED);
97,806,244 ✔
239
}
240

241
bool fmIsDynamicScanOptimizedFunc(int32_t funcId) {
47,185,847 ✔
242
  return isSpecificClassifyFunc(funcId, FUNC_MGT_DYNAMIC_SCAN_OPTIMIZED);
47,185,847 ✔
243
}
244

245
bool fmIsMultiResFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_MULTI_RES_FUNC); }
1,284,267,255 ✔
246

247
bool fmIsRepeatScanFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_REPEAT_SCAN_FUNC); }
1,262,791,272 ✔
248

249
bool fmIsUserDefinedFunc(int32_t funcId) { return funcId > FUNC_UDF_ID_START; }
2,147,483,647 ✔
250

251
bool fmIsForbidFillFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_FORBID_FILL_FUNC); }
632,442,027 ✔
252

253
bool fmIsIntervalInterpoFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_INTERVAL_INTERPO_FUNC); }
70,096,616 ✔
254

255
bool fmIsSystemInfoFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SYSTEM_INFO_FUNC); }
635,715,985 ✔
256

257
bool fmIsImplicitTsFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_IMPLICIT_TS_FUNC); }
2,147,483,647 ✔
258

259
bool fmIsClientPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_CLIENT_PC_FUNC); }
643,992,464 ✔
260

261
bool fmIsMultiRowsFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_MULTI_ROWS_FUNC); }
1,259,873,538 ✔
262

263
static bool fmIsKeepOrderFuncId(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_KEEP_ORDER_FUNC); }
760,867,194 ✔
264

265
bool fmIsKeepOrderFunc(SFunctionNode* pFunc) {
767,738,063 ✔
266
  if (pFunc->funcType == FUNCTION_TYPE_TOP || pFunc->funcType == FUNCTION_TYPE_BOTTOM ||
767,738,063 ✔
267
      pFunc->funcType == FUNCTION_TYPE_SAMPLE) {
763,417,476 ✔
268
    if (pFunc->pParameterList != NULL && pFunc->pParameterList->length >= 2) {
6,862,753 ✔
269
      SNode* pParam = nodesListGetNode(pFunc->pParameterList, 1);
6,880,374 ✔
270
      if (pParam != NULL && nodeType(pParam) == QUERY_NODE_VALUE) {
6,880,374 ✔
271
        SValueNode* pConst = (SValueNode*)pParam;
6,880,374 ✔
272
        if (pConst->datum.i == 1) {
6,880,374 ✔
273
          return true;
816,040 ✔
274
        }
275
      }
276
    }
277
    return false;
6,054,924 ✔
278
  }
279
  return fmIsKeepOrderFuncId(pFunc->funcId);
760,876,018 ✔
280
}
281

282
bool fmIsCumulativeFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_CUMULATIVE_FUNC); }
163,978,863 ✔
283

284
bool fmIsForbidSysTableFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_FORBID_SYSTABLE_FUNC); }
632,342,113 ✔
285

286
bool fmIsInterpFunc(int32_t funcId) {
1,296,118,617 ✔
287
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
1,296,118,617 ✔
288
    return false;
421,614 ✔
289
  }
290
  return FUNCTION_TYPE_INTERP == funcMgtBuiltins[funcId].type;
1,295,699,710 ✔
291
}
292

293
bool fmIsInterpPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_INTERP_PC_FUNC); }
1,274,375,420 ✔
294

295
bool fmIsForecastFunc(int32_t funcId) {
1,243,054,207 ✔
296
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
1,243,054,207 ✔
297
    return false;
426,511 ✔
298
  }
299
  return FUNCTION_TYPE_FORECAST == funcMgtBuiltins[funcId].type;
1,242,629,205 ✔
300
}
301

302
bool fmIsAnalysisPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_ANALYTICS_PC_FUNC); }
1,277,478,546 ✔
303

304
bool fmIsImputationCorrelationFunc(int32_t funcId) {
×
305
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
×
306
    return false;
×
307
  }
308

309
  int32_t type = funcMgtBuiltins[funcId].type;
×
310
  return FUNCTION_TYPE_IMPUTATION == type || FUNCTION_TYPE_DTW == type || FUNCTION_TYPE_DTW_PATH == type ||
×
311
         FUNCTION_TYPE_TLCC == type;
312
}
313

314
bool fmIsLastRowFunc(int32_t funcId) {
74,146,897 ✔
315
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
74,146,897 ✔
316
    return false;
240 ✔
317
  }
318
  return FUNCTION_TYPE_LAST_ROW == funcMgtBuiltins[funcId].type;
74,146,949 ✔
319
}
320

321
bool fmIsLastFunc(int32_t funcId) {
13,580 ✔
322
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
13,580 ✔
323
    return false;
×
324
  }
325
  return FUNCTION_TYPE_LAST == funcMgtBuiltins[funcId].type;
13,580 ✔
326
}
327

328
bool fmIsNotNullOutputFunc(int32_t funcId) {
512,779,483 ✔
329
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
512,779,483 ✔
330
    return false;
108,447 ✔
331
  }
332
  return FUNCTION_TYPE_LAST == funcMgtBuiltins[funcId].type ||
512,679,208 ✔
333
         FUNCTION_TYPE_CACHE_LAST == funcMgtBuiltins[funcId].type ||
493,454,831 ✔
334
         FUNCTION_TYPE_LAST_PARTIAL == funcMgtBuiltins[funcId].type ||
492,088,173 ✔
335
         FUNCTION_TYPE_LAST_MERGE == funcMgtBuiltins[funcId].type ||
482,574,268 ✔
336
         FUNCTION_TYPE_FIRST == funcMgtBuiltins[funcId].type ||
478,703,286 ✔
337
         FUNCTION_TYPE_FIRST_PARTIAL == funcMgtBuiltins[funcId].type ||
465,899,873 ✔
338
         FUNCTION_TYPE_FIRST_MERGE == funcMgtBuiltins[funcId].type ||
460,469,518 ✔
339
         FUNCTION_TYPE_COUNT == funcMgtBuiltins[funcId].type ||
458,395,585 ✔
340
         FUNCTION_TYPE_HYPERLOGLOG == funcMgtBuiltins[funcId].type ||
401,301,314 ✔
341
         FUNCTION_TYPE_HYPERLOGLOG_PARTIAL == funcMgtBuiltins[funcId].type ||
1,403,288,227 ✔
342
         FUNCTION_TYPE_HYPERLOGLOG_MERGE == funcMgtBuiltins[funcId].type;
397,133,290 ✔
343
}
344

345
bool fmIsSelectValueFunc(int32_t funcId) {
369,379,401 ✔
346
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
369,379,401 ✔
347
    return false;
×
348
  }
349
  return FUNCTION_TYPE_SELECT_VALUE == funcMgtBuiltins[funcId].type;
369,379,401 ✔
350
}
351

352
bool fmIsGroupKeyFunc(int32_t funcId) {
281,369,779 ✔
353
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
281,369,779 ✔
354
    return false;
×
355
  }
356
  return FUNCTION_TYPE_GROUP_KEY == funcMgtBuiltins[funcId].type;
281,369,779 ✔
357
}
358

359
bool fmIsHasNullFunc(int32_t funcId) {
×
360
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
×
361
    return false;
×
362
  }
363
  return FUNCTION_TYPE_HAS_NULL == funcMgtBuiltins[funcId].type;
×
364
}
365

366
bool fmisSelectGroupConstValueFunc(int32_t funcId) {
17,564,965 ✔
367
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
17,564,965 ✔
368
    return false;
×
369
  }
370
  return FUNCTION_TYPE_GROUP_CONST_VALUE == funcMgtBuiltins[funcId].type;
17,564,965 ✔
371
}
372

373
bool fmIsElapsedFunc(int32_t funcId) {
11,679,415 ✔
374
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
11,679,415 ✔
375
    return false;
×
376
  }
377
  return FUNCTION_TYPE_ELAPSED == funcMgtBuiltins[funcId].type;
11,679,415 ✔
378
}
379

380
bool fmIsBlockDistFunc(int32_t funcId) {
632,122,749 ✔
381
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
632,122,749 ✔
382
    return false;
201,510 ✔
383
  }
384
  return FUNCTION_TYPE_BLOCK_DIST == funcMgtBuiltins[funcId].type;
631,925,042 ✔
385
}
386

387
bool fmIsDBUsageFunc(int32_t funcId) {
632,119,531 ✔
388
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
632,119,531 ✔
389
    return false;
206,179 ✔
390
  }
391
  return FUNCTION_TYPE_DB_USAGE == funcMgtBuiltins[funcId].type;
631,915,831 ✔
392
}
393

394
bool fmIsProcessByRowFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_PROCESS_BY_ROW); }
864,943,306 ✔
395

396
bool fmIsVolatileFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_VOLATILE_FUNC); }
933,049,442 ✔
397

398
bool fmIsNoPushdownFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_NO_PUSHDOWN_FUNC); }
44,531,151 ✔
399

400
bool fmIsIgnoreNullFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_IGNORE_NULL_FUNC); }
322,243 ✔
401

402
void fmFuncMgtDestroy() {
1,691,760 ✔
403
  void* m = gFunMgtService.pFuncNameHashTable;
1,691,760 ✔
404
  if (m != NULL && atomic_val_compare_exchange_ptr((void**)&gFunMgtService.pFuncNameHashTable, m, 0) == m) {
1,691,760 ✔
405
    taosHashCleanup(m);
1,691,696 ✔
406
  }
407
}
1,691,760 ✔
408

409
#ifdef BUILD_NO_CALL
410
int32_t fmSetNormalFunc(int32_t funcId, SFuncExecFuncs* pFpSet) {
411
  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {
412
    return TSDB_CODE_FAILED;
413
  }
414
  pFpSet->process = funcMgtBuiltins[funcId].processFunc;
415
  return TSDB_CODE_SUCCESS;
416
}
417
#endif
418

419
// function has same input/output type
420
bool fmIsSameInOutType(int32_t funcId) {
50,430,024 ✔
421
  bool res = false;
50,430,024 ✔
422
  switch (funcMgtBuiltins[funcId].type) {
50,430,024 ✔
423
    case FUNCTION_TYPE_MAX:
19,783,424 ✔
424
    case FUNCTION_TYPE_MIN:
425
    case FUNCTION_TYPE_TOP:
426
    case FUNCTION_TYPE_BOTTOM:
427
    case FUNCTION_TYPE_FIRST:
428
    case FUNCTION_TYPE_LAST:
429
    case FUNCTION_TYPE_SAMPLE:
430
    case FUNCTION_TYPE_TAIL:
431
    case FUNCTION_TYPE_UNIQUE:
432
      res = true;
19,783,424 ✔
433
      break;
19,783,424 ✔
434
    default:
30,646,600 ✔
435
      break;
30,646,600 ✔
436
  }
437
  return res;
50,430,024 ✔
438
}
439

440
bool fmIsConstantResFunc(SFunctionNode* pFunc) {
15,561,624 ✔
441
  SNode* pNode;
442
  FOREACH(pNode, pFunc->pParameterList) {
15,654,600 ✔
443
    if (nodeType(pNode) != QUERY_NODE_VALUE) {
171,334 ✔
444
      return false;
78,358 ✔
445
    }
446
  }
447
  return true;
15,483,266 ✔
448
}
449

450
bool fmIsSkipScanCheckFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SKIP_SCAN_CHECK_FUNC); }
47,182,933 ✔
451

452
bool fmIsPrimaryKeyFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_PRIMARY_KEY_FUNC); }
549,938,446 ✔
453

454
bool fmIsPlaceHolderFunc(int32_t funcId) {return isSpecificClassifyFunc(funcId, FUNC_MGT_PLACE_HOLDER_FUNC); }
2,147,483,647 ✔
455

456
bool fmIsPlaceHolderFuncForExternalWin(int32_t funcId) {
738,370 ✔
457
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
738,370 ✔
458
    return false;
×
459
  }
460
  return (funcMgtBuiltins[funcId].type == FUNCTION_TYPE_WSTART || funcMgtBuiltins[funcId].type == FUNCTION_TYPE_WEND ||
1,239,515 ✔
461
          funcMgtBuiltins[funcId].type == FUNCTION_TYPE_WDURATION);
501,145 ✔
462
}
463

464
void getLastCacheDataType(SDataType* pType, int32_t pkBytes) {
×
465
  // TODO: do it later.
466
  pType->bytes = getFirstLastInfoSize(pType->bytes, pkBytes) + VARSTR_HEADER_SIZE;
×
467
  pType->type = TSDB_DATA_TYPE_BINARY;
×
468
}
×
469

470
static int32_t getFuncInfo(SFunctionNode* pFunc) {
161,500,243 ✔
471
  char msg[128] = {0};
161,500,243 ✔
472
  return fmGetFuncInfo(pFunc, msg, sizeof(msg));
161,500,243 ✔
473
}
474

475
int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** ppFunc) {
10,802,059 ✔
476
  int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)ppFunc);
10,802,059 ✔
477
  if (NULL == *ppFunc) {
10,802,059 ✔
478
    return code;
×
479
  }
480
  (void)snprintf((*ppFunc)->functionName, sizeof((*ppFunc)->functionName), "%s", pName);
10,802,059 ✔
481
  (*ppFunc)->pParameterList = pParameterList;
10,802,059 ✔
482
  code = getFuncInfo((*ppFunc));
10,802,059 ✔
483
  if (TSDB_CODE_SUCCESS != code) {
10,802,059 ✔
484
    (*ppFunc)->pParameterList = NULL;
×
485
    nodesDestroyNode((SNode*)*ppFunc);
×
486
    *ppFunc = NULL;
×
487
    return code;
×
488
  }
489
  return code;
10,802,059 ✔
490
}
491

492
static void resetOutputChangedFunc(SFunctionNode *pFunc, const SFunctionNode* pSrcFunc) {
150,699,177 ✔
493
  if (funcMgtBuiltins[pFunc->funcId].type == FUNCTION_TYPE_LAST_MERGE) {
150,699,177 ✔
494
    pFunc->node.resType = pSrcFunc->node.resType;
24,052,366 ✔
495
    return;
24,052,366 ✔
496
  }
497
}
498

499
int32_t createFunctionWithSrcFunc(const char* pName, const SFunctionNode* pSrcFunc, SNodeList* pParameterList, SFunctionNode** ppFunc) {
150,698,559 ✔
500
  int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)ppFunc);
150,698,559 ✔
501
  if (NULL == *ppFunc) {
150,702,291 ✔
502
    return code;
×
503
  }
504

505
  (*ppFunc)->hasPk = pSrcFunc->hasPk;
150,702,291 ✔
506
  (*ppFunc)->pkBytes = pSrcFunc->pkBytes;
150,702,291 ✔
507
  (*ppFunc)->pSrcFuncRef = pSrcFunc;
150,702,291 ✔
508

509
  (void)snprintf((*ppFunc)->functionName, sizeof((*ppFunc)->functionName), "%s", pName);
150,702,291 ✔
510
  (*ppFunc)->pParameterList = pParameterList;
150,702,291 ✔
511
  code = getFuncInfo((*ppFunc));
150,702,291 ✔
512
  if (TSDB_CODE_SUCCESS != code) {
150,700,509 ✔
513
    (*ppFunc)->pParameterList = NULL;
×
514
    nodesDestroyNode((SNode*)*ppFunc);
×
515
    *ppFunc = NULL;
×
516
    return code;
×
517
  }
518
  resetOutputChangedFunc(*ppFunc, pSrcFunc);
150,700,509 ✔
519
  (*ppFunc)->node.relatedTo = pSrcFunc->node.relatedTo;
150,700,794 ✔
520
  (*ppFunc)->node.bindExprID = pSrcFunc->node.bindExprID;
150,700,794 ✔
521
  return code;
150,700,794 ✔
522
}
523

524
static int32_t createColumnByFunc(const SFunctionNode* pFunc, SColumnNode** ppCol) {
100,263,148 ✔
525
  int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)ppCol);
100,263,148 ✔
526
  if (NULL == *ppCol) {
100,267,502 ✔
527
    return code;
×
528
  }
529
  tstrncpy((*ppCol)->colName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
100,267,502 ✔
530
  (*ppCol)->node.resType = pFunc->node.resType;
100,267,502 ✔
531
  return TSDB_CODE_SUCCESS;
100,267,502 ✔
532
}
533

534
bool fmIsDistExecFunc(int32_t funcId) {
394,205,408 ✔
535
  if (fmIsUserDefinedFunc(funcId)) {
394,205,408 ✔
536
    return false;
120,984 ✔
537
  }
538
  if (!fmIsVectorFunc(funcId)) {
394,103,694 ✔
539
    return true;
555,338 ✔
540
  }
541
  return (NULL != funcMgtBuiltins[funcId].pPartialFunc && NULL != funcMgtBuiltins[funcId].pMergeFunc);
393,556,209 ✔
542
}
543

544
static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNode** pPartialFunc) {
50,430,544 ✔
545
  SNodeList* pParameterList = NULL;
50,430,544 ✔
546
  int32_t    code = nodesCloneList(pSrcFunc->pParameterList, &pParameterList);
50,430,544 ✔
547
  if (NULL == pParameterList) {
50,432,491 ✔
548
    return code;
×
549
  }
550
  code =
551
      createFunctionWithSrcFunc(funcMgtBuiltins[pSrcFunc->funcId].pPartialFunc, pSrcFunc, pParameterList, pPartialFunc);
50,432,491 ✔
552
  if (TSDB_CODE_SUCCESS != code) {
50,431,126 ✔
553
    nodesDestroyList(pParameterList);
1,897 ✔
554
    return code;
×
555
  }
556
  (*pPartialFunc)->hasOriginalFunc = true;
50,429,229 ✔
557
  (*pPartialFunc)->originalFuncId = pSrcFunc->hasOriginalFunc ? pSrcFunc->originalFuncId : pSrcFunc->funcId;
50,429,229 ✔
558
  char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};
50,429,165 ✔
559

560
  int32_t len = snprintf(name, sizeof(name), "%s.%p", (*pPartialFunc)->functionName, pSrcFunc);
50,429,165 ✔
561
  if (taosHashBinary(name, len, sizeof(name)) < 0) {
50,432,256 ✔
562
    return TSDB_CODE_FAILED;
×
563
  }
564
  tstrncpy((*pPartialFunc)->node.aliasName, name, TSDB_COL_NAME_LEN);
50,432,256 ✔
565
  return TSDB_CODE_SUCCESS;
50,432,256 ✔
566
}
567

568
static int32_t createMergeFuncPara(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,
100,263,078 ✔
569
                                   SNodeList** pParameterList) {
570
  SNode*  pRes = NULL;
100,263,078 ✔
571
  int32_t code = createColumnByFunc(pPartialFunc, (SColumnNode**)&pRes);
100,263,078 ✔
572
  if (TSDB_CODE_SUCCESS != code) {
100,266,858 ✔
573
    return code;
×
574
  }
575
  if (NULL != funcMgtBuiltins[pSrcFunc->funcId].createMergeParaFuc) {
100,266,858 ✔
576
    return funcMgtBuiltins[pSrcFunc->funcId].createMergeParaFuc(pSrcFunc->pParameterList, pRes, pParameterList);
766,894 ✔
577
  } else {
578
    return nodesListMakeStrictAppend(pParameterList, pRes);
99,499,964 ✔
579
  }
580
}
581

582
static int32_t createMidFunction(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,
49,831,849 ✔
583
                                 SFunctionNode** pMidFunc) {
584
  SNodeList*     pParameterList = NULL;
49,831,849 ✔
585
  SFunctionNode* pFunc = NULL;
49,831,849 ✔
586

587
  int32_t code = createMergeFuncPara(pSrcFunc, pPartialFunc, &pParameterList);
49,831,849 ✔
588
  if (TSDB_CODE_SUCCESS == code) {
49,835,506 ✔
589
    if(funcMgtBuiltins[pSrcFunc->funcId].pMiddleFunc != NULL){
49,835,576 ✔
590
      code = createFunctionWithSrcFunc(funcMgtBuiltins[pSrcFunc->funcId].pMiddleFunc, pSrcFunc, pParameterList, &pFunc);
5,715,022 ✔
591
    }else{
592
      code = createFunctionWithSrcFunc(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pSrcFunc, pParameterList, &pFunc);
44,120,554 ✔
593
    }
594
  }
595
  if (TSDB_CODE_SUCCESS == code) {
49,835,111 ✔
596
    tstrncpy(pFunc->node.aliasName, pPartialFunc->node.aliasName, TSDB_COL_NAME_LEN);
49,835,696 ✔
597
  }
598

599
  if (TSDB_CODE_SUCCESS == code) {
49,835,111 ✔
600
    *pMidFunc = pFunc;
49,835,111 ✔
601
  } else {
602
    nodesDestroyList(pParameterList);
×
603
  }
604
  return code;
49,835,041 ✔
605
}
606

607
static int32_t createMergeFunction(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,
50,430,594 ✔
608
                                   SFunctionNode** pMergeFunc) {
609
  SNodeList*     pParameterList = NULL;
50,430,594 ✔
610
  SFunctionNode* pFunc = NULL;
50,430,594 ✔
611

612
  int32_t code = createMergeFuncPara(pSrcFunc, pPartialFunc, &pParameterList);
50,430,594 ✔
613
  if (TSDB_CODE_SUCCESS == code) {
50,432,701 ✔
614
    code = createFunctionWithSrcFunc(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pSrcFunc, pParameterList, &pFunc);
50,432,631 ✔
615
  }
616
  if (TSDB_CODE_SUCCESS == code) {
50,434,376 ✔
617
    pFunc->hasOriginalFunc = true;
50,432,569 ✔
618
    pFunc->originalFuncId = pSrcFunc->hasOriginalFunc ? pSrcFunc->originalFuncId : pSrcFunc->funcId;
50,432,569 ✔
619
    // overwrite function restype set by translate function
620
    if (fmIsSameInOutType(pSrcFunc->funcId)) {
50,432,569 ✔
621
      pFunc->node.resType = pSrcFunc->node.resType;
19,783,304 ✔
622
    }
623
    tstrncpy(pFunc->node.aliasName, pSrcFunc->node.aliasName, TSDB_COL_NAME_LEN);
50,430,119 ✔
624
  }
625

626
  if (TSDB_CODE_SUCCESS == code) {
50,431,926 ✔
627
    *pMergeFunc = pFunc;
50,431,926 ✔
628
  } else {
629
    nodesDestroyList(pParameterList);
×
630
  }
631
  return code;
50,432,091 ✔
632
}
633

634
int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMidFunc,
50,428,957 ✔
635
                        SFunctionNode** pMergeFunc) {
636
  if (!fmIsDistExecFunc(pFunc->funcId)) {
50,428,957 ✔
637
    return TSDB_CODE_FAILED;
×
638
  }
639

640
  int32_t code = createPartialFunction(pFunc, pPartialFunc);
50,432,561 ✔
641
  if (TSDB_CODE_SUCCESS == code && pMidFunc) {
50,430,619 ✔
642
    code = createMidFunction(pFunc, *pPartialFunc, pMidFunc);
49,832,999 ✔
643
  }
644
  if (TSDB_CODE_SUCCESS == code) {
50,432,801 ✔
645
    code = createMergeFunction(pFunc, *pPartialFunc, pMergeFunc);
50,432,186 ✔
646
  }
647

648
  if (TSDB_CODE_SUCCESS != code) {
50,432,636 ✔
649
    nodesDestroyNode((SNode*)*pPartialFunc);
×
650
    if (pMidFunc) nodesDestroyNode((SNode*)*pMidFunc);
×
651
    nodesDestroyNode((SNode*)*pMergeFunc);
×
652
  }
653

654
  return code;
50,432,351 ✔
655
}
656

657
const char* fmGetFuncName(int32_t funcId) {
363,986 ✔
658
  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {
363,986 ✔
659
    return "invalid function";
×
660
  }
661
  return funcMgtBuiltins[funcId].name;
363,986 ✔
662
}
663

664
/// @param [out] pStateFunc, not changed if error occured or no need to create state func
665
/// @retval 0 for succ, otherwise err occured
666
static int32_t fmCreateStateFunc(const SFunctionNode* pFunc, SFunctionNode** pStateFunc) {
9,096 ✔
667
  if (funcMgtBuiltins[pFunc->funcId].pStateFunc) {
9,096 ✔
668
    SNodeList* pParams = NULL;
9,096 ✔
669
    int32_t    code = nodesCloneList(pFunc->pParameterList, &pParams);
9,096 ✔
670
    if (!pParams) return code;
9,096 ✔
671
    code = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams, pStateFunc);
9,096 ✔
672
    if (TSDB_CODE_SUCCESS != code) {
9,096 ✔
673
      nodesDestroyList(pParams);
×
674
      return code;
×
675
    }
676
    tstrncpy((*pStateFunc)->node.aliasName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
9,096 ✔
677
    tstrncpy((*pStateFunc)->node.userAlias, pFunc->node.userAlias, TSDB_COL_NAME_LEN);
9,096 ✔
678
  }
679
  return TSDB_CODE_SUCCESS;
9,096 ✔
680
}
681

682
bool fmIsTSMASupportedFunc(func_id_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_TSMA_FUNC); }
1,571,159 ✔
683

684
bool fmIsRsmaSupportedFunc(func_id_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_RSMA_FUNC); }
145,889 ✔
685

686
int32_t fmCreateStateFuncs(SNodeList* pFuncs) {
4,001 ✔
687
  int32_t code;
688
  SNode*  pNode;
689
  char    buf[128] = {0};
4,001 ✔
690
  FOREACH(pNode, pFuncs) {
13,097 ✔
691
    SFunctionNode* pFunc = (SFunctionNode*)pNode;
9,096 ✔
692
    code = fmGetFuncInfo(pFunc, buf, 128);
9,096 ✔
693
    if (code) break;
9,096 ✔
694
    if (fmIsTSMASupportedFunc(pFunc->funcId)) {
9,096 ✔
695
      SFunctionNode* pNewFunc = NULL;
9,096 ✔
696
      code = fmCreateStateFunc(pFunc, &pNewFunc);
9,096 ✔
697
      if (code) {
9,096 ✔
698
        // error
699
        break;
×
700
      } else if (!pNewFunc) {
9,096 ✔
701
        // no need state func
702
        continue;
×
703
      } else {
704
        REPLACE_NODE(pNewFunc);
9,096 ✔
705
        nodesDestroyNode(pNode);
9,096 ✔
706
      }
707
    }
708
  }
709
  return code;
4,001 ✔
710
}
711

712
static int32_t fmCreateStateMergeFunc(SFunctionNode* pFunc, SFunctionNode** pStateMergeFunc) {
2,002 ✔
713
  if (funcMgtBuiltins[pFunc->funcId].pMergeFunc) {
2,002 ✔
714
    SNodeList* pParams = NULL;
1,638 ✔
715
    int32_t    code = nodesCloneList(pFunc->pParameterList, &pParams);
1,638 ✔
716
    if (!pParams) return code;
1,638 ✔
717
    code = createFunctionWithSrcFunc(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pFunc, pParams, pStateMergeFunc);
1,638 ✔
718
    if (TSDB_CODE_SUCCESS != code) {
1,638 ✔
719
      nodesDestroyList(pParams);
×
720
      return code;
×
721
    }
722
    tstrncpy((*pStateMergeFunc)->node.aliasName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);
1,638 ✔
723
    tstrncpy((*pStateMergeFunc)->node.userAlias, pFunc->node.userAlias, TSDB_COL_NAME_LEN);
1,638 ✔
724
  }
725
  return TSDB_CODE_SUCCESS;
2,002 ✔
726
}
727

728
int32_t fmCreateStateMergeFuncs(SNodeList* pFuncs) {
910 ✔
729
  int32_t code;
730
  SNode*  pNode;
731
  char    buf[128] = {0};
910 ✔
732
  FOREACH(pNode, pFuncs) {
2,912 ✔
733
    SFunctionNode* pFunc = (SFunctionNode*)pNode;
2,002 ✔
734
    if (fmIsTSMASupportedFunc(pFunc->funcId)) {
2,002 ✔
735
      SFunctionNode* pNewFunc = NULL;
2,002 ✔
736
      code = fmCreateStateMergeFunc(pFunc, &pNewFunc);
2,002 ✔
737
      if (code) {
2,002 ✔
738
        // error
739
        break;
×
740
      } else if (!pNewFunc) {
2,002 ✔
741
        // no state merge func
742
        continue;
364 ✔
743
      } else {
744
        REPLACE_NODE(pNewFunc);
1,638 ✔
745
        nodesDestroyNode(pNode);
1,638 ✔
746
      }
747
    }
748
  }
749
  return code;
910 ✔
750
}
751

752
int32_t fmGetFuncId(const char* name) {
9,007,940 ✔
753
  if (NULL != gFunMgtService.pFuncNameHashTable) {
9,007,940 ✔
754
    void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, name, strlen(name));
9,007,940 ✔
755
    if (NULL != pVal) {
9,007,940 ✔
756
      return *(int32_t*)pVal;
9,007,940 ✔
757
    }
758
    return -1;
×
759
  }
760
  for (int32_t i = 0; i < funcMgtBuiltinsNum; ++i) {
×
761
    if (0 == strcmp(funcMgtBuiltins[i].name, name)) {
×
762
      return i;
×
763
    }
764
  }
765
  return -1;
×
766
}
767

768
int32_t fmGetTwstartFuncId() {
1,894,765 ✔
769
  static int32_t twstartFuncId = -2;
770
  if (twstartFuncId < 0) {
1,894,765 ✔
771
    twstartFuncId = fmGetFuncId("_twstart");
1,691,696 ✔
772
  }
773
  return twstartFuncId;
1,894,765 ✔
774
}
775

776
int32_t fmGetTwendFuncId() {
1,727,984 ✔
777
  static int32_t twendFuncId = -2;
778
  if (twendFuncId < 0) {
1,727,984 ✔
779
    twendFuncId = fmGetFuncId("_twend");
1,691,696 ✔
780
  }
781
  return twendFuncId;
1,727,984 ✔
782
}
783

784
int32_t fmGetTwdurationFuncId() {
1,692,151 ✔
785
  static int32_t twdurationFuncId = -2;
786
  if (twdurationFuncId < 0) {
1,692,151 ✔
787
    twdurationFuncId = fmGetFuncId("_twduration");
1,691,696 ✔
788
  }
789
  return twdurationFuncId;
1,692,151 ✔
790
}
791

792
int32_t fmGetExternalWindowColumnFuncId() {
1,739,937 ✔
793
  static int32_t externalWindowColumnFuncId = -2;
794
  if (externalWindowColumnFuncId < 0) {
1,739,937 ✔
795
    externalWindowColumnFuncId = fmGetFuncId("_external_window_column");
1,691,696 ✔
796
  }
797
  return externalWindowColumnFuncId;
1,739,937 ✔
798
}
799

800
bool fmIsMyStateFunc(int32_t funcId, int32_t stateFuncId) {
2,576,028 ✔
801
  const SBuiltinFuncDefinition* pFunc = &funcMgtBuiltins[funcId];
2,576,028 ✔
802
  const SBuiltinFuncDefinition* pStateFunc = &funcMgtBuiltins[stateFuncId];
2,576,028 ✔
803
  if (!pFunc->pStateFunc) {
2,576,028 ✔
804
    return false;
×
805
  }
806
  if (strcmp(pFunc->pStateFunc, pStateFunc->name) == 0) return true;
2,576,028 ✔
807
  int32_t stateMergeFuncId = fmGetFuncId(pFunc->pStateFunc);
938,210 ✔
808
  if (stateMergeFuncId == -1) {
938,210 ✔
809
    return false;
×
810
  }
811
  const SBuiltinFuncDefinition* pStateMergeFunc = &funcMgtBuiltins[stateMergeFuncId];
938,210 ✔
812
  return strcmp(pStateFunc->name, pStateMergeFunc->pMergeFunc) == 0;
938,210 ✔
813
}
814

815
bool fmIsCountLikeFunc(int32_t funcId) {
602,738,435 ✔
816
  return isSpecificClassifyFunc(funcId, FUNC_MGT_COUNT_LIKE_FUNC);
602,738,435 ✔
817
}
818

819
bool fmIsRowTsOriginFunc(int32_t funcId) {
5,807,051 ✔
820
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
5,807,051 ✔
821
    return false;
×
822
  }
823
  return FUNCTION_TYPE_IROWTS_ORIGIN == funcMgtBuiltins[funcId].type;
5,807,051 ✔
824
}
825

826
bool fmIsGroupIdFunc(int32_t funcId) {
2,538,512 ✔
827
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
2,538,512 ✔
828
    return false;
×
829
  }
830
  return FUNCTION_TYPE_GROUP_ID == funcMgtBuiltins[funcId].type;
2,538,512 ✔
831
}
832

833
const void* fmGetExternalWindowColumnFuncVal(const SStreamRuntimeFuncInfo* pStreamRuntimeFuncInfo, int32_t index) {
11,343,788 ✔
834
  SSTriggerCalcParam *pParams = taosArrayGet(pStreamRuntimeFuncInfo->pStreamPesudoFuncVals, pStreamRuntimeFuncInfo->curIdx);
11,343,788 ✔
835
  if (pParams == NULL || pParams->pExternalWindowData == NULL || index < 0) {
11,365,196 ✔
836
    return NULL;
×
837
  }
838
  return taosArrayGet(pParams->pExternalWindowData, index);
11,365,196 ✔
839
}
840

841
const void* fmGetStreamPesudoFuncVal(int32_t funcId, const SStreamRuntimeFuncInfo* pStreamRuntimeFuncInfo) {
438,429,992 ✔
842
  switch (funcMgtBuiltins[funcId].type) {
438,429,992 ✔
843
    case FUNCTION_TYPE_TGRPID:
155,308 ✔
844
      return &pStreamRuntimeFuncInfo->groupId;
155,308 ✔
845
    case FUNCTION_TYPE_PLACEHOLDER_COLUMN:
1,033,364 ✔
846
      return pStreamRuntimeFuncInfo->pStreamPartColVals;
1,033,364 ✔
847
    case FUNCTION_TYPE_PLACEHOLDER_TBNAME:
2,369,716 ✔
848
      return pStreamRuntimeFuncInfo->pStreamPartColVals;
2,369,716 ✔
849
    default:
434,930,209 ✔
850
      break;
434,930,209 ✔
851
  }
852

853
  SSTriggerCalcParam *pParams = taosArrayGet(pStreamRuntimeFuncInfo->pStreamPesudoFuncVals, pStreamRuntimeFuncInfo->curIdx);
434,930,209 ✔
854
  switch (funcMgtBuiltins[funcId].type) {
435,036,759 ✔
855
    case FUNCTION_TYPE_TPREV_TS:
×
856
      return &pParams->prevTs;
×
857
    case FUNCTION_TYPE_TCURRENT_TS:
2,425,225 ✔
858
      return &pParams->currentTs;
2,425,225 ✔
859
    case FUNCTION_TYPE_TNEXT_TS:
×
860
      return &pParams->nextTs;
×
861
    case FUNCTION_TYPE_TWSTART:
374,526,802 ✔
862
      return &pParams->wstart;
374,526,802 ✔
863
    case FUNCTION_TYPE_TWEND:
19,856,510 ✔
864
      return &pParams->wend;
19,856,510 ✔
865
    case FUNCTION_TYPE_TWDURATION:
1,328,786 ✔
866
      return &pParams->wduration;
1,328,786 ✔
867
    case FUNCTION_TYPE_TWROWNUM:
34,668,386 ✔
868
      return &pParams->wrownum;
34,668,386 ✔
869
    case FUNCTION_TYPE_TPREV_LOCALTIME:
428,142 ✔
870
      return &pParams->prevLocalTime;
428,142 ✔
871
    case FUNCTION_TYPE_TLOCALTIME:
1,127,049 ✔
872
      return &pParams->triggerTime;
1,127,049 ✔
873
    case FUNCTION_TYPE_TNEXT_LOCALTIME:
653,640 ✔
874
      return &pParams->nextLocalTime;
653,640 ✔
875
    case FUNCTION_TYPE_TGRPID:
×
876
      return &pStreamRuntimeFuncInfo->groupId;
×
877
    case FUNCTION_TYPE_PLACEHOLDER_COLUMN:
×
878
      return pStreamRuntimeFuncInfo->pStreamPartColVals;
×
879
    case FUNCTION_TYPE_PLACEHOLDER_TBNAME:
×
880
      return pStreamRuntimeFuncInfo->pStreamPartColVals;
×
881
    case FUNCTION_TYPE_TIDLESTART:
6,966 ✔
882
      return &pParams->idlestart;
6,966 ✔
883
    case FUNCTION_TYPE_TIDLEEND:
6,966 ✔
884
      return &pParams->idleend;
6,966 ✔
885
    default:
×
886
      break;
×
887
  }
888
  return NULL;
×
889
}
890

891
bool fmIsStreamPesudoColVal(int32_t funcId) {
641,155 ✔
892
  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
641,155 ✔
893
    return false;
8,970 ✔
894
  }
895
  return funcMgtBuiltins[funcId].type == FUNCTION_TYPE_PLACEHOLDER_COLUMN
632,185 ✔
896
         || funcMgtBuiltins[funcId].type == FUNCTION_TYPE_PLACEHOLDER_TBNAME;
632,185 ✔
897
}
898

899
int32_t fmGetStreamPesudoFuncEnv(int32_t funcId, SNodeList* pParamNodes, SFuncExecEnv *pEnv) {
7,839,846 ✔
900
  if (NULL == pParamNodes || pParamNodes->length < 1) {
7,839,846 ✔
901
    uError("invalid stream pesudo func param list %p", pParamNodes);
826 ✔
902
    return TSDB_CODE_INTERNAL_ERROR;
×
903
  }
904

905
  int32_t firstParamType = nodeType(nodesListGetNode(pParamNodes, 0));
7,839,020 ✔
906
  if (QUERY_NODE_VALUE != firstParamType) {
7,839,846 ✔
907
    uError("invalid stream pesudo func first param type %d", firstParamType);
×
908
    return TSDB_CODE_INTERNAL_ERROR;
×
909
  }
910

911
  SValueNode* pResDesc = (SValueNode*)nodesListGetNode(pParamNodes, 0);
7,839,846 ✔
912
  pEnv->calcMemSize = pResDesc->node.resType.bytes;
7,840,480 ✔
913

914
  return TSDB_CODE_SUCCESS;
7,840,480 ✔
915
}
916

917

918
int32_t fmSetStreamPseudoFuncParamVal(int32_t funcId, SNodeList* pParamNodes, const SStreamRuntimeFuncInfo* pStreamRuntimeInfo) {
449,758,109 ✔
919
  if (!pStreamRuntimeInfo) {
449,758,109 ✔
920
    uError("internal error, should have pVals for stream pseudo funcs");
×
921
    return TSDB_CODE_INTERNAL_ERROR;
×
922
  }
923
  int32_t code = 0;
449,758,109 ✔
924
  SArray *pVals1 = NULL;
449,758,109 ✔
925
  SNode* pFirstParam = nodesListGetNode(pParamNodes, 0);
449,758,109 ✔
926
  if (nodeType(pFirstParam) != QUERY_NODE_VALUE) {
449,851,580 ✔
927
    uError("invalid param node type: %d for func: %d", nodeType(pFirstParam), funcId);
×
928
    return TSDB_CODE_INTERNAL_ERROR;
×
929
  }
930

931
  int32_t t = funcMgtBuiltins[funcId].type;
449,827,874 ✔
932
  uDebug("set stream pseudo func param val, functype: %d, pStreamRuntimeInfo: %p", t, pStreamRuntimeInfo);
449,848,566 ✔
933
  if (FUNCTION_TYPE_TGRPID == t) {
449,822,006 ✔
934
    SValue v = {0};
155,308 ✔
935
    v.type = TSDB_DATA_TYPE_BIGINT;
155,308 ✔
936
    v.val = *(int64_t*)fmGetStreamPesudoFuncVal(funcId, pStreamRuntimeInfo);
155,308 ✔
937
    
938
    code = nodesSetValueNodeValue((SValueNode*)pFirstParam, VALUE_GET_DATUM(&v, pFirstParam->type));
154,820 ✔
939
    if (code != 0) {
154,820 ✔
940
      uError("failed to set value node value: %s", tstrerror(code));
×
941
      return code;
×
942
    }
943
  } else if (FUNCTION_TYPE_PLACEHOLDER_COLUMN == t) {
449,666,698 ✔
944
    SNode* pSecondParam = nodesListGetNode(pParamNodes, 1);
1,033,364 ✔
945
    if (nodeType(pSecondParam) != QUERY_NODE_VALUE) {
1,033,364 ✔
946
      uError("invalid param node type: %d for func: %d", nodeType(pSecondParam), funcId);
×
947
      return TSDB_CODE_INTERNAL_ERROR;
×
948
    }
949
    SArray* pVal = (SArray*)fmGetStreamPesudoFuncVal(funcId, pStreamRuntimeInfo);
1,033,364 ✔
950
    int32_t idx = ((SValueNode*)pSecondParam)->datum.i;
1,033,364 ✔
951
    if (idx - 1 < 0 || idx - 1 >= taosArrayGetSize(pVal)) {
1,033,364 ✔
952
      uError("invalid idx: %d for func: %d, should be in [1, %d]", idx, funcId, (int32_t)taosArrayGetSize(pVal));
488 ✔
953
      return TSDB_CODE_INTERNAL_ERROR;
×
954
    }
955
    SStreamGroupValue* pValue = taosArrayGet(pVal, idx - 1);
1,033,364 ✔
956
    if (pValue == NULL) {
1,033,364 ✔
957
      uError("invalid idx: %d for func: %d, should be in [1, %d]", idx, funcId, (int32_t)taosArrayGetSize(pVal));
×
958
      return TSDB_CODE_INTERNAL_ERROR;
×
959
    }
960
    if (!pValue->isNull){
1,033,364 ✔
961
      if (pValue->data.type != ((SValueNode*)pFirstParam)->node.resType.type){
1,026,152 ✔
962
        uError("invalid value type: %d for func: %d, should be: %d", pValue->data.type, funcId, ((SValueNode*)pFirstParam)->node.resType.type);
×
963
        return TSDB_CODE_INTERNAL_ERROR;
×
964
      }
965
      if (IS_VAR_DATA_TYPE(((SValueNode*)pFirstParam)->node.resType.type)) {
1,025,664 ✔
966
        char* tmp = taosMemoryCalloc(1, pValue->data.nData + VARSTR_HEADER_SIZE); 
708,212 ✔
967
        if (tmp == NULL) {
708,700 ✔
968
          return TSDB_CODE_OUT_OF_MEMORY;
×
969
        }
970
        taosMemoryFree(((SValueNode*)pFirstParam)->datum.p);
708,700 ✔
971
        ((SValueNode*)pFirstParam)->datum.p = tmp;
708,212 ✔
972
        memcpy(varDataVal(((SValueNode*)pFirstParam)->datum.p), pValue->data.pData, pValue->data.nData);
708,212 ✔
973
        varDataLen(((SValueNode*)pFirstParam)->datum.p) = pValue->data.nData;
708,212 ✔
974
      } else {
975
        code = nodesSetValueNodeValue((SValueNode*)pFirstParam, VALUE_GET_DATUM(&pValue->data, pValue->data.type));
317,452 ✔
976
      }
977
    }
978
    ((SValueNode*)pFirstParam)->isNull = pValue->isNull;
1,032,876 ✔
979
  } else if (FUNCTION_TYPE_PLACEHOLDER_TBNAME == t) {
448,633,334 ✔
980
    SArray* pVal = (SArray*)fmGetStreamPesudoFuncVal(funcId, pStreamRuntimeInfo);
2,258,067 ✔
981
    for (int32_t i = 0; i < taosArrayGetSize(pVal); ++i) {
2,783,471 ✔
982
      SStreamGroupValue* pValue = taosArrayGet(pVal, i);
2,783,471 ✔
983
      if (pValue != NULL && pValue->isTbname) {
2,783,154 ✔
984
        taosMemoryFreeClear(((SValueNode*)pFirstParam)->datum.p);
2,259,006 ✔
985
        ((SValueNode*)pFirstParam)->datum.p = taosMemoryCalloc(pValue->data.nData + VARSTR_HEADER_SIZE, 1);
2,259,616 ✔
986
        if (NULL == ((SValueNode*)pFirstParam)->datum.p ) {
2,258,677 ✔
987
          return terrno;
×
988
        }
989

990
        (void)memcpy(varDataVal(((SValueNode*)pFirstParam)->datum.p), pValue->data.pData, pValue->data.nData);
2,258,372 ✔
991
        varDataLen(((SValueNode*)pFirstParam)->datum.p) = pValue->data.nData;
2,259,311 ✔
992
        break;
2,259,311 ✔
993
      }
994
    }
995
  } else if(FUNCTION_TYPE_EXTERNAL_WINDOW_COLUMN == t) {
446,375,267 ✔
996
    if (NULL == pParamNodes || LIST_LENGTH(pParamNodes) < 2) {
11,346,910 ✔
997
      uError("invalid stream external window column param list %p, len: %d", pParamNodes,
×
998
             pParamNodes ? LIST_LENGTH(pParamNodes) : 0);
999
      return TSDB_CODE_INTERNAL_ERROR;
×
1000
    }
1001

1002
    SNode* pParamNode = nodesListGetNode(pParamNodes, 1);
11,360,290 ✔
1003
    if (NULL == pParamNode || QUERY_NODE_VALUE != nodeType(pParamNode)) {
11,355,830 ✔
1004
      uError("invalid stream external window column param node %p type %d for func: %d", pParamNode,
10,258 ✔
1005
             pParamNode ? nodeType(pParamNode) : -1, funcId);
1006
      return TSDB_CODE_INTERNAL_ERROR;
×
1007
    }
1008

1009
    const SStreamGroupValue* pVal =
1010
        fmGetExternalWindowColumnFuncVal(pStreamRuntimeInfo, ((SValueNode*)pParamNode)->placeholderNo);
11,348,694 ✔
1011
    if (!pVal) {
11,365,196 ✔
1012
      uError("failed to set stream pseudo func param val, NULL val for funcId: %d", funcId);
×
1013
      return TSDB_CODE_INTERNAL_ERROR;
×
1014
    }
1015
    if (pVal->isNull) {
11,365,196 ✔
1016
      ((SValueNode*)pFirstParam)->isNull = true;
892 ✔
1017
    } else {
1018
      ((SValueNode*)pFirstParam)->isNull = false;
11,364,304 ✔
1019
      if (IS_VAR_DATA_TYPE(pVal->data.type)) {
11,364,304 ✔
1020
        // pVal->data.pData already includes the VARSTR header from colDataGetData,
1021
        // so copy it directly as datum.p expects VARSTR format [header][raw data].
1022
        char* tmp = taosMemoryMalloc(pVal->data.nData);
10,272 ✔
1023
        if (tmp == NULL) {
9,826 ✔
1024
          return TSDB_CODE_OUT_OF_MEMORY;
×
1025
        }
1026
        taosMemoryFree(((SValueNode*)pFirstParam)->datum.p);
9,826 ✔
1027
        ((SValueNode*)pFirstParam)->datum.p = tmp;
9,826 ✔
1028
        memcpy(tmp, pVal->data.pData, pVal->data.nData);
9,826 ✔
1029
      } else {
1030
        code = nodesSetValueNodeValue((SValueNode*)pFirstParam, (void*)&pVal->data.val);
11,354,032 ✔
1031
      }
1032
    }
1033
    if (code != 0) {
11,357,168 ✔
1034
      uError("failed to set value node value: %s", tstrerror(code));
×
1035
      return code;
×
1036
    }
1037
  } else if (LIST_LENGTH(pParamNodes) == 1) {
870,027,639 ✔
1038
    // twstart, twend
1039
    const void* pVal = fmGetStreamPesudoFuncVal(funcId, pStreamRuntimeInfo);
435,028,490 ✔
1040
    if (!pVal) {
434,994,015 ✔
1041
      uError("failed to set stream pseudo func param val, NULL val for funcId: %d", funcId);
×
1042
      return TSDB_CODE_INTERNAL_ERROR;
×
1043
    }
1044
    code = nodesSetValueNodeValue((SValueNode*)pFirstParam, (void*)pVal);
434,994,015 ✔
1045
    if (code != 0) {
435,042,282 ✔
1046
      uError("failed to set value node value: %s", tstrerror(code));
43,000 ✔
1047
      return code;
×
1048
    }
1049
  } else {
1050
    uError("invalid placeholder function type: %d", t);
30,274 ✔
1051
    return TSDB_CODE_INTERNAL_ERROR;
×
1052
  }
1053
  
1054
  return code;
449,835,715 ✔
1055
}
1056

STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc