#5000

Committed 22 Mar 2026 10:21AM UTC coverage: 72.307% (-0.003%) from 72.31%

Build # #5000

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

feat(subq/some): some/any/exists for stream subq (#34860)

Coverage Stats

50 of 68 new or added lines in 1 file covered. (73.53%)

614 existing lines in 138 files now uncovered.

253462 of 350536 relevant lines covered (72.31%)

134798164.58 hits per line

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

81.19

/source/dnode/mnode/impl/src/mndCompactDetail.c

/*
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
 *
 * This program is free software: you can use, redistribute, and/or modify
 * it under the terms of the GNU Affero General Public License, version 3
 * or later ("AGPL"), as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
#include "mndCompactDetail.h"
#include "mndDb.h"
#include "mndShow.h"
#include "mndTrans.h"

#define MND_COMPACT_DETAIL_VER_NUMBER 1

int32_t mndInitCompactDetail(SMnode *pMnode) {
  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_COMPACT_DETAIL, mndRetrieveCompactDetail);

  SSdbTable table = {
      .sdbType = SDB_COMPACT_DETAIL,
      .keyType = SDB_KEY_INT64,
      .encodeFp = (SdbEncodeFp)mndCompactDetailActionEncode,
      .decodeFp = (SdbDecodeFp)mndCompactDetailActionDecode,
      .insertFp = (SdbInsertFp)mndCompactDetailActionInsert,
      .updateFp = (SdbUpdateFp)mndCompactDetailActionUpdate,
      .deleteFp = (SdbDeleteFp)mndCompactDetailActionDelete,
  };

  return sdbSetTable(pMnode->pSdb, table);
}

void mndCleanupCompactDetail(SMnode *pMnode) { mDebug("mnd compact detail cleanup"); }

int32_t mndRetrieveCompactDetail(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
  SMnode            *pMnode = pReq->info.node;
  SSdb              *pSdb = pMnode->pSdb;
  int32_t            numOfRows = 0;
  SCompactDetailObj *pCompactDetail = NULL;
  char              *sep = NULL;
  SDbObj            *pDb = NULL;

  mInfo("retrieve compact detail");

  if (strlen(pShow->db) > 0) {
    sep = strchr(pShow->db, '.');
    if (sep &&
        ((0 == strcmp(sep + 1, TSDB_INFORMATION_SCHEMA_DB) || (0 == strcmp(sep + 1, TSDB_PERFORMANCE_SCHEMA_DB))))) {
      sep++;
    } else {
      pDb = mndAcquireDb(pMnode, pShow->db);
      if (pDb == NULL) return terrno;
    }
  }

  while (numOfRows < rows) {
    pShow->pIter = sdbFetch(pSdb, SDB_COMPACT_DETAIL, pShow->pIter, (void **)&pCompactDetail);
    if (pShow->pIter == NULL) break;

    SColumnInfoData *pColInfo;
    SName            n;
    int32_t          cols = 0;

    char tmpBuf[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0};

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->compactId, false),
                                   pSdb, pCompactDetail);

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->vgId, false), pSdb,
                                   pCompactDetail);

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->dnodeId, false),
                                   pSdb, pCompactDetail);

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    TAOS_CHECK_RETURN_WITH_RELEASE(
        colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->numberFileset, false), pSdb, pCompactDetail);

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->finished, false),
                                   pSdb, pCompactDetail);

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->startTime, false),
                                   pSdb, pCompactDetail);

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->progress, false),
                                   pSdb, pCompactDetail);

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
    TAOS_CHECK_RETURN_WITH_RELEASE(
        colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->remainingTime, false), pSdb, pCompactDetail);

    numOfRows++;
    sdbRelease(pSdb, pCompactDetail);
  }

  pShow->numOfRows += numOfRows;
  mndReleaseDb(pMnode, pDb);
  return numOfRows;
}

void tFreeCompactDetailObj(SCompactDetailObj *pCompact) {}

int32_t tSerializeSCompactDetailObj(void *buf, int32_t bufLen, const SCompactDetailObj *pObj) {
  SEncoder encoder = {0};
  int32_t  code = 0;
  int32_t  lino;
  int32_t  tlen;
  tEncoderInit(&encoder, buf, bufLen);

  TAOS_CHECK_EXIT(tStartEncode(&encoder));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->compactDetailId));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->compactId));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->vgId));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->dnodeId));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->numberFileset));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->finished));
  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pObj->startTime));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->newNumberFileset));
  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->newFinished));
  // 1. add progress and remaining time
  TAOS_CHECK_EXIT(tEncodeI32v(&encoder, pObj->progress));
  TAOS_CHECK_EXIT(tEncodeI64v(&encoder, pObj->remainingTime));

  tEndEncode(&encoder);

_exit:
  if (code) {
    tlen = code;
  } else {
    tlen = encoder.pos;
  }
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeSCompactDetailObj(void *buf, int32_t bufLen, SCompactDetailObj *pObj) {
  int32_t  code = 0;
  int32_t  lino;
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  TAOS_CHECK_EXIT(tStartDecode(&decoder));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->compactDetailId));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->compactId));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->vgId));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->dnodeId));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->numberFileset));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->finished));
  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pObj->startTime));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->newNumberFileset));
  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->newFinished));
  // 1. add progress and remaining time decode
  if (!tDecodeIsEnd(&decoder)) {
    TAOS_CHECK_EXIT(tDecodeI32v(&decoder, &pObj->progress));
    TAOS_CHECK_EXIT(tDecodeI64v(&decoder, &pObj->remainingTime));
  } else {
    pObj->progress = 0;
    pObj->remainingTime = 0;
  }

  tEndDecode(&decoder);

_exit:
  tDecoderClear(&decoder);
  return code;
}

SSdbRaw *mndCompactDetailActionEncode(SCompactDetailObj *pCompact) {
  int32_t code = 0;
  int32_t lino = 0;
  terrno = TSDB_CODE_SUCCESS;

  void    *buf = NULL;
  SSdbRaw *pRaw = NULL;

  int32_t tlen = tSerializeSCompactDetailObj(NULL, 0, pCompact);
  if (tlen < 0) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    goto OVER;
  }

  int32_t size = sizeof(int32_t) + tlen;
  pRaw = sdbAllocRaw(SDB_COMPACT_DETAIL, MND_COMPACT_DETAIL_VER_NUMBER, size);
  if (pRaw == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    goto OVER;
  }

  buf = taosMemoryMalloc(tlen);
  if (buf == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    goto OVER;
  }

  tlen = tSerializeSCompactDetailObj(buf, tlen, pCompact);
  if (tlen < 0) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    goto OVER;
  }

  int32_t dataPos = 0;
  SDB_SET_INT32(pRaw, dataPos, tlen, OVER);
  SDB_SET_BINARY(pRaw, dataPos, buf, tlen, OVER);
  SDB_SET_DATALEN(pRaw, dataPos, OVER);

OVER:
  taosMemoryFreeClear(buf);
  if (terrno != TSDB_CODE_SUCCESS) {
    mError("compact detail:%" PRId32 ", failed to encode to raw:%p since %s", pCompact->compactId, pRaw, terrstr());
    sdbFreeRaw(pRaw);
    return NULL;
  }

  mTrace("compact detail:%" PRId32 ", encode to raw:%p, row:%p", pCompact->compactId, pRaw, pCompact);
  return pRaw;
}

SSdbRow *mndCompactDetailActionDecode(SSdbRaw *pRaw) {
  int32_t            code = 0;
  int32_t            lino = 0;
  SSdbRow           *pRow = NULL;
  SCompactDetailObj *pCompact = NULL;
  void              *buf = NULL;
  terrno = TSDB_CODE_SUCCESS;

  int8_t sver = 0;
  if (sdbGetRawSoftVer(pRaw, &sver) != 0) {
    goto OVER;
  }

  if (sver != MND_COMPACT_DETAIL_VER_NUMBER) {
    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
    mError("compact detail read invalid ver, data ver: %d, curr ver: %d", sver, MND_COMPACT_DETAIL_VER_NUMBER);
    goto OVER;
  }

  pRow = sdbAllocRow(sizeof(SCompactObj));
  if (pRow == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    goto OVER;
  }

  pCompact = sdbGetRowObj(pRow);
  if (pCompact == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    goto OVER;
  }

  int32_t tlen;
  int32_t dataPos = 0;
  SDB_GET_INT32(pRaw, dataPos, &tlen, OVER);
  buf = taosMemoryMalloc(tlen + 1);
  if (buf == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    goto OVER;
  }
  SDB_GET_BINARY(pRaw, dataPos, buf, tlen, OVER);

  if ((terrno = tDeserializeSCompactDetailObj(buf, tlen, pCompact)) < 0) {
    goto OVER;
  }

OVER:
  taosMemoryFreeClear(buf);
  if (terrno != TSDB_CODE_SUCCESS) {
    mError("compact detail:%" PRId32 ", failed to decode from raw:%p since %s", pCompact->compactId, pRaw, terrstr());
    taosMemoryFreeClear(pRow);
    return NULL;
  }

  mTrace("compact detail:%" PRId32 ", decode from raw:%p, row:%p", pCompact->compactId, pRaw, pCompact);
  return pRow;
}

int32_t mndCompactDetailActionInsert(SSdb *pSdb, SCompactDetailObj *pCompact) {
  mTrace("compact detail:%" PRId32 ", perform insert action", pCompact->compactId);
  return 0;
}

int32_t mndCompactDetailActionDelete(SSdb *pSdb, SCompactDetailObj *pCompact) {
  mTrace("compact detail:%" PRId32 ", perform insert action", pCompact->compactId);
  tFreeCompactDetailObj(pCompact);
  return 0;
}

int32_t mndCompactDetailActionUpdate(SSdb *pSdb, SCompactDetailObj *pOldCompact, SCompactDetailObj *pNewCompact) {
  mTrace("compact detail:%" PRId32 ", perform update action, old row:%p new row:%p", pOldCompact->compactId,
         pOldCompact, pNewCompact);

  pOldCompact->numberFileset = pNewCompact->numberFileset;
  pOldCompact->finished = pNewCompact->finished;

  return 0;
}

int32_t mndAddCompactDetailToTran(SMnode *pMnode, STrans *pTrans, SCompactObj *pCompact, SVgObj *pVgroup,
                                  SVnodeGid *pVgid, int32_t index) {
  int32_t           code = 0;
  SCompactDetailObj compactDetail = {0};
  compactDetail.compactDetailId = index;
  compactDetail.compactId = pCompact->compactId;
  compactDetail.vgId = pVgroup->vgId;
  compactDetail.dnodeId = pVgid->dnodeId;
  compactDetail.startTime = taosGetTimestampMs();
  compactDetail.numberFileset = -1;
  compactDetail.finished = -1;
  compactDetail.newNumberFileset = -1;
  compactDetail.newFinished = -1;

  mInfo("compact:%d, add compact detail to trans, index:%d, vgId:%d, dnodeId:%d", compactDetail.compactId,
        compactDetail.compactDetailId, compactDetail.vgId, compactDetail.dnodeId);

  SSdbRaw *pVgRaw = mndCompactDetailActionEncode(&compactDetail);
  if (pVgRaw == NULL) return -1;
  if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) {
    sdbFreeRaw(pVgRaw);
    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
    if (terrno != 0) code = terrno;
    TAOS_RETURN(code);
  }
  code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);

  TAOS_RETURN(code);
}

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	#include "mndCompactDetail.h"
16	#include "mndDb.h"
17	#include "mndShow.h"
18	#include "mndTrans.h"
19
20	#define MND_COMPACT_DETAIL_VER_NUMBER 1
21
22	int32_t mndInitCompactDetail(SMnode *pMnode) {	453,394✔
23	mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_COMPACT_DETAIL, mndRetrieveCompactDetail);	453,394✔
24
25	SSdbTable table = {	453,394✔
26	.sdbType = SDB_COMPACT_DETAIL,
27	.keyType = SDB_KEY_INT64,
28	.encodeFp = (SdbEncodeFp)mndCompactDetailActionEncode,
29	.decodeFp = (SdbDecodeFp)mndCompactDetailActionDecode,
30	.insertFp = (SdbInsertFp)mndCompactDetailActionInsert,
31	.updateFp = (SdbUpdateFp)mndCompactDetailActionUpdate,
32	.deleteFp = (SdbDeleteFp)mndCompactDetailActionDelete,
33	};
34
35	return sdbSetTable(pMnode->pSdb, table);	453,394✔
36	}
37
38	void mndCleanupCompactDetail(SMnode *pMnode) { mDebug("mnd compact detail cleanup"); }	453,330✔
39
40	int32_t mndRetrieveCompactDetail(SRpcMsg pReq, SShowObj pShow, SSDataBlock *pBlock, int32_t rows) {	31,936✔
41	SMnode *pMnode = pReq->info.node;	31,936✔
42	SSdb *pSdb = pMnode->pSdb;	31,936✔
43	int32_t numOfRows = 0;	31,936✔
44	SCompactDetailObj *pCompactDetail = NULL;	31,936✔
45	char *sep = NULL;	31,936✔
46	SDbObj *pDb = NULL;	31,936✔
47
48	mInfo("retrieve compact detail");	31,936✔
49
50	if (strlen(pShow->db) > 0) {	31,936✔
51	sep = strchr(pShow->db, '.');	×
52	if (sep &&	×
53	((0 == strcmp(sep + 1, TSDB_INFORMATION_SCHEMA_DB) \|\| (0 == strcmp(sep + 1, TSDB_PERFORMANCE_SCHEMA_DB))))) {	×
54	sep++;	×
55	} else {
56	pDb = mndAcquireDb(pMnode, pShow->db);	×
57	if (pDb == NULL) return terrno;	×
58	}
59	}
60
61	while (numOfRows < rows) {	75,784✔
62	pShow->pIter = sdbFetch(pSdb, SDB_COMPACT_DETAIL, pShow->pIter, (void **)&pCompactDetail);	75,784✔
63	if (pShow->pIter == NULL) break;	75,784✔
64
65	SColumnInfoData *pColInfo;
66	SName n;
67	int32_t cols = 0;	43,848✔
68
69	char tmpBuf[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0};	43,848✔
70
71	pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);	43,848✔
72	TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->compactId, false),	43,848✔
73	pSdb, pCompactDetail);
74
75	pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);	43,848✔
76	TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->vgId, false), pSdb,	43,848✔
77	pCompactDetail);
78
79	pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);	43,848✔
80	TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->dnodeId, false),	43,848✔
81	pSdb, pCompactDetail);
82
83	pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);	43,848✔
84	TAOS_CHECK_RETURN_WITH_RELEASE(	43,848✔
85	colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->numberFileset, false), pSdb, pCompactDetail);
86
87	pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);	43,848✔
88	TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->finished, false),	43,848✔
89	pSdb, pCompactDetail);
90
91	pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);	43,848✔
92	TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->startTime, false),	43,848✔
93	pSdb, pCompactDetail);
94
95	pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);	43,848✔
96	TAOS_CHECK_RETURN_WITH_RELEASE(colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->progress, false),	43,848✔
97	pSdb, pCompactDetail);
98
99	pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);	43,848✔
100	TAOS_CHECK_RETURN_WITH_RELEASE(	43,848✔
101	colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->remainingTime, false), pSdb, pCompactDetail);
102
103	numOfRows++;	43,848✔
104	sdbRelease(pSdb, pCompactDetail);	43,848✔
105	}
106
107	pShow->numOfRows += numOfRows;	31,936✔
108	mndReleaseDb(pMnode, pDb);	31,936✔
109	return numOfRows;	31,936✔
110	}
111
112	void tFreeCompactDetailObj(SCompactDetailObj *pCompact) {}	347,503✔
113
114	int32_t tSerializeSCompactDetailObj(void buf, int32_t bufLen, const SCompactDetailObj pObj) {	1,109,746✔
115	SEncoder encoder = {0};	1,109,746✔
116	int32_t code = 0;	1,109,746✔
117	int32_t lino;
118	int32_t tlen;
119	tEncoderInit(&encoder, buf, bufLen);	1,109,746✔
120
121	TAOS_CHECK_EXIT(tStartEncode(&encoder));	1,109,746✔
122	TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->compactDetailId));	2,219,492✔
123	TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->compactId));	2,219,492✔
124	TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->vgId));	2,219,492✔
125	TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->dnodeId));	2,219,492✔
126	TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->numberFileset));	2,219,492✔
127	TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->finished));	2,219,492✔
128	TAOS_CHECK_EXIT(tEncodeI64(&encoder, pObj->startTime));	2,219,492✔
129	TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->newNumberFileset));	2,219,492✔
130	TAOS_CHECK_EXIT(tEncodeI32(&encoder, pObj->newFinished));	2,219,492✔
131	// 1. add progress and remaining time
132	TAOS_CHECK_EXIT(tEncodeI32v(&encoder, pObj->progress));	2,219,492✔
133	TAOS_CHECK_EXIT(tEncodeI64v(&encoder, pObj->remainingTime));	2,219,492✔
134
135	tEndEncode(&encoder);	1,109,746✔
136
137	_exit:	1,109,746✔
138	if (code) {	1,109,746✔
UNCOV 139	tlen = code;	×
140	} else {
141	tlen = encoder.pos;	1,109,746✔
142	}
143	tEncoderClear(&encoder);	1,109,746✔
144	return tlen;	1,109,746✔
145	}
146
147	int32_t tDeserializeSCompactDetailObj(void buf, int32_t bufLen, SCompactDetailObj pObj) {	515,683✔
148	int32_t code = 0;	515,683✔
149	int32_t lino;
150	SDecoder decoder = {0};	515,683✔
151	tDecoderInit(&decoder, buf, bufLen);	515,683✔
152
153	TAOS_CHECK_EXIT(tStartDecode(&decoder));	515,683✔
154	TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->compactDetailId));	1,031,366✔
155	TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->compactId));	1,031,366✔
156	TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->vgId));	1,031,366✔
157	TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->dnodeId));	1,031,366✔
158	TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->numberFileset));	1,031,366✔
159	TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->finished));	1,031,366✔
160	TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pObj->startTime));	1,031,366✔
161	TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->newNumberFileset));	1,031,366✔
162	TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pObj->newFinished));	1,031,366✔
163	// 1. add progress and remaining time decode
164	if (!tDecodeIsEnd(&decoder)) {	515,683✔
165	TAOS_CHECK_EXIT(tDecodeI32v(&decoder, &pObj->progress));	1,031,366✔
166	TAOS_CHECK_EXIT(tDecodeI64v(&decoder, &pObj->remainingTime));	1,031,366✔
167	} else {
168	pObj->progress = 0;	×
169	pObj->remainingTime = 0;	×
170	}
171
172	tEndDecode(&decoder);	515,683✔
173
174	_exit:	515,683✔
175	tDecoderClear(&decoder);	515,683✔
176	return code;	515,683✔
177	}
178
179	SSdbRaw mndCompactDetailActionEncode(SCompactDetailObj pCompact) {	387,092✔
180	int32_t code = 0;	387,092✔
181	int32_t lino = 0;	387,092✔
182	terrno = TSDB_CODE_SUCCESS;	387,092✔
183
184	void *buf = NULL;	387,092✔
185	SSdbRaw *pRaw = NULL;	387,092✔
186
187	int32_t tlen = tSerializeSCompactDetailObj(NULL, 0, pCompact);	387,092✔
188	if (tlen < 0) {	387,092✔
189	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
190	goto OVER;	×
191	}
192
193	int32_t size = sizeof(int32_t) + tlen;	387,092✔
194	pRaw = sdbAllocRaw(SDB_COMPACT_DETAIL, MND_COMPACT_DETAIL_VER_NUMBER, size);	387,092✔
195	if (pRaw == NULL) {	387,092✔
196	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
197	goto OVER;	×
198	}
199
200	buf = taosMemoryMalloc(tlen);	387,092✔
201	if (buf == NULL) {	387,092✔
202	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
203	goto OVER;	×
204	}
205
206	tlen = tSerializeSCompactDetailObj(buf, tlen, pCompact);	387,092✔
207	if (tlen < 0) {	387,092✔
UNCOV 208	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
UNCOV 209	goto OVER;	×
210	}
211
212	int32_t dataPos = 0;	387,092✔
213	SDB_SET_INT32(pRaw, dataPos, tlen, OVER);	387,092✔
214	SDB_SET_BINARY(pRaw, dataPos, buf, tlen, OVER);	387,092✔
215	SDB_SET_DATALEN(pRaw, dataPos, OVER);	387,092✔
216
217	OVER:	387,092✔
218	taosMemoryFreeClear(buf);	387,092✔
219	if (terrno != TSDB_CODE_SUCCESS) {	387,092✔
UNCOV 220	mError("compact detail:%" PRId32 ", failed to encode to raw:%p since %s", pCompact->compactId, pRaw, terrstr());	×
UNCOV 221	sdbFreeRaw(pRaw);	×
UNCOV 222	return NULL;	×
223	}
224
225	mTrace("compact detail:%" PRId32 ", encode to raw:%p, row:%p", pCompact->compactId, pRaw, pCompact);	387,092✔
226	return pRaw;	387,092✔
227	}
228
229	SSdbRow mndCompactDetailActionDecode(SSdbRaw pRaw) {	347,503✔
230	int32_t code = 0;	347,503✔
231	int32_t lino = 0;	347,503✔
232	SSdbRow *pRow = NULL;	347,503✔
233	SCompactDetailObj *pCompact = NULL;	347,503✔
234	void *buf = NULL;	347,503✔
235	terrno = TSDB_CODE_SUCCESS;	347,503✔
236
237	int8_t sver = 0;	347,503✔
238	if (sdbGetRawSoftVer(pRaw, &sver) != 0) {	347,503✔
239	goto OVER;	×
240	}
241
242	if (sver != MND_COMPACT_DETAIL_VER_NUMBER) {	347,503✔
243	terrno = TSDB_CODE_SDB_INVALID_DATA_VER;	×
244	mError("compact detail read invalid ver, data ver: %d, curr ver: %d", sver, MND_COMPACT_DETAIL_VER_NUMBER);	×
245	goto OVER;	×
246	}
247
248	pRow = sdbAllocRow(sizeof(SCompactObj));	347,503✔
249	if (pRow == NULL) {	347,503✔
250	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
251	goto OVER;	×
252	}
253
254	pCompact = sdbGetRowObj(pRow);	347,503✔
255	if (pCompact == NULL) {	347,503✔
256	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
257	goto OVER;	×
258	}
259
260	int32_t tlen;	347,503✔
261	int32_t dataPos = 0;	347,503✔
262	SDB_GET_INT32(pRaw, dataPos, &tlen, OVER);	347,503✔
263	buf = taosMemoryMalloc(tlen + 1);	347,503✔
264	if (buf == NULL) {	347,503✔
265	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
266	goto OVER;	×
267	}
268	SDB_GET_BINARY(pRaw, dataPos, buf, tlen, OVER);	347,503✔
269
270	if ((terrno = tDeserializeSCompactDetailObj(buf, tlen, pCompact)) < 0) {	347,503✔
271	goto OVER;	×
272	}
273
274	OVER:	347,503✔
275	taosMemoryFreeClear(buf);	347,503✔
276	if (terrno != TSDB_CODE_SUCCESS) {	347,503✔
277	mError("compact detail:%" PRId32 ", failed to decode from raw:%p since %s", pCompact->compactId, pRaw, terrstr());	×
278	taosMemoryFreeClear(pRow);	×
279	return NULL;	×
280	}
281
282	mTrace("compact detail:%" PRId32 ", decode from raw:%p, row:%p", pCompact->compactId, pRaw, pCompact);	347,503✔
283	return pRow;	347,503✔
284	}
285
286	int32_t mndCompactDetailActionInsert(SSdb pSdb, SCompactDetailObj pCompact) {	169,273✔
287	mTrace("compact detail:%" PRId32 ", perform insert action", pCompact->compactId);	169,273✔
288	return 0;	169,273✔
289	}
290
291	int32_t mndCompactDetailActionDelete(SSdb pSdb, SCompactDetailObj pCompact) {	347,503✔
292	mTrace("compact detail:%" PRId32 ", perform insert action", pCompact->compactId);	347,503✔
293	tFreeCompactDetailObj(pCompact);	347,503✔
294	return 0;	347,503✔
295	}
296
297	int32_t mndCompactDetailActionUpdate(SSdb pSdb, SCompactDetailObj pOldCompact, SCompactDetailObj *pNewCompact) {	95,019✔
298	mTrace("compact detail:%" PRId32 ", perform update action, old row:%p new row:%p", pOldCompact->compactId,	95,019✔
299	pOldCompact, pNewCompact);
300
301	pOldCompact->numberFileset = pNewCompact->numberFileset;	95,019✔
302	pOldCompact->finished = pNewCompact->finished;	95,019✔
303
304	return 0;	95,019✔
305	}
306
307	int32_t mndAddCompactDetailToTran(SMnode pMnode, STrans pTrans, SCompactObj pCompact, SVgObj pVgroup,	68,009✔
308	SVnodeGid *pVgid, int32_t index) {
309	int32_t code = 0;	68,009✔
310	SCompactDetailObj compactDetail = {0};	68,009✔
311	compactDetail.compactDetailId = index;	68,009✔
312	compactDetail.compactId = pCompact->compactId;	68,009✔
313	compactDetail.vgId = pVgroup->vgId;	68,009✔
314	compactDetail.dnodeId = pVgid->dnodeId;	68,009✔
315	compactDetail.startTime = taosGetTimestampMs();	68,009✔
316	compactDetail.numberFileset = -1;	68,009✔
317	compactDetail.finished = -1;	68,009✔
318	compactDetail.newNumberFileset = -1;	68,009✔
319	compactDetail.newFinished = -1;	68,009✔
320
321	mInfo("compact:%d, add compact detail to trans, index:%d, vgId:%d, dnodeId:%d", compactDetail.compactId,	68,009✔
322	compactDetail.compactDetailId, compactDetail.vgId, compactDetail.dnodeId);
323
324	SSdbRaw *pVgRaw = mndCompactDetailActionEncode(&compactDetail);	68,009✔
325	if (pVgRaw == NULL) return -1;	68,009✔
326	if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) {	68,009✔
327	sdbFreeRaw(pVgRaw);	×
328	code = TSDB_CODE_MND_RETURN_VALUE_NULL;	×
329	if (terrno != 0) code = terrno;	×
330	TAOS_RETURN(code);	×
331	}
332	code = sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);	68,009✔
333
334	TAOS_RETURN(code);	68,009✔
335	}

taosdata / TDengine / #5000

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