taosdata/TDengine | Build 3798 | source/dnode/vnode/src/meta/metaEntry.c | Coveralls

18

static bool schemasHasTypeMod(const SSchema *pSchema, int32_t nCols) {

×

19

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

×

20

    if (HAS_TYPE_MOD(pSchema + i)) {

×

21

      return true;

×

24

  return false;

×

27

static int32_t metaEncodeExtSchema(SEncoder* pCoder, const SMetaEntry* pME) {

×

28

  if (pME->pExtSchemas) {

×

29

    const SSchemaWrapper *pSchWrapper = NULL;

×

30

    bool                  hasTypeMods = false;

×

31

    if (pME->type == TSDB_SUPER_TABLE) {

×

32

      pSchWrapper = &pME->stbEntry.schemaRow;

×

33

    } else if (pME->type == TSDB_NORMAL_TABLE) {

×

34

      pSchWrapper = &pME->ntbEntry.schemaRow;

×

36

      return 0;

×

38

    hasTypeMods = schemasHasTypeMod(pSchWrapper->pSchema, pSchWrapper->nCols);

×

40

    for (int32_t i = 0; i < pSchWrapper->nCols && hasTypeMods; ++i) {

×

41

      TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->pExtSchemas[i].typeMod));

×

44

  return 0;

×

47

int meteEncodeColRefEntry(SEncoder *pCoder, const SMetaEntry *pME) {

×

48

  const SColRefWrapper *pw = &pME->colRef;

×

49

  TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->nCols));

×

50

  TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->version));

×

51

  uTrace("encode cols:%d", pw->nCols);

×

53

  for (int32_t i = 0; i < pw->nCols; i++) {

×

54

    SColRef *p = &pw->pColRef[i];

×

55

    TAOS_CHECK_RETURN(tEncodeI8(pCoder, p->hasRef));

×

56

    TAOS_CHECK_RETURN(tEncodeI16v(pCoder, p->id));

×

57

    if (p->hasRef) {

×

58

      TAOS_CHECK_RETURN(tEncodeCStr(pCoder, p->refDbName));

×

59

      TAOS_CHECK_RETURN(tEncodeCStr(pCoder, p->refTableName));

×

60

      TAOS_CHECK_RETURN(tEncodeCStr(pCoder, p->refColName));

×

63

  return 0;

×

66

static int32_t metaDecodeExtSchemas(SDecoder* pDecoder, SMetaEntry* pME) {

×

67

  bool hasExtSchema = false;

×

68

  SSchemaWrapper* pSchWrapper = NULL;

×

69

  if (pME->type == TSDB_SUPER_TABLE) {

×

70

    pSchWrapper = &pME->stbEntry.schemaRow;

×

71

  } else if (pME->type == TSDB_NORMAL_TABLE) {

×

72

    pSchWrapper = &pME->ntbEntry.schemaRow;

×

74

    return 0;

×

77

  hasExtSchema = schemasHasTypeMod(pSchWrapper->pSchema, pSchWrapper->nCols);

×

78

  if (hasExtSchema && pSchWrapper->nCols > 0) {

×

79

    pME->pExtSchemas = (SExtSchema*)tDecoderMalloc(pDecoder, sizeof(SExtSchema) * pSchWrapper->nCols);

×

80

    if (pME->pExtSchemas == NULL) {

×

81

      return terrno;

×

84

    for (int32_t i = 0; i < pSchWrapper->nCols && hasExtSchema; i++) {

×

85

      TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pME->pExtSchemas[i].typeMod));

×

89

  return 0;

×

92

SExtSchema* metaGetSExtSchema(const SMetaEntry *pME) {

×

93

  const SSchemaWrapper *pSchWrapper = NULL;

×

94

  bool                  hasTypeMods = false;

×

95

  if (pME->type == TSDB_SUPER_TABLE) {

×

96

    pSchWrapper = &pME->stbEntry.schemaRow;

×

97

  } else if (pME->type == TSDB_NORMAL_TABLE) {

×

98

    pSchWrapper = &pME->ntbEntry.schemaRow;

×

100

    return NULL;

×

102

  hasTypeMods = schemasHasTypeMod(pSchWrapper->pSchema, pSchWrapper->nCols);

×

104

  if (hasTypeMods) {

×

105

    SExtSchema *ret = taosMemoryMalloc(sizeof(SExtSchema) * pSchWrapper->nCols);

×

106

    if (ret != NULL) {

×

107

      memcpy(ret, pME->pExtSchemas, pSchWrapper->nCols * sizeof(SExtSchema));

×

109

    return ret;

×

111

  return NULL;

×

114

int meteDecodeColRefEntry(SDecoder *pDecoder, SMetaEntry *pME) {

×

115

  SColRefWrapper *pWrapper = &pME->colRef;

×

116

  TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->nCols));

×

117

  if (pWrapper->nCols == 0) {

×

118

    return 0;

×

121

  TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->version));

×

122

  uDebug("decode cols:%d", pWrapper->nCols);

×

123

  pWrapper->pColRef = (SColRef *)tDecoderMalloc(pDecoder, pWrapper->nCols * sizeof(SColRef));

×

124

  if (pWrapper->pColRef == NULL) {

×

125

    return terrno;

×

128

  for (int i = 0; i < pWrapper->nCols; i++) {

×

129

    SColRef *p = &pWrapper->pColRef[i];

×

130

    TAOS_CHECK_RETURN(tDecodeI8(pDecoder, (int8_t *)&p->hasRef));

×

131

    TAOS_CHECK_RETURN(tDecodeI16v(pDecoder, &p->id));

×

132

    if (p->hasRef) {

×

133

      TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, p->refDbName));

×

134

      TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, p->refTableName));

×

135

      TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, p->refColName));

×

138

  return 0;

×

143

  pRef->nCols = pSchema->nCols;

×

144

  if ((pRef->pColRef = (SColRef *)tDecoderMalloc(pDecoder, pRef->nCols * sizeof(SColRef))) == NULL) {

×

145

    return terrno;

×

148

  for (int32_t i = 0; i < pRef->nCols; i++) {

×

149

    SColRef  *pColRef = &pRef->pColRef[i];

×

150

    SSchema  *pColSchema = &pSchema->pSchema[i];

×

151

    pColRef->id = pColSchema->colId;

×

152

    pColRef->hasRef = false;

×

154

  return 0;

×

157

static int32_t metaCloneColRef(const SColRefWrapper*pSrc, SColRefWrapper *pDst) {

×

158

  if (pSrc->nCols > 0) {

×

159

    pDst->nCols = pSrc->nCols;

×

160

    pDst->version = pSrc->version;

×

161

    pDst->pColRef = (SColRef*)taosMemoryCalloc(pSrc->nCols, sizeof(SColRef));

×

162

    if (NULL == pDst->pColRef) {

×

163

      return terrno;

×

165

    memcpy(pDst->pColRef, pSrc->pColRef, pSrc->nCols * sizeof(SColRef));

×

167

  return 0;

×

170

int meteEncodeColCmprEntry(SEncoder *pCoder, const SMetaEntry *pME) {

×

171

  const SColCmprWrapper *pw = &pME->colCmpr;

×

172

  TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->nCols));

×

173

  TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->version));

×

174

  uTrace("encode cols:%d", pw->nCols);

×

176

  for (int32_t i = 0; i < pw->nCols; i++) {

×

177

    SColCmpr *p = &pw->pColCmpr[i];

×

178

    TAOS_CHECK_RETURN(tEncodeI16v(pCoder, p->id));

×

179

    TAOS_CHECK_RETURN(tEncodeU32(pCoder, p->alg));

×

181

  return 0;

×

183

int meteDecodeColCmprEntry(SDecoder *pDecoder, SMetaEntry *pME) {

×

184

  SColCmprWrapper *pWrapper = &pME->colCmpr;

×

185

  TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->nCols));

×

186

  if (pWrapper->nCols == 0) {

×

187

    return 0;

×

190

  TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->version));

×

191

  uDebug("dencode cols:%d", pWrapper->nCols);

×

192

  pWrapper->pColCmpr = (SColCmpr *)tDecoderMalloc(pDecoder, pWrapper->nCols * sizeof(SColCmpr));

×

193

  if (pWrapper->pColCmpr == NULL) {

×

194

    return terrno;

×

197

  for (int i = 0; i < pWrapper->nCols; i++) {

×

198

    SColCmpr *p = &pWrapper->pColCmpr[i];

×

199

    TAOS_CHECK_RETURN(tDecodeI16v(pDecoder, &p->id));

×

200

    TAOS_CHECK_RETURN(tDecodeU32(pDecoder, &p->alg));

×

202

  return 0;

×

206

  pCmpr->nCols = pSchema->nCols;

×

207

  if ((pCmpr->pColCmpr = (SColCmpr *)tDecoderMalloc(pDecoder, pCmpr->nCols * sizeof(SColCmpr))) == NULL) {

×

208

    return terrno;

×

211

  for (int32_t i = 0; i < pCmpr->nCols; i++) {

×

212

    SColCmpr *pColCmpr = &pCmpr->pColCmpr[i];

×

213

    SSchema  *pColSchema = &pSchema->pSchema[i];

×

214

    pColCmpr->id = pColSchema->colId;

×

215

    pColCmpr->alg = createDefaultColCmprByType(pColSchema->type);

×

217

  return 0;

×

220

static int32_t metaCloneColCmpr(const SColCmprWrapper *pSrc, SColCmprWrapper *pDst) {

×

221

  if (pSrc->nCols > 0) {

×

222

    pDst->nCols = pSrc->nCols;

×

223

    pDst->version = pSrc->version;

×

224

    pDst->pColCmpr = (SColCmpr *)taosMemoryCalloc(pSrc->nCols, sizeof(SColCmpr));

×

225

    if (NULL == pDst->pColCmpr) {

×

226

      return terrno;

×

228

    memcpy(pDst->pColCmpr, pSrc->pColCmpr, pSrc->nCols * sizeof(SColCmpr));

×

230

  return 0;

×

233

static void metaCloneColRefFree(SColRefWrapper *pColRef) {

×

234

  if (pColRef) {

×

235

    taosMemoryFreeClear(pColRef->pColRef);

×

237

×

239

static void metaCloneColCmprFree(SColCmprWrapper *pCmpr) {

×

240

  if (pCmpr) {

×

241

    taosMemoryFreeClear(pCmpr->pColCmpr);

×

243

×

245

int metaEncodeEntry(SEncoder *pCoder, const SMetaEntry *pME) {

×

246

  TAOS_CHECK_RETURN(tStartEncode(pCoder));

×

247

  TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->version));

×

248

  TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->type));

×

249

  TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->uid));

×

251

  if (pME->type > 0) {

×

252

    if (pME->name == NULL) {

×

253

      return TSDB_CODE_INVALID_PARA;

×

256

    TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->name));

×

258

    if (pME->type == TSDB_SUPER_TABLE) {

×

259

      TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->flags));

×

260

      TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaRow));

×

261

      TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag));

×

262

      if (TABLE_IS_ROLLUP(pME->flags)) {

×

263

        TAOS_CHECK_RETURN(tEncodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam));

×

265

    } else if (pME->type == TSDB_CHILD_TABLE || pME->type == TSDB_VIRTUAL_CHILD_TABLE) {

×

266

      TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.btime));

×

267

      TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ctbEntry.ttlDays));

×

268

      TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ctbEntry.commentLen));

×

269

      if (pME->ctbEntry.commentLen > 0) {

×

270

        TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ctbEntry.comment));

