xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

support ts range

This commit is contained in:
wpan 2021-07-02 18:18:33 +08:00
parent d7a3a975c7
commit f1a9b5890f
14 changed files with 914 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
src/client/src/tscSQLParser.c
View File

@ -4123,6 +4123,19 @@ static int32_t validateLikeExpr(tSqlExpr* pExpr, STableMeta* pTableMeta, int32_t
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t handleNeOptr(tSqlExpr** rexpr, tSqlExpr* expr) {
tSqlExpr* left = tSqlExprClone(expr);
tSqlExpr* right = expr;
left->tokenId = TK_LT;
right->tokenId = TK_GT;
*rexpr = tSqlExprCreate(left, right, TK_OR);
return TSDB_CODE_SUCCESS;
}
static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SCondExpr* pCondExpr, static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SCondExpr* pCondExpr,
int32_t* type, int32_t* tbIdx, int32_t parentOptr, tSqlExpr** columnExpr, tSqlExpr** tsExpr) { int32_t* type, int32_t* tbIdx, int32_t parentOptr, tSqlExpr** columnExpr, tSqlExpr** tsExpr) {
const char* msg1 = "table query cannot use tags filter"; const char* msg1 = "table query cannot use tags filter";
@ -4221,7 +4234,14 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
*type |= TSQL_EXPR_JOIN; *type |= TSQL_EXPR_JOIN;
} }
} else { } else {
ret = setNormalExprToCond(tsExpr, *pExpr, parentOptr); tSqlExpr *rexpr = NULL;
if ((*pExpr)->tokenId == TK_NE) {
handleNeOptr(&rexpr, *pExpr);
} else {
rexpr = *pExpr;
}
ret = setNormalExprToCond(tsExpr, rexpr, parentOptr);
if (type) { if (type) {
*type |= TSQL_EXPR_TS; *type |= TSQL_EXPR_TS;
} }
@ -4272,6 +4292,12 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
// do nothing // do nothing
// ret = setExprToCond(pCmd, &pCondExpr->pTagCond, // ret = setExprToCond(pCmd, &pCondExpr->pTagCond,
// *pExpr, NULL, parentOptr); // *pExpr, NULL, parentOptr);
tSqlExpr *rexpr = NULL;
if ((*pExpr)->tokenId == TK_NE && (pSchema->type != TSDB_DATA_TYPE_BINARY && pSchema->type != TSDB_DATA_TYPE_NCHAR && pSchema->type != TSDB_DATA_TYPE_BOOL)) {
handleNeOptr(&rexpr, *pExpr);
*pExpr = rexpr;
}
if (type) { if (type) {
*type |= TSQL_EXPR_TAG; *type |= TSQL_EXPR_TAG;
} }
@ -4286,7 +4312,14 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5); return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
} }
ret = setNormalExprToCond(columnExpr, *pExpr, parentOptr); tSqlExpr *rexpr = NULL;
if ((*pExpr)->tokenId == TK_NE && (pSchema->type != TSDB_DATA_TYPE_BINARY && pSchema->type != TSDB_DATA_TYPE_NCHAR && pSchema->type != TSDB_DATA_TYPE_BOOL)) {
handleNeOptr(&rexpr, *pExpr);
} else {
rexpr = *pExpr;
}
ret = setNormalExprToCond(columnExpr, rexpr, parentOptr);
*pExpr = NULL; // remove it from expr tree *pExpr = NULL; // remove it from expr tree
} }
@ -4575,37 +4608,40 @@ int32_t mergeTimeRange(SSqlCmd* pCmd, STimeWindow* res, STimeWindow* win, int32_
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
static int32_t createTimeRangeExpr(tSqlExpr** pExpr, STimeWindow* win, uint32_t tokenId) {
*pExpr = calloc(1, sizeof(tSqlExpr));
static int32_t getTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr, STimeWindow* win) { (*pExpr)->type = SQL_NODE_VALUE;
(*pExpr)->tokenId = tokenId;
(*pExpr)->value.nType = TSDB_DATA_TYPE_VALUE_ARRAY;
(*pExpr)->value.nLen = 2;
(*pExpr)->value.arr = taosArrayInit(2, sizeof(int64_t));
taosArrayPush((*pExpr)->value.arr, &win->skey);
taosArrayPush((*pExpr)->value.arr, &win->ekey);
return TSDB_CODE_SUCCESS;
}
static int32_t convertTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr* pExpr) {
const char* msg0 = "invalid timestamp or operator for timestamp"; const char* msg0 = "invalid timestamp or operator for timestamp";
int32_t code = 0; int32_t code = 0;
STimeWindow win2 = {.skey = INT64_MIN, .ekey = INT64_MAX}; STimeWindow win = {.skey = INT64_MIN, .ekey = INT64_MAX};
if (pExpr == NULL) { if (pExpr == NULL) {
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
if (!tSqlExprIsParentOfLeaf(pExpr)) { if (!tSqlExprIsParentOfLeaf(pExpr)) {
if (pExpr->tokenId == TK_OR) { code = convertTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pLeft);
code = getTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pLeft, win);
if (code) { if (code) {
return code; return code;
} }
code = getTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pRight, &win2); code = convertTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pRight);
if (code) { if (code) {
return code; return code;
} }
return mergeTimeRange(pCmd, win, &win2, TSDB_RELATION_OR);
}
code = getTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pLeft, win);
if (code) {
return code;
}
return getTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pRight, win);
} else { } else {
SColumnIndex index = COLUMN_INDEX_INITIALIZER; SColumnIndex index = COLUMN_INDEX_INITIALIZER;
if (getColumnIndexByName(pCmd, &pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) { if (getColumnIndexByName(pCmd, &pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
@ -4617,11 +4653,13 @@ static int32_t getTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlE
tSqlExpr* pRight = pExpr->pRight; tSqlExpr* pRight = pExpr->pRight;
if (getTimeRange(&win2, pRight, pExpr->tokenId, tinfo.precision) != TSDB_CODE_SUCCESS) { if (getTimeRange(&win, pRight, pExpr->tokenId, tinfo.precision) != TSDB_CODE_SUCCESS) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0); return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
} }
return mergeTimeRange(pCmd, win, &win2, TSDB_RELATION_AND); createTimeRangeExpr(&pExpr->pRight, &win, pRight->tokenId);
tSqlExprDestroy(pRight);
} }
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
@ -4950,6 +4988,42 @@ int32_t mergeJoinNodes(SQueryInfo* pQueryInfo, SSqlObj* pSql) {
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
static int32_t getQueryTimeRange(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr) {
int32_t ret = TSDB_CODE_SUCCESS;
if (*pExpr == NULL) {
return ret;
}
//multiple tables's query time range mixed together
tExprNode* p = NULL;
SFilterInfo *filter = NULL;
SArray* colList = taosArrayInit(10, sizeof(SColIndex));
ret = exprTreeFromSqlExpr(pCmd, &p, *pExpr, pQueryInfo, colList, NULL);
if (ret != TSDB_CODE_SUCCESS) {
goto _ret;
}
ret = filterInitFromTree(p, &filter);
if (ret != TSDB_CODE_SUCCESS) {
goto _ret;
}
ret = filterGetTimeRange(filter, &pQueryInfo->window);
_ret:
tExprTreeDestroy(p, NULL);
if (ret) {
return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), tstrerror(ret));
}
return ret;
}
int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSql) { int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSql) {
if (pExpr == NULL) { if (pExpr == NULL) {
@ -5000,12 +5074,11 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
} }
// 2. get the query time range // 2. get the query time range
STimeWindow win = {.skey = INT64_MIN, .ekey = INT64_MAX}; if ((ret = convertTimeRangeFromExpr(&pSql->cmd, pQueryInfo, condExpr.pTimewindow)) != TSDB_CODE_SUCCESS) {
if ((ret = getTimeRangeFromExpr(&pSql->cmd, pQueryInfo, condExpr.pTimewindow, &win)) != TSDB_CODE_SUCCESS) {
return ret; return ret;
} }
if ((ret = mergeTimeRange(&pSql->cmd, &pQueryInfo->window,&win, TSDB_RELATION_AND)) != TSDB_CODE_SUCCESS) { if ((ret = getQueryTimeRange(&pSql->cmd, pQueryInfo, &condExpr.pTimewindow)) != TSDB_CODE_SUCCESS) {
return ret; return ret;
} }
@ -5024,14 +5097,6 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
goto PARSE_WHERE_EXIT; goto PARSE_WHERE_EXIT;
} }
/*
if (taosArrayGetSize(pQueryInfo->pUpstream) > 0 ) {
if ((ret = getColumnQueryCondInfo(&pSql->cmd, pQueryInfo, condExpr.pTimewindow, TK_AND)) != TSDB_CODE_SUCCESS) {
goto PARSE_WHERE_EXIT;
}
}
*/
if ((ret = getColQueryCondExpr(&pSql->cmd, pQueryInfo, &condExpr.pColumnCond)) != TSDB_CODE_SUCCESS) { if ((ret = getColQueryCondExpr(&pSql->cmd, pQueryInfo, &condExpr.pColumnCond)) != TSDB_CODE_SUCCESS) {
goto PARSE_WHERE_EXIT; goto PARSE_WHERE_EXIT;
} }

4
src/common/src/texpr.c
View File

@ -118,7 +118,7 @@ void tExprTreeDestroy(tExprNode *pNode, void (*fp)(void *)) {
} else if (pNode->nodeType == TSQL_NODE_VALUE) { } else if (pNode->nodeType == TSQL_NODE_VALUE) {
tVariantDestroy(pNode->pVal); tVariantDestroy(pNode->pVal);
} else if (pNode->nodeType == TSQL_NODE_COL) { } else if (pNode->nodeType == TSQL_NODE_COL) {
free(pNode->pSchema); tfree(pNode->pSchema);
} }
free(pNode); free(pNode);
@ -435,7 +435,7 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
expr->_node.optr = TSDB_RELATION_IN; expr->_node.optr = TSDB_RELATION_IN;
tVariant* pVal = exception_calloc(1, sizeof(tVariant)); tVariant* pVal = exception_calloc(1, sizeof(tVariant));
right->pVal = pVal; right->pVal = pVal;
pVal->nType = TSDB_DATA_TYPE_ARRAY; pVal->nType = TSDB_DATA_TYPE_POINTER_ARRAY;
pVal->arr = taosArrayInit(2, POINTER_BYTES); pVal->arr = taosArrayInit(2, POINTER_BYTES);
const char* cond = tbnameCond + QUERY_COND_REL_PREFIX_IN_LEN; const char* cond = tbnameCond + QUERY_COND_REL_PREFIX_IN_LEN;

