taosdata/TDengine | Build 4897 | source/libs/parser/src/parInsertSml.c | Coveralls

22

int32_t qCreateSName(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char* msgBuf,

741,407✔

24

  SMsgBuf msg = {.buf = msgBuf, .len = msgBufLen};

741,407✔

25

  SToken  sToken = {0};

741,587✔

26

  int     code = TSDB_CODE_SUCCESS;

741,587✔

27

  int32_t lino = 0;

741,587✔

29

  NEXT_TOKEN(pTableName, sToken);

741,587✔

30

  TSDB_CHECK_CONDITION(sToken.n != 0, code, lino, end, TSDB_CODE_TSC_STMT_TBNAME_ERROR);

741,653✔

31

  code = insCreateSName(pName, &sToken, acctId, dbName, &msg);

741,653✔

32

  TSDB_CHECK_CODE(code, lino, end);

741,617✔

33

  NEXT_TOKEN(pTableName, sToken);

741,617✔

34

  TSDB_CHECK_CONDITION(sToken.n <= 0, code, lino, end, TSDB_CODE_TSC_STMT_TBNAME_ERROR);

741,617✔

36

end:

741,617✔

37

  if (code != 0) {

741,797✔

40

  return code;

741,698✔

43

int32_t qCreateSName2(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char* msgBuf,

3,347,524✔

45

  SMsgBuf msg = {.buf = msgBuf, .len = msgBufLen};

3,347,524✔

46

  SToken  sToken = {0};

3,348,304✔

47

  int     code = TSDB_CODE_SUCCESS;

3,348,304✔

48

  int32_t lino = 0;

3,348,304✔

50

  if (pTableName == NULL || strlen(pTableName) == 0) {

3,348,304✔

55

  sToken.z = (char*)pTableName;

3,348,370✔

56

  sToken.n = strlen(pTableName);

3,348,370✔

57

  sToken.type = TK_NK_ID;

3,348,370✔

59

  code = insCreateSName(pName, &sToken, acctId, dbName, &msg);

3,348,370✔

60

  TSDB_CHECK_CODE(code, lino, end);

3,347,402✔

62

end:

3,347,402✔

63

  if (code != 0) {

3,347,943✔

66

  return code;

3,347,580✔

69

static int32_t smlBoundColumnData(SArray* cols, SBoundColInfo* pBoundInfo, SSchema* pSchema, bool isTag) {

2,046,300✔

70

  int     code = TSDB_CODE_SUCCESS;

2,046,300✔

71

  int32_t lino = 0;

2,046,300✔

72

  bool*   pUseCols = taosMemoryCalloc(pBoundInfo->numOfCols, sizeof(bool));

2,046,300✔

73

  TSDB_CHECK_NULL(pUseCols, code, lino, end, terrno);

2,046,335✔

74

  pBoundInfo->numOfBound = 0;

2,046,335✔

75

  int16_t lastColIdx = -1;  // last column found

2,046,335✔

77

  for (int i = 0; i < taosArrayGetSize(cols); ++i) {

36,242,159✔

78

    SSmlKv*  kv = taosArrayGet(cols, i);

34,195,558✔

79

    SToken   sToken = {.n = kv->keyLen, .z = (char*)kv->key};

34,194,494✔

80

    col_id_t t = lastColIdx + 1;

34,192,100✔

81

    col_id_t index = ((t == 0 && !isTag) ? 0 : insFindCol(&sToken, t, pBoundInfo->numOfCols, pSchema));

34,192,100✔

82

    uTrace("SML, index:%d, t:%d, ncols:%d", index, t, pBoundInfo->numOfCols);

34,195,026✔

83

    if (index < 0 && t > 0) {

34,195,292✔

84

      index = insFindCol(&sToken, 0, t, pSchema);

6,707✔

87

    TSDB_CHECK_CONDITION(index >= 0, code, lino, end, TSDB_CODE_SML_INVALID_DATA);

34,194,760✔

88

    TSDB_CHECK_CONDITION(!pUseCols[index], code, lino, end, TSDB_CODE_SML_INVALID_DATA);

34,194,760✔

90

    lastColIdx = index;

34,195,558✔

91

    pUseCols[index] = true;

34,195,558✔

92

    pBoundInfo->pColIndex[pBoundInfo->numOfBound] = index;

34,196,356✔

93

    ++pBoundInfo->numOfBound;

34,196,622✔

96

end:

2,045,201✔

97

  if (code != 0) {

2,045,467✔

100

  taosMemoryFree(pUseCols);

2,045,467✔

101

  return code;

2,046,335✔

104

static int32_t smlMbsToUcs4(const char* mbs, size_t mbsLen, void** result, int32_t* resultLen, int32_t maxLen,

4,135,363✔

106

  int     code = TSDB_CODE_SUCCESS;

4,135,363✔

107

  void*   pUcs4 = NULL;

4,135,363✔

108

  int32_t lino = 0;

4,135,363✔

109

  pUcs4 = taosMemoryCalloc(1, maxLen);

4,135,363✔

110

  TSDB_CHECK_NULL(pUcs4, code, lino, end, terrno);

4,135,132✔

111

  TSDB_CHECK_CONDITION(taosMbsToUcs4(mbs, mbsLen, (TdUcs4*)pUcs4, maxLen, resultLen, charsetCxt), code, lino, end,

4,135,132✔

113

  *result = pUcs4;

4,135,664✔

114

  pUcs4 = NULL;

4,135,664✔

116

end:

4,135,664✔

117

  if (code != 0) {

4,135,664✔

120

  taosMemoryFree(pUcs4);

4,135,664✔

121

  return code;

4,135,664✔

133

static int32_t smlBuildTagRow(SArray* cols, SBoundColInfo* tags, SSchema* pSchema, STag** ppTag, SArray** tagName,

1,037,562✔

135

  int     code = TSDB_CODE_SUCCESS;

1,037,562✔

136

  int32_t lino = 0;

1,037,562✔

137

  SArray* pTagArray = taosArrayInit(tags->numOfBound, sizeof(STagVal));

1,037,562✔

138

  TSDB_CHECK_NULL(pTagArray, code, lino, end, terrno);

1,037,632✔

139

  *tagName = taosArrayInit(8, TSDB_COL_NAME_LEN);

1,037,632✔

140

  TSDB_CHECK_NULL(*tagName, code, lino, end, terrno);

1,037,632✔

142

  for (int i = 0; i < tags->numOfBound; ++i) {

6,576,278✔

143

    SSchema* pTagSchema = &pSchema[tags->pColIndex[i]];

5,538,646✔

144

    SSmlKv*  kv = taosArrayGet(cols, i);

5,538,646✔

145

    TSDB_CHECK_NULL(kv, code, lino, end, terrno);

5,538,681✔

146

    bool cond = (kv->keyLen == strlen(pTagSchema->name) && memcmp(kv->key, pTagSchema->name, kv->keyLen) == 0 &&

11,077,362✔

147

                 kv->type == pTagSchema->type);

5,538,681✔

148

    TSDB_CHECK_CONDITION(cond, code, lino, end, TSDB_CODE_SML_INVALID_DATA);

5,538,681✔

149

    TSDB_CHECK_NULL(taosArrayPush(*tagName, pTagSchema->name), code, lino, end, terrno);

11,077,096✔

150

    STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};

5,538,415✔

151

    if (pTagSchema->type == TSDB_DATA_TYPE_BINARY || pTagSchema->type == TSDB_DATA_TYPE_VARBINARY ||

5,538,415✔

152

        pTagSchema->type == TSDB_DATA_TYPE_GEOMETRY) {

5,297,699✔

153

      val.pData = (uint8_t*)kv->value;

240,751✔

154

      val.nData = kv->length;

240,751✔

155

    } else if (pTagSchema->type == TSDB_DATA_TYPE_NCHAR) {

5,297,664✔

156

      code = smlMbsToUcs4(kv->value, kv->length, (void**)&val.pData, (int32_t*)&val.nData, kv->length * TSDB_NCHAR_SIZE,

3,972,985✔

158

      TSDB_CHECK_CODE(code, lino, end);

3,973,286✔

160

      (void)memcpy(&val.i64, &(kv->value), kv->length);

1,324,679✔

162

    TSDB_CHECK_NULL(taosArrayPush(pTagArray, &val), code, lino, end, terrno);

5,538,646✔

164

  code = tTagNew(pTagArray, 1, false, ppTag);

1,037,632✔

166

end:

1,037,632✔

167

  if (code != 0) {

1,037,632✔

170

  for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) {

6,576,313✔

171

    STagVal* p = (STagVal*)taosArrayGet(pTagArray, i);

5,538,646✔

172

    if (p->type == TSDB_DATA_TYPE_NCHAR) {

5,538,646✔

173

      taosMemoryFree(p->pData);

3,973,251✔

176

  taosArrayDestroy(pTagArray);

1,037,632✔

177

  return code;

1,037,632✔

180

int32_t smlInitTableDataCtx(SQuery* query, STableMeta* pTableMeta, STableDataCxt** cxt) {

134,449✔

181

  int            ret = TSDB_CODE_SUCCESS;

134,449✔

182

  int32_t        lino = 0;

134,449✔

183

  SVCreateTbReq* pCreateTbReq = NULL;

134,449✔

184

  ret = insGetTableDataCxt(((SVnodeModifyOpStmt*)(query->pRoot))->pTableBlockHashObj, &pTableMeta->uid,

134,449✔

186

  TSDB_CHECK_CODE(ret, lino, end);

134,484✔

187

  ret = initTableColSubmitData(*cxt);

134,484✔

188

  TSDB_CHECK_CODE(ret, lino, end);

134,449✔

190

end:

134,449✔

191

  if (ret != 0) {

134,449✔

194

  return ret;

134,449✔

197

void clearColValArraySml(SArray* pCols) {

27,427,859✔

198

  int32_t num = taosArrayGetSize(pCols);

27,427,859✔

199

  for (int32_t i = 0; i < num; ++i) {

176,127,234✔

200

    SColVal* pCol = taosArrayGet(pCols, i);

148,726,234✔

201

    if (TSDB_DATA_TYPE_NCHAR == pCol->value.type || TSDB_DATA_TYPE_GEOMETRY == pCol->value.type ||

148,750,826✔

202

        TSDB_DATA_TYPE_VARBINARY == pCol->value.type) {

148,844,392✔

203

      taosMemoryFreeClear(pCol->value.pData);

83,159✔

205

    pCol->flag = CV_FLAG_NONE;

149,128,943✔

206

    pCol->value.val = 0;

149,136,407✔

208

27,401,000✔

210

int32_t smlBuildRow(STableDataCxt* pTableCxt) {

193,993✔

211

  int     ret = TSDB_CODE_SUCCESS;

193,993✔

212

  int32_t lino = 0;

193,993✔

213

  SRow**  pRow = taosArrayReserve(pTableCxt->pData->aRowP, 1);

193,993✔

214

  TSDB_CHECK_NULL(pRow, ret, lino, end, terrno);

193,993✔

216

  SRowBuildScanInfo sinfo = {0};

193,993✔

217

  ret = tRowBuild(pTableCxt->pValues, pTableCxt->pSchema, pRow, &sinfo);

193,993✔

218

  TSDB_CHECK_CODE(ret, lino, end);

194,028✔

219

  SRowKey key;

6,840✔

220

  tRowGetKey(*pRow, &key);

388,056✔

221

  insCheckTableDataOrder(pTableCxt, &key);

194,028✔

222

end:

193,993✔

223

  if (ret != 0) {

193,993✔

226

  return ret;

194,028✔

229

int32_t smlBuildCol(STableDataCxt* pTableCxt, SSchema* schema, void* data, int32_t index, void* charsetCxt) {

493,401✔

230

  int      ret = TSDB_CODE_SUCCESS;

493,401✔

231

  int32_t  lino = 0;

493,401✔

232

  SSchema* pColSchema = schema + index;

493,401✔

233

  SColVal* pVal = taosArrayGet(pTableCxt->pValues, index);

493,401✔

234

  TSDB_CHECK_NULL(pVal, ret, lino, end, TSDB_CODE_SUCCESS);

492,872✔

235

  SSmlKv* kv = (SSmlKv*)data;

492,872✔

236

  if (kv->keyLen != strlen(pColSchema->name) || memcmp(kv->key, pColSchema->name, kv->keyLen) != 0 ||

492,872✔

237

      kv->type != pColSchema->type) {

492,746✔

238

    ret = TSDB_CODE_SML_INVALID_DATA;

3,035✔

239

    char* tmp = taosMemoryCalloc(kv->keyLen + 1, 1);

3,035✔

240

    TSDB_CHECK_NULL(tmp, ret, lino, end, terrno);

1,980✔

241

    (void)memcpy(tmp, kv->key, kv->keyLen);

1,980✔

242

    uInfo("SML data(name:%s type:%s) is not same like the db data(name:%s type:%s)", tmp, tDataTypes[kv->type].name,

1,980✔

244

    taosMemoryFree(tmp);

1,980✔

245

    goto end;

1,980✔

247

  if (kv->type == TSDB_DATA_TYPE_NCHAR) {

490,629✔

248

    ret = smlMbsToUcs4(kv->value, kv->length, (void**)&pVal->value.pData, &pVal->value.nData,

9,450✔

249

                       pColSchema->bytes - VARSTR_HEADER_SIZE, charsetCxt);

9,450✔

250

    TSDB_CHECK_CODE(ret, lino, end);

9,450✔

251

  } else if (kv->type == TSDB_DATA_TYPE_BINARY) {

481,442✔

252

    pVal->value.nData = kv->length;

96,743✔

253

    pVal->value.pData = (uint8_t*)kv->value;

96,746✔

254

  } else if (kv->type == TSDB_DATA_TYPE_GEOMETRY || kv->type == TSDB_DATA_TYPE_VARBINARY) {

384,962✔

255

    pVal->value.nData = kv->length;

1,295✔

256

    pVal->value.pData = taosMemoryMalloc(kv->length);

1,295✔

261

    valueSetDatum(&pVal->value, kv->type, &(kv->value), kv->length);

383,667✔

263

  pVal->flag = CV_FLAG_VALUE;

490,892✔

265

end:

493,401✔

266

  if (ret != 0) {

493,401✔

267

    uError("%s failed at %d since %s", __func__, lino, tstrerror(ret));

1,980✔

269

  return ret;

493,366✔

272

int32_t smlBindData(SQuery* query, bool dataFormat, SArray* tags, SArray* colsSchema, SArray* cols,

1,037,597✔

275

  int32_t lino = 0;

1,037,597✔

276

  int32_t ret = 0;

1,037,597✔

277

  SMsgBuf pBuf = {.buf = msgBuf, .len = msgBufLen};

1,037,597✔

279

  SSchema*       pTagsSchema = getTableTagSchema(pTableMeta);

1,037,597✔

280

  SBoundColInfo  bindTags = {0};

1,037,632✔

281

  SVCreateTbReq* pCreateTblReq = NULL;

1,037,632✔

282

  SArray*        tagName = NULL;

1,037,632✔

284

  ret = insInitBoundColsInfo(getNumOfTags(pTableMeta), &bindTags);

1,037,632✔

285

  TSDB_CHECK_CODE(ret, lino, end);

1,037,632✔

287

  ret = smlBoundColumnData(tags, &bindTags, pTagsSchema, true);

1,037,632✔

288

  TSDB_CHECK_CODE(ret, lino, end);

1,037,597✔

290

  STag* pTag = NULL;

1,037,597✔

291

  ret = smlBuildTagRow(tags, &bindTags, pTagsSchema, &pTag, &tagName, &pBuf, charsetCxt);

1,037,597✔

292

  TSDB_CHECK_CODE(ret, lino, end);

1,037,597✔

294

  pCreateTblReq = taosMemoryCalloc(1, sizeof(SVCreateTbReq));

1,037,597✔

295

  TSDB_CHECK_NULL(pCreateTblReq, ret, lino, end, terrno);

1,037,632✔

297

  ret = insBuildCreateTbReq(pCreateTblReq, tableName, pTag, pTableMeta->suid, NULL, tagName,

1,037,632✔

298

                            pTableMeta->tableInfo.numOfTags, ttl);

1,037,632✔

299

  TSDB_CHECK_CODE(ret, lino, end);

1,037,632✔

301

  pCreateTblReq->ctb.stbName = taosMemoryCalloc(1, sTableNameLen + 1);

1,037,632✔

302

  TSDB_CHECK_NULL(pCreateTblReq->ctb.stbName, ret, lino, end, terrno);

1,037,632✔

304

  (void)memcpy(pCreateTblReq->ctb.stbName, sTableName, sTableNameLen);

1,037,632✔

306

  if (dataFormat) {

1,037,632✔

307

    STableDataCxt** pTableCxt = (STableDataCxt**)taosHashGet(((SVnodeModifyOpStmt*)(query->pRoot))->pTableBlockHashObj,

28,894✔

308

                                                             &pTableMeta->uid, sizeof(pTableMeta->uid));

28,894✔

309

    TSDB_CHECK_NULL(pTableCxt, ret, lino, end, TSDB_CODE_TSC_INVALID_OPERATION);

28,929✔

310

    (*pTableCxt)->pData->flags |= SUBMIT_REQ_AUTO_CREATE_TABLE;

28,929✔

311

    (*pTableCxt)->pData->pCreateTbReq = pCreateTblReq;

28,929✔

312

    (*pTableCxt)->pMeta->uid = pTableMeta->uid;

28,929✔

313

    (*pTableCxt)->pMeta->vgId = pTableMeta->vgId;

28,929✔

314

    pCreateTblReq = NULL;

28,929✔

315

    goto end;

28,929✔

318

  STableDataCxt* pTableCxt = NULL;

1,008,738✔

319

  ret = insGetTableDataCxt(((SVnodeModifyOpStmt*)(query->pRoot))->pTableBlockHashObj, &pTableMeta->uid,

1,008,738✔

321

  TSDB_CHECK_CODE(ret, lino, end);

1,008,703✔

323

  SSchema* pSchema = getTableColumnSchema(pTableMeta);

1,008,703✔

324

  ret = smlBoundColumnData(colsSchema, &pTableCxt->boundColsInfo, pSchema, false);

1,008,703✔

325

  TSDB_CHECK_CODE(ret, lino, end);

1,008,703✔

327

  ret = initTableColSubmitData(pTableCxt);

1,008,703✔

328

  TSDB_CHECK_CODE(ret, lino, end);

1,008,437✔

330

  int32_t rowNum = taosArrayGetSize(cols);

1,008,437✔

331

  TSDB_CHECK_CONDITION(rowNum > 0, ret, lino, end, TSDB_CODE_TSC_INVALID_OPERATION);

1,008,437✔

333

  for (int32_t r = 0; r < rowNum; ++r) {

28,226,573✔

334

    void* rowData = taosArrayGetP(cols, r);

27,220,458✔

335

    TSDB_CHECK_NULL(rowData, ret, lino, end, terrno);

27,089,136✔

338

    for (int c = 0; c < pTableCxt->boundColsInfo.numOfBound; ++c) {

178,342,093✔

339

      SSchema* pColSchema = &pSchema[pTableCxt->boundColsInfo.pColIndex[c]];

150,117,250✔

340

      SColVal* pVal = taosArrayGet(pTableCxt->pValues, pTableCxt->boundColsInfo.pColIndex[c]);

150,414,984✔

341

      TSDB_CHECK_NULL(pVal, ret, lino, end, terrno);

150,305,709✔

342

      void** p = taosHashGet(rowData, pColSchema->name, strlen(pColSchema->name));

150,305,709✔

343

      if (p == NULL) {

150,460,449✔

344

        continue;

28,125✔

346

      SSmlKv* kv = *(SSmlKv**)p;

150,432,324✔

347

      TSDB_CHECK_CONDITION(kv->type == pColSchema->type, ret, lino, end, TSDB_CODE_TSC_INVALID_OPERATION);

150,544,304✔

349

      if (pColSchema->type == TSDB_DATA_TYPE_TIMESTAMP) {

150,569,355✔

350

        kv->i = convertTimePrecision(kv->i, TSDB_TIME_PRECISION_NANO, pTableMeta->tableInfo.precision);

27,293,472✔

352

      if (kv->type == TSDB_DATA_TYPE_NCHAR) {

150,577,353✔

353

        ret = smlMbsToUcs4(kv->value, kv->length, (void**)&pVal->value.pData, (int32_t*)&pVal->value.nData,

152,928✔

354

                           pColSchema->bytes - VARSTR_HEADER_SIZE, charsetCxt);

152,928✔

355

        TSDB_CHECK_CODE(ret, lino, end);

152,928✔

356

      } else if (kv->type == TSDB_DATA_TYPE_BINARY) {

149,779,686✔

357

        pVal->value.nData = kv->length;

21,379,860✔

358

        pVal->value.pData = (uint8_t*)kv->value;

21,381,713✔

359

      } else if (kv->type == TSDB_DATA_TYPE_GEOMETRY || kv->type == TSDB_DATA_TYPE_VARBINARY) {

128,421,734✔

361

        pVal->value.pData = taosMemoryMalloc(kv->length);

2,760✔

362

        TSDB_CHECK_NULL(pVal->value.pData, ret, lino, end, terrno);

2,760✔

363

        (void)memcpy(pVal->value.pData, (uint8_t*)kv->value, kv->length);

2,760✔

365

        valueSetDatum(&pVal->value, kv->type, &(kv->value), kv->length);

128,560,355✔

367

      pVal->flag = CV_FLAG_VALUE;

151,182,058✔

370

    SRow** pRow = taosArrayReserve(pTableCxt->pData->aRowP, 1);

27,319,823✔

371

    TSDB_CHECK_NULL(pRow, ret, lino, end, terrno);

27,269,994✔

372

    SRowBuildScanInfo sinfo = {0};

27,269,994✔

373

    ret = tRowBuild(pTableCxt->pValues, pTableCxt->pSchema, pRow, &sinfo);

27,272,058✔

374

    TSDB_CHECK_CODE(ret, lino, end);

27,216,295✔

375

    SRowKey key = {0};

27,216,295✔

376

    tRowGetKey(*pRow, &key);

54,476,708✔

377

    insCheckTableDataOrder(pTableCxt, &key);

27,239,515✔

378

    clearColValArraySml(pTableCxt->pValues);

27,159,828✔

381

end:

1,000,055✔

382

  if (ret != 0) {

1,037,632✔

386

  insDestroyBoundColInfo(&bindTags);

1,037,632✔

387

  tdDestroySVCreateTbReq(pCreateTblReq);

1,037,597✔

388

  taosMemoryFree(pCreateTblReq);

1,037,632✔

389

  taosArrayDestroy(tagName);

1,037,366✔

390

  return ret;

1,037,366✔

393

int32_t smlInitHandle(SQuery** query) {

587,221✔

394

  int32_t             lino = 0;

587,221✔

395

  int32_t             code = 0;

587,221✔

396

  SQuery*             pQuery = NULL;

587,221✔

397

  SVnodeModifyOpStmt* stmt = NULL;

587,221✔

398

  TSDB_CHECK_NULL(query, code, lino, end, TSDB_CODE_INVALID_PARA);

587,221✔

400

  *query = NULL;

587,221✔

401

  code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);

587,221✔

402

  TSDB_CHECK_CODE(code, lino, end);

587,200✔

403

  pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;

587,200✔

404

  pQuery->haveResultSet = false;

587,200✔

405

  pQuery->msgType = TDMT_VND_SUBMIT;

587,200✔

406

  code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&stmt);

587,200✔

407

  TSDB_CHECK_CODE(code, lino, end);

587,235✔

408

  stmt->pTableBlockHashObj = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);

587,235✔

409

  TSDB_CHECK_NULL(stmt->pTableBlockHashObj, code, lino, end, terrno);

587,270✔

410

  stmt->freeHashFunc = insDestroyTableDataCxtHashMap;

587,270✔

411

  stmt->freeArrayFunc = insDestroyVgroupDataCxtList;

587,270✔

413

  pQuery->pRoot = (SNode*)stmt;

587,270✔

414

  *query = pQuery;

587,270✔

415

  return code;

587,270✔

426

int32_t smlBuildOutput(SQuery* handle, SHashObj* pVgHash) {

467,956✔

427

  int32_t lino = 0;

467,956✔

428

  int32_t code = 0;

467,956✔

430

  SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)(handle)->pRoot;

467,956✔

431

  code = insMergeTableDataCxt(pStmt->pTableBlockHashObj, &pStmt->pVgDataBlocks, true);

467,956✔

432

  TSDB_CHECK_CODE(code, lino, end);

467,956✔

433

  code = insBuildVgDataBlocks(pVgHash, pStmt->pVgDataBlocks, &pStmt->pDataBlocks, false);

467,956✔

434

  TSDB_CHECK_CODE(code, lino, end);

467,956✔

436

end:

467,956✔

437

  if (code != 0) {

467,956✔

440

  return code;

467,921✔

443

int32_t smlBuildOutputRaw(SQuery* handle, SHashObj* pVgHash) {

92✔

444

  int32_t lino = 0;

92✔

445

  int32_t code = 0;

92✔

447

  SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)(handle)->pRoot;

92✔

448

  code = insBuildVgDataBlocks(pVgHash, pStmt->pVgDataBlocks, &pStmt->pDataBlocks, false);

92✔

449

  TSDB_CHECK_CODE(code, lino, end);

92✔

451

  end:

92✔

452

  if (code != 0) {

92✔

455

  return code;

92✔

taosdata / TDengine / #4897

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

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 "parInsertUtil.h"
17	#include "parInt.h"
18	#include "parToken.h"
19	#include "ttime.h"
20	#include "ttokendef.h"
21
22	int32_t qCreateSName(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char* msgBuf,	741,407✔
23	int32_t msgBufLen) {
24	SMsgBuf msg = {.buf = msgBuf, .len = msgBufLen};	741,407✔
25	SToken sToken = {0};	741,587✔
26	int code = TSDB_CODE_SUCCESS;	741,587✔
27	int32_t lino = 0;	741,587✔
28
29	NEXT_TOKEN(pTableName, sToken);	741,587✔
30	TSDB_CHECK_CONDITION(sToken.n != 0, code, lino, end, TSDB_CODE_TSC_STMT_TBNAME_ERROR);	741,653✔
31	code = insCreateSName(pName, &sToken, acctId, dbName, &msg);	741,653✔
32	TSDB_CHECK_CODE(code, lino, end);	741,617✔
33	NEXT_TOKEN(pTableName, sToken);	741,617✔
34	TSDB_CHECK_CONDITION(sToken.n <= 0, code, lino, end, TSDB_CODE_TSC_STMT_TBNAME_ERROR);	741,617✔
35
36	end:	741,617✔
37	if (code != 0) {	741,797✔
38	uError("%s failed at %d since %s", __func__, lino, tstrerror(code));	×
39	}
40	return code;	741,698✔
41	}
42
43	int32_t qCreateSName2(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char* msgBuf,	3,347,524✔
44	int32_t msgBufLen) {
45	SMsgBuf msg = {.buf = msgBuf, .len = msgBufLen};	3,347,524✔
46	SToken sToken = {0};	3,348,304✔
47	int code = TSDB_CODE_SUCCESS;	3,348,304✔
48	int32_t lino = 0;	3,348,304✔
49
50	if (pTableName == NULL \|\| strlen(pTableName) == 0) {	3,348,304✔
51	code = TSDB_CODE_TSC_STMT_TBNAME_ERROR;	×
52	goto end;	×
53	}
54
55	sToken.z = (char*)pTableName;	3,348,370✔
56	sToken.n = strlen(pTableName);	3,348,370✔
57	sToken.type = TK_NK_ID;	3,348,370✔
58
59	code = insCreateSName(pName, &sToken, acctId, dbName, &msg);	3,348,370✔
60	TSDB_CHECK_CODE(code, lino, end);	3,347,402✔
61
62	end:	3,347,402✔
63	if (code != 0) {	3,347,943✔
64	uError("%s failed at %d since %s", __func__, lino, tstrerror(code));	×
65	}
66	return code;	3,347,580✔
67	}
68
69	static int32_t smlBoundColumnData(SArray* cols, SBoundColInfo* pBoundInfo, SSchema* pSchema, bool isTag) {	2,046,300✔
70	int code = TSDB_CODE_SUCCESS;	2,046,300✔
71	int32_t lino = 0;	2,046,300✔
72	bool* pUseCols = taosMemoryCalloc(pBoundInfo->numOfCols, sizeof(bool));	2,046,300✔
73	TSDB_CHECK_NULL(pUseCols, code, lino, end, terrno);	2,046,335✔
74	pBoundInfo->numOfBound = 0;	2,046,335✔
75	int16_t lastColIdx = -1; // last column found	2,046,335✔
76
77	for (int i = 0; i < taosArrayGetSize(cols); ++i) {	36,242,159✔
78	SSmlKv* kv = taosArrayGet(cols, i);	34,195,558✔
79	SToken sToken = {.n = kv->keyLen, .z = (char*)kv->key};	34,194,494✔
80	col_id_t t = lastColIdx + 1;	34,192,100✔
81	col_id_t index = ((t == 0 && !isTag) ? 0 : insFindCol(&sToken, t, pBoundInfo->numOfCols, pSchema));	34,192,100✔
82	uTrace("SML, index:%d, t:%d, ncols:%d", index, t, pBoundInfo->numOfCols);	34,195,026✔
83	if (index < 0 && t > 0) {	34,195,292✔
84	index = insFindCol(&sToken, 0, t, pSchema);	6,707✔
85	}
86
87	TSDB_CHECK_CONDITION(index >= 0, code, lino, end, TSDB_CODE_SML_INVALID_DATA);	34,194,760✔
88	TSDB_CHECK_CONDITION(!pUseCols[index], code, lino, end, TSDB_CODE_SML_INVALID_DATA);	34,194,760✔
89
90	lastColIdx = index;	34,195,558✔
91	pUseCols[index] = true;	34,195,558✔
92	pBoundInfo->pColIndex[pBoundInfo->numOfBound] = index;	34,196,356✔
93	++pBoundInfo->numOfBound;	34,196,622✔
94	}
95
96	end:	2,045,201✔
97	if (code != 0) {	2,045,467✔
98	uError("%s failed at %d since %s", __func__, lino, tstrerror(code));	×
99	}
100	taosMemoryFree(pUseCols);	2,045,467✔
101	return code;	2,046,335✔
102	}
103
104	static int32_t smlMbsToUcs4(const char* mbs, size_t mbsLen, void** result, int32_t* resultLen, int32_t maxLen,	4,135,363✔
105	void* charsetCxt) {
106	int code = TSDB_CODE_SUCCESS;	4,135,363✔
107	void* pUcs4 = NULL;	4,135,363✔
108	int32_t lino = 0;	4,135,363✔
109	pUcs4 = taosMemoryCalloc(1, maxLen);	4,135,363✔
110	TSDB_CHECK_NULL(pUcs4, code, lino, end, terrno);	4,135,132✔
111	TSDB_CHECK_CONDITION(taosMbsToUcs4(mbs, mbsLen, (TdUcs4*)pUcs4, maxLen, resultLen, charsetCxt), code, lino, end,	4,135,132✔
112	terrno);
113	*result = pUcs4;	4,135,664✔
114	pUcs4 = NULL;	4,135,664✔
115
116	end:	4,135,664✔
117	if (code != 0) {	4,135,664✔
118	uError("%s failed at %d since %s", __func__, lino, tstrerror(code));	×
119	}
120	taosMemoryFree(pUcs4);	4,135,664✔
121	return code;	4,135,664✔
122	}
123	/**
124	* @brief No json tag for schemaless
125	*
126	* @param cols
127	* @param tags
128	* @param pSchema
129	* @param ppTag
130	* @param msg
131	* @return int32_t
132	*/
133	static int32_t smlBuildTagRow(SArray* cols, SBoundColInfo* tags, SSchema* pSchema, STag ppTag, SArray tagName,	1,037,562✔
134	SMsgBuf* msg, void* charsetCxt) {
135	int code = TSDB_CODE_SUCCESS;	1,037,562✔
136	int32_t lino = 0;	1,037,562✔
137	SArray* pTagArray = taosArrayInit(tags->numOfBound, sizeof(STagVal));	1,037,562✔
138	TSDB_CHECK_NULL(pTagArray, code, lino, end, terrno);	1,037,632✔
139	*tagName = taosArrayInit(8, TSDB_COL_NAME_LEN);	1,037,632✔
140	TSDB_CHECK_NULL(*tagName, code, lino, end, terrno);	1,037,632✔
141
142	for (int i = 0; i < tags->numOfBound; ++i) {	6,576,278✔
143	SSchema* pTagSchema = &pSchema[tags->pColIndex[i]];	5,538,646✔
144	SSmlKv* kv = taosArrayGet(cols, i);	5,538,646✔
145	TSDB_CHECK_NULL(kv, code, lino, end, terrno);	5,538,681✔
146	bool cond = (kv->keyLen == strlen(pTagSchema->name) && memcmp(kv->key, pTagSchema->name, kv->keyLen) == 0 &&	11,077,362✔
147	kv->type == pTagSchema->type);	5,538,681✔
148	TSDB_CHECK_CONDITION(cond, code, lino, end, TSDB_CODE_SML_INVALID_DATA);	5,538,681✔
149	TSDB_CHECK_NULL(taosArrayPush(*tagName, pTagSchema->name), code, lino, end, terrno);	11,077,096✔
150	STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};	5,538,415✔
151	if (pTagSchema->type == TSDB_DATA_TYPE_BINARY \|\| pTagSchema->type == TSDB_DATA_TYPE_VARBINARY \|\|	5,538,415✔
152	pTagSchema->type == TSDB_DATA_TYPE_GEOMETRY) {	5,297,699✔
153	val.pData = (uint8_t*)kv->value;	240,751✔
154	val.nData = kv->length;	240,751✔
155	} else if (pTagSchema->type == TSDB_DATA_TYPE_NCHAR) {	5,297,664✔
156	code = smlMbsToUcs4(kv->value, kv->length, (void*)&val.pData, (int32_t)&val.nData, kv->length * TSDB_NCHAR_SIZE,	3,972,985✔
157	charsetCxt);
158	TSDB_CHECK_CODE(code, lino, end);	3,973,286✔
159	} else {
160	(void)memcpy(&val.i64, &(kv->value), kv->length);	1,324,679✔
161	}
162	TSDB_CHECK_NULL(taosArrayPush(pTagArray, &val), code, lino, end, terrno);	5,538,646✔
163	}
164	code = tTagNew(pTagArray, 1, false, ppTag);	1,037,632✔
165
166	end:	1,037,632✔
167	if (code != 0) {	1,037,632✔
168	uError("%s failed at %d since %s", __func__, lino, tstrerror(code));	×
169	}
170	for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) {	6,576,313✔
171	STagVal* p = (STagVal*)taosArrayGet(pTagArray, i);	5,538,646✔
172	if (p->type == TSDB_DATA_TYPE_NCHAR) {	5,538,646✔
173	taosMemoryFree(p->pData);	3,973,251✔
174	}
175	}
176	taosArrayDestroy(pTagArray);	1,037,632✔
177	return code;	1,037,632✔
178	}
179
180	int32_t smlInitTableDataCtx(SQuery* query, STableMeta* pTableMeta, STableDataCxt** cxt) {	134,449✔
181	int ret = TSDB_CODE_SUCCESS;	134,449✔
182	int32_t lino = 0;	134,449✔
183	SVCreateTbReq* pCreateTbReq = NULL;	134,449✔
184	ret = insGetTableDataCxt(((SVnodeModifyOpStmt*)(query->pRoot))->pTableBlockHashObj, &pTableMeta->uid,	134,449✔
185	sizeof(pTableMeta->uid), pTableMeta, &pCreateTbReq, cxt, false, false);
186	TSDB_CHECK_CODE(ret, lino, end);	134,484✔
187	ret = initTableColSubmitData(*cxt);	134,484✔
188	TSDB_CHECK_CODE(ret, lino, end);	134,449✔
189
190	end:	134,449✔
191	if (ret != 0) {	134,449✔
192	uError("%s failed at %d since %s", __func__, lino, tstrerror(ret));	×
193	}
194	return ret;	134,449✔
195	}
196
197	void clearColValArraySml(SArray* pCols) {	27,427,859✔
198	int32_t num = taosArrayGetSize(pCols);	27,427,859✔
199	for (int32_t i = 0; i < num; ++i) {	176,127,234✔
200	SColVal* pCol = taosArrayGet(pCols, i);	148,726,234✔
201	if (TSDB_DATA_TYPE_NCHAR == pCol->value.type \|\| TSDB_DATA_TYPE_GEOMETRY == pCol->value.type \|\|	148,750,826✔
202	TSDB_DATA_TYPE_VARBINARY == pCol->value.type) {	148,844,392✔
203	taosMemoryFreeClear(pCol->value.pData);	83,159✔
204	}
205	pCol->flag = CV_FLAG_NONE;	149,128,943✔
206	pCol->value.val = 0;	149,136,407✔
207	}
208	}	27,401,000✔
209
210	int32_t smlBuildRow(STableDataCxt* pTableCxt) {	193,993✔
211	int ret = TSDB_CODE_SUCCESS;	193,993✔
212	int32_t lino = 0;	193,993✔
213	SRow** pRow = taosArrayReserve(pTableCxt->pData->aRowP, 1);	193,993✔
214	TSDB_CHECK_NULL(pRow, ret, lino, end, terrno);	193,993✔
215
216	SRowBuildScanInfo sinfo = {0};	193,993✔
217	ret = tRowBuild(pTableCxt->pValues, pTableCxt->pSchema, pRow, &sinfo);	193,993✔
218	TSDB_CHECK_CODE(ret, lino, end);	194,028✔
219	SRowKey key;	6,840✔
220	tRowGetKey(*pRow, &key);	388,056✔
221	insCheckTableDataOrder(pTableCxt, &key);	194,028✔
222	end:	193,993✔
223	if (ret != 0) {	193,993✔
224	uError("%s failed at %d since %s", __func__, lino, tstrerror(ret));	×
225	}
226	return ret;	194,028✔
227	}
228
229	int32_t smlBuildCol(STableDataCxt* pTableCxt, SSchema* schema, void* data, int32_t index, void* charsetCxt) {	493,401✔
230	int ret = TSDB_CODE_SUCCESS;	493,401✔
231	int32_t lino = 0;	493,401✔
232	SSchema* pColSchema = schema + index;	493,401✔
233	SColVal* pVal = taosArrayGet(pTableCxt->pValues, index);	493,401✔
234	TSDB_CHECK_NULL(pVal, ret, lino, end, TSDB_CODE_SUCCESS);	492,872✔
235	SSmlKv* kv = (SSmlKv*)data;	492,872✔
236	if (kv->keyLen != strlen(pColSchema->name) \|\| memcmp(kv->key, pColSchema->name, kv->keyLen) != 0 \|\|	492,872✔
237	kv->type != pColSchema->type) {	492,746✔
238	ret = TSDB_CODE_SML_INVALID_DATA;	3,035✔
239	char* tmp = taosMemoryCalloc(kv->keyLen + 1, 1);	3,035✔
240	TSDB_CHECK_NULL(tmp, ret, lino, end, terrno);	1,980✔
241	(void)memcpy(tmp, kv->key, kv->keyLen);	1,980✔
242	uInfo("SML data(name:%s type:%s) is not same like the db data(name:%s type:%s)", tmp, tDataTypes[kv->type].name,	1,980✔
243	pColSchema->name, tDataTypes[pColSchema->type].name);
244	taosMemoryFree(tmp);	1,980✔
245	goto end;	1,980✔
246	}
247	if (kv->type == TSDB_DATA_TYPE_NCHAR) {	490,629✔
248	ret = smlMbsToUcs4(kv->value, kv->length, (void**)&pVal->value.pData, &pVal->value.nData,	9,450✔
249	pColSchema->bytes - VARSTR_HEADER_SIZE, charsetCxt);	9,450✔
250	TSDB_CHECK_CODE(ret, lino, end);	9,450✔
251	} else if (kv->type == TSDB_DATA_TYPE_BINARY) {	481,442✔
252	pVal->value.nData = kv->length;	96,743✔
253	pVal->value.pData = (uint8_t*)kv->value;	96,746✔
254	} else if (kv->type == TSDB_DATA_TYPE_GEOMETRY \|\| kv->type == TSDB_DATA_TYPE_VARBINARY) {	384,962✔
255	pVal->value.nData = kv->length;	1,295✔
256	pVal->value.pData = taosMemoryMalloc(kv->length);	1,295✔
257	TSDB_CHECK_NULL(pVal->value.pData, ret, lino, end, terrno);	×
258
259	(void)memcpy(pVal->value.pData, (uint8_t*)kv->value, kv->length);	×
260	} else {
261	valueSetDatum(&pVal->value, kv->type, &(kv->value), kv->length);	383,667✔
262	}
263	pVal->flag = CV_FLAG_VALUE;	490,892✔
264
265	end:	493,401✔
266	if (ret != 0) {	493,401✔
267	uError("%s failed at %d since %s", __func__, lino, tstrerror(ret));	1,980✔
268	}
269	return ret;	493,366✔
270	}
271
272	int32_t smlBindData(SQuery* query, bool dataFormat, SArray* tags, SArray* colsSchema, SArray* cols,	1,037,597✔
273	STableMeta* pTableMeta, char* tableName, const char* sTableName, int32_t sTableNameLen, int32_t ttl,
274	char* msgBuf, int32_t msgBufLen, void* charsetCxt) {
275	int32_t lino = 0;	1,037,597✔
276	int32_t ret = 0;	1,037,597✔
277	SMsgBuf pBuf = {.buf = msgBuf, .len = msgBufLen};	1,037,597✔
278
279	SSchema* pTagsSchema = getTableTagSchema(pTableMeta);	1,037,597✔
280	SBoundColInfo bindTags = {0};	1,037,632✔
281	SVCreateTbReq* pCreateTblReq = NULL;	1,037,632✔
282	SArray* tagName = NULL;	1,037,632✔
283
284	ret = insInitBoundColsInfo(getNumOfTags(pTableMeta), &bindTags);	1,037,632✔
285	TSDB_CHECK_CODE(ret, lino, end);	1,037,632✔
286
287	ret = smlBoundColumnData(tags, &bindTags, pTagsSchema, true);	1,037,632✔
288	TSDB_CHECK_CODE(ret, lino, end);	1,037,597✔
289
290	STag* pTag = NULL;	1,037,597✔
291	ret = smlBuildTagRow(tags, &bindTags, pTagsSchema, &pTag, &tagName, &pBuf, charsetCxt);	1,037,597✔
292	TSDB_CHECK_CODE(ret, lino, end);	1,037,597✔
293
294	pCreateTblReq = taosMemoryCalloc(1, sizeof(SVCreateTbReq));	1,037,597✔
295	TSDB_CHECK_NULL(pCreateTblReq, ret, lino, end, terrno);	1,037,632✔
296
297	ret = insBuildCreateTbReq(pCreateTblReq, tableName, pTag, pTableMeta->suid, NULL, tagName,	1,037,632✔
298	pTableMeta->tableInfo.numOfTags, ttl);	1,037,632✔
299	TSDB_CHECK_CODE(ret, lino, end);	1,037,632✔
300
301	pCreateTblReq->ctb.stbName = taosMemoryCalloc(1, sTableNameLen + 1);	1,037,632✔
302	TSDB_CHECK_NULL(pCreateTblReq->ctb.stbName, ret, lino, end, terrno);	1,037,632✔
303
304	(void)memcpy(pCreateTblReq->ctb.stbName, sTableName, sTableNameLen);	1,037,632✔
305
306	if (dataFormat) {	1,037,632✔
307	STableDataCxt pTableCxt = (STableDataCxt)taosHashGet(((SVnodeModifyOpStmt*)(query->pRoot))->pTableBlockHashObj,	28,894✔
308	&pTableMeta->uid, sizeof(pTableMeta->uid));	28,894✔
309	TSDB_CHECK_NULL(pTableCxt, ret, lino, end, TSDB_CODE_TSC_INVALID_OPERATION);	28,929✔
310	(*pTableCxt)->pData->flags \|= SUBMIT_REQ_AUTO_CREATE_TABLE;	28,929✔
311	(*pTableCxt)->pData->pCreateTbReq = pCreateTblReq;	28,929✔
312	(*pTableCxt)->pMeta->uid = pTableMeta->uid;	28,929✔
313	(*pTableCxt)->pMeta->vgId = pTableMeta->vgId;	28,929✔
314	pCreateTblReq = NULL;	28,929✔
315	goto end;	28,929✔
316	}
317
318	STableDataCxt* pTableCxt = NULL;	1,008,738✔
319	ret = insGetTableDataCxt(((SVnodeModifyOpStmt*)(query->pRoot))->pTableBlockHashObj, &pTableMeta->uid,	1,008,738✔
320	sizeof(pTableMeta->uid), pTableMeta, &pCreateTblReq, &pTableCxt, false, false);
321	TSDB_CHECK_CODE(ret, lino, end);	1,008,703✔
322
323	SSchema* pSchema = getTableColumnSchema(pTableMeta);	1,008,703✔
324	ret = smlBoundColumnData(colsSchema, &pTableCxt->boundColsInfo, pSchema, false);	1,008,703✔
325	TSDB_CHECK_CODE(ret, lino, end);	1,008,703✔
326
327	ret = initTableColSubmitData(pTableCxt);	1,008,703✔
328	TSDB_CHECK_CODE(ret, lino, end);	1,008,437✔
329
330	int32_t rowNum = taosArrayGetSize(cols);	1,008,437✔
331	TSDB_CHECK_CONDITION(rowNum > 0, ret, lino, end, TSDB_CODE_TSC_INVALID_OPERATION);	1,008,437✔
332
333	for (int32_t r = 0; r < rowNum; ++r) {	28,226,573✔
334	void* rowData = taosArrayGetP(cols, r);	27,220,458✔
335	TSDB_CHECK_NULL(rowData, ret, lino, end, terrno);	27,089,136✔
336
337	// 1. set the parsed value from sql string
338	for (int c = 0; c < pTableCxt->boundColsInfo.numOfBound; ++c) {	178,342,093✔
339	SSchema* pColSchema = &pSchema[pTableCxt->boundColsInfo.pColIndex[c]];	150,117,250✔
340	SColVal* pVal = taosArrayGet(pTableCxt->pValues, pTableCxt->boundColsInfo.pColIndex[c]);	150,414,984✔
341	TSDB_CHECK_NULL(pVal, ret, lino, end, terrno);	150,305,709✔
342	void** p = taosHashGet(rowData, pColSchema->name, strlen(pColSchema->name));	150,305,709✔
343	if (p == NULL) {	150,460,449✔
344	continue;	28,125✔
345	}
346	SSmlKv* kv = (SSmlKv*)p;	150,432,324✔
347	TSDB_CHECK_CONDITION(kv->type == pColSchema->type, ret, lino, end, TSDB_CODE_TSC_INVALID_OPERATION);	150,544,304✔
348
349	if (pColSchema->type == TSDB_DATA_TYPE_TIMESTAMP) {	150,569,355✔
350	kv->i = convertTimePrecision(kv->i, TSDB_TIME_PRECISION_NANO, pTableMeta->tableInfo.precision);	27,293,472✔
351	}
352	if (kv->type == TSDB_DATA_TYPE_NCHAR) {	150,577,353✔
353	ret = smlMbsToUcs4(kv->value, kv->length, (void*)&pVal->value.pData, (int32_t)&pVal->value.nData,	152,928✔
354	pColSchema->bytes - VARSTR_HEADER_SIZE, charsetCxt);	152,928✔
355	TSDB_CHECK_CODE(ret, lino, end);	152,928✔
356	} else if (kv->type == TSDB_DATA_TYPE_BINARY) {	149,779,686✔
357	pVal->value.nData = kv->length;	21,379,860✔
358	pVal->value.pData = (uint8_t*)kv->value;	21,381,713✔
359	} else if (kv->type == TSDB_DATA_TYPE_GEOMETRY \|\| kv->type == TSDB_DATA_TYPE_VARBINARY) {	128,421,734✔
360	pVal->value.nData = kv->length;	×
361	pVal->value.pData = taosMemoryMalloc(kv->length);	2,760✔
362	TSDB_CHECK_NULL(pVal->value.pData, ret, lino, end, terrno);	2,760✔
363	(void)memcpy(pVal->value.pData, (uint8_t*)kv->value, kv->length);	2,760✔
364	} else {
365	valueSetDatum(&pVal->value, kv->type, &(kv->value), kv->length);	128,560,355✔
366	}
367	pVal->flag = CV_FLAG_VALUE;	151,182,058✔
368	}
369
370	SRow** pRow = taosArrayReserve(pTableCxt->pData->aRowP, 1);	27,319,823✔
371	TSDB_CHECK_NULL(pRow, ret, lino, end, terrno);	27,269,994✔
372	SRowBuildScanInfo sinfo = {0};	27,269,994✔
373	ret = tRowBuild(pTableCxt->pValues, pTableCxt->pSchema, pRow, &sinfo);	27,272,058✔
374	TSDB_CHECK_CODE(ret, lino, end);	27,216,295✔
375	SRowKey key = {0};	27,216,295✔
376	tRowGetKey(*pRow, &key);	54,476,708✔
377	insCheckTableDataOrder(pTableCxt, &key);	27,239,515✔
378	clearColValArraySml(pTableCxt->pValues);	27,159,828✔
379	}
380
381	end:	1,000,055✔
382	if (ret != 0) {	1,037,632✔
383	uError("%s failed at %d since %s", __func__, lino, tstrerror(ret));	×
384	ret = buildInvalidOperationMsg(&pBuf, tstrerror(ret));	×
385	}
386	insDestroyBoundColInfo(&bindTags);	1,037,632✔
387	tdDestroySVCreateTbReq(pCreateTblReq);	1,037,597✔
388	taosMemoryFree(pCreateTblReq);	1,037,632✔
389	taosArrayDestroy(tagName);	1,037,366✔
390	return ret;	1,037,366✔
391	}
392
393	int32_t smlInitHandle(SQuery** query) {	587,221✔
394	int32_t lino = 0;	587,221✔
395	int32_t code = 0;	587,221✔
396	SQuery* pQuery = NULL;	587,221✔
397	SVnodeModifyOpStmt* stmt = NULL;	587,221✔
398	TSDB_CHECK_NULL(query, code, lino, end, TSDB_CODE_INVALID_PARA);	587,221✔
399
400	*query = NULL;	587,221✔
401	code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);	587,221✔
402	TSDB_CHECK_CODE(code, lino, end);	587,200✔
403	pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;	587,200✔
404	pQuery->haveResultSet = false;	587,200✔
405	pQuery->msgType = TDMT_VND_SUBMIT;	587,200✔
406	code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&stmt);	587,200✔
407	TSDB_CHECK_CODE(code, lino, end);	587,235✔
408	stmt->pTableBlockHashObj = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);	587,235✔
409	TSDB_CHECK_NULL(stmt->pTableBlockHashObj, code, lino, end, terrno);	587,270✔
410	stmt->freeHashFunc = insDestroyTableDataCxtHashMap;	587,270✔
411	stmt->freeArrayFunc = insDestroyVgroupDataCxtList;	587,270✔
412
413	pQuery->pRoot = (SNode*)stmt;	587,270✔
414	*query = pQuery;	587,270✔
415	return code;	587,270✔
416
417	end:	×
418	if (code != 0) {	×
419	uError("%s failed at %d since %s", __func__, lino, tstrerror(code));	×
420	}
421	nodesDestroyNode((SNode*)stmt);	×
422	qDestroyQuery(pQuery);	×
423	return code;	×
424	}
425
426	int32_t smlBuildOutput(SQuery* handle, SHashObj* pVgHash) {	467,956✔
427	int32_t lino = 0;	467,956✔
428	int32_t code = 0;	467,956✔
429
430	SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)(handle)->pRoot;	467,956✔
431	code = insMergeTableDataCxt(pStmt->pTableBlockHashObj, &pStmt->pVgDataBlocks, true);	467,956✔
432	TSDB_CHECK_CODE(code, lino, end);	467,956✔
433	code = insBuildVgDataBlocks(pVgHash, pStmt->pVgDataBlocks, &pStmt->pDataBlocks, false);	467,956✔
434	TSDB_CHECK_CODE(code, lino, end);	467,956✔
435
436	end:	467,956✔
437	if (code != 0) {	467,956✔
438	uError("%s failed at %d since %s", __func__, lino, tstrerror(code));	×
439	}
440	return code;	467,921✔
441	}
442
443	int32_t smlBuildOutputRaw(SQuery* handle, SHashObj* pVgHash) {	92✔
444	int32_t lino = 0;	92✔
445	int32_t code = 0;	92✔
446
447	SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)(handle)->pRoot;	92✔
448	code = insBuildVgDataBlocks(pVgHash, pStmt->pVgDataBlocks, &pStmt->pDataBlocks, false);	92✔
449	TSDB_CHECK_CODE(code, lino, end);	92✔
450
451	end:	92✔
452	if (code != 0) {	92✔
453	uError("%s failed at %d since %s", __func__, lino, tstrerror(code));	×
454	}
455	return code;	92✔
456	}

taosdata / TDengine / #4897

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