Merge branch 'feature/3.0_wxy' into 3.0
This commit is contained in:
WANG MINGMING
GitHub
commit
9012834531
|
|
@ -52,6 +52,8 @@ typedef enum EStreamType {
|
|||
typedef struct {
|
||||
SArray* pTableList;
|
||||
SHashObj* map; // speedup acquire the tableQueryInfo by table uid
|
||||
void* pTagCond;
|
||||
void* pTagIndexCond;
|
||||
} STableListInfo;
|
||||
|
||||
typedef struct SColumnDataAgg {
|
||||
|
|
|
|||
|
|
@ -71,7 +71,8 @@ SEpSet getEpSet_s(SCorEpSet* pEpSet);
|
|||
#define colDataGetData(p1_, r_) \
|
||||
((IS_VAR_DATA_TYPE((p1_)->info.type)) ? colDataGetVarData(p1_, r_) : colDataGetNumData(p1_, r_))
|
||||
|
||||
#define IS_JSON_NULL(type, data) ((type) == TSDB_DATA_TYPE_JSON && *(data) == TSDB_DATA_TYPE_NULL)
|
||||
#define IS_JSON_NULL(type, data) ((type) == TSDB_DATA_TYPE_JSON && \
|
||||
(*(data) == TSDB_DATA_TYPE_NULL || tTagIsJsonNull(data)))
|
||||
|
||||
static FORCE_INLINE bool colDataIsNull_s(const SColumnInfoData* pColumnInfoData, uint32_t row) {
|
||||
if (!pColumnInfoData->hasNull) {
|
||||
|
|
|
|||
|
|
@ -70,6 +70,8 @@ int32_t tGetTSRow(uint8_t *p, STSRow2 *pRow);
|
|||
// STag
|
||||
int32_t tTagNew(SArray *pArray, int32_t version, int8_t isJson, STag **ppTag);
|
||||
void tTagFree(STag *pTag);
|
||||
bool tTagIsJson(const void *pTag);
|
||||
bool tTagIsJsonNull(void *tagVal);
|
||||
bool tTagGet(const STag *pTag, STagVal *pTagVal);
|
||||
char *tTagValToData(const STagVal *pTagVal, bool isJson);
|
||||
int32_t tEncodeTag(SEncoder *pEncoder, const STag *pTag);
|
||||
|
|
|
|||
|
|
@ -66,6 +66,7 @@ typedef struct SScanLogicNode {
|
|||
int8_t intervalUnit;
|
||||
int8_t slidingUnit;
|
||||
SNode* pTagCond;
|
||||
SNode* pTagIndexCond;
|
||||
int8_t triggerType;
|
||||
int64_t watermark;
|
||||
int16_t tsColId;
|
||||
|
|
@ -468,6 +469,7 @@ typedef struct SSubplan {
|
|||
SPhysiNode* pNode; // physical plan of current subplan
|
||||
SDataSinkNode* pDataSink; // data of the subplan flow into the datasink
|
||||
SNode* pTagCond;
|
||||
SNode* pTagIndexCond;
|
||||
} SSubplan;
|
||||
|
||||
typedef enum EExplainMode { EXPLAIN_MODE_DISABLE = 1, EXPLAIN_MODE_STATIC, EXPLAIN_MODE_ANALYZE } EExplainMode;
|
||||
|
|
|
|||
|
|
@ -288,11 +288,11 @@ typedef enum ESqlClause {
|
|||
} ESqlClause;
|
||||
|
||||
typedef struct SDeleteStmt {
|
||||
ENodeType type; // QUERY_NODE_DELETE_STMT
|
||||
SNode* pFromTable; // FROM clause
|
||||
SNode* pWhere; // WHERE clause
|
||||
SNode* pCountFunc; // count the number of rows affected
|
||||
SNode* pTagIndexCond; // pWhere divided into pTagIndexCond and timeRange
|
||||
ENodeType type; // QUERY_NODE_DELETE_STMT
|
||||
SNode* pFromTable; // FROM clause
|
||||
SNode* pWhere; // WHERE clause
|
||||
SNode* pCountFunc; // count the number of rows affected
|
||||
SNode* pTagCond; // pWhere divided into pTagCond and timeRange
|
||||
STimeWindow timeRange;
|
||||
uint8_t precision;
|
||||
bool deleteZeroRows;
|
||||
|
|
@ -397,7 +397,8 @@ void nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
|
|||
|
||||
char* nodesGetFillModeString(EFillMode mode);
|
||||
int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc);
|
||||
int32_t nodesPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagCond, SNode** pOtherCond);
|
||||
int32_t nodesPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagIndexCond, SNode** pTagCond,
|
||||
SNode** pOtherCond);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1507,7 +1507,7 @@ static int32_t estimateJsonLen(SReqResultInfo* pResultInfo, int32_t numOfCols, i
|
|||
char* jsonInnerData = data + CHAR_BYTES;
|
||||
if (jsonInnerType == TSDB_DATA_TYPE_NULL) {
|
||||
len += (VARSTR_HEADER_SIZE + strlen(TSDB_DATA_NULL_STR_L));
|
||||
} else if (jsonInnerType & TD_TAG_JSON) {
|
||||
} else if (tTagIsJson(data)) {
|
||||
len += (VARSTR_HEADER_SIZE + ((const STag*)(data))->len);
|
||||
} else if (jsonInnerType == TSDB_DATA_TYPE_NCHAR) { // value -> "value"
|
||||
len += varDataTLen(jsonInnerData) + CHAR_BYTES * 2;
|
||||
|
|
@ -1592,7 +1592,7 @@ static int32_t doConvertJson(SReqResultInfo* pResultInfo, int32_t numOfCols, int
|
|||
if (jsonInnerType == TSDB_DATA_TYPE_NULL) {
|
||||
sprintf(varDataVal(dst), "%s", TSDB_DATA_NULL_STR_L);
|
||||
varDataSetLen(dst, strlen(varDataVal(dst)));
|
||||
} else if (jsonInnerType & TD_TAG_JSON) {
|
||||
} else if (tTagIsJson(data)) {
|
||||
char* jsonString = parseTagDatatoJson(data);
|
||||
STR_TO_VARSTR(dst, jsonString);
|
||||
taosMemoryFree(jsonString);
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ int32_t getJsonValueLen(const char* data) {
|
|||
dataLen = DOUBLE_BYTES + CHAR_BYTES;
|
||||
} else if (*data == TSDB_DATA_TYPE_BOOL) {
|
||||
dataLen = CHAR_BYTES + CHAR_BYTES;
|
||||
} else if (*data & TD_TAG_JSON) { // json string
|
||||
} else if (tTagIsJson(data)) { // json string
|
||||
dataLen = ((STag*)(data))->len;
|
||||
} else {
|
||||
ASSERT(0);
|
||||
|
|
|
|||
|
|
@ -924,6 +924,18 @@ static int32_t tGetTagVal(uint8_t *p, STagVal *pTagVal, int8_t isJson) {
|
|||
|
||||
return n;
|
||||
}
|
||||
|
||||
bool tTagIsJson(const void *pTag){
|
||||
return (((const STag *)pTag)->flags & TD_TAG_JSON);
|
||||
}
|
||||
|
||||
bool tTagIsJsonNull(void *data){
|
||||
STag *pTag = (STag*)data;
|
||||
int8_t isJson = tTagIsJson(pTag);
|
||||
if(!isJson) return false;
|
||||
return ((STag*)data)->nTag == 0;
|
||||
}
|
||||
|
||||
int32_t tTagNew(SArray *pArray, int32_t version, int8_t isJson, STag **ppTag) {
|
||||
int32_t code = 0;
|
||||
uint8_t *p = NULL;
|
||||
|
|
|
|||
|
|
@ -613,9 +613,6 @@ const void *metaGetTableTagVal(SMetaEntry *pEntry, int16_t type, STagVal *val) {
|
|||
ASSERT(pEntry->type == TSDB_CHILD_TABLE);
|
||||
STag *tag = (STag *)pEntry->ctbEntry.pTags;
|
||||
if (type == TSDB_DATA_TYPE_JSON) {
|
||||
if (tag->nTag == 0) {
|
||||
return NULL;
|
||||
}
|
||||
return tag;
|
||||
}
|
||||
bool find = tTagGet(tag, val);
|
||||
|
|
|
|||
|
|
@ -106,7 +106,8 @@ int32_t getNumOfTotalRes(SGroupResInfo* pGroupResInfo);
|
|||
|
||||
SSDataBlock* createResDataBlock(SDataBlockDescNode* pNode);
|
||||
|
||||
int32_t getTableList(void* metaHandle, SScanPhysiNode* pScanNode, STableListInfo* pListInfo, SNode* pTagCond);
|
||||
EDealRes doTranslateTagExpr(SNode** pNode, void* pContext);
|
||||
int32_t getTableList(void* metaHandle, SScanPhysiNode* pScanNode, STableListInfo* pListInfo);
|
||||
SArray* createSortInfo(SNodeList* pNodeList);
|
||||
SArray* extractPartitionColInfo(SNodeList* pNodeList);
|
||||
SArray* extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols, int32_t type);
|
||||
|
|
|
|||
|
|
@ -282,7 +282,6 @@ typedef struct STagScanInfo {
|
|||
int32_t curPos;
|
||||
SReadHandle readHandle;
|
||||
STableListInfo *pTableList;
|
||||
SNode* pFilterNode; // filter info,
|
||||
} STagScanInfo;
|
||||
|
||||
typedef enum EStreamScanMode {
|
||||
|
|
|
|||
|
|
@ -214,28 +214,111 @@ SSDataBlock* createResDataBlock(SDataBlockDescNode* pNode) {
|
|||
return pBlock;
|
||||
}
|
||||
|
||||
int32_t getTableList(void* metaHandle, SScanPhysiNode* pScanNode, STableListInfo* pListInfo, SNode* pTagCond) {
|
||||
EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
|
||||
SMetaReader* mr = (SMetaReader*)pContext;
|
||||
if(nodeType(*pNode) == QUERY_NODE_COLUMN){
|
||||
SColumnNode* pSColumnNode = *(SColumnNode**)pNode;
|
||||
|
||||
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
|
||||
if (NULL == res) {
|
||||
return DEAL_RES_ERROR;
|
||||
}
|
||||
|
||||
res->translate = true;
|
||||
res->node.resType = pSColumnNode->node.resType;
|
||||
|
||||
STagVal tagVal = {0};
|
||||
tagVal.cid = pSColumnNode->colId;
|
||||
const char* p = metaGetTableTagVal(&mr->me, pSColumnNode->node.resType.type, &tagVal);
|
||||
if (p == NULL) {
|
||||
res->node.resType.type = TSDB_DATA_TYPE_NULL;
|
||||
}else if (pSColumnNode->node.resType.type == TSDB_DATA_TYPE_JSON) {
|
||||
int32_t len = ((const STag*)p) -> len;
|
||||
res->datum.p = taosMemoryCalloc(len + 1, 1);
|
||||
memcpy(res->datum.p, p, len);
|
||||
} else if (IS_VAR_DATA_TYPE(pSColumnNode->node.resType.type)) {
|
||||
res->datum.p = taosMemoryCalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1, 1);
|
||||
memcpy(varDataVal(res->datum.p), tagVal.pData, tagVal.nData);
|
||||
varDataSetLen(res->datum.p, tagVal.nData);
|
||||
} else {
|
||||
nodesSetValueNodeValue(res, &(tagVal.i64));
|
||||
}
|
||||
nodesDestroyNode(*pNode);
|
||||
*pNode = (SNode*)res;
|
||||
}else if (nodeType(*pNode) == QUERY_NODE_FUNCTION){
|
||||
SFunctionNode * pFuncNode = *(SFunctionNode**)pNode;
|
||||
if(pFuncNode->funcType == FUNCTION_TYPE_TBNAME){
|
||||
SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
|
||||
if (NULL == res) {
|
||||
return DEAL_RES_ERROR;
|
||||
}
|
||||
|
||||
res->translate = true;
|
||||
res->node.resType = pFuncNode->node.resType;
|
||||
|
||||
int32_t len = strlen(mr->me.name);
|
||||
res->datum.p = taosMemoryCalloc(len + VARSTR_HEADER_SIZE + 1, 1);
|
||||
memcpy(varDataVal(res->datum.p), mr->me.name, len);
|
||||
varDataSetLen(res->datum.p, len);
|
||||
nodesDestroyNode(*pNode);
|
||||
*pNode = (SNode*)res;
|
||||
}
|
||||
}
|
||||
|
||||
return DEAL_RES_CONTINUE;
|
||||
}
|
||||
|
||||
static bool isTableOk(STableKeyInfo* info, SNode *pTagCond, SMeta *metaHandle){
|
||||
SMetaReader mr = {0};
|
||||
metaReaderInit(&mr, metaHandle, 0);
|
||||
metaGetTableEntryByUid(&mr, info->uid);
|
||||
|
||||
SNode *pTagCondTmp = nodesCloneNode(pTagCond);
|
||||
|
||||
nodesRewriteExprPostOrder(&pTagCondTmp, doTranslateTagExpr, &mr);
|
||||
metaReaderClear(&mr);
|
||||
|
||||
SNode* pNew = NULL;
|
||||
int32_t code = scalarCalculateConstants(pTagCondTmp, &pNew);
|
||||
if (TSDB_CODE_SUCCESS != code) {
|
||||
nodesDestroyNode(pTagCondTmp);
|
||||
return false;
|
||||
}
|
||||
|
||||
ASSERT(nodeType(pNew) == QUERY_NODE_VALUE);
|
||||
SValueNode *pValue = (SValueNode *)pNew;
|
||||
|
||||
ASSERT(pValue->node.resType.type == TSDB_DATA_TYPE_BOOL);
|
||||
bool result = pValue->datum.b;
|
||||
nodesDestroyNode(pNew);
|
||||
return result;
|
||||
}
|
||||
|
||||
int32_t getTableList(void* metaHandle, SScanPhysiNode* pScanNode, STableListInfo* pListInfo) {
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
pListInfo->pTableList = taosArrayInit(8, sizeof(STableKeyInfo));
|
||||
|
||||
uint64_t tableUid = pScanNode->uid;
|
||||
|
||||
SNode* pTagCond = (SNode*)pListInfo->pTagCond;
|
||||
SNode* pTagIndexCond = (SNode*)pListInfo->pTagIndexCond;
|
||||
if (pScanNode->tableType == TSDB_SUPER_TABLE) {
|
||||
if (pTagCond) {
|
||||
if (pTagIndexCond) {
|
||||
SIndexMetaArg metaArg = {
|
||||
.metaEx = metaHandle, .idx = tsdbGetIdx(metaHandle), .ivtIdx = tsdbGetIvtIdx(metaHandle), .suid = tableUid};
|
||||
|
||||
SArray* res = taosArrayInit(8, sizeof(uint64_t));
|
||||
code = doFilterTag(pTagCond, &metaArg, res);
|
||||
if (code == TSDB_CODE_INDEX_REBUILDING) { // todo
|
||||
// doFilter();
|
||||
//code = doFilterTag(pTagIndexCond, &metaArg, res);
|
||||
code = TSDB_CODE_INDEX_REBUILDING;
|
||||
if (code == TSDB_CODE_INDEX_REBUILDING) {
|
||||
code = tsdbGetAllTableList(metaHandle, tableUid, pListInfo->pTableList);
|
||||
} else if (code != TSDB_CODE_SUCCESS) {
|
||||
qError("failed to get tableIds, reason: %s, suid: %" PRIu64 "", tstrerror(code), tableUid);
|
||||
taosArrayDestroy(res);
|
||||
terrno = code;
|
||||
return code;
|
||||
} else {
|
||||
qDebug("success to get tableIds, size: %d, suid: %" PRIu64 "", (int)taosArrayGetSize(res), tableUid);
|
||||
qDebug("sucess to get tableIds, size: %d, suid: %" PRIu64 "", (int)taosArrayGetSize(res), tableUid);
|
||||
}
|
||||
|
||||
for (int i = 0; i < taosArrayGetSize(res); i++) {
|
||||
|
|
@ -246,7 +329,20 @@ int32_t getTableList(void* metaHandle, SScanPhysiNode* pScanNode, STableListInfo
|
|||
} else {
|
||||
code = tsdbGetAllTableList(metaHandle, tableUid, pListInfo->pTableList);
|
||||
}
|
||||
} else { // Create one table group.
|
||||
|
||||
if(pTagCond){
|
||||
int32_t i = 0;
|
||||
while(i < taosArrayGetSize(pListInfo->pTableList)) {
|
||||
STableKeyInfo* info = taosArrayGet(pListInfo->pTableList, i);
|
||||
bool isOk = isTableOk(info, pTagCond, metaHandle);
|
||||
if(!isOk){
|
||||
taosArrayRemove(pListInfo->pTableList, i);
|
||||
continue;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}else { // Create one table group.
|
||||
STableKeyInfo info = {.lastKey = 0, .uid = tableUid, .groupId = 0};
|
||||
taosArrayPush(pListInfo->pTableList, &info);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3872,8 +3872,7 @@ static SExecTaskInfo* createExecTaskInfo(uint64_t queryId, uint64_t taskId, EOPT
|
|||
}
|
||||
|
||||
static tsdbReaderT doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle,
|
||||
STableListInfo* pTableListInfo, uint64_t queryId, uint64_t taskId,
|
||||
SNode* pTagCond);
|
||||
STableListInfo* pTableListInfo, uint64_t queryId, uint64_t taskId);
|
||||
|
||||
static SArray* extractColumnInfo(SNodeList* pNodeList);
|
||||
|
||||
|
|
@ -3987,7 +3986,7 @@ int32_t generateGroupIdMap(STableListInfo* pTableListInfo, SReadHandle* pHandle,
|
|||
}
|
||||
|
||||
SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle,
|
||||
uint64_t queryId, uint64_t taskId, STableListInfo* pTableListInfo, SNode* pTagCond) {
|
||||
uint64_t queryId, uint64_t taskId, STableListInfo* pTableListInfo) {
|
||||
int32_t type = nodeType(pPhyNode);
|
||||
|
||||
if (pPhyNode->pChildren == NULL || LIST_LENGTH(pPhyNode->pChildren) == 0) {
|
||||
|
|
@ -3995,7 +3994,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
|
|||
STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pPhyNode;
|
||||
|
||||
tsdbReaderT pDataReader =
|
||||
doCreateDataReader(pTableScanNode, pHandle, pTableListInfo, (uint64_t)queryId, taskId, pTagCond);
|
||||
doCreateDataReader(pTableScanNode, pHandle, pTableListInfo, (uint64_t)queryId, taskId);
|
||||
if (pDataReader == NULL && terrno != 0) {
|
||||
pTaskInfo->code = terrno;
|
||||
return NULL;
|
||||
|
|
@ -4045,10 +4044,10 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
|
|||
if (pHandle->vnode) {
|
||||
// for stram
|
||||
pDataReader =
|
||||
doCreateDataReader(pTableScanNode, pHandle, pTableListInfo, (uint64_t)queryId, taskId, pTagCond);
|
||||
doCreateDataReader(pTableScanNode, pHandle, pTableListInfo, (uint64_t)queryId, taskId);
|
||||
} else {
|
||||
// for tq
|
||||
getTableList(pHandle->meta, pScanPhyNode, pTableListInfo, pTagCond);
|
||||
getTableList(pHandle->meta, pScanPhyNode, pTableListInfo);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -4076,7 +4075,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
|
|||
} else if (QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN == type) {
|
||||
STagScanPhysiNode* pScanPhyNode = (STagScanPhysiNode*)pPhyNode;
|
||||
|
||||
int32_t code = getTableList(pHandle->meta, pScanPhyNode, pTableListInfo, pScanPhyNode->node.pConditions);
|
||||
int32_t code = getTableList(pHandle->meta, pScanPhyNode, pTableListInfo);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
pTaskInfo->code = terrno;
|
||||
return NULL;
|
||||
|
|
@ -4134,7 +4133,7 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
|
|||
SOperatorInfo** ops = taosMemoryCalloc(size, POINTER_BYTES);
|
||||
for (int32_t i = 0; i < size; ++i) {
|
||||
SPhysiNode* pChildNode = (SPhysiNode*)nodesListGetNode(pPhyNode->pChildren, i);
|
||||
ops[i] = createOperatorTree(pChildNode, pTaskInfo, pHandle, queryId, taskId, pTableListInfo, pTagCond);
|
||||
ops[i] = createOperatorTree(pChildNode, pTaskInfo, pHandle, queryId, taskId, pTableListInfo);
|
||||
if (ops[i] == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -4338,8 +4337,8 @@ SArray* extractColumnInfo(SNodeList* pNodeList) {
|
|||
}
|
||||
|
||||
tsdbReaderT doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle,
|
||||
STableListInfo* pTableListInfo, uint64_t queryId, uint64_t taskId, SNode* pTagCond) {
|
||||
int32_t code = getTableList(pHandle->meta, &pTableScanNode->scan, pTableListInfo, pTagCond);
|
||||
STableListInfo* pTableListInfo, uint64_t queryId, uint64_t taskId) {
|
||||
int32_t code = getTableList(pHandle->meta, &pTableScanNode->scan, pTableListInfo);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
goto _error;
|
||||
}
|
||||
|
|
@ -4497,8 +4496,10 @@ int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SRead
|
|||
}
|
||||
|
||||
(*pTaskInfo)->sql = sql;
|
||||
(*pTaskInfo)->tableqinfoList.pTagCond = pPlan->pTagCond;
|
||||
(*pTaskInfo)->tableqinfoList.pTagIndexCond = pPlan->pTagIndexCond;
|
||||
(*pTaskInfo)->pRoot = createOperatorTree(pPlan->pNode, *pTaskInfo, pHandle, queryId, taskId,
|
||||
&(*pTaskInfo)->tableqinfoList, pPlan->pTagCond);
|
||||
&(*pTaskInfo)->tableqinfoList);
|
||||
if (NULL == (*pTaskInfo)->pRoot) {
|
||||
code = (*pTaskInfo)->code;
|
||||
goto _complete;
|
||||
|
|
|
|||
|
|
@ -337,7 +337,7 @@ void addTagPseudoColumnData(SReadHandle* pHandle, SExprInfo* pPseudoExpr, int32_
|
|||
}
|
||||
|
||||
for (int32_t i = 0; i < pBlock->info.rows; ++i) {
|
||||
colDataAppend(pColInfoData, i, data, (data == NULL));
|
||||
colDataAppend(pColInfoData, i, data, (data == NULL) || (pColInfoData->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data)));
|
||||
}
|
||||
|
||||
if (data && (pColInfoData->info.type != TSDB_DATA_TYPE_JSON) && p != NULL &&
|
||||
|
|
@ -1829,7 +1829,7 @@ static SSDataBlock* doTagScan(SOperatorInfo* pOperator) {
|
|||
} else {
|
||||
data = (char*)p;
|
||||
}
|
||||
colDataAppend(pDst, count, data, (data == NULL));
|
||||
colDataAppend(pDst, count, data, (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data)));
|
||||
|
||||
if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) &&
|
||||
data != NULL) {
|
||||
|
|
@ -1852,9 +1852,7 @@ static SSDataBlock* doTagScan(SOperatorInfo* pOperator) {
|
|||
}
|
||||
|
||||
pRes->info.rows = count;
|
||||
doFilter(pInfo->pFilterNode, pRes);
|
||||
|
||||
pOperator->resultInfo.totalRows += pRes->info.rows;
|
||||
pOperator->resultInfo.totalRows += count;
|
||||
|
||||
return (pRes->info.rows == 0) ? NULL : pInfo->pRes;
|
||||
}
|
||||
|
|
@ -1884,13 +1882,11 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi
|
|||
goto _error;
|
||||
}
|
||||
|
||||
pInfo->pTableList = pTableListInfo;
|
||||
pInfo->pColMatchInfo = colList;
|
||||
pInfo->pRes = createResDataBlock(pDescNode);
|
||||
pInfo->readHandle = *pReadHandle;
|
||||
pInfo->curPos = 0;
|
||||
pInfo->pFilterNode = pPhyNode->node.pConditions;
|
||||
|
||||
pInfo->pTableList = pTableListInfo;
|
||||
pInfo->pColMatchInfo = colList;
|
||||
pInfo->pRes = createResDataBlock(pDescNode);
|
||||
pInfo->readHandle = *pReadHandle;
|
||||
pInfo->curPos = 0;
|
||||
pOperator->name = "TagScanOperator";
|
||||
pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN;
|
||||
|
||||
|
|
@ -1973,7 +1969,7 @@ int32_t compareTableKeyInfoByGid(const void* p1, const void* p2) {
|
|||
|
||||
int32_t createScanTableListInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle,
|
||||
STableListInfo* pTableListInfo, uint64_t queryId, uint64_t taskId, SNode* pTagCond) {
|
||||
int32_t code = getTableList(pHandle->meta, &pTableScanNode->scan, pTableListInfo, pTagCond);
|
||||
int32_t code = getTableList(pHandle->meta, &pTableScanNode->scan, pTableListInfo);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
return code;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -351,6 +351,7 @@ static SNode* logicScanCopy(const SScanLogicNode* pSrc, SScanLogicNode* pDst) {
|
|||
COPY_SCALAR_FIELD(intervalUnit);
|
||||
COPY_SCALAR_FIELD(slidingUnit);
|
||||
CLONE_NODE_FIELD(pTagCond);
|
||||
CLONE_NODE_FIELD(pTagIndexCond);
|
||||
COPY_SCALAR_FIELD(triggerType);
|
||||
COPY_SCALAR_FIELD(watermark);
|
||||
COPY_SCALAR_FIELD(tsColId);
|
||||
|
|
|
|||
|
|
@ -2326,6 +2326,7 @@ static const char* jkSubplanNodeAddr = "NodeAddr";
|
|||
static const char* jkSubplanRootNode = "RootNode";
|
||||
static const char* jkSubplanDataSink = "DataSink";
|
||||
static const char* jkSubplanTagCond = "TagCond";
|
||||
static const char* jkSubplanTagIndexCond = "TagIndexCond";
|
||||
|
||||
static int32_t subplanToJson(const void* pObj, SJson* pJson) {
|
||||
const SSubplan* pNode = (const SSubplan*)pObj;
|
||||
|
|
@ -2355,6 +2356,9 @@ static int32_t subplanToJson(const void* pObj, SJson* pJson) {
|
|||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = tjsonAddObject(pJson, jkSubplanTagCond, nodeToJson, pNode->pTagCond);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = tjsonAddObject(pJson, jkSubplanTagIndexCond, nodeToJson, pNode->pTagIndexCond);
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
|
@ -2388,6 +2392,9 @@ static int32_t jsonToSubplan(const SJson* pJson, void* pObj) {
|
|||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = jsonToNodeObject(pJson, jkSubplanTagCond, (SNode**)&pNode->pTagCond);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = jsonToNodeObject(pJson, jkSubplanTagIndexCond, (SNode**)&pNode->pTagIndexCond);
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
|
@ -3954,7 +3961,7 @@ static int32_t deleteStmtToJson(const void* pObj, SJson* pJson) {
|
|||
code = tjsonAddObject(pJson, jkDeleteStmtCountFunc, nodeToJson, pNode->pCountFunc);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = tjsonAddObject(pJson, jkDeleteStmtTagIndexCond, nodeToJson, pNode->pTagIndexCond);
|
||||
code = tjsonAddObject(pJson, jkDeleteStmtTagIndexCond, nodeToJson, pNode->pTagCond);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = tjsonAddIntegerToObject(pJson, jkDeleteStmtTimeRangeStartKey, pNode->timeRange.skey);
|
||||
|
|
@ -3983,7 +3990,7 @@ static int32_t jsonToDeleteStmt(const SJson* pJson, void* pObj) {
|
|||
code = jsonToNodeObject(pJson, jkDeleteStmtCountFunc, &pNode->pCountFunc);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = jsonToNodeObject(pJson, jkDeleteStmtTagIndexCond, &pNode->pTagIndexCond);
|
||||
code = jsonToNodeObject(pJson, jkDeleteStmtTagIndexCond, &pNode->pTagCond);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = tjsonGetBigIntValue(pJson, jkDeleteStmtTimeRangeStartKey, &pNode->timeRange.skey);
|
||||
|
|
|
|||
|
|
@ -669,7 +669,7 @@ void nodesDestroyNode(SNode* pNode) {
|
|||
nodesDestroyNode(pStmt->pFromTable);
|
||||
nodesDestroyNode(pStmt->pWhere);
|
||||
nodesDestroyNode(pStmt->pCountFunc);
|
||||
nodesDestroyNode(pStmt->pTagIndexCond);
|
||||
nodesDestroyNode(pStmt->pTagCond);
|
||||
break;
|
||||
}
|
||||
case QUERY_NODE_QUERY: {
|
||||
|
|
@ -688,7 +688,13 @@ void nodesDestroyNode(SNode* pNode) {
|
|||
SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode;
|
||||
destroyLogicNode((SLogicNode*)pLogicNode);
|
||||
nodesDestroyList(pLogicNode->pScanCols);
|
||||
nodesDestroyList(pLogicNode->pScanPseudoCols);
|
||||
taosMemoryFreeClear(pLogicNode->pVgroupList);
|
||||
nodesDestroyList(pLogicNode->pDynamicScanFuncs);
|
||||
nodesDestroyNode(pLogicNode->pTagCond);
|
||||
nodesDestroyNode(pLogicNode->pTagIndexCond);
|
||||
taosArrayDestroy(pLogicNode->pSmaIndexes);
|
||||
nodesDestroyList(pLogicNode->pPartTags);
|
||||
break;
|
||||
}
|
||||
case QUERY_NODE_LOGIC_PLAN_JOIN: {
|
||||
|
|
@ -897,6 +903,8 @@ void nodesDestroyNode(SNode* pNode) {
|
|||
nodesDestroyList(pSubplan->pChildren);
|
||||
nodesDestroyNode((SNode*)pSubplan->pNode);
|
||||
nodesDestroyNode((SNode*)pSubplan->pDataSink);
|
||||
nodesDestroyNode((SNode*)pSubplan->pTagCond);
|
||||
nodesDestroyNode((SNode*)pSubplan->pTagIndexCond);
|
||||
nodesClearList(pSubplan->pParents);
|
||||
break;
|
||||
}
|
||||
|
|
@ -1130,6 +1138,7 @@ void* nodesGetValueFromNode(SValueNode* pNode) {
|
|||
case TSDB_DATA_TYPE_NCHAR:
|
||||
case TSDB_DATA_TYPE_VARCHAR:
|
||||
case TSDB_DATA_TYPE_VARBINARY:
|
||||
case TSDB_DATA_TYPE_JSON:
|
||||
return (void*)pNode->datum.p;
|
||||
default:
|
||||
break;
|
||||
|
|
@ -1659,6 +1668,7 @@ int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc) {
|
|||
typedef struct SClassifyConditionCxt {
|
||||
bool hasPrimaryKey;
|
||||
bool hasTagIndexCol;
|
||||
bool hasTagCol;
|
||||
bool hasOtherCol;
|
||||
} SClassifyConditionCxt;
|
||||
|
||||
|
|
@ -1670,6 +1680,9 @@ static EDealRes classifyConditionImpl(SNode* pNode, void* pContext) {
|
|||
pCxt->hasPrimaryKey = true;
|
||||
} else if (pCol->hasIndex) {
|
||||
pCxt->hasTagIndexCol = true;
|
||||
pCxt->hasTagCol = true;
|
||||
} else if (COLUMN_TYPE_TAG == pCol->colType) {
|
||||
pCxt->hasTagCol = true;
|
||||
} else {
|
||||
pCxt->hasOtherCol = true;
|
||||
}
|
||||
|
|
@ -1678,23 +1691,31 @@ static EDealRes classifyConditionImpl(SNode* pNode, void* pContext) {
|
|||
return DEAL_RES_CONTINUE;
|
||||
}
|
||||
|
||||
typedef enum EConditionType { COND_TYPE_PRIMARY_KEY = 1, COND_TYPE_TAG_INDEX, COND_TYPE_NORMAL } EConditionType;
|
||||
typedef enum EConditionType {
|
||||
COND_TYPE_PRIMARY_KEY = 1,
|
||||
COND_TYPE_TAG_INDEX,
|
||||
COND_TYPE_TAG,
|
||||
COND_TYPE_NORMAL
|
||||
} EConditionType;
|
||||
|
||||
static EConditionType classifyCondition(SNode* pNode) {
|
||||
SClassifyConditionCxt cxt = {.hasPrimaryKey = false, .hasTagIndexCol = false, .hasOtherCol = false};
|
||||
nodesWalkExpr(pNode, classifyConditionImpl, &cxt);
|
||||
return cxt.hasOtherCol ? COND_TYPE_NORMAL
|
||||
: (cxt.hasPrimaryKey && cxt.hasTagIndexCol
|
||||
: (cxt.hasPrimaryKey && cxt.hasTagCol
|
||||
? COND_TYPE_NORMAL
|
||||
: (cxt.hasPrimaryKey ? COND_TYPE_PRIMARY_KEY : COND_TYPE_TAG_INDEX));
|
||||
: (cxt.hasPrimaryKey ? COND_TYPE_PRIMARY_KEY
|
||||
: (cxt.hasTagIndexCol ? COND_TYPE_TAG_INDEX : COND_TYPE_TAG)));
|
||||
}
|
||||
|
||||
static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagCond, SNode** pOtherCond) {
|
||||
static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagIndexCond, SNode** pTagCond,
|
||||
SNode** pOtherCond) {
|
||||
SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(*pCondition);
|
||||
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
||||
SNodeList* pPrimaryKeyConds = NULL;
|
||||
SNodeList* pTagIndexConds = NULL;
|
||||
SNodeList* pTagConds = NULL;
|
||||
SNodeList* pOtherConds = NULL;
|
||||
SNode* pCond = NULL;
|
||||
|
|
@ -1706,6 +1727,14 @@ static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, S
|
|||
}
|
||||
break;
|
||||
case COND_TYPE_TAG_INDEX:
|
||||
if (NULL != pTagIndexCond) {
|
||||
code = nodesListMakeAppend(&pTagIndexConds, nodesCloneNode(pCond));
|
||||
}
|
||||
if (NULL != pTagCond) {
|
||||
code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
|
||||
}
|
||||
break;
|
||||
case COND_TYPE_TAG:
|
||||
if (NULL != pTagCond) {
|
||||
code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond));
|
||||
}
|
||||
|
|
@ -1723,11 +1752,15 @@ static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, S
|
|||
}
|
||||
|
||||
SNode* pTempPrimaryKeyCond = NULL;
|
||||
SNode* pTempTagIndexCond = NULL;
|
||||
SNode* pTempTagCond = NULL;
|
||||
SNode* pTempOtherCond = NULL;
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = nodesMergeConds(&pTempPrimaryKeyCond, &pPrimaryKeyConds);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = nodesMergeConds(&pTempTagIndexCond, &pTagIndexConds);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
code = nodesMergeConds(&pTempTagCond, &pTagConds);
|
||||
}
|
||||
|
|
@ -1739,6 +1772,9 @@ static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, S
|
|||
if (NULL != pPrimaryKeyCond) {
|
||||
*pPrimaryKeyCond = pTempPrimaryKeyCond;
|
||||
}
|
||||
if (NULL != pTagIndexCond) {
|
||||
*pTagIndexCond = pTempTagIndexCond;
|
||||
}
|
||||
if (NULL != pTagCond) {
|
||||
*pTagCond = pTempTagCond;
|
||||
}
|
||||
|
|
@ -1749,9 +1785,11 @@ static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, S
|
|||
*pCondition = NULL;
|
||||
} else {
|
||||
nodesDestroyList(pPrimaryKeyConds);
|
||||
nodesDestroyList(pTagIndexConds);
|
||||
nodesDestroyList(pTagConds);
|
||||
nodesDestroyList(pOtherConds);
|
||||
nodesDestroyNode(pTempPrimaryKeyCond);
|
||||
nodesDestroyNode(pTempTagIndexCond);
|
||||
nodesDestroyNode(pTempTagCond);
|
||||
nodesDestroyNode(pTempOtherCond);
|
||||
}
|
||||
|
|
@ -1759,10 +1797,11 @@ static int32_t partitionLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond, S
|
|||
return code;
|
||||
}
|
||||
|
||||
int32_t nodesPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagCond, SNode** pOtherCond) {
|
||||
int32_t nodesPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode** pTagIndexCond, SNode** pTagCond,
|
||||
SNode** pOtherCond) {
|
||||
if (QUERY_NODE_LOGIC_CONDITION == nodeType(*pCondition) &&
|
||||
LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)*pCondition)->condType) {
|
||||
return partitionLogicCond(pCondition, pPrimaryKeyCond, pTagCond, pOtherCond);
|
||||
return partitionLogicCond(pCondition, pPrimaryKeyCond, pTagIndexCond, pTagCond, pOtherCond);
|
||||
}
|
||||
|
||||
switch (classifyCondition(*pCondition)) {
|
||||
|
|
@ -1772,6 +1811,21 @@ int32_t nodesPartitionCond(SNode** pCondition, SNode** pPrimaryKeyCond, SNode**
|
|||
}
|
||||
break;
|
||||
case COND_TYPE_TAG_INDEX:
|
||||
if (NULL != pTagIndexCond) {
|
||||
*pTagIndexCond = *pCondition;
|
||||
}
|
||||
if (NULL != pTagCond) {
|
||||
SNode* pTempCond = *pCondition;
|
||||
if (NULL != pTagIndexCond) {
|
||||
pTempCond = nodesCloneNode(*pCondition);
|
||||
if (NULL == pTempCond) {
|
||||
return TSDB_CODE_OUT_OF_MEMORY;
|
||||
}
|
||||
}
|
||||
*pTagCond = pTempCond;
|
||||
}
|
||||
break;
|
||||
case COND_TYPE_TAG:
|
||||
if (NULL != pTagCond) {
|
||||
*pTagCond = *pCondition;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2013,7 +2013,7 @@ static int32_t getFillTimeRange(STranslateContext* pCxt, SNode* pWhere, STimeWin
|
|||
}
|
||||
|
||||
SNode* pPrimaryKeyCond = NULL;
|
||||
nodesPartitionCond(&pCond, &pPrimaryKeyCond, NULL, NULL);
|
||||
nodesPartitionCond(&pCond, &pPrimaryKeyCond, NULL, NULL, NULL);
|
||||
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
if (NULL != pPrimaryKeyCond) {
|
||||
|
|
@ -2682,7 +2682,7 @@ static int32_t partitionDeleteWhere(STranslateContext* pCxt, SDeleteStmt* pDelet
|
|||
|
||||
SNode* pPrimaryKeyCond = NULL;
|
||||
SNode* pOtherCond = NULL;
|
||||
int32_t code = nodesPartitionCond(&pDelete->pWhere, &pPrimaryKeyCond, &pDelete->pTagIndexCond, &pOtherCond);
|
||||
int32_t code = nodesPartitionCond(&pDelete->pWhere, &pPrimaryKeyCond, NULL, &pDelete->pTagCond, &pOtherCond);
|
||||
if (TSDB_CODE_SUCCESS == code && NULL != pOtherCond) {
|
||||
code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_DELETE_WHERE);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1160,8 +1160,8 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p
|
|||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code && NULL != pDelete->pTagIndexCond) {
|
||||
pScan->pTagCond = nodesCloneNode(pDelete->pTagIndexCond);
|
||||
if (TSDB_CODE_SUCCESS == code && NULL != pDelete->pTagCond) {
|
||||
pScan->pTagCond = nodesCloneNode(pDelete->pTagCond);
|
||||
if (NULL == pScan->pTagCond) {
|
||||
code = TSDB_CODE_OUT_OF_MEMORY;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,6 @@
|
|||
|
||||
#include "filter.h"
|
||||
#include "functionMgt.h"
|
||||
#include "index.h"
|
||||
#include "planInt.h"
|
||||
#include "ttime.h"
|
||||
|
||||
|
|
@ -309,32 +308,6 @@ static int32_t cpdCalcTimeRange(SOptimizeContext* pCxt, SScanLogicNode* pScan, S
|
|||
return code;
|
||||
}
|
||||
|
||||
static int32_t cpdApplyTagIndex(SScanLogicNode* pScan, SNode** pTagCond, SNode** pOtherCond) {
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
SIdxFltStatus idxStatus = idxGetFltStatus(*pTagCond);
|
||||
switch (idxStatus) {
|
||||
case SFLT_NOT_INDEX:
|
||||
code = cpdCondAppend(pOtherCond, pTagCond);
|
||||
break;
|
||||
case SFLT_COARSE_INDEX:
|
||||
pScan->pTagCond = nodesCloneNode(*pTagCond);
|
||||
if (NULL == pScan->pTagCond) {
|
||||
code = TSDB_CODE_OUT_OF_MEMORY;
|
||||
break;
|
||||
}
|
||||
code = cpdCondAppend(pOtherCond, pTagCond);
|
||||
break;
|
||||
case SFLT_ACCURATE_INDEX:
|
||||
pScan->pTagCond = *pTagCond;
|
||||
*pTagCond = NULL;
|
||||
break;
|
||||
default:
|
||||
code = TSDB_CODE_FAILED;
|
||||
break;
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
static int32_t cpdOptimizeScanCondition(SOptimizeContext* pCxt, SScanLogicNode* pScan) {
|
||||
if (NULL == pScan->node.pConditions || OPTIMIZE_FLAG_TEST_MASK(pScan->node.optimizedFlag, OPTIMIZE_FLAG_CPD) ||
|
||||
TSDB_SYSTEM_TABLE == pScan->tableType) {
|
||||
|
|
@ -342,15 +315,12 @@ static int32_t cpdOptimizeScanCondition(SOptimizeContext* pCxt, SScanLogicNode*
|
|||
}
|
||||
|
||||
SNode* pPrimaryKeyCond = NULL;
|
||||
SNode* pTagCond = NULL;
|
||||
SNode* pOtherCond = NULL;
|
||||
int32_t code = nodesPartitionCond(&pScan->node.pConditions, &pPrimaryKeyCond, &pTagCond, &pOtherCond);
|
||||
int32_t code = nodesPartitionCond(&pScan->node.pConditions, &pPrimaryKeyCond, &pScan->pTagIndexCond, &pScan->pTagCond,
|
||||
&pOtherCond);
|
||||
if (TSDB_CODE_SUCCESS == code && NULL != pPrimaryKeyCond) {
|
||||
code = cpdCalcTimeRange(pCxt, pScan, &pPrimaryKeyCond, &pOtherCond);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code && NULL != pTagCond) {
|
||||
code = cpdApplyTagIndex(pScan, &pTagCond, &pOtherCond);
|
||||
}
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
pScan->node.pConditions = pOtherCond;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -436,6 +436,15 @@ static int32_t createScanPhysiNodeFinalize(SPhysiPlanContext* pCxt, SSubplan* pS
|
|||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
if (NULL != pScanLogicNode->pTagIndexCond) {
|
||||
pSubplan->pTagIndexCond = nodesCloneNode(pScanLogicNode->pTagIndexCond);
|
||||
if (NULL == pSubplan->pTagIndexCond) {
|
||||
code = TSDB_CODE_OUT_OF_MEMORY;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (TSDB_CODE_SUCCESS == code) {
|
||||
*pPhyNode = (SPhysiNode*)pScanPhysiNode;
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -40,6 +40,8 @@ TEST_F(PlanOptimizeTest, ConditionPushDown) {
|
|||
run("SELECT ts, c1 FROM st1 WHERE tag1 > 4 or tag1 < 2");
|
||||
|
||||
run("SELECT ts, c1 FROM st1 WHERE tag1 > 4 AND tag2 = 'hello'");
|
||||
|
||||
run("SELECT ts, c1 FROM st1 WHERE tag1 > 4 AND tag2 = 'hello' AND c1 > 10");
|
||||
}
|
||||
|
||||
TEST_F(PlanOptimizeTest, orderByPrimaryKey) {
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@
|
|||
#include "sclvector.h"
|
||||
#include "tcompare.h"
|
||||
#include "tdatablock.h"
|
||||
#include "tdataformat.h"
|
||||
#include "ttypes.h"
|
||||
#include "ttime.h"
|
||||
|
||||
|
|
@ -506,6 +507,16 @@ bool convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t t
|
|||
}
|
||||
}
|
||||
|
||||
// if types can not comparable
|
||||
if((IS_NUMERIC_TYPE(typeLeft) && !IS_NUMERIC_TYPE(typeRight)) ||
|
||||
(IS_NUMERIC_TYPE(typeRight) && !IS_NUMERIC_TYPE(typeLeft)) ||
|
||||
(IS_VAR_DATA_TYPE(typeLeft) && !IS_VAR_DATA_TYPE(typeRight)) ||
|
||||
(IS_VAR_DATA_TYPE(typeRight) && !IS_VAR_DATA_TYPE(typeLeft)) ||
|
||||
((typeLeft == TSDB_DATA_TYPE_BOOL) && (typeRight != TSDB_DATA_TYPE_BOOL)) ||
|
||||
((typeRight == TSDB_DATA_TYPE_BOOL) && (typeLeft != TSDB_DATA_TYPE_BOOL)))
|
||||
return false;
|
||||
|
||||
|
||||
if(typeLeft == TSDB_DATA_TYPE_NULL || typeRight == TSDB_DATA_TYPE_NULL){
|
||||
*isNull = true;
|
||||
return true;
|
||||
|
|
@ -519,24 +530,28 @@ bool convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t t
|
|||
|
||||
*fp = filterGetCompFunc(type, optr);
|
||||
|
||||
if(IS_NUMERIC_TYPE(type) || IS_FLOAT_TYPE(type)){
|
||||
if(IS_NUMERIC_TYPE(type)){
|
||||
if(typeLeft == TSDB_DATA_TYPE_NCHAR) {
|
||||
convertNcharToDouble(*pLeftData, pLeftOut);
|
||||
*pLeftData = pLeftOut;
|
||||
ASSERT(0);
|
||||
// convertNcharToDouble(*pLeftData, pLeftOut);
|
||||
// *pLeftData = pLeftOut;
|
||||
} else if(typeLeft == TSDB_DATA_TYPE_BINARY) {
|
||||
convertBinaryToDouble(*pLeftData, pLeftOut);
|
||||
*pLeftData = pLeftOut;
|
||||
ASSERT(0);
|
||||
// convertBinaryToDouble(*pLeftData, pLeftOut);
|
||||
// *pLeftData = pLeftOut;
|
||||
} else if(typeLeft != type) {
|
||||
convertNumberToNumber(*pLeftData, pLeftOut, typeLeft, type);
|
||||
*pLeftData = pLeftOut;
|
||||
}
|
||||
|
||||
if(typeRight == TSDB_DATA_TYPE_NCHAR) {
|
||||
convertNcharToDouble(*pRightData, pRightOut);
|
||||
*pRightData = pRightOut;
|
||||
ASSERT(0);
|
||||
// convertNcharToDouble(*pRightData, pRightOut);
|
||||
// *pRightData = pRightOut;
|
||||
} else if(typeRight == TSDB_DATA_TYPE_BINARY) {
|
||||
convertBinaryToDouble(*pRightData, pRightOut);
|
||||
*pRightData = pRightOut;
|
||||
ASSERT(0);
|
||||
// convertBinaryToDouble(*pRightData, pRightOut);
|
||||
// *pRightData = pRightOut;
|
||||
} else if(typeRight != type) {
|
||||
convertNumberToNumber(*pRightData, pRightOut, typeRight, type);
|
||||
*pRightData = pRightOut;
|
||||
|
|
@ -1693,6 +1708,13 @@ void vectorIsTrue(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut,
|
|||
|
||||
STagVal getJsonValue(char *json, char *key, bool *isExist) {
|
||||
STagVal val = {.pKey = key};
|
||||
if (tTagIsJson((const STag *)json) == false){
|
||||
if(isExist){
|
||||
*isExist = false;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
bool find = tTagGet(((const STag *)json), &val); // json value is null and not exist is different
|
||||
if(isExist){
|
||||
*isExist = find;
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ class TDTestCase:
|
|||
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('[1,true]')")
|
||||
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{222}')")
|
||||
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"fe\"}')")
|
||||
#
|
||||
|
||||
# test invalidate json key, key must can be printed assic char
|
||||
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"tag1\":[1,true]}')")
|
||||
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"tag1\":{}}')")
|
||||
|
|
@ -79,7 +79,7 @@ class TDTestCase:
|
|||
# test invalidate json value, value number can not be inf,nan TD-12166
|
||||
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"k\":1.8e308}')")
|
||||
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"k\":-1.8e308}')")
|
||||
#
|
||||
|
||||
#test length limit
|
||||
char1= ''.join(['abcd']*64)
|
||||
char3= ''.join(['abcd']*1021)
|
||||
|
|
@ -87,15 +87,15 @@ class TDTestCase:
|
|||
tdSql.error("CREATE TABLE if not exists jsons1_15 using jsons1 tags('{\"%s1\":5}')" % char1) # len(key)=257
|
||||
tdSql.execute("CREATE TABLE if not exists jsons1_15 using jsons1 tags('{\"%s\":5}')" % char1) # len(key)=256
|
||||
tdSql.error("CREATE TABLE if not exists jsons1_16 using jsons1 tags('{\"TSSSS\":\"%s\"}')" % char3) # len(object)=4096
|
||||
#tdSql.execute("CREATE TABLE if not exists jsons1_16 using jsons1 tags('{\"TSSS\":\"%s\"}')" % char3) # len(object)=4095
|
||||
tdSql.execute("CREATE TABLE if not exists jsons1_16 using jsons1 tags('{\"TSSS\":\"%s\"}')" % char3) # len(object)=4095
|
||||
tdSql.execute("drop table if exists jsons1_15")
|
||||
tdSql.execute("drop table if exists jsons1_16")
|
||||
#
|
||||
|
||||
print("============== STEP 2 ===== alter table json tag")
|
||||
tdSql.error("ALTER STABLE jsons1 add tag tag2 nchar(20)")
|
||||
tdSql.error("ALTER STABLE jsons1 drop tag jtag")
|
||||
tdSql.error("ALTER TABLE jsons1 MODIFY TAG jtag nchar(128)")
|
||||
#
|
||||
|
||||
tdSql.execute("ALTER TABLE jsons1_1 SET TAG jtag='{\"tag1\":\"femail\",\"tag2\":35,\"tag3\":true}'")
|
||||
tdSql.query("select jtag from jsons1_1")
|
||||
tdSql.checkData(0, 0, '{"tag1":"femail","tag2":35,"tag3":true}')
|
||||
|
|
@ -105,9 +105,9 @@ class TDTestCase:
|
|||
tdSql.execute("create table st(ts timestamp, i int) tags(t int)")
|
||||
tdSql.error("ALTER STABLE st add tag jtag json")
|
||||
tdSql.error("ALTER STABLE st add column jtag json")
|
||||
#
|
||||
# print("============== STEP 3 ===== query table")
|
||||
# # test error syntax
|
||||
|
||||
print("============== STEP 3 ===== query table")
|
||||
# test error syntax
|
||||
tdSql.error("select * from jsons1 where jtag->tag1='beijing'")
|
||||
tdSql.error("select -> from jsons1")
|
||||
tdSql.error("select * from jsons1 where contains")
|
||||
|
|
@ -115,17 +115,17 @@ class TDTestCase:
|
|||
tdSql.error("select jtag->location from jsons1")
|
||||
tdSql.error("select jtag contains location from jsons1")
|
||||
tdSql.error("select * from jsons1 where jtag contains location")
|
||||
#tdSql.error("select * from jsons1 where jtag contains''")
|
||||
tdSql.query("select * from jsons1 where jtag contains''")
|
||||
tdSql.error("select * from jsons1 where jtag contains 'location'='beijing'")
|
||||
#
|
||||
# # test function error
|
||||
|
||||
# test function error
|
||||
tdSql.error("select avg(jtag->'tag1') from jsons1")
|
||||
tdSql.error("select avg(jtag) from jsons1")
|
||||
tdSql.error("select min(jtag->'tag1') from jsons1")
|
||||
tdSql.error("select min(jtag) from jsons1")
|
||||
tdSql.error("select ceil(jtag->'tag1') from jsons1")
|
||||
tdSql.error("select ceil(jtag) from jsons1")
|
||||
#
|
||||
|
||||
|
||||
#test scalar operation
|
||||
tdSql.query("select jtag contains 'tag1',jtag->'tag1' from jsons1 order by jtag->'tag1'")
|
||||
|
|
@ -158,10 +158,11 @@ class TDTestCase:
|
|||
tdSql.checkData(0, 0, None)
|
||||
tdSql.checkData(0, 1, False)
|
||||
tdSql.checkData(7, 0, "false")
|
||||
tdSql.checkData(7, 1, True)
|
||||
tdSql.checkData(7, 1, False)
|
||||
tdSql.checkData(8, 1, False)
|
||||
tdSql.checkData(12, 1, True)
|
||||
|
||||
# # test select normal column
|
||||
# test select normal column
|
||||
tdSql.query("select dataint from jsons1 order by dataint")
|
||||
tdSql.checkRows(9)
|
||||
tdSql.checkData(1, 0, 1)
|
||||
|
|
@ -180,7 +181,7 @@ class TDTestCase:
|
|||
tdSql.query("select jtag from jsons1_9")
|
||||
tdSql.checkData(0, 0, None)
|
||||
|
||||
# # test select json tag->'key', value is string
|
||||
# test select json tag->'key', value is string
|
||||
tdSql.query("select jtag->'tag1' from jsons1_1")
|
||||
tdSql.checkData(0, 0, '"femail"')
|
||||
tdSql.query("select jtag->'tag2' from jsons1_6")
|
||||
|
|
@ -200,7 +201,7 @@ class TDTestCase:
|
|||
# test select json tag->'key', key is not exist
|
||||
tdSql.query("select jtag->'tag10' from jsons1_4")
|
||||
tdSql.checkData(0, 0, None)
|
||||
#
|
||||
|
||||
tdSql.query("select jtag->'tag1' from jsons1")
|
||||
tdSql.checkRows(13)
|
||||
# test header name
|
||||
|
|
@ -210,24 +211,25 @@ class TDTestCase:
|
|||
tdSql.checkColNameList(res, cname_list)
|
||||
|
||||
|
||||
# # test where with json tag
|
||||
# test where with json tag
|
||||
tdSql.query("select * from jsons1_1 where jtag is not null")
|
||||
# tdSql.error("select * from jsons1 where jtag='{\"tag1\":11,\"tag2\":\"\"}'")
|
||||
# tdSql.error("select * from jsons1 where jtag->'tag1'={}")
|
||||
#
|
||||
# # where json value is string
|
||||
# tdSql.query("select * from jsons1 where jtag='{\"tag1\":11,\"tag2\":\"\"}'")
|
||||
tdSql.error("select * from jsons1 where jtag->'tag1'={}")
|
||||
|
||||
# where json value is string
|
||||
tdSql.query("select * from jsons1 where jtag->'tag2'='beijing'")
|
||||
tdSql.checkRows(2)
|
||||
tdSql.query("select dataint,tbname,jtag->'tag1',jtag from jsons1 where jtag->'tag2'='beijing'")
|
||||
tdSql.query("select dataint,tbname,jtag->'tag1',jtag from jsons1 where jtag->'tag2'='beijing' order by dataint")
|
||||
tdSql.checkRows(2)
|
||||
# out of order, cannot compare value
|
||||
#tdSql.checkData(0, 0, 2)
|
||||
#tdSql.checkData(0, 1, 'jsons1_2')
|
||||
#tdSql.checkData(0, 2, 5)
|
||||
#tdSql.checkData(0, 3, '{"tag1":5,"tag2":"beijing"}')
|
||||
#tdSql.checkData(1, 0, 3)
|
||||
#tdSql.checkData(1, 1, 'jsons1_3')
|
||||
#tdSql.checkData(1, 2, 'false')
|
||||
tdSql.checkData(0, 0, 2)
|
||||
tdSql.checkData(0, 1, 'jsons1_2')
|
||||
tdSql.checkData(0, 2, "5.000000000")
|
||||
tdSql.checkData(0, 3, '{"tag1":5,"tag2":"beijing"}')
|
||||
tdSql.checkData(1, 0, 3)
|
||||
tdSql.checkData(1, 1, 'jsons1_3')
|
||||
tdSql.checkData(1, 2, 'false')
|
||||
|
||||
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'='beijing'")
|
||||
tdSql.checkRows(0)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'='收到货'")
|
||||
|
|
@ -236,72 +238,73 @@ class TDTestCase:
|
|||
tdSql.checkRows(1)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag2'>='beijing'")
|
||||
tdSql.checkRows(3)
|
||||
# open
|
||||
#tdSql.query("select * from jsons1 where jtag->'tag2'<'beijing'")
|
||||
#tdSql.checkRows(2)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag2'<='beijing'")
|
||||
tdSql.query("select * from jsons1 where jtag->'tag2'<'beijing'")
|
||||
tdSql.checkRows(2)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag2'<='beijing'")
|
||||
tdSql.checkRows(4)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag2'!='beijing'")
|
||||
tdSql.checkRows(5)
|
||||
tdSql.checkRows(3)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag2'=''")
|
||||
tdSql.checkRows(2)
|
||||
#
|
||||
# # where json value is int
|
||||
|
||||
# where json value is int
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'=5")
|
||||
tdSql.checkRows(1)
|
||||
tdSql.checkData(0, 1, 2)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'=10")
|
||||
tdSql.checkRows(0)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'<54")
|
||||
tdSql.checkRows(4)
|
||||
tdSql.checkRows(3)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'<=11")
|
||||
tdSql.checkRows(4)
|
||||
tdSql.checkRows(3)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'>4")
|
||||
tdSql.checkRows(2)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'>=5")
|
||||
tdSql.checkRows(2)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'!=5")
|
||||
tdSql.checkRows(6)
|
||||
tdSql.checkRows(2)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'!=55")
|
||||
tdSql.checkRows(7)
|
||||
#
|
||||
# # where json value is double
|
||||
tdSql.checkRows(3)
|
||||
|
||||
# where json value is double
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'=1.232")
|
||||
tdSql.checkRows(1)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'<1.232")
|
||||
tdSql.checkRows(1)
|
||||
tdSql.checkRows(0)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'<=1.232")
|
||||
tdSql.checkRows(2)
|
||||
tdSql.checkRows(1)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'>1.23")
|
||||
tdSql.checkRows(3)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'>=1.232")
|
||||
tdSql.checkRows(3)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'!=1.232")
|
||||
tdSql.checkRows(6)
|
||||
tdSql.checkRows(2)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'!=3.232")
|
||||
tdSql.checkRows(7)
|
||||
#tdSql.error("select * from jsons1 where jtag->'tag1'/0=3")
|
||||
#tdSql.error("select * from jsons1 where jtag->'tag1'/5=1")
|
||||
#
|
||||
# # where json value is bool
|
||||
tdSql.checkRows(3)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'/0=3")
|
||||
tdSql.checkRows(0)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'/5=1")
|
||||
tdSql.checkRows(1)
|
||||
|
||||
# where json value is bool
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'=true")
|
||||
tdSql.checkRows(0)
|
||||
#tdSql.query("select * from jsons1 where jtag->'tag1'=false")
|
||||
#tdSql.checkRows(1)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'=false")
|
||||
tdSql.checkRows(1)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'!=false")
|
||||
tdSql.checkRows(3)
|
||||
#tdSql.error("select * from jsons1 where jtag->'tag1'>false")
|
||||
#
|
||||
# # where json value is null
|
||||
# open
|
||||
#tdSql.query("select * from jsons1 where jtag->'tag1'=null") # only json suport =null. This synatx will change later.
|
||||
#tdSql.checkRows(1)
|
||||
#
|
||||
# # where json key is null
|
||||
tdSql.checkRows(0)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'>false")
|
||||
tdSql.checkRows(0)
|
||||
|
||||
# where json value is null
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'=null")
|
||||
tdSql.checkRows(0)
|
||||
|
||||
# where json key is null
|
||||
tdSql.query("select * from jsons1 where jtag->'tag_no_exist'=3")
|
||||
tdSql.checkRows(0)
|
||||
#
|
||||
# # where json value is not exist
|
||||
|
||||
# where json value is not exist
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1' is null")
|
||||
tdSql.checkData(0, 0, 'jsons1_9')
|
||||
tdSql.checkRows(2)
|
||||
|
|
@ -309,16 +312,16 @@ class TDTestCase:
|
|||
tdSql.checkRows(9)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag3' is not null")
|
||||
tdSql.checkRows(3)
|
||||
#
|
||||
# # test contains
|
||||
|
||||
# test contains
|
||||
tdSql.query("select * from jsons1 where jtag contains 'tag1'")
|
||||
tdSql.checkRows(7)
|
||||
tdSql.checkRows(8)
|
||||
tdSql.query("select * from jsons1 where jtag contains 'tag3'")
|
||||
tdSql.checkRows(3)
|
||||
tdSql.checkRows(4)
|
||||
tdSql.query("select * from jsons1 where jtag contains 'tag_no_exist'")
|
||||
tdSql.checkRows(0)
|
||||
#
|
||||
# # test json tag in where condition with and/or
|
||||
|
||||
# test json tag in where condition with and/or
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'=false and jtag->'tag2'='beijing'")
|
||||
tdSql.checkRows(1)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'=false or jtag->'tag2'='beijing'")
|
||||
|
|
@ -335,15 +338,15 @@ class TDTestCase:
|
|||
tdSql.checkRows(3)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1'='femail' and jtag contains 'tag3'")
|
||||
tdSql.checkRows(2)
|
||||
#
|
||||
#
|
||||
# # test with between and
|
||||
|
||||
|
||||
# test with between and
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1' between 1 and 30")
|
||||
tdSql.checkRows(3)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1' between 'femail' and 'beijing'")
|
||||
tdSql.checkRows(2)
|
||||
#
|
||||
# # test with tbname/normal column
|
||||
|
||||
# test with tbname/normal column
|
||||
tdSql.query("select * from jsons1 where tbname = 'jsons1_1'")
|
||||
tdSql.checkRows(2)
|
||||
tdSql.query("select * from jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3'")
|
||||
|
|
@ -352,20 +355,18 @@ class TDTestCase:
|
|||
tdSql.checkRows(0)
|
||||
tdSql.query("select * from jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3' and dataint=23")
|
||||
tdSql.checkRows(1)
|
||||
#
|
||||
#
|
||||
# # test where condition like
|
||||
# open
|
||||
# syntax error
|
||||
#tdSql.query("select *,tbname from jsons1 where jtag->'tag2' like 'bei%'")
|
||||
#tdSql.checkRows(2)
|
||||
#tdSql.query("select *,tbname from jsons1 where jtag->'tag1' like 'fe%' and jtag->'tag2' is not null")
|
||||
#tdSql.checkRows(2)
|
||||
#
|
||||
# # test where condition in no support in
|
||||
|
||||
|
||||
# test where condition like
|
||||
tdSql.query("select * from jsons1 where jtag->'tag2' like 'bei%'")
|
||||
tdSql.checkRows(2)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1' like 'fe%' and jtag->'tag2' is not null")
|
||||
tdSql.checkRows(2)
|
||||
|
||||
# test where condition in no support in
|
||||
# tdSql.error("select * from jsons1 where jtag->'tag1' in ('beijing')")
|
||||
#
|
||||
# # test where condition match/nmath
|
||||
|
||||
# test where condition match/nmath
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1' match 'ma'")
|
||||
tdSql.checkRows(2)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1' match 'ma$'")
|
||||
|
|
@ -376,23 +377,22 @@ class TDTestCase:
|
|||
tdSql.checkRows(1)
|
||||
tdSql.query("select * from jsons1 where jtag->'tag1' nmatch 'ma'")
|
||||
tdSql.checkRows(1)
|
||||
#
|
||||
# # test distinct
|
||||
|
||||
# test distinct
|
||||
tdSql.execute("insert into jsons1_14 using jsons1 tags('{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}') values(1591062628000, 2, NULL, '你就会', 'dws')")
|
||||
tdSql.query("select distinct jtag->'tag1' from jsons1")
|
||||
tdSql.checkRows(8)
|
||||
tdSql.query("select distinct jtag from jsons1")
|
||||
tdSql.checkRows(9)
|
||||
#
|
||||
# #test dumplicate key with normal colomn
|
||||
|
||||
#test dumplicate key with normal colomn
|
||||
tdSql.execute("INSERT INTO jsons1_15 using jsons1 tags('{\"tbname\":\"tt\",\"databool\":true,\"datastr\":\"是是是\"}') values(1591060828000, 4, false, 'jjsf', \"你就会\")")
|
||||
#tdSql.query("select *,tbname,jtag from jsons1 where jtag->'datastr' match '是' and datastr match 'js'")
|
||||
#tdSql.checkRows(1)
|
||||
# open
|
||||
#tdSql.query("select tbname,jtag->'tbname' from jsons1 where jtag->'tbname'='tt' and tbname='jsons1_14'")
|
||||
#tdSql.checkRows(0)
|
||||
#
|
||||
# # test join
|
||||
tdSql.query("select * from jsons1 where jtag->'datastr' match '是' and datastr match 'js'")
|
||||
tdSql.checkRows(1)
|
||||
# tdSql.query("select tbname,jtag->'tbname' from jsons1 where jtag->'tbname'='tt' and tbname='jsons1_14'")
|
||||
# tdSql.checkRows(1)
|
||||
|
||||
# test join
|
||||
tdSql.execute("create table if not exists jsons2(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
|
||||
tdSql.execute("insert into jsons2_1 using jsons2 tags('{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}') values(1591060618000, 2, false, 'json2', '你是2')")
|
||||
tdSql.execute("insert into jsons2_2 using jsons2 tags('{\"tag1\":5,\"tag2\":null}') values (1591060628000, 2, true, 'json2', 'sss')")
|
||||
|
|
@ -460,19 +460,18 @@ class TDTestCase:
|
|||
tdSql.checkColNameList(res, cname_list)
|
||||
|
||||
# test top/bottom with group by json tag
|
||||
# random failure
|
||||
#tdSql.query("select top(dataint,2),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1'")
|
||||
#tdSql.checkRows(11)
|
||||
#tdSql.checkData(0, 1, None)
|
||||
#tdSql.checkData(2, 0, 4)
|
||||
#tdSql.checkData(3, 0, 3)
|
||||
#tdSql.checkData(3, 1, "false")
|
||||
#tdSql.checkData(10, 0, 23)
|
||||
#tdSql.checkData(10, 1, '"femail"')
|
||||
# tdSql.query("select top(dataint,2),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1'")
|
||||
# tdSql.checkRows(11)
|
||||
# tdSql.checkData(0, 1, None)
|
||||
# tdSql.checkData(2, 0, 4)
|
||||
# tdSql.checkData(3, 0, 3)
|
||||
# tdSql.checkData(3, 1, "false")
|
||||
# tdSql.checkData(8, 0, 2)
|
||||
# tdSql.checkData(10, 1, '"femail"')
|
||||
|
||||
# test having
|
||||
#tdSql.query("select count(*),jtag->'tag1' from jsons1 group by jtag->'tag1' having count(*) > 1")
|
||||
#tdSql.checkRows(3)
|
||||
tdSql.query("select count(*),jtag->'tag1' from jsons1 group by jtag->'tag1' having count(*) > 1")
|
||||
tdSql.checkRows(3)
|
||||
|
||||
# subquery with json tag
|
||||
tdSql.query("select * from (select jtag, dataint from jsons1) order by dataint")
|
||||
|
|
@ -480,22 +479,13 @@ class TDTestCase:
|
|||
tdSql.checkData(1, 1, 1)
|
||||
tdSql.checkData(5, 0, '{"tag1":false,"tag2":"beijing"}')
|
||||
|
||||
# tdSql.query("select jtag->'tag1' from (select jtag->'tag1', dataint from jsons1)")
|
||||
# tdSql.checkRows(11)
|
||||
# tdSql.checkData(1, 0, '"femail"')
|
||||
# tdSql.checkData(2, 0, 5)
|
||||
#
|
||||
# res = tdSql.getColNameList("select jtag->'tag1' from (select jtag->'tag1', dataint from jsons1)")
|
||||
# cname_list = []
|
||||
# cname_list.append("jtag->'tag1'")
|
||||
# tdSql.checkColNameList(res, cname_list)
|
||||
#
|
||||
# tdSql.query("select ts,tbname,jtag->'tag1' from (select jtag->'tag1',tbname,ts from jsons1 order by ts)")
|
||||
tdSql.error("select jtag->'tag1' from (select jtag->'tag1', dataint from jsons1)")
|
||||
# tdSql.query("select ts,jtag->'tag1' from (select jtag->'tag1',tbname,ts from jsons1 order by ts)")
|
||||
# tdSql.checkRows(11)
|
||||
# tdSql.checkData(1, 1, "jsons1_1")
|
||||
# tdSql.checkData(1, 2, '"femail"')
|
||||
#
|
||||
# # union all
|
||||
|
||||
# union all
|
||||
tdSql.query("select jtag->'tag1' from jsons1 union all select jtag->'tag2' from jsons2")
|
||||
tdSql.checkRows(17)
|
||||
tdSql.query("select jtag->'tag1' from jsons1_1 union all select jtag->'tag2' from jsons2_1")
|
||||
|
|
@ -508,24 +498,25 @@ class TDTestCase:
|
|||
tdSql.query("select dataint,jtag,tbname from jsons1 union all select dataint,jtag,tbname from jsons2")
|
||||
tdSql.checkRows(13)
|
||||
|
||||
# #show create table
|
||||
# tdSql.query("show create table jsons1")
|
||||
# tdSql.checkData(0, 1, 'CREATE TABLE `jsons1` (`ts` TIMESTAMP,`dataint` INT,`databool` BOOL,`datastr` NCHAR(50),`datastrbin` BINARY(150)) TAGS (`jtag` JSON)')
|
||||
#
|
||||
# #test aggregate function:count/avg/twa/irate/sum/stddev/leastsquares
|
||||
#show create table
|
||||
tdSql.query("show create table jsons1")
|
||||
tdSql.checkData(0, 1, 'CREATE STABLE `jsons1` (`ts` TIMESTAMP, `dataint` INT, `databool` BOOL, `datastr` NCHAR(50), `datastrbin` VARCHAR(150)) TAGS (`jtag` JSON) WATERMARK 5000a, 5000a')
|
||||
|
||||
#test aggregate function:count/avg/twa/irate/sum/stddev/leastsquares
|
||||
tdSql.query("select count(*) from jsons1 where jtag is not null")
|
||||
tdSql.checkData(0, 0, 10)
|
||||
tdSql.query("select avg(dataint) from jsons1 where jtag is not null")
|
||||
tdSql.checkData(0, 0, 5.3)
|
||||
#tdSql.error("select twa(dataint) from jsons1 where jtag is not null")
|
||||
tdSql.query("select irate(dataint) from jsons1 where jtag is not null")
|
||||
#tdSql.query("select sum(dataint) from jsons1 where jtag->'tag1' is not null")
|
||||
#tdSql.checkData(0, 0, 49)
|
||||
# tdSql.query("select twa(dataint) from jsons1 where jtag is not null")
|
||||
# tdSql.checkData(0, 0, 36)
|
||||
tdSql.error("select irate(dataint) from jsons1 where jtag is not null")
|
||||
tdSql.query("select sum(dataint) from jsons1 where jtag->'tag1' is not null")
|
||||
tdSql.checkData(0, 0, 45)
|
||||
tdSql.query("select stddev(dataint) from jsons1 where jtag->'tag1'>1")
|
||||
tdSql.checkData(0, 0, 4.496912521)
|
||||
#tdSql.error("SELECT LEASTSQUARES(dataint, 1, 1) from jsons1 where jtag is not null")
|
||||
#
|
||||
# #test selection function:min/max/first/last/top/bottom/percentile/apercentile/last_row/interp
|
||||
tdSql.query("SELECT LEASTSQUARES(dataint, 1, 1) from jsons1 where jtag is not null")
|
||||
|
||||
#test selection function:min/max/first/last/top/bottom/percentile/apercentile/last_row/interp
|
||||
tdSql.query("select min(dataint) from jsons1 where jtag->'tag1'>1")
|
||||
tdSql.checkData(0, 0, 1)
|
||||
tdSql.query("select max(dataint) from jsons1 where jtag->'tag1'>1")
|
||||
|
|
@ -541,13 +532,16 @@ class TDTestCase:
|
|||
tdSql.query("select percentile(dataint,20) from jsons1 where jtag->'tag1'>1")
|
||||
tdSql.query("select apercentile(dataint, 50) from jsons1 where jtag->'tag1'>1")
|
||||
tdSql.checkData(0, 0, 1.5)
|
||||
#tdSql.query("select last_row(dataint) from jsons1 where jtag->'tag1'>1")
|
||||
#tdSql.checkData(0, 0, 11)
|
||||
#tdSql.error("select interp(dataint) from jsons1 where ts = '2020-06-02 09:17:08.000' and jtag->'tag1'>1")
|
||||
#
|
||||
# #test calculation function:diff/derivative/spread/ceil/floor/round/
|
||||
#tdSql.error("select diff(dataint) from jsons1 where jtag->'tag1'>1")
|
||||
#tdSql.error("select derivative(dataint, 10m, 0) from jsons1 where jtag->'tag1'>1")
|
||||
# tdSql.query("select last_row(dataint) from jsons1 where jtag->'tag1'>1")
|
||||
# tdSql.query("select interp(dataint) from jsons1 where ts = '2020-06-02 09:17:08.000' and jtag->'tag1'>1")
|
||||
|
||||
#test calculation function:diff/derivative/spread/ceil/floor/round/
|
||||
tdSql.query("select diff(dataint) from jsons1 where jtag->'tag1'>1")
|
||||
# tdSql.checkRows(2)
|
||||
# tdSql.checkData(0, 0, -1)
|
||||
# tdSql.checkData(1, 0, 10)
|
||||
tdSql.query("select derivative(dataint, 10m, 0) from jsons1 where jtag->'tag1'>1")
|
||||
tdSql.checkData(0, 0, -2)
|
||||
tdSql.query("select spread(dataint) from jsons1 where jtag->'tag1'>1")
|
||||
tdSql.checkData(0, 0, 10)
|
||||
tdSql.query("select ceil(dataint) from jsons1 where jtag->'tag1'>1")
|
||||
|
|
|
|||
Loading…
Reference in New Issue