diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 23fd858e32..03b456b212 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -169,6 +169,9 @@ typedef enum _mgmt_table {
#define TD_CHILD_TABLE TSDB_CHILD_TABLE
#define TD_NORMAL_TABLE TSDB_NORMAL_TABLE
+#define TD_REQ_FROM_APP 0
+#define TD_REQ_FROM_TAOX 1
+
typedef struct {
int32_t vgId;
char* dbFName;
@@ -432,30 +435,30 @@ static FORCE_INLINE int32_t tDecodeSSchemaWrapperEx(SDecoder* pDecoder, SSchemaW
STSchema* tdGetSTSChemaFromSSChema(SSchema** pSchema, int32_t nCols);
typedef struct {
- char name[TSDB_TABLE_FNAME_LEN];
- int8_t igExists;
- int64_t delay1;
- int64_t delay2;
- int64_t watermark1;
- int64_t watermark2;
- int32_t ttl;
- int32_t numOfColumns;
- int32_t numOfTags;
- int32_t numOfFuncs;
- int32_t commentLen;
- int32_t ast1Len;
- int32_t ast2Len;
- SArray* pColumns; // array of SField
- int32_t cVersion;
- SArray* pTags; // array of SField
- int32_t tVersion;
- SArray* pFuncs;
- char* pComment;
- char* pAst1;
- char* pAst2;
- tb_uid_t suid;
- int8_t source; // 1-taosX or 0-taosClient
- int8_t reserved[8];
+ char name[TSDB_TABLE_FNAME_LEN];
+ int8_t igExists;
+ int8_t source; // 1-taosX or 0-taosClient
+ int8_t reserved[6];
+ tb_uid_t suid;
+ int64_t delay1;
+ int64_t delay2;
+ int64_t watermark1;
+ int64_t watermark2;
+ int32_t ttl;
+ int32_t colVer;
+ int32_t tagVer;
+ int32_t numOfColumns;
+ int32_t numOfTags;
+ int32_t numOfFuncs;
+ int32_t commentLen;
+ int32_t ast1Len;
+ int32_t ast2Len;
+ SArray* pColumns; // array of SField
+ SArray* pTags; // array of SField
+ SArray* pFuncs;
+ char* pComment;
+ char* pAst1;
+ char* pAst2;
} SMCreateStbReq;
int32_t tSerializeSMCreateStbReq(void* buf, int32_t bufLen, SMCreateStbReq* pReq);
@@ -463,11 +466,11 @@ int32_t tDeserializeSMCreateStbReq(void* buf, int32_t bufLen, SMCreateStbReq* pR
void tFreeSMCreateStbReq(SMCreateStbReq* pReq);
typedef struct {
- char name[TSDB_TABLE_FNAME_LEN];
- int8_t igNotExists;
- tb_uid_t suid;
- int8_t source; // 1-taosX or 0-taosClient
- int8_t reserved[8];
+ char name[TSDB_TABLE_FNAME_LEN];
+ int8_t igNotExists;
+ int8_t source; // 1-taosX or 0-taosClient
+ int8_t reserved[6];
+ tb_uid_t suid;
} SMDropStbReq;
int32_t tSerializeSMDropStbReq(void* buf, int32_t bufLen, SMDropStbReq* pReq);
@@ -476,8 +479,6 @@ int32_t tDeserializeSMDropStbReq(void* buf, int32_t bufLen, SMDropStbReq* pReq);
typedef struct {
char name[TSDB_TABLE_FNAME_LEN];
int8_t alterType;
- int32_t tagVer;
- int32_t colVer;
int32_t numOfFields;
SArray* pFields;
int32_t ttl;
diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h
index 1edf41b6f7..cff4b0234c 100644
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@@ -176,7 +176,7 @@ int32_t qGetStreamScanStatus(qTaskInfo_t tinfo, uint64_t* uid, int64_t* ts);
int32_t qStreamPrepareTsdbScan(qTaskInfo_t tinfo, uint64_t uid, int64_t ts);
-int32_t qStreamPrepareScan1(qTaskInfo_t tinfo, const STqOffsetVal* pOffset);
+int32_t qStreamPrepareScan(qTaskInfo_t tinfo, const STqOffsetVal* pOffset);
int32_t qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset);
diff --git a/include/libs/transport/trpc.h b/include/libs/transport/trpc.h
index d59a0a64b3..d8dea8a1be 100644
--- a/include/libs/transport/trpc.h
+++ b/include/libs/transport/trpc.h
@@ -27,7 +27,7 @@ extern "C" {
#define TAOS_CONN_SERVER 0
#define TAOS_CONN_CLIENT 1
-#define IsReq(pMsg) (pMsg->msgType & 1U)
+#define IsReq(pMsg) (pMsg->msgType & 1U)
extern int32_t tsRpcHeadSize;
diff --git a/include/libs/wal/wal.h b/include/libs/wal/wal.h
index 6d9f29906b..9b94864a05 100644
--- a/include/libs/wal/wal.h
+++ b/include/libs/wal/wal.h
@@ -133,6 +133,7 @@ typedef struct {
int64_t curFileFirstVer;
int64_t curVersion;
int64_t capacity;
+ int8_t curInvalid;
TdThreadMutex mutex;
SWalFilterCond cond;
SWalCkHead *pHead;
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index 05d1bd8ae3..ce434612c3 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -247,9 +247,11 @@ int32_t* taosGetErrno();
#define TSDB_CODE_MND_COLUMN_NOT_EXIST TAOS_DEF_ERROR_CODE(0, 0x03AE)
#define TSDB_CODE_MND_FIELD_CONFLICT_WITH_TOPIC TAOS_DEF_ERROR_CODE(0, 0x03AF)
#define TSDB_CODE_MND_SINGLE_STB_MODE_DB TAOS_DEF_ERROR_CODE(0, 0x03B0)
+#define TSDB_CODE_MND_INVALID_SCHEMA_VER TAOS_DEF_ERROR_CODE(0, 0x03B1)
+#define TSDB_CODE_MND_STABLE_UID_NOT_MATCH TAOS_DEF_ERROR_CODE(0, 0x03B2)
// mnode-infoSchema
-#define TSDB_CODE_MND_INVALID_SYS_TABLENAME TAOS_DEF_ERROR_CODE(0, 0x03BA)
+#define TSDB_CODE_MND_INVALID_SYS_TABLENAME TAOS_DEF_ERROR_CODE(0, 0x03BA)
// mnode-func
#define TSDB_CODE_MND_FUNC_ALREADY_EXIST TAOS_DEF_ERROR_CODE(0, 0x03C0)
diff --git a/packaging/tools/install.sh b/packaging/tools/install.sh
index bcc2df4b91..77817e5cf6 100755
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@@ -30,6 +30,7 @@ configDir="/etc/taos"
installDir="/usr/local/taos"
adapterName="taosadapter"
benchmarkName="taosBenchmark"
+tmqName="tmq_sim"
dumpName="taosdump"
demoName="taosdemo"
@@ -205,6 +206,7 @@ function install_bin() {
[ -x ${install_main_dir}/bin/${adapterName} ] && ${csudo}ln -s ${install_main_dir}/bin/${adapterName} ${bin_link_dir}/${adapterName} || :
[ -x ${install_main_dir}/bin/${benchmarkName} ] && ${csudo}ln -s ${install_main_dir}/bin/${benchmarkName} ${bin_link_dir}/${demoName} || :
[ -x ${install_main_dir}/bin/${benchmarkName} ] && ${csudo}ln -s ${install_main_dir}/bin/${benchmarkName} ${bin_link_dir}/${benchmarkName} || :
+ [ -x ${install_main_dir}/bin/${tmqName} ] && ${csudo}ln -s ${install_main_dir}/bin/${tmqName} ${bin_link_dir}/${tmqName} || :
[ -x ${install_main_dir}/bin/${dumpName} ] && ${csudo}ln -s ${install_main_dir}/bin/${dumpName} ${bin_link_dir}/${dumpName} || :
[ -x ${install_main_dir}/bin/TDinsight.sh ] && ${csudo}ln -s ${install_main_dir}/bin/TDinsight.sh ${bin_link_dir}/TDinsight.sh || :
[ -x ${install_main_dir}/bin/remove.sh ] && ${csudo}ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/${uninstallScript} || :
diff --git a/packaging/tools/makepkg.sh b/packaging/tools/makepkg.sh
index 2965a02b49..7edab2141b 100755
--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@@ -60,7 +60,7 @@ if [ "$pagMode" == "lite" ]; then
strip ${build_dir}/bin/${serverName}
strip ${build_dir}/bin/${clientName}
# lite version doesn't include taosadapter, which will lead to no restful interface
- bin_files="${build_dir}/bin/${serverName} ${build_dir}/bin/${clientName} ${script_dir}/remove.sh ${script_dir}/startPre.sh ${build_dir}/bin/taosBenchmark"
+ bin_files="${build_dir}/bin/${serverName} ${build_dir}/bin/${clientName} ${script_dir}/remove.sh ${script_dir}/startPre.sh ${build_dir}/bin/taosBenchmark ${build_dir}/bin/tmq_sim"
taostools_bin_files=""
else
@@ -78,6 +78,7 @@ else
taostools_bin_files=" ${build_dir}/bin/taosdump \
${build_dir}/bin/taosBenchmark \
+ ${build_dir}/bin/tmq_sim \
${build_dir}/bin/TDinsight.sh \
$tdinsight_caches"
diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c
index 48fa2d7938..e2d75d39e3 100644
--- a/source/client/src/clientHb.c
+++ b/source/client/src/clientHb.c
@@ -264,15 +264,12 @@ static int32_t hbQueryHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) {
static int32_t hbAsyncCallBack(void *param, SDataBuf *pMsg, int32_t code) {
static int32_t emptyRspNum = 0;
- if (code != 0) {
- taosMemoryFreeClear(param);
- return -1;
- }
-
char *key = (char *)param;
SClientHbBatchRsp pRsp = {0};
- tDeserializeSClientHbBatchRsp(pMsg->pData, pMsg->len, &pRsp);
-
+ if (TSDB_CODE_SUCCESS == code) {
+ tDeserializeSClientHbBatchRsp(pMsg->pData, pMsg->len, &pRsp);
+ }
+
int32_t rspNum = taosArrayGetSize(pRsp.rsps);
taosThreadMutexLock(&appInfo.mutex);
@@ -288,6 +285,10 @@ static int32_t hbAsyncCallBack(void *param, SDataBuf *pMsg, int32_t code) {
taosMemoryFreeClear(param);
+ if (code != 0) {
+ (*pInst)->onlineDnodes = 0;
+ }
+
if (rspNum) {
tscDebug("hb got %d rsp, %d empty rsp received before", rspNum,
atomic_val_compare_exchange_32(&emptyRspNum, emptyRspNum, 0));
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index bff65d3527..6fb3d98027 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -325,11 +325,13 @@ int32_t updateQnodeList(SAppInstInfo* pInfo, SArray* pNodeList) {
if (pInfo->pQnodeList) {
taosArrayDestroy(pInfo->pQnodeList);
pInfo->pQnodeList = NULL;
+ tscDebug("QnodeList cleared in cluster 0x%" PRIx64, pInfo->clusterId);
}
if (pNodeList) {
pInfo->pQnodeList = taosArrayDup(pNodeList);
taosArraySort(pInfo->pQnodeList, compareQueryNodeLoad);
+ tscDebug("QnodeList updated in cluster 0x%" PRIx64 ", num:%d", pInfo->clusterId, taosArrayGetSize(pInfo->pQnodeList));
}
taosThreadMutexUnlock(&pInfo->qnodeMutex);
diff --git a/source/client/src/tmq.c b/source/client/src/tmq.c
index 6710f73fc6..652c1205fc 100644
--- a/source/client/src/tmq.c
+++ b/source/client/src/tmq.c
@@ -13,6 +13,7 @@
* along with this program. If not, see .
*/
+#include "cJSON.h"
#include "clientInt.h"
#include "clientLog.h"
#include "parser.h"
@@ -23,7 +24,6 @@
#include "tqueue.h"
#include "tref.h"
#include "ttimer.h"
-#include "cJSON.h"
int32_t tmqAskEp(tmq_t* tmq, bool async);
@@ -106,8 +106,8 @@ struct tmq_t {
tsem_t rspSem;
};
-struct tmq_raw_data{
- void *raw_meta;
+struct tmq_raw_data {
+ void* raw_meta;
int32_t raw_meta_len;
int16_t raw_meta_type;
};
@@ -953,6 +953,8 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
goto FAIL;
}
+ tscInfo("consumer %ld is setup, consumer group %s", pTmq->consumerId, pTmq->groupId);
+
return pTmq;
FAIL:
@@ -1194,10 +1196,10 @@ bool tmqUpdateEp2(tmq_t* tmq, int32_t epoch, SMqAskEpRsp* pRsp) {
for (int32_t j = 0; j < vgNumCur; j++) {
SMqClientVg* pVgCur = taosArrayGet(pTopicCur->vgs, j);
sprintf(vgKey, "%s:%d", pTopicCur->topicName, pVgCur->vgId);
- char buf[50];
- tFormatOffset(buf, 50, &pVgCur->currentOffsetNew);
- tscDebug("consumer:%" PRId64 ", epoch %d vgId:%d vgKey is %s, offset is %s", tmq->consumerId, epoch, pVgCur->vgId,
- vgKey, buf);
+ char buf[80];
+ tFormatOffset(buf, 80, &pVgCur->currentOffsetNew);
+ tscDebug("consumer:%" PRId64 ", epoch %d vgId:%d vgKey is %s, offset is %s", tmq->consumerId, epoch,
+ pVgCur->vgId, vgKey, buf);
taosHashPut(pHash, vgKey, strlen(vgKey), &pVgCur->currentOffsetNew, sizeof(STqOffsetVal));
}
}
@@ -1564,7 +1566,8 @@ int32_t tmqPollImpl(tmq_t* tmq, int64_t timeout) {
int32_t vgStatus = atomic_val_compare_exchange_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE, TMQ_VG_STATUS__WAIT);
if (vgStatus != TMQ_VG_STATUS__IDLE) {
int32_t vgSkipCnt = atomic_add_fetch_32(&pVg->vgSkipCnt, 1);
- tscTrace("consumer:%" PRId64 ", epoch %d skip vgId:%d skip cnt %d", tmq->consumerId, tmq->epoch, pVg->vgId, vgSkipCnt);
+ tscTrace("consumer:%" PRId64 ", epoch %d skip vgId:%d skip cnt %d", tmq->consumerId, tmq->epoch, pVg->vgId,
+ vgSkipCnt);
continue;
/*if (vgSkipCnt < 10000) continue;*/
#if 0
@@ -1620,8 +1623,8 @@ int32_t tmqPollImpl(tmq_t* tmq, int64_t timeout) {
char offsetFormatBuf[80];
tFormatOffset(offsetFormatBuf, 80, &pVg->currentOffsetNew);
- tscDebug("consumer:%" PRId64 ", send poll to %s vgId:%d, epoch %d, req offset:%s, reqId:%" PRIu64, tmq->consumerId,
- pTopic->topicName, pVg->vgId, tmq->epoch, offsetFormatBuf, pReq->reqId);
+ tscDebug("consumer:%" PRId64 ", send poll to %s vgId:%d, epoch %d, req offset:%s, reqId:%" PRIu64,
+ tmq->consumerId, pTopic->topicName, pVg->vgId, tmq->epoch, offsetFormatBuf, pReq->reqId);
/*printf("send vgId:%d %" PRId64 "\n", pVg->vgId, pVg->currentOffset);*/
asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &pVg->epSet, &transporterId, sendInfo);
pVg->pollCnt++;
@@ -1669,7 +1672,8 @@ void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout, bool pollIfReset) {
int32_t consumerEpoch = atomic_load_32(&tmq->epoch);
if (pollRspWrapper->dataRsp.head.epoch == consumerEpoch) {
SMqClientVg* pVg = pollRspWrapper->vgHandle;
- /*printf("vgId:%d offset %" PRId64 " up to %" PRId64 "\n", pVg->vgId, pVg->currentOffset, rspMsg->msg.rspOffset);*/
+ /*printf("vgId:%d offset %" PRId64 " up to %" PRId64 "\n", pVg->vgId, pVg->currentOffset,
+ * rspMsg->msg.rspOffset);*/
pVg->currentOffsetNew = pollRspWrapper->dataRsp.rspOffset;
atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
if (pollRspWrapper->dataRsp.blockNum == 0) {
@@ -1691,7 +1695,8 @@ void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout, bool pollIfReset) {
int32_t consumerEpoch = atomic_load_32(&tmq->epoch);
if (pollRspWrapper->metaRsp.head.epoch == consumerEpoch) {
SMqClientVg* pVg = pollRspWrapper->vgHandle;
- /*printf("vgId:%d offset %" PRId64 " up to %" PRId64 "\n", pVg->vgId, pVg->currentOffset, rspMsg->msg.rspOffset);*/
+ /*printf("vgId:%d offset %" PRId64 " up to %" PRId64 "\n", pVg->vgId, pVg->currentOffset,
+ * rspMsg->msg.rspOffset);*/
pVg->currentOffsetNew.version = pollRspWrapper->metaRsp.rspOffset;
pVg->currentOffsetNew.type = TMQ_OFFSET__LOG;
atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
@@ -1848,9 +1853,9 @@ const char* tmq_get_table_name(TAOS_RES* res) {
return NULL;
}
-tmq_raw_data *tmq_get_raw_meta(TAOS_RES* res) {
+tmq_raw_data* tmq_get_raw_meta(TAOS_RES* res) {
if (TD_RES_TMQ_META(res)) {
- tmq_raw_data *raw = taosMemoryCalloc(1, sizeof(tmq_raw_data));
+ tmq_raw_data* raw = taosMemoryCalloc(1, sizeof(tmq_raw_data));
SMqMetaRspObj* pMetaRspObj = (SMqMetaRspObj*)res;
raw->raw_meta = pMetaRspObj->metaRsp.metaRsp;
raw->raw_meta_len = pMetaRspObj->metaRsp.metaRspLen;
@@ -1860,7 +1865,8 @@ tmq_raw_data *tmq_get_raw_meta(TAOS_RES* res) {
return NULL;
}
-static char *buildCreateTableJson(SSchemaWrapper *schemaRow, SSchemaWrapper* schemaTag, char* name, int64_t id, int8_t t){
+static char* buildCreateTableJson(SSchemaWrapper* schemaRow, SSchemaWrapper* schemaTag, char* name, int64_t id,
+ int8_t t) {
char* string = NULL;
cJSON* json = cJSON_CreateObject();
if (json == NULL) {
@@ -1870,31 +1876,31 @@ static char *buildCreateTableJson(SSchemaWrapper *schemaRow, SSchemaWrapper* sch
cJSON_AddItemToObject(json, "type", type);
char uid[32] = {0};
- sprintf(uid, "%"PRIi64, id);
+ sprintf(uid, "%" PRIi64, id);
cJSON* id_ = cJSON_CreateString(uid);
cJSON_AddItemToObject(json, "id", id_);
cJSON* tableName = cJSON_CreateString(name);
cJSON_AddItemToObject(json, "tableName", tableName);
cJSON* tableType = cJSON_CreateString(t == TSDB_NORMAL_TABLE ? "normal" : "super");
cJSON_AddItemToObject(json, "tableType", tableType);
-// cJSON* version = cJSON_CreateNumber(1);
-// cJSON_AddItemToObject(json, "version", version);
+ // cJSON* version = cJSON_CreateNumber(1);
+ // cJSON_AddItemToObject(json, "version", version);
cJSON* columns = cJSON_CreateArray();
- for(int i = 0; i < schemaRow->nCols; i++){
- cJSON* column = cJSON_CreateObject();
- SSchema *s = schemaRow->pSchema + i;
- cJSON* cname = cJSON_CreateString(s->name);
+ for (int i = 0; i < schemaRow->nCols; i++) {
+ cJSON* column = cJSON_CreateObject();
+ SSchema* s = schemaRow->pSchema + i;
+ cJSON* cname = cJSON_CreateString(s->name);
cJSON_AddItemToObject(column, "name", cname);
cJSON* ctype = cJSON_CreateNumber(s->type);
cJSON_AddItemToObject(column, "type", ctype);
- if(s->type == TSDB_DATA_TYPE_BINARY){
+ if (s->type == TSDB_DATA_TYPE_BINARY) {
int32_t length = s->bytes - VARSTR_HEADER_SIZE;
- cJSON* cbytes = cJSON_CreateNumber(length);
+ cJSON* cbytes = cJSON_CreateNumber(length);
cJSON_AddItemToObject(column, "length", cbytes);
- }else if (s->type == TSDB_DATA_TYPE_NCHAR){
- int32_t length = (s->bytes - VARSTR_HEADER_SIZE)/TSDB_NCHAR_SIZE;
- cJSON* cbytes = cJSON_CreateNumber(length);
+ } else if (s->type == TSDB_DATA_TYPE_NCHAR) {
+ int32_t length = (s->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
+ cJSON* cbytes = cJSON_CreateNumber(length);
cJSON_AddItemToObject(column, "length", cbytes);
}
cJSON_AddItemToArray(columns, column);
@@ -1902,20 +1908,20 @@ static char *buildCreateTableJson(SSchemaWrapper *schemaRow, SSchemaWrapper* sch
cJSON_AddItemToObject(json, "columns", columns);
cJSON* tags = cJSON_CreateArray();
- for(int i = 0; schemaTag && i < schemaTag->nCols; i++){
- cJSON* tag = cJSON_CreateObject();
- SSchema *s = schemaTag->pSchema + i;
- cJSON* tname = cJSON_CreateString(s->name);
+ for (int i = 0; schemaTag && i < schemaTag->nCols; i++) {
+ cJSON* tag = cJSON_CreateObject();
+ SSchema* s = schemaTag->pSchema + i;
+ cJSON* tname = cJSON_CreateString(s->name);
cJSON_AddItemToObject(tag, "name", tname);
cJSON* ttype = cJSON_CreateNumber(s->type);
cJSON_AddItemToObject(tag, "type", ttype);
- if(s->type == TSDB_DATA_TYPE_BINARY){
+ if (s->type == TSDB_DATA_TYPE_BINARY) {
int32_t length = s->bytes - VARSTR_HEADER_SIZE;
- cJSON* cbytes = cJSON_CreateNumber(length);
+ cJSON* cbytes = cJSON_CreateNumber(length);
cJSON_AddItemToObject(tag, "length", cbytes);
- }else if (s->type == TSDB_DATA_TYPE_NCHAR){
- int32_t length = (s->bytes - VARSTR_HEADER_SIZE)/TSDB_NCHAR_SIZE;
- cJSON* cbytes = cJSON_CreateNumber(length);
+ } else if (s->type == TSDB_DATA_TYPE_NCHAR) {
+ int32_t length = (s->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
+ cJSON* cbytes = cJSON_CreateNumber(length);
cJSON_AddItemToObject(tag, "length", cbytes);
}
cJSON_AddItemToArray(tags, tag);
@@ -1927,13 +1933,13 @@ static char *buildCreateTableJson(SSchemaWrapper *schemaRow, SSchemaWrapper* sch
return string;
}
-static char *processCreateStb(SMqMetaRsp *metaRsp){
+static char* processCreateStb(SMqMetaRsp* metaRsp) {
SVCreateStbReq req = {0};
SDecoder coder;
- char* string = NULL;
+ char* string = NULL;
// decode and process req
- void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
int32_t len = metaRsp->metaRspLen - sizeof(SMsgHead);
tDecoderInit(&coder, data, len);
@@ -1949,7 +1955,7 @@ _err:
return string;
}
-static char *buildCreateCTableJson(STag* pTag, int64_t sid, char* name, int64_t id){
+static char* buildCreateCTableJson(STag* pTag, int64_t sid, char* name, int64_t id) {
char* string = NULL;
cJSON* json = cJSON_CreateObject();
if (json == NULL) {
@@ -1958,7 +1964,7 @@ static char *buildCreateCTableJson(STag* pTag, int64_t sid, char* name, int64_t
cJSON* type = cJSON_CreateString("create");
cJSON_AddItemToObject(json, "type", type);
char cid[32] = {0};
- sprintf(cid, "%"PRIi64, id);
+ sprintf(cid, "%" PRIi64, id);
cJSON* cid_ = cJSON_CreateString(cid);
cJSON_AddItemToObject(json, "id", cid_);
@@ -1968,19 +1974,19 @@ static char *buildCreateCTableJson(STag* pTag, int64_t sid, char* name, int64_t
cJSON_AddItemToObject(json, "tableType", tableType);
char sid_[32] = {0};
- sprintf(sid_, "%"PRIi64, sid);
+ sprintf(sid_, "%" PRIi64, sid);
cJSON* using = cJSON_CreateString(sid_);
cJSON_AddItemToObject(json, "using", using);
-// cJSON* version = cJSON_CreateNumber(1);
-// cJSON_AddItemToObject(json, "version", version);
+ // cJSON* version = cJSON_CreateNumber(1);
+ // cJSON_AddItemToObject(json, "version", version);
cJSON* tags = cJSON_CreateArray();
- if (tTagIsJson(pTag)) { // todo
+ if (tTagIsJson(pTag)) { // todo
char* pJson = parseTagDatatoJson(pTag);
cJSON* tag = cJSON_CreateObject();
- cJSON* tname = cJSON_CreateString("unknown"); // todo
+ cJSON* tname = cJSON_CreateString("unknown"); // todo
cJSON_AddItemToObject(tag, "name", tname);
cJSON* ttype = cJSON_CreateNumber(TSDB_DATA_TYPE_JSON);
cJSON_AddItemToObject(tag, "type", ttype);
@@ -1999,12 +2005,12 @@ static char *buildCreateCTableJson(STag* pTag, int64_t sid, char* name, int64_t
goto end;
}
- for(int i = 0; i < taosArrayGetSize(pTagVals); i++){
+ for (int i = 0; i < taosArrayGetSize(pTagVals); i++) {
STagVal* pTagVal = (STagVal*)taosArrayGet(pTagVals, i);
cJSON* tag = cJSON_CreateObject();
-// cJSON* tname = cJSON_CreateNumber(pTagVal->cid);
- cJSON* tname = cJSON_CreateString("unkonwn"); // todo
+ // cJSON* tname = cJSON_CreateNumber(pTagVal->cid);
+ cJSON* tname = cJSON_CreateString("unkonwn"); // todo
cJSON_AddItemToObject(tag, "name", tname);
cJSON* ttype = cJSON_CreateNumber(pTagVal->type);
cJSON_AddItemToObject(tag, "type", ttype);
@@ -2032,13 +2038,13 @@ end:
return string;
}
-static char *processCreateTable(SMqMetaRsp *metaRsp){
+static char* processCreateTable(SMqMetaRsp* metaRsp) {
SDecoder decoder = {0};
SVCreateTbBatchReq req = {0};
- SVCreateTbReq *pCreateReq;
- char *string = NULL;
+ SVCreateTbReq* pCreateReq;
+ char* string = NULL;
// decode
- void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
int32_t len = metaRsp->metaRspLen - sizeof(SMsgHead);
tDecoderInit(&decoder, data, len);
if (tDecodeSVCreateTbBatchReq(&decoder, &req) < 0) {
@@ -2048,27 +2054,29 @@ static char *processCreateTable(SMqMetaRsp *metaRsp){
// loop to create table
for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
pCreateReq = req.pReqs + iReq;
- if(pCreateReq->type == TSDB_CHILD_TABLE){
- string = buildCreateCTableJson((STag*)pCreateReq->ctb.pTag, pCreateReq->ctb.suid, pCreateReq->name, pCreateReq->uid);
- }else if(pCreateReq->type == TSDB_NORMAL_TABLE){
- string = buildCreateTableJson(&pCreateReq->ntb.schemaRow, NULL, pCreateReq->name, pCreateReq->uid, TSDB_NORMAL_TABLE);
+ if (pCreateReq->type == TSDB_CHILD_TABLE) {
+ string =
+ buildCreateCTableJson((STag*)pCreateReq->ctb.pTag, pCreateReq->ctb.suid, pCreateReq->name, pCreateReq->uid);
+ } else if (pCreateReq->type == TSDB_NORMAL_TABLE) {
+ string =
+ buildCreateTableJson(&pCreateReq->ntb.schemaRow, NULL, pCreateReq->name, pCreateReq->uid, TSDB_NORMAL_TABLE);
}
}
tDecoderClear(&decoder);
- _exit:
+_exit:
tDecoderClear(&decoder);
return string;
}
-static char *processAlterTable(SMqMetaRsp *metaRsp){
- SDecoder decoder = {0};
- SVAlterTbReq vAlterTbReq = {0};
- char *string = NULL;
+static char* processAlterTable(SMqMetaRsp* metaRsp) {
+ SDecoder decoder = {0};
+ SVAlterTbReq vAlterTbReq = {0};
+ char* string = NULL;
// decode
- void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
int32_t len = metaRsp->metaRspLen - sizeof(SMsgHead);
tDecoderInit(&decoder, data, len);
if (tDecodeSVAlterTbReq(&decoder, &vAlterTbReq) < 0) {
@@ -2081,8 +2089,8 @@ static char *processAlterTable(SMqMetaRsp *metaRsp){
}
cJSON* type = cJSON_CreateString("alter");
cJSON_AddItemToObject(json, "type", type);
-// cJSON* uid = cJSON_CreateNumber(id);
-// cJSON_AddItemToObject(json, "uid", uid);
+ // cJSON* uid = cJSON_CreateNumber(id);
+ // cJSON_AddItemToObject(json, "uid", uid);
cJSON* tableName = cJSON_CreateString(vAlterTbReq.tbName);
cJSON_AddItemToObject(json, "tableName", tableName);
cJSON* tableType = cJSON_CreateString(vAlterTbReq.action == TSDB_ALTER_TABLE_UPDATE_TAG_VAL ? "child" : "normal");
@@ -2097,43 +2105,43 @@ static char *processAlterTable(SMqMetaRsp *metaRsp){
cJSON* colType = cJSON_CreateNumber(vAlterTbReq.type);
cJSON_AddItemToObject(json, "colType", colType);
- if(vAlterTbReq.type == TSDB_DATA_TYPE_BINARY){
+ if (vAlterTbReq.type == TSDB_DATA_TYPE_BINARY) {
int32_t length = vAlterTbReq.bytes - VARSTR_HEADER_SIZE;
- cJSON* cbytes = cJSON_CreateNumber(length);
+ cJSON* cbytes = cJSON_CreateNumber(length);
cJSON_AddItemToObject(json, "colLength", cbytes);
- }else if (vAlterTbReq.type == TSDB_DATA_TYPE_NCHAR){
- int32_t length = (vAlterTbReq.bytes - VARSTR_HEADER_SIZE)/TSDB_NCHAR_SIZE;
- cJSON* cbytes = cJSON_CreateNumber(length);
+ } else if (vAlterTbReq.type == TSDB_DATA_TYPE_NCHAR) {
+ int32_t length = (vAlterTbReq.bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
+ cJSON* cbytes = cJSON_CreateNumber(length);
cJSON_AddItemToObject(json, "colLength", cbytes);
}
break;
}
- case TSDB_ALTER_TABLE_DROP_COLUMN:{
+ case TSDB_ALTER_TABLE_DROP_COLUMN: {
cJSON* alterType = cJSON_CreateNumber(TSDB_ALTER_TABLE_DROP_COLUMN);
cJSON_AddItemToObject(json, "alterType", alterType);
cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
cJSON_AddItemToObject(json, "colName", colName);
break;
}
- case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:{
+ case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES: {
cJSON* alterType = cJSON_CreateNumber(TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES);
cJSON_AddItemToObject(json, "alterType", alterType);
cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
cJSON_AddItemToObject(json, "colName", colName);
cJSON* colType = cJSON_CreateNumber(vAlterTbReq.type);
cJSON_AddItemToObject(json, "colType", colType);
- if(vAlterTbReq.type == TSDB_DATA_TYPE_BINARY){
+ if (vAlterTbReq.type == TSDB_DATA_TYPE_BINARY) {
int32_t length = vAlterTbReq.bytes - VARSTR_HEADER_SIZE;
- cJSON* cbytes = cJSON_CreateNumber(length);
+ cJSON* cbytes = cJSON_CreateNumber(length);
cJSON_AddItemToObject(json, "colLength", cbytes);
- }else if (vAlterTbReq.type == TSDB_DATA_TYPE_NCHAR){
- int32_t length = (vAlterTbReq.bytes - VARSTR_HEADER_SIZE)/TSDB_NCHAR_SIZE;
- cJSON* cbytes = cJSON_CreateNumber(length);
+ } else if (vAlterTbReq.type == TSDB_DATA_TYPE_NCHAR) {
+ int32_t length = (vAlterTbReq.bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
+ cJSON* cbytes = cJSON_CreateNumber(length);
cJSON_AddItemToObject(json, "colLength", cbytes);
}
break;
}
- case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME:{
+ case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME: {
cJSON* alterType = cJSON_CreateNumber(TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME);
cJSON_AddItemToObject(json, "alterType", alterType);
cJSON* colName = cJSON_CreateString(vAlterTbReq.colName);
@@ -2142,12 +2150,12 @@ static char *processAlterTable(SMqMetaRsp *metaRsp){
cJSON_AddItemToObject(json, "colNewName", colNewName);
break;
}
- case TSDB_ALTER_TABLE_UPDATE_TAG_VAL:{
+ case TSDB_ALTER_TABLE_UPDATE_TAG_VAL: {
cJSON* alterType = cJSON_CreateNumber(TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
cJSON_AddItemToObject(json, "alterType", alterType);
cJSON* tagName = cJSON_CreateString(vAlterTbReq.tagName);
cJSON_AddItemToObject(json, "colName", tagName);
- cJSON* colValue = cJSON_CreateString("invalid, todo"); // todo
+ cJSON* colValue = cJSON_CreateString("invalid, todo"); // todo
cJSON_AddItemToObject(json, "colValue", colValue);
cJSON* isNull = cJSON_CreateBool(vAlterTbReq.isNull);
cJSON_AddItemToObject(json, "colValueNull", isNull);
@@ -2158,18 +2166,18 @@ static char *processAlterTable(SMqMetaRsp *metaRsp){
}
string = cJSON_PrintUnformatted(json);
- _exit:
+_exit:
tDecoderClear(&decoder);
return string;
}
-static char *processDropSTable(SMqMetaRsp *metaRsp){
- SDecoder decoder = {0};
- SVDropStbReq req = {0};
- char *string = NULL;
+static char* processDropSTable(SMqMetaRsp* metaRsp) {
+ SDecoder decoder = {0};
+ SVDropStbReq req = {0};
+ char* string = NULL;
// decode
- void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
int32_t len = metaRsp->metaRspLen - sizeof(SMsgHead);
tDecoderInit(&decoder, data, len);
if (tDecodeSVDropStbReq(&decoder, &req) < 0) {
@@ -2183,7 +2191,7 @@ static char *processDropSTable(SMqMetaRsp *metaRsp){
cJSON* type = cJSON_CreateString("drop");
cJSON_AddItemToObject(json, "type", type);
char uid[32] = {0};
- sprintf(uid, "%"PRIi64, req.suid);
+ sprintf(uid, "%" PRIi64, req.suid);
cJSON* id = cJSON_CreateString(uid);
cJSON_AddItemToObject(json, "id", id);
cJSON* tableName = cJSON_CreateString(req.name);
@@ -2193,18 +2201,18 @@ static char *processDropSTable(SMqMetaRsp *metaRsp){
string = cJSON_PrintUnformatted(json);
- _exit:
+_exit:
tDecoderClear(&decoder);
return string;
}
-static char *processDropTable(SMqMetaRsp *metaRsp){
- SDecoder decoder = {0};
- SVDropTbBatchReq req = {0};
- char *string = NULL;
+static char* processDropTable(SMqMetaRsp* metaRsp) {
+ SDecoder decoder = {0};
+ SVDropTbBatchReq req = {0};
+ char* string = NULL;
// decode
- void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
int32_t len = metaRsp->metaRspLen - sizeof(SMsgHead);
tDecoderInit(&decoder, data, len);
if (tDecodeSVDropTbBatchReq(&decoder, &req) < 0) {
@@ -2217,57 +2225,57 @@ static char *processDropTable(SMqMetaRsp *metaRsp){
}
cJSON* type = cJSON_CreateString("drop");
cJSON_AddItemToObject(json, "type", type);
-// cJSON* uid = cJSON_CreateNumber(id);
-// cJSON_AddItemToObject(json, "uid", uid);
-// cJSON* tableType = cJSON_CreateString("normal");
-// cJSON_AddItemToObject(json, "tableType", tableType);
+ // cJSON* uid = cJSON_CreateNumber(id);
+ // cJSON_AddItemToObject(json, "uid", uid);
+ // cJSON* tableType = cJSON_CreateString("normal");
+ // cJSON_AddItemToObject(json, "tableType", tableType);
cJSON* tableNameList = cJSON_CreateArray();
for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
SVDropTbReq* pDropTbReq = req.pReqs + iReq;
- cJSON* tableName = cJSON_CreateString(pDropTbReq->name); // todo
+ cJSON* tableName = cJSON_CreateString(pDropTbReq->name); // todo
cJSON_AddItemToArray(tableNameList, tableName);
}
cJSON_AddItemToObject(json, "tableNameList", tableNameList);
string = cJSON_PrintUnformatted(json);
- _exit:
+_exit:
tDecoderClear(&decoder);
return string;
}
-char *tmq_get_json_meta(TAOS_RES *res){
+char* tmq_get_json_meta(TAOS_RES* res) {
if (!TD_RES_TMQ_META(res)) {
return NULL;
}
SMqMetaRspObj* pMetaRspObj = (SMqMetaRspObj*)res;
- if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_CREATE_STB){
+ if (pMetaRspObj->metaRsp.resMsgType == TDMT_VND_CREATE_STB) {
return processCreateStb(&pMetaRspObj->metaRsp);
- }else if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_ALTER_STB){
+ } else if (pMetaRspObj->metaRsp.resMsgType == TDMT_VND_ALTER_STB) {
return processCreateStb(&pMetaRspObj->metaRsp);
- }else if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_DROP_STB){
+ } else if (pMetaRspObj->metaRsp.resMsgType == TDMT_VND_DROP_STB) {
return processDropSTable(&pMetaRspObj->metaRsp);
- }else if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_CREATE_TABLE){
+ } else if (pMetaRspObj->metaRsp.resMsgType == TDMT_VND_CREATE_TABLE) {
return processCreateTable(&pMetaRspObj->metaRsp);
- }else if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_ALTER_TABLE){
+ } else if (pMetaRspObj->metaRsp.resMsgType == TDMT_VND_ALTER_TABLE) {
return processAlterTable(&pMetaRspObj->metaRsp);
- }else if(pMetaRspObj->metaRsp.resMsgType == TDMT_VND_DROP_TABLE){
+ } else if (pMetaRspObj->metaRsp.resMsgType == TDMT_VND_DROP_TABLE) {
return processDropTable(&pMetaRspObj->metaRsp);
}
return NULL;
}
-static int32_t taosCreateStb(TAOS *taos, void *meta, int32_t metaLen){
+static int32_t taosCreateStb(TAOS* taos, void* meta, int32_t metaLen) {
SVCreateStbReq req = {0};
SDecoder coder;
SMCreateStbReq pReq = {0};
- int32_t code = TSDB_CODE_SUCCESS;
- SRequestObj* pRequest = NULL;
+ int32_t code = TSDB_CODE_SUCCESS;
+ SRequestObj* pRequest = NULL;
- STscObj *pTscObj = acquireTscObj(*(int64_t *)taos);
+ STscObj* pTscObj = acquireTscObj(*(int64_t*)taos);
if (NULL == pTscObj) {
code = TSDB_CODE_TSC_DISCONNECTED;
goto end;
@@ -2278,12 +2286,12 @@ static int32_t taosCreateStb(TAOS *taos, void *meta, int32_t metaLen){
goto end;
}
- if(!pRequest->pDb){
+ if (!pRequest->pDb) {
code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
goto end;
}
// decode and process req
- void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
int32_t len = metaLen - sizeof(SMsgHead);
tDecoderInit(&coder, data, len);
if (tDecodeSVCreateStbReq(&coder, &req) < 0) {
@@ -2292,21 +2300,21 @@ static int32_t taosCreateStb(TAOS *taos, void *meta, int32_t metaLen){
}
// build create stable
pReq.pColumns = taosArrayInit(req.schemaRow.nCols, sizeof(SField));
- for(int32_t i = 0; i < req.schemaRow.nCols; i++){
+ for (int32_t i = 0; i < req.schemaRow.nCols; i++) {
SSchema* pSchema = req.schemaRow.pSchema + i;
- SField field = {.type = pSchema->type, .bytes = pSchema->bytes};
+ SField field = {.type = pSchema->type, .bytes = pSchema->bytes};
strcpy(field.name, pSchema->name);
taosArrayPush(pReq.pColumns, &field);
}
pReq.pTags = taosArrayInit(req.schemaTag.nCols, sizeof(SField));
- for(int32_t i = 0; i < req.schemaTag.nCols; i++){
+ for (int32_t i = 0; i < req.schemaTag.nCols; i++) {
SSchema* pSchema = req.schemaTag.pSchema + i;
- SField field = {.type = pSchema->type, .bytes = pSchema->bytes};
+ SField field = {.type = pSchema->type, .bytes = pSchema->bytes};
strcpy(field.name, pSchema->name);
taosArrayPush(pReq.pTags, &field);
}
- pReq.cVersion = req.schemaRow.version;
- pReq.tVersion = req.schemaTag.version;
+ pReq.colVer = req.schemaRow.version;
+ pReq.tagVer = req.schemaTag.version;
pReq.numOfColumns = req.schemaRow.nCols;
pReq.numOfTags = req.schemaTag.nCols;
pReq.commentLen = -1;
@@ -2327,7 +2335,7 @@ static int32_t taosCreateStb(TAOS *taos, void *meta, int32_t metaLen){
}
tSerializeSMCreateStbReq(pCmdMsg.pMsg, pCmdMsg.msgLen, &pReq);
- SQuery pQuery = {0};
+ SQuery pQuery = {0};
pQuery.execMode = QUERY_EXEC_MODE_RPC;
pQuery.pCmdMsg = &pCmdMsg;
pQuery.msgType = pQuery.pCmdMsg->msgType;
@@ -2337,21 +2345,21 @@ static int32_t taosCreateStb(TAOS *taos, void *meta, int32_t metaLen){
code = pRequest->code;
taosMemoryFree(pCmdMsg.pMsg);
- end:
+end:
destroyRequest(pRequest);
tFreeSMCreateStbReq(&pReq);
tDecoderClear(&coder);
return code;
}
-static int32_t taosDropStb(TAOS *taos, void *meta, int32_t metaLen){
+static int32_t taosDropStb(TAOS* taos, void* meta, int32_t metaLen) {
SVDropStbReq req = {0};
SDecoder coder;
SMDropStbReq pReq = {0};
- int32_t code = TSDB_CODE_SUCCESS;
+ int32_t code = TSDB_CODE_SUCCESS;
SRequestObj* pRequest = NULL;
- STscObj *pTscObj = acquireTscObj(*(int64_t *)taos);
+ STscObj* pTscObj = acquireTscObj(*(int64_t*)taos);
if (NULL == pTscObj) {
code = TSDB_CODE_TSC_DISCONNECTED;
goto end;
@@ -2362,12 +2370,12 @@ static int32_t taosDropStb(TAOS *taos, void *meta, int32_t metaLen){
goto end;
}
- if(!pRequest->pDb){
+ if (!pRequest->pDb) {
code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
goto end;
}
// decode and process req
- void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
int32_t len = metaLen - sizeof(SMsgHead);
tDecoderInit(&coder, data, len);
if (tDecodeSVDropStbReq(&coder, &req) < 0) {
@@ -2393,7 +2401,7 @@ static int32_t taosDropStb(TAOS *taos, void *meta, int32_t metaLen){
}
tSerializeSMDropStbReq(pCmdMsg.pMsg, pCmdMsg.msgLen, &pReq);
- SQuery pQuery = {0};
+ SQuery pQuery = {0};
pQuery.execMode = QUERY_EXEC_MODE_RPC;
pQuery.pCmdMsg = &pCmdMsg;
pQuery.msgType = pQuery.pCmdMsg->msgType;
@@ -2403,7 +2411,7 @@ static int32_t taosDropStb(TAOS *taos, void *meta, int32_t metaLen){
code = pRequest->code;
taosMemoryFree(pCmdMsg.pMsg);
- end:
+end:
destroyRequest(pRequest);
tDecoderClear(&coder);
return code;
@@ -2416,18 +2424,18 @@ typedef struct SVgroupCreateTableBatch {
} SVgroupCreateTableBatch;
static void destroyCreateTbReqBatch(void* data) {
- SVgroupCreateTableBatch* pTbBatch = (SVgroupCreateTableBatch*) data;
+ SVgroupCreateTableBatch* pTbBatch = (SVgroupCreateTableBatch*)data;
taosArrayDestroy(pTbBatch->req.pArray);
}
-static int32_t taosCreateTable(TAOS *taos, void *meta, int32_t metaLen){
- SVCreateTbBatchReq req = {0};
- SDecoder coder = {0};
- int32_t code = TSDB_CODE_SUCCESS;
- SRequestObj *pRequest = NULL;
- SQuery *pQuery = NULL;
- SHashObj *pVgroupHashmap = NULL;
- STscObj *pTscObj = acquireTscObj(*(int64_t *)taos);
+static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) {
+ SVCreateTbBatchReq req = {0};
+ SDecoder coder = {0};
+ int32_t code = TSDB_CODE_SUCCESS;
+ SRequestObj* pRequest = NULL;
+ SQuery* pQuery = NULL;
+ SHashObj* pVgroupHashmap = NULL;
+ STscObj* pTscObj = acquireTscObj(*(int64_t*)taos);
if (NULL == pTscObj) {
code = TSDB_CODE_TSC_DISCONNECTED;
@@ -2439,12 +2447,12 @@ static int32_t taosCreateTable(TAOS *taos, void *meta, int32_t metaLen){
goto end;
}
- if(!pRequest->pDb){
+ if (!pRequest->pDb) {
code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
goto end;
}
// decode and process req
- void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
int32_t len = metaLen - sizeof(SMsgHead);
tDecoderInit(&coder, data, len);
if (tDecodeSVCreateTbBatchReq(&coder, &req) < 0) {
@@ -2452,8 +2460,8 @@ static int32_t taosCreateTable(TAOS *taos, void *meta, int32_t metaLen){
goto end;
}
- SVCreateTbReq *pCreateReq = NULL;
- SCatalog* pCatalog = NULL;
+ SVCreateTbReq* pCreateReq = NULL;
+ SCatalog* pCatalog = NULL;
code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &pCatalog);
if (code != TSDB_CODE_SUCCESS) {
goto end;
@@ -2467,15 +2475,15 @@ static int32_t taosCreateTable(TAOS *taos, void *meta, int32_t metaLen){
taosHashSetFreeFp(pVgroupHashmap, destroyCreateTbReqBatch);
SRequestConnInfo conn = {.pTrans = pTscObj->pAppInfo->pTransporter,
- .requestId = pRequest->requestId,
- .requestObjRefId = pRequest->self,
- .mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp)};
+ .requestId = pRequest->requestId,
+ .requestObjRefId = pRequest->self,
+ .mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp)};
// loop to create table
for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
pCreateReq = req.pReqs + iReq;
SVgroupInfo pInfo = {0};
- SName pName;
+ SName pName;
toName(pTscObj->acctId, pRequest->pDb, pCreateReq->name, &pName);
code = catalogGetTableHashVgroup(pCatalog, &conn, &pName, &pInfo);
if (code != TSDB_CODE_SUCCESS) {
@@ -2507,7 +2515,7 @@ static int32_t taosCreateTable(TAOS *taos, void *meta, int32_t metaLen){
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->msgType = TDMT_VND_CREATE_TABLE;
pQuery->stableQuery = false;
- pQuery->pRoot = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT);
+ pQuery->pRoot = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT);
code = rewriteToVnodeModifyOpStmt(pQuery, pBufArray);
if (code != TSDB_CODE_SUCCESS) {
@@ -2515,10 +2523,10 @@ static int32_t taosCreateTable(TAOS *taos, void *meta, int32_t metaLen){
}
launchQueryImpl(pRequest, pQuery, false, NULL);
- pQuery = NULL; // no need to free in the end
- code = pRequest->code;
+ pQuery = NULL; // no need to free in the end
+ code = pRequest->code;
- end:
+end:
taosHashCleanup(pVgroupHashmap);
destroyRequest(pRequest);
tDecoderClear(&coder);
@@ -2537,14 +2545,14 @@ static void destroyDropTbReqBatch(void* data) {
taosArrayDestroy(pTbBatch->req.pArray);
}
-static int32_t taosDropTable(TAOS *taos, void *meta, int32_t metaLen){
- SVDropTbBatchReq req = {0};
- SDecoder coder = {0};
- int32_t code = TSDB_CODE_SUCCESS;
- SRequestObj *pRequest = NULL;
- SQuery *pQuery = NULL;
- SHashObj *pVgroupHashmap = NULL;
- STscObj *pTscObj = acquireTscObj(*(int64_t *)taos);
+static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
+ SVDropTbBatchReq req = {0};
+ SDecoder coder = {0};
+ int32_t code = TSDB_CODE_SUCCESS;
+ SRequestObj* pRequest = NULL;
+ SQuery* pQuery = NULL;
+ SHashObj* pVgroupHashmap = NULL;
+ STscObj* pTscObj = acquireTscObj(*(int64_t*)taos);
if (NULL == pTscObj) {
code = TSDB_CODE_TSC_DISCONNECTED;
@@ -2556,12 +2564,12 @@ static int32_t taosDropTable(TAOS *taos, void *meta, int32_t metaLen){
goto end;
}
- if(!pRequest->pDb){
+ if (!pRequest->pDb) {
code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
goto end;
}
// decode and process req
- void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
int32_t len = metaLen - sizeof(SMsgHead);
tDecoderInit(&coder, data, len);
if (tDecodeSVDropTbBatchReq(&coder, &req) < 0) {
@@ -2569,8 +2577,8 @@ static int32_t taosDropTable(TAOS *taos, void *meta, int32_t metaLen){
goto end;
}
- SVDropTbReq *pDropReq = NULL;
- SCatalog *pCatalog = NULL;
+ SVDropTbReq* pDropReq = NULL;
+ SCatalog* pCatalog = NULL;
code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &pCatalog);
if (code != TSDB_CODE_SUCCESS) {
goto end;
@@ -2584,15 +2592,15 @@ static int32_t taosDropTable(TAOS *taos, void *meta, int32_t metaLen){
taosHashSetFreeFp(pVgroupHashmap, destroyDropTbReqBatch);
SRequestConnInfo conn = {.pTrans = pTscObj->pAppInfo->pTransporter,
- .requestId = pRequest->requestId,
- .requestObjRefId = pRequest->self,
- .mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp)};
+ .requestId = pRequest->requestId,
+ .requestObjRefId = pRequest->self,
+ .mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp)};
// loop to create table
for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
pDropReq = req.pReqs + iReq;
SVgroupInfo pInfo = {0};
- SName pName;
+ SName pName;
toName(pTscObj->acctId, pRequest->pDb, pDropReq->name, &pName);
code = catalogGetTableHashVgroup(pCatalog, &conn, &pName, &pInfo);
if (code != TSDB_CODE_SUCCESS) {
@@ -2622,7 +2630,7 @@ static int32_t taosDropTable(TAOS *taos, void *meta, int32_t metaLen){
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->msgType = TDMT_VND_DROP_TABLE;
pQuery->stableQuery = false;
- pQuery->pRoot = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT);
+ pQuery->pRoot = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT);
code = rewriteToVnodeModifyOpStmt(pQuery, pBufArray);
if (code != TSDB_CODE_SUCCESS) {
@@ -2630,10 +2638,10 @@ static int32_t taosDropTable(TAOS *taos, void *meta, int32_t metaLen){
}
launchQueryImpl(pRequest, pQuery, false, NULL);
- pQuery = NULL; // no need to free in the end
- code = pRequest->code;
+ pQuery = NULL; // no need to free in the end
+ code = pRequest->code;
- end:
+end:
taosHashCleanup(pVgroupHashmap);
destroyRequest(pRequest);
tDecoderClear(&coder);
@@ -2641,15 +2649,15 @@ static int32_t taosDropTable(TAOS *taos, void *meta, int32_t metaLen){
return code;
}
-static int32_t taosAlterTable(TAOS *taos, void *meta, int32_t metaLen){
- SVAlterTbReq req = {0};
- SDecoder coder = {0};
- int32_t code = TSDB_CODE_SUCCESS;
- SRequestObj *pRequest = NULL;
- SQuery *pQuery = NULL;
- SArray *pArray = NULL;
- SVgDataBlocks *pVgData = NULL;
- STscObj *pTscObj = acquireTscObj(*(int64_t *)taos);
+static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
+ SVAlterTbReq req = {0};
+ SDecoder coder = {0};
+ int32_t code = TSDB_CODE_SUCCESS;
+ SRequestObj* pRequest = NULL;
+ SQuery* pQuery = NULL;
+ SArray* pArray = NULL;
+ SVgDataBlocks* pVgData = NULL;
+ STscObj* pTscObj = acquireTscObj(*(int64_t*)taos);
if (NULL == pTscObj) {
code = TSDB_CODE_TSC_DISCONNECTED;
@@ -2661,12 +2669,12 @@ static int32_t taosAlterTable(TAOS *taos, void *meta, int32_t metaLen){
goto end;
}
- if(!pRequest->pDb){
+ if (!pRequest->pDb) {
code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
goto end;
}
// decode and process req
- void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
int32_t len = metaLen - sizeof(SMsgHead);
tDecoderInit(&coder, data, len);
if (tDecodeSVAlterTbReq(&coder, &req) < 0) {
@@ -2675,23 +2683,23 @@ static int32_t taosAlterTable(TAOS *taos, void *meta, int32_t metaLen){
}
// do not deal TSDB_ALTER_TABLE_UPDATE_OPTIONS
- if(req.action == TSDB_ALTER_TABLE_UPDATE_OPTIONS){
+ if (req.action == TSDB_ALTER_TABLE_UPDATE_OPTIONS) {
goto end;
}
- SCatalog *pCatalog = NULL;
+ SCatalog* pCatalog = NULL;
code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &pCatalog);
if (code != TSDB_CODE_SUCCESS) {
goto end;
}
SRequestConnInfo conn = {.pTrans = pTscObj->pAppInfo->pTransporter,
- .requestId = pRequest->requestId,
- .requestObjRefId = pRequest->self,
- .mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp)};
+ .requestId = pRequest->requestId,
+ .requestObjRefId = pRequest->self,
+ .mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp)};
SVgroupInfo pInfo = {0};
- SName pName = {0};
+ SName pName = {0};
toName(pTscObj->acctId, pRequest->pDb, req.tbName, &pName);
code = catalogGetTableHashVgroup(pCatalog, &conn, &pName, &pInfo);
if (code != TSDB_CODE_SUCCESS) {
@@ -2725,7 +2733,7 @@ static int32_t taosAlterTable(TAOS *taos, void *meta, int32_t metaLen){
pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
pQuery->msgType = TDMT_VND_ALTER_TABLE;
pQuery->stableQuery = false;
- pQuery->pRoot = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
+ pQuery->pRoot = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
code = rewriteToVnodeModifyOpStmt(pQuery, pArray);
if (code != TSDB_CODE_SUCCESS) {
@@ -2733,14 +2741,14 @@ static int32_t taosAlterTable(TAOS *taos, void *meta, int32_t metaLen){
}
launchQueryImpl(pRequest, pQuery, false, NULL);
- pQuery = NULL; // no need to free in the end
+ pQuery = NULL; // no need to free in the end
pVgData = NULL;
- pArray = NULL;
- code = pRequest->code;
+ pArray = NULL;
+ code = pRequest->code;
end:
taosArrayDestroy(pArray);
- if(pVgData) taosMemoryFreeClear(pVgData->pData);
+ if (pVgData) taosMemoryFreeClear(pVgData->pData);
taosMemoryFreeClear(pVgData);
destroyRequest(pRequest);
tDecoderClear(&coder);
@@ -2748,22 +2756,22 @@ end:
return code;
}
-int32_t taos_write_raw_meta(TAOS *taos, tmq_raw_data *raw_meta){
+int32_t taos_write_raw_meta(TAOS* taos, tmq_raw_data* raw_meta) {
if (!taos || !raw_meta) {
return TSDB_CODE_INVALID_PARA;
}
- if(raw_meta->raw_meta_type == TDMT_VND_CREATE_STB) {
+ if (raw_meta->raw_meta_type == TDMT_VND_CREATE_STB) {
return taosCreateStb(taos, raw_meta->raw_meta, raw_meta->raw_meta_len);
- }else if(raw_meta->raw_meta_type == TDMT_VND_ALTER_STB){
+ } else if (raw_meta->raw_meta_type == TDMT_VND_ALTER_STB) {
return taosCreateStb(taos, raw_meta->raw_meta, raw_meta->raw_meta_len);
- }else if(raw_meta->raw_meta_type == TDMT_VND_DROP_STB){
+ } else if (raw_meta->raw_meta_type == TDMT_VND_DROP_STB) {
return taosDropStb(taos, raw_meta->raw_meta, raw_meta->raw_meta_len);
- }else if(raw_meta->raw_meta_type == TDMT_VND_CREATE_TABLE){
+ } else if (raw_meta->raw_meta_type == TDMT_VND_CREATE_TABLE) {
return taosCreateTable(taos, raw_meta->raw_meta, raw_meta->raw_meta_len);
- }else if(raw_meta->raw_meta_type == TDMT_VND_ALTER_TABLE){
+ } else if (raw_meta->raw_meta_type == TDMT_VND_ALTER_TABLE) {
return taosAlterTable(taos, raw_meta->raw_meta, raw_meta->raw_meta_len);
- }else if(raw_meta->raw_meta_type == TDMT_VND_DROP_TABLE){
+ } else if (raw_meta->raw_meta_type == TDMT_VND_DROP_TABLE) {
return taosDropTable(taos, raw_meta->raw_meta, raw_meta->raw_meta_len);
}
return TSDB_CODE_INVALID_PARA;
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index 9972b2aa08..c80960b8ce 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -381,9 +381,11 @@ static int32_t tDeserializeSClientHbRsp(SDecoder *pDecoder, SClientHbRsp *pRsp)
if (pQnodeNum > 0) {
pRsp->query->pQnodeList = taosArrayInit(pQnodeNum, sizeof(SQueryNodeLoad));
if (NULL == pRsp->query->pQnodeList) return -1;
- SQueryNodeLoad load = {0};
- if (tDecodeSQueryNodeLoad(pDecoder, &load) < 0) return -1;
- taosArrayPush(pRsp->query->pQnodeList, &load);
+ for (int32_t i = 0; i < pQnodeNum; ++i) {
+ SQueryNodeLoad load = {0};
+ if (tDecodeSQueryNodeLoad(pDecoder, &load) < 0) return -1;
+ taosArrayPush(pRsp->query->pQnodeList, &load);
+ }
}
}
@@ -496,11 +498,18 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
if (tStartEncode(&encoder) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
+ if (tEncodeI8(&encoder, pReq->source) < 0) return -1;
+ for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
+ if (tEncodeI8(&encoder, pReq->reserved[i]) < 0) return -1;
+ }
+ if (tEncodeI64(&encoder, pReq->suid) < 0) return -1;
if (tEncodeI64(&encoder, pReq->delay1) < 0) return -1;
if (tEncodeI64(&encoder, pReq->delay2) < 0) return -1;
if (tEncodeI64(&encoder, pReq->watermark1) < 0) return -1;
if (tEncodeI64(&encoder, pReq->watermark2) < 0) return -1;
if (tEncodeI32(&encoder, pReq->ttl) < 0) return -1;
+ if (tEncodeI32(&encoder, pReq->colVer) < 0) return -1;
+ if (tEncodeI32(&encoder, pReq->tagVer) < 0) return -1;
if (tEncodeI32(&encoder, pReq->numOfColumns) < 0) return -1;
if (tEncodeI32(&encoder, pReq->numOfTags) < 0) return -1;
if (tEncodeI32(&encoder, pReq->numOfFuncs) < 0) return -1;
@@ -516,8 +525,6 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
}
- if (tEncodeI32(&encoder, pReq->cVersion) < 0) return -1;
-
for (int32_t i = 0; i < pReq->numOfTags; ++i) {
SField *pField = taosArrayGet(pReq->pTags, i);
if (tEncodeI8(&encoder, pField->type) < 0) return -1;
@@ -526,8 +533,6 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
}
- if (tEncodeI32(&encoder, pReq->tVersion) < 0) return -1;
-
for (int32_t i = 0; i < pReq->numOfFuncs; ++i) {
const char *pFunc = taosArrayGet(pReq->pFuncs, i);
if (tEncodeCStr(&encoder, pFunc) < 0) return -1;
@@ -542,11 +547,6 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
if (pReq->ast2Len > 0) {
if (tEncodeBinary(&encoder, pReq->pAst2, pReq->ast2Len) < 0) return -1;
}
- if (tEncodeI64(&encoder, pReq->suid) < 0) return -1;
- if (tEncodeI8(&encoder, pReq->source) < 0) return -1;
- for (int32_t i = 0; i < sizeof(pReq->reserved)/sizeof(int8_t); ++i) {
- if (tEncodeI8(&encoder, pReq->reserved[i]) < 0) return -1;
- }
tEndEncode(&encoder);
@@ -562,11 +562,18 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
if (tStartDecode(&decoder) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
if (tDecodeI8(&decoder, &pReq->igExists) < 0) return -1;
+ if (tDecodeI8(&decoder, &pReq->source) < 0) return -1;
+ for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
+ if (tDecodeI8(&decoder, &pReq->reserved[i]) < 0) return -1;
+ }
+ if (tDecodeI64(&decoder, &pReq->suid) < 0) return -1;
if (tDecodeI64(&decoder, &pReq->delay1) < 0) return -1;
if (tDecodeI64(&decoder, &pReq->delay2) < 0) return -1;
if (tDecodeI64(&decoder, &pReq->watermark1) < 0) return -1;
if (tDecodeI64(&decoder, &pReq->watermark2) < 0) return -1;
if (tDecodeI32(&decoder, &pReq->ttl) < 0) return -1;
+ if (tDecodeI32(&decoder, &pReq->colVer) < 0) return -1;
+ if (tDecodeI32(&decoder, &pReq->tagVer) < 0) return -1;
if (tDecodeI32(&decoder, &pReq->numOfColumns) < 0) return -1;
if (tDecodeI32(&decoder, &pReq->numOfTags) < 0) return -1;
if (tDecodeI32(&decoder, &pReq->numOfFuncs) < 0) return -1;
@@ -594,8 +601,6 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
}
}
- if (tDecodeI32(&decoder, &pReq->cVersion) < 0) return -1;
-
for (int32_t i = 0; i < pReq->numOfTags; ++i) {
SField field = {0};
if (tDecodeI8(&decoder, &field.type) < 0) return -1;
@@ -608,8 +613,6 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
}
}
- if (tDecodeI32(&decoder, &pReq->tVersion) < 0) return -1;
-
for (int32_t i = 0; i < pReq->numOfFuncs; ++i) {
char pFunc[TSDB_FUNC_NAME_LEN] = {0};
if (tDecodeCStrTo(&decoder, pFunc) < 0) return -1;
@@ -637,12 +640,6 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
if (tDecodeCStrTo(&decoder, pReq->pAst2) < 0) return -1;
}
- if (tDecodeI64(&decoder, &pReq->suid) < 0) return -1;
- if (tDecodeI8(&decoder, &pReq->source) < 0) return -1;
- for (int32_t i = 0; i < sizeof(pReq->reserved)/sizeof(int8_t); ++i) {
- if (tDecodeI8(&decoder, &pReq->reserved[i]) < 0) return -1;
- }
-
tEndDecode(&decoder);
tDecoderClear(&decoder);
return 0;
@@ -664,11 +661,11 @@ int32_t tSerializeSMDropStbReq(void *buf, int32_t bufLen, SMDropStbReq *pReq) {
if (tStartEncode(&encoder) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
if (tEncodeI8(&encoder, pReq->igNotExists) < 0) return -1;
- if (tEncodeI64(&encoder, pReq->suid) < 0) return -1;
if (tEncodeI8(&encoder, pReq->source) < 0) return -1;
- for (int32_t i = 0; i < sizeof(pReq->reserved)/sizeof(int8_t); ++i) {
+ for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
if (tEncodeI8(&encoder, pReq->reserved[i]) < 0) return -1;
}
+ if (tEncodeI64(&encoder, pReq->suid) < 0) return -1;
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
@@ -683,11 +680,11 @@ int32_t tDeserializeSMDropStbReq(void *buf, int32_t bufLen, SMDropStbReq *pReq)
if (tStartDecode(&decoder) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
if (tDecodeI8(&decoder, &pReq->igNotExists) < 0) return -1;
- if (tDecodeI64(&decoder, &pReq->suid) < 0) return -1;
if (tDecodeI8(&decoder, &pReq->source) < 0) return -1;
- for (int32_t i = 0; i < sizeof(pReq->reserved)/sizeof(int8_t); ++i) {
+ for (int32_t i = 0; i < sizeof(pReq->reserved) / sizeof(int8_t); ++i) {
if (tDecodeI8(&decoder, &pReq->reserved[i]) < 0) return -1;
}
+ if (tDecodeI64(&decoder, &pReq->suid) < 0) return -1;
tEndDecode(&decoder);
@@ -702,8 +699,6 @@ int32_t tSerializeSMAlterStbReq(void *buf, int32_t bufLen, SMAlterStbReq *pReq)
if (tStartEncode(&encoder) < 0) return -1;
if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
if (tEncodeI8(&encoder, pReq->alterType) < 0) return -1;
- if (tEncodeI32(&encoder, pReq->tagVer) < 0) return -1;
- if (tEncodeI32(&encoder, pReq->colVer) < 0) return -1;
if (tEncodeI32(&encoder, pReq->numOfFields) < 0) return -1;
for (int32_t i = 0; i < pReq->numOfFields; ++i) {
SField *pField = taosArrayGet(pReq->pFields, i);
@@ -730,8 +725,6 @@ int32_t tDeserializeSMAlterStbReq(void *buf, int32_t bufLen, SMAlterStbReq *pReq
if (tStartDecode(&decoder) < 0) return -1;
if (tDecodeCStrTo(&decoder, pReq->name) < 0) return -1;
if (tDecodeI8(&decoder, &pReq->alterType) < 0) return -1;
- if (tDecodeI32(&decoder, &pReq->tagVer) < 0) return -1;
- if (tDecodeI32(&decoder, &pReq->colVer) < 0) return -1;
if (tDecodeI32(&decoder, &pReq->numOfFields) < 0) return -1;
pReq->pFields = taosArrayInit(pReq->numOfFields, sizeof(SField));
if (pReq->pFields == NULL) {
diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index 282fc44965..8ce22c2b2e 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -45,6 +45,7 @@ static int32_t mndProcessTableMetaReq(SRpcMsg *pReq);
static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
static void mndCancelGetNextStb(SMnode *pMnode, void *pIter);
static int32_t mndProcessTableCfgReq(SRpcMsg *pReq);
+static int32_t mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp);
int32_t mndInitStb(SMnode *pMnode) {
SSdbTable table = {
@@ -707,8 +708,8 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
pDst->updateTime = pDst->createdTime;
pDst->uid = (pCreate->source == 1) ? pCreate->suid : mndGenerateUid(pCreate->name, TSDB_TABLE_FNAME_LEN);
pDst->dbUid = pDb->uid;
- pDst->tagVer = (pCreate->source == 1) ? pCreate->tVersion : 1;
- pDst->colVer = (pCreate->source == 1) ? pCreate->cVersion : 1;
+ pDst->tagVer = (pCreate->source != TD_REQ_FROM_APP) ? pCreate->tagVer : 1;
+ pDst->colVer = (pCreate->source != TD_REQ_FROM_APP) ? pCreate->colVer : 1;
pDst->smaVer = 1;
pDst->nextColId = 1;
pDst->maxdelay[0] = pCreate->delay1;
@@ -854,6 +855,7 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
SStbObj *pStb = NULL;
SDbObj *pDb = NULL;
SMCreateStbReq createReq = {0};
+ bool isAlter = false;
if (tDeserializeSMCreateStbReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
terrno = TSDB_CODE_INVALID_MSG;
@@ -869,9 +871,39 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
pStb = mndAcquireStb(pMnode, createReq.name);
if (pStb != NULL) {
if (createReq.igExists) {
- mDebug("stb:%s, already exist, ignore exist is set", createReq.name);
- code = 0;
- goto _OVER;
+ if (createReq.source == TD_REQ_FROM_APP) {
+ mDebug("stb:%s, already exist, ignore exist is set", createReq.name);
+ code = 0;
+ goto _OVER;
+ } else if (pStb->uid != createReq.suid) {
+ mError("stb:%s, already exist while create, input suid:%" PRId64 " not match with exist suid:%" PRId64,
+ createReq.name, createReq.suid, pStb->uid);
+ terrno = TSDB_CODE_MND_STABLE_UID_NOT_MATCH;
+ goto _OVER;
+ } else if (createReq.tagVer > 0 || createReq.colVer > 0) {
+ int32_t tagDelta = pStb->tagVer - createReq.tagVer;
+ int32_t colDelta = pStb->colVer - createReq.colVer;
+ int32_t verDelta = tagDelta + verDelta;
+ mInfo("stb:%s, already exist while create, input tagVer:%d colVer:%d, exist tagVer:%d colVer:%d",
+ createReq.name, createReq.tagVer, createReq.colVer, pStb->tagVer, pStb->colVer);
+ if (tagDelta <= 0 && colDelta <= 0) {
+ mInfo("stb:%s, schema version is not incremented and nothing needs to be done", createReq.name);
+ code = 0;
+ goto _OVER;
+ } else if ((tagDelta == 1 || colDelta == 1) && (verDelta == 1)) {
+ isAlter = true;
+ mInfo("stb:%s, schema version is only increased by 1 number, do alter operation", createReq.name);
+ } else {
+ mError("stb:%s, schema version increase more than 1 number, error is returned", createReq.name);
+ terrno = TSDB_CODE_MND_INVALID_SCHEMA_VER;
+ goto _OVER;
+ }
+ } else {
+ mError("stb:%s, already exist while create, input tagVer:%d colVer:%d is invalid", createReq.name,
+ createReq.tagVer, createReq.colVer, pStb->tagVer, pStb->colVer);
+ terrno = TSDB_CODE_MND_INVALID_SCHEMA_VER;
+ goto _OVER;
+ }
} else {
terrno = TSDB_CODE_MND_STB_ALREADY_EXIST;
goto _OVER;
@@ -900,7 +932,12 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
goto _OVER;
}
- code = mndCreateStb(pMnode, pReq, &createReq, pDb);
+ if (isAlter) {
+ bool needRsp = false;
+ code = mndAlterStbImp(pMnode, pReq, pDb, pStb, needRsp);
+ } else {
+ code = mndCreateStb(pMnode, pReq, &createReq, pDb);
+ }
if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
_OVER:
@@ -1466,14 +1503,13 @@ static int32_t mndBuildStbCfg(SMnode *pMnode, const char *dbFName, const char *t
return code;
}
-static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, const SMAlterStbReq *pAlter, SStbObj *pObj, void **pCont,
- int32_t *pLen) {
+static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, int32_t *pLen) {
int32_t ret;
SEncoder ec = {0};
uint32_t contLen = 0;
SMAlterStbRsp alterRsp = {0};
SName name = {0};
- tNameFromString(&name, pAlter->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+ tNameFromString(&name, pObj->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
alterRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
if (NULL == alterRsp.pMeta) {
@@ -1506,10 +1542,36 @@ static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, const SMAlterStbReq *pAlter, S
return 0;
}
+static int32_t mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp) {
+ int32_t code = -1;
+ STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB_INSIDE, pReq);
+ if (pTrans == NULL) goto _OVER;
+
+ mDebug("trans:%d, used to alter stb:%s", pTrans->id, pStb->name);
+ mndTransSetDbName(pTrans, pDb->name, NULL);
+
+ if (needRsp) {
+ void *pCont = NULL;
+ int32_t contLen = 0;
+ if (mndBuildSMAlterStbRsp(pDb, pStb, &pCont, &contLen) != 0) goto _OVER;
+ mndTransSetRpcRsp(pTrans, pCont, contLen);
+ }
+
+ if (mndSetAlterStbRedoLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
+ if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
+ if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
+ if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+
+ code = 0;
+
+_OVER:
+ mndTransDrop(pTrans);
+ return code;
+}
+
static int32_t mndAlterStb(SMnode *pMnode, SRpcMsg *pReq, const SMAlterStbReq *pAlter, SDbObj *pDb, SStbObj *pOld) {
bool needRsp = true;
int32_t code = -1;
- STrans *pTrans = NULL;
SField *pField0 = NULL;
SStbObj stbObj = {0};
@@ -1558,30 +1620,9 @@ static int32_t mndAlterStb(SMnode *pMnode, SRpcMsg *pReq, const SMAlterStbReq *p
}
if (code != 0) goto _OVER;
-
- code = -1;
- pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB_INSIDE, pReq);
- if (pTrans == NULL) goto _OVER;
-
- mDebug("trans:%d, used to alter stb:%s", pTrans->id, pAlter->name);
- mndTransSetDbName(pTrans, pDb->name, NULL);
-
- if (needRsp) {
- void *pCont = NULL;
- int32_t contLen = 0;
- if (mndBuildSMAlterStbRsp(pDb, pAlter, &stbObj, &pCont, &contLen) != 0) goto _OVER;
- mndTransSetRpcRsp(pTrans, pCont, contLen);
- }
-
- if (mndSetAlterStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
- if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
- if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
- if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
-
- code = 0;
+ code = mndAlterStbImp(pMnode, pReq, pDb, &stbObj, needRsp);
_OVER:
- mndTransDrop(pTrans);
taosMemoryFreeClear(stbObj.pTags);
taosMemoryFreeClear(stbObj.pColumns);
return code;
@@ -1614,14 +1655,6 @@ static int32_t mndProcessAlterStbReq(SRpcMsg *pReq) {
goto _OVER;
}
- if ((alterReq.tagVer > 0 && alterReq.colVer > 0) &&
- (alterReq.tagVer <= pStb->tagVer || alterReq.colVer <= pStb->colVer)) {
- mDebug("stb:%s, already exist, tagVer:%d colVer:%d smaller than in mnode, tagVer:%d colVer:%d, alter success",
- alterReq.name, alterReq.tagVer, alterReq.colVer, pStb->tagVer, pStb->colVer);
- code = 0;
- goto _OVER;
- }
-
if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pDb) != 0) {
goto _OVER;
}
@@ -1752,7 +1785,7 @@ static int32_t mndProcessDropStbReq(SRpcMsg *pReq) {
}
}
- if (dropReq.source == 1 && pStb->uid != dropReq.suid){
+ if (dropReq.source != TD_REQ_FROM_APP && pStb->uid != dropReq.suid) {
terrno = TSDB_CODE_MND_STB_NOT_EXIST;
goto _OVER;
}
diff --git a/source/dnode/mnode/impl/test/stb/stb.cpp b/source/dnode/mnode/impl/test/stb/stb.cpp
index 56b8936cf4..63bb1bf540 100644
--- a/source/dnode/mnode/impl/test/stb/stb.cpp
+++ b/source/dnode/mnode/impl/test/stb/stb.cpp
@@ -277,8 +277,6 @@ void* MndTestStb::BuildAlterStbUpdateColumnBytesReq(const char* stbname, const c
req.numOfFields = 1;
req.pFields = taosArrayInit(1, sizeof(SField));
req.alterType = TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES;
- req.tagVer = verInBlock;
- req.colVer = verInBlock;
SField field = {0};
field.bytes = bytes;
@@ -818,7 +816,7 @@ TEST_F(MndTestStb, 08_Alter_Stb_AlterTagBytes) {
{
void* pReq = BuildAlterStbUpdateColumnBytesReq(stbname, "col_not_exist", 20, &contLen, 1);
SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
- ASSERT_EQ(pRsp->code, 0);
+ ASSERT_EQ(pRsp->code, TSDB_CODE_MND_COLUMN_NOT_EXIST);
test.SendShowReq(TSDB_MGMT_TABLE_STB, "user_stables", dbname);
EXPECT_EQ(test.GetShowRows(), 1);
diff --git a/source/dnode/vnode/CMakeLists.txt b/source/dnode/vnode/CMakeLists.txt
index d20d79ee47..e9e20912c5 100644
--- a/source/dnode/vnode/CMakeLists.txt
+++ b/source/dnode/vnode/CMakeLists.txt
@@ -3,6 +3,7 @@ add_library(vnode STATIC "")
target_sources(
vnode
PRIVATE
+
# vnode
"src/vnd/vnodeOpen.c"
"src/vnd/vnodeBufPool.c"
@@ -13,7 +14,6 @@ target_sources(
"src/vnd/vnodeSvr.c"
"src/vnd/vnodeSync.c"
"src/vnd/vnodeSnapshot.c"
- "src/vnd/vnodeUtil.c"
# meta
"src/meta/metaOpen.c"
@@ -46,6 +46,7 @@ target_sources(
"src/tsdb/tsdbUtil.c"
"src/tsdb/tsdbSnapshot.c"
"src/tsdb/tsdbCacheRead.c"
+ "src/tsdb/tsdbRetention.c"
# tq
"src/tq/tq.c"
@@ -62,7 +63,6 @@ target_include_directories(
PUBLIC "inc"
PRIVATE "src/inc"
PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
-
)
target_link_libraries(
vnode
@@ -76,18 +76,19 @@ target_link_libraries(
PUBLIC executor
PUBLIC scheduler
PUBLIC tdb
- #PUBLIC bdb
- #PUBLIC scalar
+
+ # PUBLIC bdb
+ # PUBLIC scalar
PUBLIC transport
PUBLIC stream
PUBLIC index
)
target_compile_definitions(vnode PUBLIC -DMETA_REFACT)
-if (${BUILD_WITH_INVERTEDINDEX})
- add_definitions(-DUSE_INVERTED_INDEX)
+
+if(${BUILD_WITH_INVERTEDINDEX})
+ add_definitions(-DUSE_INVERTED_INDEX)
endif(${BUILD_WITH_INVERTEDINDEX})
+
if(${BUILD_TEST})
add_subdirectory(test)
endif(${BUILD_TEST})
-
-
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index ff29305b74..62a39711ec 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -38,10 +38,11 @@ extern "C" {
#endif
// vnode
-typedef struct SVnode SVnode;
-typedef struct STsdbCfg STsdbCfg; // todo: remove
-typedef struct SVnodeCfg SVnodeCfg;
-typedef struct SVSnapshotReader SVSnapshotReader;
+typedef struct SVnode SVnode;
+typedef struct STsdbCfg STsdbCfg; // todo: remove
+typedef struct SVnodeCfg SVnodeCfg;
+typedef struct SVSnapReader SVSnapReader;
+typedef struct SVSnapWriter SVSnapWriter;
extern const SVnodeCfg vnodeCfgDefault;
@@ -57,10 +58,6 @@ void vnodeStop(SVnode *pVnode);
int64_t vnodeGetSyncHandle(SVnode *pVnode);
void vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot);
void vnodeGetInfo(SVnode *pVnode, const char **dbname, int32_t *vgId);
-int32_t vnodeSnapshotReaderOpen(SVnode *pVnode, SVSnapshotReader **ppReader, int64_t sver, int64_t ever);
-int32_t vnodeSnapshotReaderClose(SVSnapshotReader *pReader);
-int32_t vnodeSnapshotRead(SVSnapshotReader *pReader, const void **ppData, uint32_t *nData);
-
int32_t vnodeProcessCreateTSma(SVnode *pVnode, void *pCont, uint32_t contLen);
int32_t vnodeGetAllTableList(SVnode *pVnode, uint64_t uid, SArray *list);
int32_t vnodeGetCtbIdList(SVnode *pVnode, int64_t suid, SArray *list);
@@ -185,7 +182,14 @@ int32_t tqRetrieveDataBlock(SSDataBlock *pBlock, STqReader *pReader);
// sma
int32_t smaGetTSmaDays(SVnodeCfg *pCfg, void *pCont, uint32_t contLen, int32_t *days);
-// need to reposition
+// SVSnapReader
+int32_t vnodeSnapReaderOpen(SVnode *pVnode, int64_t sver, int64_t ever, SVSnapReader **ppReader);
+int32_t vnodeSnapReaderClose(SVSnapReader *pReader);
+int32_t vnodeSnapRead(SVSnapReader *pReader, uint8_t **ppData, uint32_t *nData);
+// SVSnapWriter
+int32_t vnodeSnapWriterOpen(SVnode *pVnode, int64_t sver, int64_t ever, SVSnapWriter **ppWriter);
+int32_t vnodeSnapWriterClose(SVSnapWriter *pWriter, int8_t rollback);
+int32_t vnodeSnapWrite(SVSnapWriter *pWriter, uint8_t *pData, uint32_t nData);
// structs
struct STsdbCfg {
diff --git a/source/dnode/vnode/src/inc/meta.h b/source/dnode/vnode/src/inc/meta.h
index 66d1689d57..e08925acc3 100644
--- a/source/dnode/vnode/src/inc/meta.h
+++ b/source/dnode/vnode/src/inc/meta.h
@@ -57,6 +57,9 @@ int metaRemoveTableFromIdx(SMeta* pMeta, tb_uid_t uid);
// metaCommit ==================
static FORCE_INLINE tb_uid_t metaGenerateUid(SMeta* pMeta) { return tGenIdPI64(); }
+// metaTable ==================
+int metaHandleEntry(SMeta* pMeta, const SMetaEntry* pME);
+
struct SMeta {
TdThreadRwlock lock;
diff --git a/source/dnode/vnode/src/inc/sma.h b/source/dnode/vnode/src/inc/sma.h
index 7183c423fe..d5b719dfb9 100644
--- a/source/dnode/vnode/src/inc/sma.h
+++ b/source/dnode/vnode/src/inc/sma.h
@@ -49,6 +49,7 @@ struct SSmaEnv {
typedef struct {
int8_t inited;
int32_t rsetId;
+ void *tmrHandle; // shared by all fetch tasks
} SSmaMgmt;
#define SMA_ENV_LOCK(env) ((env)->lock)
@@ -65,7 +66,6 @@ struct SRSmaStat {
SSma *pSma;
int64_t submitVer;
int64_t refId; // shared by fetch tasks
- void *tmrHandle; // shared by fetch tasks
int8_t triggerStat; // shared by fetch tasks
int8_t runningStat; // for persistence task
SHashObj *rsmaInfoHash; // key: stbUid, value: SRSmaInfo;
@@ -82,7 +82,6 @@ struct SSmaStat {
#define SMA_TSMA_STAT(s) (&(s)->tsmaStat)
#define SMA_RSMA_STAT(s) (&(s)->rsmaStat)
#define RSMA_INFO_HASH(r) ((r)->rsmaInfoHash)
-#define RSMA_TMR_HANDLE(r) ((r)->tmrHandle)
#define RSMA_TRIGGER_STAT(r) (&(r)->triggerStat)
#define RSMA_RUNNING_STAT(r) (&(r)->runningStat)
#define RSMA_REF_ID(r) ((r)->refId)
@@ -189,7 +188,7 @@ static FORCE_INLINE void tdSmaStatSetDropped(STSmaStat *pTStat) {
static int32_t tdDestroySmaState(SSmaStat *pSmaStat, int8_t smaType);
void *tdFreeSmaState(SSmaStat *pSmaStat, int8_t smaType);
-void *tdFreeRSmaInfo(SRSmaInfo *pInfo);
+void *tdFreeRSmaInfo(SSma *pSma, SRSmaInfo *pInfo);
int32_t tdRSmaPersistExecImpl(SRSmaStat *pRSmaStat);
int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, const char *tbName);
diff --git a/source/dnode/vnode/src/inc/tq.h b/source/dnode/vnode/src/inc/tq.h
index b2ea08d50d..f58bbe0d68 100644
--- a/source/dnode/vnode/src/inc/tq.h
+++ b/source/dnode/vnode/src/inc/tq.h
@@ -129,7 +129,7 @@ typedef struct {
static STqMgmt tqMgmt = {0};
// tqRead
-int64_t tqScanLog(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal* offset);
+int64_t tqScan(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal* offset);
int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalCkHead** pHeadWithCkSum);
// tqExec
diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h
index cd2dfd3351..cce3da60cb 100644
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -64,6 +64,7 @@ typedef struct SRowIter SRowIter;
typedef struct STsdbFS STsdbFS;
typedef struct SRowMerger SRowMerger;
typedef struct STsdbFSState STsdbFSState;
+typedef struct STsdbSnapHdr STsdbSnapHdr;
#define TSDB_MAX_SUBBLOCKS 8
#define TSDB_FHDR_SIZE 512
diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h
index 34fac045a7..0c386babde 100644
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -49,17 +49,20 @@
extern "C" {
#endif
-typedef struct SVnodeInfo SVnodeInfo;
-typedef struct SMeta SMeta;
-typedef struct SSma SSma;
-typedef struct STsdb STsdb;
-typedef struct STQ STQ;
-typedef struct SVState SVState;
-typedef struct SVBufPool SVBufPool;
-typedef struct SQWorker SQHandle;
-typedef struct STsdbKeepCfg STsdbKeepCfg;
-typedef struct SMetaSnapshotReader SMetaSnapshotReader;
-typedef struct STsdbSnapshotReader STsdbSnapshotReader;
+typedef struct SVnodeInfo SVnodeInfo;
+typedef struct SMeta SMeta;
+typedef struct SSma SSma;
+typedef struct STsdb STsdb;
+typedef struct STQ STQ;
+typedef struct SVState SVState;
+typedef struct SVBufPool SVBufPool;
+typedef struct SQWorker SQHandle;
+typedef struct STsdbKeepCfg STsdbKeepCfg;
+typedef struct SMetaSnapReader SMetaSnapReader;
+typedef struct SMetaSnapWriter SMetaSnapWriter;
+typedef struct STsdbSnapReader STsdbSnapReader;
+typedef struct STsdbSnapWriter STsdbSnapWriter;
+typedef struct SSnapDataHdr SSnapDataHdr;
#define VNODE_META_DIR "meta"
#define VNODE_TSDB_DIR "tsdb"
@@ -72,10 +75,8 @@ typedef struct STsdbSnapshotReader STsdbSnapshotReader;
#define VNODE_RSMA2_DIR "rsma2"
// vnd.h
-void* vnodeBufPoolMalloc(SVBufPool* pPool, int size);
-void vnodeBufPoolFree(SVBufPool* pPool, void* p);
-int32_t vnodeRealloc(void** pp, int32_t size);
-void vnodeFree(void* p);
+void* vnodeBufPoolMalloc(SVBufPool* pPool, int size);
+void vnodeBufPoolFree(SVBufPool* pPool, void* p);
// meta
typedef struct SMCtbCursor SMCtbCursor;
@@ -109,9 +110,6 @@ STSma* metaGetSmaInfoByIndex(SMeta* pMeta, int64_t indexUid);
STSmaWrapper* metaGetSmaInfoByTable(SMeta* pMeta, tb_uid_t uid, bool deepCopy);
SArray* metaGetSmaIdsByTable(SMeta* pMeta, tb_uid_t uid);
SArray* metaGetSmaTbUids(SMeta* pMeta);
-int32_t metaSnapshotReaderOpen(SMeta* pMeta, SMetaSnapshotReader** ppReader, int64_t sver, int64_t ever);
-int32_t metaSnapshotReaderClose(SMetaSnapshotReader* pReader);
-int32_t metaSnapshotRead(SMetaSnapshotReader* pReader, void** ppData, uint32_t* nData);
void* metaGetIdx(SMeta* pMeta);
void* metaGetIvtIdx(SMeta* pMeta);
int metaTtlSmaller(SMeta* pMeta, uint64_t time, SArray* uidList);
@@ -131,9 +129,6 @@ int32_t tsdbInsertTableData(STsdb* pTsdb, int64_t version, SSubmitMsgIter* p
int32_t tsdbDeleteTableData(STsdb* pTsdb, int64_t version, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKEY eKey);
STsdbReader tsdbQueryCacheLastT(STsdb* tsdb, SQueryTableDataCond* pCond, STableListInfo* tableList, uint64_t qId,
void* pMemRef);
-int32_t tsdbSnapshotReaderOpen(STsdb* pTsdb, STsdbSnapshotReader** ppReader, int64_t sver, int64_t ever);
-int32_t tsdbSnapshotReaderClose(STsdbSnapshotReader* pReader);
-int32_t tsdbSnapshotRead(STsdbSnapshotReader* pReader, void** ppData, uint32_t* nData);
// tq
int tqInit();
@@ -183,6 +178,23 @@ int32_t tdUpdateTbUidList(SSma* pSma, STbUidStore* pUidStore);
void tdUidStoreDestory(STbUidStore* pStore);
void* tdUidStoreFree(STbUidStore* pStore);
+// SMetaSnapReader ========================================
+int32_t metaSnapReaderOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapReader** ppReader);
+int32_t metaSnapReaderClose(SMetaSnapReader** ppReader);
+int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData);
+// SMetaSnapWriter ========================================
+int32_t metaSnapWriterOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapWriter** ppWriter);
+int32_t metaSnapWrite(SMetaSnapWriter* pWriter, uint8_t* pData, uint32_t nData);
+int32_t metaSnapWriterClose(SMetaSnapWriter** ppWriter, int8_t rollback);
+// STsdbSnapReader ========================================
+int32_t tsdbSnapReaderOpen(STsdb* pTsdb, int64_t sver, int64_t ever, STsdbSnapReader** ppReader);
+int32_t tsdbSnapReaderClose(STsdbSnapReader** ppReader);
+int32_t tsdbSnapRead(STsdbSnapReader* pReader, uint8_t** ppData);
+// STsdbSnapWriter ========================================
+int32_t tsdbSnapWriterOpen(STsdb* pTsdb, int64_t sver, int64_t ever, STsdbSnapWriter** ppWriter);
+int32_t tsdbSnapWrite(STsdbSnapWriter* pWriter, uint8_t* pData, uint32_t nData);
+int32_t tsdbSnapWriterClose(STsdbSnapWriter** ppWriter, int8_t rollback);
+
typedef struct {
int8_t streamType; // sma or other
int8_t dstType;
@@ -202,7 +214,9 @@ typedef struct {
struct SVState {
int64_t committed;
int64_t applied;
+ int64_t applyTerm;
int64_t commitID;
+ int64_t commitTerm;
};
struct SVnodeInfo {
@@ -291,6 +305,12 @@ struct SSma {
// sma
void smaHandleRes(void* pVnode, int64_t smaId, const SArray* data);
+struct SSnapDataHdr {
+ int8_t type;
+ int64_t size;
+ uint8_t data[];
+};
+
#ifdef __cplusplus
}
#endif
diff --git a/source/dnode/vnode/src/meta/metaSnapshot.c b/source/dnode/vnode/src/meta/metaSnapshot.c
index 5757039d55..ac84842e85 100644
--- a/source/dnode/vnode/src/meta/metaSnapshot.c
+++ b/source/dnode/vnode/src/meta/metaSnapshot.c
@@ -15,53 +15,57 @@
#include "meta.h"
-struct SMetaSnapshotReader {
+// SMetaSnapReader ========================================
+struct SMetaSnapReader {
SMeta* pMeta;
- TBC* pTbc;
int64_t sver;
int64_t ever;
+ TBC* pTbc;
};
-int32_t metaSnapshotReaderOpen(SMeta* pMeta, SMetaSnapshotReader** ppReader, int64_t sver, int64_t ever) {
- int32_t code = 0;
- int32_t c = 0;
- SMetaSnapshotReader* pMetaReader = NULL;
+int32_t metaSnapReaderOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapReader** ppReader) {
+ int32_t code = 0;
+ int32_t c = 0;
+ SMetaSnapReader* pMetaSnapReader = NULL;
- pMetaReader = (SMetaSnapshotReader*)taosMemoryCalloc(1, sizeof(*pMetaReader));
- if (pMetaReader == NULL) {
+ // alloc
+ pMetaSnapReader = (SMetaSnapReader*)taosMemoryCalloc(1, sizeof(*pMetaSnapReader));
+ if (pMetaSnapReader == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto _err;
}
- pMetaReader->pMeta = pMeta;
- pMetaReader->sver = sver;
- pMetaReader->ever = ever;
- code = tdbTbcOpen(pMeta->pTbDb, &pMetaReader->pTbc, NULL);
+ pMetaSnapReader->pMeta = pMeta;
+ pMetaSnapReader->sver = sver;
+ pMetaSnapReader->ever = ever;
+
+ // impl
+ code = tdbTbcOpen(pMeta->pTbDb, &pMetaSnapReader->pTbc, NULL);
if (code) {
goto _err;
}
- code = tdbTbcMoveTo(pMetaReader->pTbc, &(STbDbKey){.version = sver, .uid = INT64_MIN}, sizeof(STbDbKey), &c);
+ code = tdbTbcMoveTo(pMetaSnapReader->pTbc, &(STbDbKey){.version = sver, .uid = INT64_MIN}, sizeof(STbDbKey), &c);
if (code) {
goto _err;
}
- *ppReader = pMetaReader;
+ *ppReader = pMetaSnapReader;
return code;
_err:
+ metaError("vgId:%d meta snap reader open failed since %s", TD_VID(pMeta->pVnode), tstrerror(code));
*ppReader = NULL;
return code;
}
-int32_t metaSnapshotReaderClose(SMetaSnapshotReader* pReader) {
- if (pReader) {
- tdbTbcClose(pReader->pTbc);
- taosMemoryFree(pReader);
- }
+int32_t metaSnapReaderClose(SMetaSnapReader** ppReader) {
+ tdbTbcClose((*ppReader)->pTbc);
+ taosMemoryFree(*ppReader);
+ *ppReader = NULL;
return 0;
}
-int32_t metaSnapshotRead(SMetaSnapshotReader* pReader, void** ppData, uint32_t* nDatap) {
+int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) {
const void* pKey = NULL;
const void* pData = NULL;
int32_t nKey = 0;
@@ -71,23 +75,110 @@ int32_t metaSnapshotRead(SMetaSnapshotReader* pReader, void** ppData, uint32_t*
for (;;) {
code = tdbTbcGet(pReader->pTbc, &pKey, &nKey, &pData, &nData);
if (code || ((STbDbKey*)pData)->version > pReader->ever) {
- return TSDB_CODE_VND_READ_END;
+ code = TSDB_CODE_VND_READ_END;
+ goto _exit;
}
if (((STbDbKey*)pData)->version < pReader->sver) {
+ tdbTbcMoveToNext(pReader->pTbc);
continue;
}
+ tdbTbcMoveToNext(pReader->pTbc);
break;
}
// copy the data
- if (vnodeRealloc(ppData, nData) < 0) {
+ if (tRealloc(ppData, sizeof(SSnapDataHdr) + nData) < 0) {
code = TSDB_CODE_OUT_OF_MEMORY;
return code;
}
+ ((SSnapDataHdr*)(*ppData))->type = 0; // TODO: use macro
+ ((SSnapDataHdr*)(*ppData))->size = nData;
+ memcpy(((SSnapDataHdr*)(*ppData))->data, pData, nData);
- memcpy(*ppData, pData, nData);
- *nDatap = nData;
+_exit:
+ return code;
+}
+
+// SMetaSnapWriter ========================================
+struct SMetaSnapWriter {
+ SMeta* pMeta;
+ int64_t sver;
+ int64_t ever;
+};
+
+static int32_t metaSnapRollback(SMetaSnapWriter* pWriter) {
+ int32_t code = 0;
+ // TODO
+ return code;
+}
+
+static int32_t metaSnapCommit(SMetaSnapWriter* pWriter) {
+ int32_t code = 0;
+ // TODO
+ return code;
+}
+
+int32_t metaSnapWriterOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapWriter** ppWriter) {
+ int32_t code = 0;
+ SMetaSnapWriter* pWriter;
+
+ // alloc
+ pWriter = (SMetaSnapWriter*)taosMemoryCalloc(1, sizeof(*pWriter));
+ if (pWriter == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+ pWriter->pMeta = pMeta;
+ pWriter->sver = sver;
+ pWriter->ever = ever;
+
+ *ppWriter = pWriter;
+ return code;
+
+_err:
+ metaError("vgId:%d meta snapshot writer open failed since %s", TD_VID(pMeta->pVnode), tstrerror(code));
+ *ppWriter = NULL;
+ return code;
+}
+
+int32_t metaSnapWriterClose(SMetaSnapWriter** ppWriter, int8_t rollback) {
+ int32_t code = 0;
+ SMetaSnapWriter* pWriter = *ppWriter;
+
+ if (rollback) {
+ code = metaSnapRollback(pWriter);
+ if (code) goto _err;
+ } else {
+ code = metaSnapCommit(pWriter);
+ if (code) goto _err;
+ }
+ taosMemoryFree(pWriter);
+ *ppWriter = NULL;
+
+ return code;
+
+_err:
+ metaError("vgId:%d meta snapshot writer close failed since %s", TD_VID(pWriter->pMeta->pVnode), tstrerror(code));
+ return code;
+}
+
+int32_t metaSnapWrite(SMetaSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
+ int32_t code = 0;
+ SMeta* pMeta = pWriter->pMeta;
+ SMetaEntry metaEntry = {0};
+ SDecoder* pDecoder = &(SDecoder){0};
+
+ tDecoderInit(pDecoder, pData, nData);
+ metaDecodeEntry(pDecoder, &metaEntry);
+
+ code = metaHandleEntry(pMeta, &metaEntry);
+ if (code) goto _err;
+
+ return code;
+
+_err:
+ metaError("vgId:%d meta snapshot write failed since %s", TD_VID(pMeta->pVnode), tstrerror(code));
return code;
}
\ No newline at end of file
diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index 341173103c..daf7ccb26a 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -17,7 +17,6 @@
static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema);
static int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema);
-static int metaHandleEntry(SMeta *pMeta, const SMetaEntry *pME);
static int metaSaveToTbDb(SMeta *pMeta, const SMetaEntry *pME);
static int metaUpdateUidIdx(SMeta *pMeta, const SMetaEntry *pME);
static int metaUpdateNameIdx(SMeta *pMeta, const SMetaEntry *pME);
@@ -51,7 +50,7 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const
if (pMeta->pTagIvtIdx == NULL || pCtbEntry == NULL) {
return -1;
}
- void * data = pCtbEntry->ctbEntry.pTags;
+ void *data = pCtbEntry->ctbEntry.pTags;
const char *tagName = pSchema->name;
tb_uid_t suid = pCtbEntry->ctbEntry.suid;
@@ -70,7 +69,7 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const
STagVal *pTagVal = (STagVal *)taosArrayGet(pTagVals, i);
char type = pTagVal->type;
- char * key = pTagVal->pKey;
+ char *key = pTagVal->pKey;
int32_t nKey = strlen(key);
SIndexTerm *term = NULL;
@@ -78,7 +77,7 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const
term = indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_VARCHAR, key, nKey, NULL, 0);
} else if (type == TSDB_DATA_TYPE_NCHAR) {
if (pTagVal->nData > 0) {
- char * val = taosMemoryCalloc(1, pTagVal->nData + VARSTR_HEADER_SIZE);
+ char *val = taosMemoryCalloc(1, pTagVal->nData + VARSTR_HEADER_SIZE);
int32_t len = taosUcs4ToMbs((TdUcs4 *)pTagVal->pData, pTagVal->nData, val + VARSTR_HEADER_SIZE);
memcpy(val, (uint16_t *)&len, VARSTR_HEADER_SIZE);
type = TSDB_DATA_TYPE_VARCHAR;
@@ -109,7 +108,7 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche
if (pMeta->pTagIvtIdx == NULL || pCtbEntry == NULL) {
return -1;
}
- void * data = pCtbEntry->ctbEntry.pTags;
+ void *data = pCtbEntry->ctbEntry.pTags;
const char *tagName = pSchema->name;
tb_uid_t suid = pCtbEntry->ctbEntry.suid;
@@ -128,7 +127,7 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche
STagVal *pTagVal = (STagVal *)taosArrayGet(pTagVals, i);
char type = pTagVal->type;
- char * key = pTagVal->pKey;
+ char *key = pTagVal->pKey;
int32_t nKey = strlen(key);
SIndexTerm *term = NULL;
@@ -136,7 +135,7 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche
term = indexTermCreate(suid, DEL_VALUE, TSDB_DATA_TYPE_VARCHAR, key, nKey, NULL, 0);
} else if (type == TSDB_DATA_TYPE_NCHAR) {
if (pTagVal->nData > 0) {
- char * val = taosMemoryCalloc(1, pTagVal->nData + VARSTR_HEADER_SIZE);
+ char *val = taosMemoryCalloc(1, pTagVal->nData + VARSTR_HEADER_SIZE);
int32_t len = taosUcs4ToMbs((TdUcs4 *)pTagVal->pData, pTagVal->nData, val + VARSTR_HEADER_SIZE);
memcpy(val, (uint16_t *)&len, VARSTR_HEADER_SIZE);
type = TSDB_DATA_TYPE_VARCHAR;
@@ -169,9 +168,9 @@ int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
int vLen = 0;
const void *pKey = NULL;
const void *pVal = NULL;
- void * pBuf = NULL;
+ void *pBuf = NULL;
int32_t szBuf = 0;
- void * p = NULL;
+ void *p = NULL;
SMetaReader mr = {0};
// validate req
@@ -229,7 +228,7 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq) {
}
// drop all child tables
- TBC * pCtbIdxc = NULL;
+ TBC *pCtbIdxc = NULL;
SArray *pArray = taosArrayInit(8, sizeof(tb_uid_t));
tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, &pMeta->txn);
@@ -285,8 +284,8 @@ _exit:
int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
SMetaEntry oStbEntry = {0};
SMetaEntry nStbEntry = {0};
- TBC * pUidIdxc = NULL;
- TBC * pTbDbc = NULL;
+ TBC *pUidIdxc = NULL;
+ TBC *pTbDbc = NULL;
const void *pData;
int nData;
int64_t oversion;
@@ -409,7 +408,7 @@ _err:
}
int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUids) {
- void * pData = NULL;
+ void *pData = NULL;
int nData = 0;
int rc = 0;
tb_uid_t uid;
@@ -477,7 +476,7 @@ static int metaDeleteTtlIdx(SMeta *pMeta, const SMetaEntry *pME) {
}
static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
- void * pData = NULL;
+ void *pData = NULL;
int nData = 0;
int rc = 0;
SMetaEntry e = {0};
@@ -538,14 +537,14 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
}
static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq, STableMetaRsp *pMetaRsp) {
- void * pVal = NULL;
+ void *pVal = NULL;
int nVal = 0;
- const void * pData = NULL;
+ const void *pData = NULL;
int nData = 0;
int ret = 0;
tb_uid_t uid;
int64_t oversion;
- SSchema * pColumn = NULL;
+ SSchema *pColumn = NULL;
SMetaEntry entry = {0};
SSchemaWrapper *pSchema;
int c;
@@ -699,7 +698,7 @@ _err:
static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
SMetaEntry ctbEntry = {0};
SMetaEntry stbEntry = {0};
- void * pVal = NULL;
+ void *pVal = NULL;
int nVal = 0;
int ret;
int c;
@@ -730,7 +729,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
oversion = *(int64_t *)pData;
// search table.db
- TBC * pTbDbc = NULL;
+ TBC *pTbDbc = NULL;
SDecoder dc1 = {0};
SDecoder dc2 = {0};
@@ -754,7 +753,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
metaDecodeEntry(&dc2, &stbEntry);
SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag;
- SSchema * pColumn = NULL;
+ SSchema *pColumn = NULL;
int32_t iCol = 0;
for (;;) {
pColumn = NULL;
@@ -784,8 +783,8 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
memcpy((void *)ctbEntry.ctbEntry.pTags, pAlterTbReq->pTagVal, pAlterTbReq->nTagVal);
} else {
const STag *pOldTag = (const STag *)ctbEntry.ctbEntry.pTags;
- STag * pNewTag = NULL;
- SArray * pTagArray = taosArrayInit(pTagSchema->nCols, sizeof(STagVal));
+ STag *pNewTag = NULL;
+ SArray *pTagArray = taosArrayInit(pTagSchema->nCols, sizeof(STagVal));
if (!pTagArray) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
goto _err;
@@ -844,7 +843,7 @@ _err:
}
static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
- void * pVal = NULL;
+ void *pVal = NULL;
int nVal = 0;
const void *pData = NULL;
int nData = 0;
@@ -948,8 +947,8 @@ int metaAlterTable(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMeta
static int metaSaveToTbDb(SMeta *pMeta, const SMetaEntry *pME) {
STbDbKey tbDbKey;
- void * pKey = NULL;
- void * pVal = NULL;
+ void *pKey = NULL;
+ void *pVal = NULL;
int kLen = 0;
int vLen = 0;
SEncoder coder = {0};
@@ -1055,14 +1054,14 @@ static void metaDestroyTagIdxKey(STagIdxKey *pTagIdxKey) {
}
static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
- void * pData = NULL;
+ void *pData = NULL;
int nData = 0;
STbDbKey tbDbKey = {0};
SMetaEntry stbEntry = {0};
- STagIdxKey * pTagIdxKey = NULL;
+ STagIdxKey *pTagIdxKey = NULL;
int32_t nTagIdxKey;
const SSchema *pTagColumn; // = &stbEntry.stbEntry.schema.pSchema[0];
- const void * pTagData = NULL; //
+ const void *pTagData = NULL; //
int32_t nTagData = 0;
SDecoder dc = {0};
@@ -1109,7 +1108,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
static int metaSaveToSkmDb(SMeta *pMeta, const SMetaEntry *pME) {
SEncoder coder = {0};
- void * pVal = NULL;
+ void *pVal = NULL;
int vLen = 0;
int rcode = 0;
SSkmDbKey skmDbKey = {0};
@@ -1151,7 +1150,7 @@ _exit:
return rcode;
}
-static int metaHandleEntry(SMeta *pMeta, const SMetaEntry *pME) {
+int metaHandleEntry(SMeta *pMeta, const SMetaEntry *pME) {
metaWLock(pMeta);
// save to table.db
diff --git a/source/dnode/vnode/src/sma/smaEnv.c b/source/dnode/vnode/src/sma/smaEnv.c
index bb8dd48236..5eb9665326 100644
--- a/source/dnode/vnode/src/sma/smaEnv.c
+++ b/source/dnode/vnode/src/sma/smaEnv.c
@@ -49,16 +49,26 @@ int32_t smaInit() {
}
if (old == 0) {
+ // init tref rset
smaMgmt.rsetId = taosOpenRef(SMA_MGMT_REF_NUM, tdDestroyRSmaStat);
if (smaMgmt.rsetId < 0) {
- smaError("failed to init sma rset since %s", terrstr());
atomic_store_8(&smaMgmt.inited, 0);
+ smaError("failed to init sma rset since %s", terrstr());
+ return TSDB_CODE_FAILED;
+ }
+
+ // init fetch timer handle
+ smaMgmt.tmrHandle = taosTmrInit(10000, 100, 10000, "RSMA");
+ if (!smaMgmt.tmrHandle) {
+ taosCloseRef(smaMgmt.rsetId);
+ atomic_store_8(&smaMgmt.inited, 0);
+ smaError("failed to init sma tmr hanle since %s", terrstr());
return TSDB_CODE_FAILED;
}
- smaInfo("sma rset is initialized, rsetId:%d", smaMgmt.rsetId);
atomic_store_8(&smaMgmt.inited, 1);
+ smaInfo("sma mgmt env is initialized, rsetId:%d, tmrHandle:%p", smaMgmt.rsetId, smaMgmt.tmrHandle);
}
return TSDB_CODE_SUCCESS;
@@ -81,8 +91,9 @@ void smaCleanUp() {
}
if (old == 1) {
- smaInfo("sma rset is cleaned up, resetId:%d", smaMgmt.rsetId);
taosCloseRef(smaMgmt.rsetId);
+ taosTmrCleanUp(smaMgmt.tmrHandle);
+ smaInfo("sma mgmt env is cleaned up, rsetId:%d, tmrHandle:%p", smaMgmt.rsetId, smaMgmt.tmrHandle);
atomic_store_8(&smaMgmt.inited, 0);
}
}
@@ -203,20 +214,11 @@ static int32_t tdInitSmaStat(SSmaStat **pSmaStat, int8_t smaType, const SSma *pS
}
pRSmaStat->refId = refId;
- // init timer
- RSMA_TMR_HANDLE(pRSmaStat) = taosTmrInit(10000, 100, 10000, "RSMA");
- if (!RSMA_TMR_HANDLE(pRSmaStat)) {
- taosMemoryFreeClear(*pSmaStat);
- return TSDB_CODE_FAILED;
- }
// init hash
RSMA_INFO_HASH(pRSmaStat) = taosHashInit(
RSMA_TASK_INFO_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
if (!RSMA_INFO_HASH(pRSmaStat)) {
- if (RSMA_TMR_HANDLE(pRSmaStat)) {
- taosTmrCleanUp(RSMA_TMR_HANDLE(pRSmaStat));
- }
taosMemoryFreeClear(*pSmaStat);
return TSDB_CODE_FAILED;
}
@@ -277,7 +279,7 @@ static void tdDestroyRSmaStat(void *pRSmaStat) {
void *infoHash = taosHashIterate(RSMA_INFO_HASH(pStat), NULL);
while (infoHash) {
SRSmaInfo *pSmaInfo = *(SRSmaInfo **)infoHash;
- tdFreeRSmaInfo(pSmaInfo);
+ tdFreeRSmaInfo(pSma, pSmaInfo);
infoHash = taosHashIterate(RSMA_INFO_HASH(pStat), infoHash);
}
}
@@ -298,11 +300,6 @@ static void tdDestroyRSmaStat(void *pRSmaStat) {
nLoops = 0;
}
}
-
- // step 6: cleanup the timer handle
- if (RSMA_TMR_HANDLE(pStat)) {
- taosTmrCleanUp(RSMA_TMR_HANDLE(pStat));
- }
}
}
diff --git a/source/dnode/vnode/src/sma/smaRollup.c b/source/dnode/vnode/src/sma/smaRollup.c
index c44a46ac5a..efa2886e48 100644
--- a/source/dnode/vnode/src/sma/smaRollup.c
+++ b/source/dnode/vnode/src/sma/smaRollup.c
@@ -27,16 +27,19 @@ SSmaMgmt smaMgmt = {
typedef struct SRSmaQTaskInfoItem SRSmaQTaskInfoItem;
typedef struct SRSmaQTaskInfoIter SRSmaQTaskInfoIter;
-static int32_t tdUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid);
-static int32_t tdUpdateTbUidListImpl(SSma *pSma, tb_uid_t *suid, SArray *tbUids);
-static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaInfo *pRSmaInfo, SReadHandle *handle,
- int8_t idx);
-static int32_t tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t inputType, SRSmaInfoItem *rsmaItem,
- tb_uid_t suid, int8_t level);
-static void tdRSmaFetchTrigger(void *param, void *tmrId);
-static void tdRSmaPersistTrigger(void *param, void *tmrId);
-static void *tdRSmaPersistExec(void *param);
-static void tdRSmaQTaskInfoGetFName(int32_t vid, int64_t version, char *outputName);
+static int32_t tdUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid);
+static int32_t tdUpdateTbUidListImpl(SSma *pSma, tb_uid_t *suid, SArray *tbUids);
+static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat *pStat, SRSmaInfo *pRSmaInfo,
+ SReadHandle *handle, int8_t idx);
+static int32_t tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t inputType, SRSmaInfoItem *rsmaItem,
+ STSchema *pTSchema, tb_uid_t suid, int8_t level);
+static SRSmaInfo *tdGetRSmaInfoBySuid(SSma *pSma, int64_t suid);
+static int32_t tdRSmaFetchAndSubmitResult(SRSmaInfoItem *pItem, STSchema *pTSchema, int64_t suid, SRSmaStat *pStat,
+ int8_t blkType);
+static void tdRSmaFetchTrigger(void *param, void *tmrId);
+static void tdRSmaPersistTrigger(void *param, void *tmrId);
+static void *tdRSmaPersistExec(void *param);
+static void tdRSmaQTaskInfoGetFName(int32_t vid, int64_t version, char *outputName);
static int32_t tdRSmaQTaskInfoIterInit(SRSmaQTaskInfoIter *pIter, STFile *pTFile);
static int32_t tdRSmaQTaskInfoIterNextBlock(SRSmaQTaskInfoIter *pIter, bool *isFinish);
@@ -48,25 +51,26 @@ static int32_t tdRSmaRestoreQTaskInfoReload(SSma *pSma, int64_t *committed);
static int32_t tdRSmaRestoreTSDataReload(SSma *pSma, int64_t committed);
struct SRSmaInfoItem {
- SRSmaInfo *pRsmaInfo;
- int64_t refId;
- void *taskInfo; // qTaskInfo_t
- tmr_h tmrId;
- int8_t level;
- int8_t tmrInitFlag;
- int8_t triggerStat;
- int32_t maxDelay;
+ void *taskInfo; // qTaskInfo_t
+ int64_t refId;
+ tmr_h tmrId;
+ int32_t maxDelay;
+ int8_t level;
+ int8_t triggerStat;
};
struct SRSmaInfo {
STSchema *pTSchema;
- SRSmaStat *pStat;
int64_t suid;
SRSmaInfoItem items[TSDB_RETENTION_L2];
};
-#define RSMA_INFO_SMA(r) ((r)->pStat->pSma)
-#define RSMA_INFO_STAT(r) ((r)->pStat)
+static SRSmaInfo *tdGetRSmaInfoByItem(SRSmaInfoItem *pItem) {
+ // adapt accordingly if definition of SRSmaInfo update
+ int32_t rsmaInfoHeadLen = sizeof(int64_t) + sizeof(STSchema *);
+ ASSERT(pItem->level == 1 || pItem->level == 2);
+ return (SRSmaInfo *)POINTER_SHIFT(pItem, -sizeof(SRSmaInfoItem) * (pItem->level - 1) - rsmaInfoHeadLen);
+}
struct SRSmaQTaskInfoItem {
int32_t len;
@@ -108,9 +112,8 @@ static FORCE_INLINE void tdFreeTaskHandle(qTaskInfo_t *taskHandle, int32_t vgId,
}
}
-void *tdFreeRSmaInfo(SRSmaInfo *pInfo) {
+void *tdFreeRSmaInfo(SSma *pSma, SRSmaInfo *pInfo) {
if (pInfo) {
- SSma *pSma = RSMA_INFO_SMA(pInfo);
for (int32_t i = 0; i < TSDB_RETENTION_L2; ++i) {
SRSmaInfoItem *pItem = &pInfo->items[i];
if (pItem->taskInfo) {
@@ -143,8 +146,6 @@ static FORCE_INLINE int32_t tdUidStoreInit(STbUidStore **pStore) {
}
static int32_t tdUpdateTbUidListImpl(SSma *pSma, tb_uid_t *suid, SArray *tbUids) {
- SSmaEnv *pEnv = SMA_RSMA_ENV(pSma);
- SRSmaStat *pStat = (SRSmaStat *)SMA_ENV_STAT(pEnv);
SRSmaInfo *pRSmaInfo = NULL;
if (!suid || !tbUids) {
@@ -153,8 +154,9 @@ static int32_t tdUpdateTbUidListImpl(SSma *pSma, tb_uid_t *suid, SArray *tbUids)
return TSDB_CODE_FAILED;
}
- pRSmaInfo = taosHashGet(RSMA_INFO_HASH(pStat), suid, sizeof(tb_uid_t));
- if (!pRSmaInfo || !(pRSmaInfo = *(SRSmaInfo **)pRSmaInfo)) {
+ pRSmaInfo = tdGetRSmaInfoBySuid(pSma, *suid);
+
+ if (!pRSmaInfo) {
smaError("vgId:%d, failed to get rsma info for uid:%" PRIi64, SMA_VID(pSma), *suid);
terrno = TSDB_CODE_RSMA_INVALID_STAT;
return TSDB_CODE_FAILED;
@@ -252,15 +254,14 @@ int32_t tdFetchTbUidList(SSma *pSma, STbUidStore **ppStore, tb_uid_t suid, tb_ui
return TSDB_CODE_SUCCESS;
}
-static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaInfo *pRSmaInfo, SReadHandle *pReadHandle,
- int8_t idx) {
+static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat *pStat, SRSmaInfo *pRSmaInfo,
+ SReadHandle *pReadHandle, int8_t idx) {
SRetention *pRetention = SMA_RETENTION(pSma);
STsdbCfg *pTsdbCfg = SMA_TSDB_CFG(pSma);
if (param->qmsg[idx]) {
SRSmaInfoItem *pItem = &(pRSmaInfo->items[idx]);
- pItem->refId = RSMA_REF_ID(pRSmaInfo->pStat);
- pItem->pRsmaInfo = pRSmaInfo;
+ pItem->refId = RSMA_REF_ID(pStat);
pItem->taskInfo = qCreateStreamExecTaskInfo(param->qmsg[idx], pReadHandle);
if (!pItem->taskInfo) {
terrno = TSDB_CODE_RSMA_QTASKINFO_CREATE;
@@ -348,14 +349,13 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
goto _err;
}
pRSmaInfo->pTSchema = pTSchema;
- pRSmaInfo->pStat = pStat;
pRSmaInfo->suid = suid;
- if (tdSetRSmaInfoItemParams(pSma, param, pRSmaInfo, &handle, 0) < 0) {
+ if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, &handle, 0) < 0) {
goto _err;
}
- if (tdSetRSmaInfoItemParams(pSma, param, pRSmaInfo, &handle, 1) < 0) {
+ if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, &handle, 1) < 0) {
goto _err;
}
@@ -367,7 +367,7 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
return TSDB_CODE_SUCCESS;
_err:
- tdFreeRSmaInfo(pRSmaInfo);
+ tdFreeRSmaInfo(pSma, pRSmaInfo);
taosMemoryFree(pReader);
return TSDB_CODE_FAILED;
}
@@ -538,10 +538,10 @@ int64_t tdRSmaGetMaxSubmitVer(SSma *pSma, int8_t level) {
return atomic_load_64(&pRSmaStat->submitVer);
}
-static int32_t tdFetchAndSubmitRSmaResult(SRSmaInfoItem *pItem, int8_t blkType) {
- SArray *pResult = NULL;
- SRSmaInfo *pRSmaInfo = pItem->pRsmaInfo;
- SSma *pSma = RSMA_INFO_SMA(pRSmaInfo);
+static int32_t tdRSmaFetchAndSubmitResult(SRSmaInfoItem *pItem, STSchema *pTSchema, int64_t suid, SRSmaStat *pStat,
+ int8_t blkType) {
+ SArray *pResult = NULL;
+ SSma *pSma = pStat->pSma;
while (1) {
SSDataBlock *output = NULL;
@@ -573,16 +573,16 @@ static int32_t tdFetchAndSubmitRSmaResult(SRSmaInfoItem *pItem, int8_t blkType)
STsdb *sinkTsdb = (pItem->level == TSDB_RETENTION_L1 ? pSma->pRSmaTsdb1 : pSma->pRSmaTsdb2);
SSubmitReq *pReq = NULL;
// TODO: the schema update should be handled
- if (buildSubmitReqFromDataBlock(&pReq, pResult, pRSmaInfo->pTSchema, SMA_VID(pSma), pRSmaInfo->suid) < 0) {
+ if (buildSubmitReqFromDataBlock(&pReq, pResult, pTSchema, SMA_VID(pSma), suid) < 0) {
smaError("vgId:%d, build submit req for rsma table %" PRIi64 "l evel %" PRIi8 " failed since %s", SMA_VID(pSma),
- pRSmaInfo->suid, pItem->level, terrstr());
+ suid, pItem->level, terrstr());
goto _err;
}
- if (pReq && tdProcessSubmitReq(sinkTsdb, atomic_add_fetch_64(&pRSmaInfo->pStat->submitVer, 1), pReq) < 0) {
+ if (pReq && tdProcessSubmitReq(sinkTsdb, atomic_add_fetch_64(&pStat->submitVer, 1), pReq) < 0) {
taosMemoryFreeClear(pReq);
smaError("vgId:%d, process submit req for rsma table %" PRIi64 " level %" PRIi8 " failed since %s", SMA_VID(pSma),
- pRSmaInfo->suid, pItem->level, terrstr());
+ suid, pItem->level, terrstr());
goto _err;
}
@@ -600,84 +600,16 @@ _err:
return TSDB_CODE_FAILED;
}
-/**
- * @brief trigger to get rsma result
- *
- * @param param
- * @param tmrId
- */
-static void tdRSmaFetchTrigger(void *param, void *tmrId) {
- SRSmaInfoItem *pItem = param;
- SSma *pSma = NULL;
- SRSmaStat *pStat = (SRSmaStat *)tdAcquireSmaRef(smaMgmt.rsetId, pItem->refId, __func__, __LINE__);
-
- if (!pStat) {
- smaDebug("rsma fetch task not start since already destroyed, rsetId rsetId:%" PRIi64 " refId:%d)", smaMgmt.rsetId,
- pItem->refId);
- return;
- }
-
- pSma = RSMA_INFO_SMA(pItem->pRsmaInfo);
-
- // if rsma trigger stat in paused, cancelled or finished, not start fetch task
- int8_t rsmaTriggerStat = atomic_load_8(RSMA_TRIGGER_STAT(pStat));
- switch (rsmaTriggerStat) {
- case TASK_TRIGGER_STAT_PAUSED:
- case TASK_TRIGGER_STAT_CANCELLED:
- case TASK_TRIGGER_STAT_FINISHED: {
- tdReleaseSmaRef(smaMgmt.rsetId, pItem->refId, __func__, __LINE__);
- smaDebug("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is %" PRIi8
- ", rsetId rsetId:%" PRIi64 " refId:%d",
- SMA_VID(pSma), pItem->level, pItem->pRsmaInfo->suid, rsmaTriggerStat, smaMgmt.rsetId, pItem->refId);
- return;
- }
- default:
- break;
- }
-
- int8_t fetchTriggerStat =
- atomic_val_compare_exchange_8(&pItem->triggerStat, TASK_TRIGGER_STAT_ACTIVE, TASK_TRIGGER_STAT_INACTIVE);
- switch (fetchTriggerStat) {
- case TASK_TRIGGER_STAT_ACTIVE: {
- smaDebug("vgId:%d, fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is active", SMA_VID(pSma),
- pItem->level, pItem->pRsmaInfo->suid);
-
- tdRefSmaStat(pSma, (SSmaStat *)pStat);
-
- SSDataBlock dataBlock = {.info.type = STREAM_GET_ALL};
- qSetStreamInput(pItem->taskInfo, &dataBlock, STREAM_INPUT__DATA_BLOCK, false);
- tdFetchAndSubmitRSmaResult(pItem, STREAM_INPUT__DATA_BLOCK);
-
- tdUnRefSmaStat(pSma, (SSmaStat *)pStat);
- } break;
- case TASK_TRIGGER_STAT_PAUSED: {
- smaDebug("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is paused",
- SMA_VID(pSma), pItem->level, pItem->pRsmaInfo->suid);
- } break;
- case TASK_TRIGGER_STAT_INACTIVE: {
- smaDebug("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is inactive",
- SMA_VID(pSma), pItem->level, pItem->pRsmaInfo->suid);
- } break;
- case TASK_TRIGGER_STAT_INIT: {
- smaDebug("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is init", SMA_VID(pSma),
- pItem->level, pItem->pRsmaInfo->suid);
- } break;
- default: {
- smaWarn("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is unknown",
- SMA_VID(pSma), pItem->level, pItem->pRsmaInfo->suid);
- } break;
- }
-
-_end:
- tdReleaseSmaRef(smaMgmt.rsetId, pItem->refId, __func__, __LINE__);
-}
-
-static int32_t tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t inputType, SRSmaInfoItem *pItem, tb_uid_t suid,
- int8_t level) {
+static int32_t tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t inputType, SRSmaInfoItem *pItem,
+ STSchema *pTSchema, tb_uid_t suid, int8_t level) {
if (!pItem || !pItem->taskInfo) {
smaDebug("vgId:%d, no qTaskInfo to execute rsma %" PRIi8 " task for suid:%" PRIu64, SMA_VID(pSma), level, suid);
return TSDB_CODE_SUCCESS;
}
+ if (!pTSchema) {
+ smaWarn("vgId:%d, no schema to execute rsma %" PRIi8 " task for suid:%" PRIu64, SMA_VID(pSma), level, suid);
+ return TSDB_CODE_FAILED;
+ }
smaDebug("vgId:%d, execute rsma %" PRIi8 " task for qTaskInfo:%p suid:%" PRIu64, SMA_VID(pSma), level,
pItem->taskInfo, suid);
@@ -687,14 +619,14 @@ static int32_t tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t inputType
return TSDB_CODE_FAILED;
}
- tdFetchAndSubmitRSmaResult(pItem, STREAM_INPUT__DATA_SUBMIT);
- atomic_store_8(&pItem->triggerStat, TASK_TRIGGER_STAT_ACTIVE);
-
SSmaEnv *pEnv = SMA_RSMA_ENV(pSma);
SRSmaStat *pStat = SMA_RSMA_STAT(pEnv->pStat);
- if (pStat->tmrHandle) {
- taosTmrReset(tdRSmaFetchTrigger, pItem->maxDelay, pItem, pStat->tmrHandle, &pItem->tmrId);
+ tdRSmaFetchAndSubmitResult(pItem, pTSchema, suid, pStat, STREAM_INPUT__DATA_SUBMIT);
+ atomic_store_8(&pItem->triggerStat, TASK_TRIGGER_STAT_ACTIVE);
+
+ if (smaMgmt.tmrHandle) {
+ taosTmrReset(tdRSmaFetchTrigger, pItem->maxDelay, pItem, smaMgmt.tmrHandle, &pItem->tmrId);
} else {
ASSERT(0);
}
@@ -702,19 +634,29 @@ static int32_t tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t inputType
return TSDB_CODE_SUCCESS;
}
-static int32_t tdExecuteRSma(SSma *pSma, const void *pMsg, int32_t inputType, tb_uid_t suid) {
- SSmaEnv *pEnv = SMA_RSMA_ENV(pSma);
+static SRSmaInfo *tdGetRSmaInfoBySuid(SSma *pSma, int64_t suid) {
+ SSmaEnv *pEnv = SMA_RSMA_ENV(pSma);
+ SRSmaStat *pStat = NULL;
if (!pEnv) {
// only applicable when rsma env exists
- return TSDB_CODE_SUCCESS;
+ return NULL;
}
- SRSmaStat *pStat = (SRSmaStat *)SMA_ENV_STAT(pEnv);
- SRSmaInfo *pRSmaInfo = NULL;
-
- pRSmaInfo = taosHashGet(RSMA_INFO_HASH(pStat), &suid, sizeof(tb_uid_t));
+ pStat = (SRSmaStat *)SMA_ENV_STAT(pEnv);
+ if (!pStat || !RSMA_INFO_HASH(pStat)) {
+ return NULL;
+ }
+ SRSmaInfo *pRSmaInfo = taosHashGet(RSMA_INFO_HASH(pStat), &suid, sizeof(tb_uid_t));
if (!pRSmaInfo || !(pRSmaInfo = *(SRSmaInfo **)pRSmaInfo)) {
+ return NULL;
+ }
+ return pRSmaInfo;
+}
+
+static int32_t tdExecuteRSma(SSma *pSma, const void *pMsg, int32_t inputType, tb_uid_t suid) {
+ SRSmaInfo *pRSmaInfo = tdGetRSmaInfoBySuid(pSma, suid);
+ if (!pRSmaInfo) {
smaDebug("vgId:%d, return as no rsma info for suid:%" PRIu64, SMA_VID(pSma), suid);
return TSDB_CODE_SUCCESS;
}
@@ -725,8 +667,8 @@ static int32_t tdExecuteRSma(SSma *pSma, const void *pMsg, int32_t inputType, tb
}
if (inputType == STREAM_INPUT__DATA_SUBMIT) {
- tdExecuteRSmaImpl(pSma, pMsg, inputType, &pRSmaInfo->items[0], suid, TSDB_RETENTION_L1);
- tdExecuteRSmaImpl(pSma, pMsg, inputType, &pRSmaInfo->items[1], suid, TSDB_RETENTION_L2);
+ tdExecuteRSmaImpl(pSma, pMsg, inputType, &pRSmaInfo->items[0], pRSmaInfo->pTSchema, suid, TSDB_RETENTION_L1);
+ tdExecuteRSmaImpl(pSma, pMsg, inputType, &pRSmaInfo->items[1], pRSmaInfo->pTSchema, suid, TSDB_RETENTION_L2);
}
return TSDB_CODE_SUCCESS;
@@ -939,13 +881,11 @@ _err:
}
static int32_t tdRSmaQTaskInfoItemRestore(SSma *pSma, const SRSmaQTaskInfoItem *pItem) {
- SRSmaStat *pStat = (SRSmaStat *)SMA_ENV_STAT((SSmaEnv *)pSma->pRSmaEnv);
SRSmaInfo *pRSmaInfo = NULL;
void *qTaskInfo = NULL;
- pRSmaInfo = taosHashGet(RSMA_INFO_HASH(pStat), &pItem->suid, sizeof(pItem->suid));
-
- if (!pRSmaInfo || !(pRSmaInfo = *(SRSmaInfo **)pRSmaInfo)) {
+ pRSmaInfo = tdGetRSmaInfoBySuid(pSma, pItem->suid);
+ if (!pRSmaInfo) {
smaDebug("vgId:%d, no restore as no rsma info for table:%" PRIu64, SMA_VID(pSma), pItem->suid);
return TSDB_CODE_SUCCESS;
}
@@ -1350,3 +1290,79 @@ static void tdRSmaPersistTrigger(void *param, void *tmrId) {
}
taosReleaseRef(smaMgmt.rsetId, rsmaStat->refId);
}
+
+/**
+ * @brief trigger to get rsma result
+ *
+ * @param param
+ * @param tmrId
+ */
+static void tdRSmaFetchTrigger(void *param, void *tmrId) {
+ SRSmaInfoItem *pItem = param;
+ SSma *pSma = NULL;
+ SRSmaStat *pStat = (SRSmaStat *)tdAcquireSmaRef(smaMgmt.rsetId, pItem->refId, __func__, __LINE__);
+
+ if (!pStat) {
+ smaDebug("rsma fetch task not start since already destroyed, rsetId rsetId:%" PRIi64 " refId:%d)", smaMgmt.rsetId,
+ pItem->refId);
+ return;
+ }
+
+ pSma = pStat->pSma;
+
+ // if rsma trigger stat in paused, cancelled or finished, not start fetch task
+ int8_t rsmaTriggerStat = atomic_load_8(RSMA_TRIGGER_STAT(pStat));
+ switch (rsmaTriggerStat) {
+ case TASK_TRIGGER_STAT_PAUSED:
+ case TASK_TRIGGER_STAT_CANCELLED:
+ case TASK_TRIGGER_STAT_FINISHED: {
+ tdReleaseSmaRef(smaMgmt.rsetId, pItem->refId, __func__, __LINE__);
+ smaDebug("vgId:%d, not fetch rsma level %" PRIi8 " data since stat is %" PRIi8 ", rsetId rsetId:%" PRIi64
+ " refId:%d",
+ SMA_VID(pSma), pItem->level, rsmaTriggerStat, smaMgmt.rsetId, pItem->refId);
+ return;
+ }
+ default:
+ break;
+ }
+
+ SRSmaInfo *pRSmaInfo = tdGetRSmaInfoByItem(pItem);
+
+ ASSERT(pRSmaInfo->suid > 0);
+
+ int8_t fetchTriggerStat =
+ atomic_val_compare_exchange_8(&pItem->triggerStat, TASK_TRIGGER_STAT_ACTIVE, TASK_TRIGGER_STAT_INACTIVE);
+ switch (fetchTriggerStat) {
+ case TASK_TRIGGER_STAT_ACTIVE: {
+ smaDebug("vgId:%d, fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is active", SMA_VID(pSma),
+ pItem->level, pRSmaInfo->suid);
+
+ tdRefSmaStat(pSma, (SSmaStat *)pStat);
+
+ SSDataBlock dataBlock = {.info.type = STREAM_GET_ALL};
+ qSetStreamInput(pItem->taskInfo, &dataBlock, STREAM_INPUT__DATA_BLOCK, false);
+ tdRSmaFetchAndSubmitResult(pItem, pRSmaInfo->pTSchema, pRSmaInfo->suid, pStat, STREAM_INPUT__DATA_BLOCK);
+
+ tdUnRefSmaStat(pSma, (SSmaStat *)pStat);
+ } break;
+ case TASK_TRIGGER_STAT_PAUSED: {
+ smaDebug("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is paused",
+ SMA_VID(pSma), pItem->level, pRSmaInfo->suid);
+ } break;
+ case TASK_TRIGGER_STAT_INACTIVE: {
+ smaDebug("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is inactive",
+ SMA_VID(pSma), pItem->level, pRSmaInfo->suid);
+ } break;
+ case TASK_TRIGGER_STAT_INIT: {
+ smaDebug("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is init", SMA_VID(pSma),
+ pItem->level, pRSmaInfo->suid);
+ } break;
+ default: {
+ smaWarn("vgId:%d, not fetch rsma level %" PRIi8 " data for table:%" PRIi64 " since stat is unknown",
+ SMA_VID(pSma), pItem->level, pRSmaInfo->suid);
+ } break;
+ }
+
+_end:
+ tdReleaseSmaRef(smaMgmt.rsetId, pItem->refId, __func__, __LINE__);
+}
diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c
index 52949838b9..e0afc6c80f 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -112,7 +112,8 @@ int32_t tqSendMetaPollRsp(STQ* pTq, const SRpcMsg* pMsg, const SMqPollReq* pReq,
};
tmsgSendRsp(&resp);
- tqDebug("vgId:%d from consumer:%" PRId64 ", (epoch %d) send rsp, res msg type %d, reqOffset:%" PRId64 ", rspOffset:%" PRId64,
+ tqDebug("vgId:%d from consumer:%" PRId64 ", (epoch %d) send rsp, res msg type %d, reqOffset:%" PRId64
+ ", rspOffset:%" PRId64,
TD_VID(pTq->pVnode), pReq->consumerId, pReq->epoch, pRsp->resMsgType, pRsp->reqOffset, pRsp->rspOffset);
return 0;
@@ -179,8 +180,8 @@ int32_t tqProcessOffsetCommitReq(STQ* pTq, char* msg, int32_t msgLen) {
tDecoderClear(&decoder);
if (offset.val.type == TMQ_OFFSET__SNAPSHOT_DATA) {
- tqDebug("receive offset commit msg to %s on vgId:%d, offset(type:snapshot) uid:%" PRId64 ", ts:%" PRId64, offset.subKey,
- TD_VID(pTq->pVnode), offset.val.uid, offset.val.ts);
+ tqDebug("receive offset commit msg to %s on vgId:%d, offset(type:snapshot) uid:%" PRId64 ", ts:%" PRId64,
+ offset.subKey, TD_VID(pTq->pVnode), offset.val.uid, offset.val.ts);
} else if (offset.val.type == TMQ_OFFSET__LOG) {
tqDebug("receive offset commit msg to %s on vgId:%d, offset(type:log) version:%" PRId64, offset.subKey,
TD_VID(pTq->pVnode), offset.val.version);
@@ -271,6 +272,9 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
tqDebug("tmq poll: consumer %ld (epoch %d), subkey %s, recv poll req in vg %d, req offset %s", consumerId,
pReq->epoch, pHandle->subKey, TD_VID(pTq->pVnode), buf);
+ SMqDataRsp dataRsp = {0};
+ tqInitDataRsp(&dataRsp, pReq, pHandle->execHandle.subType);
+
// 2.reset offset if needed
if (reqOffset.type > 0) {
fetchOffsetNew = reqOffset;
@@ -294,50 +298,36 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
tqOffsetResetToLog(&fetchOffsetNew, walGetFirstVer(pTq->pVnode->pWal));
}
} else if (reqOffset.type == TMQ_OFFSET__RESET_LATEST) {
- tqOffsetResetToLog(&fetchOffsetNew, walGetLastVer(pTq->pVnode->pWal));
+ tqOffsetResetToLog(&dataRsp.rspOffset, walGetLastVer(pTq->pVnode->pWal));
tqDebug("tmq poll: consumer %ld, subkey %s, offset reset to %ld", consumerId, pHandle->subKey,
- fetchOffsetNew.version);
- SMqDataRsp dataRsp = {0};
- tqInitDataRsp(&dataRsp, pReq, pHandle->execHandle.subType);
- dataRsp.rspOffset = fetchOffsetNew;
- code = 0;
+ dataRsp.rspOffset.version);
if (tqSendDataRsp(pTq, pMsg, pReq, &dataRsp) < 0) {
code = -1;
}
- taosArrayDestroy(dataRsp.blockDataLen);
- taosArrayDestroyP(dataRsp.blockData, (FDelete)taosMemoryFree);
-
- if (dataRsp.withSchema) {
- taosArrayDestroyP(dataRsp.blockSchema, (FDelete)tDeleteSSchemaWrapper);
- }
-
- if (dataRsp.withTbName) {
- taosArrayDestroyP(dataRsp.blockTbName, (FDelete)taosMemoryFree);
- }
- return code;
+ goto OVER;
} else if (reqOffset.type == TMQ_OFFSET__RESET_NONE) {
tqError("tmq poll: subkey %s, no offset committed for consumer %" PRId64
" in vg %d, subkey %s, reset none failed",
pHandle->subKey, consumerId, TD_VID(pTq->pVnode), pReq->subKey);
terrno = TSDB_CODE_TQ_NO_COMMITTED_OFFSET;
- return -1;
+ code = -1;
+ goto OVER;
}
}
}
// 3.query
- SMqDataRsp dataRsp = {0};
- tqInitDataRsp(&dataRsp, pReq, pHandle->execHandle.subType);
-
- if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN && fetchOffsetNew.type == TMQ_OFFSET__LOG) {
- fetchOffsetNew.version++;
- if (tqScanLog(pTq, &pHandle->execHandle, &dataRsp, &fetchOffsetNew) < 0) {
+ if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+ if (fetchOffsetNew.type == TMQ_OFFSET__LOG) {
+ fetchOffsetNew.version++;
+ }
+ if (tqScan(pTq, &pHandle->execHandle, &dataRsp, &fetchOffsetNew) < 0) {
ASSERT(0);
code = -1;
goto OVER;
}
if (dataRsp.blockNum == 0) {
- // TODO add to async task
+ // TODO add to async task pool
/*dataRsp.rspOffset.version--;*/
}
if (tqSendDataRsp(pTq, pMsg, pReq, &dataRsp) < 0) {
@@ -346,11 +336,12 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
goto OVER;
}
- if (pHandle->execHandle.subType != TOPIC_SUB_TYPE__COLUMN && fetchOffsetNew.type == TMQ_OFFSET__LOG) {
+ if (pHandle->execHandle.subType != TOPIC_SUB_TYPE__COLUMN) {
int64_t fetchVer = fetchOffsetNew.version + 1;
SWalCkHead* pCkHead = taosMemoryMalloc(sizeof(SWalCkHead) + 2048);
if (pCkHead == NULL) {
- return -1;
+ code = -1;
+ goto OVER;
}
walSetReaderCapacity(pHandle->pWalReader, 2048);
@@ -423,6 +414,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
}
taosMemoryFree(pCkHead);
+#if 0
} else if (fetchOffsetNew.type == TMQ_OFFSET__SNAPSHOT_DATA) {
tqInfo("retrieve using snapshot actual offset: uid %" PRId64 " ts %" PRId64, fetchOffsetNew.uid, fetchOffsetNew.ts);
if (tqScanSnapshot(pTq, &pHandle->execHandle, &dataRsp, fetchOffsetNew, workerId) < 0) {
@@ -433,6 +425,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
if (tqSendDataRsp(pTq, pMsg, pReq, &dataRsp) < 0) {
code = -1;
}
+#endif
} else if (fetchOffsetNew.type == TMQ_OFFSET__SNAPSHOT_META) {
ASSERT(0);
}
diff --git a/source/dnode/vnode/src/tq/tqExec.c b/source/dnode/vnode/src/tq/tqExec.c
index d381cfcdc7..49cf42b083 100644
--- a/source/dnode/vnode/src/tq/tqExec.c
+++ b/source/dnode/vnode/src/tq/tqExec.c
@@ -59,15 +59,17 @@ static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, SMqDataRsp* pRsp) {
return 0;
}
-int64_t tqScanLog(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal* pOffset) {
+int64_t tqScan(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal* pOffset) {
qTaskInfo_t task = pExec->execCol.task[0];
- if (qStreamPrepareScan1(task, pOffset) < 0) {
+ if (qStreamPrepareScan(task, pOffset) < 0) {
+ ASSERT(pOffset->type == TMQ_OFFSET__LOG);
pRsp->rspOffset = *pOffset;
pRsp->rspOffset.version--;
return 0;
}
+ int32_t rowCnt = 0;
while (1) {
SSDataBlock* pDataBlock = NULL;
uint64_t ts = 0;
@@ -77,12 +79,21 @@ int64_t tqScanLog(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOff
if (pDataBlock != NULL) {
tqAddBlockDataToRsp(pDataBlock, pRsp);
- if (pRsp->withTbName) {
- int64_t uid = pExec->pExecReader[0]->msgIter.uid;
- tqAddTbNameToRsp(pTq, uid, pRsp);
- }
pRsp->blockNum++;
- continue;
+ if (pRsp->withTbName) {
+ if (pOffset->type == TMQ_OFFSET__LOG) {
+ int64_t uid = pExec->pExecReader[0]->msgIter.uid;
+ tqAddTbNameToRsp(pTq, uid, pRsp);
+ } else {
+ pRsp->withTbName = 0;
+ }
+ }
+ if (pOffset->type == TMQ_OFFSET__LOG) {
+ continue;
+ } else {
+ rowCnt += pDataBlock->info.rows;
+ if (rowCnt <= 4096) continue;
+ }
}
void* meta = qStreamExtractMetaMsg(task);
@@ -94,26 +105,23 @@ int64_t tqScanLog(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOff
ASSERT(0);
}
+ ASSERT(pRsp->rspOffset.type != 0);
+
if (pRsp->rspOffset.type == TMQ_OFFSET__LOG) {
ASSERT(pRsp->rspOffset.version + 1 >= pRsp->reqOffset.version);
}
- ASSERT(pRsp->rspOffset.type != 0);
-
break;
}
return 0;
}
+#if 0
int32_t tqScanSnapshot(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, STqOffsetVal offset, int32_t workerId) {
ASSERT(pExec->subType == TOPIC_SUB_TYPE__COLUMN);
qTaskInfo_t task = pExec->execCol.task[workerId];
- /*if (qStreamScanSnapshot(task) < 0) {*/
- /*ASSERT(0);*/
- /*}*/
-
if (qStreamPrepareTsdbScan(task, offset.uid, offset.ts) < 0) {
ASSERT(0);
}
@@ -157,6 +165,7 @@ int32_t tqScanSnapshot(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, S
return 0;
}
+#endif
int32_t tqLogScanExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataRsp* pRsp, int32_t workerId) {
if (pExec->subType == TOPIC_SUB_TYPE__COLUMN) {
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index 35179b0234..8753ecc47c 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -22,8 +22,8 @@ int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalCkHea
while (1) {
if (walFetchHead(pHandle->pWalReader, offset, *ppCkHead) < 0) {
- tqDebug("tmq poll: consumer:%" PRId64 ", (epoch %d) vgId:%d offset %" PRId64 ", no more log to return", pHandle->consumerId,
- pHandle->epoch, TD_VID(pTq->pVnode), offset);
+ tqDebug("tmq poll: consumer:%" PRId64 ", (epoch %d) vgId:%d offset %" PRId64 ", no more log to return",
+ pHandle->consumerId, pHandle->epoch, TD_VID(pTq->pVnode), offset);
*fetchOffset = offset - 1;
code = -1;
goto END;
@@ -104,8 +104,13 @@ void tqCloseReader(STqReader* pReader) {
}
int32_t tqSeekVer(STqReader* pReader, int64_t ver) {
- //
- return walReadSeekVer(pReader->pWalReader, ver);
+ if (walReadSeekVer(pReader->pWalReader, ver) < 0) {
+ ASSERT(pReader->pWalReader->curInvalid);
+ ASSERT(pReader->pWalReader->curVersion == ver);
+ return -1;
+ }
+ ASSERT(pReader->pWalReader->curVersion == ver);
+ return 0;
}
int32_t tqNextBlock(STqReader* pReader, SFetchRet* ret) {
@@ -114,9 +119,11 @@ int32_t tqNextBlock(STqReader* pReader, SFetchRet* ret) {
while (1) {
if (!fromProcessedMsg) {
if (walNextValidMsg(pReader->pWalReader) < 0) {
+ pReader->ver = pReader->pWalReader->curVersion - pReader->pWalReader->curInvalid;
ret->offset.type = TMQ_OFFSET__LOG;
ret->offset.version = pReader->ver;
ret->fetchType = FETCH_TYPE__NONE;
+ ASSERT(ret->offset.version >= 0);
return -1;
}
void* body = pReader->pWalReader->pHead->head.body;
@@ -131,19 +138,12 @@ int32_t tqNextBlock(STqReader* pReader, SFetchRet* ret) {
}
while (tqNextDataBlock(pReader)) {
+ // TODO mem free
memset(&ret->data, 0, sizeof(SSDataBlock));
int32_t code = tqRetrieveDataBlock(&ret->data, pReader);
if (code != 0 || ret->data.info.rows == 0) {
ASSERT(0);
continue;
-#if 0
- if (fromProcessedMsg) {
- ret->fetchType = FETCH_TYPE__NONE;
- return 0;
- } else {
- break;
- }
-#endif
}
ret->fetchType = FETCH_TYPE__DATA;
return 0;
@@ -152,7 +152,7 @@ int32_t tqNextBlock(STqReader* pReader, SFetchRet* ret) {
if (fromProcessedMsg) {
ret->offset.type = TMQ_OFFSET__LOG;
ret->offset.version = pReader->ver;
- ASSERT(pReader->ver != -1);
+ ASSERT(pReader->ver >= 0);
ret->fetchType = FETCH_TYPE__NONE;
return 0;
}
diff --git a/source/dnode/vnode/src/vnd/vnodeUtil.c b/source/dnode/vnode/src/tsdb/tsdbRetention.c
similarity index 52%
rename from source/dnode/vnode/src/vnd/vnodeUtil.c
rename to source/dnode/vnode/src/tsdb/tsdbRetention.c
index cd942099bc..e73f3f947c 100644
--- a/source/dnode/vnode/src/vnd/vnodeUtil.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRetention.c
@@ -13,33 +13,30 @@
* along with this program. If not, see .
*/
-#include "vnd.h"
+#include "tsdb.h"
-int32_t vnodeRealloc(void** pp, int32_t size) {
- uint8_t* p = NULL;
- int32_t csize = 0;
+int32_t tsdbDoRetention(STsdb *pTsdb, int64_t now) {
+ int32_t code = 0;
- if (*pp) {
- p = (uint8_t*)(*pp) - sizeof(int32_t);
- csize = *(int32_t*)p;
+ // begin
+ code = tsdbFSBegin(pTsdb->fs);
+ if (code) goto _err;
+
+ // do retention
+ for (int32_t iSet = 0; iSet < taosArrayGetSize(pTsdb->fs->nState->aDFileSet); iSet++) {
+ SDFileSet *pDFileSet = (SDFileSet *)taosArrayGet(pTsdb->fs->nState->aDFileSet, iSet);
+
+ // TODO
}
- if (csize >= size) {
- return 0;
- }
+ // commit
+ code = tsdbFSCommit(pTsdb->fs);
+ if (code) goto _err;
- p = (uint8_t*)taosMemoryRealloc(p, size);
- if (p == NULL) {
- return TSDB_CODE_OUT_OF_MEMORY;
- }
- *(int32_t*)p = size;
- *pp = p + sizeof(int32_t);
+_exit:
+ return code;
- return 0;
-}
-
-void vnodeFree(void* p) {
- if (p) {
- taosMemoryFree(((uint8_t*)p) - sizeof(int32_t));
- }
+_err:
+ tsdbError("vgId:%d tsdb do retention failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+ return code;
}
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
index 79989a5560..54087a7871 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
@@ -15,22 +15,686 @@
#include "tsdb.h"
-struct STsdbSnapshotReader {
- STsdb* pTsdb;
- // TODO
+// STsdbSnapReader ========================================
+struct STsdbSnapReader {
+ STsdb* pTsdb;
+ int64_t sver;
+ int64_t ever;
+ // for data file
+ int8_t dataDone;
+ int32_t fid;
+ SDataFReader* pDataFReader;
+ SArray* aBlockIdx; // SArray
+ int32_t iBlockIdx;
+ SBlockIdx* pBlockIdx;
+ SMapData mBlock; // SMapData
+ int32_t iBlock;
+ SBlockData blkData;
+ // for del file
+ int8_t delDone;
+ SDelFReader* pDelFReader;
+ int32_t iDelIdx;
+ SArray* aDelIdx; // SArray
+ SArray* aDelData; // SArray
};
-int32_t tsdbSnapshotReaderOpen(STsdb* pTsdb, STsdbSnapshotReader** ppReader, int64_t sver, int64_t ever) {
- // TODO
- return 0;
+static int32_t tsdbSnapReadData(STsdbSnapReader* pReader, uint8_t** ppData) {
+ int32_t code = 0;
+
+ while (true) {
+ if (pReader->pDataFReader == NULL) {
+ SDFileSet* pSet = NULL;
+
+ // search the next data file set to read (todo)
+ if (0 /* TODO */) {
+ code = TSDB_CODE_VND_READ_END;
+ goto _exit;
+ }
+
+ // open
+ code = tsdbDataFReaderOpen(&pReader->pDataFReader, pReader->pTsdb, pSet);
+ if (code) goto _err;
+
+ // SBlockIdx
+ code = tsdbReadBlockIdx(pReader->pDataFReader, pReader->aBlockIdx, NULL);
+ if (code) goto _err;
+
+ pReader->iBlockIdx = 0;
+ pReader->pBlockIdx = NULL;
+ }
+
+ while (true) {
+ if (pReader->pBlockIdx == NULL) {
+ if (pReader->iBlockIdx >= taosArrayGetSize(pReader->aBlockIdx)) {
+ tsdbDataFReaderClose(&pReader->pDataFReader);
+ break;
+ }
+
+ pReader->pBlockIdx = (SBlockIdx*)taosArrayGet(pReader->aBlockIdx, pReader->iBlockIdx);
+ pReader->iBlockIdx++;
+
+ // SBlock
+ code = tsdbReadBlock(pReader->pDataFReader, pReader->pBlockIdx, &pReader->mBlock, NULL);
+ if (code) goto _err;
+
+ pReader->iBlock = 0;
+ }
+
+ while (true) {
+ SBlock block;
+ SBlock* pBlock = █
+
+ if (pReader->iBlock >= pReader->mBlock.nItem) {
+ pReader->pBlockIdx = NULL;
+ break;
+ }
+
+ tMapDataGetItemByIdx(&pReader->mBlock, pReader->iBlock, pBlock, tGetBlock);
+ pReader->iBlock++;
+
+ if ((pBlock->minVersion >= pReader->sver && pBlock->minVersion <= pReader->ever) ||
+ (pBlock->maxVersion >= pReader->sver && pBlock->maxVersion <= pReader->ever)) {
+ // overlap (todo)
+
+ code = tsdbReadBlockData(pReader->pDataFReader, pReader->pBlockIdx, pBlock, &pReader->blkData, NULL, NULL);
+ if (code) goto _err;
+
+ goto _exit;
+ }
+ }
+ }
+ }
+
+_exit:
+ return code;
+
+_err:
+ tsdbError("vgId:%d snap read data failed since %s", TD_VID(pReader->pTsdb->pVnode), tstrerror(code));
+ return code;
}
-int32_t tsdbSnapshotReaderClose(STsdbSnapshotReader* pReader) {
- // TODO
- return 0;
+static int32_t tsdbSnapReadDel(STsdbSnapReader* pReader, uint8_t** ppData) {
+ int32_t code = 0;
+ STsdb* pTsdb = pReader->pTsdb;
+ SDelFile* pDelFile = pTsdb->fs->cState->pDelFile;
+
+ if (pReader->pDelFReader == NULL) {
+ if (pDelFile == NULL) {
+ code = TSDB_CODE_VND_READ_END;
+ goto _exit;
+ }
+
+ // open
+ code = tsdbDelFReaderOpen(&pReader->pDelFReader, pDelFile, pTsdb, NULL);
+ if (code) goto _err;
+
+ // read index
+ code = tsdbReadDelIdx(pReader->pDelFReader, pReader->aDelIdx, NULL);
+ if (code) goto _err;
+
+ pReader->iDelIdx = 0;
+ }
+
+ while (pReader->iDelIdx < taosArrayGetSize(pReader->aDelIdx)) {
+ SDelIdx* pDelIdx = (SDelIdx*)taosArrayGet(pReader->aDelIdx, pReader->iDelIdx);
+ int32_t size = 0;
+
+ pReader->iDelIdx++;
+
+ code = tsdbReadDelData(pReader->pDelFReader, pDelIdx, pReader->aDelData, NULL);
+ if (code) goto _err;
+
+ for (int32_t iDelData = 0; iDelData < taosArrayGetSize(pReader->aDelData); iDelData++) {
+ SDelData* pDelData = (SDelData*)taosArrayGet(pReader->aDelData, iDelData);
+
+ if (pDelData->version >= pReader->sver && pDelData->version <= pReader->ever) {
+ size += tPutDelData(NULL, pDelData);
+ }
+ }
+
+ if (size > 0) {
+ int64_t n = 0;
+
+ size = size + sizeof(SSnapDataHdr) + sizeof(TABLEID);
+ code = tRealloc(ppData, size);
+ if (code) goto _err;
+
+ // SSnapDataHdr
+ SSnapDataHdr* pSnapDataHdr = (SSnapDataHdr*)(*ppData + n);
+ pSnapDataHdr->type = 1;
+ pSnapDataHdr->size = size; // TODO: size here may incorrect
+ n += sizeof(SSnapDataHdr);
+
+ // TABLEID
+ TABLEID* pId = (TABLEID*)(*ppData + n);
+ pId->suid = pDelIdx->suid;
+ pId->uid = pDelIdx->uid;
+ n += sizeof(*pId);
+
+ // DATA
+ for (int32_t iDelData = 0; iDelData < taosArrayGetSize(pReader->aDelData); iDelData++) {
+ SDelData* pDelData = (SDelData*)taosArrayGet(pReader->aDelData, iDelData);
+
+ if (pDelData->version >= pReader->sver && pDelData->version <= pReader->ever) {
+ n += tPutDelData(*ppData + n, pDelData);
+ }
+ }
+
+ goto _exit;
+ }
+ }
+
+ code = TSDB_CODE_VND_READ_END;
+ tsdbDelFReaderClose(&pReader->pDelFReader);
+
+_exit:
+ return code;
+
+_err:
+ tsdbError("vgId:%d snap read del failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+ return code;
}
-int32_t tsdbSnapshotRead(STsdbSnapshotReader* pReader, void** ppData, uint32_t* nData) {
- // TODO
- return 0;
+int32_t tsdbSnapReaderOpen(STsdb* pTsdb, int64_t sver, int64_t ever, STsdbSnapReader** ppReader) {
+ int32_t code = 0;
+ STsdbSnapReader* pReader = NULL;
+
+ // alloc
+ pReader = (STsdbSnapReader*)taosMemoryCalloc(1, sizeof(*pReader));
+ if (pReader == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+ pReader->pTsdb = pTsdb;
+ pReader->sver = sver;
+ pReader->ever = ever;
+
+ pReader->aBlockIdx = taosArrayInit(0, sizeof(SBlockIdx));
+ if (pReader->aBlockIdx == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+
+ pReader->mBlock = tMapDataInit();
+
+ code = tBlockDataInit(&pReader->blkData);
+ if (code) goto _err;
+
+ pReader->aDelIdx = taosArrayInit(0, sizeof(SDelIdx));
+ if (pReader->aDelIdx == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+
+ pReader->aDelData = taosArrayInit(0, sizeof(SDelData));
+ if (pReader->aDelData == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+
+ *ppReader = pReader;
+ return code;
+
+_err:
+ tsdbError("vgId:%d snapshot reader open failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+ *ppReader = NULL;
+ return code;
+}
+
+int32_t tsdbSnapReaderClose(STsdbSnapReader** ppReader) {
+ int32_t code = 0;
+ STsdbSnapReader* pReader = *ppReader;
+
+ taosArrayDestroy(pReader->aDelData);
+ taosArrayDestroy(pReader->aDelIdx);
+ if (pReader->pDelFReader) {
+ tsdbDelFReaderClose(&pReader->pDelFReader);
+ }
+ tBlockDataClear(&pReader->blkData);
+ tMapDataClear(&pReader->mBlock);
+ taosArrayDestroy(pReader->aBlockIdx);
+ if (pReader->pDataFReader) {
+ tsdbDataFReaderClose(&pReader->pDataFReader);
+ }
+ taosMemoryFree(pReader);
+ *ppReader = NULL;
+
+ return code;
+}
+
+int32_t tsdbSnapRead(STsdbSnapReader* pReader, uint8_t** ppData) {
+ int32_t code = 0;
+
+ // read data file
+ if (!pReader->dataDone) {
+ code = tsdbSnapReadData(pReader, ppData);
+ if (code) {
+ if (code == TSDB_CODE_VND_READ_END) {
+ pReader->dataDone = 1;
+ } else {
+ goto _err;
+ }
+ } else {
+ goto _exit;
+ }
+ }
+
+ // read del file
+ if (!pReader->delDone) {
+ code = tsdbSnapReadDel(pReader, ppData);
+ if (code) {
+ if (code == TSDB_CODE_VND_READ_END) {
+ pReader->delDone = 1;
+ } else {
+ goto _err;
+ }
+ } else {
+ goto _exit;
+ }
+ }
+
+ code = TSDB_CODE_VND_READ_END;
+
+_exit:
+ return code;
+
+_err:
+ tsdbError("vgId:%d snapshot read failed since %s", TD_VID(pReader->pTsdb->pVnode), tstrerror(code));
+ return code;
+}
+
+// STsdbSnapWriter ========================================
+struct STsdbSnapWriter {
+ STsdb* pTsdb;
+ int64_t sver;
+ int64_t ever;
+
+ // config
+ int32_t minutes;
+ int8_t precision;
+
+ // for data file
+ int32_t fid;
+ SDataFReader* pDataFReader;
+ SArray* aBlockIdx;
+ int32_t iBlockIdx;
+ SBlockIdx* pBlockIdx;
+ SMapData mBlock;
+ int32_t iBlock;
+ SBlockData blockData;
+ int32_t iRow;
+
+ SDataFWriter* pDataFWriter;
+ SArray* aBlockIdxN;
+ SBlockIdx blockIdx;
+ SMapData mBlockN;
+ SBlock block;
+ SBlockData nBlockData;
+
+ // for del file
+ SDelFReader* pDelFReader;
+ SDelFWriter* pDelFWriter;
+ int32_t iDelIdx;
+ SArray* aDelIdx;
+ SArray* aDelData;
+ SArray* aDelIdxN;
+};
+
+static int32_t tsdbSnapRollback(STsdbSnapWriter* pWriter) {
+ int32_t code = 0;
+ // TODO
+ return code;
+}
+
+static int32_t tsdbSnapCommit(STsdbSnapWriter* pWriter) {
+ int32_t code = 0;
+ // TODO
+ return code;
+}
+
+static int32_t tsdbSnapWriteDataEnd(STsdbSnapWriter* pWriter) {
+ int32_t code = 0;
+ STsdb* pTsdb = pWriter->pTsdb;
+
+ if (pWriter->pDataFWriter == NULL) goto _exit;
+
+ // TODO
+
+ code = tsdbDataFWriterClose(&pWriter->pDataFWriter, 0);
+ if (code) goto _err;
+
+ if (pWriter->pDataFReader) {
+ code = tsdbDataFReaderClose(&pWriter->pDataFReader);
+ if (code) goto _err;
+ }
+
+_exit:
+ return code;
+
+_err:
+ tsdbError("vgId:%d tsdb snapshot writer data end failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+ return code;
+}
+
+static int32_t tsdbSnapWriteAppendData(STsdbSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
+ int32_t code = 0;
+ int32_t iRow = 0; // todo
+ int32_t nRow = 0; // todo
+ SBlockData* pBlockData = NULL; // todo
+
+ while (iRow < nRow) {
+ code = tBlockDataAppendRow(&pWriter->nBlockData, &tsdbRowFromBlockData(pBlockData, iRow), NULL);
+ if (code) goto _err;
+ }
+
+ return code;
+
+_err:
+ tsdbError("vgId:%d tsdb snapshot write append data failed since %s", TD_VID(pWriter->pTsdb->pVnode), tstrerror(code));
+ return code;
+}
+
+static int32_t tsdbSnapWriteData(STsdbSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
+ int32_t code = 0;
+ STsdb* pTsdb = pWriter->pTsdb;
+ int64_t suid = 0; // todo
+ int64_t uid = 0; // todo
+ int64_t skey; // todo
+ int64_t ekey; // todo
+
+ int32_t fid = tsdbKeyFid(skey, pWriter->minutes, pWriter->precision);
+ ASSERT(fid == tsdbKeyFid(ekey, pWriter->minutes, pWriter->precision));
+
+ // begin
+ if (pWriter->pDataFWriter == NULL || pWriter->fid != fid) {
+ code = tsdbSnapWriteDataEnd(pWriter);
+ if (code) goto _err;
+
+ pWriter->fid = fid;
+ SDFileSet* pSet = tsdbFSStateGetDFileSet(pTsdb->fs->nState, fid);
+ // reader
+ if (pSet) {
+ // open
+ code = tsdbDataFReaderOpen(&pWriter->pDataFReader, pTsdb, pSet);
+ if (code) goto _err;
+
+ // SBlockIdx
+ code = tsdbReadBlockIdx(pWriter->pDataFReader, pWriter->aBlockIdx, NULL);
+ if (code) goto _err;
+ } else {
+ taosArrayClear(pWriter->aBlockIdx);
+ }
+ pWriter->iBlockIdx = 0;
+
+ // writer
+ SDFileSet wSet = {0};
+ if (pSet == NULL) {
+ wSet = (SDFileSet){0}; // todo
+ } else {
+ wSet = (SDFileSet){0}; // todo
+ }
+
+ code = tsdbDataFWriterOpen(&pWriter->pDataFWriter, pTsdb, &wSet);
+ if (code) goto _err;
+
+ taosArrayClear(pWriter->aBlockIdxN);
+ }
+
+ // process
+ TABLEID id = {0}; // TODO
+ TSKEY minKey = 0; // TODO
+ TSKEY maxKey = 0; // TODO
+
+ while (true) {
+ if (pWriter->pBlockIdx) {
+ int32_t c = tTABLEIDCmprFn(&id, pWriter->pBlockIdx);
+
+ if (c == 0) {
+ } else if (c < 0) {
+ // keep merge
+ } else {
+ // code = tsdbSnapWriteTableDataEnd(pWriter);
+ if (code) goto _err;
+
+ pWriter->iBlockIdx++;
+ if (pWriter->iBlockIdx < taosArrayGetSize(pWriter->aBlockIdx)) {
+ pWriter->pBlockIdx = (SBlockIdx*)taosArrayGet(pWriter->aBlockIdx, pWriter->iBlockIdx);
+ } else {
+ pWriter->pBlockIdx = NULL;
+ }
+
+ if (pWriter->pBlockIdx) {
+ code = tsdbReadBlock(pWriter->pDataFReader, pWriter->pBlockIdx, &pWriter->mBlock, NULL);
+ if (code) goto _err;
+ }
+ }
+ } else {
+ int32_t c = tTABLEIDCmprFn(&id, &pWriter->blockIdx);
+
+ if (c == 0) {
+ // merge commit the block data
+ } else if (c > 0) {
+ // code = tsdbSnapWriteTableDataEnd(pWriter);
+ if (code) goto _err;
+ } else {
+ ASSERT(0);
+ }
+ }
+ }
+
+ return code;
+
+_err:
+ tsdbError("vgId:%d tsdb snapshot write data failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+ return code;
+}
+
+static int32_t tsdbSnapWriteDel(STsdbSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
+ int32_t code = 0;
+ STsdb* pTsdb = pWriter->pTsdb;
+
+ if (pWriter->pDelFWriter == NULL) {
+ SDelFile* pDelFile = tsdbFSStateGetDelFile(pTsdb->fs->nState);
+
+ // reader
+ if (pDelFile) {
+ code = tsdbDelFReaderOpen(&pWriter->pDelFReader, pDelFile, pTsdb, NULL);
+ if (code) goto _err;
+
+ code = tsdbReadDelIdx(pWriter->pDelFReader, pWriter->aDelIdx, NULL);
+ if (code) goto _err;
+ }
+
+ // writer
+ SDelFile delFile = {.commitID = pTsdb->pVnode->state.commitID, .offset = 0, .size = 0};
+ code = tsdbDelFWriterOpen(&pWriter->pDelFWriter, &delFile, pTsdb);
+ if (code) goto _err;
+ }
+
+ // process the del data
+ TABLEID id = {0}; // todo
+
+ while (true) {
+ SDelIdx* pDelIdx = NULL;
+ int64_t n = 0;
+ SDelData delData;
+ SDelIdx delIdx;
+ int8_t toBreak = 0;
+
+ if (pWriter->iDelIdx < taosArrayGetSize(pWriter->aDelIdx)) {
+ pDelIdx = taosArrayGet(pWriter->aDelIdx, pWriter->iDelIdx);
+ }
+
+ if (pDelIdx) {
+ int32_t c = tTABLEIDCmprFn(&id, pDelIdx);
+ if (c < 0) {
+ goto _new_del;
+ } else {
+ code = tsdbReadDelData(pWriter->pDelFReader, pDelIdx, pWriter->aDelData, NULL);
+ if (code) goto _err;
+
+ pWriter->iDelIdx++;
+ if (c == 0) {
+ toBreak = 1;
+ delIdx = (SDelIdx){.suid = id.suid, .uid = id.uid};
+ goto _merge_del;
+ } else {
+ delIdx = (SDelIdx){.suid = pDelIdx->suid, .uid = pDelIdx->uid};
+ goto _write_del;
+ }
+ }
+ }
+
+ _new_del:
+ toBreak = 1;
+ delIdx = (SDelIdx){.suid = id.suid, .uid = id.uid};
+ taosArrayClear(pWriter->aDelData);
+
+ _merge_del:
+ while (n < nData) {
+ n += tGetDelData(pData + n, &delData);
+ if (taosArrayPush(pWriter->aDelData, &delData) == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+ }
+
+ _write_del:
+ code = tsdbWriteDelData(pWriter->pDelFWriter, pWriter->aDelData, NULL, &delIdx);
+ if (code) goto _err;
+
+ if (taosArrayPush(pWriter->aDelIdxN, &delIdx) == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+
+ if (toBreak) break;
+ }
+
+_exit:
+ return code;
+
+_err:
+ tsdbError("vgId:%d tsdb snapshot write del failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+ return code;
+}
+
+static int32_t tsdbSnapWriteDelEnd(STsdbSnapWriter* pWriter) {
+ int32_t code = 0;
+ STsdb* pTsdb = pWriter->pTsdb;
+
+ if (pWriter->pDelFWriter == NULL) goto _exit;
+ for (; pWriter->iDelIdx < taosArrayGetSize(pWriter->aDelIdx); pWriter->iDelIdx++) {
+ SDelIdx* pDelIdx = (SDelIdx*)taosArrayGet(pWriter->aDelIdx, pWriter->iDelIdx);
+
+ code = tsdbReadDelData(pWriter->pDelFReader, pDelIdx, pWriter->aDelData, NULL);
+ if (code) goto _err;
+
+ SDelIdx delIdx = (SDelIdx){.suid = pDelIdx->suid, .uid = pDelIdx->uid};
+ code = tsdbWriteDelData(pWriter->pDelFWriter, pWriter->aDelData, NULL, &delIdx);
+ if (code) goto _err;
+
+ if (taosArrayPush(pWriter->aDelIdx, &delIdx) == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+ }
+
+ code = tsdbUpdateDelFileHdr(pWriter->pDelFWriter);
+ if (code) goto _err;
+
+ code = tsdbFSStateUpsertDelFile(pTsdb->fs->nState, &pWriter->pDelFWriter->fDel);
+ if (code) goto _err;
+
+ code = tsdbDelFWriterClose(&pWriter->pDelFWriter, 1);
+ if (code) goto _err;
+
+ if (pWriter->pDelFReader) {
+ code = tsdbDelFReaderClose(&pWriter->pDelFReader);
+ if (code) goto _err;
+ }
+
+_exit:
+ return code;
+
+_err:
+ tsdbError("vgId:%d tsdb snapshow write del end failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+ return code;
+}
+
+int32_t tsdbSnapWriterOpen(STsdb* pTsdb, int64_t sver, int64_t ever, STsdbSnapWriter** ppWriter) {
+ int32_t code = 0;
+ STsdbSnapWriter* pWriter = NULL;
+
+ // alloc
+ pWriter = (STsdbSnapWriter*)taosMemoryCalloc(1, sizeof(*pWriter));
+ if (pWriter == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+ pWriter->pTsdb = pTsdb;
+ pWriter->sver = sver;
+ pWriter->ever = ever;
+
+ *ppWriter = pWriter;
+ return code;
+
+_err:
+ tsdbError("vgId:%d tsdb snapshot writer open failed since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+ *ppWriter = NULL;
+ return code;
+}
+
+int32_t tsdbSnapWriterClose(STsdbSnapWriter** ppWriter, int8_t rollback) {
+ int32_t code = 0;
+ STsdbSnapWriter* pWriter = *ppWriter;
+
+ if (rollback) {
+ code = tsdbSnapRollback(pWriter);
+ if (code) goto _err;
+ } else {
+ code = tsdbSnapWriteDataEnd(pWriter);
+ if (code) goto _err;
+
+ code = tsdbSnapWriteDelEnd(pWriter);
+ if (code) goto _err;
+
+ code = tsdbSnapCommit(pWriter);
+ if (code) goto _err;
+ }
+
+ taosMemoryFree(pWriter);
+ *ppWriter = NULL;
+
+ return code;
+
+_err:
+ tsdbError("vgId:%d tsdb snapshot writer close failed since %s", TD_VID(pWriter->pTsdb->pVnode), tstrerror(code));
+ return code;
+}
+
+int32_t tsdbSnapWrite(STsdbSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
+ int32_t code = 0;
+ int8_t type = pData[0];
+
+ // ts data
+ if (type == 0) {
+ code = tsdbSnapWriteData(pWriter, pData + 1, nData - 1);
+ if (code) goto _err;
+ } else {
+ code = tsdbSnapWriteDataEnd(pWriter);
+ if (code) goto _err;
+ }
+
+ // del data
+ if (type == 1) {
+ code = tsdbSnapWriteDel(pWriter, pData + 1, nData - 1);
+ if (code) goto _err;
+ }
+
+ return code;
+
+_err:
+ tsdbError("vgId:%d tsdb snapshow write failed since %s", TD_VID(pWriter->pTsdb->pVnode), tstrerror(code));
+ return code;
}
diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c
index 2e628edb7a..415a674737 100644
--- a/source/dnode/vnode/src/tsdb/tsdbUtil.c
+++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c
@@ -87,8 +87,10 @@ int32_t tPutMapData(uint8_t *p, SMapData *pMapData) {
n += tPutI32v(p ? p + n : p, pMapData->nItem);
if (pMapData->nItem) {
+ int32_t lOffset = 0;
for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) {
- n += tPutI32v(p ? p + n : p, pMapData->aOffset[iItem]);
+ n += tPutI32v(p ? p + n : p, pMapData->aOffset[iItem] - lOffset);
+ lOffset = pMapData->aOffset[iItem];
}
n += tPutI32v(p ? p + n : p, pMapData->nData);
@@ -111,8 +113,11 @@ int32_t tGetMapData(uint8_t *p, SMapData *pMapData) {
if (pMapData->nItem) {
if (tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem)) return -1;
+ int32_t lOffset = 0;
for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) {
n += tGetI32v(p + n, &pMapData->aOffset[iItem]);
+ pMapData->aOffset[iItem] += lOffset;
+ lOffset = pMapData->aOffset[iItem];
}
n += tGetI32v(p + n, &pMapData->nData);
diff --git a/source/dnode/vnode/src/vnd/vnodeCommit.c b/source/dnode/vnode/src/vnd/vnodeCommit.c
index 21db14f0df..ed829666cd 100644
--- a/source/dnode/vnode/src/vnd/vnodeCommit.c
+++ b/source/dnode/vnode/src/vnd/vnodeCommit.c
@@ -223,6 +223,7 @@ int vnodeCommit(SVnode *pVnode) {
// save info
info.config = pVnode->config;
info.state.committed = pVnode->state.applied;
+ info.state.commitTerm = pVnode->state.applyTerm;
info.state.commitID = pVnode->state.commitID;
snprintf(dir, TSDB_FILENAME_LEN, "%s%s%s", tfsGetPrimaryPath(pVnode->pTfs), TD_DIRSEP, pVnode->path);
if (vnodeSaveInfo(dir, &info) < 0) {
@@ -270,7 +271,7 @@ int vnodeCommit(SVnode *pVnode) {
ASSERT(0);
return -1;
}
-
+
pVnode->state.committed = info.state.committed;
// postCommit
@@ -316,6 +317,7 @@ static int vnodeEncodeState(const void *pObj, SJson *pJson) {
if (tjsonAddIntegerToObject(pJson, "commit version", pState->committed) < 0) return -1;
if (tjsonAddIntegerToObject(pJson, "commit ID", pState->commitID) < 0) return -1;
+ if (tjsonAddIntegerToObject(pJson, "commit term", pState->commitTerm) < 0) return -1;
return 0;
}
@@ -328,6 +330,8 @@ static int vnodeDecodeState(const SJson *pJson, void *pObj) {
if (code < 0) return -1;
tjsonGetNumberValue(pJson, "commit ID", pState->commitID, code);
if (code < 0) return -1;
+ tjsonGetNumberValue(pJson, "commit term", pState->commitTerm, code);
+ if (code < 0) return -1;
return 0;
}
diff --git a/source/dnode/vnode/src/vnd/vnodeOpen.c b/source/dnode/vnode/src/vnd/vnodeOpen.c
index 4267dd9b1f..e59f8ae558 100644
--- a/source/dnode/vnode/src/vnd/vnodeOpen.c
+++ b/source/dnode/vnode/src/vnd/vnodeOpen.c
@@ -79,8 +79,10 @@ SVnode *vnodeOpen(const char *path, STfs *pTfs, SMsgCb msgCb) {
strcpy(pVnode->path, path);
pVnode->config = info.config;
pVnode->state.committed = info.state.committed;
+ pVnode->state.commitTerm = info.state.commitTerm;
pVnode->state.applied = info.state.committed;
pVnode->state.commitID = info.state.commitID;
+ pVnode->state.commitTerm = info.state.commitTerm;
pVnode->pTfs = pTfs;
pVnode->msgCb = msgCb;
pVnode->blockCount = 0;
@@ -194,4 +196,9 @@ void vnodeStop(SVnode *pVnode) {}
int64_t vnodeGetSyncHandle(SVnode *pVnode) { return pVnode->sync; }
-void vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot) { pSnapshot->lastApplyIndex = pVnode->state.committed; }
+void vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot) {
+ pSnapshot->data = NULL;
+ pSnapshot->lastApplyIndex = pVnode->state.committed;
+ pSnapshot->lastApplyTerm = pVnode->state.commitTerm;
+ pSnapshot->lastConfigIndex = -1;
+}
diff --git a/source/dnode/vnode/src/vnd/vnodeSnapshot.c b/source/dnode/vnode/src/vnd/vnodeSnapshot.c
index baa8422307..27f30ec787 100644
--- a/source/dnode/vnode/src/vnd/vnodeSnapshot.c
+++ b/source/dnode/vnode/src/vnd/vnodeSnapshot.c
@@ -13,24 +13,27 @@
* along with this program. If not, see .
*/
-#include "vnodeInt.h"
+#include "vnd.h"
-struct SVSnapshotReader {
- SVnode *pVnode;
- int64_t sver;
- int64_t ever;
- int8_t isMetaEnd;
- int8_t isTsdbEnd;
- SMetaSnapshotReader *pMetaReader;
- STsdbSnapshotReader *pTsdbReader;
- void *pData;
- int32_t nData;
+// SVSnapReader ========================================================
+struct SVSnapReader {
+ SVnode *pVnode;
+ int64_t sver;
+ int64_t ever;
+ // meta
+ int8_t metaDone;
+ SMetaSnapReader *pMetaReader;
+ // tsdb
+ int8_t tsdbDone;
+ STsdbSnapReader *pTsdbReader;
+ uint8_t *pData;
};
-int32_t vnodeSnapshotReaderOpen(SVnode *pVnode, SVSnapshotReader **ppReader, int64_t sver, int64_t ever) {
- SVSnapshotReader *pReader = NULL;
+int32_t vnodeSnapReaderOpen(SVnode *pVnode, int64_t sver, int64_t ever, SVSnapReader **ppReader) {
+ int32_t code = 0;
+ SVSnapReader *pReader = NULL;
- pReader = (SVSnapshotReader *)taosMemoryCalloc(1, sizeof(*pReader));
+ pReader = (SVSnapReader *)taosMemoryCalloc(1, sizeof(*pReader));
if (pReader == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
goto _err;
@@ -38,72 +41,169 @@ int32_t vnodeSnapshotReaderOpen(SVnode *pVnode, SVSnapshotReader **ppReader, int
pReader->pVnode = pVnode;
pReader->sver = sver;
pReader->ever = ever;
- pReader->isMetaEnd = 0;
- pReader->isTsdbEnd = 0;
- if (metaSnapshotReaderOpen(pVnode->pMeta, &pReader->pMetaReader, sver, ever) < 0) {
- taosMemoryFree(pReader);
- goto _err;
- }
+ code = metaSnapReaderOpen(pVnode->pMeta, sver, ever, &pReader->pMetaReader);
+ if (code) goto _err;
- if (tsdbSnapshotReaderOpen(pVnode->pTsdb, &pReader->pTsdbReader, sver, ever) < 0) {
- metaSnapshotReaderClose(pReader->pMetaReader);
- taosMemoryFree(pReader);
- goto _err;
- }
+ code = tsdbSnapReaderOpen(pVnode->pTsdb, sver, ever, &pReader->pTsdbReader);
+ if (code) goto _err;
-_exit:
*ppReader = pReader;
- return 0;
+ return code;
_err:
+ vError("vgId:%d vnode snapshot reader open failed since %s", TD_VID(pVnode), tstrerror(code));
*ppReader = NULL;
- return -1;
+ return code;
}
-int32_t vnodeSnapshotReaderClose(SVSnapshotReader *pReader) {
- if (pReader) {
- vnodeFree(pReader->pData);
- tsdbSnapshotReaderClose(pReader->pTsdbReader);
- metaSnapshotReaderClose(pReader->pMetaReader);
- taosMemoryFree(pReader);
- }
- return 0;
-}
-
-int32_t vnodeSnapshotRead(SVSnapshotReader *pReader, const void **ppData, uint32_t *nData) {
+int32_t vnodeSnapReaderClose(SVSnapReader *pReader) {
int32_t code = 0;
- if (!pReader->isMetaEnd) {
- code = metaSnapshotRead(pReader->pMetaReader, &pReader->pData, &pReader->nData);
+ tFree(pReader->pData);
+ if (pReader->pTsdbReader) tsdbSnapReaderClose(&pReader->pTsdbReader);
+ if (pReader->pMetaReader) metaSnapReaderClose(&pReader->pMetaReader);
+ taosMemoryFree(pReader);
+
+ return code;
+}
+
+int32_t vnodeSnapRead(SVSnapReader *pReader, uint8_t **ppData, uint32_t *nData) {
+ int32_t code = 0;
+
+ if (!pReader->metaDone) {
+ code = metaSnapRead(pReader->pMetaReader, &pReader->pData);
if (code) {
if (code == TSDB_CODE_VND_READ_END) {
- pReader->isMetaEnd = 1;
+ pReader->metaDone = 1;
} else {
- return code;
+ goto _err;
}
} else {
*ppData = pReader->pData;
- *nData = pReader->nData;
- return code;
+ *nData = sizeof(SSnapDataHdr) + ((SSnapDataHdr *)pReader->pData)->size;
+ goto _exit;
}
}
- if (!pReader->isTsdbEnd) {
- code = tsdbSnapshotRead(pReader->pTsdbReader, &pReader->pData, &pReader->nData);
+ if (!pReader->tsdbDone) {
+ code = tsdbSnapRead(pReader->pTsdbReader, &pReader->pData);
if (code) {
if (code == TSDB_CODE_VND_READ_END) {
- pReader->isTsdbEnd = 1;
+ pReader->tsdbDone = 1;
} else {
- return code;
+ goto _err;
}
} else {
*ppData = pReader->pData;
- *nData = pReader->nData;
- return code;
+ *nData = sizeof(SSnapDataHdr) + ((SSnapDataHdr *)pReader->pData)->size;
+ goto _exit;
}
}
code = TSDB_CODE_VND_READ_END;
+
+_exit:
+ return code;
+
+_err:
+ vError("vgId:% snapshot read failed since %s", TD_VID(pReader->pVnode), tstrerror(code));
+ return code;
+}
+
+// SVSnapWriter ========================================================
+struct SVSnapWriter {
+ SVnode *pVnode;
+ int64_t sver;
+ int64_t ever;
+ // meta
+ SMetaSnapWriter *pMetaSnapWriter;
+ // tsdb
+ STsdbSnapWriter *pTsdbSnapWriter;
+};
+
+static int32_t vnodeSnapRollback(SVSnapWriter *pWriter) {
+ int32_t code = 0;
+ // TODO
+ return code;
+}
+
+static int32_t vnodeSnapCommit(SVSnapWriter *pWriter) {
+ int32_t code = 0;
+ // TODO
+ return code;
+}
+
+int32_t vnodeSnapWriterOpen(SVnode *pVnode, int64_t sver, int64_t ever, SVSnapWriter **ppWriter) {
+ int32_t code = 0;
+ SVSnapWriter *pWriter = NULL;
+
+ // alloc
+ pWriter = (SVSnapWriter *)taosMemoryCalloc(1, sizeof(*pWriter));
+ if (pWriter == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _err;
+ }
+ pWriter->pVnode = pVnode;
+ pWriter->sver = sver;
+ pWriter->ever = ever;
+
+ return code;
+
+_err:
+ vError("vgId:%d vnode snapshot writer open failed since %s", TD_VID(pVnode), tstrerror(code));
+ return code;
+}
+
+int32_t vnodeSnapWriterClose(SVSnapWriter *pWriter, int8_t rollback) {
+ int32_t code = 0;
+
+ if (rollback) {
+ code = vnodeSnapRollback(pWriter);
+ if (code) goto _err;
+ } else {
+ code = vnodeSnapCommit(pWriter);
+ if (code) goto _err;
+ }
+
+ taosMemoryFree(pWriter);
+ return code;
+
+_err:
+ vError("vgId:%d vnode snapshow writer close failed since %s", TD_VID(pWriter->pVnode), tstrerror(code));
+ return code;
+}
+
+int32_t vnodeSnapWrite(SVSnapWriter *pWriter, uint8_t *pData, uint32_t nData) {
+ int32_t code = 0;
+ SSnapDataHdr *pSnapDataHdr = (SSnapDataHdr *)pData;
+ SVnode *pVnode = pWriter->pVnode;
+
+ ASSERT(pSnapDataHdr->size + sizeof(SSnapDataHdr) == nData);
+
+ if (pSnapDataHdr->type == 0) {
+ // meta
+ if (pWriter->pMetaSnapWriter == NULL) {
+ code = metaSnapWriterOpen(pVnode->pMeta, pWriter->sver, pWriter->ever, &pWriter->pMetaSnapWriter);
+ if (code) goto _err;
+ }
+
+ code = metaSnapWrite(pWriter->pMetaSnapWriter, pData + sizeof(SSnapDataHdr), nData - sizeof(SSnapDataHdr));
+ if (code) goto _err;
+ } else {
+ // tsdb
+ if (pWriter->pTsdbSnapWriter == NULL) {
+ code = tsdbSnapWriterOpen(pVnode->pTsdb, pWriter->sver, pWriter->ever, &pWriter->pTsdbSnapWriter);
+ if (code) goto _err;
+ }
+
+ code = tsdbSnapWrite(pWriter->pTsdbSnapWriter, pData + sizeof(SSnapDataHdr), nData - sizeof(SSnapDataHdr));
+ if (code) goto _err;
+ }
+
+ return code;
+
+_err:
+ vError("vgId:%d vnode snapshot write failed since %s", TD_VID(pVnode), tstrerror(code));
return code;
}
\ No newline at end of file
diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c
index cd25707fce..dceeb4c282 100644
--- a/source/dnode/vnode/src/vnd/vnodeSvr.c
+++ b/source/dnode/vnode/src/vnd/vnodeSvr.c
@@ -143,6 +143,7 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRp
version);
pVnode->state.applied = version;
+ pVnode->state.applyTerm = pMsg->info.conn.applyTerm;
// skip header
pReq = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
diff --git a/source/dnode/vnode/src/vnd/vnodeSync.c b/source/dnode/vnode/src/vnd/vnodeSync.c
index a16ba8b89e..d49c307233 100644
--- a/source/dnode/vnode/src/vnd/vnodeSync.c
+++ b/source/dnode/vnode/src/vnd/vnodeSync.c
@@ -453,28 +453,40 @@ static void vnodeSyncRollBackMsg(SSyncFSM *pFsm, const SRpcMsg *pMsg, SFsmCbMeta
static int32_t vnodeSnapshotStartRead(struct SSyncFSM *pFsm, void *pParam, void **ppReader) {
SVnode *pVnode = pFsm->data;
SSnapshotParam *pSnapshotParam = pParam;
- int32_t code =
- vnodeSnapshotReaderOpen(pVnode, (SVSnapshotReader **)ppReader, pSnapshotParam->start, pSnapshotParam->end);
+ int32_t code = vnodeSnapReaderOpen(pVnode, pSnapshotParam->start, pSnapshotParam->end, (SVSnapReader **)ppReader);
return code;
}
static int32_t vnodeSnapshotStopRead(struct SSyncFSM *pFsm, void *pReader) {
SVnode *pVnode = pFsm->data;
- int32_t code = vnodeSnapshotReaderClose(pReader);
+ int32_t code = vnodeSnapReaderClose(pReader);
return code;
}
static int32_t vnodeSnapshotDoRead(struct SSyncFSM *pFsm, void *pReader, void **ppBuf, int32_t *len) {
SVnode *pVnode = pFsm->data;
- int32_t code = vnodeSnapshotRead(pReader, (const void **)ppBuf, len);
+ int32_t code = vnodeSnapRead(pReader, (uint8_t **)ppBuf, len);
return code;
}
-static int32_t vnodeSnapshotStartWrite(struct SSyncFSM *pFsm, void *pParam, void **ppWriter) { return 0; }
+static int32_t vnodeSnapshotStartWrite(struct SSyncFSM *pFsm, void *pParam, void **ppWriter) {
+ SVnode *pVnode = pFsm->data;
+ SSnapshotParam *pSnapshotParam = pParam;
+ int32_t code = vnodeSnapWriterOpen(pVnode, pSnapshotParam->start, pSnapshotParam->end, (SVSnapWriter **)ppWriter);
+ return code;
+}
-static int32_t vnodeSnapshotStopWrite(struct SSyncFSM *pFsm, void *pWriter, bool isApply) { return 0; }
+static int32_t vnodeSnapshotStopWrite(struct SSyncFSM *pFsm, void *pWriter, bool isApply) {
+ SVnode *pVnode = pFsm->data;
+ int32_t code = vnodeSnapWriterClose(pWriter, !isApply);
+ return code;
+}
-static int32_t vnodeSnapshotDoWrite(struct SSyncFSM *pFsm, void *pWriter, void *pBuf, int32_t len) { return 0; }
+static int32_t vnodeSnapshotDoWrite(struct SSyncFSM *pFsm, void *pWriter, void *pBuf, int32_t len) {
+ SVnode *pVnode = pFsm->data;
+ int32_t code = vnodeSnapWrite(pWriter, pBuf, len);
+ return code;
+}
static SSyncFSM *vnodeSyncMakeFsm(SVnode *pVnode) {
SSyncFSM *pFsm = taosMemoryCalloc(1, sizeof(SSyncFSM));
diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h
index 9d0e3871cc..7637c66b84 100644
--- a/source/libs/catalog/inc/catalogInt.h
+++ b/source/libs/catalog/inc/catalogInt.h
@@ -166,7 +166,7 @@ typedef struct SCtgDBCache {
int8_t deleted;
SCtgVgCache vgCache;
SHashObj *tbCache; // key:tbname, value:SCtgTbCache
- SHashObj *stbCache; // key:suid, value:STableMeta*
+ SHashObj *stbCache; // key:suid, value:char*
} SCtgDBCache;
typedef struct SCtgRentSlot {
diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h
index 82387119b6..ae0d0bebbd 100644
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@@ -144,6 +144,7 @@ typedef struct {
void* metaBlk; // for tmq fetching meta
SSDataBlock* pullOverBlk; // for streaming
SWalFilterCond cond;
+ int64_t lastScanUid;
} SStreamTaskInfo;
typedef struct SExecTaskInfo {
@@ -298,10 +299,12 @@ typedef struct STableScanInfo {
uint64_t queryId; // todo remove it
uint64_t taskId; // todo remove it
+#if 0
struct {
uint64_t uid;
int64_t ts;
} lastStatus;
+#endif
int8_t scanMode;
int8_t noTable;
diff --git a/source/libs/executor/src/executorMain.c b/source/libs/executor/src/executorMain.c
index ad33c0ae55..53ebc322a8 100644
--- a/source/libs/executor/src/executorMain.c
+++ b/source/libs/executor/src/executorMain.c
@@ -280,7 +280,7 @@ int32_t qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset) {
return 0;
}
-int32_t qStreamPrepareScan1(qTaskInfo_t tinfo, const STqOffsetVal* pOffset) {
+int32_t qStreamPrepareScan(qTaskInfo_t tinfo, const STqOffsetVal* pOffset) {
SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
SOperatorInfo* pOperator = pTaskInfo->pRoot;
ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM);
@@ -293,8 +293,53 @@ int32_t qStreamPrepareScan1(qTaskInfo_t tinfo, const STqOffsetVal* pOffset) {
pOperator->status = OP_OPENED;
if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
SStreamScanInfo* pInfo = pOperator->info;
- if (tqSeekVer(pInfo->tqReader, pOffset->version) < 0) {
- return -1;
+ if (pOffset->type == TMQ_OFFSET__LOG) {
+ if (tqSeekVer(pInfo->tqReader, pOffset->version) < 0) {
+ return -1;
+ }
+ ASSERT(pInfo->tqReader->pWalReader->curVersion == pOffset->version);
+ } else if (pOffset->type == TMQ_OFFSET__SNAPSHOT_DATA) {
+ pInfo->blockType = STREAM_INPUT__TABLE_SCAN;
+ int64_t uid = pOffset->uid;
+ int64_t ts = pOffset->ts;
+
+ if (uid == 0) {
+ if (taosArrayGetSize(pTaskInfo->tableqinfoList.pTableList) != 0) {
+ STableKeyInfo* pTableInfo = taosArrayGet(pTaskInfo->tableqinfoList.pTableList, 0);
+ uid = pTableInfo->uid;
+ ts = INT64_MIN;
+ }
+ }
+ if (pTaskInfo->streamInfo.lastStatus.type != TMQ_OFFSET__SNAPSHOT_DATA ||
+ pTaskInfo->streamInfo.lastStatus.uid != uid || pTaskInfo->streamInfo.lastStatus.ts != ts) {
+ STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;
+ int32_t tableSz = taosArrayGetSize(pTaskInfo->tableqinfoList.pTableList);
+ bool found = false;
+ for (int32_t i = 0; i < tableSz; i++) {
+ STableKeyInfo* pTableInfo = taosArrayGet(pTaskInfo->tableqinfoList.pTableList, i);
+ if (pTableInfo->uid == uid) {
+ found = true;
+ pTableScanInfo->currentTable = i;
+ }
+ }
+
+ // TODO after dropping table, table may be not found
+ ASSERT(found);
+
+ tsdbSetTableId(pTableScanInfo->dataReader, uid);
+ int64_t oldSkey = pTableScanInfo->cond.twindows[0].skey;
+ pTableScanInfo->cond.twindows[0].skey = ts + 1;
+ tsdbReaderReset(pTableScanInfo->dataReader, &pTableScanInfo->cond, 0);
+ pTableScanInfo->cond.twindows[0].skey = oldSkey;
+ pTableScanInfo->scanTimes = 0;
+ pTableScanInfo->curTWinIdx = 0;
+
+ qDebug("tsdb reader offset seek to uid %ld ts %ld, table cur set to %d , all table num %d", uid, ts,
+ pTableScanInfo->currentTable, tableSz);
+ }
+
+ } else {
+ ASSERT(0);
}
return 0;
} else {
@@ -306,6 +351,7 @@ int32_t qStreamPrepareScan1(qTaskInfo_t tinfo, const STqOffsetVal* pOffset) {
return 0;
}
+#if 0
int32_t qStreamPrepareTsdbScan(qTaskInfo_t tinfo, uint64_t uid, int64_t ts) {
SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
@@ -325,3 +371,4 @@ int32_t qGetStreamScanStatus(qTaskInfo_t tinfo, uint64_t* uid, int64_t* ts) {
return doGetScanStatus(pTaskInfo->pRoot, uid, ts);
}
+#endif
diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 4b0f29e106..f2f696b21f 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -2463,7 +2463,7 @@ static void destroySortedMergeOperatorInfo(void* param, int32_t numOfOutput) {
blockDataDestroy(pInfo->binfo.pRes);
cleanupAggSup(&pInfo->aggSup);
-
+
taosMemoryFreeClear(param);
}
@@ -2844,7 +2844,7 @@ int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scan
}
}
}
-
+#if 0
int32_t doPrepareScan(SOperatorInfo* pOperator, uint64_t uid, int64_t ts) {
uint8_t type = pOperator->operatorType;
@@ -2930,6 +2930,7 @@ int32_t doGetScanStatus(SOperatorInfo* pOperator, uint64_t* uid, int64_t* ts) {
return TSDB_CODE_SUCCESS;
}
+#endif
// this is a blocking operator
static int32_t doOpenAggregateOptr(SOperatorInfo* pOperator) {
@@ -3341,8 +3342,8 @@ static void doHandleRemainBlockForNewGroupImpl(SFillOperatorInfo* pInfo, SResult
SExecTaskInfo* pTaskInfo) {
pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
- int64_t ekey = Q_STATUS_EQUAL(pTaskInfo->status, TASK_COMPLETED) ? pInfo->win.ekey
- : pInfo->existNewGroupBlock->info.window.ekey;
+ int64_t ekey =
+ Q_STATUS_EQUAL(pTaskInfo->status, TASK_COMPLETED) ? pInfo->win.ekey : pInfo->existNewGroupBlock->info.window.ekey;
taosResetFillInfo(pInfo->pFillInfo, getFillInfoStart(pInfo->pFillInfo));
taosFillSetStartInfo(pInfo->pFillInfo, pInfo->existNewGroupBlock->info.rows, ekey);
@@ -3678,14 +3679,14 @@ void cleanupBasicInfo(SOptrBasicInfo* pInfo) {
void destroyBasicOperatorInfo(void* param, int32_t numOfOutput) {
SOptrBasicInfo* pInfo = (SOptrBasicInfo*)param;
cleanupBasicInfo(pInfo);
-
+
taosMemoryFreeClear(param);
}
void destroyAggOperatorInfo(void* param, int32_t numOfOutput) {
SAggOperatorInfo* pInfo = (SAggOperatorInfo*)param;
- cleanupBasicInfo(&pInfo->binfo);
-
+ cleanupBasicInfo(&pInfo->binfo);
+
taosMemoryFreeClear(param);
}
@@ -3694,7 +3695,7 @@ void destroySFillOperatorInfo(void* param, int32_t numOfOutput) {
pInfo->pFillInfo = taosDestroyFillInfo(pInfo->pFillInfo);
pInfo->pRes = blockDataDestroy(pInfo->pRes);
taosMemoryFreeClear(pInfo->p);
-
+
taosMemoryFreeClear(param);
}
@@ -3706,7 +3707,7 @@ static void destroyProjectOperatorInfo(void* param, int32_t numOfOutput) {
cleanupBasicInfo(&pInfo->binfo);
cleanupAggSup(&pInfo->aggSup);
taosArrayDestroy(pInfo->pPseudoColInfo);
-
+
taosMemoryFreeClear(param);
}
@@ -3724,7 +3725,7 @@ static void destroyIndefinitOperatorInfo(void* param, int32_t numOfOutput) {
taosArrayDestroy(pInfo->pPseudoColInfo);
cleanupAggSup(&pInfo->aggSup);
cleanupExprSupp(&pInfo->scalarSup);
-
+
taosMemoryFreeClear(param);
}
@@ -3743,7 +3744,7 @@ void doDestroyExchangeOperatorInfo(void* param) {
}
tsem_destroy(&pExInfo->ready);
-
+
taosMemoryFreeClear(param);
}
@@ -3972,7 +3973,7 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t
pInfo->pFillInfo = taosCreateFillInfo(order, w.skey, 0, capacity, numOfCols, pInterval, fillType, pColInfo, id);
pInfo->win = win;
- pInfo->p = taosMemoryCalloc(numOfCols, POINTER_BYTES);
+ pInfo->p = taosMemoryCalloc(numOfCols, POINTER_BYTES);
if (pInfo->pFillInfo == NULL || pInfo->p == NULL) {
taosMemoryFree(pInfo->pFillInfo);
taosMemoryFree(pInfo->p);
@@ -4465,7 +4466,8 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
.precision = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->node.resType.precision};
int32_t tsSlotId = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId;
- pOptr = createMergeAlignedIntervalOperatorInfo(ops[0], pExprInfo, num, pResBlock, &interval, tsSlotId, pPhyNode->pConditions, pTaskInfo);
+ pOptr = createMergeAlignedIntervalOperatorInfo(ops[0], pExprInfo, num, pResBlock, &interval, tsSlotId,
+ pPhyNode->pConditions, pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL == type) {
SMergeIntervalPhysiNode* pIntervalPhyNode = (SMergeIntervalPhysiNode*)pPhyNode;
@@ -4504,8 +4506,8 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
SSDataBlock* pResBlock = createResDataBlock(pPhyNode->pOutputDataBlockDesc);
int32_t tsSlotId = ((SColumnNode*)pSessionNode->window.pTspk)->slotId;
- pOptr =
- createSessionAggOperatorInfo(ops[0], pExprInfo, num, pResBlock, pSessionNode->gap, tsSlotId, &as, pPhyNode->pConditions, pTaskInfo);
+ pOptr = createSessionAggOperatorInfo(ops[0], pExprInfo, num, pResBlock, pSessionNode->gap, tsSlotId, &as,
+ pPhyNode->pConditions, pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION == type) {
pOptr = createStreamSessionAggOperatorInfo(ops[0], pPhyNode, pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION == type) {
@@ -4527,7 +4529,8 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
SColumnNode* pColNode = (SColumnNode*)((STargetNode*)pStateNode->pStateKey)->pExpr;
SColumn col = extractColumnFromColumnNode(pColNode);
- pOptr = createStatewindowOperatorInfo(ops[0], pExprInfo, num, pResBlock, &as, tsSlotId, &col, pPhyNode->pConditions, pTaskInfo);
+ pOptr = createStatewindowOperatorInfo(ops[0], pExprInfo, num, pResBlock, &as, tsSlotId, &col, pPhyNode->pConditions,
+ pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE == type) {
pOptr = createStreamStateAggOperatorInfo(ops[0], pPhyNode, pTaskInfo);
} else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN == type) {
@@ -4798,7 +4801,7 @@ int32_t createDataSinkParam(SDataSinkNode* pNode, void** pParam, qTaskInfo_t* pT
return TSDB_CODE_OUT_OF_MEMORY;
}
pInserterParam->readHandle = readHandle;
-
+
*pParam = pInserterParam;
break;
}
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index cdac46c948..e42510ceba 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -40,8 +40,8 @@ static int32_t buildDbTableInfoBlock(const SSDataBlock* p, const SSysTableMeta*
const char* dbName);
static int32_t addTagPseudoColumnData(SReadHandle* pHandle, SExprInfo* pPseudoExpr, int32_t numOfPseudoExpr,
- SSDataBlock* pBlock, const char* idStr);
-static bool processBlockWithProbability(const SSampleExecInfo* pInfo);
+ SSDataBlock* pBlock, const char* idStr);
+static bool processBlockWithProbability(const SSampleExecInfo* pInfo);
bool processBlockWithProbability(const SSampleExecInfo* pInfo) {
#if 0
@@ -265,7 +265,8 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableSca
if (pTableScanInfo->pseudoSup.numOfExprs > 0) {
SExprSupp* pSup = &pTableScanInfo->pseudoSup;
- int32_t code = addTagPseudoColumnData(&pTableScanInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pBlock, GET_TASKID(pTaskInfo));
+ int32_t code = addTagPseudoColumnData(&pTableScanInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pBlock,
+ GET_TASKID(pTaskInfo));
if (code != TSDB_CODE_SUCCESS) {
longjmp(pTaskInfo->env, code);
}
@@ -303,7 +304,7 @@ static void prepareForDescendingScan(STableScanInfo* pTableScanInfo, SqlFunction
}
int32_t addTagPseudoColumnData(SReadHandle* pHandle, SExprInfo* pPseudoExpr, int32_t numOfPseudoExpr,
- SSDataBlock* pBlock, const char* idStr) {
+ SSDataBlock* pBlock, const char* idStr) {
// currently only the tbname pseudo column
if (numOfPseudoExpr == 0) {
return TSDB_CODE_SUCCESS;
@@ -313,7 +314,7 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, SExprInfo* pPseudoExpr, int
metaReaderInit(&mr, pHandle->meta, 0);
int32_t code = metaGetTableEntryByUid(&mr, pBlock->info.uid);
if (code != TSDB_CODE_SUCCESS) {
- qError("failed to get table meta, uid:0x%"PRIx64 ", code:%s, %s", pBlock->info.uid, tstrerror(terrno), idStr);
+ qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", pBlock->info.uid, tstrerror(terrno), idStr);
metaReaderClear(&mr);
return terrno;
}
@@ -426,8 +427,11 @@ static SSDataBlock* doTableScanImpl(SOperatorInfo* pOperator) {
pOperator->cost.totalCost = pTableScanInfo->readRecorder.elapsedTime;
// todo refactor
- pTableScanInfo->lastStatus.uid = pBlock->info.uid;
- pTableScanInfo->lastStatus.ts = pBlock->info.window.ekey;
+ /*pTableScanInfo->lastStatus.uid = pBlock->info.uid;*/
+ /*pTableScanInfo->lastStatus.ts = pBlock->info.window.ekey;*/
+ pTaskInfo->streamInfo.lastStatus.type = TMQ_OFFSET__SNAPSHOT_DATA;
+ pTaskInfo->streamInfo.lastStatus.uid = pBlock->info.uid;
+ pTaskInfo->streamInfo.lastStatus.ts = pBlock->info.window.ekey;
ASSERT(pBlock->info.uid != 0);
return pBlock;
@@ -697,7 +701,7 @@ static int32_t doGetTableRowSize(void* pMeta, uint64_t uid, int32_t* rowLen, con
metaReaderInit(&mr, pMeta, 0);
int32_t code = metaGetTableEntryByUid(&mr, uid);
if (code != TSDB_CODE_SUCCESS) {
- qError("failed to get table meta, uid:0x%"PRIx64 ", code:%s, %s", uid, tstrerror(terrno), idstr);
+ qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", uid, tstrerror(terrno), idstr);
metaReaderClear(&mr);
return terrno;
}
@@ -711,7 +715,7 @@ static int32_t doGetTableRowSize(void* pMeta, uint64_t uid, int32_t* rowLen, con
uint64_t suid = mr.me.ctbEntry.suid;
code = metaGetTableEntryByUid(&mr, suid);
if (code != TSDB_CODE_SUCCESS) {
- qError("failed to get table meta, uid:0x%"PRIx64 ", code:%s, %s", suid, tstrerror(terrno), idstr);
+ qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", suid, tstrerror(terrno), idstr);
metaReaderClear(&mr);
return terrno;
}
@@ -738,12 +742,13 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) {
}
SBlockDistInfo* pBlockScanInfo = pOperator->info;
- SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+ SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
STableBlockDistInfo blockDistInfo = {.minRows = INT_MAX, .maxRows = INT_MIN};
- int32_t code = doGetTableRowSize(pBlockScanInfo->readHandle.meta, pBlockScanInfo->uid, &blockDistInfo.rowSize, GET_TASKID(pTaskInfo));
+ int32_t code = doGetTableRowSize(pBlockScanInfo->readHandle.meta, pBlockScanInfo->uid, &blockDistInfo.rowSize,
+ GET_TASKID(pTaskInfo));
if (code != TSDB_CODE_SUCCESS) {
- longjmp(pTaskInfo->env, code);
+ longjmp(pTaskInfo->env, code);
}
tsdbGetFileBlocksDistInfo(pBlockScanInfo->pHandle, &blockDistInfo);
@@ -938,7 +943,8 @@ static bool prepareDataScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_t t
setGroupId(pInfo, pSDB, GROUPID_COLUMN_INDEX, *pRowIndex);
(*pRowIndex) += updateSessionWindowInfo(pCurWin, tsCols, NULL, pSDB->info.rows, *pRowIndex, gap, NULL);
} else {
- win = getActiveTimeWindow(NULL, &dumyInfo, tsCols[*pRowIndex], &pInfo->interval, pInfo->interval.precision, TSDB_ORDER_ASC);
+ win = getActiveTimeWindow(NULL, &dumyInfo, tsCols[*pRowIndex], &pInfo->interval, pInfo->interval.precision,
+ TSDB_ORDER_ASC);
setGroupId(pInfo, pSDB, GROUPID_COLUMN_INDEX, *pRowIndex);
(*pRowIndex) +=
getNumOfRowsInTimeWindow(&pSDB->info, tsCols, *pRowIndex, win.ekey, binarySearchForKey, NULL, TSDB_ORDER_ASC);
@@ -1219,7 +1225,8 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
// currently only the tbname pseudo column
if (pInfo->numOfPseudoExpr > 0) {
- int32_t code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes, GET_TASKID(pTaskInfo));
+ int32_t code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes,
+ GET_TASKID(pTaskInfo));
if (code != TSDB_CODE_SUCCESS) {
longjmp(pTaskInfo->env, code);
}
@@ -1227,9 +1234,6 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
doFilter(pInfo->pCondition, pInfo->pRes);
blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);
- if (pBlockInfo->rows > 0) {
- return 0;
- }
return 0;
}
@@ -1255,7 +1259,9 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
/*pTaskInfo->streamInfo.lastStatus = ret.offset;*/
if (pInfo->pRes->info.rows > 0) {
return pInfo->pRes;
- /*} else {*/
+ } else {
+ // data is filtered out, do clean
+
/*tDeleteSSDataBlock(&ret.data);*/
}
} else if (ret.fetchType == FETCH_TYPE__META) {
@@ -1264,17 +1270,16 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
pTaskInfo->streamInfo.metaBlk = ret.meta;
return NULL;
} else if (ret.fetchType == FETCH_TYPE__NONE) {
- if (ret.offset.version == -1) {
- pTaskInfo->streamInfo.lastStatus.type = TMQ_OFFSET__LOG;
- pTaskInfo->streamInfo.lastStatus.version = pTaskInfo->streamInfo.prepareStatus.version - 1;
- } else {
- pTaskInfo->streamInfo.lastStatus = ret.offset;
- }
+ pTaskInfo->streamInfo.lastStatus = ret.offset;
+ ASSERT(pTaskInfo->streamInfo.lastStatus.version + 1 >= pTaskInfo->streamInfo.prepareStatus.version);
return NULL;
} else {
ASSERT(0);
}
}
+ } else if (pTaskInfo->streamInfo.prepareStatus.type == TMQ_OFFSET__SNAPSHOT_DATA) {
+ SSDataBlock* pResult = doTableScan(pInfo->pTableScanOp);
+ return pResult && pResult->info.rows > 0 ? pResult : NULL;
}
size_t total = taosArrayGetSize(pInfo->pBlockLists);
@@ -1386,71 +1391,8 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
return NULL;
}
- pInfo->pRes->info.rows = block.info.rows;
- pInfo->pRes->info.uid = block.info.uid;
- pInfo->pRes->info.type = STREAM_NORMAL;
- pInfo->pRes->info.capacity = block.info.rows;
+ setBlockIntoRes(pInfo, &block);
- uint64_t* groupIdPre = taosHashGet(pOperator->pTaskInfo->tableqinfoList.map, &block.info.uid, sizeof(int64_t));
- if (groupIdPre) {
- pInfo->pRes->info.groupId = *groupIdPre;
- } else {
- pInfo->pRes->info.groupId = 0;
- }
-
- // for generating rollup SMA result, each time is an independent time serie.
- // TODO temporarily used, when the statement of "partition by tbname" is ready, remove this
- if (pInfo->assignBlockUid) {
- pInfo->pRes->info.groupId = block.info.uid;
- }
-
- // todo extract method
- for (int32_t i = 0; i < taosArrayGetSize(pInfo->pColMatchInfo); ++i) {
- SColMatchInfo* pColMatchInfo = taosArrayGet(pInfo->pColMatchInfo, i);
- if (!pColMatchInfo->output) {
- continue;
- }
-
- bool colExists = false;
- for (int32_t j = 0; j < blockDataGetNumOfCols(&block); ++j) {
- SColumnInfoData* pResCol = bdGetColumnInfoData(&block, j);
- if (pResCol->info.colId == pColMatchInfo->colId) {
- taosArraySet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId, pResCol);
- colExists = true;
- break;
- }
- }
-
- // the required column does not exists in submit block, let's set it to be all null value
- if (!colExists) {
- SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId);
- colDataAppendNNULL(pDst, 0, pBlockInfo->rows);
- }
- }
-
- taosArrayDestroy(block.pDataBlock);
-
- ASSERT(pInfo->pRes->pDataBlock != NULL);
-#if 0
- if (pInfo->pRes->pDataBlock == NULL) {
- // TODO add log
- updateInfoDestoryColseWinSBF(pInfo->pUpdateInfo);
- pOperator->status = OP_EXEC_DONE;
- pTaskInfo->code = terrno;
- return NULL;
- }
-#endif
-
- // currently only the tbname pseudo column
- if (pInfo->numOfPseudoExpr > 0) {
- code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes, GET_TASKID(pTaskInfo));
- if (code != TSDB_CODE_SUCCESS) {
- longjmp(pTaskInfo->env, code);
- }
- }
-
- doFilter(pInfo->pCondition, pInfo->pRes);
- blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);
if (pBlockInfo->rows > 0) {
break;
}
@@ -1480,11 +1422,14 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
return (pBlockInfo->rows == 0) ? NULL : pInfo->pRes;
+#if 0
} else if (pInfo->blockType == STREAM_INPUT__TABLE_SCAN) {
+ ASSERT(0);
// check reader last status
// if not match, reset status
SSDataBlock* pResult = doTableScan(pInfo->pTableScanOp);
return pResult && pResult->info.rows > 0 ? pResult : NULL;
+#endif
} else {
ASSERT(0);
@@ -1873,9 +1818,10 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) {
metaReaderInit(&mr, pInfo->readHandle.meta, 0);
uint64_t suid = pInfo->pCur->mr.me.ctbEntry.suid;
- int32_t code = metaGetTableEntryByUid(&mr, suid);
+ int32_t code = metaGetTableEntryByUid(&mr, suid);
if (code != TSDB_CODE_SUCCESS) {
- qError("failed to get super table meta, uid:0x%"PRIx64 ", code:%s, %s", suid, tstrerror(terrno), GET_TASKID(pTaskInfo));
+ qError("failed to get super table meta, uid:0x%" PRIx64 ", code:%s, %s", suid, tstrerror(terrno),
+ GET_TASKID(pTaskInfo));
metaReaderClear(&mr);
metaCloseTbCursor(pInfo->pCur);
pInfo->pCur = NULL;
@@ -2275,9 +2221,10 @@ static SSDataBlock* doTagScan(SOperatorInfo* pOperator) {
while (pInfo->curPos < size && count < pOperator->resultInfo.capacity) {
STableKeyInfo* item = taosArrayGet(pInfo->pTableList->pTableList, pInfo->curPos);
- int32_t code = metaGetTableEntryByUid(&mr, item->uid);
+ int32_t code = metaGetTableEntryByUid(&mr, item->uid);
if (code != TSDB_CODE_SUCCESS) {
- qError("failed to get table meta, uid:0x%"PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno), GET_TASKID(pTaskInfo));
+ qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),
+ GET_TASKID(pTaskInfo));
metaReaderClear(&mr);
longjmp(pTaskInfo->env, terrno);
}
@@ -2565,8 +2512,8 @@ static int32_t loadDataBlockFromOneTable(SOperatorInfo* pOperator, STableMergeSc
// currently only the tbname pseudo column
if (pTableScanInfo->numOfPseudoExpr > 0) {
- int32_t code = addTagPseudoColumnData(&pTableScanInfo->readHandle, pTableScanInfo->pPseudoExpr, pTableScanInfo->numOfPseudoExpr,
- pBlock, GET_TASKID(pTaskInfo));
+ int32_t code = addTagPseudoColumnData(&pTableScanInfo->readHandle, pTableScanInfo->pPseudoExpr,
+ pTableScanInfo->numOfPseudoExpr, pBlock, GET_TASKID(pTaskInfo));
if (code != TSDB_CODE_SUCCESS) {
longjmp(pTaskInfo->env, code);
}
diff --git a/source/libs/index/inc/indexFstCommon.h b/source/libs/index/inc/indexFstCommon.h
index 8335e437fb..e15df5dc34 100644
--- a/source/libs/index/inc/indexFstCommon.h
+++ b/source/libs/index/inc/indexFstCommon.h
@@ -4,6 +4,7 @@
#include "tutil.h"
extern const uint8_t COMMON_INPUTS[];
extern const char COMMON_INPUTS_INV[];
+extern const int32_t COMMON_INPUTS_LEN;
#ifdef __cplusplus
extern "C" {
diff --git a/source/libs/index/inc/indexFstDfa.h b/source/libs/index/inc/indexFstDfa.h
index f6c220bcb7..9ca10897fd 100644
--- a/source/libs/index/inc/indexFstDfa.h
+++ b/source/libs/index/inc/indexFstDfa.h
@@ -29,16 +29,16 @@ extern "C" {
typedef struct FstDfa FstDfa;
typedef struct {
- SArray * insts;
+ SArray *insts;
uint32_t next[256];
bool isMatch;
-} State;
+} DfaState;
/*
* dfa builder related func
**/
typedef struct FstDfaBuilder {
- FstDfa * dfa;
+ FstDfa *dfa;
SHashObj *cache;
} FstDfaBuilder;
diff --git a/source/libs/index/inc/indexFstRegex.h b/source/libs/index/inc/indexFstRegex.h
index 2bf9c9b791..2814b5dc16 100644
--- a/source/libs/index/inc/indexFstRegex.h
+++ b/source/libs/index/inc/indexFstRegex.h
@@ -65,6 +65,7 @@ typedef struct {
} FstRegex;
FstRegex *regexCreate(const char *str);
+void regexDestroy(FstRegex *regex);
uint32_t regexAutomStart(FstRegex *regex);
bool regexAutomIsMatch(FstRegex *regex, uint32_t state);
diff --git a/source/libs/index/src/indexCache.c b/source/libs/index/src/indexCache.c
index 040e8ed830..05ce418037 100644
--- a/source/libs/index/src/indexCache.c
+++ b/source/libs/index/src/indexCache.c
@@ -22,7 +22,7 @@
#define MAX_INDEX_KEY_LEN 256 // test only, change later
#define MEM_TERM_LIMIT 10 * 10000
-#define MEM_THRESHOLD 64 * 1024
+#define MEM_THRESHOLD 512 * 1024
#define MEM_SIGNAL_QUIT MEM_THRESHOLD * 20
#define MEM_ESTIMATE_RADIO 1.5
@@ -204,7 +204,6 @@ static int32_t cacheSearchTerm_JSON(void* cache, SIndexTerm* term, SIdxTRslt* tr
if (0 == strcmp(c->colVal, pCt->colVal)) {
if (c->operaType == ADD_VALUE) {
INDEX_MERGE_ADD_DEL(tr->del, tr->add, c->uid)
- // taosArrayPush(result, &c->uid);
*s = kTypeValue;
} else if (c->operaType == DEL_VALUE) {
INDEX_MERGE_ADD_DEL(tr->add, tr->del, c->uid)
@@ -309,7 +308,6 @@ static int32_t cacheSearchCompareFunc_JSON(void* cache, SIndexTerm* term, SIdxTR
if (cond == MATCH) {
if (c->operaType == ADD_VALUE) {
INDEX_MERGE_ADD_DEL(tr->del, tr->add, c->uid)
- // taosArrayPush(result, &c->uid);
*s = kTypeValue;
} else if (c->operaType == DEL_VALUE) {
INDEX_MERGE_ADD_DEL(tr->add, tr->del, c->uid)
diff --git a/source/libs/index/src/indexFst.c b/source/libs/index/src/indexFst.c
index 81ac4c9d40..c4b83f8a07 100644
--- a/source/libs/index/src/indexFst.c
+++ b/source/libs/index/src/indexFst.c
@@ -1307,7 +1307,6 @@ FStmStRslt* stmStNextWith(FStmSt* sws, StreamCallback callback) {
taosArrayPush(sws->inp, &(trn.inp));
if (FST_NODE_IS_FINAL(nextNode)) {
- // void *eofState = sws->aut->acceptEof(nextState);
void* eofState = automFuncs[aut->type].acceptEof(aut, nextState);
if (eofState != NULL) {
isMatch = automFuncs[aut->type].isMatch(aut, eofState);
diff --git a/source/libs/index/src/indexFstCommon.c b/source/libs/index/src/indexFstCommon.c
index 902e68ce09..0b20157009 100644
--- a/source/libs/index/src/indexFstCommon.c
+++ b/source/libs/index/src/indexFstCommon.c
@@ -294,3 +294,4 @@ const char COMMON_INPUTS_INV[] = {
'\xee', '\xef', '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf7', '\xf8', '\xf9', '\xfa', '\xfb',
'\xfc', '\xfd', '\xfe', '\xff',
};
+const int32_t COMMON_INPUTS_LEN = sizeof(COMMON_INPUTS) / sizeof(COMMON_INPUTS[0]);
diff --git a/source/libs/index/src/indexFstDfa.c b/source/libs/index/src/indexFstDfa.c
index 3011f124c9..b820f16a2a 100644
--- a/source/libs/index/src/indexFstDfa.c
+++ b/source/libs/index/src/indexFstDfa.c
@@ -41,7 +41,7 @@ FstDfaBuilder *dfaBuilderCreate(SArray *insts) {
return NULL;
}
- SArray *states = taosArrayInit(4, sizeof(State));
+ SArray *states = taosArrayInit(4, sizeof(DfaState));
builder->dfa = dfaCreate(insts, states);
builder->cache = taosHashInit(
@@ -71,7 +71,7 @@ FstDfa *dfaBuilder(FstDfaBuilder *builder) {
dfaAdd(builder->dfa, cur, 0);
- SArray * states = taosArrayInit(0, sizeof(uint32_t));
+ SArray *states = taosArrayInit(0, sizeof(uint32_t));
uint32_t result;
if (dfaBuilderCachedState(builder, cur, &result)) {
taosArrayPush(states, &result);
@@ -98,10 +98,12 @@ FstDfa *dfaBuilder(FstDfaBuilder *builder) {
return builder->dfa;
}
+FstDfa *dfaBuilderBuild(FstDfaBuilder *builer) { return NULL; }
+
bool dfaBuilderRunState(FstDfaBuilder *builder, FstSparseSet *cur, FstSparseSet *next, uint32_t state, uint8_t byte,
uint32_t *result) {
sparSetClear(cur);
- State *t = taosArrayGet(builder->dfa->states, state);
+ DfaState *t = taosArrayGet(builder->dfa->states, state);
for (int i = 0; i < taosArrayGetSize(t->insts); i++) {
uint32_t ip = *(int32_t *)taosArrayGet(t->insts, i);
sparSetAdd(cur, ip);
@@ -144,7 +146,7 @@ bool dfaBuilderCachedState(FstDfaBuilder *builder, FstSparseSet *set, uint32_t *
*result = *v;
taosArrayDestroy(tinsts);
} else {
- State st;
+ DfaState st;
st.insts = tinsts;
st.isMatch = isMatch;
taosArrayPush(builder->dfa->states, &st);
@@ -169,14 +171,14 @@ bool dfaIsMatch(FstDfa *dfa, uint32_t si) {
if (dfa->states == NULL || si < taosArrayGetSize(dfa->states)) {
return false;
}
- State *st = taosArrayGet(dfa->states, si);
+ DfaState *st = taosArrayGet(dfa->states, si);
return st != NULL ? st->isMatch : false;
}
bool dfaAccept(FstDfa *dfa, uint32_t si, uint8_t byte, uint32_t *result) {
if (dfa->states == NULL || si < taosArrayGetSize(dfa->states)) {
return false;
}
- State *st = taosArrayGet(dfa->states, si);
+ DfaState *st = taosArrayGet(dfa->states, si);
*result = st->next[byte];
return true;
}
diff --git a/source/libs/index/src/indexFstRegex.c b/source/libs/index/src/indexFstRegex.c
index 33eeae802e..37cb58996f 100644
--- a/source/libs/index/src/indexFstRegex.c
+++ b/source/libs/index/src/indexFstRegex.c
@@ -23,7 +23,7 @@ FstRegex *regexCreate(const char *str) {
return NULL;
}
int32_t sz = (int32_t)strlen(str);
- char * orig = taosMemoryCalloc(1, sz);
+ char *orig = taosMemoryCalloc(1, sz);
memcpy(orig, str, sz);
regex->orig = orig;
@@ -36,6 +36,12 @@ FstRegex *regexCreate(const char *str) {
return regex;
}
+void regexDestroy(FstRegex *regex) {
+ if (regex == NULL) return;
+ taosMemoryFree(regex->orig);
+ taosMemoryFree(regex);
+}
+
uint32_t regexAutomStart(FstRegex *regex) {
///// no nothing
return 0;
diff --git a/source/libs/index/test/CMakeLists.txt b/source/libs/index/test/CMakeLists.txt
index 9a4b7bbad8..b3eca28003 100644
--- a/source/libs/index/test/CMakeLists.txt
+++ b/source/libs/index/test/CMakeLists.txt
@@ -4,6 +4,7 @@ IF(NOT TD_DARWIN)
add_executable(idxFstUT "")
add_executable(idxUtilUT "")
add_executable(idxJsonUT "")
+ add_executable(idxFstUtilUT "")
target_sources(idxTest
PRIVATE
@@ -23,6 +24,25 @@ IF(NOT TD_DARWIN)
"utilUT.cc"
)
+ target_sources(idxJsonUT
+ PRIVATE
+ "jsonUT.cc"
+ )
+ target_sources(idxFstUtilUT
+ PRIVATE
+ "fstUtilUT.cc"
+ )
+
+ target_include_directories (idxTest
+ PUBLIC
+ "${TD_SOURCE_DIR}/include/libs/index"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
+ )
+ target_include_directories (idxFstTest
+ PUBLIC
+ "${TD_SOURCE_DIR}/include/libs/index"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
+ )
target_sources(idxJsonUT
PRIVATE
"jsonUT.cc"
@@ -50,6 +70,38 @@ IF(NOT TD_DARWIN)
"${CMAKE_CURRENT_SOURCE_DIR}/../inc"
)
+ target_include_directories (idxJsonUT
+ PUBLIC
+ "${TD_SOURCE_DIR}/include/libs/index"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
+ )
+ target_include_directories (idxFstUtilUT
+ PUBLIC
+ "${TD_SOURCE_DIR}/include/libs/index"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
+ )
+
+ target_link_libraries (idxTest
+ os
+ util
+ common
+ gtest_main
+ index
+ )
+ target_link_libraries (idxFstTest
+ os
+ util
+ common
+ gtest_main
+ index
+ )
+ target_link_libraries (idxFstUT
+ os
+ util
+ common
+ gtest_main
+ index
+ )
target_include_directories (idxJsonUT
PUBLIC
"${TD_SOURCE_DIR}/include/libs/index"
@@ -92,15 +144,28 @@ IF(NOT TD_DARWIN)
gtest_main
index
)
+ target_link_libraries (idxFstUtilUT
+ os
+ util
+ common
+ gtest_main
+ index
+ )
+
+ add_test(
+ NAME idxJsonUT
+ COMMAND idxJsonUT
+ )
+ add_test(
+ NAME idxFstUtilUT
+ COMMAND idxFstUtilUT
+
+ )
add_test(
NAME idxtest
COMMAND idxTest
)
- add_test(
- NAME idxJsonUT
- COMMAND idxJsonUT
- )
add_test(
NAME idxUtilUT
COMMAND idxUtilUT
@@ -109,4 +174,4 @@ IF(NOT TD_DARWIN)
NAME idxFstUT
COMMAND idxFstUT
)
-ENDIF ()
\ No newline at end of file
+ENDIF ()
diff --git a/source/libs/index/test/fstUtilUT.cc b/source/libs/index/test/fstUtilUT.cc
new file mode 100644
index 0000000000..2c29758756
--- /dev/null
+++ b/source/libs/index/test/fstUtilUT.cc
@@ -0,0 +1,70 @@
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include "index.h"
+#include "indexCache.h"
+#include "indexFst.h"
+#include "indexFstDfa.h"
+#include "indexFstRegex.h"
+#include "indexFstSparse.h"
+#include "indexFstUtil.h"
+#include "indexInt.h"
+#include "indexTfile.h"
+#include "tglobal.h"
+#include "tlog.h"
+#include "tskiplist.h"
+#include "tutil.h"
+class FstUtilEnv : public ::testing::Test {
+ protected:
+ virtual void SetUp() {
+ SArray *inst = taosArrayInit(4, sizeof(char));
+ builder = dfaBuilderCreate(inst);
+ }
+ virtual void TearDown() { dfaBuilderDestroy(builder); }
+
+ FstDfaBuilder *builder;
+};
+
+class FstRegexEnv : public ::testing::Test {
+ protected:
+ virtual void SetUp() { regex = regexCreate("test"); }
+ virtual void TearDown() { regexDestroy(regex); }
+ FstRegex *regex;
+};
+
+class FstSparseSetEnv : public ::testing::Test {
+ protected:
+ virtual void SetUp() { set = sparSetCreate(256); }
+ virtual void TearDown() {
+ // tear down
+ sparSetDestroy(set);
+ }
+ void ReBuild(int32_t sz) {
+ sparSetDestroy(set);
+ set = sparSetCreate(sz);
+ }
+ FstSparseSet *set;
+};
+
+// test FstDfaBuilder
+TEST_F(FstUtilEnv, test1) {}
+TEST_F(FstUtilEnv, test2) {}
+TEST_F(FstUtilEnv, test3) {}
+TEST_F(FstUtilEnv, test4) {}
+
+// test FstRegex
+
+TEST_F(FstRegexEnv, test1) {}
+TEST_F(FstRegexEnv, test2) {}
+TEST_F(FstRegexEnv, test3) {}
+TEST_F(FstRegexEnv, test4) {}
+
+// test FstSparseSet
+TEST_F(FstSparseSetEnv, test1) {}
+TEST_F(FstSparseSetEnv, test2) {}
+TEST_F(FstSparseSetEnv, test3) {}
+TEST_F(FstSparseSetEnv, test4) {}
diff --git a/source/libs/index/test/utilUT.cc b/source/libs/index/test/utilUT.cc
index ab5128cd3e..323a6b4afa 100644
--- a/source/libs/index/test/utilUT.cc
+++ b/source/libs/index/test/utilUT.cc
@@ -8,6 +8,7 @@
#include "indexCache.h"
#include "indexComm.h"
#include "indexFst.h"
+#include "indexFstCommon.h"
#include "indexFstUtil.h"
#include "indexInt.h"
#include "indexTfile.h"
@@ -356,3 +357,11 @@ TEST_F(UtilEnv, TempResultExcept) {
idxTRsltMergeTo(relt, f);
EXPECT_EQ(taosArrayGetSize(f), 1);
}
+
+TEST_F(UtilEnv, testDictComm) {
+ int32_t count = COMMON_INPUTS_LEN;
+ for (int i = 0; i < 256; i++) {
+ uint8_t v = COMMON_INPUTS_INV[i];
+ EXPECT_EQ(COMMON_INPUTS[v], i);
+ }
+}
diff --git a/source/libs/qworker/src/qwDbg.c b/source/libs/qworker/src/qwDbg.c
index dfe5a04d19..869eedf8f6 100644
--- a/source/libs/qworker/src/qwDbg.c
+++ b/source/libs/qworker/src/qwDbg.c
@@ -9,7 +9,7 @@
#include "tmsg.h"
#include "tname.h"
-SQWDebug gQWDebug = {.statusEnable = true, .dumpEnable = false, .tmp = false};
+SQWDebug gQWDebug = {.statusEnable = true, .dumpEnable = false, .tmp = true};
int32_t qwDbgValidateStatus(QW_FPARAMS_DEF, int8_t oriStatus, int8_t newStatus, bool *ignore) {
if (!gQWDebug.statusEnable) {
diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index cf8116fee7..757279269a 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -517,7 +517,7 @@ int32_t qwProcessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg, const char* sql) {
ctx->needFetch = qwMsg->msgInfo.needFetch;
ctx->queryType = qwMsg->msgType;
- QW_TASK_DLOGL("subplan json string, len:%d, %s", qwMsg->msgLen, qwMsg->msg);
+ //QW_TASK_DLOGL("subplan json string, len:%d, %s", qwMsg->msgLen, qwMsg->msg);
code = qStringToSubplan(qwMsg->msg, &plan);
if (TSDB_CODE_SUCCESS != code) {
diff --git a/source/libs/scalar/src/scalar.c b/source/libs/scalar/src/scalar.c
index 9bd82fb1a4..fc593355b3 100644
--- a/source/libs/scalar/src/scalar.c
+++ b/source/libs/scalar/src/scalar.c
@@ -578,7 +578,7 @@ _return:
SCL_RET(code);
}
-EDealRes sclRewriteBasedOnOptr(SNode** pNode, SScalarCtx *ctx, EOperatorType opType) {
+EDealRes sclRewriteNullInOptr(SNode** pNode, SScalarCtx *ctx, EOperatorType opType) {
if (opType <= OP_TYPE_CALC_MAX) {
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
if (NULL == res) {
@@ -610,6 +610,24 @@ EDealRes sclRewriteBasedOnOptr(SNode** pNode, SScalarCtx *ctx, EOperatorType opT
return DEAL_RES_CONTINUE;
}
+EDealRes sclAggFuncWalker(SNode* pNode, void* pContext) {
+ if (QUERY_NODE_FUNCTION == nodeType(pNode)) {
+ SFunctionNode* pFunc = (SFunctionNode*)pNode;
+ *(bool*)pContext = fmIsAggFunc(pFunc->funcId);
+ if (*(bool*)pContext) {
+ return DEAL_RES_END;
+ }
+ }
+
+ return DEAL_RES_CONTINUE;
+}
+
+
+bool sclContainsAggFuncNode(SNode* pNode) {
+ bool aggFunc = false;
+ nodesWalkExpr(pNode, sclAggFuncWalker, (void *)&aggFunc);
+ return aggFunc;
+}
EDealRes sclRewriteNonConstOperator(SNode** pNode, SScalarCtx *ctx) {
SOperatorNode *node = (SOperatorNode *)*pNode;
@@ -617,8 +635,9 @@ EDealRes sclRewriteNonConstOperator(SNode** pNode, SScalarCtx *ctx) {
if (node->pLeft && (QUERY_NODE_VALUE == nodeType(node->pLeft))) {
SValueNode *valueNode = (SValueNode *)node->pLeft;
- if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL)) {
- return sclRewriteBasedOnOptr(pNode, ctx, node->opType);
+ if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL)
+ && (!sclContainsAggFuncNode(node->pRight))) {
+ return sclRewriteNullInOptr(pNode, ctx, node->opType);
}
if (IS_STR_DATA_TYPE(valueNode->node.resType.type) && node->pRight && nodesIsExprNode(node->pRight)
@@ -633,8 +652,9 @@ EDealRes sclRewriteNonConstOperator(SNode** pNode, SScalarCtx *ctx) {
if (node->pRight && (QUERY_NODE_VALUE == nodeType(node->pRight))) {
SValueNode *valueNode = (SValueNode *)node->pRight;
- if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL)) {
- return sclRewriteBasedOnOptr(pNode, ctx, node->opType);
+ if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL)
+ && (!sclContainsAggFuncNode(node->pLeft))) {
+ return sclRewriteNullInOptr(pNode, ctx, node->opType);
}
if (IS_STR_DATA_TYPE(valueNode->node.resType.type) && node->pLeft && nodesIsExprNode(node->pLeft)
@@ -656,7 +676,7 @@ EDealRes sclRewriteNonConstOperator(SNode** pNode, SScalarCtx *ctx) {
ERASE_NODE(listNode->pNodeList);
continue;
} else { //OP_TYPE_NOT_IN
- return sclRewriteBasedOnOptr(pNode, ctx, node->opType);
+ return sclRewriteNullInOptr(pNode, ctx, node->opType);
}
}
@@ -664,7 +684,7 @@ EDealRes sclRewriteNonConstOperator(SNode** pNode, SScalarCtx *ctx) {
}
if (listNode->pNodeList->length <= 0) {
- return sclRewriteBasedOnOptr(pNode, ctx, node->opType);
+ return sclRewriteNullInOptr(pNode, ctx, node->opType);
}
}
diff --git a/source/libs/scheduler/inc/schInt.h b/source/libs/scheduler/inc/schInt.h
index 9018deaf13..052fdefa61 100644
--- a/source/libs/scheduler/inc/schInt.h
+++ b/source/libs/scheduler/inc/schInt.h
@@ -35,7 +35,6 @@ extern "C" {
#define SCH_DEFAULT_TASK_TIMEOUT_USEC 10000000
#define SCH_MAX_TASK_TIMEOUT_USEC 60000000
-#define SCH_TASK_MAX_EXEC_TIMES 8
#define SCH_MAX_CANDIDATE_EP_NUM TSDB_MAX_REPLICA
enum {
@@ -179,10 +178,10 @@ typedef struct SSchLevel {
} SSchLevel;
typedef struct SSchTaskProfile {
- int64_t startTs;
- int64_t execUseTime[SCH_TASK_MAX_EXEC_TIMES];
- int64_t waitTime;
- int64_t endTs;
+ int64_t startTs;
+ int64_t* execTime;
+ int64_t waitTime;
+ int64_t endTs;
} SSchTaskProfile;
typedef struct SSchTask {
@@ -260,33 +259,7 @@ typedef struct SSchJob {
extern SSchedulerMgmt schMgmt;
-#define SCH_LOG_TASK_START_TS(_task) \
- do { \
- int64_t us = taosGetTimestampUs(); \
- int32_t idx = (_task)->execId % SCH_TASK_MAX_EXEC_TIMES; \
- (_task)->profile.execUseTime[idx] = us; \
- if (0 == (_task)->execId) { \
- (_task)->profile.startTs = us; \
- } \
- } while (0)
-
-#define SCH_LOG_TASK_WAIT_TS(_task) \
- do { \
- int64_t us = taosGetTimestampUs(); \
- int32_t idx = (_task)->execId % SCH_TASK_MAX_EXEC_TIMES; \
- (_task)->profile.waitTime += us - (_task)->profile.execUseTime[idx]; \
- } while (0)
-
-
-#define SCH_LOG_TASK_END_TS(_task) \
- do { \
- int64_t us = taosGetTimestampUs(); \
- int32_t idx = (_task)->execId % SCH_TASK_MAX_EXEC_TIMES; \
- (_task)->profile.execUseTime[idx] = us - (_task)->profile.execUseTime[idx]; \
- (_task)->profile.endTs = us; \
- } while (0)
-
-#define SCH_TASK_TIMEOUT(_task) ((taosGetTimestampUs() - (_task)->profile.execUseTime[(_task)->execId % SCH_TASK_MAX_EXEC_TIMES]) > (_task)->timeoutUsec)
+#define SCH_TASK_TIMEOUT(_task) ((taosGetTimestampUs() - (_task)->profile.execTime[(_task)->execId % (_task)->maxExecTimes]) > (_task)->timeoutUsec)
#define SCH_TASK_READY_FOR_LAUNCH(readyNum, task) ((readyNum) >= taosArrayGetSize((task)->children))
@@ -320,6 +293,7 @@ extern SSchedulerMgmt schMgmt;
#define SCH_TASK_NEED_FLOW_CTRL(_job, _task) (SCH_IS_DATA_BIND_QRY_TASK(_task) && SCH_JOB_NEED_FLOW_CTRL(_job) && SCH_IS_LEVEL_UNFINISHED((_task)->level))
#define SCH_FETCH_TYPE(_pSrcTask) (SCH_IS_DATA_BIND_QRY_TASK(_pSrcTask) ? TDMT_SCH_FETCH : TDMT_SCH_MERGE_FETCH)
#define SCH_TASK_NEED_FETCH(_task) ((_task)->plan->subplanType != SUBPLAN_TYPE_MODIFY)
+#define SCH_TASK_MAX_EXEC_TIMES(_levelIdx, _levelNum) (SCH_MAX_CANDIDATE_EP_NUM * ((_levelNum) - (_levelIdx)))
#define SCH_SET_JOB_TYPE(_job, type) do { if ((type) != SUBPLAN_TYPE_MODIFY) { (_job)->attr.queryJob = true; } } while (0)
#define SCH_IS_QUERY_JOB(_job) ((_job)->attr.queryJob)
@@ -328,16 +302,43 @@ extern SSchedulerMgmt schMgmt;
#define SCH_JOB_NEED_DROP(_job) (SCH_IS_QUERY_JOB(_job))
#define SCH_IS_EXPLAIN_JOB(_job) (EXPLAIN_MODE_ANALYZE == (_job)->attr.explainMode)
#define SCH_NETWORK_ERR(_code) ((_code) == TSDB_CODE_RPC_BROKEN_LINK || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL)
-#define SCH_SUB_TASK_NETWORK_ERR(_code, _len) (SCH_NETWORK_ERR(_code) && ((_len) > 0))
-#define SCH_NEED_REDIRECT_MSGTYPE(_msgType) ((_msgType) == TDMT_SCH_QUERY || (_msgType) == TDMT_SCH_MERGE_QUERY || (_msgType) == TDMT_SCH_FETCH || (_msgType) == TDMT_SCH_MERGE_FETCH)
-#define SCH_NEED_REDIRECT(_msgType, _code, _rspLen) (SCH_NEED_REDIRECT_MSGTYPE(_msgType) && (NEED_SCHEDULER_REDIRECT_ERROR(_code) || SCH_SUB_TASK_NETWORK_ERR(_code, _rspLen)))
-#define SCH_NEED_RETRY(_msgType, _code) ((SCH_NETWORK_ERR(_code) && SCH_NEED_REDIRECT_MSGTYPE(_msgType)) || (_code) == TSDB_CODE_SCH_TIMEOUT_ERROR)
+#define SCH_MERGE_TASK_NETWORK_ERR(_task, _code, _len) (SCH_NETWORK_ERR(_code) && (((_len) > 0) || (!SCH_IS_DATA_BIND_TASK(_task))))
+#define SCH_REDIRECT_MSGTYPE(_msgType) ((_msgType) == TDMT_SCH_QUERY || (_msgType) == TDMT_SCH_MERGE_QUERY || (_msgType) == TDMT_SCH_FETCH || (_msgType) == TDMT_SCH_MERGE_FETCH)
+#define SCH_TASK_NEED_REDIRECT(_task, _msgType, _code, _rspLen) (SCH_REDIRECT_MSGTYPE(_msgType) && (NEED_SCHEDULER_REDIRECT_ERROR(_code) || SCH_MERGE_TASK_NETWORK_ERR((_task), (_code), (_rspLen))))
+#define SCH_NEED_RETRY(_msgType, _code) ((SCH_NETWORK_ERR(_code) && SCH_REDIRECT_MSGTYPE(_msgType)) || (_code) == TSDB_CODE_SCH_TIMEOUT_ERROR)
#define SCH_IS_LEVEL_UNFINISHED(_level) ((_level)->taskLaunchedNum < (_level)->taskNum)
#define SCH_GET_CUR_EP(_addr) (&(_addr)->epSet.eps[(_addr)->epSet.inUse])
#define SCH_SWITCH_EPSET(_addr) ((_addr)->epSet.inUse = ((_addr)->epSet.inUse + 1) % (_addr)->epSet.numOfEps)
#define SCH_TASK_NUM_OF_EPS(_addr) ((_addr)->epSet.numOfEps)
+#define SCH_LOG_TASK_START_TS(_task) \
+ do { \
+ int64_t us = taosGetTimestampUs(); \
+ int32_t idx = (_task)->execId % (_task)->maxExecTimes; \
+ (_task)->profile.execTime[idx] = us; \
+ if (0 == (_task)->execId) { \
+ (_task)->profile.startTs = us; \
+ } \
+ } while (0)
+
+#define SCH_LOG_TASK_WAIT_TS(_task) \
+ do { \
+ int64_t us = taosGetTimestampUs(); \
+ int32_t idx = (_task)->execId % (_task)->maxExecTimes; \
+ (_task)->profile.waitTime += us - (_task)->profile.execTime[idx]; \
+ } while (0)
+
+
+#define SCH_LOG_TASK_END_TS(_task) \
+ do { \
+ int64_t us = taosGetTimestampUs(); \
+ int32_t idx = (_task)->execId % (_task)->maxExecTimes; \
+ (_task)->profile.execTime[idx] = us - (_task)->profile.execTime[idx]; \
+ (_task)->profile.endTs = us; \
+ } while (0)
+
+
#define SCH_JOB_ELOG(param, ...) qError("QID:0x%" PRIx64 " " param, pJob->queryId, __VA_ARGS__)
#define SCH_JOB_DLOG(param, ...) qDebug("QID:0x%" PRIx64 " " param, pJob->queryId, __VA_ARGS__)
@@ -431,7 +432,8 @@ void schFreeTask(SSchJob *pJob, SSchTask *pTask);
void schDropTaskInHashList(SSchJob *pJob, SHashObj *list);
int32_t schLaunchLevelTasks(SSchJob *pJob, SSchLevel *level);
int32_t schGetTaskFromList(SHashObj *pTaskList, uint64_t taskId, SSchTask **pTask);
-int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel *pLevel);
+int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel *pLevel, int32_t levelNum);
+int32_t schSwitchTaskCandidateAddr(SSchJob *pJob, SSchTask *pTask);
#ifdef __cplusplus
diff --git a/source/libs/scheduler/src/schJob.c b/source/libs/scheduler/src/schJob.c
index 13100afb8b..d2f9624eee 100644
--- a/source/libs/scheduler/src/schJob.c
+++ b/source/libs/scheduler/src/schJob.c
@@ -337,7 +337,7 @@ int32_t schValidateAndBuildJob(SQueryPlan *pDag, SSchJob *pJob) {
SCH_SET_JOB_TYPE(pJob, plan->subplanType);
SSchTask task = {0};
- SCH_ERR_JRET(schInitTask(pJob, &task, plan, pLevel));
+ SCH_ERR_JRET(schInitTask(pJob, &task, plan, pLevel, levelNum));
SSchTask *pTask = taosArrayPush(pLevel->subTasks, &task);
if (NULL == pTask) {
diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c
index f9c3d80e46..2257ba8328 100644
--- a/source/libs/scheduler/src/schRemote.c
+++ b/source/libs/scheduler/src/schRemote.c
@@ -85,7 +85,7 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDa
SCH_ERR_JRET(schValidateRspMsgType(pJob, pTask, msgType));
int32_t reqType = IsReq(pMsg) ? pMsg->msgType : (pMsg->msgType - 1);
- if (SCH_NEED_REDIRECT(reqType, rspCode, pMsg->len)) {
+ if (SCH_TASK_NEED_REDIRECT(pTask, reqType, rspCode, pMsg->len)) {
SCH_RET(schHandleRedirect(pJob, pTask, (SDataBuf *)pMsg, rspCode));
}
diff --git a/source/libs/scheduler/src/schTask.c b/source/libs/scheduler/src/schTask.c
index d56397283c..e1e4ed8769 100644
--- a/source/libs/scheduler/src/schTask.c
+++ b/source/libs/scheduler/src/schTask.c
@@ -46,21 +46,31 @@ void schFreeTask(SSchJob *pJob, SSchTask *pTask) {
}
-int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel *pLevel) {
+int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel *pLevel, int32_t levelNum) {
+ int32_t code = 0;
+
pTask->plan = pPlan;
pTask->level = pLevel;
pTask->execId = -1;
- pTask->maxExecTimes = SCH_TASK_MAX_EXEC_TIMES;
+ pTask->maxExecTimes = SCH_TASK_MAX_EXEC_TIMES(pLevel->level, levelNum);
pTask->timeoutUsec = SCH_DEFAULT_TASK_TIMEOUT_USEC;
- SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_INIT);
pTask->taskId = schGenTaskId();
pTask->execNodes = taosHashInit(SCH_MAX_CANDIDATE_EP_NUM, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
- if (NULL == pTask->execNodes) {
- SCH_TASK_ELOG("taosHashInit %d execNodes failed", SCH_MAX_CANDIDATE_EP_NUM);
- SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
+ pTask->profile.execTime = taosMemoryCalloc(pTask->maxExecTimes, sizeof(int64_t));
+ if (NULL == pTask->execNodes || NULL == pTask->profile.execTime) {
+ SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
}
+ SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_INIT);
+
return TSDB_CODE_SUCCESS;
+
+_return:
+
+ taosMemoryFreeClear(pTask->profile.execTime);
+ taosHashCleanup(pTask->execNodes);
+
+ SCH_RET(code);
}
int32_t schRecordTaskSucceedNode(SSchJob *pJob, SSchTask *pTask) {
@@ -338,6 +348,11 @@ int32_t schDoTaskRedirect(SSchJob *pJob, SSchTask *pTask, SDataBuf* pData, int32
qClearSubplanExecutionNode(pTask->plan);
+ // Note: current error task and upper level merge task
+ if ((pData && 0 == pData->len) || NULL == pData) {
+ SCH_ERR_JRET(schSwitchTaskCandidateAddr(pJob, pTask));
+ }
+
SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_INIT);
int32_t childrenNum = taosArrayGetSize(pTask->children);
@@ -531,10 +546,7 @@ int32_t schHandleTaskRetry(SSchJob *pJob, SSchTask *pTask) {
if (SCH_IS_DATA_BIND_TASK(pTask)) {
SCH_SWITCH_EPSET(&pTask->plan->execNode);
} else {
- int32_t candidateNum = taosArrayGetSize(pTask->candidateAddrs);
- if (++pTask->candidateIdx >= candidateNum) {
- pTask->candidateIdx = 0;
- }
+ SCH_ERR_RET(schSwitchTaskCandidateAddr(pJob, pTask));
}
SCH_ERR_RET(schLaunchTask(pJob, pTask));
@@ -633,6 +645,16 @@ int32_t schUpdateTaskCandidateAddr(SSchJob *pJob, SSchTask *pTask, SEpSet* pEpSe
return TSDB_CODE_SUCCESS;
}
+int32_t schSwitchTaskCandidateAddr(SSchJob *pJob, SSchTask *pTask) {
+ int32_t candidateNum = taosArrayGetSize(pTask->candidateAddrs);
+ if (++pTask->candidateIdx >= candidateNum) {
+ pTask->candidateIdx = 0;
+ }
+ SCH_TASK_DLOG("switch task candiateIdx to %d", pTask->candidateIdx);
+ return TSDB_CODE_SUCCESS;
+}
+
+
int32_t schRemoveTaskFromExecList(SSchJob *pJob, SSchTask *pTask) {
int32_t code = taosHashRemove(pJob->execTasks, &pTask->taskId, sizeof(pTask->taskId));
diff --git a/source/libs/wal/src/walRead.c b/source/libs/wal/src/walRead.c
index 18b500aa19..2d910a85b8 100644
--- a/source/libs/wal/src/walRead.c
+++ b/source/libs/wal/src/walRead.c
@@ -30,8 +30,9 @@ SWalReader *walOpenReader(SWal *pWal, SWalFilterCond *cond) {
pRead->pWal = pWal;
pRead->pIdxFile = NULL;
pRead->pLogFile = NULL;
- pRead->curVersion = -1;
+ pRead->curVersion = -5;
pRead->curFileFirstVer = -1;
+ pRead->curInvalid = 1;
pRead->capacity = 0;
if (cond)
pRead->cond = *cond;
@@ -152,13 +153,17 @@ static int32_t walReadChangeFile(SWalReader *pRead, int64_t fileFirstVer) {
int32_t walReadSeekVer(SWalReader *pRead, int64_t ver) {
SWal *pWal = pRead->pWal;
- if (ver == pRead->curVersion) {
+ if (!pRead->curInvalid && ver == pRead->curVersion) {
wDebug("wal version %ld match, no need to reset", ver);
return 0;
}
+
+ pRead->curInvalid = 1;
+ pRead->curVersion = ver;
+
if (ver > pWal->vers.lastVer || ver < pWal->vers.firstVer) {
- wError("vgId:$d, invalid index:%" PRId64 ", first index:%" PRId64 ", last index:%" PRId64, pRead->pWal->cfg.vgId, ver,
- pWal->vers.firstVer, pWal->vers.lastVer);
+ wDebug("vgId:%d, invalid index:%" PRId64 ", first index:%" PRId64 ", last index:%" PRId64, pRead->pWal->cfg.vgId,
+ ver, pWal->vers.firstVer, pWal->vers.lastVer);
terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
return -1;
}
@@ -171,13 +176,13 @@ int32_t walReadSeekVer(SWalReader *pRead, int64_t ver) {
SWalFileInfo *pRet = taosArraySearch(pWal->fileInfoSet, &tmpInfo, compareWalFileInfo, TD_LE);
ASSERT(pRet != NULL);
if (pRead->curFileFirstVer != pRet->firstVer) {
- // error code set inner
+ // error code was set inner
if (walReadChangeFile(pRead, pRet->firstVer) < 0) {
return -1;
}
}
- // error code set inner
+ // error code was set inner
if (walReadSeekFilePos(pRead, pRet->firstVer, ver) < 0) {
return -1;
}
@@ -193,9 +198,11 @@ void walSetReaderCapacity(SWalReader *pRead, int32_t capacity) { pRead->capacity
static int32_t walFetchHeadNew(SWalReader *pRead, int64_t fetchVer) {
int64_t contLen;
- if (pRead->curVersion != fetchVer) {
+ if (pRead->curInvalid || pRead->curVersion != fetchVer) {
if (walReadSeekVer(pRead, fetchVer) < 0) {
ASSERT(0);
+ pRead->curVersion = fetchVer;
+ pRead->curInvalid = 1;
return -1;
}
}
@@ -207,7 +214,7 @@ static int32_t walFetchHeadNew(SWalReader *pRead, int64_t fetchVer) {
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
}
ASSERT(0);
- pRead->curVersion = -1;
+ pRead->curInvalid = 1;
return -1;
}
return 0;
@@ -238,7 +245,7 @@ static int32_t walFetchBodyNew(SWalReader *pRead) {
pRead->pWal->cfg.vgId, pRead->pHead->head.version, ver);
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
}
- pRead->curVersion = -1;
+ pRead->curInvalid = 1;
ASSERT(0);
return -1;
}
@@ -246,7 +253,7 @@ static int32_t walFetchBodyNew(SWalReader *pRead) {
if (pReadHead->version != ver) {
wError("vgId:%d, wal fetch body error:%" PRId64 ", read request index:%" PRId64, pRead->pWal->cfg.vgId,
pRead->pHead->head.version, ver);
- pRead->curVersion = -1;
+ pRead->curInvalid = 1;
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
ASSERT(0);
return -1;
@@ -254,7 +261,7 @@ static int32_t walFetchBodyNew(SWalReader *pRead) {
if (walValidBodyCksum(pRead->pHead) != 0) {
wError("vgId:%d, wal fetch body error:%" PRId64 ", since body checksum not passed", pRead->pWal->cfg.vgId, ver);
- pRead->curVersion = -1;
+ pRead->curInvalid = 1;
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
ASSERT(0);
return -1;
@@ -273,7 +280,7 @@ static int32_t walSkipFetchBodyNew(SWalReader *pRead) {
code = taosLSeekFile(pRead->pLogFile, pRead->pHead->head.bodyLen, SEEK_CUR);
if (code < 0) {
terrno = TAOS_SYSTEM_ERROR(errno);
- pRead->curVersion = -1;
+ pRead->curInvalid = 1;
ASSERT(0);
return -1;
}
@@ -292,7 +299,7 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver, SWalCkHead *pHead) {
return -1;
}
- if (pRead->curVersion != ver) {
+ if (pRead->curInvalid || pRead->curVersion != ver) {
code = walReadSeekVer(pRead, ver);
if (code < 0) return -1;
}
@@ -307,8 +314,7 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver, SWalCkHead *pHead) {
code = walValidHeadCksum(pHead);
if (code != 0) {
- wError("vgId:%d, unexpected wal log index:%" PRId64 ", since head checksum not passed", pRead->pWal->cfg.vgId,
- ver);
+ wError("vgId:%d, unexpected wal log index:%" PRId64 ", since head checksum not passed", pRead->pWal->cfg.vgId, ver);
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
return -1;
}
@@ -324,7 +330,7 @@ int32_t walSkipFetchBody(SWalReader *pRead, const SWalCkHead *pHead) {
code = taosLSeekFile(pRead->pLogFile, pHead->head.bodyLen, SEEK_CUR);
if (code < 0) {
terrno = TAOS_SYSTEM_ERROR(errno);
- pRead->curVersion = -1;
+ pRead->curInvalid = 1;
return -1;
}
@@ -356,14 +362,14 @@ int32_t walFetchBody(SWalReader *pRead, SWalCkHead **ppHead) {
if (pReadHead->version != ver) {
wError("vgId:%d, wal fetch body error:%" PRId64 ", read request index:%" PRId64, pRead->pWal->cfg.vgId,
pRead->pHead->head.version, ver);
- pRead->curVersion = -1;
+ pRead->curInvalid = 1;
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
return -1;
}
if (walValidBodyCksum(*ppHead) != 0) {
wError("vgId:%d, wal fetch body error:%" PRId64 ", since body checksum not passed", pRead->pWal->cfg.vgId, ver);
- pRead->curVersion = -1;
+ pRead->curInvalid = 1;
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
return -1;
}
@@ -380,8 +386,7 @@ int32_t walReadVer(SWalReader *pRead, int64_t ver) {
return -1;
}
- // TODO: check wal life
- if (pRead->curVersion != ver) {
+ if (pRead->curInvalid || pRead->curVersion != ver) {
if (walReadSeekVer(pRead, ver) < 0) {
wError("vgId:%d, unexpected wal log index:%" PRId64 ", since %s", pRead->pWal->cfg.vgId, ver, terrstr());
return -1;
@@ -389,8 +394,8 @@ int32_t walReadVer(SWalReader *pRead, int64_t ver) {
}
if (ver > pRead->pWal->vers.lastVer || ver < pRead->pWal->vers.firstVer) {
- wError("vgId:%d, invalid index:%" PRId64 ", first index:%" PRId64 ", last index:%" PRId64, pRead->pWal->cfg.vgId, ver,
- pRead->pWal->vers.firstVer, pRead->pWal->vers.lastVer);
+ wError("vgId:%d, invalid index:%" PRId64 ", first index:%" PRId64 ", last index:%" PRId64, pRead->pWal->cfg.vgId,
+ ver, pRead->pWal->vers.firstVer, pRead->pWal->vers.lastVer);
terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
return -1;
}
@@ -410,8 +415,7 @@ int32_t walReadVer(SWalReader *pRead, int64_t ver) {
code = walValidHeadCksum(pRead->pHead);
if (code != 0) {
- wError("vgId:%d, unexpected wal log index:%" PRId64 ", since head checksum not passed", pRead->pWal->cfg.vgId,
- ver);
+ wError("vgId:%d, unexpected wal log index:%" PRId64 ", since head checksum not passed", pRead->pWal->cfg.vgId, ver);
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
return -1;
}
@@ -440,16 +444,15 @@ int32_t walReadVer(SWalReader *pRead, int64_t ver) {
if (pRead->pHead->head.version != ver) {
wError("vgId:%d, unexpected wal log index:%" PRId64 ", read request index:%" PRId64, pRead->pWal->cfg.vgId,
pRead->pHead->head.version, ver);
- pRead->curVersion = -1;
+ pRead->curInvalid = 1;
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
return -1;
}
code = walValidBodyCksum(pRead->pHead);
if (code != 0) {
- wError("vgId:%d, unexpected wal log index:%" PRId64 ", since body checksum not passed", pRead->pWal->cfg.vgId,
- ver);
- pRead->curVersion = -1;
+ wError("vgId:%d, unexpected wal log index:%" PRId64 ", since body checksum not passed", pRead->pWal->cfg.vgId, ver);
+ pRead->curInvalid = 1;
terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
return -1;
}
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index 0301b842c4..ef6697b3b5 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -251,6 +251,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_ALREADY_EXIST, "Column already exists
TAOS_DEFINE_ERROR(TSDB_CODE_MND_COLUMN_NOT_EXIST, "Column does not exist")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_CONFLICT_WITH_TOPIC,"Field used by topic")
TAOS_DEFINE_ERROR(TSDB_CODE_MND_SINGLE_STB_MODE_DB, "Database is single stable mode")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_SCHEMA_VER, "Invalid schema version while alter stb")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_STABLE_UID_NOT_MATCH, "Invalid stable uid while alter stb")
// mnode-infoSchema
TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_SYS_TABLENAME, "Invalid system table name")
diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh
index 409fb5e930..9ed34daf69 100755
--- a/tests/system-test/fulltest.sh
+++ b/tests/system-test/fulltest.sh
@@ -120,7 +120,7 @@ python3 ./test.py -f 2-query/irate.py
python3 ./test.py -f 2-query/and_or_for_byte.py
python3 ./test.py -f 2-query/function_null.py
-python3 ./test.py -f 2-query/queryQnode.py
+#python3 ./test.py -f 2-query/queryQnode.py
#python3 ./test.py -f 6-cluster/5dnode1mnode.py
#python3 ./test.py -f 6-cluster/5dnode2mnode.py -N 5 -M 3
diff --git a/tests/test/c/sdbDump.c b/tests/test/c/sdbDump.c
index a62c30660d..42f1bb4062 100644
--- a/tests/test/c/sdbDump.c
+++ b/tests/test/c/sdbDump.c
@@ -24,6 +24,7 @@
#define TMP_MNODE_DIR TD_TMP_DIR_PATH "dumpsdb" TD_DIRSEP "mnode"
#define TMP_SDB_DATA_DIR TD_TMP_DIR_PATH "dumpsdb" TD_DIRSEP "mnode" TD_DIRSEP "data"
#define TMP_SDB_SYNC_DIR TD_TMP_DIR_PATH "dumpsdb" TD_DIRSEP "mnode" TD_DIRSEP "sync"
+#define TMP_SDB_MNODE_JSON TD_TMP_DIR_PATH "dumpsdb" TD_DIRSEP "mnode" TD_DIRSEP "mnode.json"
#define TMP_SDB_DATA_FILE TD_TMP_DIR_PATH "dumpsdb" TD_DIRSEP "mnode" TD_DIRSEP "data" TD_DIRSEP "sdb.data"
#define TMP_SDB_RAFT_CFG_FILE TD_TMP_DIR_PATH "dumpsdb" TD_DIRSEP "mnode" TD_DIRSEP "sync" TD_DIRSEP "raft_config.json"
#define TMP_SDB_RAFT_STORE_FILE TD_TMP_DIR_PATH "dumpsdb" TD_DIRSEP "mnode" TD_DIRSEP "sync" TD_DIRSEP "raft_store.json"
@@ -412,9 +413,11 @@ int32_t parseArgs(int32_t argc, char *argv[]) {
return -1;
}
+ char mnodeJson[PATH_MAX] = {0};
char dataFile[PATH_MAX] = {0};
char raftCfgFile[PATH_MAX] = {0};
char raftStoreFile[PATH_MAX] = {0};
+ snprintf(mnodeJson, PATH_MAX, "%s" TD_DIRSEP "mnode" TD_DIRSEP "mnode.json", tsDataDir);
snprintf(dataFile, PATH_MAX, "%s" TD_DIRSEP "mnode" TD_DIRSEP "data" TD_DIRSEP "sdb.data", tsDataDir);
snprintf(raftCfgFile, PATH_MAX, "%s" TD_DIRSEP "mnode" TD_DIRSEP "sync" TD_DIRSEP "raft_config.json", tsDataDir);
snprintf(raftStoreFile, PATH_MAX, "%s" TD_DIRSEP "mnode" TD_DIRSEP "sync" TD_DIRSEP "raft_store.json", tsDataDir);
@@ -425,6 +428,8 @@ int32_t parseArgs(int32_t argc, char *argv[]) {
#ifdef WINDOWS
taosMulMkDir(TMP_SDB_DATA_DIR);
taosMulMkDir(TMP_SDB_SYNC_DIR);
+ snprintf(cmd, sizeof(cmd), "cp %s %s 2>nul", mnodeJson, TMP_SDB_MNODE_JSON);
+ system(cmd);
snprintf(cmd, sizeof(cmd), "cp %s %s 2>nul", dataFile, TMP_SDB_DATA_FILE);
system(cmd);
snprintf(cmd, sizeof(cmd), "cp %s %s 2>nul", raftCfgFile, TMP_SDB_RAFT_CFG_FILE);
@@ -436,6 +441,8 @@ int32_t parseArgs(int32_t argc, char *argv[]) {
system(cmd);
snprintf(cmd, sizeof(cmd), "mkdir -p %s", TMP_SDB_SYNC_DIR);
system(cmd);
+ snprintf(cmd, sizeof(cmd), "cp %s %s 2>/dev/null", mnodeJson, TMP_SDB_MNODE_JSON);
+ system(cmd);
snprintf(cmd, sizeof(cmd), "cp %s %s 2>/dev/null", dataFile, TMP_SDB_DATA_FILE);
system(cmd);
snprintf(cmd, sizeof(cmd), "cp %s %s 2>/dev/null", raftCfgFile, TMP_SDB_RAFT_CFG_FILE);