133
src/common/src/ttypes.c
View File

@ -368,21 +368,21 @@ static void getStatics_nchr(const void *pData, int32_t numOfRow, int64_t *min, i
} }
tDataTypeDescriptor tDataTypes[15] = { tDataTypeDescriptor tDataTypes[15] = {
{TSDB_DATA_TYPE_NULL, 6,1, "NOTYPE", NULL, NULL, NULL}, {TSDB_DATA_TYPE_NULL, 6, 1, "NOTYPE", 0, 0, NULL, NULL, NULL},
{TSDB_DATA_TYPE_BOOL, 4, CHAR_BYTES, "BOOL", tsCompressBool, tsDecompressBool, getStatics_bool}, {TSDB_DATA_TYPE_BOOL, 4, CHAR_BYTES, "BOOL", false, true, tsCompressBool, tsDecompressBool, getStatics_bool},
{TSDB_DATA_TYPE_TINYINT, 7, CHAR_BYTES, "TINYINT", tsCompressTinyint, tsDecompressTinyint, getStatics_i8}, {TSDB_DATA_TYPE_TINYINT, 7, CHAR_BYTES, "TINYINT", INT8_MIN, INT8_MAX, tsCompressTinyint, tsDecompressTinyint, getStatics_i8},
{TSDB_DATA_TYPE_SMALLINT, 8, SHORT_BYTES, "SMALLINT", tsCompressSmallint, tsDecompressSmallint, getStatics_i16}, {TSDB_DATA_TYPE_SMALLINT, 8, SHORT_BYTES, "SMALLINT", INT16_MIN, INT16_MAX, tsCompressSmallint, tsDecompressSmallint, getStatics_i16},
{TSDB_DATA_TYPE_INT, 3, INT_BYTES, "INT", tsCompressInt, tsDecompressInt, getStatics_i32}, {TSDB_DATA_TYPE_INT, 3, INT_BYTES, "INT", INT32_MIN, INT32_MAX, tsCompressInt, tsDecompressInt, getStatics_i32},
{TSDB_DATA_TYPE_BIGINT, 6, LONG_BYTES, "BIGINT", tsCompressBigint, tsDecompressBigint, getStatics_i64}, {TSDB_DATA_TYPE_BIGINT, 6, LONG_BYTES, "BIGINT", INT64_MIN, INT64_MAX, tsCompressBigint, tsDecompressBigint, getStatics_i64},
{TSDB_DATA_TYPE_FLOAT, 5, FLOAT_BYTES, "FLOAT", tsCompressFloat, tsDecompressFloat, getStatics_f}, {TSDB_DATA_TYPE_FLOAT, 5, FLOAT_BYTES, "FLOAT", 0, 0, tsCompressFloat, tsDecompressFloat, getStatics_f},
{TSDB_DATA_TYPE_DOUBLE, 6, DOUBLE_BYTES, "DOUBLE", tsCompressDouble, tsDecompressDouble, getStatics_d}, {TSDB_DATA_TYPE_DOUBLE, 6, DOUBLE_BYTES, "DOUBLE", 0, 0, tsCompressDouble, tsDecompressDouble, getStatics_d},
{TSDB_DATA_TYPE_BINARY, 6, 0, "BINARY", tsCompressString, tsDecompressString, getStatics_bin}, {TSDB_DATA_TYPE_BINARY, 6, 0, "BINARY", 0, 0, tsCompressString, tsDecompressString, getStatics_bin},
{TSDB_DATA_TYPE_TIMESTAMP, 9, LONG_BYTES, "TIMESTAMP", tsCompressTimestamp, tsDecompressTimestamp, getStatics_i64}, {TSDB_DATA_TYPE_TIMESTAMP, 9, LONG_BYTES, "TIMESTAMP", INT64_MIN, INT64_MAX, tsCompressTimestamp, tsDecompressTimestamp, getStatics_i64},
{TSDB_DATA_TYPE_NCHAR, 5, 8, "NCHAR", tsCompressString, tsDecompressString, getStatics_nchr}, {TSDB_DATA_TYPE_NCHAR, 5, 8, "NCHAR", 0, 0, tsCompressString, tsDecompressString, getStatics_nchr},
{TSDB_DATA_TYPE_UTINYINT, 16, CHAR_BYTES, "TINYINT UNSIGNED", tsCompressTinyint, tsDecompressTinyint, getStatics_u8}, {TSDB_DATA_TYPE_UTINYINT, 16, CHAR_BYTES, "TINYINT UNSIGNED", 0, UINT8_MAX, tsCompressTinyint, tsDecompressTinyint, getStatics_u8},
{TSDB_DATA_TYPE_USMALLINT, 17, SHORT_BYTES, "SMALLINT UNSIGNED", tsCompressSmallint, tsDecompressSmallint, getStatics_u16}, {TSDB_DATA_TYPE_USMALLINT, 17, SHORT_BYTES, "SMALLINT UNSIGNED", 0, UINT16_MAX, tsCompressSmallint, tsDecompressSmallint, getStatics_u16},
{TSDB_DATA_TYPE_UINT, 12, INT_BYTES, "INT UNSIGNED", tsCompressInt, tsDecompressInt, getStatics_u32}, {TSDB_DATA_TYPE_UINT, 12, INT_BYTES, "INT UNSIGNED", 0, UINT32_MAX, tsCompressInt, tsDecompressInt, getStatics_u32},
{TSDB_DATA_TYPE_UBIGINT, 15, LONG_BYTES, "BIGINT UNSIGNED", tsCompressBigint, tsDecompressBigint, getStatics_u64}, {TSDB_DATA_TYPE_UBIGINT, 15, LONG_BYTES, "BIGINT UNSIGNED", 0, UINT64_MAX, tsCompressBigint, tsDecompressBigint, getStatics_u64},
}; };
char tTokenTypeSwitcher[13] = { char tTokenTypeSwitcher[13] = {
@ -560,65 +560,50 @@ void assignVal(char *val, const char *src, int32_t len, int32_t type) {
} }
} }
int8_t getInt8Val(void *s) { void operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type) {
return (int8_t)GET_INT8_VAL(s); if (optr == TSDB_BINARY_OP_ADD) {
} switch (type) {
uint8_t getUint8Val(void *s) { case TSDB_DATA_TYPE_TINYINT:
return (uint8_t)GET_INT8_VAL(s); *((int8_t *)dst) = GET_INT8_VAL(s1) + GET_INT8_VAL(s2);
} break;
int16_t getInt16Val(void *s) { case TSDB_DATA_TYPE_UTINYINT:
return (int16_t)GET_INT16_VAL(s); *((uint8_t *)dst) = GET_UINT8_VAL(s1) + GET_UINT8_VAL(s2);
} break;
uint16_t getUint16Val(void *s) { case TSDB_DATA_TYPE_SMALLINT:
return (uint16_t)GET_INT16_VAL(s); *((int16_t *)dst) = GET_INT16_VAL(s1) + GET_INT16_VAL(s2);
} break;
int32_t getInt32Val(void *s) { case TSDB_DATA_TYPE_USMALLINT:
return (int32_t)GET_INT32_VAL(s); *((uint16_t *)dst) = GET_UINT16_VAL(s1) + GET_UINT16_VAL(s2);
} break;
uint32_t getUint32Val(void *s) { case TSDB_DATA_TYPE_INT:
return (uint32_t)GET_INT32_VAL(s); *((int32_t *)dst) = GET_INT32_VAL(s1) + GET_INT32_VAL(s2);
} break;
int64_t getInt64Val(void *s) { case TSDB_DATA_TYPE_UINT:
return (int64_t)GET_INT64_VAL(s); *((uint32_t *)dst) = GET_UINT32_VAL(s1) + GET_UINT32_VAL(s2);
} break;
uint64_t getUint64Val(void *s) { case TSDB_DATA_TYPE_BIGINT:
return (uint64_t)GET_INT64_VAL(s); *((int64_t *)dst) = GET_INT64_VAL(s1) + GET_INT64_VAL(s2);
} break;
float getFloatVal(void *s) { case TSDB_DATA_TYPE_UBIGINT:
return GET_FLOAT_VAL(s); *((uint64_t *)dst) = GET_UINT64_VAL(s1) + GET_UINT64_VAL(s2);
} break;
double getDoubleVal(void *s) { case TSDB_DATA_TYPE_TIMESTAMP:
return GET_DOUBLE_VAL(s); *((int64_t *)dst) = GET_INT64_VAL(s1) + GET_INT64_VAL(s2);
} break;
void setInt8Val(void *d, void *s) { case TSDB_DATA_TYPE_FLOAT:
*((int8_t *)d) = (int8_t)GET_INT8_VAL(s); SET_FLOAT_VAL(dst, GET_FLOAT_VAL(s1) + GET_FLOAT_VAL(s2));
} break;
void setUint8Val(void *d, void *s) { case TSDB_DATA_TYPE_DOUBLE:
*((uint8_t *)d) = GET_INT8_VAL(s); SET_DOUBLE_VAL(dst, GET_DOUBLE_VAL(s1) + GET_DOUBLE_VAL(s2));
} break;
void setInt16Val(void *d, void *s) { default: {
*((int16_t *)d) = (int16_t)GET_INT16_VAL(s); assert(0);
} break;
void setUint16Val(void *d, void *s) { }
*((uint16_t *)d) = GET_INT16_VAL(s); }
} } else {
void setInt32Val(void *d, void *s) { assert(0);
*((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));
} }

18
src/common/src/tvariant.c
View File