×

272

      TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.suid));

×

273

      TAOS_CHECK_RETURN(tEncodeTag(pCoder, (const STag *)pME->ctbEntry.pTags));

×

274

    } else if (pME->type == TSDB_NORMAL_TABLE || pME->type == TSDB_VIRTUAL_NORMAL_TABLE) {

×

275

      TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ntbEntry.btime));

×

276

      TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ntbEntry.ttlDays));

×

277

      TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.commentLen));

×

278

      if (pME->ntbEntry.commentLen > 0) {

×

279

        TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ntbEntry.comment));

×

281

      TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.ncid));

×

282

      TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->ntbEntry.schemaRow));

×

283

    } else if (pME->type == TSDB_TSMA_TABLE) {

×

284

      TAOS_CHECK_RETURN(tEncodeTSma(pCoder, pME->smaEntry.tsma));

×

286

      metaError("meta/entry: invalide table type: %" PRId8 " encode failed.", pME->type);

×

287

      return TSDB_CODE_INVALID_PARA;

×

289

    if (pME->type == TSDB_VIRTUAL_NORMAL_TABLE || pME->type == TSDB_VIRTUAL_CHILD_TABLE) {

×

290

      TAOS_CHECK_RETURN(meteEncodeColRefEntry(pCoder, pME));

×

292

      TAOS_CHECK_RETURN(meteEncodeColCmprEntry(pCoder, pME));

×

294

    TAOS_CHECK_RETURN(metaEncodeExtSchema(pCoder, pME));

×

296

  if (pME->type == TSDB_SUPER_TABLE) {

×

297

    TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->stbEntry.keep));

×

300

  tEndEncode(pCoder);

×

301

  return 0;

×

304

int metaDecodeEntryImpl(SDecoder *pCoder, SMetaEntry *pME, bool headerOnly) {

×

305

  TAOS_CHECK_RETURN(tStartDecode(pCoder));

×

306

  TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->version));

