diff --git a/examples/c/tmq.c b/examples/c/tmq.c
index 74efb4c026..5d7f1bbe70 100644
--- a/examples/c/tmq.c
+++ b/examples/c/tmq.c
@@ -28,15 +28,23 @@ static void msg_process(TAOS_RES* msg) {
printf("db: %s\n", tmq_get_db_name(msg));
printf("vg: %d\n", tmq_get_vgroup_id(msg));
if (tmq_get_res_type(msg) == TMQ_RES_TABLE_META) {
- void* meta;
- int32_t metaLen;
- tmq_get_raw_meta(msg, &meta, &metaLen);
+ tmq_raw_data *raw = tmq_get_raw_meta(msg);
+ if(raw){
+ TAOS* pConn = taos_connect("192.168.1.86", "root", "taosdata", "abc1", 0);
+ if (pConn == NULL) {
+ return;
+ }
+ int32_t ret = taos_write_raw_meta(pConn, raw);
+ printf("write raw data: %s\n", tmq_err2str(ret));
+ free(raw);
+ taos_close(pConn);
+ }
char* result = tmq_get_json_meta(msg);
if(result){
printf("meta result: %s\n", result);
free(result);
}
- printf("meta, len is %d\n", metaLen);
+ printf("meta:%p\n", raw);
return;
}
while (1) {
diff --git a/include/client/taos.h b/include/client/taos.h
index 216a5832b0..362782b420 100644
--- a/include/client/taos.h
+++ b/include/client/taos.h
@@ -260,15 +260,16 @@ enum tmq_res_t {
};
typedef enum tmq_res_t tmq_res_t;
+typedef struct tmq_raw_data tmq_raw_data;
-DLL_EXPORT tmq_res_t tmq_get_res_type(TAOS_RES *res);
-DLL_EXPORT int32_t tmq_get_raw_meta(TAOS_RES *res, void **raw_meta, int32_t *raw_meta_len);
-DLL_EXPORT int32_t taos_write_raw_meta(TAOS *res, void *raw_meta, int32_t raw_meta_len);
-DLL_EXPORT char *tmq_get_json_meta(TAOS_RES *res); // Returning null means error. Returned result need to be freed.
-DLL_EXPORT const char *tmq_get_topic_name(TAOS_RES *res);
-DLL_EXPORT const char *tmq_get_db_name(TAOS_RES *res);
-DLL_EXPORT int32_t tmq_get_vgroup_id(TAOS_RES *res);
-DLL_EXPORT const char *tmq_get_table_name(TAOS_RES *res);
+DLL_EXPORT tmq_res_t tmq_get_res_type(TAOS_RES *res);
+DLL_EXPORT tmq_raw_data *tmq_get_raw_meta(TAOS_RES *res);
+DLL_EXPORT int32_t taos_write_raw_meta(TAOS *taos, tmq_raw_data *raw_meta);
+DLL_EXPORT char *tmq_get_json_meta(TAOS_RES *res); // Returning null means error. Returned result need to be freed.
+DLL_EXPORT const char *tmq_get_topic_name(TAOS_RES *res);
+DLL_EXPORT const char *tmq_get_db_name(TAOS_RES *res);
+DLL_EXPORT int32_t tmq_get_vgroup_id(TAOS_RES *res);
+DLL_EXPORT const char *tmq_get_table_name(TAOS_RES *res);
/* ------------------------------ TMQ END -------------------------------- */
diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 20f9503150..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,25 +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
- SArray* pTags; // array of SField
- SArray* pFuncs;
- char* pComment;
- char* pAst1;
- char* pAst2;
+ 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);
@@ -458,8 +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;
+ 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);
@@ -468,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/common/tname.h b/include/common/tname.h
index 3bf1cee870..77965947ad 100644
--- a/include/common/tname.h
+++ b/include/common/tname.h
@@ -37,6 +37,8 @@ typedef struct SName {
char tname[TSDB_TABLE_NAME_LEN];
} SName;
+SName* toName(int32_t acctId, const char* pDbName, const char* pTableName, SName* pName);
+
int32_t tNameExtractFullName(const SName* name, char* dst);
int32_t tNameLen(const SName* name);
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/parser/parser.h b/include/libs/parser/parser.h
index c3007306ae..a4aec72d4f 100644
--- a/include/libs/parser/parser.h
+++ b/include/libs/parser/parser.h
@@ -96,6 +96,9 @@ int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols
char* tableName, char* msgBuf, int16_t msgBufLen);
int32_t smlBuildOutput(void* handle, SHashObj* pVgHash);
+int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray);
+SArray* serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap);
+SArray* serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap);
#ifdef __cplusplus
}
#endif
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 41d5910625..fcc00d0d80 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/include/util/tlog.h b/include/util/tlog.h
index a519aaa9b7..a8c9eeabde 100644
--- a/include/util/tlog.h
+++ b/include/util/tlog.h
@@ -94,7 +94,7 @@ void taosPrintLongString(const char *flags, ELogLevel level, int32_t dflag, cons
#define pError(...) { taosPrintLog("APP ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }
#define pPrint(...) { taosPrintLog("APP ", DEBUG_INFO, 255, __VA_ARGS__); }
// clang-format on
-
+#define BUF_PAGE_DEBUG
#ifdef __cplusplus
}
#endif
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/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/clientSml.c b/source/client/src/clientSml.c
index 5039f8bbaf..b6972e4670 100644
--- a/source/client/src/clientSml.c
+++ b/source/client/src/clientSml.c
@@ -1570,41 +1570,40 @@ static int32_t smlParseTSFromJSONObj(SSmlHandle *info, cJSON *root, int64_t *tsV
return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
+ *tsVal = timeDouble;
size_t typeLen = strlen(type->valuestring);
if (typeLen == 1 && (type->valuestring[0] == 's' || type->valuestring[0] == 'S')) {
// seconds
- timeDouble = timeDouble * 1e9;
+ *tsVal = *tsVal * NANOSECOND_PER_SEC;
+ timeDouble = timeDouble * NANOSECOND_PER_SEC;
if (smlDoubleToInt64OverFlow(timeDouble)) {
smlBuildInvalidDataMsg(&info->msgBuf, "timestamp is too large", NULL);
return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
- *tsVal = timeDouble;
} else if (typeLen == 2 && (type->valuestring[1] == 's' || type->valuestring[1] == 'S')) {
switch (type->valuestring[0]) {
case 'm':
case 'M':
// milliseconds
- timeDouble = timeDouble * 1e6;
+ *tsVal = *tsVal * NANOSECOND_PER_MSEC;
+ timeDouble = timeDouble * NANOSECOND_PER_MSEC;
if (smlDoubleToInt64OverFlow(timeDouble)) {
smlBuildInvalidDataMsg(&info->msgBuf, "timestamp is too large", NULL);
return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
- *tsVal = timeDouble;
break;
case 'u':
case 'U':
// microseconds
- timeDouble = timeDouble * 1e3;
+ *tsVal = *tsVal * NANOSECOND_PER_USEC;
+ timeDouble = timeDouble * NANOSECOND_PER_USEC;
if (smlDoubleToInt64OverFlow(timeDouble)) {
smlBuildInvalidDataMsg(&info->msgBuf, "timestamp is too large", NULL);
return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
- *tsVal = timeDouble;
break;
case 'n':
case 'N':
- // nanoseconds
- *tsVal = timeDouble;
break;
default:
return TSDB_CODE_TSC_INVALID_JSON;
@@ -1641,21 +1640,23 @@ static int32_t smlParseTSFromJSON(SSmlHandle *info, cJSON *root, SArray *cols) {
if (timeDouble < 0) {
return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
+
uint8_t tsLen = smlGetTimestampLen((int64_t)timeDouble);
+ tsVal = (int64_t)timeDouble;
if (tsLen == TSDB_TIME_PRECISION_SEC_DIGITS) {
- timeDouble = timeDouble * 1e9;
+ tsVal = tsVal * NANOSECOND_PER_SEC;
+ timeDouble = timeDouble * NANOSECOND_PER_SEC;
if (smlDoubleToInt64OverFlow(timeDouble)) {
smlBuildInvalidDataMsg(&info->msgBuf, "timestamp is too large", NULL);
return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
- tsVal = timeDouble;
} else if (tsLen == TSDB_TIME_PRECISION_MILLI_DIGITS) {
- timeDouble = timeDouble * 1e6;
+ tsVal = tsVal * NANOSECOND_PER_MSEC;
+ timeDouble = timeDouble * NANOSECOND_PER_MSEC;
if (smlDoubleToInt64OverFlow(timeDouble)) {
smlBuildInvalidDataMsg(&info->msgBuf, "timestamp is too large", NULL);
return TSDB_CODE_TSC_INVALID_TIME_STAMP;
}
- tsVal = timeDouble;
} else if (timeDouble == 0) {
tsVal = taosGetTimestampNs();
} else {
diff --git a/source/client/src/tmq.c b/source/client/src/tmq.c
index a442f82bec..cea6905c69 100644
--- a/source/client/src/tmq.c
+++ b/source/client/src/tmq.c
@@ -106,6 +106,12 @@ struct tmq_t {
tsem_t rspSem;
};
+struct tmq_raw_data{
+ void *raw_meta;
+ int32_t raw_meta_len;
+ int16_t raw_meta_type;
+};
+
enum {
TMQ_VG_STATUS__IDLE = 0,
TMQ_VG_STATUS__WAIT,
@@ -1842,14 +1848,16 @@ const char* tmq_get_table_name(TAOS_RES* res) {
return NULL;
}
-int32_t tmq_get_raw_meta(TAOS_RES* res, void** raw_meta, int32_t* raw_meta_len) {
+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));
SMqMetaRspObj* pMetaRspObj = (SMqMetaRspObj*)res;
- *raw_meta = pMetaRspObj->metaRsp.metaRsp;
- *raw_meta_len = pMetaRspObj->metaRsp.metaRspLen;
- return 0;
+ raw->raw_meta = pMetaRspObj->metaRsp.metaRsp;
+ raw->raw_meta_len = pMetaRspObj->metaRsp.metaRspLen;
+ raw->raw_meta_type = pMetaRspObj->metaRsp.resMsgType;
+ return raw;
}
- return -1;
+ return NULL;
}
static char *buildCreateTableJson(SSchemaWrapper *schemaRow, SSchemaWrapper* schemaTag, char* name, int64_t id, int8_t t){
@@ -2252,6 +2260,515 @@ char *tmq_get_json_meta(TAOS_RES *res){
return NULL;
}
+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;
+
+ STscObj *pTscObj = acquireTscObj(*(int64_t *)taos);
+ if (NULL == pTscObj) {
+ code = TSDB_CODE_TSC_DISCONNECTED;
+ goto end;
+ }
+
+ code = buildRequest(pTscObj, "", 0, &pRequest);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ if(!pRequest->pDb){
+ code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
+ goto end;
+ }
+ // decode and process req
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ int32_t len = metaLen - sizeof(SMsgHead);
+ tDecoderInit(&coder, data, len);
+ if (tDecodeSVCreateStbReq(&coder, &req) < 0) {
+ code = TSDB_CODE_INVALID_PARA;
+ goto end;
+ }
+ // build create stable
+ pReq.pColumns = taosArrayInit(req.schemaRow.nCols, sizeof(SField));
+ for(int32_t i = 0; i < req.schemaRow.nCols; i++){
+ SSchema* pSchema = req.schemaRow.pSchema + i;
+ 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++){
+ SSchema* pSchema = req.schemaTag.pSchema + i;
+ SField field = {.type = pSchema->type, .bytes = pSchema->bytes};
+ strcpy(field.name, pSchema->name);
+ taosArrayPush(pReq.pTags, &field);
+ }
+ pReq.colVer = req.schemaRow.version;
+ pReq.tagVer = req.schemaTag.version;
+ pReq.numOfColumns = req.schemaRow.nCols;
+ pReq.numOfTags = req.schemaTag.nCols;
+ pReq.commentLen = -1;
+ pReq.suid = req.suid;
+ pReq.source = 1;
+
+ SName tableName;
+ tNameExtractFullName(toName(pTscObj->acctId, pRequest->pDb, req.name, &tableName), pReq.name);
+
+ SCmdMsgInfo pCmdMsg = {0};
+ pCmdMsg.epSet = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
+ pCmdMsg.msgType = TDMT_MND_CREATE_STB;
+ pCmdMsg.msgLen = tSerializeSMCreateStbReq(NULL, 0, &pReq);
+ pCmdMsg.pMsg = taosMemoryMalloc(pCmdMsg.msgLen);
+ if (NULL == pCmdMsg.pMsg) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto end;
+ }
+ tSerializeSMCreateStbReq(pCmdMsg.pMsg, pCmdMsg.msgLen, &pReq);
+
+ SQuery pQuery = {0};
+ pQuery.execMode = QUERY_EXEC_MODE_RPC;
+ pQuery.pCmdMsg = &pCmdMsg;
+ pQuery.msgType = pQuery.pCmdMsg->msgType;
+ pQuery.stableQuery = true;
+
+ launchQueryImpl(pRequest, &pQuery, true, NULL);
+ code = pRequest->code;
+ taosMemoryFree(pCmdMsg.pMsg);
+
+ end:
+ destroyRequest(pRequest);
+ tFreeSMCreateStbReq(&pReq);
+ tDecoderClear(&coder);
+ return code;
+}
+
+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;
+ SRequestObj* pRequest = NULL;
+
+ STscObj *pTscObj = acquireTscObj(*(int64_t *)taos);
+ if (NULL == pTscObj) {
+ code = TSDB_CODE_TSC_DISCONNECTED;
+ goto end;
+ }
+
+ code = buildRequest(pTscObj, "", 0, &pRequest);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ if(!pRequest->pDb){
+ code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
+ goto end;
+ }
+ // decode and process req
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ int32_t len = metaLen - sizeof(SMsgHead);
+ tDecoderInit(&coder, data, len);
+ if (tDecodeSVDropStbReq(&coder, &req) < 0) {
+ code = TSDB_CODE_INVALID_PARA;
+ goto end;
+ }
+
+ // build drop stable
+ pReq.igNotExists = true;
+ pReq.source = 1;
+ pReq.suid = req.suid;
+ SName tableName;
+ tNameExtractFullName(toName(pTscObj->acctId, pRequest->pDb, req.name, &tableName), pReq.name);
+
+ SCmdMsgInfo pCmdMsg = {0};
+ pCmdMsg.epSet = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
+ pCmdMsg.msgType = TDMT_MND_DROP_STB;
+ pCmdMsg.msgLen = tSerializeSMDropStbReq(NULL, 0, &pReq);
+ pCmdMsg.pMsg = taosMemoryMalloc(pCmdMsg.msgLen);
+ if (NULL == pCmdMsg.pMsg) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto end;
+ }
+ tSerializeSMDropStbReq(pCmdMsg.pMsg, pCmdMsg.msgLen, &pReq);
+
+ SQuery pQuery = {0};
+ pQuery.execMode = QUERY_EXEC_MODE_RPC;
+ pQuery.pCmdMsg = &pCmdMsg;
+ pQuery.msgType = pQuery.pCmdMsg->msgType;
+ pQuery.stableQuery = true;
+
+ launchQueryImpl(pRequest, &pQuery, true, NULL);
+ code = pRequest->code;
+ taosMemoryFree(pCmdMsg.pMsg);
+
+ end:
+ destroyRequest(pRequest);
+ tDecoderClear(&coder);
+ return code;
+}
+
+typedef struct SVgroupCreateTableBatch {
+ SVCreateTbBatchReq req;
+ SVgroupInfo info;
+ char dbName[TSDB_DB_NAME_LEN];
+} SVgroupCreateTableBatch;
+
+static void destroyCreateTbReqBatch(void* 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);
+
+ if (NULL == pTscObj) {
+ code = TSDB_CODE_TSC_DISCONNECTED;
+ goto end;
+ }
+
+ code = buildRequest(pTscObj, "", 0, &pRequest);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ if(!pRequest->pDb){
+ code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
+ goto end;
+ }
+ // decode and process req
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ int32_t len = metaLen - sizeof(SMsgHead);
+ tDecoderInit(&coder, data, len);
+ if (tDecodeSVCreateTbBatchReq(&coder, &req) < 0) {
+ code = TSDB_CODE_INVALID_PARA;
+ goto end;
+ }
+
+ SVCreateTbReq *pCreateReq = NULL;
+ SCatalog* pCatalog = NULL;
+ code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &pCatalog);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ pVgroupHashmap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
+ if (NULL == pVgroupHashmap) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto end;
+ }
+ taosHashSetFreeFp(pVgroupHashmap, destroyCreateTbReqBatch);
+
+ SRequestConnInfo conn = {.pTrans = pTscObj->pAppInfo->pTransporter,
+ .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;
+ toName(pTscObj->acctId, pRequest->pDb, pCreateReq->name, &pName);
+ code = catalogGetTableHashVgroup(pCatalog, &conn, &pName, &pInfo);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ SVgroupCreateTableBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pInfo.vgId, sizeof(pInfo.vgId));
+ if (pTableBatch == NULL) {
+ SVgroupCreateTableBatch tBatch = {0};
+ tBatch.info = pInfo;
+ strcpy(tBatch.dbName, pRequest->pDb);
+
+ tBatch.req.pArray = taosArrayInit(4, sizeof(struct SVCreateTbReq));
+ taosArrayPush(tBatch.req.pArray, pCreateReq);
+
+ taosHashPut(pVgroupHashmap, &pInfo.vgId, sizeof(pInfo.vgId), &tBatch, sizeof(tBatch));
+ } else { // add to the correct vgroup
+ taosArrayPush(pTableBatch->req.pArray, pCreateReq);
+ }
+ }
+
+ SArray* pBufArray = serializeVgroupsCreateTableBatch(pVgroupHashmap);
+ if (NULL == pBufArray) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto end;
+ }
+
+ pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
+ pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
+ pQuery->msgType = TDMT_VND_CREATE_TABLE;
+ pQuery->stableQuery = false;
+ pQuery->pRoot = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT);
+
+ code = rewriteToVnodeModifyOpStmt(pQuery, pBufArray);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ launchQueryImpl(pRequest, pQuery, false, NULL);
+ pQuery = NULL; // no need to free in the end
+ code = pRequest->code;
+
+ end:
+ taosHashCleanup(pVgroupHashmap);
+ destroyRequest(pRequest);
+ tDecoderClear(&coder);
+ qDestroyQuery(pQuery);
+ return code;
+}
+
+typedef struct SVgroupDropTableBatch {
+ SVDropTbBatchReq req;
+ SVgroupInfo info;
+ char dbName[TSDB_DB_NAME_LEN];
+} SVgroupDropTableBatch;
+
+static void destroyDropTbReqBatch(void* data) {
+ SVgroupDropTableBatch* pTbBatch = (SVgroupDropTableBatch*)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);
+
+ if (NULL == pTscObj) {
+ code = TSDB_CODE_TSC_DISCONNECTED;
+ goto end;
+ }
+
+ code = buildRequest(pTscObj, "", 0, &pRequest);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ if(!pRequest->pDb){
+ code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
+ goto end;
+ }
+ // decode and process req
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ int32_t len = metaLen - sizeof(SMsgHead);
+ tDecoderInit(&coder, data, len);
+ if (tDecodeSVDropTbBatchReq(&coder, &req) < 0) {
+ code = TSDB_CODE_INVALID_PARA;
+ goto end;
+ }
+
+ SVDropTbReq *pDropReq = NULL;
+ SCatalog *pCatalog = NULL;
+ code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &pCatalog);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ pVgroupHashmap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
+ if (NULL == pVgroupHashmap) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto end;
+ }
+ taosHashSetFreeFp(pVgroupHashmap, destroyDropTbReqBatch);
+
+ SRequestConnInfo conn = {.pTrans = pTscObj->pAppInfo->pTransporter,
+ .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;
+ toName(pTscObj->acctId, pRequest->pDb, pDropReq->name, &pName);
+ code = catalogGetTableHashVgroup(pCatalog, &conn, &pName, &pInfo);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ SVgroupDropTableBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pInfo.vgId, sizeof(pInfo.vgId));
+ if (pTableBatch == NULL) {
+ SVgroupDropTableBatch tBatch = {0};
+ tBatch.info = pInfo;
+ tBatch.req.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbReq));
+ taosArrayPush(tBatch.req.pArray, pDropReq);
+
+ taosHashPut(pVgroupHashmap, &pInfo.vgId, sizeof(pInfo.vgId), &tBatch, sizeof(tBatch));
+ } else { // add to the correct vgroup
+ taosArrayPush(pTableBatch->req.pArray, pDropReq);
+ }
+ }
+
+ SArray* pBufArray = serializeVgroupsDropTableBatch(pVgroupHashmap);
+ if (NULL == pBufArray) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto end;
+ }
+
+ pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
+ pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
+ pQuery->msgType = TDMT_VND_DROP_TABLE;
+ pQuery->stableQuery = false;
+ pQuery->pRoot = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT);
+
+ code = rewriteToVnodeModifyOpStmt(pQuery, pBufArray);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ launchQueryImpl(pRequest, pQuery, false, NULL);
+ pQuery = NULL; // no need to free in the end
+ code = pRequest->code;
+
+ end:
+ taosHashCleanup(pVgroupHashmap);
+ destroyRequest(pRequest);
+ tDecoderClear(&coder);
+ qDestroyQuery(pQuery);
+ 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);
+
+ if (NULL == pTscObj) {
+ code = TSDB_CODE_TSC_DISCONNECTED;
+ goto end;
+ }
+
+ code = buildRequest(pTscObj, "", 0, &pRequest);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ if(!pRequest->pDb){
+ code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
+ goto end;
+ }
+ // decode and process req
+ void* data = POINTER_SHIFT(meta, sizeof(SMsgHead));
+ int32_t len = metaLen - sizeof(SMsgHead);
+ tDecoderInit(&coder, data, len);
+ if (tDecodeSVAlterTbReq(&coder, &req) < 0) {
+ code = TSDB_CODE_INVALID_PARA;
+ goto end;
+ }
+
+ // do not deal TSDB_ALTER_TABLE_UPDATE_OPTIONS
+ if(req.action == TSDB_ALTER_TABLE_UPDATE_OPTIONS){
+ goto end;
+ }
+
+ 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)};
+
+ SVgroupInfo pInfo = {0};
+ SName pName = {0};
+ toName(pTscObj->acctId, pRequest->pDb, req.tbName, &pName);
+ code = catalogGetTableHashVgroup(pCatalog, &conn, &pName, &pInfo);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ pArray = taosArrayInit(1, sizeof(void*));
+ if (NULL == pArray) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto end;
+ }
+
+ pVgData = taosMemoryCalloc(1, sizeof(SVgDataBlocks));
+ if (NULL == pVgData) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto end;
+ }
+ pVgData->vg = pInfo;
+ pVgData->pData = taosMemoryMalloc(metaLen);
+ if (NULL == pVgData->pData) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto end;
+ }
+ memcpy(pVgData->pData, meta, metaLen);
+ ((SMsgHead*)pVgData->pData)->vgId = htonl(pInfo.vgId);
+ pVgData->size = metaLen;
+ pVgData->numOfTables = 1;
+ taosArrayPush(pArray, &pVgData);
+
+ pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
+ pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
+ pQuery->msgType = TDMT_VND_ALTER_TABLE;
+ pQuery->stableQuery = false;
+ pQuery->pRoot = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
+
+ code = rewriteToVnodeModifyOpStmt(pQuery, pArray);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto end;
+ }
+
+ launchQueryImpl(pRequest, pQuery, false, NULL);
+ pQuery = NULL; // no need to free in the end
+ pVgData = NULL;
+ pArray = NULL;
+ code = pRequest->code;
+
+end:
+ taosArrayDestroy(pArray);
+ if(pVgData) taosMemoryFreeClear(pVgData->pData);
+ taosMemoryFreeClear(pVgData);
+ destroyRequest(pRequest);
+ tDecoderClear(&coder);
+ qDestroyQuery(pQuery);
+ return code;
+}
+
+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) {
+ return taosCreateStb(taos, raw_meta->raw_meta, raw_meta->raw_meta_len);
+ }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){
+ return taosDropStb(taos, raw_meta->raw_meta, raw_meta->raw_meta_len);
+ }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){
+ return taosAlterTable(taos, raw_meta->raw_meta, raw_meta->raw_meta_len);
+ }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;
+}
+
void tmq_commit_async(tmq_t* tmq, const TAOS_RES* msg, tmq_commit_cb* cb, void* param) {
tmqCommitInner2(tmq, msg, 0, 1, cb, param);
}
diff --git a/source/client/test/smlTest.cpp b/source/client/test/smlTest.cpp
index 832564e0db..a6062efb98 100644
--- a/source/client/test/smlTest.cpp
+++ b/source/client/test/smlTest.cpp
@@ -1284,4 +1284,210 @@ TEST(testCase, sml_dup_time_Test) {
ASSERT_EQ(taos_errno(pRes), 0);
taos_free_result(pRes);
}
-*/
+
+
+TEST(testCase, sml_16960_Test) {
+TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+ASSERT_NE(taos, nullptr);
+
+TAOS_RES* pRes = taos_query(taos, "create database if not exists d16368 schemaless 1");
+taos_free_result(pRes);
+
+pRes = taos_query(taos, "use d16368");
+taos_free_result(pRes);
+
+const char *sql[] = {
+ "[\n"
+ "{\n"
+ "\"timestamp\":\n"
+ "\n"
+ "{ \"value\": 1349020800000, \"type\": \"ms\" }\n"
+ ",\n"
+ "\"value\":\n"
+ "\n"
+ "{ \"value\": 830525384, \"type\": \"int\" }\n"
+ ",\n"
+ "\"tags\": {\n"
+ "\"id\": \"stb00_0\",\n"
+ "\"t0\":\n"
+ "\n"
+ "{ \"value\": 83972721, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t1\":\n"
+ "\n"
+ "{ \"value\": 539147525, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t2\":\n"
+ "\n"
+ "{ \"value\": 618258572, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t3\":\n"
+ "\n"
+ "{ \"value\": -10536201, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t4\":\n"
+ "\n"
+ "{ \"value\": 349227409, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t5\":\n"
+ "\n"
+ "{ \"value\": 249347042, \"type\": \"int\" }\n"
+ "},\n"
+ "\"metric\": \"stb0\"\n"
+ "},\n"
+ "{\n"
+ "\"timestamp\":\n"
+ "\n"
+ "{ \"value\": 1349020800001, \"type\": \"ms\" }\n"
+ ",\n"
+ "\"value\":\n"
+ "\n"
+ "{ \"value\": -588348364, \"type\": \"int\" }\n"
+ ",\n"
+ "\"tags\": {\n"
+ "\"id\": \"stb00_0\",\n"
+ "\"t0\":\n"
+ "\n"
+ "{ \"value\": 83972721, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t1\":\n"
+ "\n"
+ "{ \"value\": 539147525, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t2\":\n"
+ "\n"
+ "{ \"value\": 618258572, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t3\":\n"
+ "\n"
+ "{ \"value\": -10536201, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t4\":\n"
+ "\n"
+ "{ \"value\": 349227409, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t5\":\n"
+ "\n"
+ "{ \"value\": 249347042, \"type\": \"int\" }\n"
+ "},\n"
+ "\"metric\": \"stb0\"\n"
+ "},\n"
+ "{\n"
+ "\"timestamp\":\n"
+ "\n"
+ "{ \"value\": 1349020800002, \"type\": \"ms\" }\n"
+ ",\n"
+ "\"value\":\n"
+ "\n"
+ "{ \"value\": -370310823, \"type\": \"int\" }\n"
+ ",\n"
+ "\"tags\": {\n"
+ "\"id\": \"stb00_0\",\n"
+ "\"t0\":\n"
+ "\n"
+ "{ \"value\": 83972721, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t1\":\n"
+ "\n"
+ "{ \"value\": 539147525, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t2\":\n"
+ "\n"
+ "{ \"value\": 618258572, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t3\":\n"
+ "\n"
+ "{ \"value\": -10536201, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t4\":\n"
+ "\n"
+ "{ \"value\": 349227409, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t5\":\n"
+ "\n"
+ "{ \"value\": 249347042, \"type\": \"int\" }\n"
+ "},\n"
+ "\"metric\": \"stb0\"\n"
+ "},\n"
+ "{\n"
+ "\"timestamp\":\n"
+ "\n"
+ "{ \"value\": 1349020800003, \"type\": \"ms\" }\n"
+ ",\n"
+ "\"value\":\n"
+ "\n"
+ "{ \"value\": -811250191, \"type\": \"int\" }\n"
+ ",\n"
+ "\"tags\": {\n"
+ "\"id\": \"stb00_0\",\n"
+ "\"t0\":\n"
+ "\n"
+ "{ \"value\": 83972721, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t1\":\n"
+ "\n"
+ "{ \"value\": 539147525, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t2\":\n"
+ "\n"
+ "{ \"value\": 618258572, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t3\":\n"
+ "\n"
+ "{ \"value\": -10536201, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t4\":\n"
+ "\n"
+ "{ \"value\": 349227409, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t5\":\n"
+ "\n"
+ "{ \"value\": 249347042, \"type\": \"int\" }\n"
+ "},\n"
+ "\"metric\": \"stb0\"\n"
+ "},\n"
+ "{\n"
+ "\"timestamp\":\n"
+ "\n"
+ "{ \"value\": 1349020800004, \"type\": \"ms\" }\n"
+ ",\n"
+ "\"value\":\n"
+ "\n"
+ "{ \"value\": -330340558, \"type\": \"int\" }\n"
+ ",\n"
+ "\"tags\": {\n"
+ "\"id\": \"stb00_0\",\n"
+ "\"t0\":\n"
+ "\n"
+ "{ \"value\": 83972721, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t1\":\n"
+ "\n"
+ "{ \"value\": 539147525, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t2\":\n"
+ "\n"
+ "{ \"value\": 618258572, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t3\":\n"
+ "\n"
+ "{ \"value\": -10536201, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t4\":\n"
+ "\n"
+ "{ \"value\": 349227409, \"type\": \"int\" }\n"
+ ",\n"
+ "\"t5\":\n"
+ "\n"
+ "{ \"value\": 249347042, \"type\": \"int\" }\n"
+ "},\n"
+ "\"metric\": \"stb0\"\n"
+ "}\n"
+ "]"
+};
+
+pRes = taos_schemaless_insert(taos, (char**)sql, sizeof(sql)/sizeof(sql[0]), TSDB_SML_JSON_PROTOCOL, TSDB_SML_TIMESTAMP_MILLI_SECONDS);
+ASSERT_EQ(taos_errno(pRes), 0);
+taos_free_result(pRes);
+}
+*/
\ No newline at end of file
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index 68f7f69aca..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;
@@ -553,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;
@@ -645,6 +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 (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;
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
@@ -659,6 +680,12 @@ 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 (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;
+
tEndDecode(&decoder);
tDecoderClear(&decoder);
@@ -672,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);
@@ -700,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/common/src/tname.c b/source/common/src/tname.c
index fb3a2d7464..7183153824 100644
--- a/source/common/src/tname.c
+++ b/source/common/src/tname.c
@@ -115,6 +115,14 @@ int64_t taosGetIntervalStartTimestamp(int64_t startTime, int64_t slidingTime, in
#endif
+SName* toName(int32_t acctId, const char* pDbName, const char* pTableName, SName* pName) {
+ pName->type = TSDB_TABLE_NAME_T;
+ pName->acctId = acctId;
+ strcpy(pName->dbname, pDbName);
+ strcpy(pName->tname, pTableName);
+ return pName;
+}
+
int32_t tNameExtractFullName(const SName* name, char* dst) {
assert(name != NULL && dst != NULL);
diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index e084710e25..224c1dbb5d 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -705,10 +705,10 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
memcpy(pDst->db, pDb->name, TSDB_DB_FNAME_LEN);
pDst->createdTime = taosGetTimestampMs();
pDst->updateTime = pDst->createdTime;
- pDst->uid = mndGenerateUid(pCreate->name, TSDB_TABLE_FNAME_LEN);
+ pDst->uid = (pCreate->source == 1) ? pCreate->suid : mndGenerateUid(pCreate->name, TSDB_TABLE_FNAME_LEN);
pDst->dbUid = pDb->uid;
- pDst->tagVer = 1;
- pDst->colVer = 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;
@@ -869,9 +869,38 @@ 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)) {
+ 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;
@@ -1614,14 +1643,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,6 +1773,11 @@ static int32_t mndProcessDropStbReq(SRpcMsg *pReq) {
}
}
+ if (dropReq.source != TD_REQ_FROM_APP && pStb->uid != dropReq.suid) {
+ terrno = TSDB_CODE_MND_STB_NOT_EXIST;
+ goto _OVER;
+ }
+
pDb = mndAcquireDbByStb(pMnode, dropReq.name);
if (pDb == NULL) {
terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
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 8ffa569865..b42b0f2b44 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/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..0c72d35027 100644
--- a/source/dnode/vnode/src/tq/tq.c
+++ b/source/dnode/vnode/src/tq/tq.c
@@ -271,6 +271,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,41 +297,25 @@ 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) {
@@ -337,7 +324,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
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) {
@@ -350,7 +337,8 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
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);
diff --git a/source/dnode/vnode/src/tq/tqExec.c b/source/dnode/vnode/src/tq/tqExec.c
index d381cfcdc7..4ecd88b1fd 100644
--- a/source/dnode/vnode/src/tq/tqExec.c
+++ b/source/dnode/vnode/src/tq/tqExec.c
@@ -62,7 +62,7 @@ static int32_t tqAddTbNameToRsp(const STQ* pTq, int64_t uid, SMqDataRsp* pRsp) {
int64_t tqScanLog(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) {
pRsp->rspOffset = *pOffset;
pRsp->rspOffset.version--;
return 0;
@@ -110,10 +110,6 @@ int32_t tqScanSnapshot(STQ* pTq, const STqExecHandle* pExec, SMqDataRsp* pRsp, S
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);
}
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..8d0ae4785b 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/executor/src/executorMain.c b/source/libs/executor/src/executorMain.c
index ad33c0ae55..ca1d8b2b10 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,55 @@ 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 {
+ // switch to log
+ }
+
+ } else {
+ ASSERT(0);
}
return 0;
} else {
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index db45ddb801..3d36ab16de 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);
}
@@ -298,7 +299,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;
@@ -308,7 +309,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;
}
@@ -663,7 +664,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;
}
@@ -677,7 +678,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;
}
@@ -704,12 +705,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);
@@ -1180,7 +1182,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);
}
@@ -1225,17 +1228,21 @@ 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;
- }
+ /*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;
+ 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);
@@ -1404,7 +1411,8 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
// currently only the tbname pseudo column
if (pInfo->numOfPseudoExpr > 0) {
- code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes, GET_TASKID(pTaskInfo));
+ code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes,
+ GET_TASKID(pTaskInfo));
if (code != TSDB_CODE_SUCCESS) {
longjmp(pTaskInfo->env, code);
}
@@ -1442,6 +1450,7 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
return (pBlockInfo->rows == 0) ? NULL : pInfo->pRes;
} else if (pInfo->blockType == STREAM_INPUT__TABLE_SCAN) {
+ /*ASSERT(0);*/
// check reader last status
// if not match, reset status
SSDataBlock* pResult = doTableScan(pInfo->pTableScanOp);
@@ -1834,9 +1843,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;
@@ -2236,9 +2246,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);
}
@@ -2526,8 +2537,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/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index f95ec78c76..932bfb8793 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -3464,6 +3464,10 @@ void saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pS
setBufPageDirty(pPage, true);
releaseBufPage(pCtx->pBuf, pPage);
+#ifdef BUF_PAGE_DEBUG
+ qDebug("page_saveTuple pos:%p,pageId:%d, offset:%d\n", pPos, pPos->pageId,
+ pPos->offset);
+#endif
}
void copyTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos) {
@@ -3498,6 +3502,9 @@ void copyTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pS
setBufPageDirty(pPage, true);
releaseBufPage(pCtx->pBuf, pPage);
+#ifdef BUF_PAGE_DEBUG
+ qDebug("page_copyTuple pos:%p, pageId:%d, offset:%d", pPos, pPos->pageId, pPos->offset);
+#endif
}
int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 0fbeac47e6..67133d0bf1 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -77,14 +77,6 @@ static int32_t addNamespace(STranslateContext* pCxt, void* pTable) {
return TSDB_CODE_SUCCESS;
}
-static SName* toName(int32_t acctId, const char* pDbName, const char* pTableName, SName* pName) {
- pName->type = TSDB_TABLE_NAME_T;
- pName->acctId = acctId;
- strcpy(pName->dbname, pDbName);
- strcpy(pName->tname, pTableName);
- return pName;
-}
-
static int32_t collectUseDatabaseImpl(const char* pFullDbName, SHashObj* pDbs) {
SFullDatabaseName name = {0};
strcpy(name.fullDbName, pFullDbName);
@@ -5370,7 +5362,8 @@ static int32_t serializeVgroupCreateTableBatch(SVgroupCreateTableBatch* pTbBatch
return TSDB_CODE_SUCCESS;
}
-static void destroyCreateTbReqBatch(SVgroupCreateTableBatch* pTbBatch) {
+static void destroyCreateTbReqBatch(void* data) {
+ SVgroupCreateTableBatch* pTbBatch = (SVgroupCreateTableBatch*) data;
size_t size = taosArrayGetSize(pTbBatch->req.pArray);
for (int32_t i = 0; i < size; ++i) {
SVCreateTbReq* pTableReq = taosArrayGet(pTbBatch->req.pArray, i);
@@ -5387,7 +5380,7 @@ static void destroyCreateTbReqBatch(SVgroupCreateTableBatch* pTbBatch) {
taosArrayDestroy(pTbBatch->req.pArray);
}
-static int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray) {
+int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray) {
SVnodeModifOpStmt* pNewStmt = (SVnodeModifOpStmt*)nodesMakeNode(QUERY_NODE_VNODE_MODIF_STMT);
if (pNewStmt == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
@@ -5453,10 +5446,10 @@ static int32_t rewriteCreateTable(STranslateContext* pCxt, SQuery* pQuery) {
static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, SCreateSubTableClause* pStmt,
const STag* pTag, uint64_t suid, SVgroupInfo* pVgInfo) {
- char dbFName[TSDB_DB_FNAME_LEN] = {0};
- SName name = {.type = TSDB_DB_NAME_T, .acctId = acctId};
- strcpy(name.dbname, pStmt->dbName);
- tNameGetFullDbName(&name, dbFName);
+// char dbFName[TSDB_DB_FNAME_LEN] = {0};
+// SName name = {.type = TSDB_DB_NAME_T, .acctId = acctId};
+// strcpy(name.dbname, pStmt->dbName);
+// tNameGetFullDbName(&name, dbFName);
struct SVCreateTbReq req = {0};
req.type = TD_CHILD_TABLE;
@@ -5717,7 +5710,7 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla
return code;
}
-static SArray* serializeVgroupsCreateTableBatch(int32_t acctId, SHashObj* pVgroupHashmap) {
+SArray* serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap) {
SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*));
if (NULL == pBufArray) {
return NULL;
@@ -5732,7 +5725,6 @@ static SArray* serializeVgroupsCreateTableBatch(int32_t acctId, SHashObj* pVgrou
}
serializeVgroupCreateTableBatch(pTbBatch, pBufArray);
- destroyCreateTbReqBatch(pTbBatch);
} while (true);
return pBufArray;
@@ -5746,6 +5738,7 @@ static int32_t rewriteCreateMultiTable(STranslateContext* pCxt, SQuery* pQuery)
return TSDB_CODE_OUT_OF_MEMORY;
}
+ taosHashSetFreeFp(pVgroupHashmap, destroyCreateTbReqBatch);
int32_t code = TSDB_CODE_SUCCESS;
SNode* pNode;
FOREACH(pNode, pStmt->pSubTables) {
@@ -5757,7 +5750,7 @@ static int32_t rewriteCreateMultiTable(STranslateContext* pCxt, SQuery* pQuery)
}
}
- SArray* pBufArray = serializeVgroupsCreateTableBatch(pCxt->pParseCxt->acctId, pVgroupHashmap);
+ SArray* pBufArray = serializeVgroupsCreateTableBatch(pVgroupHashmap);
taosHashCleanup(pVgroupHashmap);
if (NULL == pBufArray) {
return TSDB_CODE_OUT_OF_MEMORY;
@@ -5817,7 +5810,10 @@ over:
return code;
}
-static void destroyDropTbReqBatch(SVgroupDropTableBatch* pTbBatch) { taosArrayDestroy(pTbBatch->req.pArray); }
+static void destroyDropTbReqBatch(void* data) {
+ SVgroupDropTableBatch* pTbBatch = (SVgroupDropTableBatch*)data;
+ taosArrayDestroy(pTbBatch->req.pArray);
+}
static int32_t serializeVgroupDropTableBatch(SVgroupDropTableBatch* pTbBatch, SArray* pBufArray) {
int tlen;
@@ -5851,7 +5847,7 @@ static int32_t serializeVgroupDropTableBatch(SVgroupDropTableBatch* pTbBatch, SA
return TSDB_CODE_SUCCESS;
}
-static SArray* serializeVgroupsDropTableBatch(int32_t acctId, SHashObj* pVgroupHashmap) {
+SArray* serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap) {
SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*));
if (NULL == pBufArray) {
return NULL;
@@ -5866,7 +5862,6 @@ static SArray* serializeVgroupsDropTableBatch(int32_t acctId, SHashObj* pVgroupH
}
serializeVgroupDropTableBatch(pTbBatch, pBufArray);
- destroyDropTbReqBatch(pTbBatch);
} while (true);
return pBufArray;
@@ -5880,6 +5875,7 @@ static int32_t rewriteDropTable(STranslateContext* pCxt, SQuery* pQuery) {
return TSDB_CODE_OUT_OF_MEMORY;
}
+ taosHashSetFreeFp(pVgroupHashmap, destroyDropTbReqBatch);
bool isSuperTable = false;
SNode* pNode;
FOREACH(pNode, pStmt->pTables) {
@@ -5898,7 +5894,7 @@ static int32_t rewriteDropTable(STranslateContext* pCxt, SQuery* pQuery) {
return TSDB_CODE_SUCCESS;
}
- SArray* pBufArray = serializeVgroupsDropTableBatch(pCxt->pParseCxt->acctId, pVgroupHashmap);
+ SArray* pBufArray = serializeVgroupsDropTableBatch(pVgroupHashmap);
taosHashCleanup(pVgroupHashmap);
if (NULL == pBufArray) {
return TSDB_CODE_OUT_OF_MEMORY;
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/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/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);