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

UNCOV

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

×

UNCOV

19

  const SColCmprWrapper *pw = &pME->colCmpr;

×

UNCOV

20

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

×

UNCOV

21

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

×

UNCOV

22

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

×

UNCOV

24

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

×

UNCOV

25

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

×

UNCOV

26

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

×

UNCOV

27

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

×

UNCOV

29

  return 0;

×

UNCOV

31

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

×

UNCOV

32

  SColCmprWrapper *pWrapper = &pME->colCmpr;

×

UNCOV

33

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

×

UNCOV

34

  if (pWrapper->nCols == 0) {

×

35

    return 0;

×

UNCOV

38

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

×

UNCOV

39

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

×

UNCOV

40

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

×

UNCOV

41

  if (pWrapper->pColCmpr == NULL) {

×

42

    return terrno;

×

UNCOV

45

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

×

UNCOV

46

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

×

UNCOV

47

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

×

UNCOV

48

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

×

UNCOV

50

  return 0;

×

54

  pCmpr->nCols = pSchema->nCols;

×

UNCOV

55

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

×

56

    return terrno;

×

UNCOV

59

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

×

UNCOV

60

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

×

UNCOV

61

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

×

UNCOV

62

    pColCmpr->id = pColSchema->colId;

×

UNCOV

63

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

×

UNCOV

65

  return 0;

×

UNCOV

68

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

×

UNCOV

69

  if (pSrc->nCols > 0) {

×

UNCOV

70

    pDst->nCols = pSrc->nCols;

×

UNCOV

71

    pDst->version = pSrc->version;

×

UNCOV

72

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

×

UNCOV

73

    if (NULL == pDst->pColCmpr) {

×

74

      return terrno;

×

UNCOV

76

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

×

UNCOV

78

  return 0;

×

UNCOV

81

static void metaCloneColCmprFree(SColCmprWrapper *pCmpr) {

×

UNCOV

82

  if (pCmpr) {

×

UNCOV

83

    taosMemoryFreeClear(pCmpr->pColCmpr);

×

UNCOV

85

×

UNCOV

87

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

×

UNCOV

88

  TAOS_CHECK_RETURN(tStartEncode(pCoder));

×

UNCOV

89

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

×

UNCOV

90

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

×

UNCOV

91

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

×

UNCOV

93

  if (pME->type > 0) {

×

UNCOV

94

    if (pME->name == NULL) {

×

95

      return TSDB_CODE_INVALID_PARA;

×

UNCOV

98

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

×

UNCOV

100

    if (pME->type == TSDB_SUPER_TABLE) {

×

UNCOV

101

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

×

UNCOV

102

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

×

UNCOV

103

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

×

UNCOV

104

      if (TABLE_IS_ROLLUP(pME->flags)) {

×

UNCOV

105

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

×

UNCOV

107

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

×

UNCOV

108

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

×

UNCOV

109

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

×

UNCOV

110

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

×

UNCOV

111

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

×

UNCOV

112

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

×

UNCOV

114

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

×

UNCOV

115

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

×

UNCOV

116

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

×

UNCOV

117

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

×

UNCOV

118

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

×

UNCOV

119

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

×

UNCOV

120

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

×

UNCOV

121

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

×

UNCOV

123

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

×

UNCOV

124

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

×

UNCOV

125

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

×

UNCOV

126

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

×

UNCOV

128

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

×

129

      return TSDB_CODE_INVALID_PARA;

×

UNCOV

131

    TAOS_CHECK_RETURN(meteEncodeColCmprEntry(pCoder, pME));

×

UNCOV

134

  tEndEncode(pCoder);

×

UNCOV

135

  return 0;

×

UNCOV

138

int metaDecodeEntry(SDecoder *pCoder, SMetaEntry *pME) {

×

UNCOV

139

  TAOS_CHECK_RETURN(tStartDecode(pCoder));

×

UNCOV

140

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

×

UNCOV

141

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

×

UNCOV

142

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

×

UNCOV

144

  if (pME->type > 0) {

×

UNCOV

145

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

×

UNCOV

147

    if (pME->type == TSDB_SUPER_TABLE) {

×

UNCOV

148

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

×

UNCOV

149

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

×

UNCOV

150

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

×

UNCOV

151

      if (TABLE_IS_ROLLUP(pME->flags)) {

×

UNCOV

152

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

×

UNCOV

154

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

×

UNCOV

155

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

×

UNCOV

156

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

×

UNCOV

157

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

×

UNCOV

158

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

×

UNCOV

159

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

×

UNCOV

161

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

×

UNCOV

162

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

×

UNCOV

163

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

×

UNCOV

164

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

×

UNCOV

165

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

×

UNCOV

166

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

×

UNCOV

167

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

×

UNCOV

168

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

×

UNCOV

170

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

×

UNCOV

171

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

×

172

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

×

UNCOV

173

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

×

UNCOV

174

      if (!pME->smaEntry.tsma) {

×

175

        return terrno;

×

UNCOV

177

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

×

179

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

×

180

      return TSDB_CODE_INVALID_PARA;

×

UNCOV

182

    if (pME->type == TSDB_SUPER_TABLE) {

×

UNCOV

183

      if (TABLE_IS_COL_COMPRESSED(pME->flags)) {

×

UNCOV

184

        TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME));

×

UNCOV

186

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

×

187

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

×

190

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

×

UNCOV

191

        TABLE_SET_COL_COMPRESSED(pME->flags);

×

UNCOV

193

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

×

UNCOV

194

      if (!tDecodeIsEnd(pCoder)) {

×

UNCOV

195

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

×

UNCOV

196

        TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME));

×

UNCOV

197

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

×

198

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

×

201

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

×

202

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

×

UNCOV

204

      TABLE_SET_COL_COMPRESSED(pME->flags);

×

UNCOV

208

  tEndDecode(pCoder);

×

UNCOV

209

  return 0;

×

UNCOV

212

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

×

UNCOV

213

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

×

214

    return TSDB_CODE_INVALID_PARA;

×

UNCOV

217

  pDst->nCols = pSrc->nCols;

×

UNCOV

218

  pDst->version = pSrc->version;

×

UNCOV

219

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

×

UNCOV

220

  if (pDst->pSchema == NULL) {

×

221

    return terrno;

×

UNCOV

223

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

×

UNCOV

224

  return TSDB_CODE_SUCCESS;

×

UNCOV

227

static void metaCloneSchemaFree(SSchemaWrapper *pSchema) {

×

UNCOV

228

  if (pSchema) {

×

UNCOV

229

    taosMemoryFreeClear(pSchema->pSchema);

×

UNCOV

231

×

UNCOV

233

void metaCloneEntryFree(SMetaEntry **ppEntry) {

×

UNCOV

234

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

×

235

    return;

×

UNCOV

238

  taosMemoryFreeClear((*ppEntry)->name);

×

UNCOV

240

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

×

241

    taosMemoryFreeClear(*ppEntry);

×

242

    return;

×

UNCOV

245

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

×

UNCOV

246

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

×

UNCOV

247

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

×

UNCOV

248

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

×

UNCOV

249

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

×

UNCOV

250

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

×

UNCOV

251

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

×

UNCOV

252

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

×

UNCOV

253

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

×

UNCOV

255

    return;

×

UNCOV

257

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

×

UNCOV

259

  taosMemoryFreeClear(*ppEntry);

×

UNCOV

260

  return;

×

UNCOV

263

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

×

UNCOV

264

  int32_t code = TSDB_CODE_SUCCESS;

×

UNCOV

266

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

×

267

    return TSDB_CODE_INVALID_PARA;

×

UNCOV

270

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

×

UNCOV

271

  if (NULL == *ppEntry) {

×

272

    return terrno;

×

UNCOV

275

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

×

UNCOV

276

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

×

UNCOV

277

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

×

UNCOV

279

  if (pEntry->type < 0) {

×

280

    return TSDB_CODE_SUCCESS;

×

UNCOV

283

  if (pEntry->name) {

×

UNCOV

284

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

×

UNCOV

285

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

×

286

      code = terrno;

×

287

      metaCloneEntryFree(ppEntry);

×

288

      return code;

×

UNCOV

292

  if (pEntry->type == TSDB_SUPER_TABLE) {

×

UNCOV

293

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

×

UNCOV

295

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

×

UNCOV

296

    if (code) {

×

297

      metaCloneEntryFree(ppEntry);

×

298

      return code;

×

UNCOV

301

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

×

UNCOV

302

    if (code) {

×

303

      metaCloneEntryFree(ppEntry);

×

304

      return code;

×

UNCOV

306

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

×

UNCOV

307

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

×

UNCOV

308

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

×

UNCOV

309

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

×

UNCOV

312

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

×

UNCOV

313

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

×

UNCOV

314

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

×

UNCOV

315

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

×

316

        code = terrno;

×

317

        metaCloneEntryFree(ppEntry);

×

318

        return code;

×

UNCOV

320

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

×

UNCOV

324

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

×

UNCOV

325

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

×

UNCOV

326

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

×

327

      code = terrno;

×

328

      metaCloneEntryFree(ppEntry);

×

329

      return code;

×

UNCOV

331

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

×

UNCOV

332

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

×

UNCOV

333

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

×

UNCOV

334

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

×

UNCOV

335

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

×

UNCOV

338

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

×

UNCOV

339

    if (code) {

×

340

      metaCloneEntryFree(ppEntry);

×

341

      return code;

×

UNCOV

345

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

×

UNCOV

346

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

×

UNCOV

347

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

×

UNCOV

348

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

×

349

        code = terrno;

×

350

        metaCloneEntryFree(ppEntry);

×

351

        return code;

×

UNCOV

353

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

×

UNCOV

356

    return TSDB_CODE_INVALID_PARA;

×

UNCOV

359

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

×

UNCOV

360

  if (code) {

×

361

    metaCloneEntryFree(ppEntry);

×

362

    return code;

×

UNCOV

365

  return code;

×

taosdata / TDengine / #3621

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 "meta.h"
17
UNCOV 18	int meteEncodeColCmprEntry(SEncoder pCoder, const SMetaEntry pME) {	×
UNCOV 19	const SColCmprWrapper *pw = &pME->colCmpr;	×
UNCOV 20	TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->nCols));	×
UNCOV 21	TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->version));	×
UNCOV 22	uDebug("encode cols:%d", pw->nCols);	×
23
UNCOV 24	for (int32_t i = 0; i < pw->nCols; i++) {	×
UNCOV 25	SColCmpr *p = &pw->pColCmpr[i];	×
UNCOV 26	TAOS_CHECK_RETURN(tEncodeI16v(pCoder, p->id));	×
UNCOV 27	TAOS_CHECK_RETURN(tEncodeU32(pCoder, p->alg));	×
28	}
UNCOV 29	return 0;	×
30	}
UNCOV 31	int meteDecodeColCmprEntry(SDecoder pDecoder, SMetaEntry pME) {	×
UNCOV 32	SColCmprWrapper *pWrapper = &pME->colCmpr;	×
UNCOV 33	TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->nCols));	×
UNCOV 34	if (pWrapper->nCols == 0) {	×
35	return 0;	×
36	}
37
UNCOV 38	TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->version));	×
UNCOV 39	uDebug("dencode cols:%d", pWrapper->nCols);	×
UNCOV 40	pWrapper->pColCmpr = (SColCmpr )tDecoderMalloc(pDecoder, pWrapper->nCols sizeof(SColCmpr));	×
UNCOV 41	if (pWrapper->pColCmpr == NULL) {	×
42	return terrno;	×
43	}
44
UNCOV 45	for (int i = 0; i < pWrapper->nCols; i++) {	×
UNCOV 46	SColCmpr *p = &pWrapper->pColCmpr[i];	×
UNCOV 47	TAOS_CHECK_RETURN(tDecodeI16v(pDecoder, &p->id));	×
UNCOV 48	TAOS_CHECK_RETURN(tDecodeU32(pDecoder, &p->alg));	×
49	}
UNCOV 50	return 0;	×
51	}
52	static FORCE_INLINE int32_t metatInitDefaultSColCmprWrapper(SDecoder pDecoder, SColCmprWrapper pCmpr,
53	SSchemaWrapper *pSchema) {
54	pCmpr->nCols = pSchema->nCols;	×
UNCOV 55	if ((pCmpr->pColCmpr = (SColCmpr )tDecoderMalloc(pDecoder, pCmpr->nCols sizeof(SColCmpr))) == NULL) {	×
56	return terrno;	×
57	}
58
UNCOV 59	for (int32_t i = 0; i < pCmpr->nCols; i++) {	×
UNCOV 60	SColCmpr *pColCmpr = &pCmpr->pColCmpr[i];	×
UNCOV 61	SSchema *pColSchema = &pSchema->pSchema[i];	×
UNCOV 62	pColCmpr->id = pColSchema->colId;	×
UNCOV 63	pColCmpr->alg = createDefaultColCmprByType(pColSchema->type);	×
64	}
UNCOV 65	return 0;	×
66	}
67
UNCOV 68	static int32_t metaCloneColCmpr(const SColCmprWrapper pSrc, SColCmprWrapper pDst) {	×
UNCOV 69	if (pSrc->nCols > 0) {	×
UNCOV 70	pDst->nCols = pSrc->nCols;	×
UNCOV 71	pDst->version = pSrc->version;	×
UNCOV 72	pDst->pColCmpr = (SColCmpr *)taosMemoryCalloc(pSrc->nCols, sizeof(SColCmpr));	×
UNCOV 73	if (NULL == pDst->pColCmpr) {	×
74	return terrno;	×
75	}
UNCOV 76	memcpy(pDst->pColCmpr, pSrc->pColCmpr, pSrc->nCols * sizeof(SColCmpr));	×
77	}
UNCOV 78	return 0;	×
79	}
80
UNCOV 81	static void metaCloneColCmprFree(SColCmprWrapper *pCmpr) {	×
UNCOV 82	if (pCmpr) {	×
UNCOV 83	taosMemoryFreeClear(pCmpr->pColCmpr);	×
84	}
UNCOV 85	}	×
86
UNCOV 87	int metaEncodeEntry(SEncoder pCoder, const SMetaEntry pME) {	×
UNCOV 88	TAOS_CHECK_RETURN(tStartEncode(pCoder));	×
UNCOV 89	TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->version));	×
UNCOV 90	TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->type));	×
UNCOV 91	TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->uid));	×
92
UNCOV 93	if (pME->type > 0) {	×
UNCOV 94	if (pME->name == NULL) {	×
95	return TSDB_CODE_INVALID_PARA;	×
96	}
97
UNCOV 98	TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->name));	×
99
UNCOV 100	if (pME->type == TSDB_SUPER_TABLE) {	×
UNCOV 101	TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->flags));	×
UNCOV 102	TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaRow));	×
UNCOV 103	TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag));	×
UNCOV 104	if (TABLE_IS_ROLLUP(pME->flags)) {	×
UNCOV 105	TAOS_CHECK_RETURN(tEncodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam));	×
106	}
UNCOV 107	} else if (pME->type == TSDB_CHILD_TABLE) {	×
UNCOV 108	TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.btime));	×
UNCOV 109	TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ctbEntry.ttlDays));	×
UNCOV 110	TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ctbEntry.commentLen));	×
UNCOV 111	if (pME->ctbEntry.commentLen > 0) {	×
UNCOV 112	TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ctbEntry.comment));	×
113	}
UNCOV 114	TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.suid));	×
UNCOV 115	TAOS_CHECK_RETURN(tEncodeTag(pCoder, (const STag *)pME->ctbEntry.pTags));	×
UNCOV 116	} else if (pME->type == TSDB_NORMAL_TABLE) {	×
UNCOV 117	TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ntbEntry.btime));	×
UNCOV 118	TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ntbEntry.ttlDays));	×
UNCOV 119	TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.commentLen));	×
UNCOV 120	if (pME->ntbEntry.commentLen > 0) {	×
UNCOV 121	TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ntbEntry.comment));	×
122	}
UNCOV 123	TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.ncid));	×
UNCOV 124	TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->ntbEntry.schemaRow));	×
UNCOV 125	} else if (pME->type == TSDB_TSMA_TABLE) {	×
UNCOV 126	TAOS_CHECK_RETURN(tEncodeTSma(pCoder, pME->smaEntry.tsma));	×
127	} else {
UNCOV 128	metaError("meta/entry: invalide table type: %" PRId8 " encode failed.", pME->type);	×
129	return TSDB_CODE_INVALID_PARA;	×
130	}
UNCOV 131	TAOS_CHECK_RETURN(meteEncodeColCmprEntry(pCoder, pME));	×
132	}
133
UNCOV 134	tEndEncode(pCoder);	×
UNCOV 135	return 0;	×
136	}
137
UNCOV 138	int metaDecodeEntry(SDecoder pCoder, SMetaEntry pME) {	×
UNCOV 139	TAOS_CHECK_RETURN(tStartDecode(pCoder));	×
UNCOV 140	TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->version));	×
UNCOV 141	TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->type));	×
UNCOV 142	TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->uid));	×
143
UNCOV 144	if (pME->type > 0) {	×
UNCOV 145	TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->name));	×
146
UNCOV 147	if (pME->type == TSDB_SUPER_TABLE) {	×
UNCOV 148	TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->flags));	×
UNCOV 149	TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaRow));	×
UNCOV 150	TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaTag));	×
UNCOV 151	if (TABLE_IS_ROLLUP(pME->flags)) {	×
UNCOV 152	TAOS_CHECK_RETURN(tDecodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam));	×
153	}
UNCOV 154	} else if (pME->type == TSDB_CHILD_TABLE) {	×
UNCOV 155	TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.btime));	×
UNCOV 156	TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ctbEntry.ttlDays));	×
UNCOV 157	TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ctbEntry.commentLen));	×
UNCOV 158	if (pME->ctbEntry.commentLen > 0) {	×
UNCOV 159	TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ctbEntry.comment));	×
160	}
UNCOV 161	TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.suid));	×
UNCOV 162	TAOS_CHECK_RETURN(tDecodeTag(pCoder, (STag **)&pME->ctbEntry.pTags));	×
UNCOV 163	} else if (pME->type == TSDB_NORMAL_TABLE) {	×
UNCOV 164	TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ntbEntry.btime));	×
UNCOV 165	TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ntbEntry.ttlDays));	×
UNCOV 166	TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.commentLen));	×
UNCOV 167	if (pME->ntbEntry.commentLen > 0) {	×
UNCOV 168	TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ntbEntry.comment));	×
169	}
UNCOV 170	TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.ncid));	×
UNCOV 171	TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->ntbEntry.schemaRow));	×
172	} else if (pME->type == TSDB_TSMA_TABLE) {	×
UNCOV 173	pME->smaEntry.tsma = tDecoderMalloc(pCoder, sizeof(STSma));	×
UNCOV 174	if (!pME->smaEntry.tsma) {	×
175	return terrno;	×
176	}
UNCOV 177	TAOS_CHECK_RETURN(tDecodeTSma(pCoder, pME->smaEntry.tsma, true));	×
178	} else {
179	metaError("meta/entry: invalide table type: %" PRId8 " decode failed.", pME->type);	×
180	return TSDB_CODE_INVALID_PARA;	×
181	}
UNCOV 182	if (pME->type == TSDB_SUPER_TABLE) {	×
UNCOV 183	if (TABLE_IS_COL_COMPRESSED(pME->flags)) {	×
UNCOV 184	TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME));	×
185
UNCOV 186	if (pME->colCmpr.nCols == 0) {	×
187	TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow));	×
188	}
189	} else {
190	TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow));	×
UNCOV 191	TABLE_SET_COL_COMPRESSED(pME->flags);	×
192	}
UNCOV 193	} else if (pME->type == TSDB_NORMAL_TABLE) {	×
UNCOV 194	if (!tDecodeIsEnd(pCoder)) {	×
UNCOV 195	uDebug("set type: %d, tableName:%s", pME->type, pME->name);	×
UNCOV 196	TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME));	×
UNCOV 197	if (pME->colCmpr.nCols == 0) {	×
198	TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow));	×
199	}
200	} else {
201	uDebug("set default type: %d, tableName:%s", pME->type, pME->name);	×
202	TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow));	×
203	}
UNCOV 204	TABLE_SET_COL_COMPRESSED(pME->flags);	×
205	}
206	}
207
UNCOV 208	tEndDecode(pCoder);	×
UNCOV 209	return 0;	×
210	}
211
UNCOV 212	static int32_t metaCloneSchema(const SSchemaWrapper pSrc, SSchemaWrapper pDst) {	×
UNCOV 213	if (pSrc == NULL \|\| pDst == NULL) {	×
214	return TSDB_CODE_INVALID_PARA;	×
215	}
216
UNCOV 217	pDst->nCols = pSrc->nCols;	×
UNCOV 218	pDst->version = pSrc->version;	×
UNCOV 219	pDst->pSchema = (SSchema )taosMemoryMalloc(pSrc->nCols sizeof(SSchema));	×
UNCOV 220	if (pDst->pSchema == NULL) {	×
221	return terrno;	×
222	}
UNCOV 223	memcpy(pDst->pSchema, pSrc->pSchema, pSrc->nCols * sizeof(SSchema));	×
UNCOV 224	return TSDB_CODE_SUCCESS;	×
225	}
226
UNCOV 227	static void metaCloneSchemaFree(SSchemaWrapper *pSchema) {	×
UNCOV 228	if (pSchema) {	×
UNCOV 229	taosMemoryFreeClear(pSchema->pSchema);	×
230	}
UNCOV 231	}	×
232
UNCOV 233	void metaCloneEntryFree(SMetaEntry **ppEntry) {	×
UNCOV 234	if (ppEntry == NULL \|\| *ppEntry == NULL) {	×
235	return;	×
236	}
237
UNCOV 238	taosMemoryFreeClear((*ppEntry)->name);	×
239
UNCOV 240	if ((*ppEntry)->type < 0) {	×
241	taosMemoryFreeClear(*ppEntry);	×
242	return;	×
243	}
244
UNCOV 245	if (TSDB_SUPER_TABLE == (*ppEntry)->type) {	×
UNCOV 246	metaCloneSchemaFree(&(*ppEntry)->stbEntry.schemaRow);	×
UNCOV 247	metaCloneSchemaFree(&(*ppEntry)->stbEntry.schemaTag);	×
UNCOV 248	} else if (TSDB_CHILD_TABLE == (*ppEntry)->type) {	×
UNCOV 249	taosMemoryFreeClear((*ppEntry)->ctbEntry.comment);	×
UNCOV 250	taosMemoryFreeClear((*ppEntry)->ctbEntry.pTags);	×
UNCOV 251	} else if (TSDB_NORMAL_TABLE == (*ppEntry)->type) {	×
UNCOV 252	metaCloneSchemaFree(&(*ppEntry)->ntbEntry.schemaRow);	×
UNCOV 253	taosMemoryFreeClear((*ppEntry)->ntbEntry.comment);	×
254	} else {
UNCOV 255	return;	×
256	}
UNCOV 257	metaCloneColCmprFree(&(*ppEntry)->colCmpr);	×
258
UNCOV 259	taosMemoryFreeClear(*ppEntry);	×
UNCOV 260	return;	×
261	}
262
UNCOV 263	int32_t metaCloneEntry(const SMetaEntry pEntry, SMetaEntry *ppEntry) {	×
UNCOV 264	int32_t code = TSDB_CODE_SUCCESS;	×
265
UNCOV 266	if (NULL == pEntry \|\| NULL == ppEntry) {	×
267	return TSDB_CODE_INVALID_PARA;	×
268	}
269
UNCOV 270	ppEntry = (SMetaEntry )taosMemoryCalloc(1, sizeof(SMetaEntry));	×
UNCOV 271	if (NULL == *ppEntry) {	×
272	return terrno;	×
273	}
274
UNCOV 275	(*ppEntry)->version = pEntry->version;	×
UNCOV 276	(*ppEntry)->type = pEntry->type;	×
UNCOV 277	(*ppEntry)->uid = pEntry->uid;	×
278
UNCOV 279	if (pEntry->type < 0) {	×
280	return TSDB_CODE_SUCCESS;	×
281	}
282
UNCOV 283	if (pEntry->name) {	×
UNCOV 284	(*ppEntry)->name = tstrdup(pEntry->name);	×
UNCOV 285	if (NULL == (*ppEntry)->name) {	×
286	code = terrno;	×
287	metaCloneEntryFree(ppEntry);	×
288	return code;	×
289	}
290	}
291
UNCOV 292	if (pEntry->type == TSDB_SUPER_TABLE) {	×
UNCOV 293	(*ppEntry)->flags = pEntry->flags;	×
294
UNCOV 295	code = metaCloneSchema(&pEntry->stbEntry.schemaRow, &(*ppEntry)->stbEntry.schemaRow);	×
UNCOV 296	if (code) {	×
297	metaCloneEntryFree(ppEntry);	×
298	return code;	×
299	}
300
UNCOV 301	code = metaCloneSchema(&pEntry->stbEntry.schemaTag, &(*ppEntry)->stbEntry.schemaTag);	×
UNCOV 302	if (code) {	×
303	metaCloneEntryFree(ppEntry);	×
304	return code;	×
305	}
UNCOV 306	} else if (pEntry->type == TSDB_CHILD_TABLE) {	×
UNCOV 307	(*ppEntry)->ctbEntry.btime = pEntry->ctbEntry.btime;	×
UNCOV 308	(*ppEntry)->ctbEntry.ttlDays = pEntry->ctbEntry.ttlDays;	×
UNCOV 309	(*ppEntry)->ctbEntry.suid = pEntry->ctbEntry.suid;	×
310
311	// comment
UNCOV 312	(*ppEntry)->ctbEntry.commentLen = pEntry->ctbEntry.commentLen;	×
UNCOV 313	if (pEntry->ctbEntry.commentLen > 0) {	×
UNCOV 314	(*ppEntry)->ctbEntry.comment = taosMemoryMalloc(pEntry->ctbEntry.commentLen + 1);	×
UNCOV 315	if (NULL == (*ppEntry)->ctbEntry.comment) {	×
316	code = terrno;	×
317	metaCloneEntryFree(ppEntry);	×
318	return code;	×
319	}
UNCOV 320	memcpy((*ppEntry)->ctbEntry.comment, pEntry->ctbEntry.comment, pEntry->ctbEntry.commentLen + 1);	×
321	}
322
323	// tags
UNCOV 324	STag pTags = (STag )pEntry->ctbEntry.pTags;	×
UNCOV 325	(*ppEntry)->ctbEntry.pTags = taosMemoryCalloc(1, pTags->len);	×
UNCOV 326	if (NULL == (*ppEntry)->ctbEntry.pTags) {	×
327	code = terrno;	×
328	metaCloneEntryFree(ppEntry);	×
329	return code;	×
330	}
UNCOV 331	memcpy((*ppEntry)->ctbEntry.pTags, pEntry->ctbEntry.pTags, pTags->len);	×
UNCOV 332	} else if (pEntry->type == TSDB_NORMAL_TABLE) {	×
UNCOV 333	(*ppEntry)->ntbEntry.btime = pEntry->ntbEntry.btime;	×
UNCOV 334	(*ppEntry)->ntbEntry.ttlDays = pEntry->ntbEntry.ttlDays;	×
UNCOV 335	(*ppEntry)->ntbEntry.ncid = pEntry->ntbEntry.ncid;	×
336
337	// schema
UNCOV 338	code = metaCloneSchema(&pEntry->ntbEntry.schemaRow, &(*ppEntry)->ntbEntry.schemaRow);	×
UNCOV 339	if (code) {	×
340	metaCloneEntryFree(ppEntry);	×
341	return code;	×
342	}
343
344	// comment
UNCOV 345	(*ppEntry)->ntbEntry.commentLen = pEntry->ntbEntry.commentLen;	×
UNCOV 346	if (pEntry->ntbEntry.commentLen > 0) {	×
UNCOV 347	(*ppEntry)->ntbEntry.comment = taosMemoryMalloc(pEntry->ntbEntry.commentLen + 1);	×
UNCOV 348	if (NULL == (*ppEntry)->ntbEntry.comment) {	×
349	code = terrno;	×
350	metaCloneEntryFree(ppEntry);	×
351	return code;	×
352	}
UNCOV 353	memcpy((*ppEntry)->ntbEntry.comment, pEntry->ntbEntry.comment, pEntry->ntbEntry.commentLen + 1);	×
354	}
355	} else {
UNCOV 356	return TSDB_CODE_INVALID_PARA;	×
357	}
358
UNCOV 359	code = metaCloneColCmpr(&pEntry->colCmpr, &(*ppEntry)->colCmpr);	×
UNCOV 360	if (code) {	×
361	metaCloneEntryFree(ppEntry);	×
362	return code;	×
363	}
364
UNCOV 365	return code;	×
366	}

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