Merge branch '3.0' into cpwu/3.0
This commit is contained in:
cpwu
commit
4ec50d141a
|
|
@ -79,7 +79,7 @@ ENDIF ()
|
|||
|
||||
option(
|
||||
BUILD_SANITIZER
|
||||
"If build addr2line"
|
||||
"If build sanitizer"
|
||||
OFF
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -161,7 +161,6 @@ typedef struct SQueryTableDataCond {
|
|||
int64_t endVersion;
|
||||
} SQueryTableDataCond;
|
||||
|
||||
void* blockDataDestroy(SSDataBlock* pBlock);
|
||||
int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlock);
|
||||
void* tDecodeDataBlock(const void* buf, SSDataBlock* pBlock);
|
||||
|
||||
|
|
@ -169,19 +168,6 @@ int32_t tEncodeDataBlocks(void** buf, const SArray* blocks);
|
|||
void* tDecodeDataBlocks(const void* buf, SArray** blocks);
|
||||
void colDataDestroy(SColumnInfoData* pColData);
|
||||
|
||||
static FORCE_INLINE void blockDestroyInner(SSDataBlock* pBlock) {
|
||||
int32_t numOfOutput = taosArrayGetSize(pBlock->pDataBlock);
|
||||
for (int32_t i = 0; i < numOfOutput; ++i) {
|
||||
SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);
|
||||
colDataDestroy(pColInfoData);
|
||||
}
|
||||
|
||||
taosArrayDestroy(pBlock->pDataBlock);
|
||||
taosMemoryFreeClear(pBlock->pBlockAgg);
|
||||
}
|
||||
|
||||
static FORCE_INLINE void tDeleteSSDataBlock(SSDataBlock* pBlock) { blockDestroyInner(pBlock); }
|
||||
|
||||
//======================================================================================================================
|
||||
// the following structure shared by parser and executor
|
||||
typedef struct SColumn {
|
||||
|
|
|
|||
|
|
@ -226,8 +226,12 @@ int32_t blockDataKeepFirstNRows(SSDataBlock* pBlock, size_t n);
|
|||
|
||||
int32_t assignOneDataBlock(SSDataBlock* dst, const SSDataBlock* src);
|
||||
int32_t copyDataBlock(SSDataBlock* dst, const SSDataBlock* src);
|
||||
SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock, bool copyData);
|
||||
|
||||
SSDataBlock* createDataBlock();
|
||||
void* blockDataDestroy(SSDataBlock* pBlock);
|
||||
void blockDataFreeRes(SSDataBlock* pBlock);
|
||||
SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock, bool copyData);
|
||||
|
||||
int32_t blockDataAppendColInfo(SSDataBlock* pBlock, SColumnInfoData* pColInfoData);
|
||||
|
||||
SColumnInfoData createColumnInfoData(int16_t type, int32_t bytes, int16_t colId);
|
||||
|
|
|
|||
|
|
@ -275,7 +275,12 @@ typedef struct SScanPhysiNode {
|
|||
|
||||
typedef SScanPhysiNode STagScanPhysiNode;
|
||||
typedef SScanPhysiNode SBlockDistScanPhysiNode;
|
||||
typedef SScanPhysiNode SLastRowScanPhysiNode;
|
||||
|
||||
typedef struct SLastRowScanPhysiNode {
|
||||
SScanPhysiNode scan;
|
||||
SNodeList* pGroupTags;
|
||||
bool groupSort;
|
||||
} SLastRowScanPhysiNode;
|
||||
|
||||
typedef struct SSystemTableScanPhysiNode {
|
||||
SScanPhysiNode scan;
|
||||
|
|
|
|||
|
|
@ -340,12 +340,12 @@ static FORCE_INLINE int32_t streamTaskOutput(SStreamTask* pTask, SStreamDataBloc
|
|||
if (pTask->sinkType == TASK_SINK__TABLE) {
|
||||
ASSERT(pTask->dispatchType == TASK_DISPATCH__NONE);
|
||||
pTask->tbSink.tbSinkFunc(pTask, pTask->tbSink.vnode, 0, pBlock->blocks);
|
||||
taosArrayDestroyEx(pBlock->blocks, (FDelete)tDeleteSSDataBlock);
|
||||
taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
|
||||
taosFreeQitem(pBlock);
|
||||
} else if (pTask->sinkType == TASK_SINK__SMA) {
|
||||
ASSERT(pTask->dispatchType == TASK_DISPATCH__NONE);
|
||||
pTask->smaSink.smaSink(pTask->smaSink.vnode, pTask->smaSink.smaId, pBlock->blocks);
|
||||
taosArrayDestroyEx(pBlock->blocks, (FDelete)tDeleteSSDataBlock);
|
||||
taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
|
||||
taosFreeQitem(pBlock);
|
||||
} else {
|
||||
ASSERT(pTask->dispatchType != TASK_DISPATCH__NONE);
|
||||
|
|
|
|||
|
|
@ -22,7 +22,10 @@ extern "C" {
|
|||
|
||||
#if defined(_TD_DARWIN_64)
|
||||
// specific
|
||||
#ifndef __COMPAR_FN_T
|
||||
#define __COMPAR_FN_T
|
||||
typedef int(*__compar_fn_t)(const void *, const void *);
|
||||
#endif
|
||||
|
||||
// for send function in tsocket.c
|
||||
#if defined(MSG_NOSIGNAL)
|
||||
|
|
@ -41,7 +44,10 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
#if defined(_ALPINE)
|
||||
#ifndef __COMPAR_FN_T
|
||||
#define __COMPAR_FN_T
|
||||
typedef int(*__compar_fn_t)(const void *, const void *);
|
||||
#endif
|
||||
void error (int, int, const char *);
|
||||
#ifndef PTHREAD_MUTEX_RECURSIVE_NP
|
||||
#define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
|
||||
|
|
@ -54,7 +60,10 @@ extern "C" {
|
|||
char *stpncpy (char *dest, const char *src, size_t n);
|
||||
|
||||
// specific
|
||||
#ifndef __COMPAR_FN_T
|
||||
#define __COMPAR_FN_T
|
||||
typedef int (*__compar_fn_t)(const void *, const void *);
|
||||
#endif
|
||||
#define ssize_t int
|
||||
#define _SSIZE_T_
|
||||
#define bzero(ptr, size) memset((ptr), 0, (size))
|
||||
|
|
@ -69,7 +78,6 @@ extern "C" {
|
|||
char * strsep(char **stringp, const char *delim);
|
||||
char * getpass(const char *prefix);
|
||||
char * strndup(const char *s, size_t n);
|
||||
int gettimeofday(struct timeval *ptv, void *pTimeZone);
|
||||
|
||||
// for send function in tsocket.c
|
||||
#define MSG_NOSIGNAL 0
|
||||
|
|
|
|||
|
|
@ -343,7 +343,7 @@ tmq_list_t* tmq_list_new() {
|
|||
|
||||
int32_t tmq_list_append(tmq_list_t* list, const char* src) {
|
||||
SArray* container = &list->container;
|
||||
char* topic = strDupUnquo(src);
|
||||
char* topic = strdup(src);
|
||||
if (taosArrayPush(container, &topic) == NULL) return -1;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1197,15 +1197,28 @@ int32_t blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows) {
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
void blockDataFreeRes(SSDataBlock* pBlock) {
|
||||
int32_t numOfOutput = taosArrayGetSize(pBlock->pDataBlock);
|
||||
for (int32_t i = 0; i < numOfOutput; ++i) {
|
||||
SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);
|
||||
colDataDestroy(pColInfoData);
|
||||
}
|
||||
|
||||
taosArrayDestroy(pBlock->pDataBlock);
|
||||
taosMemoryFreeClear(pBlock->pBlockAgg);
|
||||
memset(&pBlock->info, 0, sizeof(SDataBlockInfo));
|
||||
}
|
||||
|
||||
void* blockDataDestroy(SSDataBlock* pBlock) {
|
||||
if (pBlock == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
blockDestroyInner(pBlock);
|
||||
blockDataFreeRes(pBlock);
|
||||
taosMemoryFreeClear(pBlock);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int32_t assignOneDataBlock(SSDataBlock* dst, const SSDataBlock* src) {
|
||||
ASSERT(src != NULL);
|
||||
|
||||
|
|
|
|||
|
|
@ -125,7 +125,7 @@ typedef struct SMnode {
|
|||
} SMnode;
|
||||
|
||||
void mndSetMsgHandle(SMnode *pMnode, tmsg_t msgType, MndMsgFp fp);
|
||||
int64_t mndGenerateUid(char *name, int32_t len);
|
||||
int64_t mndGenerateUid(const char *name, int32_t len);
|
||||
|
||||
int32_t mndAcquireRpcRef(SMnode *pMnode);
|
||||
void mndReleaseRpcRef(SMnode *pMnode);
|
||||
|
|
|
|||
|
|
@ -624,7 +624,7 @@ void mndSetMsgHandle(SMnode *pMnode, tmsg_t msgType, MndMsgFp fp) {
|
|||
}
|
||||
|
||||
// Note: uid 0 is reserved
|
||||
int64_t mndGenerateUid(char *name, int32_t len) {
|
||||
int64_t mndGenerateUid(const char *name, int32_t len) {
|
||||
int32_t hashval = MurmurHash3_32(name, len);
|
||||
do {
|
||||
int64_t us = taosGetTimestampUs();
|
||||
|
|
|
|||
|
|
@ -479,7 +479,8 @@ static void mndDestroySmaObj(SSmaObj *pSmaObj) {
|
|||
}
|
||||
}
|
||||
|
||||
static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCreate, SDbObj *pDb, SStbObj *pStb) {
|
||||
static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCreate, SDbObj *pDb, SStbObj *pStb,
|
||||
const char *streamName) {
|
||||
SSmaObj smaObj = {0};
|
||||
memcpy(smaObj.name, pCreate->name, TSDB_TABLE_FNAME_LEN);
|
||||
memcpy(smaObj.stb, pStb->name, TSDB_TABLE_FNAME_LEN);
|
||||
|
|
@ -520,12 +521,12 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
|
|||
}
|
||||
|
||||
SStreamObj streamObj = {0};
|
||||
tstrncpy(streamObj.name, pCreate->name, TSDB_STREAM_FNAME_LEN);
|
||||
tstrncpy(streamObj.name, streamName, TSDB_STREAM_FNAME_LEN);
|
||||
tstrncpy(streamObj.sourceDb, pDb->name, TSDB_DB_FNAME_LEN);
|
||||
tstrncpy(streamObj.targetDb, streamObj.sourceDb, TSDB_DB_FNAME_LEN);
|
||||
streamObj.createTime = taosGetTimestampMs();
|
||||
streamObj.updateTime = streamObj.createTime;
|
||||
streamObj.uid = mndGenerateUid(pCreate->name, strlen(pCreate->name));
|
||||
streamObj.uid = mndGenerateUid(streamName, strlen(streamName));
|
||||
streamObj.sourceDbUid = pDb->uid;
|
||||
streamObj.targetDbUid = pDb->uid;
|
||||
streamObj.version = 1;
|
||||
|
|
@ -590,7 +591,7 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
|
|||
if (pTrans == NULL) goto _OVER;
|
||||
mndTransSetDbName(pTrans, pDb->name, NULL);
|
||||
mndTransSetSerial(pTrans);
|
||||
mDebug("trans:%d, used to create sma:%s", pTrans->id, pCreate->name);
|
||||
mDebug("trans:%d, used to create sma:%s stream:%s", pTrans->id, pCreate->name, streamObj.name);
|
||||
|
||||
if (mndSetCreateSmaRedoLogs(pMnode, pTrans, &smaObj) != 0) goto _OVER;
|
||||
if (mndSetCreateSmaVgroupRedoLogs(pMnode, pTrans, &streamObj.fixedSinkVg) != 0) goto _OVER;
|
||||
|
|
@ -638,6 +639,14 @@ static int32_t mndCheckCreateSmaReq(SMCreateSmaReq *pCreate) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void mndGetStreamNameFromSmaName(char *streamName, char *smaName) {
|
||||
SName n;
|
||||
tNameFromString(&n, smaName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
|
||||
streamName[0] = '1';
|
||||
streamName[1] = '.';
|
||||
strcpy(streamName + 2, tNameGetTableName(&n));
|
||||
}
|
||||
|
||||
static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
|
||||
SMnode *pMnode = pReq->info.node;
|
||||
int32_t code = -1;
|
||||
|
|
@ -663,9 +672,12 @@ static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
|
|||
goto _OVER;
|
||||
}
|
||||
|
||||
pStream = mndAcquireStream(pMnode, createReq.name);
|
||||
char streamName[TSDB_TABLE_FNAME_LEN] = {0};
|
||||
mndGetStreamNameFromSmaName(streamName, createReq.name);
|
||||
|
||||
pStream = mndAcquireStream(pMnode, streamName);
|
||||
if (pStream != NULL) {
|
||||
mError("sma:%s, failed to create since stream:%s already exist", createReq.name, createReq.name);
|
||||
mError("sma:%s, failed to create since stream:%s already exist", createReq.name, streamName);
|
||||
terrno = TSDB_CODE_MND_STREAM_ALREADY_EXIST;
|
||||
goto _OVER;
|
||||
}
|
||||
|
|
@ -692,7 +704,7 @@ static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
|
|||
goto _OVER;
|
||||
}
|
||||
|
||||
code = mndCreateSma(pMnode, pReq, &createReq, pDb, pStb);
|
||||
code = mndCreateSma(pMnode, pReq, &createReq, pDb, pStb, streamName);
|
||||
if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
|
||||
|
||||
_OVER:
|
||||
|
|
@ -789,7 +801,10 @@ static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *p
|
|||
mDebug("trans:%d, used to drop sma:%s", pTrans->id, pSma->name);
|
||||
mndTransSetDbName(pTrans, pDb->name, NULL);
|
||||
|
||||
SStreamObj *pStream = mndAcquireStream(pMnode, pSma->name);
|
||||
char streamName[TSDB_TABLE_FNAME_LEN] = {0};
|
||||
mndGetStreamNameFromSmaName(streamName, pSma->name);
|
||||
|
||||
SStreamObj *pStream = mndAcquireStream(pMnode, streamName);
|
||||
if (pStream == NULL || pStream->smaId != pSma->uid) {
|
||||
sdbRelease(pMnode->pSdb, pStream);
|
||||
goto _OVER;
|
||||
|
|
@ -838,7 +853,10 @@ int32_t mndDropSmasByStb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *p
|
|||
pVgroup = mndAcquireVgroup(pMnode, pSma->dstVgId);
|
||||
if (pVgroup == NULL) goto _OVER;
|
||||
|
||||
SStreamObj *pStream = mndAcquireStream(pMnode, pSma->name);
|
||||
char streamName[TSDB_TABLE_FNAME_LEN] = {0};
|
||||
mndGetStreamNameFromSmaName(streamName, pSma->name);
|
||||
|
||||
SStreamObj *pStream = mndAcquireStream(pMnode, streamName);
|
||||
if (pStream != NULL && pStream->smaId == pSma->uid) {
|
||||
if (mndDropStreamTasks(pMnode, pTrans, pStream) < 0) {
|
||||
mError("stream:%s, failed to drop task since %s", pStream->name, terrstr());
|
||||
|
|
|
|||
|
|
@ -236,6 +236,7 @@ static int32_t mndStreamGetPlanString(const char *ast, int8_t triggerType, int64
|
|||
|
||||
static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj, SCMCreateStreamReq *pCreate) {
|
||||
SNode *pAst = NULL;
|
||||
SQueryPlan *pPlan = NULL;
|
||||
|
||||
mDebug("stream:%s to create", pCreate->name);
|
||||
memcpy(pObj->name, pCreate->name, TSDB_STREAM_FNAME_LEN);
|
||||
|
|
@ -293,7 +294,6 @@ static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj,
|
|||
goto FAIL;
|
||||
}
|
||||
|
||||
SQueryPlan *pPlan = NULL;
|
||||
SPlanContext cxt = {
|
||||
.pAstRoot = pAst,
|
||||
.topicQuery = false,
|
||||
|
|
@ -317,6 +317,7 @@ static int32_t mndBuildStreamObjFromCreateReq(SMnode *pMnode, SStreamObj *pObj,
|
|||
|
||||
FAIL:
|
||||
if (pAst != NULL) nodesDestroyNode(pAst);
|
||||
if (pPlan != NULL) qDestroyQueryPlan(pPlan);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -541,7 +542,7 @@ static int32_t mndProcessCreateStreamReq(SRpcMsg *pReq) {
|
|||
// build stream obj from request
|
||||
SStreamObj streamObj = {0};
|
||||
if (mndBuildStreamObjFromCreateReq(pMnode, &streamObj, &createStreamReq) < 0) {
|
||||
ASSERT(0);
|
||||
/*ASSERT(0);*/
|
||||
mError("stream:%s, failed to create since %s", createStreamReq.name, terrstr());
|
||||
goto _OVER;
|
||||
}
|
||||
|
|
@ -689,7 +690,14 @@ int32_t mndDropStreamByDb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
|
|||
terrno = TSDB_CODE_MND_STREAM_ALREADY_EXIST;
|
||||
return -1;
|
||||
} else {
|
||||
// TODO drop all task on snode
|
||||
#if 0
|
||||
if (mndDropStreamTasks(pMnode, pTrans, pStream) < 0) {
|
||||
mError("stream:%s, failed to drop task since %s", pStream->name, terrstr());
|
||||
sdbRelease(pMnode->pSdb, pStream);
|
||||
sdbCancelFetch(pSdb, pIter);
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
if (mndPersistDropStreamLog(pMnode, pTrans, pStream) < 0) {
|
||||
sdbRelease(pSdb, pStream);
|
||||
sdbCancelFetch(pSdb, pIter);
|
||||
|
|
|
|||
|
|
@ -163,7 +163,6 @@ typedef struct SSdbRow {
|
|||
ESdbType type;
|
||||
ESdbStatus status;
|
||||
int32_t refCount;
|
||||
int64_t forAlign;
|
||||
char pObj[];
|
||||
} SSdbRow;
|
||||
|
||||
|
|
|
|||
|
|
@ -214,7 +214,6 @@ static int32_t tdInitSmaStat(SSmaStat **pSmaStat, int8_t smaType, const SSma *pS
|
|||
}
|
||||
pRSmaStat->refId = refId;
|
||||
|
||||
|
||||
// init hash
|
||||
RSMA_INFO_HASH(pRSmaStat) = taosHashInit(
|
||||
RSMA_TASK_INFO_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
|
||||
|
|
@ -256,6 +255,7 @@ static void tdDestroyRSmaStat(void *pRSmaStat) {
|
|||
|
||||
// step 2: destroy the rsma info and associated fetch tasks
|
||||
// TODO: use taosHashSetFreeFp when taosHashSetFreeFp is ready.
|
||||
#if 1
|
||||
if (taosHashGetSize(RSMA_INFO_HASH(pStat)) > 0) {
|
||||
void *infoHash = taosHashIterate(RSMA_INFO_HASH(pStat), NULL);
|
||||
while (infoHash) {
|
||||
|
|
@ -264,6 +264,7 @@ static void tdDestroyRSmaStat(void *pRSmaStat) {
|
|||
infoHash = taosHashIterate(RSMA_INFO_HASH(pStat), infoHash);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
taosHashCleanup(RSMA_INFO_HASH(pStat));
|
||||
|
||||
// step 3: wait all triggered fetch tasks finished
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ 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, SRSmaStat *pStat, SRSmaInfo *pRSmaInfo,
|
||||
SReadHandle *handle, int8_t idx);
|
||||
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);
|
||||
|
|
@ -256,14 +256,20 @@ int32_t tdFetchTbUidList(SSma *pSma, STbUidStore **ppStore, tb_uid_t suid, tb_ui
|
|||
}
|
||||
|
||||
static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat *pStat, SRSmaInfo *pRSmaInfo,
|
||||
SReadHandle *pReadHandle, int8_t idx) {
|
||||
int8_t idx) {
|
||||
SRetention *pRetention = SMA_RETENTION(pSma);
|
||||
STsdbCfg *pTsdbCfg = SMA_TSDB_CFG(pSma);
|
||||
|
||||
SReadHandle handle = {
|
||||
.meta = pSma->pVnode->pMeta,
|
||||
.vnode = pSma->pVnode,
|
||||
.initTqReader = 1,
|
||||
};
|
||||
|
||||
if (param->qmsg[idx]) {
|
||||
SRSmaInfoItem *pItem = &(pRSmaInfo->items[idx]);
|
||||
pItem->refId = RSMA_REF_ID(pStat);
|
||||
pItem->taskInfo = qCreateStreamExecTaskInfo(param->qmsg[idx], pReadHandle);
|
||||
pItem->taskInfo = qCreateStreamExecTaskInfo(param->qmsg[idx], &handle);
|
||||
if (!pItem->taskInfo) {
|
||||
terrno = TSDB_CODE_RSMA_QTASKINFO_CREATE;
|
||||
goto _err;
|
||||
|
|
@ -299,10 +305,6 @@ _err:
|
|||
* @return int32_t
|
||||
*/
|
||||
int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, const char *tbName) {
|
||||
SVnode *pVnode = pSma->pVnode;
|
||||
SMeta *pMeta = pVnode->pMeta;
|
||||
SMsgCb *pMsgCb = &pVnode->msgCb;
|
||||
|
||||
if ((param->qmsgLen[0] == 0) && (param->qmsgLen[1] == 0)) {
|
||||
smaDebug("vgId:%d, no qmsg1/qmsg2 for rollup table %s %" PRIi64, SMA_VID(pSma), tbName, suid);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
|
|
@ -331,19 +333,6 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
|
|||
return TSDB_CODE_FAILED;
|
||||
}
|
||||
|
||||
STqReader *pReader = tqOpenReader(pVnode);
|
||||
if (!pReader) {
|
||||
terrno = TSDB_CODE_OUT_OF_MEMORY;
|
||||
goto _err;
|
||||
}
|
||||
|
||||
SReadHandle handle = {
|
||||
.tqReader = pReader,
|
||||
.meta = pMeta,
|
||||
.pMsgCb = pMsgCb,
|
||||
.vnode = pVnode,
|
||||
};
|
||||
|
||||
STSchema *pTSchema = metaGetTbTSchema(SMA_META(pSma), suid, -1);
|
||||
if (!pTSchema) {
|
||||
terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
|
||||
|
|
@ -352,11 +341,11 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
|
|||
pRSmaInfo->pTSchema = pTSchema;
|
||||
pRSmaInfo->suid = suid;
|
||||
|
||||
if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, &handle, 0) < 0) {
|
||||
if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, 0) < 0) {
|
||||
goto _err;
|
||||
}
|
||||
|
||||
if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, &handle, 1) < 0) {
|
||||
if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, 1) < 0) {
|
||||
goto _err;
|
||||
}
|
||||
|
||||
|
|
@ -369,7 +358,6 @@ int32_t tdProcessRSmaCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
|
|||
return TSDB_CODE_SUCCESS;
|
||||
_err:
|
||||
tdFreeRSmaInfo(pSma, pRSmaInfo);
|
||||
taosMemoryFree(pReader);
|
||||
return TSDB_CODE_FAILED;
|
||||
}
|
||||
|
||||
|
|
@ -412,11 +400,9 @@ int32_t tdProcessRSmaDrop(SSma *pSma, SVDropStbReq *pReq) {
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
smaDebug("vgId:%d, drop rsma for table %" PRIi64 " succeed", TD_VID(pVnode), pReq->suid);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief store suid/[uids], prefer to use array and then hash
|
||||
|
|
|
|||
|
|
@ -82,6 +82,13 @@ void tqClose(STQ* pTq) {
|
|||
if (pTq) {
|
||||
tqOffsetClose(pTq->pOffsetStore);
|
||||
taosHashCleanup(pTq->handles);
|
||||
void* pIter = NULL;
|
||||
while (1) {
|
||||
pIter = taosHashIterate(pTq->pStreamTasks, pIter);
|
||||
if (pIter == NULL) break;
|
||||
SStreamTask* pTask = *(SStreamTask**)pIter;
|
||||
tFreeSStreamTask(pTask);
|
||||
}
|
||||
taosHashCleanup(pTq->pStreamTasks);
|
||||
taosHashCleanup(pTq->pushMgr);
|
||||
taosMemoryFree(pTq->path);
|
||||
|
|
@ -608,7 +615,8 @@ int32_t tqProcessTaskDeployReq(STQ* pTq, char* msg, int32_t msgLen) {
|
|||
|
||||
streamSetupTrigger(pTask);
|
||||
|
||||
tqInfo("deploy stream task id %d child id %d on vgId:%d", pTask->taskId, pTask->selfChildId, TD_VID(pTq->pVnode));
|
||||
tqInfo("deploy stream task on vg %d, task id %d, child id %d", TD_VID(pTq->pVnode), pTask->taskId,
|
||||
pTask->selfChildId);
|
||||
|
||||
taosHashPut(pTq->pStreamTasks, &pTask->taskId, sizeof(int32_t), &pTask, sizeof(void*));
|
||||
|
||||
|
|
@ -634,9 +642,6 @@ int32_t tqProcessStreamTrigger(STQ* pTq, SSubmitReq* pReq) {
|
|||
pIter = taosHashIterate(pTq->pStreamTasks, pIter);
|
||||
if (pIter == NULL) break;
|
||||
SStreamTask* pTask = *(SStreamTask**)pIter;
|
||||
if (atomic_load_8(&pTask->taskStatus) == TASK_STATUS__DROPPING) {
|
||||
continue;
|
||||
}
|
||||
if (!pTask->isDataScan) continue;
|
||||
|
||||
if (!failed) {
|
||||
|
|
@ -665,11 +670,12 @@ int32_t tqProcessTaskRunReq(STQ* pTq, SRpcMsg* pMsg) {
|
|||
SStreamTaskRunReq* pReq = pMsg->pCont;
|
||||
int32_t taskId = pReq->taskId;
|
||||
SStreamTask* pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
|
||||
if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
|
||||
return 0;
|
||||
}
|
||||
if (pTask) {
|
||||
streamProcessRunReq(pTask);
|
||||
return 0;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t tqProcessTaskDispatchReq(STQ* pTq, SRpcMsg* pMsg) {
|
||||
|
|
@ -682,55 +688,62 @@ int32_t tqProcessTaskDispatchReq(STQ* pTq, SRpcMsg* pMsg) {
|
|||
tDecodeStreamDispatchReq(&decoder, &req);
|
||||
int32_t taskId = req.taskId;
|
||||
SStreamTask* pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
|
||||
if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
|
||||
return 0;
|
||||
}
|
||||
if (pTask) {
|
||||
SRpcMsg rsp = {
|
||||
.info = pMsg->info,
|
||||
.code = 0,
|
||||
};
|
||||
streamProcessDispatchReq(pTask, &req, &rsp);
|
||||
return 0;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t tqProcessTaskRecoverReq(STQ* pTq, SRpcMsg* pMsg) {
|
||||
SStreamTaskRecoverReq* pReq = pMsg->pCont;
|
||||
int32_t taskId = pReq->taskId;
|
||||
SStreamTask* pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
|
||||
if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
|
||||
return 0;
|
||||
}
|
||||
if (pTask) {
|
||||
streamProcessRecoverReq(pTask, pReq, pMsg);
|
||||
return 0;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t tqProcessTaskDispatchRsp(STQ* pTq, SRpcMsg* pMsg) {
|
||||
SStreamDispatchRsp* pRsp = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
|
||||
int32_t taskId = pRsp->taskId;
|
||||
SStreamTask* pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
|
||||
if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
|
||||
return 0;
|
||||
}
|
||||
if (pTask) {
|
||||
streamProcessDispatchRsp(pTask, pRsp);
|
||||
return 0;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t tqProcessTaskRecoverRsp(STQ* pTq, SRpcMsg* pMsg) {
|
||||
SStreamTaskRecoverRsp* pRsp = pMsg->pCont;
|
||||
int32_t taskId = pRsp->taskId;
|
||||
SStreamTask* pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
|
||||
if (atomic_load_8(&pTask->taskStatus) != TASK_STATUS__NORMAL) {
|
||||
return 0;
|
||||
}
|
||||
if (pTask) {
|
||||
streamProcessRecoverRsp(pTask, pRsp);
|
||||
return 0;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t tqProcessTaskDropReq(STQ* pTq, char* msg, int32_t msgLen) {
|
||||
SVDropStreamTaskReq* pReq = (SVDropStreamTaskReq*)msg;
|
||||
|
||||
SStreamTask* pTask = *(SStreamTask**)taosHashGet(pTq->pStreamTasks, &pReq->taskId, sizeof(int32_t));
|
||||
if (pTask) {
|
||||
taosHashRemove(pTq->pStreamTasks, &pReq->taskId, sizeof(int32_t));
|
||||
atomic_store_8(&pTask->taskStatus, TASK_STATUS__DROPPING);
|
||||
}
|
||||
// todo
|
||||
// clear queue
|
||||
// push drop req into queue
|
||||
|
|
|
|||
|
|
@ -98,8 +98,21 @@ STqReader* tqOpenReader(SVnode* pVnode) {
|
|||
|
||||
void tqCloseReader(STqReader* pReader) {
|
||||
// close wal reader
|
||||
if (pReader->pWalReader) {
|
||||
walCloseReader(pReader->pWalReader);
|
||||
}
|
||||
// free cached schema
|
||||
if (pReader->pSchema) {
|
||||
taosMemoryFree(pReader->pSchema);
|
||||
}
|
||||
if (pReader->pSchemaWrapper) {
|
||||
tDeleteSSchemaWrapper(pReader->pSchemaWrapper);
|
||||
}
|
||||
if (pReader->pColIdList) {
|
||||
taosArrayDestroy(pReader->pColIdList);
|
||||
}
|
||||
// free hash
|
||||
taosHashCleanup(pReader->tbIdHash);
|
||||
taosMemoryFree(pReader);
|
||||
}
|
||||
|
||||
|
|
@ -319,7 +332,7 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, STqReader* pReader) {
|
|||
return 0;
|
||||
|
||||
FAIL:
|
||||
tDeleteSSDataBlock(pBlock);
|
||||
blockDataFreeRes(pBlock);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -147,7 +147,7 @@ SSubmitReq* tdBlockToSubmit(const SArray* pBlocks, const STSchema* pTSchema, boo
|
|||
const STColumn* pColumn = &pTSchema->columns[k];
|
||||
SColumnInfoData* pColData = taosArrayGet(pDataBlock->pDataBlock, k);
|
||||
if (colDataIsNull_s(pColData, j)) {
|
||||
tdAppendColValToRow(&rb, pColumn->colId, pColumn->type, TD_VTYPE_NONE, NULL, false, pColumn->offset, k);
|
||||
tdAppendColValToRow(&rb, pColumn->colId, pColumn->type, TD_VTYPE_NULL, NULL, false, pColumn->offset, k);
|
||||
} else {
|
||||
void* data = colDataGetData(pColData, j);
|
||||
tdAppendColValToRow(&rb, pColumn->colId, pColumn->type, TD_VTYPE_NORM, data, true, pColumn->offset, k);
|
||||
|
|
|
|||
|
|
@ -209,10 +209,10 @@ static void resetDataBlockScanInfo(SHashObj* pTableMap) {
|
|||
p->iterInit = false;
|
||||
p->iiter.hasVal = false;
|
||||
if (p->iter.iter != NULL) {
|
||||
tsdbTbDataIterDestroy(p->iter.iter);
|
||||
p->iter.iter = tsdbTbDataIterDestroy(p->iter.iter);
|
||||
}
|
||||
|
||||
taosArrayDestroy(p->delSkyline);
|
||||
p->delSkyline = taosArrayDestroy(p->delSkyline);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -224,18 +224,15 @@ static void destroyBlockScanInfo(SHashObj* pTableMap) {
|
|||
p->iiter.hasVal = false;
|
||||
|
||||
if (p->iter.iter != NULL) {
|
||||
tsdbTbDataIterDestroy(p->iter.iter);
|
||||
p->iter.iter = NULL;
|
||||
p->iter.iter = tsdbTbDataIterDestroy(p->iter.iter);
|
||||
}
|
||||
|
||||
if (p->iiter.iter != NULL) {
|
||||
tsdbTbDataIterDestroy(p->iiter.iter);
|
||||
p->iiter.iter = NULL;
|
||||
p->iiter.iter = tsdbTbDataIterDestroy(p->iiter.iter);
|
||||
}
|
||||
|
||||
taosArrayDestroy(p->delSkyline);
|
||||
taosArrayDestroy(p->pBlockList);
|
||||
p->delSkyline = NULL;
|
||||
p->delSkyline = taosArrayDestroy(p->delSkyline);
|
||||
p->pBlockList = taosArrayDestroy(p->pBlockList);
|
||||
}
|
||||
|
||||
taosHashCleanup(pTableMap);
|
||||
|
|
|
|||
|
|
@ -206,7 +206,7 @@ int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNo
|
|||
}
|
||||
case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: {
|
||||
SLastRowScanPhysiNode *lastRowPhysiNode = (SLastRowScanPhysiNode *)pNode;
|
||||
pPhysiChildren = lastRowPhysiNode->node.pChildren;
|
||||
pPhysiChildren = lastRowPhysiNode->scan.node.pChildren;
|
||||
break;
|
||||
}
|
||||
case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: {
|
||||
|
|
@ -1209,19 +1209,19 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
|
|||
}
|
||||
case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: {
|
||||
SLastRowScanPhysiNode *pLastRowNode = (SLastRowScanPhysiNode *)pNode;
|
||||
EXPLAIN_ROW_NEW(level, EXPLAIN_LASTROW_SCAN_FORMAT, pLastRowNode->tableName.tname);
|
||||
EXPLAIN_ROW_NEW(level, EXPLAIN_LASTROW_SCAN_FORMAT, pLastRowNode->scan.tableName.tname);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);
|
||||
if (pResNode->pExecInfo) {
|
||||
QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
|
||||
}
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pLastRowNode->pScanCols->length);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT, pLastRowNode->scan.pScanCols->length);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
|
||||
if (pLastRowNode->pScanPseudoCols) {
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pLastRowNode->pScanPseudoCols->length);
|
||||
if (pLastRowNode->scan.pScanPseudoCols) {
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_PSEUDO_COLUMNS_FORMAT, pLastRowNode->scan.pScanPseudoCols->length);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
|
||||
}
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->node.pOutputDataBlockDesc->totalRowSize);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->scan.node.pOutputDataBlockDesc->totalRowSize);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_RIGHT_PARENTHESIS_FORMAT);
|
||||
EXPLAIN_ROW_END();
|
||||
|
|
@ -1230,15 +1230,15 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
|
|||
if (verbose) {
|
||||
EXPLAIN_ROW_NEW(level + 1, EXPLAIN_OUTPUT_FORMAT);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_COLUMNS_FORMAT,
|
||||
nodesGetOutputNumFromSlotList(pLastRowNode->node.pOutputDataBlockDesc->pSlots));
|
||||
nodesGetOutputNumFromSlotList(pLastRowNode->scan.node.pOutputDataBlockDesc->pSlots));
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_BLANK_FORMAT);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->node.pOutputDataBlockDesc->outputRowSize);
|
||||
EXPLAIN_ROW_APPEND(EXPLAIN_WIDTH_FORMAT, pLastRowNode->scan.node.pOutputDataBlockDesc->outputRowSize);
|
||||
EXPLAIN_ROW_END();
|
||||
QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
|
||||
|
||||
if (pLastRowNode->node.pConditions) {
|
||||
if (pLastRowNode->scan.node.pConditions) {
|
||||
EXPLAIN_ROW_NEW(level + 1, EXPLAIN_FILTER_FORMAT);
|
||||
QRY_ERR_RET(nodesNodeToSQL(pLastRowNode->node.pConditions, tbuf + VARSTR_HEADER_SIZE,
|
||||
QRY_ERR_RET(nodesNodeToSQL(pLastRowNode->scan.node.pConditions, tbuf + VARSTR_HEADER_SIZE,
|
||||
TSDB_EXPLAIN_RESULT_ROW_SIZE, &tlen));
|
||||
EXPLAIN_ROW_END();
|
||||
QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
|
||||
|
|
|
|||
|
|
@ -147,7 +147,6 @@ typedef struct {
|
|||
SSDataBlock* pullOverBlk; // for streaming
|
||||
SWalFilterCond cond;
|
||||
int64_t lastScanUid;
|
||||
SStreamQueue* inputQueue;
|
||||
} SStreamTaskInfo;
|
||||
|
||||
typedef struct SExecTaskInfo {
|
||||
|
|
@ -561,6 +560,7 @@ typedef struct SFillOperatorInfo {
|
|||
SNode* pCondition;
|
||||
SArray* pColMatchColInfo;
|
||||
int32_t primaryTsCol;
|
||||
uint64_t curGroupId; // current handled group id
|
||||
} SFillOperatorInfo;
|
||||
|
||||
typedef struct SGroupbyOperatorInfo {
|
||||
|
|
|
|||
|
|
@ -40,10 +40,10 @@ SOperatorInfo* createLastrowScanOperator(SLastRowScanPhysiNode* pScanNode, SRead
|
|||
|
||||
pInfo->pTableList = pTableList;
|
||||
pInfo->readHandle = *readHandle;
|
||||
pInfo->pRes = createResDataBlock(pScanNode->node.pOutputDataBlockDesc);
|
||||
pInfo->pRes = createResDataBlock(pScanNode->scan.node.pOutputDataBlockDesc);
|
||||
|
||||
int32_t numOfCols = 0;
|
||||
pInfo->pColMatchInfo = extractColMatchInfo(pScanNode->pScanCols, pScanNode->node.pOutputDataBlockDesc, &numOfCols,
|
||||
pInfo->pColMatchInfo = extractColMatchInfo(pScanNode->scan.pScanCols, pScanNode->scan.node.pOutputDataBlockDesc, &numOfCols,
|
||||
COL_MATCH_FROM_COL_ID);
|
||||
int32_t code = extractTargetSlotId(pInfo->pColMatchInfo, pTaskInfo, &pInfo->pSlotIds);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
|
|
@ -53,10 +53,10 @@ SOperatorInfo* createLastrowScanOperator(SLastRowScanPhysiNode* pScanNode, SRead
|
|||
tsdbLastRowReaderOpen(readHandle->vnode, LASTROW_RETRIEVE_TYPE_SINGLE, pTableList, taosArrayGetSize(pInfo->pColMatchInfo),
|
||||
&pInfo->pLastrowReader);
|
||||
|
||||
if (pScanNode->pScanPseudoCols != NULL) {
|
||||
if (pScanNode->scan.pScanPseudoCols != NULL) {
|
||||
SExprSupp* pPseudoExpr = &pInfo->pseudoExprSup;
|
||||
|
||||
pPseudoExpr->pExprInfo = createExprInfo(pScanNode->pScanPseudoCols, NULL, &pPseudoExpr->numOfExprs);
|
||||
pPseudoExpr->pExprInfo = createExprInfo(pScanNode->scan.pScanPseudoCols, NULL, &pPseudoExpr->numOfExprs);
|
||||
pPseudoExpr->pCtx = createSqlFunctionCtx(pPseudoExpr->pExprInfo, pPseudoExpr->numOfExprs, &pPseudoExpr->rowEntryInfoOffset);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -44,13 +44,6 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
|
|||
goto _error;
|
||||
}
|
||||
|
||||
if (model == OPTR_EXEC_MODEL_STREAM) {
|
||||
(*pTask)->streamInfo.inputQueue = streamQueueOpen();
|
||||
if ((*pTask)->streamInfo.inputQueue == NULL) {
|
||||
goto _error;
|
||||
}
|
||||
}
|
||||
|
||||
SDataSinkMgtCfg cfg = {.maxDataBlockNum = 1000, .maxDataBlockNumPerQuery = 100};
|
||||
code = dsDataSinkMgtInit(&cfg);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
|
|
@ -259,12 +252,14 @@ int32_t qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner) {
|
|||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
int32_t qStreamInput(qTaskInfo_t tinfo, void* pItem) {
|
||||
SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
|
||||
ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM);
|
||||
taosWriteQitem(pTaskInfo->streamInfo.inputQueue->queue, pItem);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
void* qExtractReaderFromStreamScanner(void* scanner) {
|
||||
SStreamScanInfo* pInfo = scanner;
|
||||
|
|
|
|||
|
|
@ -1637,8 +1637,6 @@ static int32_t compressQueryColData(SColumnInfoData* pColRes, int32_t numOfRows,
|
|||
|
||||
int32_t doFillTimeIntervalGapsInResults(struct SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t capacity) {
|
||||
int32_t numOfRows = (int32_t)taosFillResultDataBlock(pFillInfo, pBlock, capacity - pBlock->info.rows);
|
||||
pBlock->info.rows += numOfRows;
|
||||
|
||||
return pBlock->info.rows;
|
||||
}
|
||||
|
||||
|
|
@ -3344,14 +3342,15 @@ static void doHandleRemainBlockForNewGroupImpl(SFillOperatorInfo* pInfo, SResult
|
|||
taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->existNewGroupBlock);
|
||||
|
||||
doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pResultInfo->capacity);
|
||||
pInfo->curGroupId = pInfo->existNewGroupBlock->info.groupId;
|
||||
pInfo->existNewGroupBlock = NULL;
|
||||
*newgroup = true;
|
||||
// *newgroup = true;
|
||||
}
|
||||
|
||||
static void doHandleRemainBlockFromNewGroup(SFillOperatorInfo* pInfo, SResultInfo* pResultInfo, bool* newgroup,
|
||||
SExecTaskInfo* pTaskInfo) {
|
||||
if (taosFillHasMoreResults(pInfo->pFillInfo)) {
|
||||
*newgroup = false;
|
||||
// *newgroup = false;
|
||||
doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, (int32_t)pResultInfo->capacity);
|
||||
if (pInfo->pRes->info.rows > pResultInfo->threshold || (!pInfo->multigroupResult)) {
|
||||
return;
|
||||
|
|
@ -3373,10 +3372,7 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
|
|||
|
||||
blockDataCleanup(pResBlock);
|
||||
|
||||
// todo handle different group data interpolation
|
||||
bool n = false;
|
||||
bool* newgroup = &n;
|
||||
doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, newgroup, pTaskInfo);
|
||||
doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, NULL, pTaskInfo);
|
||||
if (pResBlock->info.rows > pResultInfo->threshold || (!pInfo->multigroupResult && pResBlock->info.rows > 0)) {
|
||||
return pResBlock;
|
||||
}
|
||||
|
|
@ -3384,20 +3380,6 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
|
|||
SOperatorInfo* pDownstream = pOperator->pDownstream[0];
|
||||
while (1) {
|
||||
SSDataBlock* pBlock = pDownstream->fpSet.getNextFn(pDownstream);
|
||||
if (*newgroup) {
|
||||
assert(pBlock != NULL);
|
||||
}
|
||||
|
||||
blockDataUpdateTsWindow(pBlock, pInfo->primaryTsCol);
|
||||
|
||||
if (*newgroup && pInfo->totalInputRows > 0) { // there are already processed current group data block
|
||||
pInfo->existNewGroupBlock = pBlock;
|
||||
*newgroup = false;
|
||||
|
||||
// Fill the previous group data block, before handle the data block of new group.
|
||||
// Close the fill operation for previous group data block
|
||||
taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
|
||||
} else {
|
||||
if (pBlock == NULL) {
|
||||
if (pInfo->totalInputRows == 0) {
|
||||
pOperator->status = OP_EXEC_DONE;
|
||||
|
|
@ -3406,9 +3388,21 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
|
|||
|
||||
taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
|
||||
} else {
|
||||
blockDataUpdateTsWindow(pBlock, pInfo->primaryTsCol);
|
||||
|
||||
if (pInfo->curGroupId == 0 || pInfo->curGroupId == pBlock->info.groupId) {
|
||||
pInfo->curGroupId = pBlock->info.groupId; // the first data block
|
||||
|
||||
pInfo->totalInputRows += pBlock->info.rows;
|
||||
|
||||
taosFillSetStartInfo(pInfo->pFillInfo, pBlock->info.rows, pBlock->info.window.ekey);
|
||||
taosFillSetInputDataBlock(pInfo->pFillInfo, pBlock);
|
||||
} else if (pInfo->curGroupId != pBlock->info.groupId) { // the new group data block
|
||||
pInfo->existNewGroupBlock = pBlock;
|
||||
|
||||
// Fill the previous group data block, before handle the data block of new group.
|
||||
// Close the fill operation for previous group data block
|
||||
taosFillSetStartInfo(pInfo->pFillInfo, 0, pInfo->win.ekey);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3419,17 +3413,17 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
|
|||
if (pResBlock->info.rows > 0) {
|
||||
// 1. The result in current group not reach the threshold of output result, continue
|
||||
// 2. If multiple group results existing in one SSDataBlock is not allowed, return immediately
|
||||
if (pResBlock->info.rows > pResultInfo->threshold || pBlock == NULL || (!pInfo->multigroupResult)) {
|
||||
if (pResBlock->info.rows > pResultInfo->threshold || pBlock == NULL || pInfo->existNewGroupBlock != NULL) {
|
||||
return pResBlock;
|
||||
}
|
||||
|
||||
doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, newgroup, pTaskInfo);
|
||||
if (pResBlock->info.rows > pOperator->resultInfo.threshold || pBlock == NULL) {
|
||||
doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, NULL, pTaskInfo);
|
||||
if (pResBlock->info.rows >= pOperator->resultInfo.threshold || pBlock == NULL) {
|
||||
return pResBlock;
|
||||
}
|
||||
} else if (pInfo->existNewGroupBlock) { // try next group
|
||||
assert(pBlock != NULL);
|
||||
doHandleRemainBlockForNewGroupImpl(pInfo, pResultInfo, newgroup, pTaskInfo);
|
||||
doHandleRemainBlockForNewGroupImpl(pInfo, pResultInfo, NULL, pTaskInfo);
|
||||
if (pResBlock->info.rows > pResultInfo->threshold) {
|
||||
return pResBlock;
|
||||
}
|
||||
|
|
@ -4444,21 +4438,21 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
|
|||
// return NULL;
|
||||
// }
|
||||
|
||||
int32_t code = extractTableSchemaInfo(pHandle, pScanNode->uid, pTaskInfo);
|
||||
int32_t code = extractTableSchemaInfo(pHandle, pScanNode->scan.uid, pTaskInfo);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
pTaskInfo->code = code;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
pTableListInfo->pTableList = taosArrayInit(4, sizeof(STableKeyInfo));
|
||||
if (pScanNode->tableType == TSDB_SUPER_TABLE) {
|
||||
code = vnodeGetAllTableList(pHandle->vnode, pScanNode->uid, pTableListInfo->pTableList);
|
||||
if (pScanNode->scan.tableType == TSDB_SUPER_TABLE) {
|
||||
code = vnodeGetAllTableList(pHandle->vnode, pScanNode->scan.uid, pTableListInfo->pTableList);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
pTaskInfo->code = terrno;
|
||||
return NULL;
|
||||
}
|
||||
} else { // Create one table group.
|
||||
STableKeyInfo info = {.lastKey = 0, .uid = pScanNode->uid, .groupId = 0};
|
||||
STableKeyInfo info = {.lastKey = 0, .uid = pScanNode->scan.uid, .groupId = 0};
|
||||
taosArrayPush(pTableListInfo->pTableList, &info);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -874,22 +874,22 @@ static bool prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_
|
|||
return true;
|
||||
}
|
||||
|
||||
static STimeWindow getSlidingWindow(TSKEY* tsCol, SInterval* pInterval, SDataBlockInfo* pDataBlockInfo, int32_t* pRowIndex) {
|
||||
static STimeWindow getSlidingWindow(TSKEY* tsCol, SInterval* pInterval, SDataBlockInfo* pDataBlockInfo,
|
||||
int32_t* pRowIndex) {
|
||||
SResultRowInfo dumyInfo;
|
||||
dumyInfo.cur.pageId = -1;
|
||||
STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, tsCol[*pRowIndex], pInterval,
|
||||
TSDB_ORDER_ASC);
|
||||
STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, tsCol[*pRowIndex], pInterval, TSDB_ORDER_ASC);
|
||||
STimeWindow endWin = win;
|
||||
STimeWindow preWin = win;
|
||||
while (1) {
|
||||
(*pRowIndex) += getNumOfRowsInTimeWindow(pDataBlockInfo, tsCol, *pRowIndex, endWin.ekey,
|
||||
binarySearchForKey, NULL, TSDB_ORDER_ASC);
|
||||
(*pRowIndex) += getNumOfRowsInTimeWindow(pDataBlockInfo, tsCol, *pRowIndex, endWin.ekey, binarySearchForKey, NULL,
|
||||
TSDB_ORDER_ASC);
|
||||
do {
|
||||
preWin = endWin;
|
||||
getNextTimeWindow(pInterval, &endWin, TSDB_ORDER_ASC);
|
||||
} while (tsCol[(*pRowIndex) - 1] >= endWin.skey);
|
||||
endWin = preWin;
|
||||
if (win.ekey == endWin.ekey || (*pRowIndex) == pDataBlockInfo->rows ) {
|
||||
if (win.ekey == endWin.ekey || (*pRowIndex) == pDataBlockInfo->rows) {
|
||||
win.ekey = endWin.ekey;
|
||||
return win;
|
||||
}
|
||||
|
|
@ -923,7 +923,8 @@ static bool prepareDataScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_t t
|
|||
pInfo->updateWin.ekey = tsCols[*pRowIndex - 1];
|
||||
// win = getActiveTimeWindow(NULL, &dumyInfo, tsCols[*pRowIndex], &pInfo->interval, TSDB_ORDER_ASC);
|
||||
// (*pRowIndex) +=
|
||||
// getNumOfRowsInTimeWindow(&pSDB->info, tsCols, *pRowIndex, win.ekey, binarySearchForKey, NULL, TSDB_ORDER_ASC);
|
||||
// getNumOfRowsInTimeWindow(&pSDB->info, tsCols, *pRowIndex, win.ekey, binarySearchForKey, NULL,
|
||||
// TSDB_ORDER_ASC);
|
||||
}
|
||||
needRead = true;
|
||||
} else if (isStateWindow(pInfo)) {
|
||||
|
|
@ -1177,10 +1178,9 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
|
|||
for (int32_t j = 0; j < blockDataGetNumOfCols(pBlock); ++j) {
|
||||
SColumnInfoData* pResCol = bdGetColumnInfoData(pBlock, j);
|
||||
if (pResCol->info.colId == pColMatchInfo->colId) {
|
||||
|
||||
SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId);
|
||||
colDataAssign(pDst, pResCol, pBlock->info.rows, &pInfo->pRes->info);
|
||||
// taosArraySet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId, pResCol);
|
||||
// taosArraySet(pInfo->pRes->pDataBlock, pColMatchInfo->targetSlotId, pResCol);
|
||||
colExists = true;
|
||||
break;
|
||||
}
|
||||
|
|
@ -1193,8 +1193,6 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
|
|||
}
|
||||
}
|
||||
|
||||
taosArrayDestroy(pBlock->pDataBlock);
|
||||
|
||||
ASSERT(pInfo->pRes->pDataBlock != NULL);
|
||||
|
||||
// currently only the tbname pseudo column
|
||||
|
|
@ -1202,12 +1200,14 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
|
|||
int32_t code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes,
|
||||
GET_TASKID(pTaskInfo));
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
blockDataFreeRes((SSDataBlock*)pBlock);
|
||||
longjmp(pTaskInfo->env, code);
|
||||
}
|
||||
}
|
||||
|
||||
doFilter(pInfo->pCondition, pInfo->pRes);
|
||||
blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);
|
||||
blockDataFreeRes((SSDataBlock*)pBlock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1441,6 +1441,29 @@ SOperatorInfo* createRawScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNo
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static void destroyStreamScanOperatorInfo(void* param, int32_t numOfOutput) {
|
||||
SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;
|
||||
#if 1
|
||||
if (pStreamScan->pTableScanOp && pStreamScan->pTableScanOp->info) {
|
||||
STableScanInfo* pTableScanInfo = pStreamScan->pTableScanOp->info;
|
||||
destroyTableScanOperatorInfo(pTableScanInfo, 1);
|
||||
}
|
||||
#endif
|
||||
if (pStreamScan->tqReader) {
|
||||
tqCloseReader(pStreamScan->tqReader);
|
||||
}
|
||||
if (pStreamScan->pColMatchInfo) {
|
||||
taosArrayDestroy(pStreamScan->pColMatchInfo);
|
||||
}
|
||||
updateInfoDestroy(pStreamScan->pUpdateInfo);
|
||||
blockDataDestroy(pStreamScan->pRes);
|
||||
blockDataDestroy(pStreamScan->pUpdateRes);
|
||||
blockDataDestroy(pStreamScan->pPullDataRes);
|
||||
blockDataDestroy(pStreamScan->pDeleteDataRes);
|
||||
taosArrayDestroy(pStreamScan->pBlockLists);
|
||||
taosMemoryFree(pStreamScan);
|
||||
}
|
||||
|
||||
SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,
|
||||
SExecTaskInfo* pTaskInfo, STimeWindowAggSupp* pTwSup, uint64_t queryId,
|
||||
uint64_t taskId) {
|
||||
|
|
@ -1555,8 +1578,8 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
|
|||
pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);
|
||||
pOperator->pTaskInfo = pTaskInfo;
|
||||
|
||||
pOperator->fpSet =
|
||||
createOperatorFpSet(operatorDummyOpenFn, doStreamScan, NULL, NULL, operatorDummyCloseFn, NULL, NULL, NULL);
|
||||
pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doStreamScan, NULL, NULL, destroyStreamScanOperatorInfo,
|
||||
NULL, NULL, NULL);
|
||||
|
||||
return pOperator;
|
||||
|
||||
|
|
|
|||
|
|
@ -71,13 +71,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
|
|||
SPoint point1, point2, point;
|
||||
int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order);
|
||||
|
||||
// set the primary timestamp column value
|
||||
int32_t index = pFillInfo->numOfCurrent;
|
||||
SColumnInfoData* pCol0 = taosArrayGet(pBlock->pDataBlock, pFillInfo->tsSlotId);
|
||||
char* val = colDataGetData(pCol0, index);
|
||||
|
||||
// set the primary timestamp value
|
||||
*(TSKEY*)val = pFillInfo->currentKey;
|
||||
// set the primary timestamp column value
|
||||
int32_t index = pBlock->info.rows;
|
||||
|
||||
// set the other values
|
||||
if (pFillInfo->type == TSDB_FILL_PREV) {
|
||||
|
|
@ -92,7 +87,7 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
|
|||
SColumnInfoData* pDstColInfoData = taosArrayGet(pBlock->pDataBlock, GET_DEST_SLOT_ID(pCol));
|
||||
|
||||
if (pDstColInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
|
||||
colDataAppend(pDstColInfoData, index, (const char*)&ts, false);
|
||||
colDataAppend(pDstColInfoData, index, (const char*)&pFillInfo->currentKey, false);
|
||||
} else {
|
||||
SGroupKeys* pKey = taosArrayGet(p, i);
|
||||
doSetVal(pDstColInfoData, index, pKey);
|
||||
|
|
@ -101,41 +96,51 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
|
|||
} else if (pFillInfo->type == TSDB_FILL_NEXT) {
|
||||
SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->next : pFillInfo->prev;
|
||||
// todo refactor: start from 0 not 1
|
||||
for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) {
|
||||
for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
|
||||
SFillColInfo* pCol = &pFillInfo->pFillCol[i];
|
||||
if (TSDB_COL_IS_TAG(pCol->flag)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
SGroupKeys* pKey = taosArrayGet(p, i);
|
||||
SColumnInfoData* pDstColInfoData = taosArrayGet(pBlock->pDataBlock, GET_DEST_SLOT_ID(pCol));
|
||||
|
||||
if (pDstColInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
|
||||
colDataAppend(pDstColInfoData, index, (const char*)&pFillInfo->currentKey, false);
|
||||
} else {
|
||||
SGroupKeys* pKey = taosArrayGet(p, i);
|
||||
doSetVal(pDstColInfoData, index, pKey);
|
||||
}
|
||||
}
|
||||
} else if (pFillInfo->type == TSDB_FILL_LINEAR) {
|
||||
// TODO : linear interpolation supports NULL value
|
||||
if (outOfBound) {
|
||||
setNullRow(pBlock, pFillInfo->currentKey, index);
|
||||
} else {
|
||||
for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) {
|
||||
for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
|
||||
SFillColInfo* pCol = &pFillInfo->pFillCol[i];
|
||||
if (TSDB_COL_IS_TAG(pCol->flag)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
int32_t srcSlotId = GET_SRC_SLOT_ID(pCol);
|
||||
|
||||
int32_t dstSlotId = GET_DEST_SLOT_ID(pCol);
|
||||
SColumnInfoData* pDstCol = taosArrayGet(pBlock->pDataBlock, dstSlotId);
|
||||
|
||||
int16_t type = pCol->pExpr->base.resSchema.type;
|
||||
int16_t type = pDstCol->info.type;
|
||||
if (type == TSDB_DATA_TYPE_TIMESTAMP) {
|
||||
colDataAppend(pDstCol, index, (const char*)&pFillInfo->currentKey, false);
|
||||
continue;
|
||||
}
|
||||
|
||||
SGroupKeys* pKey = taosArrayGet(pFillInfo->prev, i);
|
||||
if (IS_VAR_DATA_TYPE(type) || type == TSDB_DATA_TYPE_BOOL || pKey->isNull) {
|
||||
colDataAppendNULL(pDstCol, index);
|
||||
continue;
|
||||
}
|
||||
|
||||
SGroupKeys* pKey1 = taosArrayGet(pFillInfo->prev, 0);
|
||||
SGroupKeys* pKey1 = taosArrayGet(pFillInfo->prev, pFillInfo->tsSlotId);
|
||||
|
||||
int64_t prevTs = *(int64_t*)pKey1->pData;
|
||||
int32_t srcSlotId = GET_SRC_SLOT_ID(pCol);
|
||||
|
||||
SColumnInfoData* pSrcCol = taosArrayGet(pSrcBlock->pDataBlock, srcSlotId);
|
||||
char* data = colDataGetData(pSrcCol, pFillInfo->index);
|
||||
|
|
@ -153,7 +158,7 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
|
|||
} else if (pFillInfo->type == TSDB_FILL_NULL) { // fill with NULL
|
||||
setNullRow(pBlock, pFillInfo->currentKey, index);
|
||||
} else { // fill with user specified value for each column
|
||||
for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) {
|
||||
for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
|
||||
SFillColInfo* pCol = &pFillInfo->pFillCol[i];
|
||||
if (TSDB_COL_IS_TAG(pCol->flag) /* || IS_VAR_DATA_TYPE(pCol->schema.type)*/) {
|
||||
continue;
|
||||
|
|
@ -176,6 +181,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
|
|||
colDataAppend(pDst, index, (char*)&v, false);
|
||||
} else if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
|
||||
colDataAppend(pDst, index, (const char*)&pFillInfo->currentKey, false);
|
||||
} else { // varchar/nchar data
|
||||
colDataAppendNULL(pDst, index);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -184,6 +191,7 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
|
|||
SInterval* pInterval = &pFillInfo->interval;
|
||||
pFillInfo->currentKey =
|
||||
taosTimeAdd(pFillInfo->currentKey, pInterval->sliding * step, pInterval->slidingUnit, pInterval->precision);
|
||||
pBlock->info.rows += 1;
|
||||
pFillInfo->numOfCurrent++;
|
||||
}
|
||||
|
||||
|
|
@ -234,8 +242,7 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SArray
|
|||
static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t outputRows) {
|
||||
pFillInfo->numOfCurrent = 0;
|
||||
|
||||
// todo make sure the first column is always the primary timestamp column?
|
||||
SColumnInfoData* pTsCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, 0);
|
||||
SColumnInfoData* pTsCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->tsSlotId);
|
||||
|
||||
int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order);
|
||||
bool ascFill = FILL_IS_ASC_FILL(pFillInfo);
|
||||
|
|
@ -267,6 +274,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
|
|||
}
|
||||
} else {
|
||||
assert(pFillInfo->currentKey == ts);
|
||||
int32_t index = pBlock->info.rows;
|
||||
|
||||
if (pFillInfo->type == TSDB_FILL_NEXT && (pFillInfo->index + 1) < pFillInfo->numOfRows) {
|
||||
int32_t nextRowIndex = pFillInfo->index + 1;
|
||||
|
|
@ -290,24 +298,24 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
|
|||
if (i == 0 || (/*pCol->functionId != FUNCTION_COUNT &&*/ !colDataIsNull_s(pSrc, pFillInfo->index)) /*||
|
||||
(pCol->functionId == FUNCTION_COUNT && GET_INT64_VAL(src) != 0)*/) {
|
||||
bool isNull = colDataIsNull_s(pSrc, pFillInfo->index);
|
||||
colDataAppend(pDst, pFillInfo->numOfCurrent, src, isNull);
|
||||
colDataAppend(pDst, index, src, isNull);
|
||||
saveColData(pFillInfo->prev, i, src, isNull);
|
||||
} else { // i > 0 and data is null , do interpolation
|
||||
if (pFillInfo->type == TSDB_FILL_PREV) {
|
||||
SGroupKeys* pKey = taosArrayGet(pFillInfo->prev, i);
|
||||
doSetVal(pDst, pFillInfo->numOfCurrent, pKey);
|
||||
doSetVal(pDst, index, pKey);
|
||||
} else if (pFillInfo->type == TSDB_FILL_LINEAR) {
|
||||
bool isNull = colDataIsNull_s(pSrc, pFillInfo->index);
|
||||
colDataAppend(pDst, pFillInfo->numOfCurrent, src, isNull);
|
||||
colDataAppend(pDst, index, src, isNull);
|
||||
saveColData(pFillInfo->prev, i, src, isNull);
|
||||
} else if (pFillInfo->type == TSDB_FILL_NULL) {
|
||||
colDataAppendNULL(pDst, pFillInfo->numOfCurrent);
|
||||
colDataAppendNULL(pDst, index);
|
||||
} else if (pFillInfo->type == TSDB_FILL_NEXT) {
|
||||
SGroupKeys* pKey = taosArrayGet(pFillInfo->next, i);
|
||||
doSetVal(pDst, pFillInfo->numOfCurrent, pKey);
|
||||
doSetVal(pDst, index, pKey);
|
||||
} else {
|
||||
SVariant* pVar = &pFillInfo->pFillCol[i].fillVal;
|
||||
colDataAppend(pDst, pFillInfo->numOfCurrent, (char*)&pVar->i, false);
|
||||
colDataAppend(pDst, index, (char*)&pVar->i, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -318,6 +326,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
|
|||
pFillInfo->currentKey =
|
||||
taosTimeAdd(pFillInfo->currentKey, pInterval->sliding * step, pInterval->slidingUnit, pInterval->precision);
|
||||
|
||||
pBlock->info.rows += 1;
|
||||
pFillInfo->index += 1;
|
||||
pFillInfo->numOfCurrent += 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1537,7 +1537,6 @@ void destroyStreamFinalIntervalOperatorInfo(void* param, int32_t numOfOutput) {
|
|||
for (int32_t i = 0; i < size; i++) {
|
||||
SOperatorInfo* pChildOp = taosArrayGetP(pInfo->pChildren, i);
|
||||
destroyStreamFinalIntervalOperatorInfo(pChildOp->info, numOfOutput);
|
||||
taosMemoryFreeClear(pChildOp->info);
|
||||
taosMemoryFreeClear(pChildOp);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -402,7 +402,6 @@ typedef struct SGroupKeyInfo {
|
|||
(x) += step; \
|
||||
} while (0)
|
||||
|
||||
|
||||
#define STATE_COMP(_op, _lval, _param) STATE_COMP_IMPL(_op, _lval, GET_STATE_VAL(_param))
|
||||
|
||||
#define GET_STATE_VAL(param) ((param.nType == TSDB_DATA_TYPE_BIGINT) ? (param.i) : (param.d))
|
||||
|
|
@ -986,7 +985,7 @@ int32_t avgFunctionMerge(SqlFunctionCtx* pCtx) {
|
|||
|
||||
int32_t start = pInput->startRowIndex;
|
||||
|
||||
for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
char* data = colDataGetData(pCol, i);
|
||||
SAvgRes* pInputInfo = (SAvgRes*)varDataVal(data);
|
||||
avgTransferInfo(pInputInfo, pInfo);
|
||||
|
|
@ -2559,7 +2558,7 @@ int32_t apercentileFunctionMerge(SqlFunctionCtx* pCtx) {
|
|||
|
||||
int32_t start = pInput->startRowIndex;
|
||||
|
||||
for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
char* data = colDataGetData(pCol, i);
|
||||
SAPercentileInfo* pInputInfo = (SAPercentileInfo*)varDataVal(data);
|
||||
apercentileTransferInfo(pInputInfo, pInfo);
|
||||
|
|
@ -2925,7 +2924,7 @@ static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx* pCtx, bool isFirstQuer
|
|||
int32_t start = pInput->startRowIndex;
|
||||
int32_t numOfElems = 0;
|
||||
|
||||
for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
char* data = colDataGetData(pCol, i);
|
||||
SFirstLastRes* pInputInfo = (SFirstLastRes*)varDataVal(data);
|
||||
firstLastTransferInfo(pCtx, pInputInfo, pInfo, isFirstQuery);
|
||||
|
|
@ -2951,7 +2950,7 @@ int32_t firstLastFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
|
|||
pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;
|
||||
|
||||
SFirstLastRes* pRes = GET_ROWCELL_INTERBUF(pResInfo);
|
||||
colDataAppend(pCol, pBlock->info.rows, pRes->buf, pRes->isNull||pResInfo->isNullRes);
|
||||
colDataAppend(pCol, pBlock->info.rows, pRes->buf, pRes->isNull || pResInfo->isNullRes);
|
||||
|
||||
// handle selectivity
|
||||
STuplePos* pTuplePos = (STuplePos*)(pRes->buf + pRes->bytes + sizeof(TSKEY));
|
||||
|
|
@ -3763,7 +3762,7 @@ int32_t spreadFunctionMerge(SqlFunctionCtx* pCtx) {
|
|||
|
||||
int32_t start = pInput->startRowIndex;
|
||||
|
||||
for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
char* data = colDataGetData(pCol, i);
|
||||
SSpreadInfo* pInputInfo = (SSpreadInfo*)varDataVal(data);
|
||||
spreadTransferInfo(pInputInfo, pInfo);
|
||||
|
|
@ -3935,7 +3934,7 @@ int32_t elapsedFunctionMerge(SqlFunctionCtx* pCtx) {
|
|||
|
||||
int32_t start = pInput->startRowIndex;
|
||||
|
||||
for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
char* data = colDataGetData(pCol, i);
|
||||
SElapsedInfo* pInputInfo = (SElapsedInfo*)varDataVal(data);
|
||||
elapsedTransferInfo(pInputInfo, pInfo);
|
||||
|
|
@ -4200,13 +4199,9 @@ static int32_t histogramFunctionImpl(SqlFunctionCtx* pCtx, bool isPartial) {
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t histogramFunction(SqlFunctionCtx* pCtx) {
|
||||
return histogramFunctionImpl(pCtx, false);
|
||||
}
|
||||
int32_t histogramFunction(SqlFunctionCtx* pCtx) { return histogramFunctionImpl(pCtx, false); }
|
||||
|
||||
int32_t histogramFunctionPartial(SqlFunctionCtx* pCtx) {
|
||||
return histogramFunctionImpl(pCtx, true);
|
||||
}
|
||||
int32_t histogramFunctionPartial(SqlFunctionCtx* pCtx) { return histogramFunctionImpl(pCtx, true); }
|
||||
|
||||
static void histogramTransferInfo(SHistoFuncInfo* pInput, SHistoFuncInfo* pOutput) {
|
||||
pOutput->normalized = pInput->normalized;
|
||||
|
|
@ -4228,7 +4223,7 @@ int32_t histogramFunctionMerge(SqlFunctionCtx* pCtx) {
|
|||
|
||||
int32_t start = pInput->startRowIndex;
|
||||
|
||||
for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
char* data = colDataGetData(pCol, i);
|
||||
SHistoFuncInfo* pInputInfo = (SHistoFuncInfo*)varDataVal(data);
|
||||
histogramTransferInfo(pInputInfo, pInfo);
|
||||
|
|
@ -4449,7 +4444,7 @@ int32_t hllFunctionMerge(SqlFunctionCtx* pCtx) {
|
|||
|
||||
int32_t start = pInput->startRowIndex;
|
||||
|
||||
for(int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
|
||||
char* data = colDataGetData(pCol, i);
|
||||
SHLLInfo* pInputInfo = (SHLLInfo*)varDataVal(data);
|
||||
hllTransferInfo(pInputInfo, pInfo);
|
||||
|
|
@ -6019,7 +6014,6 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) {
|
|||
char* data = colDataGetData(pInputCol, i);
|
||||
TSKEY cts = getRowPTs(pInput->pPTS, i);
|
||||
if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
|
||||
|
||||
if (colDataIsNull_s(pInputCol, i)) {
|
||||
pInfo->isNull = true;
|
||||
} else {
|
||||
|
|
@ -6032,9 +6026,6 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) {
|
|||
}
|
||||
|
||||
pInfo->ts = cts;
|
||||
pInfo->hasResult = true;
|
||||
pResInfo->numOfRes = 1;
|
||||
|
||||
if (pCtx->subsidiaries.num > 0) {
|
||||
STuplePos* pTuplePos = (STuplePos*)(pInfo->buf + bytes + sizeof(TSKEY));
|
||||
if (!pInfo->hasResult) {
|
||||
|
|
@ -6043,6 +6034,8 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) {
|
|||
copyTupleData(pCtx, i, pCtx->pSrcBlock, pTuplePos);
|
||||
}
|
||||
}
|
||||
|
||||
pInfo->hasResult = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -296,8 +296,8 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
|
|||
|
||||
switch (call->callType) {
|
||||
case TSDB_UDF_CALL_SCALA_PROC: {
|
||||
tDeleteSSDataBlock(&call->block);
|
||||
tDeleteSSDataBlock(&subRsp->resultData);
|
||||
blockDataFreeRes(&call->block);
|
||||
blockDataFreeRes(&subRsp->resultData);
|
||||
break;
|
||||
}
|
||||
case TSDB_UDF_CALL_AGG_INIT: {
|
||||
|
|
@ -305,7 +305,7 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
|
|||
break;
|
||||
}
|
||||
case TSDB_UDF_CALL_AGG_PROC: {
|
||||
tDeleteSSDataBlock(&call->block);
|
||||
blockDataFreeRes(&call->block);
|
||||
freeUdfInterBuf(&subRsp->resultBuf);
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1470,9 +1470,36 @@ static int32_t jsonToPhysiScanNode(const SJson* pJson, void* pObj) {
|
|||
return code;
|
||||
}
|
||||
|
||||
static int32_t physiTagScanNodeToJson(const void* pObj, SJson* pJson) { return physiScanNodeToJson(pObj, pJson); }
|
||||
static const char* jkLastRowScanPhysiPlanGroupTags = "GroupTags";
|
||||
static const char* jkLastRowScanPhysiPlanGroupSort = "GroupSort";
|
||||
|
||||
static int32_t jsonToPhysiTagScanNode(const SJson* pJson, void* pObj) { return jsonToPhysiScanNode(pJson, pObj); }
|
||||
static int32_t physiLastRowScanNodeToJson(const void* pObj, SJson* pJson) {
|
||||
const SLastRowScanPhysiNode* pNode = (const SLastRowScanPhysiNode*)pObj;
|
||||
|
||||
int32_t code = physiScanNodeToJson(pObj, pJson);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = nodeListToJson(pJson, jkLastRowScanPhysiPlanGroupTags, pNode->pGroupTags);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = tjsonAddBoolToObject(pJson, jkLastRowScanPhysiPlanGroupSort, pNode->groupSort);
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
static int32_t jsonToPhysiLastRowScanNode(const SJson* pJson, void* pObj) {
|
||||
SLastRowScanPhysiNode* pNode = (SLastRowScanPhysiNode*)pObj;
|
||||
|
||||
int32_t code = jsonToPhysiScanNode(pJson, pObj);
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = jsonToNodeList(pJson, jkLastRowScanPhysiPlanGroupTags, &pNode->pGroupTags);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = tjsonGetBoolValue(pJson, jkLastRowScanPhysiPlanGroupSort, &pNode->groupSort);
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
static const char* jkTableScanPhysiPlanScanCount = "ScanCount";
|
||||
static const char* jkTableScanPhysiPlanReverseScanCount = "ReverseScanCount";
|
||||
|
|
@ -4317,8 +4344,9 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) {
|
|||
return logicPlanToJson(pObj, pJson);
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
|
||||
case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:
|
||||
return physiScanNodeToJson(pObj, pJson);
|
||||
case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:
|
||||
return physiTagScanNodeToJson(pObj, pJson);
|
||||
return physiLastRowScanNodeToJson(pObj, pJson);
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
|
||||
|
|
@ -4463,8 +4491,10 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) {
|
|||
return jsonToLogicPlan(pJson, pObj);
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
|
||||
case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:
|
||||
return jsonToPhysiScanNode(pJson, pObj);
|
||||
case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:
|
||||
return jsonToPhysiTagScanNode(pJson, pObj);
|
||||
|
||||
return jsonToPhysiLastRowScanNode(pJson, pObj);
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
|
||||
case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
|
||||
case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
|
||||
|
|
|
|||
|
|
@ -1178,6 +1178,13 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
|
|||
TSKEY tsKey = TD_ROW_KEY(row);
|
||||
checkTimestamp(pDataBlocks, (const char*)&tsKey);
|
||||
}
|
||||
|
||||
if (i < spd->numOfBound - 1) {
|
||||
NEXT_VALID_TOKEN(pCxt->pSql, sToken);
|
||||
if (TK_NK_COMMA != sToken.type) {
|
||||
return buildSyntaxErrMsg(&pCxt->msg, ", expected", sToken.z);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!isParseBindParam) {
|
||||
|
|
|
|||
|
|
@ -5954,7 +5954,8 @@ static int32_t buildAddColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, S
|
|||
|
||||
pReq->type = pStmt->dataType.type;
|
||||
pReq->flags = COL_SMA_ON;
|
||||
pReq->bytes = pStmt->dataType.bytes;
|
||||
// pReq->bytes = pStmt->dataType.bytes;
|
||||
pReq->bytes = calcTypeBytes(pStmt->dataType);
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -481,8 +481,6 @@ static ENodeType getScanOperatorType(EScanType scanType) {
|
|||
return QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN;
|
||||
case SCAN_TYPE_BLOCK_INFO:
|
||||
return QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN;
|
||||
case SCAN_TYPE_LAST_ROW:
|
||||
return QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
@ -502,6 +500,24 @@ static int32_t createSimpleScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSub
|
|||
return createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, pScan, pPhyNode);
|
||||
}
|
||||
|
||||
static int32_t createLastRowScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan, SScanLogicNode* pScanLogicNode,
|
||||
SPhysiNode** pPhyNode) {
|
||||
SLastRowScanPhysiNode* pScan =
|
||||
(SLastRowScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode, QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN);
|
||||
if (NULL == pScan) {
|
||||
return TSDB_CODE_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
pScan->pGroupTags = nodesCloneList(pScanLogicNode->pGroupTags);
|
||||
if (NULL != pScanLogicNode->pGroupTags && NULL == pScan->pGroupTags) {
|
||||
nodesDestroyNode((SNode*)pScan);
|
||||
return TSDB_CODE_OUT_OF_MEMORY;
|
||||
}
|
||||
pScan->groupSort = pScanLogicNode->groupSort;
|
||||
|
||||
return createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pScan, pPhyNode);
|
||||
}
|
||||
|
||||
static int32_t createTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan, SScanLogicNode* pScanLogicNode,
|
||||
SPhysiNode** pPhyNode) {
|
||||
STableScanPhysiNode* pTableScan = (STableScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode,
|
||||
|
|
@ -583,8 +599,9 @@ static int32_t createScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubplan,
|
|||
switch (pScanLogicNode->scanType) {
|
||||
case SCAN_TYPE_TAG:
|
||||
case SCAN_TYPE_BLOCK_INFO:
|
||||
case SCAN_TYPE_LAST_ROW:
|
||||
return createSimpleScanPhysiNode(pCxt, pSubplan, pScanLogicNode, pPhyNode);
|
||||
case SCAN_TYPE_LAST_ROW:
|
||||
return createLastRowScanPhysiNode(pCxt, pSubplan, pScanLogicNode, pPhyNode);
|
||||
case SCAN_TYPE_TABLE:
|
||||
return createTableScanPhysiNode(pCxt, pSubplan, pScanLogicNode, pPhyNode);
|
||||
case SCAN_TYPE_SYSTEM_TABLE:
|
||||
|
|
|
|||
|
|
@ -364,6 +364,8 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
|
|||
pMergeWindow->node.pTargets = NULL;
|
||||
SNodeList* pChildren = pMergeWindow->node.pChildren;
|
||||
pMergeWindow->node.pChildren = NULL;
|
||||
SNode* pConditions = pMergeWindow->node.pConditions;
|
||||
pMergeWindow->node.pConditions = NULL;
|
||||
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
SWindowLogicNode* pPartWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow);
|
||||
|
|
@ -373,6 +375,7 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic
|
|||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
pMergeWindow->node.pTargets = pTargets;
|
||||
pMergeWindow->node.pConditions = pConditions;
|
||||
pPartWin->node.pChildren = pChildren;
|
||||
splSetParent((SLogicNode*)pPartWin);
|
||||
code = stbSplRewriteFuns(pFunc, &pPartWin->pFuncs, &pMergeWindow->pFuncs);
|
||||
|
|
|
|||
|
|
@ -108,6 +108,8 @@ TEST_F(PlanBasicTest, lastRowFunc) {
|
|||
|
||||
run("SELECT LAST_ROW(c1) FROM st1");
|
||||
|
||||
run("SELECT LAST_ROW(c1) FROM st1 PARTITION BY TBNAME");
|
||||
|
||||
run("SELECT LAST_ROW(c1), SUM(c3) FROM t1");
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -36,6 +36,8 @@ TEST_F(PlanSubqeuryTest, basic) {
|
|||
run("SELECT * FROM (SELECT NOW() FROM t1)");
|
||||
|
||||
run("SELECT NOW() FROM (SELECT * FROM t1) ORDER BY ts");
|
||||
|
||||
run("SELECT * FROM (SELECT AVG(c1) a FROM st1 INTERVAL(10s)) WHERE a > 1");
|
||||
}
|
||||
|
||||
TEST_F(PlanSubqeuryTest, doubleGroupBy) {
|
||||
|
|
|
|||
|
|
@ -1477,7 +1477,8 @@ void vectorAssign(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut,
|
|||
|
||||
pOut->numOfRows = pLeft->numOfRows;
|
||||
|
||||
if (IS_HELPER_NULL(pRight->columnData, 0)) {
|
||||
// if (IS_HELPER_NULL(pRight->columnData, 0)) {
|
||||
if(colDataIsNull_s(pRight->columnData, 0)){
|
||||
for (int32_t i = 0; i < pOut->numOfRows; ++i) {
|
||||
colDataAppend(pOutputCol, i, NULL, true);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ void streamFreeQitem(SStreamQueueItem* data) {
|
|||
blockDataDestroy(((SStreamTrigger*)data)->pBlock);
|
||||
taosFreeQitem(data);
|
||||
} else if (type == STREAM_INPUT__DATA_BLOCK || type == STREAM_INPUT__DATA_RETRIEVE) {
|
||||
taosArrayDestroyEx(((SStreamDataBlock*)data)->blocks, (FDelete)tDeleteSSDataBlock);
|
||||
taosArrayDestroyEx(((SStreamDataBlock*)data)->blocks, (FDelete)blockDataFreeRes);
|
||||
taosFreeQitem(data);
|
||||
} else if (type == STREAM_INPUT__DATA_SUBMIT) {
|
||||
streamDataSubmitRefDec((SStreamDataSubmit*)data);
|
||||
|
|
|
|||
|
|
@ -313,7 +313,7 @@ int32_t streamDispatch(SStreamTask* pTask, SMsgCb* pMsgCb) {
|
|||
atomic_store_8(&pTask->outputStatus, TASK_OUTPUT_STATUS__NORMAL);
|
||||
return -1;
|
||||
}
|
||||
taosArrayDestroyEx(pBlock->blocks, (FDelete)tDeleteSSDataBlock);
|
||||
taosArrayDestroyEx(pBlock->blocks, (FDelete)blockDataFreeRes);
|
||||
taosFreeQitem(pBlock);
|
||||
|
||||
tmsgSendReq(pEpSet, &dispatchMsg);
|
||||
|
|
|
|||
|
|
@ -74,7 +74,6 @@ static int32_t streamTaskExecImpl(SStreamTask* pTask, void* data, SArray* pRes)
|
|||
}
|
||||
|
||||
static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
|
||||
while (1) {
|
||||
int32_t cnt = 0;
|
||||
void* data = NULL;
|
||||
while (1) {
|
||||
|
|
@ -99,17 +98,18 @@ static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
|
|||
}
|
||||
}
|
||||
}
|
||||
if (data == NULL) break;
|
||||
|
||||
qDebug("stream task %d exec begin, batch msg: %d", pTask->taskId, cnt);
|
||||
streamTaskExecImpl(pTask, data, pRes);
|
||||
qDebug("stream task %d exec end", pTask->taskId);
|
||||
|
||||
if (pTask->taskStatus == TASK_STATUS__DROPPING) {
|
||||
taosArrayDestroyEx(pRes, (FDelete)tDeleteSSDataBlock);
|
||||
if (data) streamFreeQitem(data);
|
||||
taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (data == NULL) return pRes;
|
||||
|
||||
qDebug("stream task %d exec begin, msg batch: %d", pTask->taskId, cnt);
|
||||
streamTaskExecImpl(pTask, data, pRes);
|
||||
qDebug("stream task %d exec end", pTask->taskId);
|
||||
|
||||
if (taosArrayGetSize(pRes) != 0) {
|
||||
SStreamDataBlock* qRes = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM);
|
||||
if (qRes == NULL) {
|
||||
|
|
@ -121,7 +121,7 @@ static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
|
|||
qRes->blocks = pRes;
|
||||
if (streamTaskOutput(pTask, qRes) < 0) {
|
||||
/*streamQueueProcessFail(pTask->inputQueue);*/
|
||||
taosArrayDestroyEx(pRes, (FDelete)tDeleteSSDataBlock);
|
||||
taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
|
||||
taosFreeQitem(qRes);
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -130,7 +130,6 @@ static SArray* streamExecForQall(SStreamTask* pTask, SArray* pRes) {
|
|||
}
|
||||
|
||||
streamFreeQitem(data);
|
||||
}
|
||||
return pRes;
|
||||
}
|
||||
|
||||
|
|
@ -155,7 +154,7 @@ int32_t streamExec(SStreamTask* pTask, SMsgCb* pMsgCb) {
|
|||
pRes = streamExecForQall(pTask, pRes);
|
||||
if (pRes == NULL) goto FAIL;
|
||||
|
||||
taosArrayDestroyEx(pRes, (FDelete)tDeleteSSDataBlock);
|
||||
taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
|
||||
atomic_store_8(&pTask->execStatus, TASK_EXEC_STATUS__IDLE);
|
||||
qDebug("stream exec, return result");
|
||||
return 0;
|
||||
|
|
@ -163,7 +162,7 @@ int32_t streamExec(SStreamTask* pTask, SMsgCb* pMsgCb) {
|
|||
continue;
|
||||
} else if (execStatus == TASK_EXEC_STATUS__EXECUTING) {
|
||||
ASSERT(taosArrayGetSize(pRes) == 0);
|
||||
taosArrayDestroyEx(pRes, (FDelete)tDeleteSSDataBlock);
|
||||
taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes);
|
||||
return 0;
|
||||
} else {
|
||||
ASSERT(0);
|
||||
|
|
@ -171,6 +170,11 @@ int32_t streamExec(SStreamTask* pTask, SMsgCb* pMsgCb) {
|
|||
}
|
||||
FAIL:
|
||||
if (pRes) taosArrayDestroy(pRes);
|
||||
if (pTask->taskStatus == TASK_STATUS__DROPPING) {
|
||||
tFreeSStreamTask(pTask);
|
||||
return 0;
|
||||
} else {
|
||||
atomic_store_8(&pTask->execStatus, TASK_EXEC_STATUS__IDLE);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -163,6 +163,6 @@ void tFreeSStreamTask(SStreamTask* pTask) {
|
|||
streamQueueClose(pTask->inputQueue);
|
||||
streamQueueClose(pTask->outputQueue);
|
||||
if (pTask->exec.qmsg) taosMemoryFree(pTask->exec.qmsg);
|
||||
qDestroyTask(pTask->exec.executor);
|
||||
if (pTask->exec.executor) qDestroyTask(pTask->exec.executor);
|
||||
taosMemoryFree(pTask);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -382,7 +382,7 @@ class TDDnode:
|
|||
|
||||
if self.valgrind == 0:
|
||||
if platform.system().lower() == 'windows':
|
||||
cmd = "mintty -h never -w hide %s -c %s" % (
|
||||
cmd = "mintty -h never %s -c %s" % (
|
||||
binPath, self.cfgDir)
|
||||
else:
|
||||
cmd = "nohup %s -c %s > /dev/null 2>&1 & " % (
|
||||
|
|
@ -391,7 +391,7 @@ class TDDnode:
|
|||
valgrindCmdline = "valgrind --log-file=\"%s/../log/valgrind.log\" --tool=memcheck --leak-check=full --show-reachable=no --track-origins=yes --show-leak-kinds=all -v --workaround-gcc296-bugs=yes"%self.cfgDir
|
||||
|
||||
if platform.system().lower() == 'windows':
|
||||
cmd = "mintty -h never -w hide %s %s -c %s" % (
|
||||
cmd = "mintty -h never %s %s -c %s" % (
|
||||
valgrindCmdline, binPath, self.cfgDir)
|
||||
else:
|
||||
cmd = "nohup %s %s -c %s 2>&1 & " % (
|
||||
|
|
@ -518,7 +518,7 @@ class TDDnode:
|
|||
|
||||
if self.running != 0:
|
||||
if platform.system().lower() == 'windows':
|
||||
os.system("wmic process where \"name='taosd.exe' and CommandLine like '%%dnode%d%%'\" get processId | xargs echo | awk '{print $2}' | xargs taskkill -f -pid"%self.index)
|
||||
psCmd = "for /f %a in ('wmic process where \"name='taosd.exe' and CommandLine like '%%dnode%d%%'\" get processId ^| xargs echo ^| awk ^'{print $2}^'') do @(ps | grep %a | awk '{print $1}' | xargs kill -INT )" % (self.index)
|
||||
else:
|
||||
psCmd = "ps -ef|grep -w %s| grep dnode%d|grep -v grep | awk '{print $2}'" % (toBeKilled,self.index)
|
||||
processID = subprocess.check_output(
|
||||
|
|
|
|||
|
|
@ -1,21 +0,0 @@
|
|||
system sh/stop_dnodes.sh
|
||||
system sh/deploy.sh -n dnode1 -i 1
|
||||
system sh/cfg.sh -n dnode1 -c wallevel -v 0
|
||||
system sh/exec.sh -n dnode1 -s start
|
||||
sleep 2000
|
||||
sql connect
|
||||
|
||||
print ============= step1
|
||||
sql close
|
||||
print close1
|
||||
sql connect
|
||||
|
||||
print ============= step2
|
||||
sql close
|
||||
sql connect
|
||||
|
||||
print ============= step3
|
||||
sql close
|
||||
sql connect
|
||||
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
system sh/stop_dnodes.sh
|
||||
|
||||
system sh/deploy.sh -n dnode1 -i 1
|
||||
system sh/cfg.sh -n dnode1 -c walLevel -v 2
|
||||
system sh/cfg.sh -n dnode1 -c numOfMnodes -v 1
|
||||
system sh/cfg.sh -n dnode1 -c mnodeEqualVnodeNum -v 4
|
||||
system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 100000
|
||||
system sh/cfg.sh -n dnode1 -c http -v 1
|
||||
system sh/cfg.sh -n dnode1 -c mqtt -v 1
|
||||
|
||||
system sh/exec.sh -n dnode1 -s start
|
||||
|
||||
sleep 2000
|
||||
sql connect
|
||||
sql create database mqttdb;
|
||||
sql create table mqttdb.devices(ts timestamp, value double) tags(name binary(32), model binary(32), serial binary(16), param binary(16), unit binary(16));
|
||||
|
||||
sleep 1000
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
Binary file not shown.
|
|
@ -1,32 +0,0 @@
|
|||
system sh/stop_dnodes.sh
|
||||
system sh/mv_old_data.sh
|
||||
|
||||
print ============== deploy
|
||||
|
||||
system sh/exec.sh -n dnode1 -s start
|
||||
system sh/exec.sh -n dnode2 -s start
|
||||
system sh/exec.sh -n dnode3 -s start
|
||||
|
||||
print =============== step1
|
||||
|
||||
sql use test
|
||||
sql select * from m1
|
||||
|
||||
print $rows points data are retrieved
|
||||
if $rows != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print =============== step 2
|
||||
|
||||
sql select * from t1
|
||||
|
||||
print $rows points data are retrieved
|
||||
if $rows != 7 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
system sh/exec.sh -n dnode2 -s stop -x SIGINT
|
||||
system sh/exec.sh -n dnode3 -s stop -x SIGINT
|
||||
|
|
@ -1,263 +0,0 @@
|
|||
system sh/stop_dnodes.sh
|
||||
system sh/deploy.sh -n dnode1 -i 1
|
||||
system sh/cfg.sh -n dnode1 -c wallevel -v 0
|
||||
system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 1000
|
||||
|
||||
system sh/exec.sh -n dnode1 -s start
|
||||
|
||||
sleep 2000
|
||||
sql connect
|
||||
|
||||
print ============= create database
|
||||
sql create database db cache 2 blocks 4 duration 10 keep 20 minRows 300 maxRows 400 ctime 120 precision 'ms' comp 2 wal 1 replica 1
|
||||
sql show databases
|
||||
if $data00 != db then
|
||||
return -1
|
||||
endi
|
||||
if $data02 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data03 != 0 then
|
||||
return -1
|
||||
endi
|
||||
if $data04 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data06 != 10 then
|
||||
return -1
|
||||
endi
|
||||
if $data07 != 20,20,20 then
|
||||
return -1
|
||||
endi
|
||||
if $data08 != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data09 != 4 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print ============== step name
|
||||
sql_error alter database db name d1
|
||||
sql_error alter database db name d2
|
||||
|
||||
print ============== step ntables
|
||||
sql_error alter database db ntables -1
|
||||
sql_error alter database db ntables 0
|
||||
sql_error alter database db ntables 1
|
||||
sql_error alter database db ntables 10
|
||||
|
||||
print ============== step vgroups
|
||||
sql_error alter database db vgroups -1
|
||||
sql_error alter database db vgroups 0
|
||||
sql_error alter database db vgroups 1
|
||||
sql_error alter database db vgroups 10
|
||||
|
||||
print ============== step replica
|
||||
sql_error alter database db replica 2
|
||||
sql_error alter database db replica 3
|
||||
sql_error alter database db replica 0
|
||||
|
||||
sql alter database db replica 1
|
||||
sql show databases
|
||||
print replica $data4_db
|
||||
if $data4_db != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print ============== step quorum
|
||||
sql show databases
|
||||
print quorum $data5_db
|
||||
if $data5_db != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db quorum 1
|
||||
sql show databases
|
||||
print quorum $data5_db
|
||||
if $data5_db != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql_error alter database db quorum 2
|
||||
|
||||
sql_error alter database db quorum 3
|
||||
|
||||
sql_error alter database db quorum 0
|
||||
sql_error alter database db quorum 4
|
||||
sql_error alter database db quorum 5
|
||||
sql_error alter database db quorum -1
|
||||
|
||||
print ============== step duration
|
||||
sql_error alter database db duration 0
|
||||
sql_error alter database db duration 1
|
||||
sql_error alter database db duration 2
|
||||
sql_error alter database db duration 10
|
||||
sql_error alter database db duration 50
|
||||
sql_error alter database db duration 100
|
||||
|
||||
print ============== step keep
|
||||
sql show databases
|
||||
print keep $data7_db
|
||||
if $data7_db != 20,20,20 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db keep 20
|
||||
sql show databases
|
||||
print keep $data7_db
|
||||
if $data7_db != 20,20,20 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db keep 30
|
||||
sql show databases
|
||||
print keep $data7_db
|
||||
if $data7_db != 30,30,30 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db keep 40
|
||||
sql show databases
|
||||
print keep $data7_db
|
||||
if $data7_db != 40,40,40 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db keep 40,50
|
||||
sql alter database db keep 30,31
|
||||
sql alter database db keep 20
|
||||
sql_error alter database db keep 10.0
|
||||
sql_error alter database db keep 9
|
||||
sql_error alter database db keep 1
|
||||
sql_error alter database db keep 0
|
||||
sql_error alter database db keep -1
|
||||
sql_error alter database db keep 365001
|
||||
|
||||
print ============== step cache
|
||||
sql_error alter database db cache 60
|
||||
sql_error alter database db cache 50
|
||||
sql_error alter database db cache 20
|
||||
sql_error alter database db cache 3
|
||||
sql_error alter database db cache 129
|
||||
sql_error alter database db cache 300
|
||||
sql_error alter database db cache 0
|
||||
sql_error alter database db cache -1
|
||||
|
||||
print ============== step blocks
|
||||
sql show databases
|
||||
print blocks $data9_db
|
||||
if $data9_db != 4 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db blocks 10
|
||||
sql show databases
|
||||
print blocks $data9_db
|
||||
if $data9_db != 10 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db blocks 20
|
||||
sql show databases
|
||||
print blocks $data9_db
|
||||
if $data9_db != 20 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db blocks 30
|
||||
sql show databases
|
||||
print blocks $data9_db
|
||||
if $data9_db != 30 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db blocks 40
|
||||
sql alter database db blocks 30
|
||||
sql alter database db blocks 20
|
||||
sql alter database db blocks 10
|
||||
sql_error alter database db blocks 2
|
||||
sql_error alter database db blocks 1
|
||||
sql_error alter database db blocks 0
|
||||
sql_error alter database db blocks -1
|
||||
sql_error alter database db blocks 10001
|
||||
|
||||
print ============== step minrows
|
||||
sql_error alter database db minrows 1
|
||||
sql_error alter database db minrows 100
|
||||
sql_error alter database db minrows 1000
|
||||
|
||||
print ============== step maxrows
|
||||
sql_error alter database db maxrows 1
|
||||
sql_error alter database db maxrows 100
|
||||
sql_error alter database db maxrows 1000
|
||||
|
||||
print ============== step wallevel
|
||||
sql show databases
|
||||
print wallevel $data12_db
|
||||
if $data12_db != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql_error alter database db wal 1
|
||||
|
||||
|
||||
sql_error alter database db wal 1
|
||||
sql_error alter database db wal 2
|
||||
sql_error alter database db wal 1
|
||||
sql_error alter database db wal 2
|
||||
sql_error alter database db wal 0
|
||||
sql_error alter database db wal 3
|
||||
sql_error alter database db wal 4
|
||||
sql_error alter database db wal -1
|
||||
sql_error alter database db wal 1000
|
||||
|
||||
print ============== step fsync
|
||||
sql_error alter database db fsync 0
|
||||
sql_error alter database db fsync 1
|
||||
sql_error alter database db fsync 3600
|
||||
sql_error alter database db fsync 18000
|
||||
sql_error alter database db fsync 180000
|
||||
sql_error alter database db fsync 180001
|
||||
sql_error alter database db fsync -1
|
||||
|
||||
print ============== step comp
|
||||
sql show databases
|
||||
print comp $data14_db
|
||||
if $data14_db != 2 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db comp 1
|
||||
sql show databases
|
||||
print comp $data14_db
|
||||
if $data14_db != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db comp 2
|
||||
sql show databases
|
||||
print comp $data14_db
|
||||
if $data14_db != 2 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql alter database db comp 0
|
||||
sql show databases
|
||||
print comp $data14_db
|
||||
if $data14_db != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql_error alter database db comp 3
|
||||
sql_error alter database db comp 4
|
||||
sql_error alter database db comp 5
|
||||
sql_error alter database db comp -1
|
||||
|
||||
|
||||
print ============== step precision
|
||||
sql_error alter database db prec 'us'
|
||||
|
||||
print ============== step status
|
||||
sql_error alter database db status 'delete'
|
||||
|
||||
system sh/exec.sh -n dnode1 -s stop -x SIGINT
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
sql connect
|
||||
$x = 1
|
||||
begin:
|
||||
sql reset query cache
|
||||
sleep 1000
|
||||
sql insert into db.tb values(now, $x ) -x begin
|
||||
#print ===> insert successed $x
|
||||
$x = $x + 1
|
||||
goto begin
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
run general/insert/basic.sim
|
||||
run general/insert/insert_drop.sim
|
||||
run general/insert/query_block1_memory.sim
|
||||
run general/insert/query_block2_memory.sim
|
||||
run general/insert/query_block1_file.sim
|
||||
run general/insert/query_block2_file.sim
|
||||
run general/insert/query_file_memory.sim
|
||||
run general/insert/query_multi_file.sim
|
||||
run general/insert/tcp.sim
|
||||
|
|
@ -1,68 +0,0 @@
|
|||
run general/parser/alter.sim
|
||||
run general/parser/alter1.sim
|
||||
run general/parser/alter_stable.sim
|
||||
run general/parser/auto_create_tb.sim
|
||||
run general/parser/auto_create_tb_drop_tb.sim
|
||||
run general/parser/col_arithmetic_operation.sim
|
||||
run general/parser/columnValue.sim
|
||||
run general/parser/commit.sim
|
||||
run general/parser/create_db.sim
|
||||
run general/parser/create_mt.sim
|
||||
run general/parser/create_tb.sim
|
||||
run general/parser/dbtbnameValidate.sim
|
||||
run general/parser/fill.sim
|
||||
run general/parser/fill_stb.sim
|
||||
#run general/parser/fill_us.sim #
|
||||
run general/parser/first_last.sim
|
||||
run general/parser/import_commit1.sim
|
||||
run general/parser/import_commit2.sim
|
||||
run general/parser/import_commit3.sim
|
||||
run general/parser/import_file.sim
|
||||
run general/parser/insert_tb.sim
|
||||
run general/parser/tags_dynamically_specifiy.sim
|
||||
run general/parser/interp.sim
|
||||
run general/parser/lastrow.sim
|
||||
run general/parser/limit.sim
|
||||
run general/parser/limit1.sim
|
||||
run general/parser/limit1_tblocks100.sim
|
||||
run general/parser/limit2.sim
|
||||
run general/parser/mixed_blocks.sim
|
||||
run general/parser/nchar.sim
|
||||
run general/parser/null_char.sim
|
||||
run general/parser/selectResNum.sim
|
||||
run general/parser/select_across_vnodes.sim
|
||||
run general/parser/select_from_cache_disk.sim
|
||||
run general/parser/set_tag_vals.sim
|
||||
run general/parser/single_row_in_tb.sim
|
||||
run general/parser/slimit.sim
|
||||
run general/parser/slimit1.sim
|
||||
run general/parser/slimit_alter_tags.sim
|
||||
run general/parser/tbnameIn.sim
|
||||
run general/parser/join.sim
|
||||
run general/parser/join_multivnode.sim
|
||||
run general/parser/join_manyblocks.sim
|
||||
run general/parser/projection_limit_offset.sim
|
||||
run general/parser/select_with_tags.sim
|
||||
run general/parser/select_distinct_tag.sim
|
||||
run general/parser/groupby.sim
|
||||
run general/parser/tags_filter.sim
|
||||
run general/parser/topbot.sim
|
||||
run general/parser/union.sim
|
||||
run general/parser/constCol.sim
|
||||
run general/parser/where.sim
|
||||
run general/parser/timestamp.sim
|
||||
run general/parser/sliding.sim
|
||||
run general/parser/function.sim
|
||||
run general/parser/stableOp.sim
|
||||
run general/parser/having.sim
|
||||
run general/parser/having_child.sim
|
||||
run general/parser/slimit_alter_tags.sim
|
||||
run general/parser/binary_escapeCharacter.sim
|
||||
run general/parser/between_and.sim
|
||||
run general/parser/last_cache.sim
|
||||
run general/parser/slimit_alter_tags.sim
|
||||
run general/parser/udf.sim
|
||||
run general/parser/udf_dll.sim
|
||||
run general/parser/udf_dll_stable.sim
|
||||
run general/parser/nestquery.sim
|
||||
run general/parser/precision_ns.sim
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
run general/tag/3.sim
|
||||
run general/tag/4.sim
|
||||
run general/tag/5.sim
|
||||
run general/tag/6.sim
|
||||
run general/tag/add.sim
|
||||
run general/tag/bigint.sim
|
||||
run general/tag/binary_binary.sim
|
||||
run general/tag/binary.sim
|
||||
run general/tag/bool_binary.sim
|
||||
run general/tag/bool_int.sim
|
||||
run general/tag/bool.sim
|
||||
run general/tag/change.sim
|
||||
run general/tag/column.sim
|
||||
run general/tag/commit.sim
|
||||
run general/tag/create.sim
|
||||
run general/tag/delete.sim
|
||||
run general/tag/double.sim
|
||||
run general/tag/filter.sim
|
||||
run general/tag/float.sim
|
||||
run general/tag/int_binary.sim
|
||||
run general/tag/int_float.sim
|
||||
run general/tag/int.sim
|
||||
run general/tag/set.sim
|
||||
run general/tag/smallint.sim
|
||||
run general/tag/tinyint.sim
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
run general/table/autocreate.sim
|
||||
run general/table/basic1.sim
|
||||
run general/table/basic2.sim
|
||||
run general/table/basic3.sim
|
||||
run general/table/bigint.sim
|
||||
run general/table/binary.sim
|
||||
run general/table/bool.sim
|
||||
run general/table/column_name.sim
|
||||
run general/table/column_num.sim
|
||||
run general/table/column_value.sim
|
||||
run general/table/column2.sim
|
||||
run general/table/date.sim
|
||||
run general/table/db.table.sim
|
||||
run general/table/delete_reuse1.sim
|
||||
run general/table/delete_reuse2.sim
|
||||
run general/table/delete_writing.sim
|
||||
run general/table/describe.sim
|
||||
run general/table/double.sim
|
||||
run general/table/fill.sim
|
||||
run general/table/float.sim
|
||||
run general/table/int.sim
|
||||
run general/table/limit.sim
|
||||
run general/table/smallint.sim
|
||||
run general/table/table_len.sim
|
||||
run general/table/table.sim
|
||||
run general/table/tinyint.sim
|
||||
run general/table/vgroup.sim
|
||||
|
|
@ -11,17 +11,41 @@
|
|||
./test.sh -f tsim/db/alter_option.sim
|
||||
# ./test.sh -f tsim/db/alter_replica_13.sim
|
||||
# ./test.sh -f tsim/db/alter_replica_31.sim
|
||||
#./test.sh -f tsim/db/alter_tables_d2.sim
|
||||
#./test.sh -f tsim/db/alter_tables_v1.sim
|
||||
#./test.sh -f tsim/db/alter_tables_v4.sim
|
||||
#./test.sh -f tsim/db/alter_vgroups.sim
|
||||
./test.sh -f tsim/db/basic1.sim
|
||||
./test.sh -f tsim/db/basic2.sim
|
||||
./test.sh -f tsim/db/basic3.sim
|
||||
#./test.sh -f tsim/db/basic4.sim
|
||||
#./test.sh -f tsim/db/basic5.sim
|
||||
./test.sh -f tsim/db/basic6.sim
|
||||
./test.sh -f tsim/db/basic7.sim
|
||||
#./test.sh -f tsim/db/commit.sim
|
||||
./test.sh -f tsim/db/create_all_options.sim
|
||||
#./test.sh -f tsim/db/delete_part.sim
|
||||
#./test.sh -f tsim/db/delete_reuse1.sim
|
||||
#./test.sh -f tsim/db/delete_reuse2.sim
|
||||
#./test.sh -f tsim/db/delete_reusevnode.sim
|
||||
#./test.sh -f tsim/db/delete_reusevnode2.sim
|
||||
#./test.sh -f tsim/db/delete_writing1.sim
|
||||
#./test.sh -f tsim/db/delete_writing2.sim
|
||||
#./test.sh -f tsim/db/delete.sim
|
||||
#./test.sh -f tsim/db/delete2.sim
|
||||
#./test.sh -f tsim/db/dropvnodes.sim
|
||||
./test.sh -f tsim/db/error1.sim
|
||||
#./test.sh -f tsim/db/keep.sim
|
||||
#./test.sh -f tsim/db/len.sim
|
||||
#./test.sh -f tsim/db/nosuchfile.sim
|
||||
#./test.sh -f tsim/db/repeat.sim
|
||||
#./test.sh -f tsim/db/show_create_db.sim
|
||||
#./test.sh -f tsim/db/show_create_table.sim
|
||||
#./test.sh -f tsim/db/tables.sim
|
||||
./test.sh -f tsim/db/taosdlog.sim
|
||||
#./test.sh -f tsim/db/topic1.sim
|
||||
#./test.sh -f tsim/db/topic2.sim
|
||||
#./test.sh -f tsim/db/vnodes.sim
|
||||
|
||||
# ---- dnode
|
||||
# ./test.sh -f tsim/dnode/balance_replica1.sim
|
||||
|
|
@ -52,17 +76,132 @@
|
|||
./test.sh -f tsim/import/replica1.sim
|
||||
|
||||
# ---- insert
|
||||
./test.sh -f tsim/insert/backquote.sim
|
||||
./test.sh -f tsim/insert/basic.sim
|
||||
./test.sh -f tsim/insert/basic0.sim
|
||||
./test.sh -f tsim/insert/basic1.sim
|
||||
./test.sh -f tsim/insert/backquote.sim
|
||||
./test.sh -f tsim/insert/null.sim
|
||||
./test.sh -f tsim/insert/update0.sim
|
||||
./test.sh -f tsim/insert/commit-merge0.sim
|
||||
./test.sh -f tsim/insert/insert_drop.sim
|
||||
./test.sh -f tsim/insert/insert_select.sim
|
||||
./test.sh -f tsim/insert/null.sim
|
||||
./test.sh -f tsim/insert/query_block1_file.sim
|
||||
./test.sh -f tsim/insert/query_block1_memory.sim
|
||||
./test.sh -f tsim/insert/query_block2_file.sim
|
||||
./test.sh -f tsim/insert/query_block2_memory.sim
|
||||
./test.sh -f tsim/insert/query_file_memory.sim
|
||||
./test.sh -f tsim/insert/query_multi_file.sim
|
||||
#./test.sh -f tsim/insert/tcp.sim
|
||||
./test.sh -f tsim/insert/update0.sim
|
||||
|
||||
# ---- parser
|
||||
./test.sh -f tsim/parser/groupby-basic.sim
|
||||
# ./test.sh -f tsim/parser/alter.sim
|
||||
# ./test.sh -f tsim/parser/alter1.sim
|
||||
## ./test.sh -f tsim/parser/alter__for_community_version.sim
|
||||
## ./test.sh -f tsim/parser/alter_column.sim
|
||||
# ./test.sh -f tsim/parser/alter_stable.sim
|
||||
# ./test.sh -f tsim/parser/auto_create_tb.sim
|
||||
# ./test.sh -f tsim/parser/auto_create_tb_drop_tb.sim
|
||||
# ./test.sh -f tsim/parser/between_and.sim
|
||||
# ./test.sh -f tsim/parser/binary_escapeCharacter.sim
|
||||
# ./test.sh -f tsim/parser/col_arithmetic_operation.sim
|
||||
## ./test.sh -f tsim/parser/col_arithmetic_query.sim
|
||||
## ./test.sh -f tsim/parser/columnValue.sim
|
||||
## ./test.sh -f tsim/parser/columnValue_bigint.sim
|
||||
## ./test.sh -f tsim/parser/columnValue_bool.sim
|
||||
## ./test.sh -f tsim/parser/columnValue_double.sim
|
||||
## ./test.sh -f tsim/parser/columnValue_float.sim
|
||||
## ./test.sh -f tsim/parser/columnValue_int.sim
|
||||
## ./test.sh -f tsim/parser/columnValue_smallint.sim
|
||||
## ./test.sh -f tsim/parser/columnValue_tinyint.sim
|
||||
## ./test.sh -f tsim/parser/columnValue_unsign.sim
|
||||
## ./test.sh -f tsim/parser/commit.sim
|
||||
## ./test.sh -f tsim/parser/condition.sim
|
||||
## ./test.sh -f tsim/parser/condition_query.sim
|
||||
## ./test.sh -f tsim/parser/constCol.sim
|
||||
# ./test.sh -f tsim/parser/create_db.sim
|
||||
## ./test.sh -f tsim/parser/create_db__for_community_version.sim
|
||||
# ./test.sh -f tsim/parser/create_mt.sim
|
||||
# ./test.sh -f tsim/parser/create_tb.sim
|
||||
## ./test.sh -f tsim/parser/create_tb_with_tag_name.sim
|
||||
# ./test.sh -f tsim/parser/dbtbnameValidate.sim
|
||||
##./test.sh -f tsim/parser/distinct.sim
|
||||
# ./test.sh -f tsim/parser/fill.sim
|
||||
# ./test.sh -f tsim/parser/fill_stb.sim
|
||||
## ./test.sh -f tsim/parser/fill_us.sim
|
||||
# ./test.sh -f tsim/parser/first_last.sim
|
||||
## ./test.sh -f tsim/parser/first_last_query.sim
|
||||
./test.sh -f tsim/parser/fourArithmetic-basic.sim
|
||||
## ./test.sh -f tsim/parser/function.sim
|
||||
./test.sh -f tsim/parser/groupby-basic.sim
|
||||
# ./test.sh -f tsim/parser/groupby.sim
|
||||
## ./test.sh -f tsim/parser/having.sim
|
||||
# ./test.sh -f tsim/parser/having_child.sim
|
||||
## ./test.sh -f tsim/parser/import.sim
|
||||
# ./test.sh -f tsim/parser/import_commit1.sim
|
||||
# ./test.sh -f tsim/parser/import_commit2.sim
|
||||
# ./test.sh -f tsim/parser/import_commit3.sim
|
||||
## ./test.sh -f tsim/parser/import_file.sim
|
||||
## ./test.sh -f tsim/parser/insert_multiTbl.sim
|
||||
# ./test.sh -f tsim/parser/insert_tb.sim
|
||||
## ./test.sh -f tsim/parser/interp.sim
|
||||
## ./test.sh -f tsim/parser/interp_test.sim
|
||||
# ./test.sh -f tsim/parser/join.sim
|
||||
# ./test.sh -f tsim/parser/join_manyblocks.sim
|
||||
## ./test.sh -f tsim/parser/join_multitables.sim
|
||||
# ./test.sh -f tsim/parser/join_multivnode.sim
|
||||
# ./test.sh -f tsim/parser/last_cache.sim
|
||||
## ./test.sh -f tsim/parser/last_cache_query.sim
|
||||
## ./test.sh -f tsim/parser/last_groupby.sim
|
||||
# ./test.sh -f tsim/parser/lastrow.sim
|
||||
## ./test.sh -f tsim/parser/lastrow_query.sim
|
||||
## ./test.sh -f tsim/parser/like.sim
|
||||
# ./test.sh -f tsim/parser/limit.sim
|
||||
# ./test.sh -f tsim/parser/limit1.sim
|
||||
## ./test.sh -f tsim/parser/limit1_stb.sim
|
||||
## ./test.sh -f tsim/parser/limit1_tb.sim
|
||||
# ./test.sh -f tsim/parser/limit1_tblocks100.sim
|
||||
## ./test.sh -f tsim/parser/limit2.sim
|
||||
## ./test.sh -f tsim/parser/limit2_query.sim
|
||||
## ./test.sh -f tsim/parser/limit2_tblocks100.sim
|
||||
## ./test.sh -f tsim/parser/limit_stb.sim
|
||||
## ./test.sh -f tsim/parser/limit_tb.sim
|
||||
## ./test.sh -f tsim/parser/line_insert.sim
|
||||
# ./test.sh -f tsim/parser/mixed_blocks.sim
|
||||
# ./test.sh -f tsim/parser/nchar.sim
|
||||
# ./test.sh -f tsim/parser/nestquery.sim
|
||||
# ./test.sh -f tsim/parser/null_char.sim
|
||||
## ./test.sh -f tsim/parser/precision_ns.sim
|
||||
# ./test.sh -f tsim/parser/projection_limit_offset.sim
|
||||
## ./test.sh -f tsim/parser/regex.sim
|
||||
# ./test.sh -f tsim/parser/repeatAlter.sim
|
||||
# ./test.sh -f tsim/parser/selectResNum.sim
|
||||
# ./test.sh -f tsim/parser/select_across_vnodes.sim
|
||||
# ./test.sh -f tsim/parser/select_distinct_tag.sim
|
||||
# ./test.sh -f tsim/parser/select_from_cache_disk.sim
|
||||
# ./test.sh -f tsim/parser/select_with_tags.sim
|
||||
# ./test.sh -f tsim/parser/set_tag_vals.sim
|
||||
# ./test.sh -f tsim/parser/single_row_in_tb.sim
|
||||
## ./test.sh -f tsim/parser/single_row_in_tb_query.sim
|
||||
# ./test.sh -f tsim/parser/sliding.sim
|
||||
# ./test.sh -f tsim/parser/slimit.sim
|
||||
# ./test.sh -f tsim/parser/slimit1.sim
|
||||
## ./test.sh -f tsim/parser/slimit1_query.sim
|
||||
# ./test.sh -f tsim/parser/slimit_alter_tags.sim
|
||||
## ./test.sh -f tsim/parser/slimit_query.sim
|
||||
# ./test.sh -f tsim/parser/stableOp.sim
|
||||
# ./test.sh -f tsim/parser/tags_dynamically_specifiy.sim
|
||||
# ./test.sh -f tsim/parser/tags_filter.sim
|
||||
# ./test.sh -f tsim/parser/tbnameIn.sim
|
||||
## ./test.sh -f tsim/parser/tbnameIn_query.sim
|
||||
# ./test.sh -f tsim/parser/timestamp.sim
|
||||
## ./test.sh -f tsim/parser/timestamp_query.sim
|
||||
## ./test.sh -f tsim/parser/top_groupby.sim
|
||||
# ./test.sh -f tsim/parser/topbot.sim
|
||||
# ./test.sh -f tsim/parser/udf.sim
|
||||
# ./test.sh -f tsim/parser/udf_dll.sim
|
||||
# ./test.sh -f tsim/parser/udf_dll_stable.sim
|
||||
# ./test.sh -f tsim/parser/union.sim
|
||||
# ./test.sh -f tsim/parser/where.sim
|
||||
|
||||
# ---- query
|
||||
./test.sh -f tsim/query/interval.sim
|
||||
|
|
@ -94,7 +233,33 @@
|
|||
./test.sh -f tsim/show/basic.sim
|
||||
|
||||
# ---- table
|
||||
./test.sh -f tsim/table/autocreate.sim
|
||||
./test.sh -f tsim/table/basic1.sim
|
||||
./test.sh -f tsim/table/basic2.sim
|
||||
./test.sh -f tsim/table/basic3.sim
|
||||
./test.sh -f tsim/table/bigint.sim
|
||||
./test.sh -f tsim/table/binary.sim
|
||||
./test.sh -f tsim/table/bool.sim
|
||||
./test.sh -f tsim/table/column_name.sim
|
||||
./test.sh -f tsim/table/column_num.sim
|
||||
./test.sh -f tsim/table/column_value.sim
|
||||
./test.sh -f tsim/table/column2.sim
|
||||
./test.sh -f tsim/table/createmulti.sim
|
||||
./test.sh -f tsim/table/date.sim
|
||||
./test.sh -f tsim/table/db.table.sim
|
||||
# ./test.sh -f tsim/table/delete_reuse1.sim
|
||||
# ./test.sh -f tsim/table/delete_reuse2.sim
|
||||
# ./test.sh -f tsim/table/delete_writing.sim
|
||||
./test.sh -f tsim/table/describe.sim
|
||||
./test.sh -f tsim/table/double.sim
|
||||
./test.sh -f tsim/table/float.sim
|
||||
./test.sh -f tsim/table/int.sim
|
||||
./test.sh -f tsim/table/limit.sim
|
||||
./test.sh -f tsim/table/smallint.sim
|
||||
./test.sh -f tsim/table/table_len.sim
|
||||
./test.sh -f tsim/table/table.sim
|
||||
./test.sh -f tsim/table/tinyint.sim
|
||||
./test.sh -f tsim/table/vgroup.sim
|
||||
|
||||
# ---- stream
|
||||
./test.sh -f tsim/stream/basic0.sim
|
||||
|
|
@ -161,7 +326,7 @@
|
|||
./test.sh -f tsim/db/basic3.sim -m
|
||||
./test.sh -f tsim/db/error1.sim -m
|
||||
./test.sh -f tsim/insert/backquote.sim -m
|
||||
./test.sh -f tsim/parser/fourArithmetic-basic.sim -m
|
||||
# ./test.sh -f tsim/parser/fourArithmetic-basic.sim -m
|
||||
./test.sh -f tsim/query/interval-offset.sim -m
|
||||
./test.sh -f tsim/tmq/basic3.sim -m
|
||||
./test.sh -f tsim/stable/vnode3.sim -m
|
||||
|
|
@ -209,7 +374,7 @@
|
|||
# ---- alter
|
||||
./test.sh -f tsim/alter/cached_schema_after_alter.sim
|
||||
./test.sh -f tsim/alter/dnode.sim
|
||||
#./test.sh -f tsim/alter/table.sim
|
||||
./test.sh -f tsim/alter/table.sim
|
||||
|
||||
# ---- cache
|
||||
./test.sh -f tsim/cache/new_metrics.sim
|
||||
|
|
@ -228,23 +393,23 @@
|
|||
./test.sh -f tsim/compress/uncompress.sim
|
||||
|
||||
# ---- compute
|
||||
#./test.sh -f tsim/compute/avg.sim
|
||||
./test.sh -f tsim/compute/avg.sim
|
||||
#./test.sh -f tsim/compute/block_dist.sim
|
||||
#./test.sh -f tsim/compute/bottom.sim
|
||||
#./test.sh -f tsim/compute/count.sim
|
||||
#./test.sh -f tsim/compute/diff.sim
|
||||
#./test.sh -f tsim/compute/diff2.sim
|
||||
#./test.sh -f tsim/compute/first.sim
|
||||
#./test.sh -f tsim/compute/interval.sim
|
||||
./test.sh -f tsim/compute/bottom.sim
|
||||
./test.sh -f tsim/compute/count.sim
|
||||
./test.sh -f tsim/compute/diff.sim
|
||||
./test.sh -f tsim/compute/diff2.sim
|
||||
./test.sh -f tsim/compute/first.sim
|
||||
./test.sh -f tsim/compute/interval.sim
|
||||
#./test.sh -f tsim/compute/last_row.sim
|
||||
#./test.sh -f tsim/compute/last.sim
|
||||
#./test.sh -f tsim/compute/leastsquare.sim
|
||||
#./test.sh -f tsim/compute/max.sim
|
||||
#./test.sh -f tsim/compute/min.sim
|
||||
./test.sh -f tsim/compute/last.sim
|
||||
./test.sh -f tsim/compute/leastsquare.sim
|
||||
./test.sh -f tsim/compute/max.sim
|
||||
./test.sh -f tsim/compute/min.sim
|
||||
#./test.sh -f tsim/compute/null.sim
|
||||
./test.sh -f tsim/compute/percentile.sim
|
||||
./test.sh -f tsim/compute/stddev.sim
|
||||
#./test.sh -f tsim/compute/sum.sim
|
||||
./test.sh -f tsim/compute/sum.sim
|
||||
./test.sh -f tsim/compute/top.sim
|
||||
|
||||
# ---- field
|
||||
|
|
@ -280,4 +445,38 @@
|
|||
# ---- wal
|
||||
./test.sh -f tsim/wal/kill.sim
|
||||
|
||||
# ---- issue
|
||||
#./test.sh -f tsim/issue/TD-2677.sim
|
||||
#./test.sh -f tsim/issue/TD-2680.sim
|
||||
#./test.sh -f tsim/issue/TD-2713.sim
|
||||
#./test.sh -f tsim/issue/TD-3300.sim
|
||||
|
||||
# ---- tag
|
||||
./test.sh -f tsim/tag/3.sim
|
||||
./test.sh -f tsim/tag/4.sim
|
||||
./test.sh -f tsim/tag/5.sim
|
||||
#./test.sh -f tsim/tag/6.sim
|
||||
#./test.sh -f tsim/tag/add.sim
|
||||
./test.sh -f tsim/tag/bigint.sim
|
||||
./test.sh -f tsim/tag/binary_binary.sim
|
||||
./test.sh -f tsim/tag/binary.sim
|
||||
./test.sh -f tsim/tag/bool_binary.sim
|
||||
./test.sh -f tsim/tag/bool_int.sim
|
||||
./test.sh -f tsim/tag/bool.sim
|
||||
#./test.sh -f tsim/tag/change.sim
|
||||
#./test.sh -f tsim/tag/column.sim
|
||||
#./test.sh -f tsim/tag/commit.sim
|
||||
#./test.sh -f tsim/tag/create.sim
|
||||
#./test.sh -f tsim/tag/delete.sim
|
||||
#./test.sh -f tsim/tag/double.sim
|
||||
#./test.sh -f tsim/tag/filter.sim
|
||||
#./test.sh -f tsim/tag/float.sim
|
||||
./test.sh -f tsim/tag/int_binary.sim
|
||||
./test.sh -f tsim/tag/int_float.sim
|
||||
./test.sh -f tsim/tag/int.sim
|
||||
#./test.sh -f tsim/tag/set.sim
|
||||
./test.sh -f tsim/tag/smallint.sim
|
||||
./test.sh -f tsim/tag/tinyint.sim
|
||||
|
||||
|
||||
#======================b1-end===============
|
||||
|
|
|
|||
|
|
@ -77,7 +77,10 @@ goto :eof
|
|||
:check_offline
|
||||
sleep 1
|
||||
for /f "tokens=2" %%C in ('wmic process where "name='taosd.exe' and CommandLine like '%%%NODE_NAME%%%'" get processId ^| xargs echo') do (
|
||||
echo check taosd offline
|
||||
for /f "tokens=1" %%D in ('ps ^| grep %%C') do (
|
||||
echo kill -INT %%D
|
||||
echo check taosd offline %NODE_NAME% %%C %%D
|
||||
goto :check_offline
|
||||
)
|
||||
)
|
||||
goto :eof
|
||||
|
|
@ -24,7 +24,7 @@ for /F "usebackq tokens=*" %%i in (!caseFile!) do (
|
|||
)
|
||||
)
|
||||
)
|
||||
exit !exitNum!
|
||||
exit /b !exitNum!
|
||||
|
||||
:colorEcho
|
||||
set timeNow=%time%
|
||||
|
|
|
|||
|
|
@ -660,7 +660,7 @@ endi
|
|||
print ======= over
|
||||
sql drop database d1
|
||||
sql show databases
|
||||
if $rows != 0 then
|
||||
if $rows != 2 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
|
|||
|
|
@ -83,10 +83,6 @@ while $i < 10
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
print ==> sleep 1 seconds to renew cache
|
||||
sql reset query cache
|
||||
sleep 1000
|
||||
|
||||
print =============== step5
|
||||
sql select * from $tb order by ts desc
|
||||
print ===>rows $rows, data $data01
|
||||
|
|
|
|||
|
|
@ -48,9 +48,7 @@ system sh/deploy.sh -n dnode1 -i 1
|
|||
system sh/exec.sh -n dnode1 -s start
|
||||
|
||||
print =============== step3
|
||||
print ==> sleep 1 seconds to renew cache
|
||||
sql reset query cache
|
||||
sleep 1000
|
||||
|
||||
print =============== step4
|
||||
sql create database $db
|
||||
|
|
|
|||
|
|
@ -32,9 +32,7 @@ system sh/deploy.sh -n dnode1 -i 1
|
|||
system sh/exec.sh -n dnode1 -s start
|
||||
|
||||
print =============== step3
|
||||
print ==> sleep 1 seconds to renew cache
|
||||
sql reset query cache
|
||||
sleep 1000
|
||||
|
||||
print =============== step4
|
||||
sql create database $db
|
||||
|
|
|
|||
|
|
@ -57,15 +57,7 @@ $tb = $tbPrefix . $i
|
|||
|
||||
sql create database $db
|
||||
sql use $db
|
||||
|
||||
$x = 0
|
||||
step3:
|
||||
$x = $x + 1
|
||||
sleep 1000
|
||||
if $x == 20 then
|
||||
return -1
|
||||
endi
|
||||
sql create table $tb (ts timestamp, b bool, t tinyint, s smallint, i int, big bigint, f float, d double, str binary(256)) -x step3
|
||||
sql create table $tb (ts timestamp, b bool, t tinyint, s smallint, i int, big bigint, f float, d double, str binary(256))
|
||||
|
||||
$count = 0
|
||||
while $count < $N
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
@ -69,13 +67,13 @@ endi
|
|||
print =============== step5
|
||||
sql select avg(tbcol) as b from $tb interval(1m)
|
||||
print ===> $data01
|
||||
if $data11 != 1.000000000 then
|
||||
if $data10 != 1.000000000 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select avg(tbcol) as b from $tb interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != 9.500000000 then
|
||||
if $data00 != 9.500000000 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -84,7 +82,7 @@ $cc = 4 * 60000
|
|||
$ms = 1601481600000 + $cc
|
||||
sql select avg(tbcol) as b from $tb where ts <= $ms interval(1m)
|
||||
print ===> $data01
|
||||
if $data41 != 4.000000000 then
|
||||
if $data40 != 4.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $rows != 5 then
|
||||
|
|
@ -123,14 +121,14 @@ endi
|
|||
|
||||
print =============== step9
|
||||
sql select avg(tbcol) as b from $mt interval(1m)
|
||||
print ===> $data11
|
||||
if $data11 != 1.000000000 then
|
||||
print ===> $data10
|
||||
if $data10 != 1.000000000 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select avg(tbcol) as b from $mt interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != 9.500000000 then
|
||||
if $data00 != 9.500000000 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -148,9 +146,9 @@ endi
|
|||
print =============== step11
|
||||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
sql select avg(tbcol) as b from $mt where ts <= $ms interval(1m) group by tgcol
|
||||
print ===> $data11
|
||||
if $data11 != 1.000000000 then
|
||||
sql select avg(tbcol) as b from $mt where ts <= $ms partition by tgcol interval(1m)
|
||||
print ===> $data10
|
||||
if $data10 != 1.000000000 then
|
||||
return -1
|
||||
endi
|
||||
if $rows != 50 then
|
||||
|
|
|
|||
|
|
@ -47,8 +47,6 @@ while $x < $rowNum
|
|||
$x = $x + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 0
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
|
|||
|
|
@ -38,15 +38,13 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
||||
sql select bottom(tbcol, 1) from $tb
|
||||
print ===> $data01
|
||||
if $data01 != 0 then
|
||||
print ===> $data00
|
||||
if $data00 != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -54,25 +52,25 @@ print =============== step3
|
|||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
sql select bottom(tbcol, 1) from $tb where ts > $ms
|
||||
print ===> $data01
|
||||
if $data01 != 5 then
|
||||
print ===> $data00
|
||||
if $data00 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print =============== step4
|
||||
sql select bottom(tbcol, 1) as b from $tb
|
||||
print ===> $data01
|
||||
if $data01 != 0 then
|
||||
print ===> $data00
|
||||
if $data00 != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print =============== step5
|
||||
sql select bottom(tbcol, 2) as b from $tb
|
||||
print ===> $data01 $data11
|
||||
if $data01 != 0 then
|
||||
print ===> $data00 $data10
|
||||
if $data00 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 1 then
|
||||
if $data10 != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -80,11 +78,11 @@ print =============== step6
|
|||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
sql select bottom(tbcol, 2) as b from $tb where ts > $ms
|
||||
print ===> $data01 $data11
|
||||
if $data01 != 5 then
|
||||
print ===> $data00 $data10
|
||||
if $data00 != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 6 then
|
||||
if $data10 != 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
|
|||
|
|
@ -38,13 +38,10 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
||||
|
||||
sql select count(*) from $tb
|
||||
print ===> select count(*) from $tb => $data00
|
||||
if $data00 != $rowNum then
|
||||
|
|
@ -81,14 +78,14 @@ endi
|
|||
|
||||
print =============== step5
|
||||
sql select count(tbcol) as b from $tb interval(1m)
|
||||
print ===> $data01
|
||||
if $data01 != 1 then
|
||||
print ===> $data00
|
||||
if $data00 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select count(tbcol) as b from $tb interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != $rowNum then
|
||||
print ===> $data00
|
||||
if $data00 != $rowNum then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -96,8 +93,8 @@ print =============== step6
|
|||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
sql select count(tbcol) as b from $tb where ts <= $ms interval(1m)
|
||||
print ===> $data01
|
||||
if $data01 != 1 then
|
||||
print ===> $data00
|
||||
if $data00 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $rows != 5 then
|
||||
|
|
@ -149,17 +146,17 @@ endi
|
|||
|
||||
print =============== step9
|
||||
sql select count(tbcol) as b from $mt interval(1m)
|
||||
print ===> $data01
|
||||
if $data01 != 10 then
|
||||
print ===> $data00
|
||||
if $data00 != 10 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 != 10 then
|
||||
if $data10 != 10 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select count(tbcol) as b from $mt interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != 200 then
|
||||
print ===> $data00
|
||||
if $data00 != 200 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -177,9 +174,9 @@ endi
|
|||
print =============== step11
|
||||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
sql select count(tbcol) as b from $mt where ts <= $ms interval(1m) group by tgcol
|
||||
sql select count(tbcol) as b from $mt where ts <= $ms partition by tgcol interval(1m)
|
||||
print ===> $data01
|
||||
if $data01 != 1 then
|
||||
if $data00 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $rows != 50 then
|
||||
|
|
|
|||
|
|
@ -37,15 +37,13 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
||||
sql select diff(tbcol) from $tb
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -53,23 +51,23 @@ print =============== step3
|
|||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
sql select diff(tbcol) from $tb where ts > $ms
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
sql select diff(tbcol) from $tb where ts <= $ms
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print =============== step4
|
||||
sql select diff(tbcol) as b from $tb
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
system sh/stop_dnodes.sh
|
||||
system sh/deploy.sh -n dnode1 -i 1
|
||||
system sh/cfg.sh -n dnode1 -c debugflag -v 131
|
||||
system sh/exec.sh -n dnode1 -s start
|
||||
sql connect
|
||||
|
||||
|
|
@ -39,91 +40,90 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
||||
sql select diff(c1) from $tb
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c2) from $tb
|
||||
print ===> $data11
|
||||
if $data11 != 1.00000 then
|
||||
print ===> $data10
|
||||
if $data10 != 1.000000000 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c3) from $tb
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c4) from $tb
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c5) from $tb
|
||||
print ===> $data11
|
||||
if $data11 != 0 then
|
||||
print ===> $data10
|
||||
if $data10 != 0 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c6) from $tb
|
||||
print ===> $data11
|
||||
if $data11 != 1.000000000 then
|
||||
print ===> $data10
|
||||
if $data10 != 1.000000000 then
|
||||
return -1
|
||||
endi
|
||||
sql_error select diff(c7) from $tb
|
||||
|
||||
sql select diff(c7) from $tb
|
||||
sql_error select diff(c8) from $tb
|
||||
sql_error select diff(c9) from $tb
|
||||
sql_error select diff(ts) from $tb
|
||||
sql_error select diff(c1), diff(c2) from $tb
|
||||
#sql_error select 2+diff(c1) from $tb
|
||||
sql_error select diff(c1+2) from $tb
|
||||
|
||||
sql select 2+diff(c1) from $tb
|
||||
sql select diff(c1+2) from $tb
|
||||
sql_error select diff(c1) from $tb where ts > 0 and ts < now + 100m interval(10m)
|
||||
sql_error select diff(c1) from $mt
|
||||
sql select diff(c1) from $mt
|
||||
sql_error select diff(diff(c1)) from $tb
|
||||
sql_error select diff(c1) from m_di_tb1 where c2 like '2%'
|
||||
|
||||
|
||||
print =============== step3
|
||||
sql select diff(c1) from $tb where c1 > 5
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c2) from $tb where c2 > 5
|
||||
print ===> $data11
|
||||
if $data11 != 1.00000 then
|
||||
print ===> $data10
|
||||
if $data10 != 1.000000000 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c3) from $tb where c3 > 5
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c4) from $tb where c4 > 5
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c5) from $tb where c5 > 5
|
||||
print ===> $data11
|
||||
if $data11 != 0 then
|
||||
print ===> $data10
|
||||
if $data10 != 0 then
|
||||
return -1
|
||||
endi
|
||||
sql select diff(c6) from $tb where c6 > 5
|
||||
print ===> $data11
|
||||
if $data11 != 1.000000000 then
|
||||
print ===> $data10
|
||||
if $data10 != 1.000000000 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print =============== step4
|
||||
sql select diff(c1) from $tb where c1 > 5 and c2 < $rowNum
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -131,8 +131,8 @@ sql select diff(c1) from $tb where c9 like '%9' and c1 <= 20
|
|||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
print ===> $data11
|
||||
if $data01 != 10 then
|
||||
print ===> $data10
|
||||
if $data00 != 10 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
@ -68,14 +66,14 @@ endi
|
|||
|
||||
print =============== step5
|
||||
sql select first(tbcol) as b from $tb interval(1m)
|
||||
print ===> $data01
|
||||
if $data01 != 0 then
|
||||
print ===> $data00
|
||||
if $data00 != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select first(tbcol) as b from $tb interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != 0 then
|
||||
print ===> $data00
|
||||
if $data00 != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -83,8 +81,8 @@ print =============== step6
|
|||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
sql select first(tbcol) as b from $tb where ts <= $ms interval(1m)
|
||||
print ===> $data01
|
||||
if $data41 != 4 then
|
||||
print ===> $data00
|
||||
if $data40 != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $rows != 5 then
|
||||
|
|
@ -124,14 +122,14 @@ endi
|
|||
print =============== step9
|
||||
sql select first(tbcol) as b from $mt interval(1m)
|
||||
print select first(tbcol) as b from $mt interval(1m)
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select first(tbcol) as b from $mt interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != 0 then
|
||||
print ===> $data00
|
||||
if $data00 != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -149,9 +147,9 @@ endi
|
|||
print =============== step11
|
||||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
sql select first(tbcol) as b from $mt where ts <= $ms interval(1m) group by tgcol
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
sql select first(tbcol) as b from $mt where ts <= $ms partition by tgcol interval(1m)
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
print ===> $rows
|
||||
|
|
|
|||
|
|
@ -47,10 +47,10 @@ print ===> $rows
|
|||
if $rows < $rowNum then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 1 then
|
||||
if $data00 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 1 then
|
||||
if $data04 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -65,10 +65,10 @@ endi
|
|||
if $rows < 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 1 then
|
||||
if $data00 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 1 then
|
||||
if $data04 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -87,10 +87,10 @@ endi
|
|||
if $rows > 22 then
|
||||
return -1
|
||||
endi
|
||||
if $data01 != 1 then
|
||||
if $data00 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data05 != 1 then
|
||||
if $data04 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -109,10 +109,10 @@ endi
|
|||
if $rows > 50 then
|
||||
return -1
|
||||
endi
|
||||
if $data21 != 1 then
|
||||
if $data20 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data25 != 1 then
|
||||
if $data24 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -125,10 +125,10 @@ endi
|
|||
if $rows > 22 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 > 15 then
|
||||
if $data10 > 15 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 < 5 then
|
||||
if $data10 < 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -143,10 +143,10 @@ endi
|
|||
if $rows > 7 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 > 15 then
|
||||
if $data10 > 15 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 < 5 then
|
||||
if $data10 < 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -165,10 +165,10 @@ endi
|
|||
if $rows > 22 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 > 15 then
|
||||
if $data10 > 15 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 < 5 then
|
||||
if $data10 < 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -186,10 +186,10 @@ endi
|
|||
if $rows > 50 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 > 15 then
|
||||
if $data10 > 15 then
|
||||
return -1
|
||||
endi
|
||||
if $data11 < 5 then
|
||||
if $data10 < 5 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
@ -69,14 +67,14 @@ endi
|
|||
|
||||
print =============== step5
|
||||
sql select last(tbcol) as b from $tb interval(1m)
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select last(tbcol) as b from $tb interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != 19 then
|
||||
print ===> $data00
|
||||
if $data00 != 19 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -85,8 +83,8 @@ $cc = 4 * 60000
|
|||
$ms = 1601481600000 + $cc
|
||||
|
||||
sql select last(tbcol) as b from $tb where ts <= $ms interval(1m)
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $rows != 5 then
|
||||
|
|
@ -127,14 +125,14 @@ endi
|
|||
|
||||
print =============== step9
|
||||
sql select last(tbcol) as b from $mt interval(1m)
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select last(tbcol) as b from $mt interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != 19 then
|
||||
print ===> $data00
|
||||
if $data00 != 19 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -153,9 +151,9 @@ print =============== step11
|
|||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
|
||||
sql select last(tbcol) as b from $mt where ts <= $ms interval(1m) group by tgcol
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
sql select last(tbcol) as b from $mt where ts <= $ms partition by tgcol interval(1m)
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
print ===> $rows
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
@ -53,6 +51,7 @@ endi
|
|||
print =============== step3
|
||||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
print select last_row(tbcol) from $tb where ts <= $ms
|
||||
sql select last_row(tbcol) from $tb where ts <= $ms
|
||||
print ===> $data00
|
||||
if $data00 != 4 then
|
||||
|
|
@ -98,8 +97,6 @@ if $data00 != 4 then
|
|||
return -1
|
||||
endi
|
||||
|
||||
|
||||
|
||||
print =============== step10
|
||||
sql select last_row(tbcol) as b from $mt group by tgcol
|
||||
print ===> $data00
|
||||
|
|
|
|||
|
|
@ -37,8 +37,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
@ -65,21 +63,21 @@ endi
|
|||
|
||||
print =============== step5
|
||||
sql select leastsquares(tbcol, 1, 1) as b from $tb interval(1m)
|
||||
print ===> $data01
|
||||
if $data01 != @{slop:1.000000, intercept:1.000000}@ then
|
||||
print ===> $data00
|
||||
if $data00 != @{slop:1.000000, intercept:1.000000}@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select leastsquares(tbcol, 1, 1) as b from $tb interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != @{slop:1.000000, intercept:1.000000}@ then
|
||||
print ===> $data00
|
||||
if $data00 != @{slop:1.000000, intercept:1.000000}@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print =============== step6
|
||||
sql select leastsquares(tbcol, 1, 1) as b from $tb where ts < now + 4m interval(1m)
|
||||
print ===> $data01
|
||||
if $data01 != @{slop:1.000000, intercept:1.000000}@ then
|
||||
print ===> $data00
|
||||
if $data00 != @{slop:1.000000, intercept:1.000000}@ then
|
||||
return -1
|
||||
endi
|
||||
print ===> $rows
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
@ -69,14 +67,14 @@ endi
|
|||
|
||||
print =============== step5
|
||||
sql select max(tbcol) as b from $tb interval(1m)
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select max(tbcol) as b from $tb interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != 19 then
|
||||
print ===> $data00
|
||||
if $data00 != 19 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -85,8 +83,8 @@ $cc = 4 * 60000
|
|||
$ms = 1601481600000 + $cc
|
||||
|
||||
sql select max(tbcol) as b from $tb where ts <= $ms interval(1m)
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $rows != 5 then
|
||||
|
|
@ -127,14 +125,14 @@ endi
|
|||
|
||||
print =============== step9
|
||||
sql select max(tbcol) as b from $mt interval(1m)
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select max(tbcol) as b from $mt interval(1d)
|
||||
print ===> $data01
|
||||
if $data01 != 19 then
|
||||
print ===> $data00
|
||||
if $data00 != 19 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
|
@ -153,9 +151,9 @@ print =============== step11
|
|||
$cc = 4 * 60000
|
||||
$ms = 1601481600000 + $cc
|
||||
|
||||
sql select max(tbcol) as b from $mt where ts <= $ms interval(1m) group by tgcol
|
||||
print ===> $data11
|
||||
if $data11 != 1 then
|
||||
sql select max(tbcol) as b from $mt where ts <= $ms partition by tgcol interval(1m)
|
||||
print ===> $data10
|
||||
if $data10 != 1 then
|
||||
return -1
|
||||
endi
|
||||
print ===> $rows
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
|
|||
|
|
@ -100,9 +100,10 @@ if $rows != 1 then
|
|||
return -1
|
||||
endi
|
||||
|
||||
sql_error select * from $tb where tbcol = NULL
|
||||
|
||||
return
|
||||
sql select * from $tb where tbcol = NULL
|
||||
if $rows != 0 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print =============== step5
|
||||
sql create table tt using $mt tags( NULL )
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
|
|||
|
|
@ -38,8 +38,6 @@ while $i < $tbNum
|
|||
$i = $i + 1
|
||||
endw
|
||||
|
||||
sleep 100
|
||||
|
||||
print =============== step2
|
||||
$i = 1
|
||||
$tb = $tbPrefix . $i
|
||||
|
|
|
|||
|
|
@ -6,64 +6,36 @@ system sh/exec.sh -n dnode1 -s start
|
|||
system sh/exec.sh -n dnode2 -s start
|
||||
system sh/exec.sh -n dnode3 -s start
|
||||
|
||||
$loop_cnt = 0
|
||||
check_dnode_ready:
|
||||
$loop_cnt = $loop_cnt + 1
|
||||
sleep 200
|
||||
if $loop_cnt == 10 then
|
||||
print ====> dnode not ready!
|
||||
return -1
|
||||
endi
|
||||
sql show dnodes
|
||||
print ===> $rows $data00 $data01 $data02 $data03 $data04 $data05
|
||||
if $data00 != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data04 != ready then
|
||||
goto check_dnode_ready
|
||||
endi
|
||||
|
||||
sql connect
|
||||
sql create dnode $hostname port 7200
|
||||
sql create dnode $hostname port 7300
|
||||
|
||||
$loop_cnt = 0
|
||||
check_dnode_ready_1:
|
||||
$loop_cnt = $loop_cnt + 1
|
||||
sleep 200
|
||||
if $loop_cnt == 10 then
|
||||
$x = 0
|
||||
step1:
|
||||
$x = $x + 1
|
||||
sleep 1000
|
||||
if $x == 10 then
|
||||
print ====> dnode not ready!
|
||||
return -1
|
||||
endi
|
||||
sql show dnodes
|
||||
print ===> rows: $rows
|
||||
print ===> $data00 $data01 $data02 $data03 $data04 $data05
|
||||
print ===> $data10 $data11 $data12 $data13 $data14 $data15
|
||||
print ===> $data20 $data21 $data22 $data23 $data24 $data25
|
||||
if $data00 != 1 then
|
||||
if $rows != 3 then
|
||||
return -1
|
||||
endi
|
||||
system_content printf %OS%
|
||||
if $system_content == Windows_NT then
|
||||
system_content printf %COMPUTERNAME%:7100
|
||||
if $data01 != $system_content then
|
||||
return -1
|
||||
endi
|
||||
else
|
||||
if $data01 != localhost:7100 then
|
||||
return -1
|
||||
endi
|
||||
if $data(1)[4] != ready then
|
||||
goto step1
|
||||
endi
|
||||
if $data04 != ready then
|
||||
goto check_dnode_ready_1
|
||||
if $data(2)[4] != ready then
|
||||
goto step1
|
||||
endi
|
||||
if $data14 != ready then
|
||||
goto check_dnode_ready_1
|
||||
endi
|
||||
if $data24 != ready then
|
||||
goto check_dnode_ready_1
|
||||
if $data(3)[4] != ready then
|
||||
goto step1
|
||||
endi
|
||||
|
||||
|
||||
print ============= create database
|
||||
#database_option: {
|
||||
# | BUFFER value [3~16384, default: 96]
|
||||
|
|
@ -137,7 +109,6 @@ if $data17_db != ns then # precision
|
|||
return -1
|
||||
endi
|
||||
|
||||
sleep 3000
|
||||
#sql show db.vgroups
|
||||
#if $data[0][4] == leader then
|
||||
# if $data[0][6] != follower then
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
sql connect
|
||||
$x = 1
|
||||
begin:
|
||||
sql reset query cache
|
||||
sleep 1000
|
||||
sql insert into db.tb values(now, $x ) -x begin
|
||||
#print ===> insert successed $x
|
||||
$x = $x + 1
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue