taosdata/TDengine | Build 3621 | source/libs/command/src/command.c | Coveralls

UNCOV

static int32_t buildRetrieveTableRsp(SSDataBlock* pBlock, int32_t numOfCols, SRetrieveTableRsp** pRsp) {

×

UNCOV

38

  if (NULL == pBlock || NULL == pRsp) {

×

39

    return TSDB_CODE_INVALID_PARA;

×

UNCOV

41

  size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);

×

UNCOV

42

  size_t rspSize = sizeof(SRetrieveTableRsp) + dataEncodeBufSize + PAYLOAD_PREFIX_LEN;

×

UNCOV

43

  *pRsp = taosMemoryCalloc(1, rspSize);

×

UNCOV

44

  if (NULL == *pRsp) {

×

45

    return terrno;

×

UNCOV

48

  (*pRsp)->useconds = 0;

×

UNCOV

49

  (*pRsp)->completed = 1;

×

UNCOV

50

  (*pRsp)->precision = 0;

×

UNCOV

51

  (*pRsp)->compressed = 0;

×

UNCOV

53

  (*pRsp)->numOfRows = htobe64((int64_t)pBlock->info.rows);

×

UNCOV

54

  (*pRsp)->numOfCols = htonl(numOfCols);

×

UNCOV

56

  int32_t len = blockEncode(pBlock, (*pRsp)->data + PAYLOAD_PREFIX_LEN, dataEncodeBufSize, numOfCols);

×

UNCOV

57

  if (len < 0) {

×

58

    taosMemoryFree(*pRsp);

×

59

    *pRsp = NULL;

×

60

    return terrno;

×

UNCOV

62

  SET_PAYLOAD_LEN((*pRsp)->data, len, len);

×

UNCOV

64

  int32_t payloadLen = len + PAYLOAD_PREFIX_LEN;

×

UNCOV

65

  (*pRsp)->payloadLen = htonl(payloadLen);

×

UNCOV

66

  (*pRsp)->compLen = htonl(payloadLen);

×

UNCOV

68

  return TSDB_CODE_SUCCESS;

×

UNCOV

71

static int32_t getSchemaBytes(const SSchema* pSchema) {

×

UNCOV

72

  switch (pSchema->type) {

×

UNCOV

73

    case TSDB_DATA_TYPE_BINARY:

×

UNCOV

76

      return (pSchema->bytes - VARSTR_HEADER_SIZE);

×

UNCOV

77

    case TSDB_DATA_TYPE_NCHAR:

×

UNCOV

79

      return (pSchema->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;

×

UNCOV

80

    default:

×

UNCOV

81

      return pSchema->bytes;

×

UNCOV

85

static int32_t buildDescResultDataBlock(SSDataBlock** pOutput) {

×

UNCOV

86

  QRY_PARAM_CHECK(pOutput);

×

UNCOV

88

  SSDataBlock* pBlock = NULL;

×

UNCOV

89

  int32_t      code = createDataBlock(&pBlock);

×

UNCOV

90

  if (code) {

×

91

    return code;

×

UNCOV

94

  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_FIELD_LEN, 1);

×

UNCOV

95

  code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

96

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

97

    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_TYPE_LEN, 2);

×

UNCOV

98

    code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

100

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

101

    infoData = createColumnInfoData(TSDB_DATA_TYPE_INT, tDataTypes[TSDB_DATA_TYPE_INT].bytes, 3);

×

UNCOV

102

    code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

104

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

105

    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_NOTE_LEN, 4);

×

UNCOV

106

    code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

108

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

109

    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_COPRESS_OPTION_LEN, 5);

×

UNCOV

110

    code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

112

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

113

    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_COPRESS_OPTION_LEN, 6);

×

UNCOV

114

    code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

116

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

117

    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_COPRESS_OPTION_LEN, 7);

×

UNCOV

118

    code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

121

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

122

    *pOutput = pBlock;

×

124

    (void)blockDataDestroy(pBlock);

×

UNCOV

126

  return code;

×

UNCOV

129

static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock, int32_t numOfRows, STableMeta* pMeta,

×

UNCOV

131

  int32_t blockCap = (biMode != 0) ? numOfRows + 1 : numOfRows;

×

UNCOV

132

  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, blockCap));

×

UNCOV

133

  pBlock->info.rows = 0;

×

UNCOV

136

  SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);

×

UNCOV

138

  SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);

×

UNCOV

140

  SColumnInfoData* pCol3 = taosArrayGet(pBlock->pDataBlock, 2);

×

UNCOV

142

  SColumnInfoData* pCol4 = taosArrayGet(pBlock->pDataBlock, 3);

×

UNCOV

144

  SColumnInfoData* pCol5 = NULL;

×

UNCOV

146

  SColumnInfoData* pCol6 = NULL;

×

UNCOV

148

  SColumnInfoData* pCol7 = NULL;

×

UNCOV

