support range merge
This commit is contained in:
wpan
parent
5712f7a2d7
commit
45cd731d7b
|
|
@ -3494,9 +3494,10 @@ enum {
|
|||
TSQL_EXPR_TAG = 2,
|
||||
TSQL_EXPR_COLUMN = 4,
|
||||
TSQL_EXPR_TBNAME = 8,
|
||||
TSQL_EXPR_JOIN = 16,
|
||||
};
|
||||
|
||||
#define GET_MIXED_TYPE(t) ((t) > TSQL_EXPR_COLUMN || (t) == (TSQL_EXPR_TS|TSQL_EXPR_TAG))
|
||||
#define GET_MIXED_TYPE(t) (((t) >= TSQL_EXPR_JOIN) || ((t) > TSQL_EXPR_COLUMN && (t) < TSQL_EXPR_TBNAME) || ((t) == (TSQL_EXPR_TS|TSQL_EXPR_TAG)))
|
||||
|
||||
static int32_t checkColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SColumnIndex* pIndex, tSqlExpr* pExpr, int32_t sqlOptr) {
|
||||
STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, pIndex->tableIndex);
|
||||
|
|
@ -4216,12 +4217,17 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
|
|||
* since this expression is used to set the join query type
|
||||
*/
|
||||
tSqlExprDestroy(*pExpr);
|
||||
if (type) {
|
||||
*type |= TSQL_EXPR_JOIN;
|
||||
}
|
||||
} else {
|
||||
ret = setNormalExprToCond(tsExpr, *pExpr, parentOptr);
|
||||
if (type) {
|
||||
*type |= TSQL_EXPR_TS;
|
||||
}
|
||||
}
|
||||
|
||||
*pExpr = NULL; // remove this expression
|
||||
*type |= TSQL_EXPR_TS;
|
||||
} else if (index.columnIndex >= tscGetNumOfColumns(pTableMeta) || index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
|
||||
// query on tags, check for tag query condition
|
||||
if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
|
||||
|
|
@ -4246,7 +4252,9 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
|
|||
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
|
||||
}
|
||||
|
||||
if (type) {
|
||||
*type |= TSQL_EXPR_TAG;
|
||||
}
|
||||
*pExpr = NULL;
|
||||
} else {
|
||||
if (pRight != NULL && pRight->tokenId == TK_ID) { // join on tag columns for stable query
|
||||
|
|
@ -4257,17 +4265,22 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
|
|||
pQueryInfo->type |= TSDB_QUERY_TYPE_JOIN_QUERY;
|
||||
ret = setExprToCond(&pCondExpr->pJoinExpr, *pExpr, NULL, parentOptr, pQueryInfo->msg);
|
||||
*pExpr = NULL;
|
||||
if (type) {
|
||||
*type |= TSQL_EXPR_JOIN;
|
||||
}
|
||||
} else {
|
||||
// do nothing
|
||||
// ret = setExprToCond(pCmd, &pCondExpr->pTagCond,
|
||||
// *pExpr, NULL, parentOptr);
|
||||
}
|
||||
|
||||
if (type) {
|
||||
*type |= TSQL_EXPR_TAG;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
} else { // query on other columns
|
||||
if (type) {
|
||||
*type |= TSQL_EXPR_COLUMN;
|
||||
}
|
||||
|
||||
if (pRight->tokenId == TK_ID) { // other column cannot be served as the join column
|
||||
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
|
||||
|
|
@ -4293,7 +4306,7 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
|
|||
|
||||
int32_t ret = 0;
|
||||
|
||||
const char* msg1 = "query condition between columns and tags and timestamp must use 'AND'";
|
||||
const char* msg1 = "query condition between columns/tags/timestamp/join fields must use 'AND'";
|
||||
const char* msg2 = "query condition between tables must use 'AND'";
|
||||
|
||||
if ((*pExpr)->flags & (1 << EXPR_FLAG_TS_ERROR)) {
|
||||
|
|
@ -4313,12 +4326,12 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
|
|||
int32_t rightTbIdx = 0;
|
||||
|
||||
if (!tSqlExprIsParentOfLeaf(*pExpr)) {
|
||||
ret = getQueryCondExpr(pCmd, pQueryInfo, &(*pExpr)->pLeft, pCondExpr, &leftType, &leftTbIdx, (*pExpr)->tokenId, &columnLeft, &tsLeft);
|
||||
ret = getQueryCondExpr(pCmd, pQueryInfo, &(*pExpr)->pLeft, pCondExpr, type ? &leftType : NULL, &leftTbIdx, (*pExpr)->tokenId, &columnLeft, &tsLeft);
|
||||
if (ret != TSDB_CODE_SUCCESS) {
|
||||
goto err_ret;
|
||||
}
|
||||
|
||||
ret = getQueryCondExpr(pCmd, pQueryInfo, &(*pExpr)->pRight, pCondExpr, &rightType, &rightTbIdx, (*pExpr)->tokenId, &columnRight, &tsRight);
|
||||
ret = getQueryCondExpr(pCmd, pQueryInfo, &(*pExpr)->pRight, pCondExpr, type ? &rightType : NULL, &rightTbIdx, (*pExpr)->tokenId, &columnRight, &tsRight);
|
||||
if (ret != TSDB_CODE_SUCCESS) {
|
||||
goto err_ret;
|
||||
}
|
||||
|
|
@ -4327,7 +4340,7 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
|
|||
* if left child and right child do not belong to the same group, the sub
|
||||
* expression is not valid for parent node, it must be TK_AND operator.
|
||||
*/
|
||||
if (((leftType != rightType) || GET_MIXED_TYPE(leftType)) && ((*pExpr)->tokenId == TK_OR)) {
|
||||
if (type != NULL && ((leftType != rightType) || GET_MIXED_TYPE(leftType)) && ((*pExpr)->tokenId == TK_OR)) {
|
||||
ret = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
|
||||
goto err_ret;
|
||||
}
|
||||
|
|
@ -4353,7 +4366,9 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
|
|||
*tsExpr = tsLeft ? tsLeft : tsRight;
|
||||
}
|
||||
|
||||
if (type) {
|
||||
*type = leftType|rightType;
|
||||
}
|
||||
*tbIdx = (leftTbIdx == rightTbIdx) ? leftTbIdx : -1;
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
|
|
@ -4956,10 +4971,24 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
|
|||
|
||||
int32_t type = 0;
|
||||
int32_t tbIdx = 0;
|
||||
if ((ret = getQueryCondExpr(&pSql->cmd, pQueryInfo, pExpr, &condExpr, &type, &tbIdx, (*pExpr)->tokenId, &condExpr.pColumnCond, &condExpr.pTimewindow)) != TSDB_CODE_SUCCESS) {
|
||||
int32_t *etype = &type;
|
||||
|
||||
#if 0
|
||||
//DISABLE PARENT CONDITION GROUP TYPE CHECK
|
||||
if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) {
|
||||
etype = NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
if ((ret = getQueryCondExpr(&pSql->cmd, pQueryInfo, pExpr, &condExpr, etype, &tbIdx, (*pExpr)->tokenId, &condExpr.pColumnCond, &condExpr.pTimewindow)) != TSDB_CODE_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (taosArrayGetSize(pQueryInfo->pUpstream) > 0 && condExpr.pTimewindow != NULL) {
|
||||
setNormalExprToCond(&condExpr.pColumnCond, condExpr.pTimewindow, TK_AND);
|
||||
condExpr.pTimewindow = NULL;
|
||||
}
|
||||
|
||||
tSqlExprCompact(pExpr);
|
||||
|
||||
// after expression compact, the expression tree is only include tag query condition
|
||||
|
|
|
|||
|
|
@ -560,6 +560,68 @@ void assignVal(char *val, const char *src, int32_t len, int32_t type) {
|
|||
}
|
||||
}
|
||||
|
||||
int8_t getInt8Val(void *s) {
|
||||
return (int8_t)GET_INT8_VAL(s);
|
||||
}
|
||||
uint8_t getUint8Val(void *s) {
|
||||
return (uint8_t)GET_INT8_VAL(s);
|
||||
}
|
||||
int16_t getInt16Val(void *s) {
|
||||
return (int16_t)GET_INT16_VAL(s);
|
||||
}
|
||||
uint16_t getUint16Val(void *s) {
|
||||
return (uint16_t)GET_INT16_VAL(s);
|
||||
}
|
||||
int32_t getInt32Val(void *s) {
|
||||
return (int32_t)GET_INT32_VAL(s);
|
||||
}
|
||||
uint32_t getUint32Val(void *s) {
|
||||
return (uint32_t)GET_INT32_VAL(s);
|
||||
}
|
||||
int64_t getInt64Val(void *s) {
|
||||
return (int64_t)GET_INT64_VAL(s);
|
||||
}
|
||||
uint64_t getUint64Val(void *s) {
|
||||
return (uint64_t)GET_INT64_VAL(s);
|
||||
}
|
||||
float getFloatVal(void *s) {
|
||||
return GET_FLOAT_VAL(s);
|
||||
}
|
||||
double getDoubleVal(void *s) {
|
||||
return GET_DOUBLE_VAL(s);
|
||||
}
|
||||
void setInt8Val(void *d, void *s) {
|
||||
*((int8_t *)d) = (int8_t)GET_INT8_VAL(s);
|
||||
}
|
||||
void setUint8Val(void *d, void *s) {
|
||||
*((uint8_t *)d) = GET_INT8_VAL(s);
|
||||
}
|
||||
void setInt16Val(void *d, void *s) {
|
||||
*((int16_t *)d) = (int16_t)GET_INT16_VAL(s);
|
||||
}
|
||||
void setUint16Val(void *d, void *s) {
|
||||
*((uint16_t *)d) = GET_INT16_VAL(s);
|
||||
}
|
||||
void setInt32Val(void *d, void *s) {
|
||||
*((int32_t *)d) = GET_INT32_VAL(s);
|
||||
}
|
||||
void setUint32Val(void *d, void *s) {
|
||||
*((uint32_t *)d) = GET_INT32_VAL(s);
|
||||
}
|
||||
void setInt64Val(void *d, void *s) {
|
||||
*((int64_t *)d) = GET_INT64_VAL(s);
|
||||
}
|
||||
void setUint64Val(void *d, void *s) {
|
||||
*((uint64_t *)d) = GET_INT64_VAL(s);
|
||||
}
|
||||
void setFloatVal(void *d, void *s) {
|
||||
SET_FLOAT_VAL(d, GET_FLOAT_VAL(s));
|
||||
}
|
||||
void setDoubleVal(void *d, void *s) {
|
||||
SET_DOUBLE_VAL(d, GET_DOUBLE_VAL(s));
|
||||
}
|
||||
|
||||
|
||||
void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf) {
|
||||
switch (type) {
|
||||
case TSDB_DATA_TYPE_INT:
|
||||
|
|
|
|||
|
|
@ -32,11 +32,34 @@ enum {
|
|||
F_FIELD_MAX
|
||||
};
|
||||
|
||||
enum {
|
||||
MR_ST_START = 1,
|
||||
MR_ST_FIN = 2,
|
||||
};
|
||||
|
||||
enum {
|
||||
MR_OPT_TS = 1,
|
||||
};
|
||||
|
||||
typedef struct OptrStr {
|
||||
uint16_t optr;
|
||||
char *str;
|
||||
} OptrStr;
|
||||
|
||||
typedef struct SFilterRange {
|
||||
struct SFilterRange* prev;
|
||||
struct SFilterRange* next;
|
||||
int64_t s;
|
||||
int64_t e;
|
||||
} SFilterRange;
|
||||
|
||||
typedef struct SFilterRMCtx {
|
||||
int32_t type;
|
||||
int32_t options;
|
||||
int8_t status;
|
||||
__compar_fn_t pCompareFunc;
|
||||
SFilterRange *rs;
|
||||
} SFilterRMCtx ;
|
||||
|
||||
typedef struct SFilterField {
|
||||
uint16_t type;
|
||||
|
|
@ -83,6 +106,15 @@ typedef struct SFilterInfo {
|
|||
uint8_t *unitFlags; // got result
|
||||
} SFilterInfo;
|
||||
|
||||
#define MR_GET_FLAG(st, f) (st & f)
|
||||
#define MR_SET_FLAG(st, f) st |= (f)
|
||||
|
||||
#define GEN_RANGE(r, t, s, e) do { r = calloc(1, sizeof(SFilterRange)); assignVal((char*)&(r)->s, s, 0, t); assignVal((char*)&(r)->e, e, 0, t); } while (0)
|
||||
#define FREE_RANGE(rs, r) do { if (r->prev) { r->prev->next = r->next; } else { rs = r->next;} if (r->next) { r->next->prev = r->prev; } free(r); } while (0)
|
||||
#define FREE_FROM_RANGE(rs, r) do { if (r->prev) { r->prev->next = NULL; } else { rs = NULL;} while (r) {SFilterRange *n = r->next; free(r); r = n; } } while (0)
|
||||
#define INSERT_RANGE(rs, r, t, s, e) do { SFilterRange *n = calloc(1, sizeof(SFilterRange)); assignVal((char*)&n->s, s, 0, t); assignVal((char*)&n->e, e, 0, t); n->prev = r->prev; r->prev = n; if (r->prev) { r->prev->next = n; } else { rs->next = n; } n->next = r; } while (0)
|
||||
#define APPEND_RANGE(r, t, s, e) do { SFilterRange *n = calloc(1, sizeof(SFilterRange)); assignVal((char*)&n->s, s, 0, t); assignVal((char*)&n->e, e, 0, t); n->prev = r; r->next = n; } while (0)
|
||||
|
||||
#define ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { return _code; } } while (0)
|
||||
#define ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { qError(__VA_ARGS__); return _code; } } while (0)
|
||||
#define ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { goto _err_return; } } while (0)
|
||||
|
|
@ -112,6 +144,11 @@ typedef int32_t(*filter_desc_compare_func)(const void *, const void *);
|
|||
extern int32_t filterInitFromTree(tExprNode* tree, SFilterInfo **pinfo);
|
||||
extern bool filterExecute(SFilterInfo *info, int32_t numOfRows, int8_t* p);
|
||||
extern int32_t filterSetColFieldData(SFilterInfo *info, int16_t colId, void *data);
|
||||
extern void* filterInitMergeRange(int32_t type, int32_t options);
|
||||
extern int32_t filterAddMergeRange(void* h, void* s, void* e, int32_t optr);
|
||||
extern int32_t filterGetMergeRangeNum(void* h, int32_t* num);
|
||||
extern int32_t filterGetMergeRangeRes(void* h, void *s, void* e);
|
||||
extern int32_t filterFreeMergeRange(void* h);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -54,6 +54,199 @@ filter_desc_compare_func gDescCompare [F_FIELD_MAX] = {
|
|||
filterFieldValDescCompare
|
||||
};
|
||||
|
||||
void* filterInitMergeRange(int32_t type, int32_t options) {
|
||||
if (type > TSDB_DATA_TYPE_UBIGINT || type < TSDB_DATA_TYPE_BOOL || type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
|
||||
qError("not supported range type:%d", type);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
SFilterRMCtx *ctx = calloc(1, sizeof(SFilterRMCtx));
|
||||
|
||||
ctx->type = type;
|
||||
ctx->pCompareFunc = getComparFunc(type, 0);
|
||||
|
||||
return ctx;
|
||||
}
|
||||
|
||||
int32_t filterAddMergeRange(void* h, void* s, void* e, int32_t optr) {
|
||||
SFilterRMCtx *ctx = (SFilterRMCtx *)h;
|
||||
|
||||
if (ctx->rs == NULL) {
|
||||
if (MR_GET_FLAG(ctx->status, MR_ST_START) == 0 || optr == TSDB_RELATION_OR) {
|
||||
GEN_RANGE(ctx->rs, ctx->type, s, e);
|
||||
MR_SET_FLAG(ctx->status, MR_ST_START);
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
SFilterRange *r = ctx->rs;
|
||||
SFilterRange *rn = NULL;
|
||||
|
||||
if (optr == TSDB_RELATION_AND) {
|
||||
while (r != NULL) {
|
||||
if (ctx->pCompareFunc(&r->s, e) > 0) {
|
||||
FREE_FROM_RANGE(ctx->rs, r);
|
||||
break;
|
||||
}
|
||||
|
||||
if (ctx->pCompareFunc(s, &r->e) > 0) {
|
||||
rn = r->next;
|
||||
FREE_RANGE(ctx->rs, r);
|
||||
r = rn;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ctx->pCompareFunc(s, &r->s) > 0) {
|
||||
assignVal((char *)&r->s, s, 0, ctx->type);
|
||||
}
|
||||
|
||||
if (ctx->pCompareFunc(&r->e, e) > 0) {
|
||||
assignVal((char *)&r->e, e, 0, ctx->type);
|
||||
break;
|
||||
}
|
||||
|
||||
r = r->next;
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
//TSDB_RELATION_OR
|
||||
bool smerged = false;
|
||||
bool emerged = false;
|
||||
|
||||
while (r != NULL) {
|
||||
if (ctx->pCompareFunc(&r->s, e) > 0) {
|
||||
if (emerged == false) {
|
||||
INSERT_RANGE(ctx->rs, r, ctx->type, s, e);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (ctx->pCompareFunc(s, &r->e) > 0) {
|
||||
if (r->next) {
|
||||
r= r->next;
|
||||
continue;
|
||||
}
|
||||
|
||||
APPEND_RANGE(r, ctx->type, s, e);
|
||||
break;
|
||||
}
|
||||
|
||||
if (smerged == false) {
|
||||
if (ctx->pCompareFunc(&r->s, s) > 0) {
|
||||
assignVal((char *)&r->s, s, 0, ctx->type);
|
||||
}
|
||||
|
||||
smerged = true;
|
||||
}
|
||||
|
||||
if (emerged == false) {
|
||||
if (ctx->pCompareFunc(e, &r->e) > 0) {
|
||||
assignVal((char *)&r->e, e, 0, ctx->type);
|
||||
emerged = true;
|
||||
e = &r->e;
|
||||
r = r->next;
|
||||
continue;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (ctx->pCompareFunc(e, &r->e) > 0) {
|
||||
rn = r->next;
|
||||
FREE_RANGE(ctx->rs, r);
|
||||
r = rn;
|
||||
|
||||
continue;
|
||||
} else {
|
||||
assignVal(e, (char *)&r->e, 0, ctx->type);
|
||||
FREE_RANGE(ctx->rs, r);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t filterFinMergeRange(void* h) {
|
||||
SFilterRMCtx *ctx = (SFilterRMCtx *)h;
|
||||
|
||||
if (MR_GET_FLAG(ctx->status, MR_ST_FIN)) {
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
if (MR_GET_FLAG(ctx->options, MR_OPT_TS)) {
|
||||
|
||||
}
|
||||
|
||||
MR_SET_FLAG(ctx->status, MR_ST_FIN);
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t filterGetMergeRangeNum(void* h, int32_t* num) {
|
||||
filterFinMergeRange(h);
|
||||
|
||||
SFilterRMCtx *ctx = (SFilterRMCtx *)h;
|
||||
|
||||
*num = 0;
|
||||
|
||||
SFilterRange *r = ctx->rs;
|
||||
|
||||
while (r) {
|
||||
++(*num);
|
||||
r = r->next;
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
int32_t filterGetMergeRangeRes(void* h, void *s, void* e) {
|
||||
filterFinMergeRange(h);
|
||||
|
||||
SFilterRMCtx *ctx = (SFilterRMCtx *)h;
|
||||
uint32_t num = 0;
|
||||
SFilterRange* r = ctx->rs;
|
||||
|
||||
while (r) {
|
||||
assignVal(s + num * tDataTypes[ctx->type].bytes, (char *)&r->s, 0, ctx->type);
|
||||
assignVal(e + num * tDataTypes[ctx->type].bytes, (char *)&r->e, 0, ctx->type);
|
||||
|
||||
++num;
|
||||
r = r->next;
|
||||
}
|
||||
|
||||
if (num == 0) {
|
||||
qError("no range result");
|
||||
return TSDB_CODE_QRY_APP_ERROR;
|
||||
}
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
int32_t filterFreeMergeRange(void* h) {
|
||||
SFilterRMCtx *ctx = (SFilterRMCtx *)h;
|
||||
SFilterRange *r = ctx->rs;
|
||||
SFilterRange *rn = NULL;
|
||||
|
||||
while (r) {
|
||||
rn = r->next;
|
||||
free(r);
|
||||
r = rn;
|
||||
}
|
||||
|
||||
free(ctx);
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
int32_t filterMergeGroup(SFilterGroup *gp1, SFilterGroup *gp2, SArray* group) {
|
||||
SFilterGroup gp = {0};
|
||||
|
||||
|
|
@ -505,5 +698,3 @@ _err_return:
|
|||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -20,9 +20,10 @@ IF (HEADER_GTEST_INCLUDE_DIR AND LIB_GTEST_STATIC_DIR)
|
|||
TARGET_LINK_LIBRARIES(queryTest taos query gtest pthread)
|
||||
ENDIF()
|
||||
|
||||
SET_SOURCE_FILES_PROPERTIES(./astTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
SET_SOURCE_FILES_PROPERTIES(./histogramTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
SET_SOURCE_FILES_PROPERTIES(./percentileTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
SET_SOURCE_FILES_PROPERTIES(./resultBufferTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
SET_SOURCE_FILES_PROPERTIES(./tsBufTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
SET_SOURCE_FILES_PROPERTIES(./unitTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
#SET_SOURCE_FILES_PROPERTIES(./astTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
#SET_SOURCE_FILES_PROPERTIES(./histogramTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
#SET_SOURCE_FILES_PROPERTIES(./percentileTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
#SET_SOURCE_FILES_PROPERTIES(./resultBufferTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
#SET_SOURCE_FILES_PROPERTIES(./tsBufTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
#SET_SOURCE_FILES_PROPERTIES(./unitTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
SET_SOURCE_FILES_PROPERTIES(./rangeMergeTest.cpp PROPERTIES COMPILE_FLAGS -w)
|
||||
|
|
|
|||
|
|
@ -1,635 +0,0 @@
|
|||
#include <gtest/gtest.h>
|
||||
#include <sys/time.h>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
#include "texpr.h"
|
||||
#include "taosmsg.h"
|
||||
#include "tsdb.h"
|
||||
#include "tskiplist.h"
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wwrite-strings"
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
|
||||
typedef struct ResultObj {
|
||||
int32_t numOfResult;
|
||||
char * resultName[64];
|
||||
} ResultObj;
|
||||
|
||||
static void initSchema(SSchema *pSchema, int32_t numOfCols);
|
||||
|
||||
static void initSchema_binary(SSchema *schema, int32_t numOfCols);
|
||||
|
||||
static SSkipList *createSkipList(SSchema *pSchema, int32_t numOfTags);
|
||||
static SSkipList *createSkipList_binary(SSchema *pSchema, int32_t numOfTags);
|
||||
|
||||
static void dropMeter(SSkipList *pSkipList);
|
||||
|
||||
static void Right2LeftTest(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList);
|
||||
|
||||
static void Left2RightTest(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList);
|
||||
|
||||
static void IllegalExprTest(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList);
|
||||
|
||||
static void Left2RightTest_binary(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList);
|
||||
static void Right2LeftTest_binary(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList);
|
||||
|
||||
void setValue(ResultObj *pResult, int32_t num, char **val) {
|
||||
pResult->numOfResult = num;
|
||||
for (int32_t i = 0; i < num; ++i) {
|
||||
pResult->resultName[i] = val[i];
|
||||
}
|
||||
}
|
||||
|
||||
static void initSchema_binary(SSchema *schema, int32_t numOfCols) {
|
||||
schema[0].type = TSDB_DATA_TYPE_BINARY;
|
||||
schema[0].bytes = 8;
|
||||
strcpy(schema[0].name, "a");
|
||||
|
||||
schema[1].type = TSDB_DATA_TYPE_DOUBLE;
|
||||
schema[1].bytes = 8;
|
||||
strcpy(schema[1].name, "b");
|
||||
|
||||
schema[2].type = TSDB_DATA_TYPE_INT;
|
||||
schema[2].bytes = 20;
|
||||
strcpy(schema[2].name, "c");
|
||||
|
||||
schema[3].type = TSDB_DATA_TYPE_BIGINT;
|
||||
schema[3].bytes = 8;
|
||||
strcpy(schema[3].name, "d");
|
||||
|
||||
schema[4].type = TSDB_DATA_TYPE_SMALLINT;
|
||||
schema[4].bytes = 2;
|
||||
strcpy(schema[4].name, "e");
|
||||
|
||||
schema[5].type = TSDB_DATA_TYPE_TINYINT;
|
||||
schema[5].bytes = 1;
|
||||
strcpy(schema[5].name, "f");
|
||||
|
||||
schema[6].type = TSDB_DATA_TYPE_FLOAT;
|
||||
schema[6].bytes = 4;
|
||||
strcpy(schema[6].name, "g");
|
||||
|
||||
schema[7].type = TSDB_DATA_TYPE_BOOL;
|
||||
schema[7].bytes = 1;
|
||||
strcpy(schema[7].name, "h");
|
||||
}
|
||||
|
||||
static void initSchema(SSchema *schema, int32_t numOfCols) {
|
||||
schema[0].type = TSDB_DATA_TYPE_INT;
|
||||
schema[0].bytes = 8;
|
||||
strcpy(schema[0].name, "a");
|
||||
|
||||
schema[1].type = TSDB_DATA_TYPE_DOUBLE;
|
||||
schema[1].bytes = 8;
|
||||
strcpy(schema[1].name, "b");
|
||||
|
||||
schema[2].type = TSDB_DATA_TYPE_BINARY;
|
||||
schema[2].bytes = 20;
|
||||
strcpy(schema[2].name, "c");
|
||||
|
||||
schema[3].type = TSDB_DATA_TYPE_BIGINT;
|
||||
schema[3].bytes = 8;
|
||||
strcpy(schema[3].name, "d");
|
||||
|
||||
schema[4].type = TSDB_DATA_TYPE_SMALLINT;
|
||||
schema[4].bytes = 2;
|
||||
strcpy(schema[4].name, "e");
|
||||
|
||||
schema[5].type = TSDB_DATA_TYPE_TINYINT;
|
||||
schema[5].bytes = 1;
|
||||
strcpy(schema[5].name, "f");
|
||||
|
||||
schema[6].type = TSDB_DATA_TYPE_FLOAT;
|
||||
schema[6].bytes = 4;
|
||||
strcpy(schema[6].name, "g");
|
||||
|
||||
schema[7].type = TSDB_DATA_TYPE_BOOL;
|
||||
schema[7].bytes = 1;
|
||||
strcpy(schema[7].name, "h");
|
||||
}
|
||||
|
||||
// static void addOneNode(SSchema *pSchema, int32_t tagsLen, SSkipList *pSkipList,
|
||||
// char *meterId, int32_t a, double b, char *c, int64_t d, int16_t e, int8_t f, float g,
|
||||
// bool h, int32_t numOfTags) {
|
||||
// STabObj *pMeter = calloc(1, sizeof(STabObj));
|
||||
// pMeter->numOfTags = numOfTags;
|
||||
// pMeter->pTagData = calloc(1, tagsLen + TSDB_METER_ID_LEN);
|
||||
// strcpy(pMeter->meterId, meterId);
|
||||
//
|
||||
// char *tags = pMeter->pTagData + TSDB_METER_ID_LEN;
|
||||
// int32_t offset = 0;
|
||||
//
|
||||
// *(int32_t *) tags = a;
|
||||
//
|
||||
// offset += pSchema[0].bytes;
|
||||
// *(double *) (tags + offset) = b;
|
||||
//
|
||||
// offset += pSchema[1].bytes;
|
||||
// memcpy(tags + offset, c, 3);
|
||||
//
|
||||
// offset += pSchema[2].bytes;
|
||||
// *(int64_t *) (tags + offset) = d;
|
||||
//
|
||||
// offset += pSchema[3].bytes;
|
||||
// *(int16_t *) (tags + offset) = e;
|
||||
//
|
||||
// offset += pSchema[4].bytes;
|
||||
// *(int8_t *) (tags + offset) = f;
|
||||
//
|
||||
// offset += pSchema[5].bytes;
|
||||
// *(float *) (tags + offset) = g;
|
||||
//
|
||||
// offset += pSchema[6].bytes;
|
||||
// *(int8_t *) (tags + offset) = h ? 1 : 0;
|
||||
//
|
||||
// SSkipListKey pKey = SSkipListCreateKey(pSchema[0].type, tags, pSchema[0].bytes);
|
||||
// SSkipListPut(pSkipList, pMeter, &pKey, 1);
|
||||
//}
|
||||
//
|
||||
// static void addOneNode_binary(SSchema *pSchema, int32_t tagsLen, SSkipList *pSkipList,
|
||||
// char *meterId, int32_t a, double b, char *c, int64_t d, int16_t e, int8_t f, float g,
|
||||
// bool h, int32_t numOfTags) {
|
||||
// STabObj *pMeter = calloc(1, sizeof(STabObj));
|
||||
// pMeter->numOfTags = numOfTags;
|
||||
// pMeter->pTagData = calloc(1, tagsLen + TSDB_METER_ID_LEN);
|
||||
// strcpy(pMeter->meterId, meterId);
|
||||
//
|
||||
// char *tags = pMeter->pTagData + TSDB_METER_ID_LEN;
|
||||
// int32_t offset = 0;
|
||||
// memcpy(tags, c, pSchema[0].bytes);
|
||||
//
|
||||
// offset += pSchema[0].bytes;
|
||||
// *(double *) (tags + offset) = b;
|
||||
//
|
||||
// offset += pSchema[1].bytes;
|
||||
// *(int32_t *) (tags + offset) = a;
|
||||
//
|
||||
// offset += pSchema[2].bytes;
|
||||
// *(int64_t *) (tags + offset) = d;
|
||||
//
|
||||
// offset += pSchema[3].bytes;
|
||||
// *(int16_t *) (tags + offset) = e;
|
||||
//
|
||||
// offset += pSchema[4].bytes;
|
||||
// *(int8_t *) (tags + offset) = f;
|
||||
//
|
||||
// offset += pSchema[5].bytes;
|
||||
// *(float *) (tags + offset) = g;
|
||||
//
|
||||
// offset += pSchema[6].bytes;
|
||||
// *(int8_t *) (tags + offset) = h ? 1 : 0;
|
||||
//
|
||||
// SSkipListKey pKey = SSkipListCreateKey(pSchema[0].type, tags, pSchema[0].bytes);
|
||||
// SSkipListPut(pSkipList, pMeter, &pKey, 1);
|
||||
// SSkipListDestroyKey(&pKey);
|
||||
//}
|
||||
|
||||
// static void dropMeter(SSkipList *pSkipList) {
|
||||
// SSkipListNode **pRes = NULL;
|
||||
// int32_t num = SSkipListIterateList(pSkipList, &pRes, NULL, NULL);
|
||||
// for (int32_t i = 0; i < num; ++i) {
|
||||
// SSkipListNode *pNode = pRes[i];
|
||||
// STabObj *pMeter = (STabObj *) pNode->pData;
|
||||
// free(pMeter->pTagData);
|
||||
// free(pMeter);
|
||||
// pNode->pData = NULL;
|
||||
// }
|
||||
// free(pRes);
|
||||
//}
|
||||
|
||||
// static SSkipList *createSkipList(SSchema *pSchema, int32_t numOfTags) {
|
||||
// int32_t tagsLen = 0;
|
||||
// for (int32_t i = 0; i < numOfTags; ++i) {
|
||||
// tagsLen += pSchema[i].bytes;
|
||||
// }
|
||||
//
|
||||
// SSkipList *pSkipList = SSkipListCreate(10, pSchema[0].type, 4);
|
||||
//
|
||||
// addOneNode(pSchema, tagsLen, pSkipList, "tm0\0", 0, 10.5, "abc", 1000, -10000, -20, 1.0, true, 8);
|
||||
// addOneNode(pSchema, tagsLen, pSkipList, "tm1\0", 1, 20.5, "def", 1100, -10500, -30, 2.0, false, 8);
|
||||
// addOneNode(pSchema, tagsLen, pSkipList, "tm2\0", 2, 30.5, "ghi", 1200, -11000, -40, 3.0, true, 8);
|
||||
// addOneNode(pSchema, tagsLen, pSkipList, "tm3\0", 3, 40.5, "jkl", 1300, -11500, -50, 4.0, false, 8);
|
||||
// addOneNode(pSchema, tagsLen, pSkipList, "tm4\0", 4, 50.5, "mno", 1400, -12000, -60, 5.0, true, 8);
|
||||
// addOneNode(pSchema, tagsLen, pSkipList, "tm5\0", 5, 60.5, "pqr", 1500, -12500, -70, 6.0, false, 8);
|
||||
// addOneNode(pSchema, tagsLen, pSkipList, "tm6\0", 6, 70.5, "stu", 1600, -13000, -80, 7.0, true, 8);
|
||||
//
|
||||
// return pSkipList;
|
||||
//}
|
||||
//
|
||||
// static SSkipList *createSkipList_binary(SSchema *pSchema, int32_t numOfTags) {
|
||||
// int32_t tagsLen = 0;
|
||||
// for (int32_t i = 0; i < numOfTags; ++i) {
|
||||
// tagsLen += pSchema[i].bytes;
|
||||
// }
|
||||
//
|
||||
// SSkipList *pSkipList = SSkipListCreate(10, pSchema[0].type, 4);
|
||||
//
|
||||
// addOneNode_binary(pSchema, tagsLen, pSkipList, "tm0\0", 0, 10.5, "abc", 1000, -10000, -20, 1.0, true, 8);
|
||||
// addOneNode_binary(pSchema, tagsLen, pSkipList, "tm1\0", 1, 20.5, "def", 1100, -10500, -30, 2.0, false, 8);
|
||||
// addOneNode_binary(pSchema, tagsLen, pSkipList, "tm2\0", 2, 30.5, "ghi", 1200, -11000, -40, 3.0, true, 8);
|
||||
// addOneNode_binary(pSchema, tagsLen, pSkipList, "tm3\0", 3, 40.5, "jkl", 1300, -11500, -50, 4.0, false, 8);
|
||||
// addOneNode_binary(pSchema, tagsLen, pSkipList, "tm4\0", 4, 50.5, "mno", 1400, -12000, -60, 5.0, true, 8);
|
||||
// addOneNode_binary(pSchema, tagsLen, pSkipList, "tm5\0", 5, 60.5, "pqr", 1500, -12500, -70, 6.0, false, 8);
|
||||
// addOneNode_binary(pSchema, tagsLen, pSkipList, "tm6\0", 6, 70.5, "stu", 1600, -13000, -80, 7.0, true, 8);
|
||||
//
|
||||
// return pSkipList;
|
||||
//}
|
||||
|
||||
//static void testQueryStr(SSchema *schema, int32_t numOfCols, char *sql, SSkipList *pSkipList, ResultObj *pResult) {
|
||||
// tExprNode *pExpr = NULL;
|
||||
// tSQLBinaryExprFromString(&pExpr, schema, numOfCols, sql, strlen(sql));
|
||||
//
|
||||
// char str[512] = {0};
|
||||
// int32_t len = 0;
|
||||
// if (pExpr == NULL) {
|
||||
// printf("-----error in parse syntax:%s\n\n", sql);
|
||||
// assert(pResult == NULL);
|
||||
// return;
|
||||
// }
|
||||
//
|
||||
// tSQLBinaryExprToString(pExpr, str, &len);
|
||||
// printf("expr is: %s\n", str);
|
||||
//
|
||||
// SArray *result = NULL;
|
||||
// // tExprTreeTraverse(pExpr, pSkipList, result, SSkipListNodeFilterCallback, &result);
|
||||
// // printf("the result is:%lld\n", result.num);
|
||||
// //
|
||||
// // bool findResult = false;
|
||||
// // for (int32_t i = 0; i < result.num; ++i) {
|
||||
// // STabObj *pm = (STabObj *)result.pRes[i];
|
||||
// // printf("meterid:%s,\t", pm->meterId);
|
||||
// //
|
||||
// // for (int32_t j = 0; j < pResult->numOfResult; ++j) {
|
||||
// // if (strcmp(pm->meterId, pResult->resultName[j]) == 0) {
|
||||
// // findResult = true;
|
||||
// // break;
|
||||
// // }
|
||||
// // }
|
||||
// // assert(findResult == true);
|
||||
// // findResult = false;
|
||||
// // }
|
||||
//
|
||||
// printf("\n\n");
|
||||
// tExprTreeDestroy(&pExpr, NULL);
|
||||
//}
|
||||
|
||||
#if 0
|
||||
static void Left2RightTest(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList) {
|
||||
char str[256] = {0};
|
||||
|
||||
char *t0[1] = {"tm0"};
|
||||
char *t1[1] = {"tm1"};
|
||||
char *sql = NULL;
|
||||
|
||||
ResultObj res = {1, {"tm1"}};
|
||||
testQueryStr(schema, numOfCols, "a=1", pSkipList, &res);
|
||||
|
||||
char *tt[1] = {"tm6"};
|
||||
setValue(&res, 1, tt);
|
||||
testQueryStr(schema, numOfCols, "a>=6", pSkipList, &res);
|
||||
|
||||
setValue(&res, 1, t0);
|
||||
testQueryStr(schema, numOfCols, "b<=10.6", pSkipList, &res);
|
||||
|
||||
strcpy(str, "c<>'pqr'");
|
||||
char *t2[6] = {"tm0", "tm1", "tm2", "tm3", "tm4", "tm6"};
|
||||
setValue(&res, 6, t2);
|
||||
testQueryStr(schema, numOfCols, str, pSkipList, &res);
|
||||
|
||||
strcpy(str, "c='abc'");
|
||||
setValue(&res, 1, t0);
|
||||
testQueryStr(schema, numOfCols, str, pSkipList, &res);
|
||||
|
||||
char *t3[6] = {"tm1", "tm2", "tm3", "tm4", "tm5", "tm6"};
|
||||
setValue(&res, 6, t3);
|
||||
testQueryStr(schema, numOfCols, "d>1050", pSkipList, &res);
|
||||
|
||||
char *t4[3] = {"tm4", "tm5", "tm6"};
|
||||
setValue(&res, 3, t4);
|
||||
testQueryStr(schema, numOfCols, "g>4.5980765", pSkipList, &res);
|
||||
|
||||
char *t5[4] = {"tm0", "tm2", "tm4", "tm6"};
|
||||
setValue(&res, 4, t5);
|
||||
testQueryStr(schema, numOfCols, "h=true", pSkipList, &res);
|
||||
|
||||
char *t6[3] = {"tm1", "tm3", "tm5"};
|
||||
setValue(&res, 3, t6);
|
||||
testQueryStr(schema, numOfCols, "h=0", pSkipList, &res);
|
||||
|
||||
sql = "(((b<40)))\0";
|
||||
char *t7[3] = {"tm0", "tm1", "tm2"};
|
||||
setValue(&res, 3, t7);
|
||||
testQueryStr(schema, numOfCols, sql, pSkipList, &res);
|
||||
|
||||
sql = "((a=1) or (a=10)) or ((b=12))";
|
||||
setValue(&res, 1, t1);
|
||||
testQueryStr(schema, numOfCols, sql, pSkipList, &res);
|
||||
|
||||
sql = "((((((a>0 and a<2))) or a=6) or a=3) or (b=50.5)) and h=0";
|
||||
char *t8[2] = {"tm1", "tm3"};
|
||||
setValue(&res, 2, t8);
|
||||
testQueryStr(schema, numOfCols, sql, pSkipList, &res);
|
||||
|
||||
char *tf[1] = {"tm6"};
|
||||
setValue(&res, 1, tf);
|
||||
testQueryStr(schema, numOfCols, "e = -13000", pSkipList, &res);
|
||||
|
||||
char *ft[5] = {"tm0", "tm1", "tm2", "tm3", "tm4"};
|
||||
setValue(&res, 5, ft);
|
||||
testQueryStr(schema, numOfCols, "f > -65", pSkipList, &res);
|
||||
}
|
||||
|
||||
void Right2LeftTest(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList) {
|
||||
ResultObj res = {1, {"tm1"}};
|
||||
testQueryStr(schema, numOfCols, "((1=a))", pSkipList, &res);
|
||||
|
||||
char *t9[2] = {"tm0", "tm1"};
|
||||
setValue(&res, 2, t9);
|
||||
testQueryStr(schema, numOfCols, "1>=a", pSkipList, &res);
|
||||
|
||||
char *t0[1] = {"tm0"};
|
||||
setValue(&res, 1, t0);
|
||||
testQueryStr(schema, numOfCols, "10.6>=b", pSkipList, &res);
|
||||
|
||||
char *t10[3] = {"tm1", "tm3", "tm5"};
|
||||
setValue(&res, 3, t10);
|
||||
testQueryStr(schema, numOfCols, "0=h", pSkipList, &res);
|
||||
}
|
||||
|
||||
static void IllegalExprTest(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList) {
|
||||
testQueryStr(schema, numOfCols, "h=", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "h<", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "a=1 and ", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "and or", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "and a = 1 or", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "(())", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "(", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "(a", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "(a)", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "())", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "a===1", pSkipList, NULL);
|
||||
testQueryStr(schema, numOfCols, "a=1 and ", pSkipList, NULL);
|
||||
}
|
||||
|
||||
static void Left2RightTest_binary(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList) {
|
||||
char str[256] = {0};
|
||||
char *sql = NULL;
|
||||
|
||||
char *t0[1] = {"tm0"};
|
||||
char *t1[1] = {"tm1"};
|
||||
|
||||
ResultObj res = {1, {"tm0"}};
|
||||
strcpy(str, "a='abc'");
|
||||
testQueryStr(schema, numOfCols, str, pSkipList, &res);
|
||||
|
||||
char *tt[1] = {"tm6"};
|
||||
setValue(&res, 1, tt);
|
||||
testQueryStr(schema, numOfCols, "c>=6", pSkipList, &res);
|
||||
|
||||
setValue(&res, 1, t0);
|
||||
testQueryStr(schema, numOfCols, "b<=10.6", pSkipList, &res);
|
||||
|
||||
strcpy(str, "a<>'pqr'");
|
||||
char *t2[6] = {"tm0", "tm1", "tm2", "tm3", "tm4", "tm6"};
|
||||
setValue(&res, 6, t2);
|
||||
testQueryStr(schema, numOfCols, str, pSkipList, &res);
|
||||
|
||||
strcpy(str, "a='abc'");
|
||||
setValue(&res, 1, t0);
|
||||
testQueryStr(schema, numOfCols, str, pSkipList, &res);
|
||||
|
||||
char *t3[6] = {"tm1", "tm2", "tm3", "tm4", "tm5", "tm6"};
|
||||
setValue(&res, 6, t3);
|
||||
testQueryStr(schema, numOfCols, "d>1050", pSkipList, &res);
|
||||
|
||||
char *t4[3] = {"tm4", "tm5", "tm6"};
|
||||
setValue(&res, 3, t4);
|
||||
testQueryStr(schema, numOfCols, "g>4.5980765", pSkipList, &res);
|
||||
|
||||
char *t5[4] = {"tm0", "tm2", "tm4", "tm6"};
|
||||
setValue(&res, 4, t5);
|
||||
testQueryStr(schema, numOfCols, "h=true", pSkipList, &res);
|
||||
|
||||
char *t6[3] = {"tm1", "tm3", "tm5"};
|
||||
setValue(&res, 3, t6);
|
||||
testQueryStr(schema, numOfCols, "h=0", pSkipList, &res);
|
||||
|
||||
sql = "(((b<40)))\0";
|
||||
char *t7[3] = {"tm0", "tm1", "tm2"};
|
||||
setValue(&res, 3, t7);
|
||||
testQueryStr(schema, numOfCols, sql, pSkipList, &res);
|
||||
|
||||
sql = "((c=1) or (c=10)) or ((b=12))\0";
|
||||
setValue(&res, 1, t1);
|
||||
testQueryStr(schema, numOfCols, sql, pSkipList, &res);
|
||||
|
||||
sql = "((((((c>0 and c<2))) or c=6) or c=3) or (b=50.5)) and h=false\0";
|
||||
char *t8[2] = {"tm1", "tm3"};
|
||||
setValue(&res, 2, t8);
|
||||
testQueryStr(schema, numOfCols, sql, pSkipList, &res);
|
||||
}
|
||||
|
||||
static void Right2LeftTest_binary(SSchema *schema, int32_t numOfCols, SSkipList *pSkipList) {
|
||||
char str[256] = {0};
|
||||
char *sql = NULL;
|
||||
|
||||
char *t0[1] = {"tm0"};
|
||||
char *t1[1] = {"tm1"};
|
||||
|
||||
ResultObj res = {1, {"tm0"}};
|
||||
strcpy(str, "'abc'=a");
|
||||
testQueryStr(schema, numOfCols, str, pSkipList, &res);
|
||||
|
||||
char *tt[1] = {"tm6"};
|
||||
setValue(&res, 1, tt);
|
||||
testQueryStr(schema, numOfCols, "6<=c", pSkipList, &res);
|
||||
|
||||
setValue(&res, 1, t0);
|
||||
testQueryStr(schema, numOfCols, "10.6>=b", pSkipList, &res);
|
||||
|
||||
strcpy(str, "'pqr'<>a");
|
||||
char *t2[6] = {"tm0", "tm1", "tm2", "tm3", "tm4", "tm6"};
|
||||
setValue(&res, 6, t2);
|
||||
testQueryStr(schema, numOfCols, str, pSkipList, &res);
|
||||
}
|
||||
|
||||
namespace {
|
||||
// two level expression tree
|
||||
tExprNode *createExpr1() {
|
||||
auto *pLeft = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
pLeft->nodeType = TSQL_NODE_COL;
|
||||
pLeft->pSchema = (SSchema*) calloc(1, sizeof(SSchema));
|
||||
|
||||
strcpy(pLeft->pSchema->name, "col_a");
|
||||
pLeft->pSchema->type = TSDB_DATA_TYPE_INT;
|
||||
pLeft->pSchema->bytes = sizeof(int32_t);
|
||||
pLeft->pSchema->colId = 1;
|
||||
|
||||
auto *pRight = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
pRight->nodeType = TSQL_NODE_VALUE;
|
||||
pRight->pVal = (tVariant*) calloc(1, sizeof(tVariant));
|
||||
|
||||
pRight->pVal->nType = TSDB_DATA_TYPE_INT;
|
||||
pRight->pVal->i64 = 12;
|
||||
|
||||
auto *pRoot = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
pRoot->nodeType = TSQL_NODE_EXPR;
|
||||
|
||||
pRoot->_node.optr = TSDB_RELATION_EQUAL;
|
||||
pRoot->_node.pLeft = pLeft;
|
||||
pRoot->_node.pRight = pRight;
|
||||
pRoot->_node.hasPK = true;
|
||||
|
||||
return pRoot;
|
||||
}
|
||||
|
||||
// thress level expression tree
|
||||
tExprNode* createExpr2() {
|
||||
auto *pLeft2 = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
pLeft2->nodeType = TSQL_NODE_COL;
|
||||
pLeft2->pSchema = (SSchema*) calloc(1, sizeof(SSchema));
|
||||
|
||||
strcpy(pLeft2->pSchema->name, "col_a");
|
||||
pLeft2->pSchema->type = TSDB_DATA_TYPE_BINARY;
|
||||
pLeft2->pSchema->bytes = 20;
|
||||
pLeft2->pSchema->colId = 1;
|
||||
|
||||
auto *pRight2 = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
pRight2->nodeType = TSQL_NODE_VALUE;
|
||||
pRight2->pVal = (tVariant*) calloc(1, sizeof(tVariant));
|
||||
|
||||
pRight2->pVal->nType = TSDB_DATA_TYPE_BINARY;
|
||||
const char* v = "hello world!";
|
||||
pRight2->pVal->pz = strdup(v);
|
||||
pRight2->pVal->nLen = strlen(v);
|
||||
|
||||
auto *p1 = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
p1->nodeType = TSQL_NODE_EXPR;
|
||||
|
||||
p1->_node.optr = TSDB_RELATION_LIKE;
|
||||
p1->_node.pLeft = pLeft2;
|
||||
p1->_node.pRight = pRight2;
|
||||
p1->_node.hasPK = false;
|
||||
|
||||
auto *pLeft1 = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
pLeft1->nodeType = TSQL_NODE_COL;
|
||||
pLeft1->pSchema = (SSchema*) calloc(1, sizeof(SSchema));
|
||||
|
||||
strcpy(pLeft1->pSchema->name, "col_b");
|
||||
pLeft1->pSchema->type = TSDB_DATA_TYPE_DOUBLE;
|
||||
pLeft1->pSchema->bytes = 8;
|
||||
pLeft1->pSchema->colId = 99;
|
||||
|
||||
auto *pRight1 = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
pRight1->nodeType = TSQL_NODE_VALUE;
|
||||
pRight1->pVal = (tVariant*) calloc(1, sizeof(tVariant));
|
||||
|
||||
pRight1->pVal->nType = TSDB_DATA_TYPE_DOUBLE;
|
||||
pRight1->pVal->dKey = 91.99;
|
||||
|
||||
auto *p2 = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
p2->nodeType = TSQL_NODE_EXPR;
|
||||
|
||||
p2->_node.optr = TSDB_RELATION_GREATER_EQUAL;
|
||||
p2->_node.pLeft = pLeft1;
|
||||
p2->_node.pRight = pRight1;
|
||||
p2->_node.hasPK = false;
|
||||
|
||||
auto *pRoot = (tExprNode*) calloc(1, sizeof(tExprNode));
|
||||
pRoot->nodeType = TSQL_NODE_EXPR;
|
||||
|
||||
pRoot->_node.optr = TSDB_RELATION_OR;
|
||||
pRoot->_node.pLeft = p1;
|
||||
pRoot->_node.pRight = p2;
|
||||
pRoot->_node.hasPK = true;
|
||||
return pRoot;
|
||||
}
|
||||
|
||||
void exprSerializeTest1() {
|
||||
tExprNode* p1 = createExpr1();
|
||||
SBufferWriter bw = tbufInitWriter(NULL, false);
|
||||
exprTreeToBinary(&bw, p1);
|
||||
|
||||
size_t size = tbufTell(&bw);
|
||||
ASSERT_TRUE(size > 0);
|
||||
char* b = tbufGetData(&bw, false);
|
||||
|
||||
tExprNode* p2 = exprTreeFromBinary(b, size);
|
||||
ASSERT_EQ(p1->nodeType, p2->nodeType);
|
||||
|
||||
ASSERT_EQ(p2->_node.optr, p1->_node.optr);
|
||||
ASSERT_EQ(p2->_node.pLeft->nodeType, p1->_node.pLeft->nodeType);
|
||||
ASSERT_EQ(p2->_node.pRight->nodeType, p1->_node.pRight->nodeType);
|
||||
|
||||
SSchema* s1 = p1->_node.pLeft->pSchema;
|
||||
SSchema* s2 = p2->_node.pLeft->pSchema;
|
||||
|
||||
ASSERT_EQ(s2->colId, s1->colId);
|
||||
ASSERT_EQ(s2->type, s1->type);
|
||||
ASSERT_EQ(s2->bytes, s1->bytes);
|
||||
ASSERT_STRCASEEQ(s2->name, s1->name);
|
||||
|
||||
tVariant* v1 = p1->_node.pRight->pVal;
|
||||
tVariant* v2 = p2->_node.pRight->pVal;
|
||||
|
||||
ASSERT_EQ(v1->nType, v2->nType);
|
||||
ASSERT_EQ(v1->i64, v2->i64);
|
||||
ASSERT_EQ(p1->_node.hasPK, p2->_node.hasPK);
|
||||
|
||||
tExprTreeDestroy(&p1, nullptr);
|
||||
tExprTreeDestroy(&p2, nullptr);
|
||||
|
||||
// tbufClose(&bw);
|
||||
}
|
||||
|
||||
void exprSerializeTest2() {
|
||||
tExprNode* p1 = createExpr2();
|
||||
SBufferWriter bw = tbufInitWriter(NULL, false);
|
||||
exprTreeToBinary(&bw, p1);
|
||||
|
||||
size_t size = tbufTell(&bw);
|
||||
ASSERT_TRUE(size > 0);
|
||||
char* b = tbufGetData(&bw, false);
|
||||
|
||||
tExprNode* p2 = exprTreeFromBinary(b, size);
|
||||
ASSERT_EQ(p1->nodeType, p2->nodeType);
|
||||
|
||||
ASSERT_EQ(p2->_node.optr, p1->_node.optr);
|
||||
ASSERT_EQ(p2->_node.pLeft->nodeType, p1->_node.pLeft->nodeType);
|
||||
ASSERT_EQ(p2->_node.pRight->nodeType, p1->_node.pRight->nodeType);
|
||||
|
||||
tExprNode* c1Left = p1->_node.pLeft;
|
||||
tExprNode* c2Left = p2->_node.pLeft;
|
||||
|
||||
ASSERT_EQ(c1Left->nodeType, c2Left->nodeType);
|
||||
|
||||
ASSERT_EQ(c2Left->nodeType, TSQL_NODE_EXPR);
|
||||
ASSERT_EQ(c2Left->_node.optr, TSDB_RELATION_LIKE);
|
||||
|
||||
ASSERT_STRCASEEQ(c2Left->_node.pLeft->pSchema->name, "col_a");
|
||||
ASSERT_EQ(c2Left->_node.pRight->nodeType, TSQL_NODE_VALUE);
|
||||
|
||||
ASSERT_STRCASEEQ(c2Left->_node.pRight->pVal->pz, "hello world!");
|
||||
|
||||
tExprNode* c1Right = p1->_node.pRight;
|
||||
tExprNode* c2Right = p2->_node.pRight;
|
||||
|
||||
ASSERT_EQ(c1Right->nodeType, c2Right->nodeType);
|
||||
ASSERT_EQ(c2Right->nodeType, TSQL_NODE_EXPR);
|
||||
ASSERT_EQ(c2Right->_node.optr, TSDB_RELATION_GREATER_EQUAL);
|
||||
ASSERT_EQ(c2Right->_node.pRight->pVal->dKey, 91.99);
|
||||
|
||||
ASSERT_EQ(p2->_node.hasPK, true);
|
||||
|
||||
tExprTreeDestroy(&p1, nullptr);
|
||||
tExprTreeDestroy(&p2, nullptr);
|
||||
|
||||
// tbufClose(&bw);
|
||||
}
|
||||
} // namespace
|
||||
TEST(testCase, astTest) {
|
||||
// exprSerializeTest2();
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,142 +0,0 @@
|
|||
#include <gtest/gtest.h>
|
||||
#include <sys/time.h>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
#include "taos.h"
|
||||
#include "qHistogram.h"
|
||||
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
|
||||
namespace {
|
||||
void doHistogramAddTest() {
|
||||
SHistogramInfo* pHisto = NULL;
|
||||
|
||||
/**
|
||||
* use arrayList, elapsed time is:
|
||||
* before:
|
||||
* 10,000,000 45sec, bin:1000 (-O0) / 17sec. bin:1000, (-O3)
|
||||
*
|
||||
* after:
|
||||
*
|
||||
*/
|
||||
struct timeval systemTime;
|
||||
gettimeofday(&systemTime, NULL);
|
||||
int64_t st =
|
||||
(int64_t)systemTime.tv_sec * 1000L + (uint64_t)systemTime.tv_usec / 1000;
|
||||
for (int32_t i = 0; i < 10000; ++i) {
|
||||
tHistogramAdd(&pHisto, i);
|
||||
// tHistogramPrint(pHisto);
|
||||
}
|
||||
//
|
||||
gettimeofday(&systemTime, NULL);
|
||||
int64_t et =
|
||||
(int64_t)systemTime.tv_sec * 1000L + (uint64_t)systemTime.tv_usec / 1000;
|
||||
printf("total elapsed time: %ld\n", et - st);
|
||||
|
||||
printf("elements: %d, slot:%d \n", pHisto->numOfElems, pHisto->numOfEntries);
|
||||
tHistogramPrint(pHisto);
|
||||
|
||||
printf("%ld\n", tHistogramSum(pHisto, 1.5));
|
||||
printf("%ld\n", tHistogramSum(pHisto, 2));
|
||||
printf("%ld\n", tHistogramSum(pHisto, 3));
|
||||
printf("%ld\n", tHistogramSum(pHisto, 4));
|
||||
printf("%ld\n", tHistogramSum(pHisto, 5));
|
||||
printf("%ld\n", tHistogramSum(pHisto, 6));
|
||||
|
||||
for (int32_t i = 399; i < 400; ++i) {
|
||||
printf("val:%d, %ld\n", i, tHistogramSum(pHisto, i));
|
||||
}
|
||||
|
||||
double ratio[] = {0 / 100, 20.0 / 100, 88.0 / 100, 100 / 100};
|
||||
double* res = tHistogramUniform(pHisto, ratio, 4);
|
||||
for (int32_t i = 0; i < 4; ++i) {
|
||||
printf("%f\n", res[i]);
|
||||
}
|
||||
|
||||
SHistogramInfo* pHisto1 = NULL;
|
||||
for (int32_t i = (90000 - 1); i >= 80000; --i) {
|
||||
tHistogramAdd(&pHisto1, i);
|
||||
}
|
||||
tHistogramPrint(pHisto1);
|
||||
|
||||
SHistogramInfo* pRes = tHistogramMerge(pHisto1, pHisto, MAX_HISTOGRAM_BIN);
|
||||
assert(pRes->numOfElems == pHisto->numOfElems + pHisto1->numOfElems);
|
||||
tHistogramPrint(pRes);
|
||||
|
||||
tHistogramDestroy(&pHisto);
|
||||
tHistogramDestroy(&pHisto1);
|
||||
tHistogramDestroy(&pRes);
|
||||
free(res);
|
||||
}
|
||||
void doHistogramRepeatTest() {
|
||||
SHistogramInfo* pHisto = NULL;
|
||||
struct timeval systemTime;
|
||||
|
||||
gettimeofday(&systemTime, NULL);
|
||||
int64_t st =
|
||||
(int64_t)systemTime.tv_sec * 1000L + (uint64_t)systemTime.tv_usec / 1000;
|
||||
|
||||
for (int32_t i = 0; i < 1000; ++i) {
|
||||
tHistogramAdd(&pHisto, -24 + i);
|
||||
// tHistogramPrint(pHisto);
|
||||
}
|
||||
|
||||
tHistogramDestroy(&pHisto);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/* test validate the names for table/database */
|
||||
TEST(testCase, histogram_binary_search) {
|
||||
SHistogramInfo* pHisto = tHistogramCreate(MAX_HISTOGRAM_BIN);
|
||||
|
||||
pHisto->numOfEntries = 10;
|
||||
for (int32_t i = 0; i < 10; ++i) {
|
||||
pHisto->elems[i].num = 1;
|
||||
pHisto->elems[i].val = i;
|
||||
}
|
||||
|
||||
int32_t idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 1);
|
||||
assert(idx == 1);
|
||||
|
||||
idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 9);
|
||||
assert(idx == 9);
|
||||
|
||||
idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 20);
|
||||
assert(idx == 10);
|
||||
|
||||
idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, -1);
|
||||
assert(idx == 0);
|
||||
|
||||
idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 3.9);
|
||||
assert(idx == 4);
|
||||
|
||||
free(pHisto);
|
||||
}
|
||||
|
||||
TEST(testCase, histogram_add) {
|
||||
doHistogramAddTest();
|
||||
doHistogramRepeatTest();
|
||||
}
|
||||
|
||||
TEST(testCase, heapsort) {
|
||||
// int32_t num = 20;
|
||||
//
|
||||
// SHeapEntry* pEntry = tHeapCreate(num);
|
||||
//
|
||||
// for(int32_t i=0; i<num; ++i) {
|
||||
// pEntry[i].val = num - 1 - i;
|
||||
// }
|
||||
//
|
||||
// tHeapSort(pEntry, num);
|
||||
//
|
||||
// for(int32_t i=0; i<num; ++i) {
|
||||
// printf("%lf, ", pEntry[i].val);
|
||||
// }
|
||||
//
|
||||
// printf("\n");
|
||||
//
|
||||
// free(pEntry);
|
||||
}
|
||||
|
|
@ -1,86 +0,0 @@
|
|||
#include <gtest/gtest.h>
|
||||
#include <sys/time.h>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
#include "qAggMain.h"
|
||||
#include "tcompare.h"
|
||||
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
|
||||
TEST(testCase, patternMatchTest) {
|
||||
SPatternCompareInfo info = PATTERN_COMPARE_INFO_INITIALIZER;
|
||||
|
||||
const char* str = "abcdef";
|
||||
int32_t ret = patternMatch("a%b%", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "tm01";
|
||||
ret = patternMatch("tm__", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "tkm1";
|
||||
ret = patternMatch("t%m1", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "tkm1";
|
||||
ret = patternMatch("%m1", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "";
|
||||
ret = patternMatch("%_", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
|
||||
|
||||
str = "1";
|
||||
ret = patternMatch("%__", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
|
||||
|
||||
str = "";
|
||||
ret = patternMatch("%", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = " ";
|
||||
ret = patternMatch("_", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "!";
|
||||
ret = patternMatch("%_", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "abcdefg";
|
||||
ret = patternMatch("abc%fg", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "abcdefgabcdeju";
|
||||
ret = patternMatch("abc%fg", str, 7, &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "abcdefgabcdeju";
|
||||
ret = patternMatch("abc%f_", str, 6, &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_NOWILDCARDMATCH);
|
||||
|
||||
str = "abcdefgabcdeju";
|
||||
ret = patternMatch("abc%f_", str, 1, &info); // pattern string is longe than the size
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_NOMATCH);
|
||||
|
||||
str = "abcdefgabcdeju";
|
||||
ret = patternMatch("ab", str, 2, &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "abcdefgabcdeju";
|
||||
ret = patternMatch("a%", str, 2, &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "abcdefgabcdeju";
|
||||
ret = patternMatch("a__", str, 2, &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_NOMATCH);
|
||||
|
||||
str = "carzero";
|
||||
ret = patternMatch("%o", str, strlen(str), &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
|
||||
str = "19";
|
||||
ret = patternMatch("%9", str, 2, &info);
|
||||
EXPECT_EQ(ret, TSDB_PATTERN_MATCH);
|
||||
}
|
||||
|
|
@ -1,257 +0,0 @@
|
|||
#include <gtest/gtest.h>
|
||||
#include <iostream>
|
||||
|
||||
#include "qResultbuf.h"
|
||||
#include "taos.h"
|
||||
#include "taosdef.h"
|
||||
|
||||
#include "qPercentile.h"
|
||||
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
|
||||
namespace {
|
||||
tMemBucket *createBigIntDataBucket(int32_t start, int32_t end) {
|
||||
tMemBucket *pBucket = tMemBucketCreate(sizeof(int64_t), TSDB_DATA_TYPE_BIGINT, start, end);
|
||||
for (int32_t i = start; i <= end; ++i) {
|
||||
int64_t val = i;
|
||||
tMemBucketPut(pBucket, &val, 1);
|
||||
}
|
||||
|
||||
return pBucket;
|
||||
}
|
||||
|
||||
tMemBucket *createIntDataBucket(int32_t start, int32_t end) {
|
||||
tMemBucket *pBucket = tMemBucketCreate(sizeof(int32_t), TSDB_DATA_TYPE_INT, start, end);
|
||||
|
||||
for (int32_t i = start; i <= end; ++i) {
|
||||
int32_t val = i;
|
||||
tMemBucketPut(pBucket, &val, 1);
|
||||
}
|
||||
|
||||
return pBucket;
|
||||
}
|
||||
|
||||
tMemBucket *createDoubleDataBucket(int32_t start, int32_t end) {
|
||||
tMemBucket *pBucket = tMemBucketCreate(sizeof(double), TSDB_DATA_TYPE_DOUBLE, start, end);
|
||||
for (int32_t i = start; i <= end; ++i) {
|
||||
double val = i;
|
||||
int32_t ret = tMemBucketPut(pBucket, &val, 1);
|
||||
if (ret != 0) {
|
||||
printf("value out of range:%f", val);
|
||||
}
|
||||
}
|
||||
|
||||
return pBucket;
|
||||
}
|
||||
|
||||
tMemBucket *createUnsignedDataBucket(int32_t start, int32_t end, int32_t type) {
|
||||
tMemBucket *pBucket = tMemBucketCreate(tDataTypes[type].bytes, type, start, end);
|
||||
for (int32_t i = start; i <= end; ++i) {
|
||||
uint64_t k = i;
|
||||
int32_t ret = tMemBucketPut(pBucket, &k, 1);
|
||||
if (ret != 0) {
|
||||
printf("value out of range:%" PRId64, k);
|
||||
}
|
||||
}
|
||||
|
||||
return pBucket;
|
||||
}
|
||||
|
||||
void intDataTest() {
|
||||
printf("running %s\n", __FUNCTION__);
|
||||
|
||||
tMemBucket *pBucket = NULL;
|
||||
double result = 0.;
|
||||
|
||||
pBucket = createIntDataBucket(0, 0);
|
||||
result = getPercentile(pBucket, 0);
|
||||
ASSERT_DOUBLE_EQ(result, 0);
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createIntDataBucket(0, 1);
|
||||
result = getPercentile(pBucket, 100);
|
||||
ASSERT_DOUBLE_EQ(result, 1);
|
||||
|
||||
result = getPercentile(pBucket, 0);
|
||||
ASSERT_DOUBLE_EQ(result, 0);
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createIntDataBucket(-1, 1);
|
||||
|
||||
result = getPercentile(pBucket, 50);
|
||||
ASSERT_DOUBLE_EQ(result, 0);
|
||||
|
||||
result = getPercentile(pBucket, 0);
|
||||
ASSERT_DOUBLE_EQ(result, -1);
|
||||
|
||||
result = getPercentile(pBucket, 75);
|
||||
ASSERT_DOUBLE_EQ(result, 0.5);
|
||||
|
||||
result = getPercentile(pBucket, 100);
|
||||
ASSERT_DOUBLE_EQ(result, 1);
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createIntDataBucket(0, 99999);
|
||||
result = getPercentile(pBucket, 50);
|
||||
ASSERT_DOUBLE_EQ(result, 49999.5);
|
||||
|
||||
tMemBucketDestroy(pBucket);
|
||||
}
|
||||
|
||||
void bigintDataTest() {
|
||||
printf("running %s\n", __FUNCTION__);
|
||||
|
||||
tMemBucket *pBucket = NULL;
|
||||
double result = 0.0;
|
||||
|
||||
pBucket = createBigIntDataBucket(-1000, 1000);
|
||||
result = getPercentile(pBucket, 50);
|
||||
ASSERT_DOUBLE_EQ(result, 0.);
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createBigIntDataBucket(-10000, 10000);
|
||||
result = getPercentile(pBucket, 100);
|
||||
ASSERT_DOUBLE_EQ(result, 10000.0);
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createBigIntDataBucket(-10000, 10000);
|
||||
result = getPercentile(pBucket, 75);
|
||||
ASSERT_DOUBLE_EQ(result, 5000.0);
|
||||
|
||||
tMemBucketDestroy(pBucket);
|
||||
}
|
||||
|
||||
void doubleDataTest() {
|
||||
printf("running %s\n", __FUNCTION__);
|
||||
|
||||
tMemBucket *pBucket = NULL;
|
||||
double result = 0;
|
||||
|
||||
pBucket = createDoubleDataBucket(-10, 10);
|
||||
result = getPercentile(pBucket, 0);
|
||||
ASSERT_DOUBLE_EQ(result, -10.0);
|
||||
|
||||
printf("result is: %lf\n", result);
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createDoubleDataBucket(-100000, 100000);
|
||||
result = getPercentile(pBucket, 25);
|
||||
ASSERT_DOUBLE_EQ(result, -50000);
|
||||
|
||||
printf("result is: %lf\n", result);
|
||||
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createDoubleDataBucket(-100000, 100000);
|
||||
result = getPercentile(pBucket, 50);
|
||||
ASSERT_DOUBLE_EQ(result, 0);
|
||||
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createDoubleDataBucket(-100000, 100000);
|
||||
result = getPercentile(pBucket, 75);
|
||||
ASSERT_DOUBLE_EQ(result, 50000);
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createDoubleDataBucket(-100000, 100000);
|
||||
|
||||
result = getPercentile(pBucket, 100);
|
||||
ASSERT_DOUBLE_EQ(result, 100000.0);
|
||||
|
||||
printf("result is: %lf\n", result);
|
||||
tMemBucketDestroy(pBucket);
|
||||
}
|
||||
|
||||
/*
|
||||
* large data test, we employ 0.1billion double data to calculated the percentile
|
||||
* which is 800MB data
|
||||
*/
|
||||
void largeDataTest() {
|
||||
printf("running : %s\n", __FUNCTION__);
|
||||
|
||||
tMemBucket *pBucket = NULL;
|
||||
double result = 0;
|
||||
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, NULL);
|
||||
|
||||
int64_t start = tv.tv_sec;
|
||||
printf("start time: %" PRId64 "\n", tv.tv_sec);
|
||||
pBucket = createDoubleDataBucket(0, 100000000);
|
||||
result = getPercentile(pBucket, 50);
|
||||
ASSERT_DOUBLE_EQ(result, 50000000);
|
||||
|
||||
gettimeofday(&tv, NULL);
|
||||
|
||||
printf("total elapsed time: %" PRId64 " sec.", -start + tv.tv_sec);
|
||||
printf("the result of %d is: %lf\n", 50, result);
|
||||
tMemBucketDestroy(pBucket);
|
||||
}
|
||||
|
||||
void qsortTest() {
|
||||
printf("running : %s\n", __FUNCTION__);
|
||||
|
||||
SSchema field[1] = {
|
||||
{TSDB_DATA_TYPE_INT, "k", sizeof(int32_t)},
|
||||
};
|
||||
|
||||
const int32_t num = 2000;
|
||||
|
||||
int32_t *d = (int32_t *)malloc(sizeof(int32_t) * num);
|
||||
for (int32_t i = 0; i < num; ++i) {
|
||||
d[i] = i % 4;
|
||||
}
|
||||
|
||||
const int32_t numOfOrderCols = 1;
|
||||
int32_t orderColIdx = 0;
|
||||
SColumnModel * pModel = createColumnModel(field, 1, 1000);
|
||||
tOrderDescriptor *pDesc = tOrderDesCreate(&orderColIdx, numOfOrderCols, pModel, 1);
|
||||
|
||||
tColDataQSort(pDesc, num, 0, num - 1, (char *)d, 1);
|
||||
|
||||
for (int32_t i = 0; i < num; ++i) {
|
||||
printf("%d\t", d[i]);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
destroyColumnModel(pModel);
|
||||
}
|
||||
|
||||
void unsignedDataTest() {
|
||||
printf("running %s\n", __FUNCTION__);
|
||||
|
||||
tMemBucket *pBucket = NULL;
|
||||
double result = 0.0;
|
||||
|
||||
pBucket = createUnsignedDataBucket(0, 1000, TSDB_DATA_TYPE_UINT);
|
||||
result = getPercentile(pBucket, 50);
|
||||
ASSERT_DOUBLE_EQ(result, 500.0);
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
pBucket = createUnsignedDataBucket(0, 10000, TSDB_DATA_TYPE_UBIGINT);
|
||||
result = getPercentile(pBucket, 100);
|
||||
ASSERT_DOUBLE_EQ(result, 10000.0);
|
||||
|
||||
result = getPercentile(pBucket, 0);
|
||||
ASSERT_DOUBLE_EQ(result, 0.0);
|
||||
|
||||
result = getPercentile(pBucket, 50);
|
||||
ASSERT_DOUBLE_EQ(result, 5000);
|
||||
|
||||
result = getPercentile(pBucket, 75);
|
||||
ASSERT_DOUBLE_EQ(result, 7500);
|
||||
tMemBucketDestroy(pBucket);
|
||||
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(testCase, percentileTest) {
|
||||
// qsortTest();
|
||||
intDataTest();
|
||||
bigintDataTest();
|
||||
doubleDataTest();
|
||||
unsignedDataTest();
|
||||
largeDataTest();
|
||||
}
|
||||
|
|
@ -0,0 +1,163 @@
|
|||
#include <gtest/gtest.h>
|
||||
#include <iostream>
|
||||
|
||||
#include "qResultbuf.h"
|
||||
#include "taos.h"
|
||||
#include "taosdef.h"
|
||||
|
||||
#include "qFilter.h"
|
||||
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
|
||||
namespace {
|
||||
|
||||
void intDataTest() {
|
||||
printf("running %s\n", __FUNCTION__);
|
||||
int32_t s0[3] = {-100, 1, 3};
|
||||
int32_t e0[3] = {0 , 2, 4};
|
||||
int64_t s1[3] = {INT64_MIN, 0 , 3};
|
||||
int64_t e1[3] = {100 , 50, 4};
|
||||
int64_t s2[5] = {1 , 3 , 10,30,70};
|
||||
int64_t e2[5] = {10, 100, 20,50,120};
|
||||
int64_t s3[3] = {1 , 20 , 5};
|
||||
int64_t e3[3] = {10, 100, 25};
|
||||
|
||||
int32_t rs0[3];
|
||||
int32_t re0[3];
|
||||
int64_t rs1[3];
|
||||
int64_t re1[3];
|
||||
int64_t rs2[5];
|
||||
int64_t re2[5];
|
||||
int64_t rs3[5];
|
||||
int64_t re3[5];
|
||||
|
||||
int32_t num = 0;
|
||||
|
||||
void *h = filterInitMergeRange(TSDB_DATA_TYPE_INT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s0)/sizeof(s0[0]); ++i) {
|
||||
filterAddMergeRange(h, s0 + i, e0 + i, TSDB_RELATION_AND);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 0);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
|
||||
h = filterInitMergeRange(TSDB_DATA_TYPE_INT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s0)/sizeof(s0[0]); ++i) {
|
||||
filterAddMergeRange(h, s0 + i, e0 + i, TSDB_RELATION_OR);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 3);
|
||||
filterGetMergeRangeRes(h, rs0, re0);
|
||||
ASSERT_EQ(rs0[0], -100);
|
||||
ASSERT_EQ(re0[0], 0);
|
||||
ASSERT_EQ(rs0[1], 1);
|
||||
ASSERT_EQ(re0[1], 2);
|
||||
ASSERT_EQ(rs0[2], 3);
|
||||
ASSERT_EQ(re0[2], 4);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
|
||||
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s1)/sizeof(s1[0]); ++i) {
|
||||
filterAddMergeRange(h, s1 + i, e1 + i, TSDB_RELATION_AND);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 1);
|
||||
filterGetMergeRangeRes(h, rs1, re1);
|
||||
ASSERT_EQ(rs1[0], 3);
|
||||
ASSERT_EQ(re1[0], 4);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s1)/sizeof(s1[0]); ++i) {
|
||||
filterAddMergeRange(h, s1 + i, e1 + i, TSDB_RELATION_OR);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 1);
|
||||
filterGetMergeRangeRes(h, rs1, re1);
|
||||
ASSERT_EQ(rs1[0], INT64_MIN);
|
||||
ASSERT_EQ(re1[0], 100);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
|
||||
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) {
|
||||
filterAddMergeRange(h, s2 + i, e2 + i, TSDB_RELATION_AND);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 0);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) {
|
||||
filterAddMergeRange(h, s2 + i, e2 + i, TSDB_RELATION_OR);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 1);
|
||||
filterGetMergeRangeRes(h, rs2, re2);
|
||||
ASSERT_EQ(rs2[0], 1);
|
||||
ASSERT_EQ(re2[0], 120);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
|
||||
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) {
|
||||
filterAddMergeRange(h, s2 + i, e2 + i, i % 2 ? TSDB_RELATION_OR : TSDB_RELATION_AND);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 0);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) {
|
||||
filterAddMergeRange(h, s2 + i, e2 + i, i % 2 ? TSDB_RELATION_AND : TSDB_RELATION_OR);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 1);
|
||||
filterGetMergeRangeRes(h, rs2, re2);
|
||||
ASSERT_EQ(rs2[0], 70);
|
||||
ASSERT_EQ(re2[0], 120);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
|
||||
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s3)/sizeof(s3[0]); ++i) {
|
||||
filterAddMergeRange(h, s3 + i, e3 + i, TSDB_RELATION_AND);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 0);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
|
||||
for (int32_t i = 0; i < sizeof(s3)/sizeof(s3[0]); ++i) {
|
||||
filterAddMergeRange(h, s3 + i, e3 + i, TSDB_RELATION_OR);
|
||||
}
|
||||
filterGetMergeRangeNum(h, &num);
|
||||
ASSERT_EQ(num, 1);
|
||||
filterGetMergeRangeRes(h, rs3, re3);
|
||||
ASSERT_EQ(rs3[0], 1);
|
||||
ASSERT_EQ(re3[0], 100);
|
||||
filterFreeMergeRange(h);
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(testCase, rangeMergeTest) {
|
||||
intDataTest();
|
||||
|
||||
}
|
||||
|
|
@ -1,163 +0,0 @@
|
|||
#include <gtest/gtest.h>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
#include "qResultbuf.h"
|
||||
#include "taos.h"
|
||||
#include "tsdb.h"
|
||||
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
|
||||
namespace {
|
||||
// simple test
|
||||
void simpleTest() {
|
||||
SDiskbasedResultBuf* pResultBuf = NULL;
|
||||
int32_t ret = createDiskbasedResultBuffer(&pResultBuf, 1024, 4096, 1);
|
||||
|
||||
int32_t pageId = 0;
|
||||
int32_t groupId = 0;
|
||||
|
||||
tFilePage* pBufPage = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
ASSERT_TRUE(pBufPage != NULL);
|
||||
|
||||
ASSERT_EQ(getResBufSize(pResultBuf), 1024);
|
||||
|
||||
SIDList list = getDataBufPagesIdList(pResultBuf, groupId);
|
||||
ASSERT_EQ(taosArrayGetSize(list), 1);
|
||||
ASSERT_EQ(getNumOfResultBufGroupId(pResultBuf), 1);
|
||||
|
||||
releaseResBufPage(pResultBuf, pBufPage);
|
||||
|
||||
tFilePage* pBufPage1 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
|
||||
tFilePage* t = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t == pBufPage1);
|
||||
|
||||
tFilePage* pBufPage2 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t1 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t1 == pBufPage2);
|
||||
|
||||
tFilePage* pBufPage3 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t2 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t2 == pBufPage3);
|
||||
|
||||
tFilePage* pBufPage4 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t3 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t3 == pBufPage4);
|
||||
|
||||
tFilePage* pBufPage5 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t4 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t4 == pBufPage5);
|
||||
|
||||
destroyResultBuf(pResultBuf);
|
||||
}
|
||||
|
||||
void writeDownTest() {
|
||||
SDiskbasedResultBuf* pResultBuf = NULL;
|
||||
int32_t ret = createDiskbasedResultBuffer(&pResultBuf, 1024, 4*1024, 1);
|
||||
|
||||
int32_t pageId = 0;
|
||||
int32_t writePageId = 0;
|
||||
int32_t groupId = 0;
|
||||
int32_t nx = 12345;
|
||||
|
||||
tFilePage* pBufPage = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
ASSERT_TRUE(pBufPage != NULL);
|
||||
|
||||
*(int32_t*)(pBufPage->data) = nx;
|
||||
writePageId = pageId;
|
||||
releaseResBufPage(pResultBuf, pBufPage);
|
||||
|
||||
tFilePage* pBufPage1 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t1 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t1 == pBufPage1);
|
||||
ASSERT_TRUE(pageId == 1);
|
||||
|
||||
tFilePage* pBufPage2 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t2 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t2 == pBufPage2);
|
||||
ASSERT_TRUE(pageId == 2);
|
||||
|
||||
tFilePage* pBufPage3 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t3 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t3 == pBufPage3);
|
||||
ASSERT_TRUE(pageId == 3);
|
||||
|
||||
tFilePage* pBufPage4 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t4 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t4 == pBufPage4);
|
||||
ASSERT_TRUE(pageId == 4);
|
||||
releaseResBufPage(pResultBuf, t4);
|
||||
|
||||
// flush the written page to disk, and read it out again
|
||||
tFilePage* pBufPagex = getResBufPage(pResultBuf, writePageId);
|
||||
ASSERT_EQ(*(int32_t*)pBufPagex->data, nx);
|
||||
|
||||
SArray* pa = getDataBufPagesIdList(pResultBuf, groupId);
|
||||
ASSERT_EQ(taosArrayGetSize(pa), 5);
|
||||
|
||||
destroyResultBuf(pResultBuf);
|
||||
}
|
||||
|
||||
void recyclePageTest() {
|
||||
SDiskbasedResultBuf* pResultBuf = NULL;
|
||||
int32_t ret = createDiskbasedResultBuffer(&pResultBuf, 1024, 4*1024, 1);
|
||||
|
||||
int32_t pageId = 0;
|
||||
int32_t writePageId = 0;
|
||||
int32_t groupId = 0;
|
||||
int32_t nx = 12345;
|
||||
|
||||
tFilePage* pBufPage = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
ASSERT_TRUE(pBufPage != NULL);
|
||||
releaseResBufPage(pResultBuf, pBufPage);
|
||||
|
||||
tFilePage* pBufPage1 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t1 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t1 == pBufPage1);
|
||||
ASSERT_TRUE(pageId == 1);
|
||||
|
||||
tFilePage* pBufPage2 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t2 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t2 == pBufPage2);
|
||||
ASSERT_TRUE(pageId == 2);
|
||||
|
||||
tFilePage* pBufPage3 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t3 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t3 == pBufPage3);
|
||||
ASSERT_TRUE(pageId == 3);
|
||||
|
||||
tFilePage* pBufPage4 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t4 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t4 == pBufPage4);
|
||||
ASSERT_TRUE(pageId == 4);
|
||||
releaseResBufPage(pResultBuf, t4);
|
||||
|
||||
tFilePage* pBufPage5 = getNewDataBuf(pResultBuf, groupId, &pageId);
|
||||
tFilePage* t5 = getResBufPage(pResultBuf, pageId);
|
||||
ASSERT_TRUE(t5 == pBufPage5);
|
||||
ASSERT_TRUE(pageId == 5);
|
||||
|
||||
// flush the written page to disk, and read it out again
|
||||
tFilePage* pBufPagex = getResBufPage(pResultBuf, writePageId);
|
||||
*(int32_t*)(pBufPagex->data) = nx;
|
||||
writePageId = pageId; // update the data
|
||||
releaseResBufPage(pResultBuf, pBufPagex);
|
||||
|
||||
tFilePage* pBufPagex1 = getResBufPage(pResultBuf, 1);
|
||||
|
||||
SArray* pa = getDataBufPagesIdList(pResultBuf, groupId);
|
||||
ASSERT_EQ(taosArrayGetSize(pa), 6);
|
||||
|
||||
destroyResultBuf(pResultBuf);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
|
||||
TEST(testCase, resultBufferTest) {
|
||||
srand(time(NULL));
|
||||
simpleTest();
|
||||
writeDownTest();
|
||||
recyclePageTest();
|
||||
}
|
||||
|
|
@ -1,515 +0,0 @@
|
|||
#include "os.h"
|
||||
#include <gtest/gtest.h>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
|
||||
#include "qTsbuf.h"
|
||||
#include "taos.h"
|
||||
#include "tsdb.h"
|
||||
#include "ttoken.h"
|
||||
#include "tutil.h"
|
||||
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
|
||||
|
||||
namespace {
|
||||
/**
|
||||
*
|
||||
* @param num total number
|
||||
* @param step gap between two consecutive ts
|
||||
* @return
|
||||
*/
|
||||
int64_t* createTsList(int32_t num, int64_t start, int32_t step) {
|
||||
int64_t* pList = (int64_t*)malloc(num * sizeof(int64_t));
|
||||
|
||||
for (int64_t i = 0; i < num; ++i) {
|
||||
pList[i] = start + i * step;
|
||||
}
|
||||
|
||||
return pList;
|
||||
}
|
||||
|
||||
// simple test
|
||||
void simpleTest() {
|
||||
STSBuf* pTSBuf = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
|
||||
// write 10 ts points
|
||||
int32_t num = 10;
|
||||
tVariant t = {0};
|
||||
t.nType = TSDB_DATA_TYPE_BIGINT;
|
||||
t.i64 = 1;
|
||||
|
||||
int64_t* list = createTsList(10, 10000000, 30);
|
||||
tsBufAppend(pTSBuf, 0, &t, (const char*)list, num * sizeof(int64_t));
|
||||
EXPECT_EQ(pTSBuf->tsOrder, TSDB_ORDER_ASC);
|
||||
|
||||
EXPECT_EQ(pTSBuf->tsData.len, sizeof(int64_t) * num);
|
||||
EXPECT_EQ(tVariantCompare(&pTSBuf->block.tag, &t), 0);
|
||||
EXPECT_EQ(pTSBuf->numOfGroups, 1);
|
||||
|
||||
tsBufFlush(pTSBuf);
|
||||
EXPECT_EQ(pTSBuf->tsData.len, 0);
|
||||
EXPECT_EQ(pTSBuf->block.numOfElem, num);
|
||||
|
||||
tsBufDestroy(pTSBuf);
|
||||
|
||||
free(list);
|
||||
}
|
||||
|
||||
// one large list of ts, the ts list need to be split into several small blocks
|
||||
void largeTSTest() {
|
||||
STSBuf* pTSBuf = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
|
||||
// write 10 ts points
|
||||
int32_t num = 1000000;
|
||||
tVariant t = {0};
|
||||
t.nType = TSDB_DATA_TYPE_BIGINT;
|
||||
t.i64 = 1;
|
||||
|
||||
int64_t* list = createTsList(num, 10000000, 30);
|
||||
tsBufAppend(pTSBuf, 0, &t, (const char*)list, num * sizeof(int64_t));
|
||||
|
||||
// the data has been flush to disk, no data in cache
|
||||
EXPECT_EQ(pTSBuf->tsData.len, 0);
|
||||
EXPECT_EQ(tVariantCompare(&pTSBuf->block.tag, &t), 0);
|
||||
EXPECT_EQ(pTSBuf->numOfGroups, 1);
|
||||
EXPECT_EQ(pTSBuf->tsOrder, TSDB_ORDER_ASC);
|
||||
|
||||
tsBufFlush(pTSBuf);
|
||||
EXPECT_EQ(pTSBuf->tsData.len, 0);
|
||||
EXPECT_EQ(pTSBuf->block.numOfElem, num);
|
||||
|
||||
tsBufDestroy(pTSBuf);
|
||||
free(list);
|
||||
}
|
||||
|
||||
void multiTagsTest() {
|
||||
STSBuf* pTSBuf = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
|
||||
int32_t num = 10000;
|
||||
tVariant t = {0};
|
||||
t.nType = TSDB_DATA_TYPE_BIGINT;
|
||||
|
||||
int64_t start = 10000000;
|
||||
int32_t numOfTags = 50;
|
||||
int32_t step = 30;
|
||||
|
||||
for (int32_t i = 0; i < numOfTags; ++i) {
|
||||
int64_t* list = createTsList(num, start, step);
|
||||
t.i64 = i;
|
||||
|
||||
tsBufAppend(pTSBuf, 0, &t, (const char*)list, num * sizeof(int64_t));
|
||||
free(list);
|
||||
|
||||
start += step * num;
|
||||
}
|
||||
|
||||
EXPECT_EQ(pTSBuf->tsOrder, TSDB_ORDER_ASC);
|
||||
EXPECT_EQ(pTSBuf->tsData.len, num * sizeof(int64_t));
|
||||
|
||||
EXPECT_EQ(pTSBuf->block.tag.i64, numOfTags - 1);
|
||||
EXPECT_EQ(pTSBuf->numOfGroups, 1);
|
||||
|
||||
tsBufFlush(pTSBuf);
|
||||
EXPECT_EQ(pTSBuf->tsData.len, 0);
|
||||
EXPECT_EQ(pTSBuf->block.numOfElem, num);
|
||||
|
||||
tsBufDestroy(pTSBuf);
|
||||
}
|
||||
|
||||
void multiVnodeTagsTest() {
|
||||
STSBuf* pTSBuf = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
|
||||
int32_t num = 10000;
|
||||
int64_t start = 10000000;
|
||||
int32_t numOfTags = 50;
|
||||
int32_t step = 30;
|
||||
|
||||
// 2000 vnodes
|
||||
for (int32_t j = 0; j < 20; ++j) {
|
||||
// vnodeId:0
|
||||
start = 10000000;
|
||||
tVariant t = {0};
|
||||
t.nType = TSDB_DATA_TYPE_BIGINT;
|
||||
|
||||
for (int32_t i = 0; i < numOfTags; ++i) {
|
||||
int64_t* list = createTsList(num, start, step);
|
||||
t.i64 = i;
|
||||
|
||||
tsBufAppend(pTSBuf, j, &t, (const char*)list, num * sizeof(int64_t));
|
||||
free(list);
|
||||
|
||||
start += step * num;
|
||||
}
|
||||
|
||||
EXPECT_EQ(pTSBuf->numOfGroups, j + 1);
|
||||
}
|
||||
|
||||
EXPECT_EQ(pTSBuf->tsOrder, TSDB_ORDER_ASC);
|
||||
EXPECT_EQ(pTSBuf->tsData.len, num * sizeof(int64_t));
|
||||
EXPECT_EQ(pTSBuf->block.tag.i64, numOfTags - 1);
|
||||
|
||||
EXPECT_EQ(pTSBuf->tsData.len, num * sizeof(int64_t));
|
||||
|
||||
EXPECT_EQ(pTSBuf->block.tag.i64, numOfTags - 1);
|
||||
|
||||
tsBufFlush(pTSBuf);
|
||||
EXPECT_EQ(pTSBuf->tsData.len, 0);
|
||||
EXPECT_EQ(pTSBuf->block.numOfElem, num);
|
||||
|
||||
tsBufDestroy(pTSBuf);
|
||||
}
|
||||
|
||||
void loadDataTest() {
|
||||
STSBuf* pTSBuf = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
|
||||
int32_t num = 10000;
|
||||
int64_t oldStart = 10000000;
|
||||
int32_t numOfTags = 50;
|
||||
int32_t step = 30;
|
||||
int32_t numOfVnode = 200;
|
||||
|
||||
// 10000 vnodes
|
||||
for (int32_t j = 0; j < numOfVnode; ++j) {
|
||||
// vnodeId:0
|
||||
int64_t start = 10000000;
|
||||
tVariant t = {0};
|
||||
t.nType = TSDB_DATA_TYPE_BIGINT;
|
||||
|
||||
for (int32_t i = 0; i < numOfTags; ++i) {
|
||||
int64_t* list = createTsList(num, start, step);
|
||||
t.i64 = i;
|
||||
|
||||
tsBufAppend(pTSBuf, j, &t, (const char*)list, num * sizeof(int64_t));
|
||||
printf("%d - %" PRIu64 "\n", i, list[0]);
|
||||
|
||||
free(list);
|
||||
start += step * num;
|
||||
}
|
||||
|
||||
EXPECT_EQ(pTSBuf->numOfGroups, j + 1);
|
||||
}
|
||||
|
||||
EXPECT_EQ(pTSBuf->tsOrder, TSDB_ORDER_ASC);
|
||||
|
||||
EXPECT_EQ(pTSBuf->tsData.len, num * sizeof(int64_t));
|
||||
EXPECT_EQ(pTSBuf->block.tag.i64, numOfTags - 1);
|
||||
|
||||
EXPECT_EQ(pTSBuf->tsData.len, num * sizeof(int64_t));
|
||||
|
||||
EXPECT_EQ(pTSBuf->block.tag.i64, numOfTags - 1);
|
||||
|
||||
tsBufFlush(pTSBuf);
|
||||
EXPECT_EQ(pTSBuf->tsData.len, 0);
|
||||
EXPECT_EQ(pTSBuf->block.numOfElem, num);
|
||||
|
||||
// create from exists file
|
||||
STSBuf* pNewBuf = tsBufCreateFromFile(pTSBuf->path, false);
|
||||
EXPECT_EQ(pNewBuf->tsOrder, pTSBuf->tsOrder);
|
||||
EXPECT_EQ(pNewBuf->numOfGroups, numOfVnode);
|
||||
EXPECT_EQ(pNewBuf->fileSize, pTSBuf->fileSize);
|
||||
|
||||
EXPECT_EQ(pNewBuf->pData[0].info.offset, pTSBuf->pData[0].info.offset);
|
||||
EXPECT_EQ(pNewBuf->pData[0].info.numOfBlocks, pTSBuf->pData[0].info.numOfBlocks);
|
||||
EXPECT_EQ(pNewBuf->pData[0].info.compLen, pTSBuf->pData[0].info.compLen);
|
||||
|
||||
EXPECT_STREQ(pNewBuf->path, pTSBuf->path);
|
||||
|
||||
tsBufResetPos(pNewBuf);
|
||||
|
||||
int64_t s = taosGetTimestampUs();
|
||||
printf("start:%" PRIu64 "\n", s);
|
||||
|
||||
int32_t x = 0;
|
||||
while (tsBufNextPos(pNewBuf)) {
|
||||
STSElem elem = tsBufGetElem(pNewBuf);
|
||||
if (++x == 100000000) {
|
||||
break;
|
||||
}
|
||||
|
||||
// printf("%d-%" PRIu64 "-%" PRIu64 "\n", elem.vnode, elem.tag, elem.ts);
|
||||
}
|
||||
|
||||
int64_t e = taosGetTimestampUs();
|
||||
printf("end:%" PRIu64 ", elapsed:%" PRIu64 ", total obj:%d\n", e, e - s, x);
|
||||
tsBufDestroy(pTSBuf);
|
||||
tsBufDestroy(pNewBuf);
|
||||
}
|
||||
|
||||
void randomIncTsTest() {}
|
||||
|
||||
void TSTraverse() {
|
||||
// 10000 vnodes
|
||||
int32_t num = 200000;
|
||||
int64_t oldStart = 10000000;
|
||||
int32_t numOfTags = 3;
|
||||
int32_t step = 30;
|
||||
int32_t numOfVnode = 2;
|
||||
|
||||
STSBuf* pTSBuf = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
|
||||
for (int32_t j = 0; j < numOfVnode; ++j) {
|
||||
// vnodeId:0
|
||||
int64_t start = 10000000;
|
||||
tVariant t = {0};
|
||||
t.nType = TSDB_DATA_TYPE_BIGINT;
|
||||
|
||||
for (int32_t i = 0; i < numOfTags; ++i) {
|
||||
int64_t* list = createTsList(num, start, step);
|
||||
t.i64 = i;
|
||||
|
||||
tsBufAppend(pTSBuf, j, &t, (const char*)list, num * sizeof(int64_t));
|
||||
printf("%d - %d - %" PRIu64 ", %" PRIu64 "\n", j, i, list[0], list[num - 1]);
|
||||
|
||||
free(list);
|
||||
start += step * num;
|
||||
|
||||
list = createTsList(num, start, step);
|
||||
tsBufAppend(pTSBuf, j, &t, (const char*)list, num * sizeof(int64_t));
|
||||
printf("%d - %d - %" PRIu64 ", %" PRIu64 "\n", j, i, list[0], list[num - 1]);
|
||||
free(list);
|
||||
|
||||
start += step * num;
|
||||
}
|
||||
|
||||
EXPECT_EQ(pTSBuf->numOfGroups, j + 1);
|
||||
}
|
||||
|
||||
tsBufResetPos(pTSBuf);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
// reverse traverse
|
||||
int64_t s = taosGetTimestampUs();
|
||||
printf("start:%" PRIu64 "\n", s);
|
||||
|
||||
pTSBuf->cur.order = TSDB_ORDER_DESC;
|
||||
|
||||
// complete reverse traverse
|
||||
int32_t x = 0;
|
||||
while (tsBufNextPos(pTSBuf)) {
|
||||
STSElem elem = tsBufGetElem(pTSBuf);
|
||||
// printf("%d-%" PRIu64 "-%" PRIu64 "\n", elem.vnode, elem.tag, elem.ts);
|
||||
}
|
||||
|
||||
// specify the data block with vnode and tags value
|
||||
tsBufResetPos(pTSBuf);
|
||||
pTSBuf->cur.order = TSDB_ORDER_DESC;
|
||||
|
||||
int32_t startVnode = 1;
|
||||
int32_t startTag = 2;
|
||||
|
||||
tVariant t = {0};
|
||||
t.nType = TSDB_DATA_TYPE_BIGINT;
|
||||
t.i64 = startTag;
|
||||
|
||||
tsBufGetElemStartPos(pTSBuf, startVnode, &t);
|
||||
|
||||
int32_t totalOutput = 10;
|
||||
while (1) {
|
||||
STSElem elem = tsBufGetElem(pTSBuf);
|
||||
printf("%d-%" PRIu64 "-%" PRIu64 "\n", elem.id, elem.tag->i64, elem.ts);
|
||||
|
||||
if (!tsBufNextPos(pTSBuf)) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (--totalOutput <= 0) {
|
||||
totalOutput = 10;
|
||||
|
||||
startTag -= 1;
|
||||
t.i64 = startTag;
|
||||
tsBufGetElemStartPos(pTSBuf, startVnode, &t);
|
||||
|
||||
if (startTag == 0) {
|
||||
startVnode -= 1;
|
||||
startTag = 3;
|
||||
}
|
||||
|
||||
if (startVnode < 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
// traverse
|
||||
pTSBuf->cur.order = TSDB_ORDER_ASC;
|
||||
tsBufResetPos(pTSBuf);
|
||||
|
||||
// complete forwards traverse
|
||||
while (tsBufNextPos(pTSBuf)) {
|
||||
STSElem elem = tsBufGetElem(pTSBuf);
|
||||
// printf("%d-%" PRIu64 "-%" PRIu64 "\n", elem.vnode, elem.tag, elem.ts);
|
||||
}
|
||||
|
||||
// specify the data block with vnode and tags value
|
||||
tsBufResetPos(pTSBuf);
|
||||
pTSBuf->cur.order = TSDB_ORDER_ASC;
|
||||
|
||||
startVnode = 1;
|
||||
startTag = 2;
|
||||
t.i64 = startTag;
|
||||
|
||||
tsBufGetElemStartPos(pTSBuf, startVnode, &t);
|
||||
|
||||
totalOutput = 10;
|
||||
while (1) {
|
||||
STSElem elem = tsBufGetElem(pTSBuf);
|
||||
printf("%d-%" PRIu64 "-%" PRIu64 "\n", elem.id, elem.tag->i64, elem.ts);
|
||||
|
||||
if (!tsBufNextPos(pTSBuf)) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (--totalOutput <= 0) {
|
||||
totalOutput = 10;
|
||||
|
||||
startTag -= 1;
|
||||
t.i64 = startTag;
|
||||
tsBufGetElemStartPos(pTSBuf, startVnode, &t);
|
||||
|
||||
if (startTag < 0) {
|
||||
startVnode -= 1;
|
||||
startTag = 3;
|
||||
}
|
||||
|
||||
if (startVnode < 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tsBufDestroy(pTSBuf);
|
||||
}
|
||||
|
||||
void performanceTest() {}
|
||||
|
||||
void emptyTagTest() {}
|
||||
|
||||
void invalidFileTest() {
|
||||
const char* cmd = "touch /tmp/test";
|
||||
|
||||
// create empty file
|
||||
system(cmd);
|
||||
|
||||
STSBuf* pNewBuf = tsBufCreateFromFile("/tmp/test", true);
|
||||
EXPECT_TRUE(pNewBuf == NULL);
|
||||
tsBufDestroy(pNewBuf);
|
||||
|
||||
pNewBuf = tsBufCreateFromFile("/tmp/911", true);
|
||||
EXPECT_TRUE(pNewBuf == NULL);
|
||||
|
||||
tsBufDestroy(pNewBuf);
|
||||
}
|
||||
|
||||
void mergeDiffVnodeBufferTest() {
|
||||
STSBuf* pTSBuf1 = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
STSBuf* pTSBuf2 = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
|
||||
int32_t step = 30;
|
||||
int32_t num = 1000;
|
||||
int32_t numOfTags = 10;
|
||||
|
||||
tVariant t = {0};
|
||||
t.nType = TSDB_DATA_TYPE_BIGINT;
|
||||
|
||||
// vnodeId:0
|
||||
int64_t start = 10000000;
|
||||
for (int32_t i = 0; i < numOfTags; ++i) {
|
||||
int64_t* list = createTsList(num, start, step);
|
||||
t.i64 = i;
|
||||
|
||||
tsBufAppend(pTSBuf1, 1, &t, (const char*)list, num * sizeof(int64_t));
|
||||
tsBufAppend(pTSBuf2, 9, &t, (const char*)list, num * sizeof(int64_t));
|
||||
|
||||
free(list);
|
||||
|
||||
start += step * num;
|
||||
}
|
||||
|
||||
tsBufFlush(pTSBuf2);
|
||||
|
||||
tsBufMerge(pTSBuf1, pTSBuf2);
|
||||
EXPECT_EQ(pTSBuf1->numOfGroups, 2);
|
||||
EXPECT_EQ(pTSBuf1->numOfTotal, numOfTags * 2 * num);
|
||||
|
||||
tsBufDisplay(pTSBuf1);
|
||||
|
||||
tsBufDestroy(pTSBuf2);
|
||||
tsBufDestroy(pTSBuf1);
|
||||
}
|
||||
|
||||
void mergeIdenticalVnodeBufferTest() {
|
||||
STSBuf* pTSBuf1 = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
STSBuf* pTSBuf2 = tsBufCreate(true, TSDB_ORDER_ASC);
|
||||
|
||||
tVariant t = {0};
|
||||
t.nType = TSDB_DATA_TYPE_BIGINT;
|
||||
|
||||
int32_t step = 30;
|
||||
int32_t num = 1000;
|
||||
int32_t numOfTags = 10;
|
||||
|
||||
// vnodeId:0
|
||||
int64_t start = 10000000;
|
||||
for (int32_t i = 0; i < numOfTags; ++i) {
|
||||
int64_t* list = createTsList(num, start, step);
|
||||
t.i64 = i;
|
||||
|
||||
tsBufAppend(pTSBuf1, 12, &t, (const char*)list, num * sizeof(int64_t));
|
||||
free(list);
|
||||
|
||||
start += step * num;
|
||||
}
|
||||
|
||||
for (int32_t i = numOfTags; i < numOfTags * 2; ++i) {
|
||||
int64_t* list = createTsList(num, start, step);
|
||||
|
||||
t.i64 = i;
|
||||
tsBufAppend(pTSBuf2, 77, &t, (const char*)list, num * sizeof(int64_t));
|
||||
free(list);
|
||||
|
||||
start += step * num;
|
||||
}
|
||||
|
||||
tsBufFlush(pTSBuf2);
|
||||
|
||||
tsBufMerge(pTSBuf1, pTSBuf2);
|
||||
EXPECT_EQ(pTSBuf1->numOfGroups, 2);
|
||||
EXPECT_EQ(pTSBuf1->numOfTotal, numOfTags * 2 * num);
|
||||
|
||||
tsBufResetPos(pTSBuf1);
|
||||
|
||||
int32_t count = 0;
|
||||
while (tsBufNextPos(pTSBuf1)) {
|
||||
STSElem elem = tsBufGetElem(pTSBuf1);
|
||||
|
||||
if (count++ < numOfTags * num) {
|
||||
EXPECT_EQ(elem.id, 12);
|
||||
} else {
|
||||
EXPECT_EQ(elem.id, 77);
|
||||
}
|
||||
|
||||
printf("%d-%" PRIu64 "-%" PRIu64 "\n", elem.id, elem.tag->i64, elem.ts);
|
||||
}
|
||||
|
||||
tsBufDestroy(pTSBuf1);
|
||||
tsBufDestroy(pTSBuf2);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
|
||||
//TODO add binary tag value test case
|
||||
TEST(testCase, tsBufTest) {
|
||||
simpleTest();
|
||||
largeTSTest();
|
||||
multiTagsTest();
|
||||
multiVnodeTagsTest();
|
||||
loadDataTest();
|
||||
invalidFileTest();
|
||||
// randomIncTsTest();
|
||||
TSTraverse();
|
||||
mergeDiffVnodeBufferTest();
|
||||
mergeIdenticalVnodeBufferTest();
|
||||
}
|
||||
|
|
@ -103,6 +103,8 @@ sql_error select * from stb1 where c7 < 'nuLl';
|
|||
sql_error select * from stb1 where c8 < 'nuLl';
|
||||
sql_error select * from stb1 where c9 > 'nuLl';
|
||||
sql_error select * from (select * from stb1 where c7=true) a, (select * from stb1 where c1 > 30) b;
|
||||
sql_error select a.ts,a.c1,a.c8 from (select * from stb1 where c7=true) a, (select * from stb1 where c1 > 30) b where a.ts=b.ts and a.c1 > 50 or b.c1 < 60;
|
||||
sql_error select a.ts,a.c1,a.c8 from (select * from stb1 where c7=true) a, (select * from stb1 where c1 > 30) b where a.ts=b.ts and ((a.c1 > 50 and a.c1 < 60) or (b.c2 > 60));
|
||||
|
||||
sql select * from stb1 where c2 > 3.0 or c2 < 60;
|
||||
if $rows != 28 then
|
||||
|
|
@ -1487,10 +1489,37 @@ if $data10 != @21-05-05 18:19:21.000@ then
|
|||
return -1
|
||||
endi
|
||||
|
||||
sql_error select a.ts,a.c1,a.c8 from (select * from stb1 where c7=true) a, (select * from stb1 where c1 > 30) b where a.ts=b.ts and a.c1 > 50 or b.c1 < 60;
|
||||
sql_error select a.ts,a.c1,a.c8 from (select * from stb1 where c7=true) a, (select * from stb1 where c1 > 30) b where a.ts=b.ts and ((a.c1 > 50 and a.c1 < 60) or (b.c2 > 60));
|
||||
sql select a.ts,b.ts,a.c1,b.u1,b.u2 from (select * from stb1) a, (select * from stb2) b where a.ts=b.ts and (a.c1 < 10 or a.c1 > 30) and (b.u1 < 5 or b.u1 > 5);
|
||||
if $rows != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:00.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-05-05 18:19:02.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-05-05 18:19:12.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != @21-05-05 18:19:14.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select a.ts,b.ts,a.c1,b.u1,b.u2 from (select * from stb1) a, (select * from stb2) b where a.ts=b.ts and a.c1 < 30 and b.u1 > 1 and a.c1 > 10 and b.u1 < 8 and b.u1<>5;
|
||||
if $rows != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:04.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-05-05 18:19:06.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-05-05 18:19:10.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
#!!!!!!!!!!!select a.* from (select * from tb1) a, (select * from tb2) b where a.ts = b.ts and a.f1 > 0 and b.f1 > 0;
|
||||
|
||||
|
||||
print "ts test"
|
||||
|
|
@ -1639,7 +1668,84 @@ if $data10 != @21-05-05 18:19:03.000@ then
|
|||
return -1
|
||||
endi
|
||||
|
||||
sql select a.ts,b.ts,a.c1,b.u1,b.u2 from (select * from stb1) a, (select * from stb2) b where a.ts=b.ts and (a.ts < '2021-05-05 18:19:03.000' or a.ts >= '2021-05-05 18:19:13.000') and (b.ts >= '2021-05-05 18:19:01.000' and b.ts <= '2021-05-05 18:19:14.000');
|
||||
if $rows != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:01.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-05-05 18:19:02.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-05-05 18:19:13.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != @21-05-05 18:19:14.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select a.ts,c.ts,b.c1,c.u1,c.u2 from (select * from stb1) a, (select * from stb1) b, (select * from stb2) c where a.ts=b.ts and b.ts=c.ts and a.ts <= '2021-05-05 18:19:12.000' and b.ts >= '2021-05-05 18:19:06.000' and c.ts >= '2021-05-05 18:19:08.000' and c.ts <= '2021-05-05 18:19:11.000' and a.ts != '2021-05-05 18:19:10.000';
|
||||
if $rows != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:08.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-05-05 18:19:09.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-05-05 18:19:11.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select ts,c1,c2,c8 from (select * from stb1) where (ts <= '2021-05-05 18:19:06.000' or ts >= '2021-05-05 18:19:13.000') and (ts >= '2021-05-05 18:19:02.000' and ts <= '2021-05-05 18:19:14.000') and ts != '2021-05-05 18:19:04.000';
|
||||
if $rows != 6 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:02.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-05-05 18:19:03.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-05-05 18:19:05.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != @21-05-05 18:19:06.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data40 != @21-05-05 18:19:13.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data50 != @21-05-05 18:19:14.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print "tbname test"
|
||||
sql_error select * from stb1 where tbname like '%3' and tbname like '%4';
|
||||
|
||||
sql select * from stb1 where tbname like 'tb%';
|
||||
if $rows != 29 then
|
||||
return -1
|
||||
endi
|
||||
|
||||
sql select * from stb1 where tbname like '%2';
|
||||
if $rows != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:08.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-05-05 18:19:09.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-05-05 18:19:10.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != @21-05-05 18:19:11.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print "tag test"
|
||||
sql select * from stb1 where t1 in (1,2) and t1 in (2,3);
|
||||
|
|
@ -1665,16 +1771,44 @@ if $rows != 0 then
|
|||
endi
|
||||
|
||||
print "join test"
|
||||
|
||||
|
||||
sql_error select * from tb1, tb2_1 where tb1.ts=tb2_1.ts or tb1.ts =tb2_1.ts;
|
||||
sql select tb1.ts from tb1, tb2_1 where tb1.ts=tb2_1.ts and tb1.ts > '2021-05-05 18:19:03.000' and tb2_1.ts < '2021-05-05 18:19:06.000';
|
||||
if $rows != 2 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:04.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-05-05 18:19:05.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
|
||||
print "column&ts test"
|
||||
sql_error select count(*) from stb1 where ts > 0 or c1 > 0;
|
||||
sql select * from stb1 where ts > '2021-05-05 18:19:03.000' and ts < '2021-05-05 18:19:20.000' and (c1 > 23 or c1 < 14) and c7 in (true) and c8 like '%2';
|
||||
if $rows != 3 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:05.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-05-05 18:19:13.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-05-05 18:19:17.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print "column&tbname test"
|
||||
sql_error select count(*) from stb1 where tbname like 'tb%' or c1 > 0;
|
||||
|
||||
sql select * from stb1 where tbname like '%3' and c6 < 34 and c5 != 33 and c4 > 31;
|
||||
if $rows != 1 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:13.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print "column&tag test"
|
||||
sql_error select * from stb1 where t1 > 0 or c1 > 0
|
||||
|
|
@ -1687,7 +1821,7 @@ sql_error select * from stb1 where c1 > 0 or t1 > 0 and c1 > 1
|
|||
sql_error select * from stb1 where t1 > 0 or t1 > 0 and c1 > 1
|
||||
sql_error select * from stb1 where (c1 > 0 and t1 > 0 ) or (t1 > 1 and c1 > 3)
|
||||
sql_error select * from stb1 where (c1 > 0 and t1 > 0 ) or t1 > 1
|
||||
|
||||
sql_error select a.ts,b.ts,a.c1,b.u1,b.u2 from (select * from stb1) a, (select * from stb2) b where a.ts=b.ts and a.t1=b.t1;
|
||||
|
||||
sql select * from stb1 where c1 < 63 and t1 > 5
|
||||
if $rows != 2 then
|
||||
|
|
@ -1726,6 +1860,8 @@ endi
|
|||
|
||||
|
||||
print "column&join test"
|
||||
sql_error select tb1.ts,tb1.c1,tb2_1.u1 from tb1, tb2_1 where tb1.ts=tb2_1.ts or tb1.c1 > 0;
|
||||
|
||||
|
||||
print "ts&tbname test"
|
||||
sql_error select count(*) from stb1 where ts > 0 or tbname like 'tb%';
|
||||
|
|
@ -1743,9 +1879,29 @@ endi
|
|||
if $data10 != @21-05-05 18:19:12.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print "ts&join test"
|
||||
sql_error select tb1.ts,tb1.c1,tb2_1.u1 from tb1, tb2_1 where tb1.ts=tb2_1.ts or tb1.ts > 0;
|
||||
sql select tb1.ts,tb1.c1,tb2_1.u1 from tb1, tb2_1 where tb1.ts=tb2_1.ts and (tb1.ts > '2021-05-05 18:19:05.000' or tb1.ts < '2021-05-05 18:19:03.000' or tb1.ts > 0);
|
||||
|
||||
|
||||
print "tbname&tag test"
|
||||
sql select * from stb1 where tbname like 'tb%' and (t1=1 or t2=2 or t3=3) and t1 > 2;
|
||||
if $rows != 4 then
|
||||
return -1
|
||||
endi
|
||||
if $data00 != @21-05-05 18:19:12.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data10 != @21-05-05 18:19:13.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data20 != @21-05-05 18:19:14.000@ then
|
||||
return -1
|
||||
endi
|
||||
if $data30 != @21-05-05 18:19:15.000@ then
|
||||
return -1
|
||||
endi
|
||||
|
||||
print "tbname&join test"
|
||||
|
||||
|
|
|
|||
|
|
@ -113,6 +113,7 @@ echo "rpcDebugFlag 143" >> $TAOS_CFG
|
|||
echo "tmrDebugFlag 131" >> $TAOS_CFG
|
||||
echo "cDebugFlag 143" >> $TAOS_CFG
|
||||
echo "udebugFlag 143" >> $TAOS_CFG
|
||||
echo "debugFlag 143" >> $TAOS_CFG
|
||||
echo "wal 0" >> $TAOS_CFG
|
||||
echo "asyncLog 0" >> $TAOS_CFG
|
||||
echo "locale en_US.UTF-8" >> $TAOS_CFG
|
||||
|
|
|
|||
Loading…
Reference in New Issue