@ -184,7 +184,7 @@ void tVariantDestroy(tVariant *pVar) {
} }
// NOTE: this is only for string array // NOTE: this is only for string array
if (pVar->nType == TSDB_DATA_TYPE_ARRAY) { if (pVar->nType == TSDB_DATA_TYPE_POINTER_ARRAY) {
size_t num = taosArrayGetSize(pVar->arr); size_t num = taosArrayGetSize(pVar->arr);
for(size_t i = 0; i < num; i++) { for(size_t i = 0; i < num; i++) {
void* p = taosArrayGetP(pVar->arr, i); void* p = taosArrayGetP(pVar->arr, i);
@ -192,6 +192,9 @@ void tVariantDestroy(tVariant *pVar) {
} }
taosArrayDestroy(pVar->arr); taosArrayDestroy(pVar->arr);
pVar->arr = NULL; pVar->arr = NULL;
} else if (pVar->nType == TSDB_DATA_TYPE_VALUE_ARRAY) {
taosArrayDestroy(pVar->arr);
pVar->arr = NULL;
} }
} }
@ -220,7 +223,7 @@ void tVariantAssign(tVariant *pDst, const tVariant *pSrc) {
if (IS_NUMERIC_TYPE(pSrc->nType) || (pSrc->nType == TSDB_DATA_TYPE_BOOL)) { if (IS_NUMERIC_TYPE(pSrc->nType) || (pSrc->nType == TSDB_DATA_TYPE_BOOL)) {
pDst->i64 = pSrc->i64; pDst->i64 = pSrc->i64;
} else if (pSrc->nType == TSDB_DATA_TYPE_ARRAY) { // this is only for string array } else if (pSrc->nType == TSDB_DATA_TYPE_POINTER_ARRAY) { // this is only for string array
size_t num = taosArrayGetSize(pSrc->arr); size_t num = taosArrayGetSize(pSrc->arr);
pDst->arr = taosArrayInit(num, sizeof(char*)); pDst->arr = taosArrayInit(num, sizeof(char*));
for(size_t i = 0; i < num; i++) { for(size_t i = 0; i < num; i++) {
@ -228,9 +231,18 @@ void tVariantAssign(tVariant *pDst, const tVariant *pSrc) {
char* n = strdup(p); char* n = strdup(p);
taosArrayPush(pDst->arr, &n); taosArrayPush(pDst->arr, &n);
} }
} else if (pSrc->nType == TSDB_DATA_TYPE_VALUE_ARRAY) {
size_t num = taosArrayGetSize(pSrc->arr);
pDst->arr = taosArrayInit(num, sizeof(int64_t));
pDst->nLen = pSrc->nLen;
assert(pSrc->nLen == num);
for(size_t i = 0; i < num; i++) {
int64_t *p = taosArrayGet(pSrc->arr, i);
taosArrayPush(pDst->arr, p);
}
} }
if (pDst->nType != TSDB_DATA_TYPE_ARRAY) { if (pDst->nType != TSDB_DATA_TYPE_POINTER_ARRAY && pDst->nType != TSDB_DATA_TYPE_VALUE_ARRAY) {
pDst->nLen = tDataTypes[pDst->nType].bytes; pDst->nLen = tDataTypes[pDst->nType].bytes;
} }
} }

1
src/inc/taoserror.h
View File

@ -260,6 +260,7 @@ int32_t* taosGetErrno();
#define TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW TAOS_DEF_ERROR_CODE(0, 0x070A) //"Too many time window in query") #define TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW TAOS_DEF_ERROR_CODE(0, 0x070A) //"Too many time window in query")
#define TSDB_CODE_QRY_NOT_ENOUGH_BUFFER TAOS_DEF_ERROR_CODE(0, 0x070B) //"Query buffer limit has reached") #define TSDB_CODE_QRY_NOT_ENOUGH_BUFFER TAOS_DEF_ERROR_CODE(0, 0x070B) //"Query buffer limit has reached")
#define TSDB_CODE_QRY_INCONSISTAN TAOS_DEF_ERROR_CODE(0, 0x070C) //"File inconsistency in replica") #define TSDB_CODE_QRY_INCONSISTAN TAOS_DEF_ERROR_CODE(0, 0x070C) //"File inconsistency in replica")
#define TSDB_CODE_QRY_INVALID_TIME_CONDITION TAOS_DEF_ERROR_CODE(0, 0x070D) //"invalid time condition")
// grant // grant

6
src/inc/ttype.h
View File