149

  if (useCompress(pMeta->tableType)) {

×

UNCOV

150

    pCol5 = taosArrayGet(pBlock->pDataBlock, 4);

×

UNCOV

151

    pCol6 = taosArrayGet(pBlock->pDataBlock, 5);

×

UNCOV

152

    pCol7 = taosArrayGet(pBlock->pDataBlock, 6);

×

UNCOV

155

  int32_t fillTagCol = 0;

×

UNCOV

156

  char    buf[DESCRIBE_RESULT_FIELD_LEN] = {0};

×

UNCOV

157

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

×

UNCOV

158

    if (invisibleColumn(sysInfoUser, pMeta->tableType, pMeta->schema[i].flags)) {

×

159

      continue;

×

UNCOV

161

    STR_TO_VARSTR(buf, pMeta->schema[i].name);

×

UNCOV

162

    COL_DATA_SET_VAL_AND_CHECK(pCol1, pBlock->info.rows, buf, false);

×

UNCOV

164

    STR_TO_VARSTR(buf, tDataTypes[pMeta->schema[i].type].name);

×

UNCOV

165

    COL_DATA_SET_VAL_AND_CHECK(pCol2, pBlock->info.rows, buf, false);

×

UNCOV

166

    int32_t bytes = getSchemaBytes(pMeta->schema + i);

×

UNCOV

167

    COL_DATA_SET_VAL_AND_CHECK(pCol3, pBlock->info.rows, (const char*)&bytes, false);

×

UNCOV

168

    if (TSDB_VIEW_TABLE != pMeta->tableType) {

×

UNCOV

169

      if (i >= pMeta->tableInfo.numOfColumns) {

×

UNCOV

170

        STR_TO_VARSTR(buf, "TAG");

×

UNCOV

171

        fillTagCol = 1;

×

UNCOV

172

      } else if (i == 1 && pMeta->schema[i].flags & COL_IS_KEY) {

×

UNCOV

173

        STR_TO_VARSTR(buf, "PRIMARY KEY")

×

UNCOV

175

        STR_TO_VARSTR(buf, "");

×

UNCOV

178

      STR_TO_VARSTR(buf, "VIEW COL");

×

UNCOV

180

    COL_DATA_SET_VAL_AND_CHECK(pCol4, pBlock->info.rows, buf, false);

×

UNCOV

181

    if (useCompress(pMeta->tableType) && pMeta->schemaExt) {

×

UNCOV

182

      if (i < pMeta->tableInfo.numOfColumns) {

×

UNCOV

183

        STR_TO_VARSTR(buf, columnEncodeStr(COMPRESS_L1_TYPE_U32(pMeta->schemaExt[i].compress)));

×

UNCOV

184

        COL_DATA_SET_VAL_AND_CHECK(pCol5, pBlock->info.rows, buf, false);

×

UNCOV

185

        STR_TO_VARSTR(buf, columnCompressStr(COMPRESS_L2_TYPE_U32(pMeta->schemaExt[i].compress)));

×

UNCOV

186

        COL_DATA_SET_VAL_AND_CHECK(pCol6, pBlock->info.rows, buf, false);

×

UNCOV

187

        STR_TO_VARSTR(buf, columnLevelStr(COMPRESS_L2_TYPE_LEVEL_U32(pMeta->schemaExt[i].compress)));

×

UNCOV

188

        COL_DATA_SET_VAL_AND_CHECK(pCol7, pBlock->info.rows, buf, false);

×

UNCOV

190

        STR_TO_VARSTR(buf, fillTagCol == 0 ? "" : "disabled");

×

UNCOV

191

        COL_DATA_SET_VAL_AND_CHECK(pCol5, pBlock->info.rows, buf, false);

×

UNCOV

192

        STR_TO_VARSTR(buf, fillTagCol == 0 ? "" : "disabled");

×

UNCOV

193

        COL_DATA_SET_VAL_AND_CHECK(pCol6, pBlock->info.rows, buf, false);

×

UNCOV

194

        STR_TO_VARSTR(buf, fillTagCol == 0 ? "" : "disabled");

×

UNCOV

195

        COL_DATA_SET_VAL_AND_CHECK(pCol7, pBlock->info.rows, buf, false);

×

UNCOV

199

    fillTagCol = 0;

×

UNCOV

201

    ++(pBlock->info.rows);

×

UNCOV

203

  if (pMeta->tableType == TSDB_SUPER_TABLE && biMode != 0) {

×

204

    STR_TO_VARSTR(buf, "tbname");

×

205

    COL_DATA_SET_VAL_AND_CHECK(pCol1, pBlock->info.rows, buf, false);

×

206

    STR_TO_VARSTR(buf, "VARCHAR");

×

207

    COL_DATA_SET_VAL_AND_CHECK(pCol2, pBlock->info.rows, buf, false);

×

208

    int32_t bytes = TSDB_TABLE_NAME_LEN - 1;

×

209

    COL_DATA_SET_VAL_AND_CHECK(pCol3, pBlock->info.rows, (const char*)&bytes, false);

×

210

    STR_TO_VARSTR(buf, "TAG");

×

211

    COL_DATA_SET_VAL_AND_CHECK(pCol4, pBlock->info.rows, buf, false);

×

212

    ++(pBlock->info.rows);

×

UNCOV

214

  if (pBlock->info.rows <= 0) {

×

215

    qError("no permission to view any columns");

×

216

    return TSDB_CODE_PAR_PERMISSION_DENIED;

×

UNCOV

218

  return TSDB_CODE_SUCCESS;

×

UNCOV

221

static int32_t execDescribe(bool sysInfoUser, SNode* pStmt, SRetrieveTableRsp** pRsp, int8_t biMode) {

×

UNCOV

222

  SDescribeStmt* pDesc = (SDescribeStmt*)pStmt;

×

UNCOV

223

  if (NULL == pDesc || NULL == pDesc->pMeta) {

×

224

    return TSDB_CODE_INVALID_PARA;

×

UNCOV

226

  int32_t numOfRows = TABLE_TOTAL_COL_NUM(pDesc->pMeta);

×

UNCOV

228

  SSDataBlock* pBlock = NULL;

×

UNCOV

229

  int32_t      code = buildDescResultDataBlock(&pBlock);

×

UNCOV

230

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

231

    code = setDescResultIntoDataBlock(sysInfoUser, pBlock, numOfRows, pDesc->pMeta, biMode);

×

UNCOV

233

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

234

    if (pDesc->pMeta && useCompress(pDesc->pMeta->tableType) && pDesc->pMeta->schemaExt) {

×

UNCOV

235

      code = buildRetrieveTableRsp(pBlock, DESCRIBE_RESULT_COLS_COMPRESS, pRsp);

×

UNCOV

237

      code = buildRetrieveTableRsp(pBlock, DESCRIBE_RESULT_COLS, pRsp);

×

UNCOV

240

  (void)blockDataDestroy(pBlock);

×

UNCOV

241

  return code;

×

UNCOV

244

static int32_t execResetQueryCache() { return catalogClearCache(); }

×

UNCOV

246

static int32_t buildCreateDBResultDataBlock(SSDataBlock** pOutput) {

×

UNCOV

247

  QRY_PARAM_CHECK(pOutput);

×

UNCOV

249

  SSDataBlock* pBlock = NULL;

×

UNCOV

250

  int32_t      code = createDataBlock(&pBlock);

×

UNCOV

251

  if (code) {

×

252

    return code;

×

UNCOV

255

  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_DB_RESULT_COLS, 1);

×

UNCOV

256

  code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

257

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

258

    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_DB_RESULT_FIELD2_LEN, 2);

×

UNCOV

259

    code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

262

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

263

    *pOutput = pBlock;

×

265

    (void)blockDataDestroy(pBlock);

×

UNCOV

267

  return code;

×

270

int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {

×

271

  int64_t v = 0;

×

272

  switch (unit) {

×

273

    case 's':

×

274

      v = val / 1000;

×

275

      break;

×

276

    case 'm':

×

277

      v = val / tsTickPerMin[TSDB_TIME_PRECISION_MILLI];

×

278

      break;

×

279

    case 'h':

×

280

      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 60);

×

281

      break;

×

282

    case 'd':

×

283

      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60);

×

284

      break;

×

285

    case 'w':

×

286

      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60 * 7);

×

287

      break;

×

288

    default:

×

289

      break;

×

292

  return v;

×

UNCOV

295

static int32_t buildRetension(SArray* pRetension, char** ppRetentions) {

×

UNCOV

296

  size_t size = taosArrayGetSize(pRetension);

×

UNCOV

297

  if (size == 0) {

×

UNCOV

298

    *ppRetentions = NULL;

×

UNCOV

299

    return TSDB_CODE_SUCCESS;

×

302

  const int lMaxLen = 128;

×

303

  char*     p1 = taosMemoryCalloc(1, lMaxLen);

×

304

  if (NULL == p1) {

×

305

    return terrno;

×

307

  int32_t len = 0;

×

309

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

×

310

    SRetention* p = TARRAY_GET_ELEM(pRetension, i);

×

311

    int64_t     v1 = getValOfDiffPrecision(p->freqUnit, p->freq);

×

312

    int64_t     v2 = getValOfDiffPrecision(p->keepUnit, p->keep);

×

313

    if (i == 0) {

×

314

      len += tsnprintf(p1 + len, lMaxLen - len, "-:%" PRId64 "%c", v2, p->keepUnit);

×

316

      len += tsnprintf(p1 + len, lMaxLen - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);

×

319

    if (i < size - 1) {

×

320

      len += tsnprintf(p1 + len, lMaxLen - len, ",");

×

324

  *ppRetentions = p1;

×

325

  return TSDB_CODE_SUCCESS;

×

UNCOV

328

static const char* cacheModelStr(int8_t cacheModel) {

×

UNCOV

329

  switch (cacheModel) {

×

UNCOV

330

    case TSDB_CACHE_MODEL_NONE:

×

UNCOV

331

      return TSDB_CACHE_MODEL_NONE_STR;

×

332

    case TSDB_CACHE_MODEL_LAST_ROW:

×

333

      return TSDB_CACHE_MODEL_LAST_ROW_STR;

×

334

    case TSDB_CACHE_MODEL_LAST_VALUE:

×

335

      return TSDB_CACHE_MODEL_LAST_VALUE_STR;

×

336

    case TSDB_CACHE_MODEL_BOTH:

×

337

      return TSDB_CACHE_MODEL_BOTH_STR;

×

338

    default:

×

339

      break;

×

341

  return TSDB_CACHE_MODEL_NONE_STR;

×

UNCOV

344

static const char* encryptAlgorithmStr(int8_t encryptAlgorithm) {

×

UNCOV

345

  switch (encryptAlgorithm) {

×

UNCOV

346

    case TSDB_ENCRYPT_ALGO_NONE:

×

UNCOV

347

      return TSDB_ENCRYPT_ALGO_NONE_STR;

×

348

    case TSDB_ENCRYPT_ALGO_SM4:

×

349

      return TSDB_ENCRYPT_ALGO_SM4_STR;

×

350

    default:

×

351

      break;

×

353

  return TSDB_CACHE_MODEL_NONE_STR;

×

UNCOV

356

int32_t formatDurationOrKeep(char* buffer, int64_t bufSize, int32_t timeInMinutes) {

×

UNCOV

357

  if (buffer == NULL || bufSize <= 0) {

×

358

    return 0;

×

UNCOV

360

  int32_t len = 0;

×

UNCOV

361

  if (timeInMinutes % 1440 == 0) {

×

UNCOV

362

    int32_t days = timeInMinutes / 1440;

×

UNCOV

363

    len = tsnprintf(buffer, bufSize, "%dd", days);

×

364

  } else if (timeInMinutes % 60 == 0) {

×

UNCOV

365

    int32_t hours = timeInMinutes / 60;

×

UNCOV

366

    len = tsnprintf(buffer, bufSize, "%dh", hours);

×

368

    len = tsnprintf(buffer, bufSize, "%dm", timeInMinutes);

×

UNCOV

370

  return len;

×

UNCOV

373

static int32_t setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbName, char* dbFName, SDbCfgInfo* pCfg) {

×

UNCOV

374

  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));

×

UNCOV

375

  pBlock->info.rows = 1;

×

UNCOV

377

  SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);

×

UNCOV

378

  char             buf1[SHOW_CREATE_DB_RESULT_FIELD1_LEN] = {0};

×

UNCOV

379

  STR_TO_VARSTR(buf1, dbName);

×

UNCOV

380

  COL_DATA_SET_VAL_AND_CHECK(pCol1, 0, buf1, false);

×

UNCOV

382

  SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);

×

UNCOV

383

  char             buf2[SHOW_CREATE_DB_RESULT_FIELD2_LEN] = {0};

×

UNCOV

384

  int32_t          len = 0;

×

UNCOV

385

  char*            prec = NULL;

×

UNCOV

386

  switch (pCfg->precision) {

×

UNCOV

387

    case TSDB_TIME_PRECISION_MILLI:

×

UNCOV

388

      prec = TSDB_TIME_PRECISION_MILLI_STR;

×

UNCOV

389

      break;

×

390

    case TSDB_TIME_PRECISION_MICRO:

×

391

      prec = TSDB_TIME_PRECISION_MICRO_STR;

×

392

      break;

×

393

    case TSDB_TIME_PRECISION_NANO:

×

394

      prec = TSDB_TIME_PRECISION_NANO_STR;

×

395

      break;

×

396

    default:

×

397

      prec = "none";

×

398

      break;

×

UNCOV

401

  char* pRetentions = NULL;

×

UNCOV

402

  QRY_ERR_RET(buildRetension(pCfg->pRetensions, &pRetentions));

×

UNCOV

403

  int32_t dbFNameLen = strlen(dbFName);

×

UNCOV

404

  int32_t hashPrefix = 0;

×

UNCOV

405

  if (pCfg->hashPrefix > 0) {

×

UNCOV

406

    hashPrefix = pCfg->hashPrefix - dbFNameLen - 1;

×

UNCOV

407

  } else if (pCfg->hashPrefix < 0) {

×

UNCOV

408

    hashPrefix = pCfg->hashPrefix + dbFNameLen + 1;

×

UNCOV

410

  char durationStr[128] = {0};

×

UNCOV

411

  char keep0Str[128] = {0};

×

UNCOV

412

  char keep1Str[128] = {0};

×

UNCOV

413

  char keep2Str[128] = {0};

×

UNCOV

414

  char compactIntervalStr[13] = {0};

×

UNCOV

415

  char compactStartTimeStr[13] = {0};

×

UNCOV

416

  char compactEndTimeStr[13] = {0};

×

UNCOV

418

  int32_t lenDuration = formatDurationOrKeep(durationStr, sizeof(durationStr), pCfg->daysPerFile);

×

UNCOV

419

  int32_t lenKeep0 = formatDurationOrKeep(keep0Str, sizeof(keep0Str), pCfg->daysToKeep0);

×

UNCOV

420

  int32_t lenKeep1 = formatDurationOrKeep(keep1Str, sizeof(keep1Str), pCfg->daysToKeep1);

×

UNCOV

421

  int32_t lenKeep2 = formatDurationOrKeep(keep2Str, sizeof(keep2Str), pCfg->daysToKeep2);

×

UNCOV

422

  UNUSED(formatDurationOrKeep(compactIntervalStr, sizeof(compactIntervalStr), pCfg->compactInterval));

×

UNCOV

423

  UNUSED(formatDurationOrKeep(compactStartTimeStr, sizeof(compactStartTimeStr), pCfg->compactStartTime));

×

UNCOV

424

  UNUSED(formatDurationOrKeep(compactEndTimeStr, sizeof(compactEndTimeStr), pCfg->compactEndTime));

×

UNCOV

426

  if (IS_SYS_DBNAME(dbName)) {

×

427

    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_DB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,

×

428

                     "CREATE DATABASE `%s`", dbName);

×

UNCOV

430

    len +=

×

UNCOV

431

        tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_DB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,

×

UNCOV

439

                  dbName, pCfg->buffer, pCfg->cacheSize, cacheModelStr(pCfg->cacheLast), pCfg->compression, durationStr,

×

UNCOV

440

                  pCfg->walFsyncPeriod, pCfg->maxRows, pCfg->minRows, pCfg->sstTrigger, keep0Str, keep1Str, keep2Str,

×

UNCOV

441

                  pCfg->pages, pCfg->pageSize, prec, pCfg->replications, pCfg->walLevel, pCfg->numOfVgroups,

×

UNCOV

442

                  1 == pCfg->numOfStables, hashPrefix, pCfg->hashSuffix, pCfg->tsdbPageSize, pCfg->walRetentionPeriod,

×

UNCOV

443

                  pCfg->walRetentionSize, pCfg->keepTimeOffset, encryptAlgorithmStr(pCfg->encryptAlgorithm),

×

UNCOV

444

                  pCfg->s3ChunkSize, pCfg->s3KeepLocal, pCfg->s3Compact, compactIntervalStr, compactStartTimeStr,

×

UNCOV

445

                  compactEndTimeStr, pCfg->compactTimeOffset);

×

UNCOV

447

    if (pRetentions) {

×

448

      len += tsnprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_DB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,

×

UNCOV

453

  taosMemoryFree(pRetentions);

×

UNCOV

455

  (varDataLen(buf2)) = len;

×

UNCOV

457

  COL_DATA_SET_VAL_AND_CHECK(pCol2, 0, buf2, false);

×

UNCOV

459

  return TSDB_CODE_SUCCESS;

×

UNCOV

462

static int32_t execShowCreateDatabase(SShowCreateDatabaseStmt* pStmt, SRetrieveTableRsp** pRsp) {

×

UNCOV

463

  SSDataBlock* pBlock = NULL;

×

UNCOV

464

  int32_t      code = buildCreateDBResultDataBlock(&pBlock);

×

UNCOV

465

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

466

    code = setCreateDBResultIntoDataBlock(pBlock, pStmt->dbName, pStmt->dbFName, pStmt->pCfg);

×

UNCOV

468

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

469

    code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_DB_RESULT_COLS, pRsp);

×

UNCOV

471

  (void)blockDataDestroy(pBlock);

×

UNCOV

472

  return code;

×

UNCOV

475

static int32_t buildCreateTbResultDataBlock(SSDataBlock** pOutput) {

×

UNCOV

476

  QRY_PARAM_CHECK(pOutput);

×

UNCOV

478

  SSDataBlock* pBlock = NULL;

×

UNCOV

479

  int32_t      code = createDataBlock(&pBlock);

×

UNCOV

480

  if (code) {

×

481

    return code;

×

UNCOV

484

  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_TB_RESULT_FIELD1_LEN, 1);

×

UNCOV

485

  code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

486

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

487

    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_TB_RESULT_FIELD2_LEN, 2);

×

UNCOV

488

    code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

491

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

492

    *pOutput = pBlock;

×

494

    (void)blockDataDestroy(pBlock);

×

UNCOV

496

  return code;

×

UNCOV

499

static int32_t buildCreateViewResultDataBlock(SSDataBlock** pOutput) {

×

UNCOV

500

  QRY_PARAM_CHECK(pOutput);

×

UNCOV

502

  SSDataBlock* pBlock = NULL;

×

UNCOV

503

  int32_t      code = createDataBlock(&pBlock);

×

UNCOV

504

  if (code) {

×

505

    return code;

×

UNCOV

508

  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_VIEW_RESULT_FIELD1_LEN, 1);

×

UNCOV

509

  code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

510

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

511

    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_VIEW_RESULT_FIELD2_LEN, 2);

×

UNCOV

512

    code = blockDataAppendColInfo(pBlock, &infoData);

×

UNCOV

515

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

516

    *pOutput = pBlock;

×

518

    (void)blockDataDestroy(pBlock);

×

UNCOV

520

  return code;

×

UNCOV

523

static void appendColumnFields(char* buf, int32_t* len, STableCfg* pCfg) {

×

UNCOV

524

  for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {

×

UNCOV

525

    SSchema* pSchema = pCfg->pSchemas + i;

×

UNCOV

528

    snprintf(type, LTYPE_LEN, "%s", tDataTypes[pSchema->type].name);

×

UNCOV

529

    int typeLen = strlen(type);

×

UNCOV

530

    if (TSDB_DATA_TYPE_VARCHAR == pSchema->type || TSDB_DATA_TYPE_VARBINARY == pSchema->type ||

×

UNCOV

531

        TSDB_DATA_TYPE_GEOMETRY == pSchema->type) {

×

UNCOV

532

      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, "(%d)", (int32_t)(pSchema->bytes - VARSTR_HEADER_SIZE));

×

UNCOV

533

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

×

UNCOV

534

      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, "(%d)",

×

UNCOV

535

                           (int32_t)((pSchema->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));

×

UNCOV

538

    if (useCompress(pCfg->tableType) && pCfg->pSchemaExt) {

×

UNCOV

539

      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, " ENCODE \'%s\'",

×

UNCOV

540

                           columnEncodeStr(COMPRESS_L1_TYPE_U32(pCfg->pSchemaExt[i].compress)));

×

UNCOV

541

      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, " COMPRESS \'%s\'",

×

UNCOV

542

                           columnCompressStr(COMPRESS_L2_TYPE_U32(pCfg->pSchemaExt[i].compress)));

×

UNCOV

543

      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, " LEVEL \'%s\'",

×

UNCOV

544

                           columnLevelStr(COMPRESS_L2_TYPE_LEVEL_U32(pCfg->pSchemaExt[i].compress)));

×

UNCOV

546

    if (!(pSchema->flags & COL_IS_KEY)) {

×

UNCOV

547

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

548

                        "%s`%s` %s", ((i > 0) ? ", " : ""), pSchema->name, type);

×

UNCOV

550

      char* pk = "PRIMARY KEY";

×

UNCOV

551

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

552

                        "%s`%s` %s %s", ((i > 0) ? ", " : ""), pSchema->name, type, pk);

×

UNCOV

555

×

UNCOV

557

static void appendTagFields(char* buf, int32_t* len, STableCfg* pCfg) {

×

UNCOV

558

  for (int32_t i = 0; i < pCfg->numOfTags; ++i) {

×

UNCOV

559

    SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;

×

UNCOV

561

    snprintf(type, sizeof(type), "%s", tDataTypes[pSchema->type].name);

×

UNCOV

562

    if (TSDB_DATA_TYPE_VARCHAR == pSchema->type || TSDB_DATA_TYPE_VARBINARY == pSchema->type ||

×

UNCOV

563

        TSDB_DATA_TYPE_GEOMETRY == pSchema->type) {

×

UNCOV

564

      snprintf(type + strlen(type), sizeof(type) - strlen(type), "(%d)",

×

UNCOV

565

               (int32_t)(pSchema->bytes - VARSTR_HEADER_SIZE));

×

UNCOV

566

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

×

UNCOV

567

      snprintf(type + strlen(type), sizeof(type) - strlen(type), "(%d)",

×

UNCOV

568

               (int32_t)((pSchema->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));

×

UNCOV

571

    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

572

                      "%s`%s` %s", ((i > 0) ? ", " : ""), pSchema->name, type);

×

UNCOV

574

×

UNCOV

576

static void appendTagNameFields(char* buf, int32_t* len, STableCfg* pCfg) {

×

UNCOV

577

  for (int32_t i = 0; i < pCfg->numOfTags; ++i) {

×

UNCOV

578

    SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;

×

UNCOV

579

    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

580

                      "%s`%s`", ((i > 0) ? ", " : ""), pSchema->name);

×

UNCOV

582

×

UNCOV

584

static int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg, void* charsetCxt) {

×

UNCOV

585

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

586

  SArray* pTagVals = NULL;

×

UNCOV

587

  STag*   pTag = (STag*)pCfg->pTags;

×

UNCOV

589

  if (NULL == pCfg->pTags || pCfg->numOfTags <= 0) {

×

590

    qError("tag missed in table cfg, pointer:%p, numOfTags:%d", pCfg->pTags, pCfg->numOfTags);

×

591

    return TSDB_CODE_APP_ERROR;

×

UNCOV

594

  if (tTagIsJson(pTag)) {

×

UNCOV

595

    char* pJson = NULL;

×

UNCOV

596

    parseTagDatatoJson(pTag, &pJson, charsetCxt);

×

UNCOV

597

    if (NULL == pJson) {

×

598

      qError("failed to parse tag to json, pJson is NULL");

×

599

      return terrno;

×

UNCOV

601

    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

603

    taosMemoryFree(pJson);

×

UNCOV

605

    return TSDB_CODE_SUCCESS;

×

UNCOV

608

  QRY_ERR_RET(tTagToValArray((const STag*)pCfg->pTags, &pTagVals));

×

UNCOV

609

  int16_t valueNum = taosArrayGetSize(pTagVals);

×

UNCOV

610

  int32_t num = 0;

×

UNCOV

611

  int32_t j = 0;

×

UNCOV

612

  for (int32_t i = 0; i < pCfg->numOfTags; ++i) {

×

UNCOV

613

    SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;

×

UNCOV

614

    if (i > 0) {

×

UNCOV

615

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

619

    if (j >= valueNum) {

×

UNCOV

620

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

622

      continue;

×

UNCOV

625

    STagVal* pTagVal = (STagVal*)taosArrayGet(pTagVals, j);

×

UNCOV

626

    if (pSchema->colId > pTagVal->cid) {

×

627

      qError("tag value and column mismatch, schemaId:%d, valId:%d", pSchema->colId, pTagVal->cid);

×

628

      code = TSDB_CODE_APP_ERROR;

×

629

      TAOS_CHECK_ERRNO(code);

×

UNCOV

630

    } else if (pSchema->colId == pTagVal->cid) {

×

UNCOV

631

      char    type = pTagVal->type;

×

UNCOV

632

      int32_t tlen = 0;

×

UNCOV

634

      int64_t leftSize = SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len);

×

UNCOV

635

      if (leftSize <= 0) {

×

636

        qError("no enough space to store tag value, leftSize:%" PRId64, leftSize);

×

637

        code = TSDB_CODE_APP_ERROR;

×

638

        TAOS_CHECK_ERRNO(code);

×

UNCOV

640

      if (IS_VAR_DATA_TYPE(type)) {

×

UNCOV

641

        code = dataConverToStr(buf + VARSTR_HEADER_SIZE + *len, leftSize, type, pTagVal->pData, pTagVal->nData, &tlen);

×

UNCOV

642

        TAOS_CHECK_ERRNO(code);

×

UNCOV

644

        code = dataConverToStr(buf + VARSTR_HEADER_SIZE + *len, leftSize, type, &pTagVal->i64, tDataTypes[type].bytes,

×

UNCOV

646

        TAOS_CHECK_ERRNO(code);

×

UNCOV

648

      *len += tlen;

×

UNCOV

649

      j++;

×

UNCOV

651

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

655

_exit:

×

UNCOV

656

  taosArrayDestroy(pTagVals);

×

UNCOV

658

  return code;

×

UNCOV

661

static void appendTableOptions(char* buf, int32_t* len, SDbCfgInfo* pDbCfg, STableCfg* pCfg) {

×

UNCOV

662

  if (pCfg->commentLen > 0) {

×

663

    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

665

  } else if (0 == pCfg->commentLen) {

×

666

    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

670

  if (NULL != pDbCfg->pRetensions && pCfg->watermark1 > 0) {

×

671

    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

673

    if (pCfg->watermark2 > 0) {

×

674

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

679

  if (NULL != pDbCfg->pRetensions && pCfg->delay1 > 0) {

×

680

    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

682

    if (pCfg->delay2 > 0) {

×

683

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

688

  int32_t funcNum = taosArrayGetSize(pCfg->pFuncs);

×

UNCOV

689

  if (NULL != pDbCfg->pRetensions && funcNum > 0) {

×

690

    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

692

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

×

693

      char* pFunc = taosArrayGet(pCfg->pFuncs, i);

×

694

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

697

    *len +=

×

698

        snprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len), ")");

×

UNCOV

701

  if (pCfg->ttl > 0) {

×

702

    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

UNCOV

706

  if (TSDB_SUPER_TABLE == pCfg->tableType || TSDB_NORMAL_TABLE == pCfg->tableType) {

×

UNCOV

707

    int32_t nSma = 0;

×

UNCOV

708

    for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {

×

UNCOV

709

      if (IS_BSMA_ON(pCfg->pSchemas + i)) {

×

UNCOV

710

        ++nSma;

×

UNCOV

714

    if (nSma < pCfg->numOfColumns && nSma > 0) {

×

715

      bool smaOn = false;

×

716

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),

×

718

      for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {

×

719

        if (IS_BSMA_ON(pCfg->pSchemas + i)) {

×

720

          if (smaOn) {

×

721

            *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len,

×

722

                              SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len), ",`%s`",

×

723

                              (pCfg->pSchemas + i)->name);

×

725

            smaOn = true;

×

726

            *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len,

×

727

                              SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len), "`%s`",

×

728

                              (pCfg->pSchemas + i)->name);

×

732

      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE, ")");

×

UNCOV

735

×

UNCOV

737

static int32_t setCreateTBResultIntoDataBlock(SSDataBlock* pBlock, SDbCfgInfo* pDbCfg, char* tbName, STableCfg* pCfg,

×

UNCOV

739

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

740

  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));

×

UNCOV

741

  pBlock->info.rows = 1;

×

UNCOV

743

  SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);

×

UNCOV

744

  char             buf1[SHOW_CREATE_TB_RESULT_FIELD1_LEN] = {0};

×

UNCOV

745

  STR_TO_VARSTR(buf1, tbName);

×

UNCOV

746

  QRY_ERR_RET(colDataSetVal(pCol1, 0, buf1, false));

×

UNCOV

748

  SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);

×

UNCOV

749

  char*            buf2 = taosMemoryMalloc(SHOW_CREATE_TB_RESULT_FIELD2_LEN);

×

UNCOV

750

  if (NULL == buf2) {

×

751

    QRY_ERR_RET(terrno);

×

UNCOV

754

  int32_t len = 0;

×

UNCOV

756

  if (TSDB_SUPER_TABLE == pCfg->tableType) {

×

UNCOV

757

    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_TB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,

×

UNCOV

759

    appendColumnFields(buf2, &len, pCfg);

×

UNCOV

760

    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len),

×

UNCOV

762

    appendTagFields(buf2, &len, pCfg);

×

UNCOV

763

    len +=

×

UNCOV

764

        snprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len), ")");

×

UNCOV

765

    appendTableOptions(buf2, &len, pDbCfg, pCfg);

×

UNCOV

766

  } else if (TSDB_CHILD_TABLE == pCfg->tableType) {

×

UNCOV

767

    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_TB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,

×

UNCOV

768

                     "CREATE TABLE `%s` USING `%s` (", tbName, pCfg->stbName);

×

UNCOV

769

    appendTagNameFields(buf2, &len, pCfg);

×

UNCOV

770

    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len),

×

UNCOV

772

    code = appendTagValues(buf2, &len, pCfg, charsetCxt);

×

UNCOV

773

    TAOS_CHECK_ERRNO(code);

×

UNCOV

774

    len +=

×

UNCOV

775

        snprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len), ")");

×

UNCOV

776

    appendTableOptions(buf2, &len, pDbCfg, pCfg);

×

UNCOV

778

    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_TB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,

×

UNCOV

780

    appendColumnFields(buf2, &len, pCfg);

×

UNCOV

781

    len +=

×

UNCOV

782

        snprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len), ")");

×

UNCOV

783

    appendTableOptions(buf2, &len, pDbCfg, pCfg);

×

UNCOV

786

  varDataLen(buf2) = (len > 65535) ? 65535 : len;

×

UNCOV

788

  code = colDataSetVal(pCol2, 0, buf2, false);

×

UNCOV

789

  TAOS_CHECK_ERRNO(code);

×

UNCOV

791

_exit:

×

UNCOV

792

  taosMemoryFree(buf2);

×

UNCOV

794

  return code;

×

UNCOV

797

static int32_t setCreateViewResultIntoDataBlock(SSDataBlock* pBlock, SShowCreateViewStmt* pStmt) {

×

UNCOV

798

  int32_t code = 0;

×

UNCOV

799

  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));

×

UNCOV

800

  pBlock->info.rows = 1;

×

UNCOV

802

  SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);

×

UNCOV

803

  char             buf1[SHOW_CREATE_VIEW_RESULT_FIELD1_LEN + 1] = {0};

×

UNCOV

804

  snprintf(varDataVal(buf1), TSDB_VIEW_FNAME_LEN + 4, "`%s`.`%s`", pStmt->dbName, pStmt->viewName);

×

UNCOV

805

  varDataSetLen(buf1, strlen(varDataVal(buf1)));

×

UNCOV

806

  QRY_ERR_RET(colDataSetVal(pCol1, 0, buf1, false));

×

UNCOV

808

  SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);

×

UNCOV

809

  char*            buf2 = taosMemoryMalloc(SHOW_CREATE_VIEW_RESULT_FIELD2_LEN);

×

UNCOV

810

  if (NULL == buf2) {

×

811

    return terrno;

×

UNCOV

814

  SViewMeta* pMeta = pStmt->pViewMeta;

×

UNCOV

815

  if (NULL == pMeta) {

×

816

    qError("exception: view meta is null");

×

817

    return TSDB_CODE_APP_ERROR;

×

UNCOV

819

  snprintf(varDataVal(buf2), SHOW_CREATE_VIEW_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE, "CREATE VIEW `%s`.`%s` AS %s",

×

UNCOV

820

           pStmt->dbName, pStmt->viewName, pMeta->querySql);

×

UNCOV

821

  int32_t len = strlen(varDataVal(buf2));

×

UNCOV

822

  varDataLen(buf2) = (len > 65535) ? 65535 : len;

×

UNCOV

823

  code = colDataSetVal(pCol2, 0, buf2, false);

×

UNCOV

824

  taosMemoryFree(buf2);

×

UNCOV

826

  return code;

×

UNCOV

829

static int32_t execShowCreateTable(SShowCreateTableStmt* pStmt, SRetrieveTableRsp** pRsp, void* charsetCxt) {

×

UNCOV

830

  SSDataBlock* pBlock = NULL;

×

UNCOV

831

  int32_t      code = buildCreateTbResultDataBlock(&pBlock);

×

UNCOV

832

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

833

    code = setCreateTBResultIntoDataBlock(pBlock, pStmt->pDbCfg, pStmt->tableName, pStmt->pTableCfg, charsetCxt);

×

UNCOV

835

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

836

    code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_TB_RESULT_COLS, pRsp);

×

UNCOV

838

  (void)blockDataDestroy(pBlock);

×

UNCOV

839

  return code;

×

UNCOV

842

static int32_t execShowCreateSTable(SShowCreateTableStmt* pStmt, SRetrieveTableRsp** pRsp, void* charsetCxt) {

×

UNCOV

843

  STableCfg* pCfg = (STableCfg*)pStmt->pTableCfg;

×

UNCOV

844

  if (TSDB_SUPER_TABLE != pCfg->tableType) {

×

UNCOV

845

    terrno = TSDB_CODE_TSC_NOT_STABLE_ERROR;

×

UNCOV

846

    return terrno;

×

UNCOV

849

  return execShowCreateTable(pStmt, pRsp, charsetCxt);

×

UNCOV

852

static int32_t execAlterCmd(char* cmd, char* value, bool* processed) {

×

UNCOV

853

  int32_t code = 0;

×

UNCOV

855

  if (0 == strcasecmp(cmd, COMMAND_RESET_LOG)) {

×

856

    taosResetLog();

×

857

    cfgDumpCfg(tsCfg, 0, false);

×

UNCOV

858

  } else if (0 == strcasecmp(cmd, COMMAND_SCHEDULE_POLICY)) {

×

UNCOV

859

    int32_t tmp = 0;

×

UNCOV

860

    code = taosStr2int32(value, &tmp);

×

UNCOV

861

    if (code) {

×

862

      qError("invalid value:%s, error:%s", value, tstrerror(code));

×

863

      return code;

×

UNCOV

865

    code = schedulerUpdatePolicy(tmp);

×

UNCOV

866

  } else if (0 == strcasecmp(cmd, COMMAND_ENABLE_RESCHEDULE)) {

×

867

    int32_t tmp = 0;

×

868

    code = taosStr2int32(value, &tmp);

×

869

    if (code) {

×

870

      qError("invalid value:%s, error:%s", value, tstrerror(code));

×

871

      return code;

×

873

    code = schedulerEnableReSchedule(tmp != 0);

×

UNCOV

874

  } else if (0 == strcasecmp(cmd, COMMAND_CATALOG_DEBUG)) {

×

875

    code = ctgdHandleDbgCommand(value);

×

UNCOV

876

  } else if (0 == strcasecmp(cmd, COMMAND_ENABLE_MEM_DEBUG)) {

×

877

    code = taosMemoryDbgInit();

×

878

    if (code) {

×

879

      qError("failed to init memory dbg, error:%s", tstrerror(code));

×

880

      return code;

×

882

    tsAsyncLog = false;

×

883

    qInfo("memory dbg enabled");

×

UNCOV

884

  } else if (0 == strcasecmp(cmd, COMMAND_DISABLE_MEM_DEBUG)) {

×

885

    code = taosMemoryDbgInitRestore();

×

886

    if (code) {

×

887

      qError("failed to restore from memory dbg, error:%s", tstrerror(code));

×

888

      return code;

×

890

    qInfo("memory dbg disabled");

×

UNCOV

892

    goto _return;

×

UNCOV

895

  *processed = true;

×

UNCOV

897

_return:

×

UNCOV

899

  if (code) {

×

900

    terrno = code;

×

UNCOV

903

  return code;

×

UNCOV

906

static int32_t execAlterLocal(SAlterLocalStmt* pStmt) {

×

UNCOV

907

  bool processed = false;

×

UNCOV

909

  if (execAlterCmd(pStmt->config, pStmt->value, &processed)) {

×

910

    return terrno;

×

UNCOV

913

  if (processed) {

×

UNCOV

914

    goto _return;

×

UNCOV

917

  if (cfgCheckRangeForDynUpdate(tsCfg, pStmt->config, pStmt->value, false, CFG_ALTER_LOCAL)) {

×

UNCOV

918

    return terrno;

×

UNCOV

921

  if (cfgSetItem(tsCfg, pStmt->config, pStmt->value, CFG_STYPE_ALTER_CLIENT_CMD, true)) {

×

922

    return terrno;

×

UNCOV

925

  TAOS_CHECK_RETURN(taosCfgDynamicOptions(tsCfg, pStmt->config, false));

×

UNCOV

927

_return:

×

UNCOV

929

  return TSDB_CODE_SUCCESS;

×

UNCOV

932

static int32_t buildLocalVariablesResultDataBlock(SSDataBlock** pOutput) {

×

UNCOV

933

  SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock));

×

UNCOV

934

  if (NULL == pBlock) {

×

935

    return terrno;

×

UNCOV

938

  pBlock->info.hasVarCol = true;

×

UNCOV

940

  pBlock->pDataBlock = taosArrayInit(SHOW_LOCAL_VARIABLES_RESULT_COLS, sizeof(SColumnInfoData));

×

UNCOV

941

  if (NULL == pBlock->pDataBlock) {

×

942

    taosMemoryFree(pBlock);

×

943

    return terrno;

×

UNCOV

946

  SColumnInfoData infoData = {0};

×

UNCOV

948

  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;

×

UNCOV

949

  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN;

×

UNCOV

950

  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {

×

951

    goto _exit;

×

UNCOV

954

  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;

×

UNCOV

955

  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN;

×

UNCOV

956

  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {

×

957

    goto _exit;

×

UNCOV

960

  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;

×

UNCOV

961

  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD3_LEN;

×

UNCOV

962

  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {

×

963

    goto _exit;

×

UNCOV

966

  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;

×

UNCOV

967

  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD4_LEN;

×

UNCOV

968

  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {

×

969

    goto _exit;

×

UNCOV

972

  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;

×

UNCOV

973

  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD5_LEN;

×

UNCOV

974

  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {

×

975

    goto _exit;

×

UNCOV

978

  *pOutput = pBlock;

×

UNCOV

980

_exit:

×

UNCOV

981

  if (terrno != TSDB_CODE_SUCCESS) {

×

982

    taosArrayDestroy(pBlock->pDataBlock);

×

983

    taosMemoryFree(pBlock);

×

UNCOV

985

  return terrno;

×

UNCOV

988

static int32_t execShowLocalVariables(SRetrieveTableRsp** pRsp) {

×

UNCOV

989

  SSDataBlock* pBlock = NULL;

×

UNCOV

990

  int32_t      code = buildLocalVariablesResultDataBlock(&pBlock);

×

UNCOV

991

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

992

    code = dumpConfToDataBlock(pBlock, 0);

×

UNCOV

994

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

995

    code = buildRetrieveTableRsp(pBlock, SHOW_LOCAL_VARIABLES_RESULT_COLS, pRsp);

×

UNCOV

997

  (void)blockDataDestroy(pBlock);

×

UNCOV

998

  return code;

×

UNCOV

1001

static int32_t createSelectResultDataBlock(SNodeList* pProjects, SSDataBlock** pOutput) {

×

UNCOV

1002

  QRY_PARAM_CHECK(pOutput);

×

UNCOV

1004

  SSDataBlock* pBlock = NULL;

×

UNCOV

1005

  int32_t      code = createDataBlock(&pBlock);

×

UNCOV

1006

  if (code) {

×

1007

    return code;

×

UNCOV

1010

  SNode* pProj = NULL;

×

UNCOV

1011

  FOREACH(pProj, pProjects) {

×

UNCOV

1012

    SExprNode*      pExpr = (SExprNode*)pProj;

×

UNCOV

1013

    SColumnInfoData infoData = {0};

×

UNCOV

1014

    if (TSDB_DATA_TYPE_NULL == pExpr->resType.type) {

×

1015

      infoData.info.type = TSDB_DATA_TYPE_VARCHAR;

×

1016

      infoData.info.bytes = 0;

×

UNCOV

1018

      infoData.info.type = pExpr->resType.type;

×

UNCOV

1019

      infoData.info.bytes = pExpr->resType.bytes;

×

UNCOV

1021

    QRY_ERR_RET(blockDataAppendColInfo(pBlock, &infoData));

×

UNCOV

1024

  *pOutput = pBlock;

×

UNCOV

1025

  return code;

×

UNCOV

1028

static int32_t buildSelectResultDataBlock(SNodeList* pProjects, SSDataBlock* pBlock) {

×

UNCOV

1029

  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));

×

UNCOV

1031

  int32_t index = 0;

×

UNCOV

1032

  SNode*  pProj = NULL;

×

UNCOV

1033

  FOREACH(pProj, pProjects) {

×

UNCOV

1034

    if (QUERY_NODE_VALUE != nodeType(pProj)) {

×

1035

      return TSDB_CODE_PAR_INVALID_SELECTED_EXPR;

×

UNCOV

1037

      if (((SValueNode*)pProj)->isNull) {

×

UNCOV

1038

        QRY_ERR_RET(colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0, NULL, true));

×

UNCOV

1040

        QRY_ERR_RET(colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0,

×

UNCOV

1046

  pBlock->info.rows = 1;

×

UNCOV

1047

  return TSDB_CODE_SUCCESS;

×

UNCOV

1050

static int32_t execSelectWithoutFrom(SSelectStmt* pSelect, SRetrieveTableRsp** pRsp) {

×

UNCOV

1051

  SSDataBlock* pBlock = NULL;

×

UNCOV

1052

  int32_t      code = createSelectResultDataBlock(pSelect->pProjectionList, &pBlock);

×

UNCOV

1053

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

1054

    code = buildSelectResultDataBlock(pSelect->pProjectionList, pBlock);

×

UNCOV

1056

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

1057

    code = buildRetrieveTableRsp(pBlock, LIST_LENGTH(pSelect->pProjectionList), pRsp);

×

UNCOV

1059

  (void)blockDataDestroy(pBlock);

×

UNCOV

1060

  return code;

×

UNCOV

1063

static int32_t execShowCreateView(SShowCreateViewStmt* pStmt, SRetrieveTableRsp** pRsp) {

×

UNCOV

1064

  SSDataBlock* pBlock = NULL;

×

UNCOV

1065

  int32_t      code = buildCreateViewResultDataBlock(&pBlock);

×

UNCOV

1066

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

1067

    code = setCreateViewResultIntoDataBlock(pBlock, pStmt);

×

UNCOV

1069

  if (TSDB_CODE_SUCCESS == code) {

×

UNCOV

1070

    code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_VIEW_RESULT_COLS, pRsp);

×

UNCOV

1072

  (void)blockDataDestroy(pBlock);

×

UNCOV

1073

  return code;

×

UNCOV

1076

int32_t qExecCommand(int64_t* pConnId, bool sysInfoUser, SNode* pStmt, SRetrieveTableRsp** pRsp, int8_t biMode,

×

UNCOV

1078

  switch (nodeType(pStmt)) {

×

UNCOV

1079

    case QUERY_NODE_DESCRIBE_STMT:

×

UNCOV

1080

      return execDescribe(sysInfoUser, pStmt, pRsp, biMode);

×

UNCOV

1081

    case QUERY_NODE_RESET_QUERY_CACHE_STMT:

×

UNCOV

1082

      return execResetQueryCache();

×

UNCOV

1083

    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:

×

UNCOV

1084

      return execShowCreateDatabase((SShowCreateDatabaseStmt*)pStmt, pRsp);

×

UNCOV

1085

    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:

×

UNCOV

1086

      return execShowCreateTable((SShowCreateTableStmt*)pStmt, pRsp, charsetCxt);

×

UNCOV

1087

    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:

×

UNCOV

1088

      return execShowCreateSTable((SShowCreateTableStmt*)pStmt, pRsp, charsetCxt);

×

UNCOV

1089

    case QUERY_NODE_SHOW_CREATE_VIEW_STMT:

×

UNCOV

1090

      return execShowCreateView((SShowCreateViewStmt*)pStmt, pRsp);

×

UNCOV

1091

    case QUERY_NODE_ALTER_LOCAL_STMT:

×

UNCOV

1092

      return execAlterLocal((SAlterLocalStmt*)pStmt);

×

UNCOV

1093

    case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:

×

UNCOV

1094

      return execShowLocalVariables(pRsp);

×

UNCOV

1095

    case QUERY_NODE_SELECT_STMT:

×

UNCOV

1096

      return execSelectWithoutFrom((SSelectStmt*)pStmt, pRsp);

×

1097

    default:

×

1098

      break;

×

1100

  return TSDB_CODE_FAILED;

×

taosdata / TDengine / #3621

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

taosdata / TDengine / #3621

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