×

307

  TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->type));

×

308

  TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->uid));

×

310

  if (headerOnly) {

×

311

    tEndDecode(pCoder);

×

312

    return 0;

×

315

  if (pME->type > 0) {

×

316

    TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->name));

×

318

    if (pME->type == TSDB_SUPER_TABLE) {

×

319

      TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->flags));

×

320

      TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaRow));

×

321

      TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaTag));

×

322

      if (TABLE_IS_ROLLUP(pME->flags)) {

×

323

        TAOS_CHECK_RETURN(tDecodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam));

×

325

    } else if (pME->type == TSDB_CHILD_TABLE || pME->type == TSDB_VIRTUAL_CHILD_TABLE) {

×

326

      TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.btime));

×

327

      TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ctbEntry.ttlDays));

×

328

      TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ctbEntry.commentLen));

×

329

      if (pME->ctbEntry.commentLen > 0) {

×

330

        TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ctbEntry.comment));

×

332

      TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.suid));

×

333

      TAOS_CHECK_RETURN(tDecodeTag(pCoder, (STag **)&pME->ctbEntry.pTags));

×

334

    } else if (pME->type == TSDB_NORMAL_TABLE || pME->type == TSDB_VIRTUAL_NORMAL_TABLE) {

×

335

      TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ntbEntry.btime));