@ -29,7 +29,8 @@ typedef struct tstr {
#define IS_VAR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_BINARY) || ((t) == TSDB_DATA_TYPE_NCHAR)) #define IS_VAR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_BINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
// this data type is internally used only in 'in' query to hold the values // this data type is internally used only in 'in' query to hold the values
#define TSDB_DATA_TYPE_ARRAY (1000) #define TSDB_DATA_TYPE_POINTER_ARRAY (1000)
#define TSDB_DATA_TYPE_VALUE_ARRAY (1001)
#define GET_TYPED_DATA(_v, _finalType, _type, _data) \ #define GET_TYPED_DATA(_v, _finalType, _type, _data) \
do { \ do { \
@ -161,6 +162,8 @@ typedef struct tDataTypeDescriptor {
int16_t nameLen; int16_t nameLen;
int32_t bytes; int32_t bytes;
char * name; char * name;
int64_t minValue;
int64_t maxValue;
int (*compFunc)(const char *const input, int inputSize, const int nelements, char *const output, int outputSize, int (*compFunc)(const char *const input, int inputSize, const int nelements, char *const output, int outputSize,
char algorithm, char *const buffer, int bufferSize); char algorithm, char *const buffer, int bufferSize);
int (*decompFunc)(const char *const input, int compressedSize, const int nelements, char *const output, int (*decompFunc)(const char *const input, int compressedSize, const int nelements, char *const output,
@ -180,6 +183,7 @@ void *getNullValue(int32_t type);
void assignVal(char *val, const char *src, int32_t len, int32_t type); void assignVal(char *val, const char *src, int32_t len, int32_t type);
void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf); void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf);
void operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type);
int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bool issigned); int32_t tStrToInteger(const char* z, int16_t type, int32_t n, int64_t* value, bool issigned);

56
src/query/inc/qFilter.h
View File

@ -41,30 +41,50 @@ enum {
MR_OPT_TS = 1, MR_OPT_TS = 1,
}; };
enum {
RA_EXCLUDE = 1,
RA_NULL = 2,
};
typedef struct OptrStr { typedef struct OptrStr {
uint16_t optr; uint16_t optr;
char *str; char *str;
} OptrStr; } OptrStr;
typedef struct SFilterColRange {
uint16_t idx; //column field idx
int64_t s;
int64_t e;
} SFilterColRange;
typedef struct SFilterRange { typedef struct SFilterRange {
struct SFilterRange* prev; char sflag;
struct SFilterRange* next; char eflag;
int64_t s; int64_t s;
int64_t e; int64_t e;
} SFilterRange; } SFilterRange;
typedef struct SFilterRangeNode {
struct SFilterRangeNode* prev;
struct SFilterRangeNode* next;
SFilterRange ra;
} SFilterRangeNode;
typedef struct SFilterRMCtx { typedef struct SFilterRMCtx {
int32_t type; int32_t type;
int32_t options; int32_t options;
int8_t status; int8_t status;
__compar_fn_t pCompareFunc; __compar_fn_t pCompareFunc;
SFilterRange *rs; SFilterRangeNode *rf; //freed
SFilterRangeNode *rs;
} SFilterRMCtx ; } SFilterRMCtx ;
typedef struct SFilterField { typedef struct SFilterField {
uint16_t type; uint16_t type;
void* desc; void* desc;
void* data; void* data;
int64_t range[];
} SFilterField; } SFilterField;
typedef struct SFilterFields { typedef struct SFilterFields {
@ -106,14 +126,23 @@ typedef struct SFilterInfo {
uint8_t *unitFlags; // got result uint8_t *unitFlags; // got result
} SFilterInfo; } SFilterInfo;
#define COL_FIELD_SIZE (sizeof(SFilterField) + 2 * sizeof(int64_t))
#define FILTER_NO_MERGE_DATA_TYPE(t) ((t) == TSDB_DATA_TYPE_BINARY || (t) == TSDB_DATA_TYPE_NCHAR)
#define FILTER_NO_MERGE_OPTR(o) ((o) == TSDB_RELATION_ISNULL || (o) == TSDB_RELATION_NOTNULL)
#define MR_EMPTY_RES(ctx) (ctx->rs == NULL)
#define MR_GET_FLAG(st, f) (st & f) #define MR_GET_FLAG(st, f) (st & f)
#define MR_SET_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 SIMPLE_COPY_VALUES(dst, src) *((int64_t *)dst) = *((int64_t *)src)
#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 RESET_RANGE(ctx, r) do { r->next = ctx->rf; ctx->rf = r; } 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 FREE_RANGE(ctx, r) do { if (r->prev) { r->prev->next = r->next; } else { ctx->rs = r->next;} if (r->next) { r->next->prev = r->prev; } RESET_RANGE(ctx, 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 FREE_FROM_RANGE(ctx, r) do { if (r->prev) { r->prev->next = NULL; } else { ctx->rs = NULL;} while (r) {SFilterRangeNode *n = r->next; RESET_RANGE(ctx, r); r = n; } } while (0)
#define INSERT_RANGE(ctx, r, t, s, e) do { SFilterRangeNode *n = filterNewRange(ctx, t, s, e); n->prev = r->prev; if (r->prev) { r->prev->next = n; } else { ctx->rs = n; } r->prev = n; n->next = r; } while (0)
#define APPEND_RANGE(ctx, r, t, s, e) do { SFilterRangeNode *n = filterNewRange(ctx, t, s, e); n->prev = r; if (r) { r->next = n; } else { ctx->rs = n; } } while (0)
#define ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { return _code; } } 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_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { qError(__VA_ARGS__); return _code; } } while (0)
@ -121,6 +150,7 @@ typedef struct SFilterInfo {
#define CHK_RETV(c) do { if (c) { return; } } while (0) #define CHK_RETV(c) do { if (c) { return; } } while (0)
#define CHK_RET(c, r) do { if (c) { return r; } } while (0) #define CHK_RET(c, r) do { if (c) { return r; } } while (0)
#define CHK_JMP(c) do { if (c) { goto _err_return; } } while (0)
#define CHK_LRETV(c,...) do { if (c) { qError(__VA_ARGS__); return; } } while (0) #define CHK_LRETV(c,...) do { if (c) { qError(__VA_ARGS__); return; } } while (0)
#define CHK_LRET(c, r,...) do { if (c) { qError(__VA_ARGS__); return r; } } while (0) #define CHK_LRET(c, r,...) do { if (c) { qError(__VA_ARGS__); return r; } } while (0)
@ -130,7 +160,13 @@ typedef struct SFilterInfo {
#define FILTER_GET_VAL_FIELD_TYPE(fi) (((tVariant *)((fi)->desc))->nType) #define FILTER_GET_VAL_FIELD_TYPE(fi) (((tVariant *)((fi)->desc))->nType)
#define FILTER_GET_VAL_FIELD_DATA(fi) ((fi)->data) #define FILTER_GET_VAL_FIELD_DATA(fi) ((fi)->data)
#define FILTER_GROUP_UNIT(i, g, uid) ((i)->units[(g)->unitIdxs[uid]])
#define FILTER_UNIT_LEFT_FIELD(i, u) FILTER_GET_FIELD(i, (u)->left)
#define FILTER_UNIT_RIGHT_FIELD(i, u) FILTER_GET_FIELD(i, (u)->right)
#define FILTER_UNIT_DATA_TYPE(i, u) FILTER_GET_COL_FIELD_TYPE(FILTER_UNIT_LEFT_FIELD(i, u))
#define FILTER_UNIT_VAL(i, u) FILTER_GET_VAL_FIELD_DATA(FILTER_UNIT_RIGHT_FIELD(i, u))
#define FILTER_UNIT_COL_IDX(u) ((u)->left.idx)
#define FILTER_UNIT_OPTR(u) ((u)->compare.optr)
#define FILTER_UNIT_CLR_F(i) memset((i)->unitFlags, 0, (i)->unitNum * sizeof(*info->unitFlags)) #define FILTER_UNIT_CLR_F(i) memset((i)->unitFlags, 0, (i)->unitNum * sizeof(*info->unitFlags))
#define FILTER_UNIT_SET_F(i, idx) (i)->unitFlags[idx] = 1 #define FILTER_UNIT_SET_F(i, idx) (i)->unitFlags[idx] = 1
@ -149,7 +185,7 @@ 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 filterGetMergeRangeNum(void* h, int32_t* num);
extern int32_t filterGetMergeRangeRes(void* h, void *s, void* e); extern int32_t filterGetMergeRangeRes(void* h, void *s, void* e);
extern int32_t filterFreeMergeRange(void* h); extern int32_t filterFreeMergeRange(void* h);
extern int32_t filterGetTimeRange(SFilterInfo *info, STimeWindow *win);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

9
src/query/src/qExecutor.c
View File

@ -6966,7 +6966,10 @@ int32_t createQueryFilter(char *data, uint16_t len, SFilterInfo** pFilters) {
return TSDB_CODE_QRY_APP_ERROR; return TSDB_CODE_QRY_APP_ERROR;
} }
return filterInitFromTree(expr, pFilters); int32_t ret = filterInitFromTree(expr, pFilters);
tExprTreeDestroy(expr, NULL);
return ret;
} }
@ -7284,10 +7287,6 @@ SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, S
} }
doUpdateExprColumnIndex(pQueryAttr); doUpdateExprColumnIndex(pQueryAttr);
int32_t ret = createFilterInfo(pQueryAttr, pQInfo->qId);
if (ret != TSDB_CODE_SUCCESS) {
goto _cleanup;
}
if (pQueryAttr->fillType != TSDB_FILL_NONE) { if (pQueryAttr->fillType != TSDB_FILL_NONE) {
pQueryAttr->fillVal = malloc(sizeof(int64_t) * pQueryAttr->numOfOutput); pQueryAttr->fillVal = malloc(sizeof(int64_t) * pQueryAttr->numOfOutput);

470
src/query/src/qFilter.c
View File

@ -54,6 +54,24 @@ filter_desc_compare_func gDescCompare [F_FIELD_MAX] = {
filterFieldValDescCompare filterFieldValDescCompare
}; };
static FORCE_INLINE SFilterRangeNode* filterNewRange(SFilterRMCtx *ctx, int32_t t, void *s, void *e) {
SFilterRangeNode *r = NULL;
if (ctx->rf) {
r = ctx->rf;
ctx->rf = ctx->rf->next;
r->prev = NULL;
r->next = NULL;
} else {
r = calloc(1, sizeof(SFilterRangeNode));
}
SIMPLE_COPY_VALUES((char*)&r->s, s);
SIMPLE_COPY_VALUES((char*)&r->e, e);
return r;
}
void* filterInitMergeRange(int32_t type, int32_t options) { 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) { 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); qError("not supported range type:%d", type);
@ -63,46 +81,97 @@ void* filterInitMergeRange(int32_t type, int32_t options) {
SFilterRMCtx *ctx = calloc(1, sizeof(SFilterRMCtx)); SFilterRMCtx *ctx = calloc(1, sizeof(SFilterRMCtx));
ctx->type = type; ctx->type = type;
ctx->options = options;
ctx->pCompareFunc = getComparFunc(type, 0); ctx->pCompareFunc = getComparFunc(type, 0);
return ctx; return ctx;
} }
int32_t filterAddMergeRange(void* h, void* s, void* e, int32_t optr) { int32_t filterAddMergeRangeCtx(void *dst, void *src, int32_t optr) {
SFilterRMCtx *dctx = (SFilterRMCtx *)dst;
SFilterRMCtx *sctx = (SFilterRMCtx *)src;
if (sctx->rs == NULL) {
return TSDB_CODE_SUCCESS;
}
SFilterRangeNode *r = sctx->rs;
while (r) {
filterAddMergeRange(dctx, &r->s, &r->e, optr);
r = r->next;
}
return TSDB_CODE_SUCCESS;
}
int32_t filterResetMergeRangeCtx(SFilterRMCtx *ctx) {
ctx->status = 0;
if (ctx->rf == NULL) {
ctx->rf = ctx->rs;
ctx->rs = NULL;
return TSDB_CODE_SUCCESS;
}
SFilterRangeNode *r = ctx->rf;
while (r && r->next) {
r = r->next;
}
r->next = ctx->rs;
ctx->rs = NULL;
return TSDB_CODE_SUCCESS;
}
int32_t filterReuseMergeRangeCtx(SFilterRMCtx *ctx, int32_t type, int32_t options) {
filterResetMergeRangeCtx(ctx);
ctx->type = type;
ctx->options = options;
ctx->pCompareFunc = getComparFunc(type, 0);
return TSDB_CODE_SUCCESS;
}
int32_t filterAddMergeRangeImpl(void* h, void* s, void* e, char sflag, char eflag, int32_t optr) {
SFilterRMCtx *ctx = (SFilterRMCtx *)h; SFilterRMCtx *ctx = (SFilterRMCtx *)h;
if (ctx->rs == NULL) { if (ctx->rs == NULL) {
if (MR_GET_FLAG(ctx->status, MR_ST_START) == 0 || optr == TSDB_RELATION_OR) { if (MR_GET_FLAG(ctx->status, MR_ST_START) == 0 || optr == TSDB_RELATION_OR) {
GEN_RANGE(ctx->rs, ctx->type, s, e); APPEND_RANGE(ctx, ctx->rs, ctx->type, s, e);
MR_SET_FLAG(ctx->status, MR_ST_START); MR_SET_FLAG(ctx->status, MR_ST_START);
} }
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
SFilterRange *r = ctx->rs; SFilterRangeNode *r = ctx->rs;
SFilterRange *rn = NULL; SFilterRangeNode *rn = NULL;
if (optr == TSDB_RELATION_AND) { if (optr == TSDB_RELATION_AND) {
while (r != NULL) { while (r != NULL) {
if (ctx->pCompareFunc(&r->s, e) > 0) { if (ctx->pCompareFunc(&r->s, e) > 0) {
FREE_FROM_RANGE(ctx->rs, r); FREE_FROM_RANGE(ctx, r);
break; break;
} }
if (ctx->pCompareFunc(s, &r->e) > 0) { if (ctx->pCompareFunc(s, &r->e) > 0) {
rn = r->next; rn = r->next;
FREE_RANGE(ctx->rs, r); FREE_RANGE(ctx, r);
r = rn; r = rn;
continue; continue;
} }
if (ctx->pCompareFunc(s, &r->s) > 0) { if (ctx->pCompareFunc(s, &r->s) > 0) {
assignVal((char *)&r->s, s, 0, ctx->type); SIMPLE_COPY_VALUES((char *)&r->s, s);
} }
if (ctx->pCompareFunc(&r->e, e) > 0) { if (ctx->pCompareFunc(&r->e, e) > 0) {
assignVal((char *)&r->e, e, 0, ctx->type); SIMPLE_COPY_VALUES((char *)&r->e, e);
break; break;
} }
@ -120,7 +189,7 @@ int32_t filterAddMergeRange(void* h, void* s, void* e, int32_t optr) {
while (r != NULL) { while (r != NULL) {
if (ctx->pCompareFunc(&r->s, e) > 0) { if (ctx->pCompareFunc(&r->s, e) > 0) {
if (emerged == false) { if (emerged == false) {
INSERT_RANGE(ctx->rs, r, ctx->type, s, e); INSERT_RANGE(ctx, r, ctx->type, s, e);
} }
break; break;
@ -132,13 +201,13 @@ int32_t filterAddMergeRange(void* h, void* s, void* e, int32_t optr) {
continue; continue;
} }
APPEND_RANGE(r, ctx->type, s, e); APPEND_RANGE(ctx, r, ctx->type, s, e);
break; break;
} }
if (smerged == false) { if (smerged == false) {
if (ctx->pCompareFunc(&r->s, s) > 0) { if (ctx->pCompareFunc(&r->s, s) > 0) {
assignVal((char *)&r->s, s, 0, ctx->type); SIMPLE_COPY_VALUES((char *)&r->s, s);
} }
smerged = true; smerged = true;
@ -146,7 +215,7 @@ int32_t filterAddMergeRange(void* h, void* s, void* e, int32_t optr) {
if (emerged == false) { if (emerged == false) {
if (ctx->pCompareFunc(e, &r->e) > 0) { if (ctx->pCompareFunc(e, &r->e) > 0) {
assignVal((char *)&r->e, e, 0, ctx->type); SIMPLE_COPY_VALUES((char *)&r->e, e);
emerged = true; emerged = true;
e = &r->e; e = &r->e;
r = r->next; r = r->next;
@ -158,13 +227,13 @@ int32_t filterAddMergeRange(void* h, void* s, void* e, int32_t optr) {
if (ctx->pCompareFunc(e, &r->e) > 0) { if (ctx->pCompareFunc(e, &r->e) > 0) {
rn = r->next; rn = r->next;
FREE_RANGE(ctx->rs, r); FREE_RANGE(ctx, r);
r = rn; r = rn;
continue; continue;
} else { } else {
assignVal(e, (char *)&r->e, 0, ctx->type); SIMPLE_COPY_VALUES(e, (char *)&r->e);
FREE_RANGE(ctx->rs, r); FREE_RANGE(ctx, r);
break; break;
} }
@ -173,6 +242,29 @@ int32_t filterAddMergeRange(void* h, void* s, void* e, int32_t optr) {
return TSDB_CODE_SUCCESS; return TSDB_CODE_SUCCESS;
} }
int32_t filterAddMergeRange(void* h, SFilterRange* ra, int32_t optr) {
SFilterRMCtx *ctx = (SFilterRMCtx *)h;
int64_t sv, ev;
void *s, *e;
char sflag = 0, eflag = 0;
if (MR_GET_FLAG(ra->sflag, RA_NULL)) {
SIMPLE_COPY_VALUES(&sv, &tDataTypes[ctx->type].minValue);
s = &sv;
} else {
s = &ra.s;
}
if (MR_GET_FLAG(ra->eflag, RA_NULL)) {
SIMPLE_COPY_VALUES(&ev, &tDataTypes[ctx->type].maxValue);
e = &ev;
} else {
e = &ra.e;
}
return filterAddMergeRangeImpl(h, s, e, ra.sflag, ra.eflag, optr);
}
int32_t filterFinMergeRange(void* h) { int32_t filterFinMergeRange(void* h) {
SFilterRMCtx *ctx = (SFilterRMCtx *)h; SFilterRMCtx *ctx = (SFilterRMCtx *)h;
@ -181,7 +273,23 @@ int32_t filterFinMergeRange(void* h) {
} }
if (MR_GET_FLAG(ctx->options, MR_OPT_TS)) { if (MR_GET_FLAG(ctx->options, MR_OPT_TS)) {
SFilterRangeNode *r = ctx->rs;
SFilterRangeNode *rn = NULL;
while (r && r->next) {
int64_t tmp = 1;
operateVal(&tmp, &r->e, &tmp, TSDB_BINARY_OP_ADD, ctx->type);
if (ctx->pCompareFunc(&tmp, &r->next->s) == 0) {
rn = r->next;
SIMPLE_COPY_VALUES((char *)&r->next->s, (char *)&r->s);
FREE_RANGE(ctx, r);
r = rn;
continue;
}
r = r->next;
}
} }
MR_SET_FLAG(ctx->status, MR_ST_FIN); MR_SET_FLAG(ctx->status, MR_ST_FIN);
@ -196,7 +304,7 @@ int32_t filterGetMergeRangeNum(void* h, int32_t* num) {
*num = 0; *num = 0;
SFilterRange *r = ctx->rs; SFilterRangeNode *r = ctx->rs;
while (r) { while (r) {
++(*num); ++(*num);
@ -212,7 +320,7 @@ int32_t filterGetMergeRangeRes(void* h, void *s, void* e) {
SFilterRMCtx *ctx = (SFilterRMCtx *)h; SFilterRMCtx *ctx = (SFilterRMCtx *)h;
uint32_t num = 0; uint32_t num = 0;
SFilterRange* r = ctx->rs; SFilterRangeNode* r = ctx->rs;
while (r) { while (r) {
assignVal(s + num * tDataTypes[ctx->type].bytes, (char *)&r->s, 0, ctx->type); assignVal(s + num * tDataTypes[ctx->type].bytes, (char *)&r->s, 0, ctx->type);
@ -231,9 +339,13 @@ int32_t filterGetMergeRangeRes(void* h, void *s, void* e) {
} }
int32_t filterFreeMergeRange(void* h) { int32_t filterFreeMergeRange(void* h) {
if (h == NULL) {
return TSDB_CODE_SUCCESS;
}
SFilterRMCtx *ctx = (SFilterRMCtx *)h; SFilterRMCtx *ctx = (SFilterRMCtx *)h;
SFilterRange *r = ctx->rs; SFilterRangeNode *r = ctx->rs;
SFilterRange *rn = NULL; SFilterRangeNode *rn = NULL;
while (r) { while (r) {
rn = r->next; rn = r->next;
@ -299,7 +411,7 @@ int32_t filterGetFiled(SFilterFields* fields, int32_t type, void *v) {
int32_t filterAddField(SFilterInfo *info, tExprNode *node, SFilterFieldId *fid) { int32_t filterAddField(SFilterInfo *info, tExprNode *node, SFilterFieldId *fid) {
CHK_LRET(node == NULL, TSDB_CODE_QRY_APP_ERROR, "empty node"); CHK_LRET(node == NULL, TSDB_CODE_QRY_APP_ERROR, "empty node");
CHK_LRET(node->nodeType != TSQL_NODE_COL && node->nodeType != TSQL_NODE_VALUE, TSDB_CODE_QRY_APP_ERROR, "invalid nodeType"); CHK_LRET(node->nodeType != TSQL_NODE_COL && node->nodeType != TSQL_NODE_VALUE, TSDB_CODE_QRY_APP_ERROR, "invalid nodeType:%d", node->nodeType);
int32_t type, idx = -1; int32_t type, idx = -1;
uint16_t *num; uint16_t *num;
@ -308,9 +420,11 @@ int32_t filterAddField(SFilterInfo *info, tExprNode *node, SFilterFieldId *fid)
if (node->nodeType == TSQL_NODE_COL) { if (node->nodeType == TSQL_NODE_COL) {
type = F_FIELD_COLUMN; type = F_FIELD_COLUMN;
v = node->pSchema; v = node->pSchema;
node->pSchema = NULL;
} else { } else {
type = F_FIELD_VALUE; type = F_FIELD_VALUE;
v = node->pVal; v = node->pVal;
node->pVal = NULL;
} }
num = &info->fields[type].num; num = &info->fields[type].num;
@ -422,7 +536,7 @@ _err_return:
int32_t filterInitUnitFunc(SFilterInfo *info) { int32_t filterInitUnitFunc(SFilterInfo *info) {
for (uint16_t i = 0; i < info->unitNum; ++i) { for (uint16_t i = 0; i < info->unitNum; ++i) {
SFilterUnit* unit = &info->units[i]; SFilterUnit* unit = &info->units[i];
SFilterField *left = FILTER_GET_FIELD(info, unit->left); SFilterField *left = FILTER_UNIT_LEFT_FIELD(info, unit);
unit->compare.pCompareFunc = getComparFunc(FILTER_GET_COL_FIELD_TYPE(left), unit->compare.optr); unit->compare.pCompareFunc = getComparFunc(FILTER_GET_COL_FIELD_TYPE(left), unit->compare.optr);
} }
@ -432,18 +546,18 @@ int32_t filterInitUnitFunc(SFilterInfo *info) {
void filterDumpInfoToString(SFilterInfo *info) { void filterDumpInfoToString(SFilterInfo *info, const char *msg) {
CHK_LRETV(info == NULL, "FilterInfo: empty"); CHK_LRETV(info == NULL, "%s - FilterInfo: empty", msg);
qDebug("FilterInfo:"); qDebug("%s - FilterInfo:", msg);
qDebug("Field Col Num:%u", info->fields[F_FIELD_COLUMN].num); qDebug("COLUMN Field Num:%u", info->fields[F_FIELD_COLUMN].num);
for (uint16_t i = 0; i < info->fields[F_FIELD_COLUMN].num; ++i) { for (uint16_t i = 0; i < info->fields[F_FIELD_COLUMN].num; ++i) {
SFilterField *field = &info->fields[F_FIELD_COLUMN].fields[i]; SFilterField *field = &info->fields[F_FIELD_COLUMN].fields[i];
SSchema *sch = field->desc; SSchema *sch = field->desc;
qDebug("COL%d => [%d][%s]", i, sch->colId, sch->name); qDebug("COL%d => [%d][%s]", i, sch->colId, sch->name);
} }
qDebug("Field Val Num:%u", info->fields[F_FIELD_VALUE].num); qDebug("VALUE Field Num:%u", info->fields[F_FIELD_VALUE].num);
for (uint16_t i = 0; i < info->fields[F_FIELD_VALUE].num; ++i) { for (uint16_t i = 0; i < info->fields[F_FIELD_VALUE].num; ++i) {
SFilterField *field = &info->fields[F_FIELD_VALUE].fields[i]; SFilterField *field = &info->fields[F_FIELD_VALUE].fields[i];
tVariant *var = field->desc; tVariant *var = field->desc;
@ -453,8 +567,8 @@ void filterDumpInfoToString(SFilterInfo *info) {
qDebug("Unit Num:%u", info->unitNum); qDebug("Unit Num:%u", info->unitNum);
for (uint16_t i = 0; i < info->unitNum; ++i) { for (uint16_t i = 0; i < info->unitNum; ++i) {
SFilterUnit *unit = &info->units[i]; SFilterUnit *unit = &info->units[i];
SFilterField *left = FILTER_GET_FIELD(info, unit->left); SFilterField *left = FILTER_UNIT_LEFT_FIELD(info);
SFilterField *right = FILTER_GET_FIELD(info, unit->right); SFilterField *right = FILTER_UNIT_RIGHT_FIELD(info, unit);
SSchema *sch = left->desc; SSchema *sch = left->desc;
tVariant *var = right->desc; tVariant *var = right->desc;
@ -478,27 +592,13 @@ void filterFreeInfo(SFilterInfo *info) {
//TODO //TODO
} }
int32_t filterSetColFieldData(SFilterInfo *info, int16_t colId, void *data) {
CHK_LRET(info == NULL, TSDB_CODE_QRY_APP_ERROR, "info NULL");
CHK_LRET(info->fields[F_FIELD_COLUMN].num <= 0, TSDB_CODE_QRY_APP_ERROR, "no column fileds");
for (uint16_t i = 0; i < info->fields[F_FIELD_COLUMN].num; ++i) {
SFilterField* fi = &info->fields[F_FIELD_COLUMN].fields[i];
SSchema* sch = fi->desc;
if (sch->colId == colId) {
fi->data = data;
break;
}
}
return TSDB_CODE_SUCCESS;
}
int32_t filterInitValFieldData(SFilterInfo *info) { int32_t filterInitValFieldData(SFilterInfo *info) {
for (uint16_t i = 0; i < info->unitNum; ++i) { for (uint16_t i = 0; i < info->unitNum; ++i) {
SFilterUnit* unit = &info->units[i]; SFilterUnit* unit = &info->units[i];
SFilterField* left = FILTER_GET_FIELD(info, unit->left); SFilterField* left = FILTER_UNIT_LEFT_FIELD(info, unit);
SFilterField* right = FILTER_GET_FIELD(info, unit->right); SFilterField* right = FILTER_UNIT_RIGHT_FIELD(info, unit);
if (left->type != F_FIELD_VALUE && right->type != F_FIELD_VALUE) { if (left->type != F_FIELD_VALUE && right->type != F_FIELD_VALUE) {
continue; continue;
@ -530,9 +630,19 @@ int32_t filterInitValFieldData(SFilterInfo *info) {
fi->data = calloc(1, (var->nLen + 1) * TSDB_NCHAR_SIZE); fi->data = calloc(1, (var->nLen + 1) * TSDB_NCHAR_SIZE);
} else if (type == TSDB_DATA_TYPE_NCHAR) { } else if (type == TSDB_DATA_TYPE_NCHAR) {
fi->data = calloc(1, (var->nLen + 1) * TSDB_NCHAR_SIZE); fi->data = calloc(1, (var->nLen + 1) * TSDB_NCHAR_SIZE);
} else {
if (var->nType == TSDB_DATA_TYPE_VALUE_ARRAY) {
fi->data = calloc(var->nLen, tDataTypes[type].bytes);
for (int32_t a = 0; a < var->nLen; ++a) {
int64_t *v = taosArrayGet(var->arr, a);
assignVal(fi->data + a * tDataTypes[type].bytes, (char *)v, 0, type);
}
continue;
} else { } else {
fi->data = calloc(1, sizeof(int64_t)); fi->data = calloc(1, sizeof(int64_t));
} }
}
ERR_LRET(tVariantDump(var, (char*)fi->data, type, true), "dump type[%d] failed", type); ERR_LRET(tVariantDump(var, (char*)fi->data, type, true), "dump type[%d] failed", type);
} }
@ -579,6 +689,197 @@ bool filterDoCompare(SFilterUnit *unit, void *left, void *right) {
} }
#if 0
int32_t filterAddUnitRange(SFilterInfo *info, SFilterUnit* u, SFilterRMCtx *ctx, int32_t optr) {
int32_t type = FILTER_UNIT_DATA_TYPE(info, u);
uint8_t uoptr = FILTER_UNIT_OPTR(u);
void *val = FILTER_UNIT_VAL(info, u);
int64_t s = 0, e = 0;
switch (uoptr) {
case TSDB_RELATION_GREATER:
break;
case TSDB_RELATION_GREATER_EQUAL:
case TSDB_RELATION_LESS:
case TSDB_RELATION_LESS_EQUAL:
case TSDB_RELATION_NOT_EQUAL:
case TSDB_RELATION_EQUAL:
case TSDB_RELATION_IN:
default:
assert(0);
}
filterAddMergeRange(ctx, &s, &e, optr);
return TSDB_CODE_SUCCESS;
}
int32_t filterMergeSingleGroupUnits(SFilterInfo *info, SFilterGroup* g, uint16_t id1, uint16_t id2, SArray* res) {
bool isnull = false, notnull = false;
int32_t num = 0;
SFilterRMCtx *cur = filterInitMergeRange(type, 0);
SFilterUnit* u1 = FILTER_GROUP_UNIT(info, g, id1);
SFilterUnit* u2 = FILTER_GROUP_UNIT(info, g, id2);
uint8_t optr1 = FILTER_UNIT_OPTR(u1);
uint8_t optr2 = FILTER_UNIT_OPTR(u2);
uint16_t cidx = FILTER_UNIT_COL_IDX(u1);
int32_t type = FILTER_UNIT_DATA_TYPE(info, u1);
#define SET_OPTR(o) ((o == TSDB_RELATION_ISNULL) ? isnull = true : notnull = true)
#define CHK_OPTR() (isnull == true && notnull == true)
SET_OPTR(optr1);
SET_OPTR(optr2);
CHK_JMP(CHK_OPTR());
if (!FILTER_NO_MERGE_OPTR(optr1)) {
filterAddUnitRange(info, u1, cur, TSDB_RELATION_AND);
}
if (!FILTER_NO_MERGE_OPTR(optr2)) {
filterAddUnitRange(info, u2, cur, TSDB_RELATION_AND);
CHK_JMP(MR_EMPTY_RES(cur));
}
for (int32_t i = id2 + 1; i < g->unitNum; ++i) {
SFilterUnit* u = FILTER_GROUP_UNIT(info, g, i);
if (cidx != FILTER_UNIT_COL_IDX(u)) {
continue;
}
optr2 = FILTER_UNIT_OPTR(u);
SET_OPTR(optr2);
CHK_JMP(CHK_OPTR());
if (!FILTER_NO_MERGE_OPTR(optr2)) {
filterAddUnitRange(info, u2, cur, TSDB_RELATION_AND);
CHK_JMP(MR_EMPTY_RES(cur));
}
}
SFilterColRange ra;
ra.idx = cidx;
filterGetMergeRangeNum(cur, &num);
assert(num == 1);
filterGetMergeRangeRes(cur, &ra.s, &ra.e);
taosArrayPush(res, &ra);
filterFreeMergeRange(cur);
return TSDB_CODE_SUCCESS;
_err_return:
g->unitNum = 0;
filterFreeMergeRange(cur);
return TSDB_CODE_SUCCESS;
}
int32_t filterMergeGroupUnits(SFilterInfo *info, SArray** res) {
uint16_t *f = malloc(1, info->fields[F_FIELD_COLUMN].num * sizeof(uint16_t));
SArray *gres = NULL;
bool gresUsed = false;
for (uint16_t i = 0; i < info->groupNum; ++i) {
SFilterGroup* g = info->groups + i;
memet(f, -1, info->fields[F_FIELD_COLUMN].num);
gresUsed = false;
for (uint16_t j = 0; j < g->unitNum; ++j) {
SFilterUnit* u = FILTER_GROUP_UNIT(info, g, j);
int32_t type = FILTER_UNIT_DATA_TYPE(info, u);
if (FILTER_NO_MERGE_DATA_TYPE(type)) {
continue;
}
uint16_t cidx = FILTER_UNIT_COL_IDX(u);
if (f[cidx] == -1) {
f[u->left.idx] = j;
} else if (cidx] == -2) {
continue;
} else {
f[cidx] = -2;
if (gres == NULL) {
gres = taosArrayInit(4, sizeof(SFilterColRange));
}
filterMergeSingleGroupUnits(info, g, f[cidx], j, gres);
if (g->unitNum == 0) {
break;
} else {
gresUsed = true;
}
}
}
if (g->unitNum == 0) {
if (gresUsed) {
taosArrayClear(gres);
}
continue;
}
if (res == NULL) {
res = calloc(info->groupNum, sizeof(SArray *));
res[i] = gres;
gres = NULL;
}
}
free(f);
if (gres) {
taosArrayDestroy(gres);
}
return TSDB_CODE_SUCCESS;
}
int32_t filterPreprocess(SFilterInfo *info) {
SArray* res = NULL;
filterMergeGroupUnits(info, &res);
}
#endif
int32_t filterSetColFieldData(SFilterInfo *info, int16_t colId, void *data) {
CHK_LRET(info == NULL, TSDB_CODE_QRY_APP_ERROR, "info NULL");
CHK_LRET(info->fields[F_FIELD_COLUMN].num <= 0, TSDB_CODE_QRY_APP_ERROR, "no column fileds");
for (uint16_t i = 0; i < info->fields[F_FIELD_COLUMN].num; ++i) {
SFilterField* fi = &info->fields[F_FIELD_COLUMN].fields[i];
SSchema* sch = fi->desc;
if (sch->colId == colId) {
fi->data = data;
break;
}
}
return TSDB_CODE_SUCCESS;
}
bool filterExecute(SFilterInfo *info, int32_t numOfRows, int8_t* p) { bool filterExecute(SFilterInfo *info, int32_t numOfRows, int8_t* p) {
bool all = true; bool all = true;
@ -599,8 +900,8 @@ bool filterExecute(SFilterInfo *info, int32_t numOfRows, int8_t* p) {
ures = FILTER_UNIT_GET_R(info, uidx); ures = FILTER_UNIT_GET_R(info, uidx);
} else { } else {
SFilterUnit *unit = &info->units[uidx]; SFilterUnit *unit = &info->units[uidx];
SFilterField *left = FILTER_GET_FIELD(info, unit->left); SFilterField *left = FILTER_UNIT_LEFT_FIELD(info);
SFilterField *right = FILTER_GET_FIELD(info, unit->right); SFilterField *right = FILTER_UNIT_RIGHT_FIELD(info, unit);
if (isNull(FILTER_GET_COL_FIELD_DATA(left, i), FILTER_GET_COL_FIELD_TYPE(left))) { if (isNull(FILTER_GET_COL_FIELD_DATA(left, i), FILTER_GET_COL_FIELD_TYPE(left))) {
ures = unit->compare.optr == TSDB_RELATION_ISNULL ? true : false; ures = unit->compare.optr == TSDB_RELATION_ISNULL ? true : false;
@ -659,7 +960,7 @@ int32_t filterInitFromTree(tExprNode* tree, SFilterInfo **pinfo) {
info->fields[F_FIELD_COLUMN].num = 0; info->fields[F_FIELD_COLUMN].num = 0;
info->fields[F_FIELD_COLUMN].size = FILTER_DEFAULT_FIELD_SIZE; info->fields[F_FIELD_COLUMN].size = FILTER_DEFAULT_FIELD_SIZE;
info->fields[F_FIELD_COLUMN].fields = calloc(info->fields[F_FIELD_COLUMN].size, sizeof(SFilterField)); info->fields[F_FIELD_COLUMN].fields = calloc(info->fields[F_FIELD_COLUMN].size, COL_FIELD_SIZE);
info->fields[F_FIELD_VALUE].num = 0; info->fields[F_FIELD_VALUE].num = 0;
info->fields[F_FIELD_VALUE].size = FILTER_DEFAULT_FIELD_SIZE; info->fields[F_FIELD_VALUE].size = FILTER_DEFAULT_FIELD_SIZE;
info->fields[F_FIELD_VALUE].fields = calloc(info->fields[F_FIELD_VALUE].size, sizeof(SFilterField)); info->fields[F_FIELD_VALUE].fields = calloc(info->fields[F_FIELD_VALUE].size, sizeof(SFilterField));
@ -678,17 +979,22 @@ int32_t filterInitFromTree(tExprNode* tree, SFilterInfo **pinfo) {
for (size_t i = 0; i < groupSize; ++i) { for (size_t i = 0; i < groupSize; ++i) {
SFilterGroup *pg = taosArrayGet(group, i); SFilterGroup *pg = taosArrayGet(group, i);
pg->unitFlags = calloc(pg->unitNum, sizeof(*pg->unitFlags));
info->groups[i] = *pg; info->groups[i] = *pg;
} }
ERR_JRET(filterInitUnitFunc(info));
ERR_JRET(filterInitValFieldData(info)); ERR_JRET(filterInitValFieldData(info));
filterDumpInfoToString(info, "Before preprocess");
//ERR_JRET(filterPreprocess(info));
ERR_JRET(filterInitUnitFunc(info));
info->unitRes = malloc(info->unitNum * sizeof(*info->unitRes)); info->unitRes = malloc(info->unitNum * sizeof(*info->unitRes));
info->unitFlags = malloc(info->unitNum * sizeof(*info->unitFlags)); info->unitFlags = malloc(info->unitNum * sizeof(*info->unitFlags));
filterDumpInfoToString(info); filterDumpInfoToString(info, "Final");
_err_return: _err_return:
@ -697,4 +1003,68 @@ _err_return:
return code; return code;
} }
int32_t filterGetTimeRange(SFilterInfo *info, STimeWindow *win) {
SFilterRange ra = {0};
SFilterRMCtx *prev = filterInitMergeRange(TSDB_DATA_TYPE_TIMESTAMP, MR_OPT_TS);
SFilterRMCtx *tmpc = filterInitMergeRange(TSDB_DATA_TYPE_TIMESTAMP, MR_OPT_TS);
SFilterRMCtx *cur = NULL;
int32_t num = 0;
int32_t optr = 0;
int32_t code = 0;
for (int32_t i = 0; i < info->groupNum; ++i) {
SFilterGroup *group = &info->groups[i];
if (group->unitNum > 1) {
cur = tmpc;
optr = TSDB_RELATION_AND;
} else {
cur = prev;
optr = TSDB_RELATION_OR;
}
for (int32_t u = 0; u < group->unitNum; ++u) {
uint16_t uidx = group->unitIdxs[u];
SFilterUnit *unit = &info->units[uidx];
SFilterField *right = FILTER_UNIT_RIGHT_FIELD(info, unit);
void *s = FILTER_GET_VAL_FIELD_DATA(right);
void *e = FILTER_GET_VAL_FIELD_DATA(right) + tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes;
SIMPLE_COPY_VALUES(&ra.s, s);
SIMPLE_COPY_VALUES(&ra.e, e);
code = filterAddMergeRange(cur, &ra, optr);
if (code) {
break;
}
}
if (code != TSDB_CODE_SUCCESS) {
break;
}
if (group->unitNum > 1) {
filterAddMergeRangeCtx(prev, cur, TSDB_RELATION_OR);
filterResetMergeRangeCtx(cur);
}
}
if (code == TSDB_CODE_SUCCESS) {
filterGetMergeRangeNum(prev, &num);
if (num != 1) {
qError("only one time range accepted, num:%d", num);
ERR_JRET(TSDB_CODE_QRY_INVALID_TIME_CONDITION);
}
filterGetMergeRangeRes(prev, &win->skey, &win->ekey);
}
_err_return:
filterFreeMergeRange(prev);
filterFreeMergeRange(tmpc);
return code;
}

3
src/query/src/qSqlParser.c
View File

@ -401,6 +401,9 @@ tSqlExpr *tSqlExprClone(tSqlExpr *pSrc) {
pExpr->pRight = tSqlExprClone(pSrc->pRight); pExpr->pRight = tSqlExprClone(pSrc->pRight);
} }
memset(&pExpr->value, 0, sizeof(pExpr->value));
tVariantAssign(&pExpr->value, &pSrc->value);
//we don't clone pParam now because clone is only used for between/and //we don't clone pParam now because clone is only used for between/and
assert(pSrc->pParam == NULL); assert(pSrc->pParam == NULL);
return pExpr; return pExpr;

2
src/query/src/queryMain.c
View File

@ -188,6 +188,8 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
taosArrayDestroy(param.pGroupbyExpr->columnInfo); taosArrayDestroy(param.pGroupbyExpr->columnInfo);
} }
tfree(param.colCond);
taosArrayDestroy(param.pTableIdList); taosArrayDestroy(param.pTableIdList);
param.pTableIdList = NULL; param.pTableIdList = NULL;

204
src/query/tests/rangeMergeTest.cpp
View File

@ -14,81 +14,100 @@ namespace {
void intDataTest() { void intDataTest() {
printf("running %s\n", __FUNCTION__); printf("running %s\n", __FUNCTION__);
int32_t s0[3] = {-100, 1, 3}; int32_t asize = 0;
int32_t e0[3] = {0 , 2, 4}; int64_t *s =NULL;
int64_t *e =NULL;
int64_t s0[3] = {-100, 1, 3};
int64_t e0[3] = {0 , 2, 4};
int64_t s1[3] = {INT64_MIN, 0 , 3}; int64_t s1[3] = {INT64_MIN, 0 , 3};
int64_t e1[3] = {100 , 50, 4}; int64_t e1[3] = {100 , 50, 4};
int64_t s2[5] = {1 , 3 , 10,30,70}; int64_t s2[5] = {1 , 3 , 10,30,70};
int64_t e2[5] = {10, 100, 20,50,120}; int64_t e2[5] = {10, 100, 20,50,120};
int64_t s3[3] = {1 , 20 , 5}; int64_t s3[3] = {1 , 20 , 5};
int64_t e3[3] = {10, 100, 25}; int64_t e3[3] = {10, 100, 25};
int64_t s4[2] = {10, 0};
int64_t e4[2] = {20, 5};
int64_t s5[3] = {0, 6 ,7};
int64_t e5[5] = {4, 10,20};
int32_t rs0[3]; int64_t rs[10];
int32_t re0[3]; int64_t re[10];
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; int32_t num = 0;
void *h = filterInitMergeRange(TSDB_DATA_TYPE_INT, 0); s = s0;
for (int32_t i = 0; i < sizeof(s0)/sizeof(s0[0]); ++i) { e = e0;
filterAddMergeRange(h, s0 + i, e0 + i, TSDB_RELATION_AND); asize = sizeof(s0)/sizeof(s[0]);
void *h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 0); ASSERT_EQ(num, 0);
filterFreeMergeRange(h); filterFreeMergeRange(h);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
h = filterInitMergeRange(TSDB_DATA_TYPE_INT, 0); for (int32_t i = 0; i < asize; ++i) {
for (int32_t i = 0; i < sizeof(s0)/sizeof(s0[0]); ++i) { filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
filterAddMergeRange(h, s0 + i, e0 + i, TSDB_RELATION_OR);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 3); ASSERT_EQ(num, 3);
filterGetMergeRangeRes(h, rs0, re0); filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs0[0], -100); ASSERT_EQ(rs[0], -100);
ASSERT_EQ(re0[0], 0); ASSERT_EQ(re[0], 0);
ASSERT_EQ(rs0[1], 1); ASSERT_EQ(rs[1], 1);
ASSERT_EQ(re0[1], 2); ASSERT_EQ(re[1], 2);
ASSERT_EQ(rs0[2], 3); ASSERT_EQ(rs[2], 3);
ASSERT_EQ(re0[2], 4); ASSERT_EQ(re[2], 4);
filterFreeMergeRange(h); filterFreeMergeRange(h);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, MR_OPT_TS);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0); for (int32_t i = 0; i < asize; ++i) {
for (int32_t i = 0; i < sizeof(s1)/sizeof(s1[0]); ++i) { filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
filterAddMergeRange(h, s1 + i, e1 + i, TSDB_RELATION_AND);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 1); ASSERT_EQ(num, 1);
filterGetMergeRangeRes(h, rs1, re1); filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs1[0], 3); ASSERT_EQ(rs[0], -100);
ASSERT_EQ(re1[0], 4); ASSERT_EQ(re[0], 4);
filterFreeMergeRange(h); filterFreeMergeRange(h);
s = s1;
e = e1;
asize = sizeof(s1)/sizeof(s[0]);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0); h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < sizeof(s1)/sizeof(s1[0]); ++i) { for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s1 + i, e1 + i, TSDB_RELATION_OR); filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 1); ASSERT_EQ(num, 1);
filterGetMergeRangeRes(h, rs1, re1); filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs1[0], INT64_MIN); ASSERT_EQ(rs[0], 3);
ASSERT_EQ(re1[0], 100); ASSERT_EQ(re[0], 4);
filterFreeMergeRange(h); filterFreeMergeRange(h);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0); h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) { for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s2 + i, e2 + i, TSDB_RELATION_AND); filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
}
filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 1);
filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs[0], INT64_MIN);
ASSERT_EQ(re[0], 100);
filterFreeMergeRange(h);
s = s2;
e = e2;
asize = sizeof(s2)/sizeof(s[0]);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 0); ASSERT_EQ(num, 0);
@ -96,21 +115,21 @@ void intDataTest() {
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0); h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) { for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s2 + i, e2 + i, TSDB_RELATION_OR); filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 1); ASSERT_EQ(num, 1);
filterGetMergeRangeRes(h, rs2, re2); filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs2[0], 1); ASSERT_EQ(rs[0], 1);
ASSERT_EQ(re2[0], 120); ASSERT_EQ(re[0], 120);
filterFreeMergeRange(h); filterFreeMergeRange(h);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0); h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) { for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s2 + i, e2 + i, i % 2 ? TSDB_RELATION_OR : TSDB_RELATION_AND); filterAddMergeRange(h, s + i, e + i, i % 2 ? TSDB_RELATION_OR : TSDB_RELATION_AND);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 0); ASSERT_EQ(num, 0);
@ -118,21 +137,23 @@ void intDataTest() {
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0); h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < sizeof(s2)/sizeof(s2[0]); ++i) { for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s2 + i, e2 + i, i % 2 ? TSDB_RELATION_AND : TSDB_RELATION_OR); filterAddMergeRange(h, s + i, e + i, i % 2 ? TSDB_RELATION_AND : TSDB_RELATION_OR);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 1); ASSERT_EQ(num, 1);
filterGetMergeRangeRes(h, rs2, re2); filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs2[0], 70); ASSERT_EQ(rs[0], 70);
ASSERT_EQ(re2[0], 120); ASSERT_EQ(re[0], 120);
filterFreeMergeRange(h); filterFreeMergeRange(h);
s = s3;
e = e3;
asize = sizeof(s3)/sizeof(s[0]);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0); h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < sizeof(s3)/sizeof(s3[0]); ++i) { for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s3 + i, e3 + i, TSDB_RELATION_AND); filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_AND);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 0); ASSERT_EQ(num, 0);
@ -140,18 +161,83 @@ void intDataTest() {
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0); h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < sizeof(s3)/sizeof(s3[0]); ++i) { for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s3 + i, e3 + i, TSDB_RELATION_OR); filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
} }
filterGetMergeRangeNum(h, &num); filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 1); ASSERT_EQ(num, 1);
filterGetMergeRangeRes(h, rs3, re3); filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs3[0], 1); ASSERT_EQ(rs[0], 1);
ASSERT_EQ(re3[0], 100); ASSERT_EQ(re[0], 100);
filterFreeMergeRange(h); filterFreeMergeRange(h);
s = s4;
e = e4;
asize = sizeof(s4)/sizeof(s[0]);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s + i, e + 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 < asize; ++i) {
filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
}
filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 2);
filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs[0], 0);
ASSERT_EQ(re[0], 5);
ASSERT_EQ(rs[1], 10);
ASSERT_EQ(re[1], 20);
filterFreeMergeRange(h);
s = s5;
e = e5;
asize = sizeof(s5)/sizeof(s[0]);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s + i, e + 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 < asize; ++i) {
filterAddMergeRange(h, s + i, e + i, TSDB_RELATION_OR);
}
filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 2);
filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs[0], 0);
ASSERT_EQ(re[0], 4);
ASSERT_EQ(rs[1], 6);
ASSERT_EQ(re[1], 20);
filterFreeMergeRange(h);
h = filterInitMergeRange(TSDB_DATA_TYPE_BIGINT, 0);
for (int32_t i = 0; i < asize; ++i) {
filterAddMergeRange(h, s + i, e + i, (i == (asize -1)) ? TSDB_RELATION_AND : TSDB_RELATION_OR);
}
filterGetMergeRangeNum(h, &num);
ASSERT_EQ(num, 1);
filterGetMergeRangeRes(h, rs, re);
ASSERT_EQ(rs[0], 7);
ASSERT_EQ(re[0], 10);
filterFreeMergeRange(h);
} }

1
src/util/src/terror.c
View File

@ -268,6 +268,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_QRY_IN_EXEC, "Multiple retrieval of
TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW, "Too many time window in query") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW, "Too many time window in query")
TAOS_DEFINE_ERROR(TSDB_CODE_QRY_NOT_ENOUGH_BUFFER, "Query buffer limit has reached") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_NOT_ENOUGH_BUFFER, "Query buffer limit has reached")
TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INCONSISTAN, "File inconsistance in replica") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INCONSISTAN, "File inconsistance in replica")
TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_TIME_CONDITION, "One valid time range condition expected")
// grant // grant

115
tests/script/general/parser/condition.sim
View File

@ -1527,12 +1527,109 @@ sql_error select ts,c1,c7 from stb1 where ts != '2021-05-05 18:19:27'
sql_error select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:03.000' or ts < '2021-05-05 18:19:02.000'; sql_error select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:03.000' or ts < '2021-05-05 18:19:02.000';
sql_error select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:03.000' and ts > '2021-05-05 18:19:20.000' and ts != '2021-05-05 18:19:22.000'; sql_error select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:03.000' and ts > '2021-05-05 18:19:20.000' and ts != '2021-05-05 18:19:22.000';
sql_error select * from stb1 where ts2 like '2021-05-05%'; sql_error select * from stb1 where ts2 like '2021-05-05%';
sql_error select * from stb1 where ts > '2021-05-05 18:19:03.000' and ts < '2021-05-05 18:19:02';
sql_error select ts,c1,c2 from stb1 where (ts > '2021-05-05 18:19:25.000' or ts < '2021-05-05 18:19:05.000') and ts > '2021-05-05 18:19:01.000' and ts < '2021-05-05 18:19:27.000';
sql_error select ts,c1,c2 from stb1 where (ts > '2021-05-05 18:19:20.000' or ts < '2021-05-05 18:19:05.000') and ts != '2021-05-05 18:19:25.000';
sql_error select ts,c1,c2 from stb1 where ((ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:10.000') or (ts >= '2021-05-05 18:19:15.000' and ts <= '2021-05-05 18:19:20.000') or (ts >= '2021-05-05 18:19:11.000' and ts <= '2021-05-05 18:19:14.000'));
sql_error select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts < '2021-05-05 18:19:24.000';
sql_error select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' and ts < '2021-05-05 18:19:10.000';
sql select * from stb1 where ts > '2021-05-05 18:19:03.000' and ts < '2021-05-05 18:19:02'; sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts < '2021-05-05 18:19:25.000';
if $rows != 0 then if $rows != 29 then
return -1 return -1
endi endi
sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' and ts < '2021-05-05 18:19:26.000';
if $rows != 1 then
return -1
endi
if $data00 != @21-05-05 18:19:25.000@ then
return -1
endi
sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts < '2021-05-05 18:19:28.000';
if $rows != 29 then
return -1
endi
sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts > '2021-05-05 18:19:27.000';
if $rows != 4 then
return -1
endi
if $data00 != @21-05-05 18:19:25.000@ then
return -1
endi
if $data10 != @21-05-05 18:19:26.000@ then
return -1
endi
if $data20 != @21-05-05 18:19:27.000@ then
return -1
endi
if $data30 != @21-05-05 18:19:28.000@ then
return -1
endi
sql select ts,c1,c2 from stb1 where ts > '2021-05-05 18:19:20.000' or ts < '2021-05-05 18:19:05.000' or ts != '2021-05-05 18:19:25.000';
if $rows != 29 then
return -1
endi
sql select ts,c1,c2 from stb1 where ts >= '2021-05-05 18:19:25.000' or ts <> '2021-05-05 18:19:25.000';
if $rows != 29 then
return -1
endi
sql select ts,c1,c2 from stb1 where ((ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:10.999') or (ts >= '2021-05-05 18:19:15.000' and ts <= '2021-05-05 18:19:20.000') or (ts >= '2021-05-05 18:19:11.000' and ts <= '2021-05-05 18:19:14.999'));
if $rows != 16 then
return -1
endi
if $data00 != @21-05-05 18:19:05.000@ then
return -1
endi
sql select ts,c1,c2 from stb1 where (ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:10.000') or (ts >= '2021-05-05 18:19:12.000' and ts <= '2021-05-05 18:19:14.000') or (ts >= '2021-05-05 18:19:08.000' and ts <= '2021-05-05 18:19:17.000');
if $rows != 13 then
return -1
endi
if $data00 != @21-05-05 18:19:05.000@ then
return -1
endi
sql select ts,c1,c2 from stb1 where (ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:10.000') or (ts >= '2021-05-05 18:19:02.000' and ts <= '2021-05-05 18:19:03.000') or (ts >= '2021-05-05 18:19:01.000' and ts <= '2021-05-05 18:19:08.000');
if $rows != 10 then
return -1
endi
if $data00 != @21-05-05 18:19:01.000@ then
return -1
endi
sql select ts,c1,c2 from stb1 where ((ts >= '2021-05-05 18:19:08.000' and ts <= '2021-05-05 18:19:10.000') or (ts >= '2021-05-05 18:19:02.000' and ts <= '2021-05-05 18:19:03.000') or (ts >= '2021-05-05 18:19:05.000' and ts <= '2021-05-05 18:19:06.000') or (ts >= '2021-05-05 18:19:03.000' and ts <= '2021-05-05 18:19:12.000')) and (ts >= '2021-05-05 18:19:10.000');
if $rows != 3 then
return -1
endi
if $data00 != @21-05-05 18:19:10.000@ then
return -1
endi
if $data10 != @21-05-05 18:19:11.000@ then
return -1
endi
if $data20 != @21-05-05 18:19:12.000@ then
return -1
endi
sql select ts,c1,c7 from stb1 where ts > '2021-05-05 18:19:25.000' and ts != '2021-05-05 18:19:18';
if $rows != 3 then
return -1
endi
if $data00 != @21-05-05 18:19:26.000@ then
return -1
endi
if $data10 != @21-05-05 18:19:27.000@ then
return -1
endi
if $data20 != @21-05-05 18:19:28.000@ then
return -1
endi
sql select * from stb1 where ts > '2021-05-05 18:19:03.000' and ts > '2021-05-05 18:19:25'; sql select * from stb1 where ts > '2021-05-05 18:19:03.000' and ts > '2021-05-05 18:19:25';
if $rows != 3 then if $rows != 3 then
return -1 return -1
@ -1858,6 +1955,20 @@ if $data00 != @21-05-05 18:19:21.000@ then
return -1 return -1
endi endi
sql select * from stb1 where c1!=31 and c1 !=32 and c1 <> 63 and c1 <>1 and c1 <> 21 and c1 <> 2 and c7 <> true and c8 <> '3' and c9 <> '4' and c2<>13 and c3 <> 23 and c4 <> 33 and c5 <> 34 and c6 <> 43 and c2 <> 53 and t1 <> 5 and t2 <>4;
if $rows != 3 then
return -1
endi
if $data00 != @21-05-05 18:19:07.000@ then
return -1
endi
if $data10 != @21-05-05 18:19:11.000@ then
return -1
endi
if $data20 != @21-05-05 18:19:27.000@ then
return -1
endi
print "column&join test" 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; sql_error select tb1.ts,tb1.c1,tb2_1.u1 from tb1, tb2_1 where tb1.ts=tb2_1.ts or tb1.c1 > 0;