×

336

      TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ntbEntry.ttlDays));

×

337

      TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.commentLen));

×

338

      if (pME->ntbEntry.commentLen > 0) {

×

339

        TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ntbEntry.comment));

×

341

      TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.ncid));

×

342

      TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->ntbEntry.schemaRow));

×

343

    } else if (pME->type == TSDB_TSMA_TABLE) {

×

344

      pME->smaEntry.tsma = tDecoderMalloc(pCoder, sizeof(STSma));

×

345

      if (!pME->smaEntry.tsma) {

×

346

        return terrno;

×

348

      TAOS_CHECK_RETURN(tDecodeTSma(pCoder, pME->smaEntry.tsma, true));

×

350

      metaError("meta/entry: invalide table type: %" PRId8 " decode failed.", pME->type);

×

351

      return TSDB_CODE_INVALID_PARA;

×

353

    if (pME->type == TSDB_SUPER_TABLE) {

×

354

      if (TABLE_IS_COL_COMPRESSED(pME->flags)) {

×

355

        TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME));

×

357

        if (pME->colCmpr.nCols == 0) {

×

358

          TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow));

×

361

        TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow));

×

362

        TABLE_SET_COL_COMPRESSED(pME->flags);

×

364

    } else if (pME->type == TSDB_NORMAL_TABLE) {

×

365

      if (!tDecodeIsEnd(pCoder)) {

×

366

        uDebug("set type: %d, tableName:%s", pME->type, pME->name);

×

367

        TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME));

×

368

        if (pME->colCmpr.nCols == 0) {

×

369

          TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow));

×

372

        uDebug("set default type: %d, tableName:%s", pME->type, pME->name);

×

373

        TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow));

×

375

      TABLE_SET_COL_COMPRESSED(pME->flags);

×

376

    } else if (pME->type == TSDB_VIRTUAL_NORMAL_TABLE || pME->type == TSDB_VIRTUAL_CHILD_TABLE) {

×

377

      if (!tDecodeIsEnd(pCoder)) {

×

378

        uDebug("set type: %d, tableName:%s", pME->type, pME->name);

×

379

        TAOS_CHECK_RETURN(meteDecodeColRefEntry(pCoder, pME));

×

381

        uDebug("set default type: %d, tableName:%s", pME->type, pME->name);

×

382

        if (pME->type == TSDB_VIRTUAL_NORMAL_TABLE) {

×

383

           TAOS_CHECK_RETURN(metatInitDefaultSColRefWrapper(pCoder, &pME->colRef, &pME->ntbEntry.schemaRow));

×

387

    if (!tDecodeIsEnd(pCoder)) {

×

388

      TAOS_CHECK_RETURN(metaDecodeExtSchemas(pCoder, pME));

×

391

  if (pME->type == TSDB_SUPER_TABLE) {

×

392

    if (!tDecodeIsEnd(pCoder)) {

×

393

      TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->stbEntry.keep));

×

398

  tEndDecode(pCoder);

×

399

  return 0;

×

402

int metaDecodeEntry(SDecoder *pCoder, SMetaEntry *pME) { return metaDecodeEntryImpl(pCoder, pME, false); }

×

404

static int32_t metaCloneSchema(const SSchemaWrapper *pSrc, SSchemaWrapper *pDst) {

×

405

  if (pSrc == NULL || pDst == NULL) {

×

406

    return TSDB_CODE_INVALID_PARA;

×

409

  pDst->nCols = pSrc->nCols;

×

410

  pDst->version = pSrc->version;

×

411

  pDst->pSchema = (SSchema *)taosMemoryMalloc(pSrc->nCols * sizeof(SSchema));

×

412

  if (pDst->pSchema == NULL) {

×

413

    return terrno;

×

415

  memcpy(pDst->pSchema, pSrc->pSchema, pSrc->nCols * sizeof(SSchema));

×

416

  return TSDB_CODE_SUCCESS;

×

419

static void metaCloneSchemaFree(SSchemaWrapper *pSchema) {

×

420

  if (pSchema) {

×

421

    taosMemoryFreeClear(pSchema->pSchema);

×

423

×

425

void metaCloneEntryFree(SMetaEntry **ppEntry) {

×

426

  if (ppEntry == NULL || *ppEntry == NULL) {

×

427

    return;

×

430

  taosMemoryFreeClear((*ppEntry)->name);

×

432

  if ((*ppEntry)->type < 0) {

×

433

    taosMemoryFreeClear(*ppEntry);

×

434

    return;

×

437

  if (TSDB_SUPER_TABLE == (*ppEntry)->type) {

×

438

    metaCloneSchemaFree(&(*ppEntry)->stbEntry.schemaRow);

×

439

    metaCloneSchemaFree(&(*ppEntry)->stbEntry.schemaTag);

×

440

  } else if (TSDB_CHILD_TABLE == (*ppEntry)->type || TSDB_VIRTUAL_CHILD_TABLE == (*ppEntry)->type) {

×

441

    taosMemoryFreeClear((*ppEntry)->ctbEntry.comment);

×

442

    taosMemoryFreeClear((*ppEntry)->ctbEntry.pTags);

×

443

  } else if (TSDB_NORMAL_TABLE == (*ppEntry)->type || TSDB_VIRTUAL_NORMAL_TABLE == (*ppEntry)->type) {

×

444

    metaCloneSchemaFree(&(*ppEntry)->ntbEntry.schemaRow);

×

445

    taosMemoryFreeClear((*ppEntry)->ntbEntry.comment);

×

447

    return;

×

449

  metaCloneColCmprFree(&(*ppEntry)->colCmpr);

×

450

  taosMemoryFreeClear((*ppEntry)->pExtSchemas);

×

451

  metaCloneColRefFree(&(*ppEntry)->colRef);

×

453

  taosMemoryFreeClear(*ppEntry);

×

454

  return;

×

457

int32_t metaCloneEntry(const SMetaEntry *pEntry, SMetaEntry **ppEntry) {

×

458

  int32_t code = TSDB_CODE_SUCCESS;

×

460

  if (NULL == pEntry || NULL == ppEntry) {

×

461

    return TSDB_CODE_INVALID_PARA;

×

464

  *ppEntry = (SMetaEntry *)taosMemoryCalloc(1, sizeof(SMetaEntry));

×

465

  if (NULL == *ppEntry) {

×

466

    return terrno;

×

469

  (*ppEntry)->version = pEntry->version;

×

470

  (*ppEntry)->type = pEntry->type;

×

471

  (*ppEntry)->uid = pEntry->uid;

×

473

  if (pEntry->type < 0) {

×

474

    return TSDB_CODE_SUCCESS;

×

477

  if (pEntry->name) {

×

478

    (*ppEntry)->name = tstrdup(pEntry->name);

×

479

    if (NULL == (*ppEntry)->name) {

×

480

      code = terrno;

×

481

      metaCloneEntryFree(ppEntry);

×

482

      return code;

×

486

  if (pEntry->type == TSDB_SUPER_TABLE) {

×

487

    (*ppEntry)->flags = pEntry->flags;

×

489

    code = metaCloneSchema(&pEntry->stbEntry.schemaRow, &(*ppEntry)->stbEntry.schemaRow);

×

490

    if (code) {

×

491

      metaCloneEntryFree(ppEntry);

×

492

      return code;

×

495

    code = metaCloneSchema(&pEntry->stbEntry.schemaTag, &(*ppEntry)->stbEntry.schemaTag);

×

496

    if (code) {

×

497

      metaCloneEntryFree(ppEntry);

×

498

      return code;

×

500

    (*ppEntry)->stbEntry.keep = pEntry->stbEntry.keep;

×

501

  } else if (pEntry->type == TSDB_CHILD_TABLE || pEntry->type == TSDB_VIRTUAL_CHILD_TABLE) {

×

502

    (*ppEntry)->ctbEntry.btime = pEntry->ctbEntry.btime;

×

503

    (*ppEntry)->ctbEntry.ttlDays = pEntry->ctbEntry.ttlDays;

×

504

    (*ppEntry)->ctbEntry.suid = pEntry->ctbEntry.suid;

×

507

    (*ppEntry)->ctbEntry.commentLen = pEntry->ctbEntry.commentLen;

×

508

    if (pEntry->ctbEntry.commentLen > 0) {

×

509

      (*ppEntry)->ctbEntry.comment = taosMemoryMalloc(pEntry->ctbEntry.commentLen + 1);

×

510

      if (NULL == (*ppEntry)->ctbEntry.comment) {

×

511

        code = terrno;

×

512

        metaCloneEntryFree(ppEntry);

×

513

        return code;

×

515

      memcpy((*ppEntry)->ctbEntry.comment, pEntry->ctbEntry.comment, pEntry->ctbEntry.commentLen + 1);

×

519

    STag *pTags = (STag *)pEntry->ctbEntry.pTags;

×

520

    (*ppEntry)->ctbEntry.pTags = taosMemoryCalloc(1, pTags->len);

×

521

    if (NULL == (*ppEntry)->ctbEntry.pTags) {

×

522

      code = terrno;

×

523

      metaCloneEntryFree(ppEntry);

×

524

      return code;

×

526

    memcpy((*ppEntry)->ctbEntry.pTags, pEntry->ctbEntry.pTags, pTags->len);

×

527

  } else if (pEntry->type == TSDB_NORMAL_TABLE || pEntry->type == TSDB_VIRTUAL_NORMAL_TABLE) {

×

528

    (*ppEntry)->ntbEntry.btime = pEntry->ntbEntry.btime;

×

529

    (*ppEntry)->ntbEntry.ttlDays = pEntry->ntbEntry.ttlDays;

×

530

    (*ppEntry)->ntbEntry.ncid = pEntry->ntbEntry.ncid;

×

533

    code = metaCloneSchema(&pEntry->ntbEntry.schemaRow, &(*ppEntry)->ntbEntry.schemaRow);

×

534

    if (code) {

×

535

      metaCloneEntryFree(ppEntry);

×

536

      return code;

×

540

    (*ppEntry)->ntbEntry.commentLen = pEntry->ntbEntry.commentLen;

×

541

    if (pEntry->ntbEntry.commentLen > 0) {

×

542

      (*ppEntry)->ntbEntry.comment = taosMemoryMalloc(pEntry->ntbEntry.commentLen + 1);

×

543

      if (NULL == (*ppEntry)->ntbEntry.comment) {

×

544

        code = terrno;

×

545

        metaCloneEntryFree(ppEntry);

×

546

        return code;

×

548

      memcpy((*ppEntry)->ntbEntry.comment, pEntry->ntbEntry.comment, pEntry->ntbEntry.commentLen + 1);

×

551

    return TSDB_CODE_INVALID_PARA;

×

554

  if (pEntry->type == TSDB_VIRTUAL_NORMAL_TABLE || pEntry->type == TSDB_VIRTUAL_CHILD_TABLE) {

×

555

    code = metaCloneColRef(&pEntry->colRef, &(*ppEntry)->colRef);

×

556

    if (code) {

×

557

      metaCloneEntryFree(ppEntry);

×

558

      return code;

×

561

    code = metaCloneColCmpr(&pEntry->colCmpr, &(*ppEntry)->colCmpr);

×

562

    if (code) {

×

563

      metaCloneEntryFree(ppEntry);

×

564

      return code;

×

567

  if (pEntry->pExtSchemas && pEntry->colCmpr.nCols > 0) {

×

568

    (*ppEntry)->pExtSchemas = taosMemoryCalloc(pEntry->colCmpr.nCols, sizeof(SExtSchema));

×

569

    if (!(*ppEntry)->pExtSchemas) {

×

570

      code = terrno;

×

571

      metaCloneEntryFree(ppEntry);

×

572

      return code;

×

574

    memcpy((*ppEntry)->pExtSchemas, pEntry->pExtSchemas, sizeof(SExtSchema) * pEntry->colCmpr.nCols);

×

577

  return code;

×

taosdata / TDengine / #3798

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

taosdata / TDengine / #3798

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