Merge pull request #17199 from taosdata/fix/tbNameInvalidTag

fix(query): fix invalid tag value

include/util/tarray.h

@@ -288,6 +288,13 @@ void*   taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_
 
 char* taosShowStrArray(const SArray* pArray);
 
+/**
+ * swap array
+ * @param a
+ * @param b
+ * @return
+ */
+void taosArraySwap(SArray* a, SArray* b);
 #ifdef __cplusplus
 }
 #endif

source/dnode/vnode/inc/vnode.h

@@ -96,11 +96,11 @@ void        metaReaderClear(SMetaReader *pReader);
 int32_t     metaGetTableEntryByUid(SMetaReader *pReader, tb_uid_t uid);
 int         metaGetTableEntryByName(SMetaReader *pReader, const char *name);
 int32_t     metaGetTableTags(SMeta *pMeta, uint64_t suid, SArray *uidList, SHashObj *tags);
-int32_t     metaGetTableTagsByUids(SMeta *pMeta, uint64_t suid, SArray *uidList, SHashObj *tags);
+int32_t     metaGetTableTagsByUids(SMeta *pMeta, int64_t suid, SArray *uidList, SHashObj *tags);
 int32_t     metaReadNext(SMetaReader *pReader);
 const void *metaGetTableTagVal(void *tag, int16_t type, STagVal *tagVal);
 int         metaGetTableNameByUid(void *meta, uint64_t uid, char *tbName);
-int         metaGetTableUidByName(void *meta, char *tbName, uint64_t *uid);
+int         metaGetTableUidByName(void *meta, char *tbName, int64_t *uid);
 int         metaGetTableTypeByName(void *meta, char *tbName, ETableType *tbType);
 bool        metaIsTableExist(SMeta *pMeta, tb_uid_t uid);
 

source/dnode/vnode/src/meta/metaQuery.c

@@ -202,7 +202,7 @@ int metaGetTableNameByUid(void *meta, uint64_t uid, char *tbName) {
 
   return 0;
 }
-int metaGetTableUidByName(void *meta, char *tbName, uint64_t *uid) {
+int metaGetTableUidByName(void *meta, char *tbName, int64_t *uid) {
   int         code = 0;
   SMetaReader mr = {0};
   metaReaderInit(&mr, (SMeta *)meta, 0);
@@ -1134,7 +1134,7 @@ END:
   return ret;
 }
 
-static int32_t metaGetTableTagByUid(SMeta *pMeta, uint64_t suid, uint64_t uid, void **tag, int32_t *len, bool lock) {
+static int32_t metaGetTableTagByUid(SMeta *pMeta, int64_t suid, int64_t uid, void **tag, int32_t *len, bool lock) {
   int ret = 0;
   if (lock) {
     metaRLock(pMeta);
@@ -1148,7 +1148,7 @@ static int32_t metaGetTableTagByUid(SMeta *pMeta, uint64_t suid, uint64_t uid, v
 
   return ret;
 }
-int32_t metaGetTableTagsByUids(SMeta *pMeta, uint64_t suid, SArray *uidList, SHashObj *tags) {
+int32_t metaGetTableTagsByUids(SMeta *pMeta, int64_t suid, SArray *uidList, SHashObj *tags) {
   const int32_t LIMIT = 128;
 
   int32_t isLock = false;
@@ -1169,6 +1169,9 @@ int32_t metaGetTableTagsByUids(SMeta *pMeta, uint64_t suid, SArray *uidList, SHa
       if (metaGetTableTagByUid(pMeta, suid, *id, &val, &len, false) == 0) {
         taosHashPut(tags, id, sizeof(tb_uid_t), val, len);
         tdbFree(val);
+      } else {
+        metaError("vgId:%d, failed to table IDs, suid: %" PRId64 ", uid: %" PRId64 "", TD_VID(pMeta->pVnode), suid,
+                  *id);
       }
     }
   }

source/libs/executor/src/executil.c

@@ -26,7 +26,8 @@
 #include "executorimpl.h"
 #include "tcompression.h"
 
-static int32_t optimizeTbnameInCond(void* metaHandle, int64_t suid, SArray* list, SNode* pTagCond);
+static int32_t removeInvalidTable(SArray* list, SHashObj* tags);
+static int32_t optimizeTbnameInCond(void* metaHandle, int64_t suid, SArray* list, SNode* pTagCond, SHashObj* tags);
 static int32_t optimizeTbnameInCondImpl(void* metaHandle, int64_t suid, SArray* list, SNode* pTagCond);
 
 void initResultRowInfo(SResultRowInfo* pResultRowInfo) {
@@ -373,7 +374,7 @@ static int32_t createResultData(SDataType* pType, int32_t numOfRows, SScalarPara
   return TSDB_CODE_SUCCESS;
 }
 
-static SColumnInfoData* getColInfoResult(void* metaHandle, uint64_t suid, SArray* uidList, SNode* pTagCond) {
+static SColumnInfoData* getColInfoResult(void* metaHandle, int64_t suid, SArray* uidList, SNode* pTagCond) {
   int32_t      code = TSDB_CODE_SUCCESS;
   SArray*      pBlockList = NULL;
   SSDataBlock* pResBlock = NULL;
@@ -411,7 +412,7 @@ static SColumnInfoData* getColInfoResult(void* metaHandle, uint64_t suid, SArray
   //  int64_t stt = taosGetTimestampUs();
   tags = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
 
-  int32_t filter = optimizeTbnameInCond(metaHandle, suid, uidList, pTagCond);
+  int32_t filter = optimizeTbnameInCond(metaHandle, suid, uidList, pTagCond, tags);
   if (filter == -1) {
     code = metaGetTableTags(metaHandle, suid, uidList, tags);
     if (code != TSDB_CODE_SUCCESS) {
@@ -419,10 +420,17 @@ static SColumnInfoData* getColInfoResult(void* metaHandle, uint64_t suid, SArray
       terrno = code;
       goto end;
     }
+  }
+  /*else {
+    code = metaGetTableTagsByUids(metaHandle, suid, uidList, tags);
+    if (code != 0) {
+      terrno = code;
+      qError("failed to get table from meta idx, reason: %s, suid:%" PRId64, tstrerror(code), suid);
+      goto end;
     } else {
-    metaGetTableTagsByUids(metaHandle, suid, uidList, tags);
-    qInfo("succ to get table from meta idx, suid:%" PRIu64, suid);
+      qInfo("succ to get table from meta idx, suid:%" PRId64, suid);
     }
+  }*/
 
   int32_t rows = taosArrayGetSize(uidList);
   if (rows == 0) {
@@ -760,13 +768,18 @@ static int tableUidCompare(const void* a, const void* b) {
   }
   return u1 < u2 ? -1 : 1;
 }
-static int32_t optimizeTbnameInCond(void* metaHandle, int64_t suid, SArray* list, SNode* cond) {
+static int32_t optimizeTbnameInCond(void* metaHandle, int64_t suid, SArray* list, SNode* cond, SHashObj* tags) {
+  int32_t ret = -1;
   if (nodeType(cond) == QUERY_NODE_OPERATOR) {
-    return optimizeTbnameInCondImpl(metaHandle, suid, list, cond);
+    ret = optimizeTbnameInCondImpl(metaHandle, suid, list, cond);
+    if (ret != -1) {
+      metaGetTableTagsByUids(metaHandle, suid, list, tags);
+      removeInvalidTable(list, tags);
+    }
   }
 
   if (nodeType(cond) != QUERY_NODE_LOGIC_CONDITION || ((SLogicConditionNode*)cond)->condType != LOGIC_COND_TYPE_AND) {
-    return -1;
+    return ret;
   }
 
   bool                 hasTbnameCond = false;
@@ -774,20 +787,44 @@ static int32_t optimizeTbnameInCond(void* metaHandle, int64_t suid, SArray* list
   SNodeList*           pList = (SNodeList*)pNode->pParameterList;
 
   int32_t len = LIST_LENGTH(pList);
-  if (len <= 0) return -1;
+  if (len <= 0) return ret;
 
   SListCell* cell = pList->pHead;
   for (int i = 0; i < len; i++) {
     if (cell == NULL) break;
     if (optimizeTbnameInCondImpl(metaHandle, suid, list, cell->pNode) == 0) {
       hasTbnameCond = true;
+      break;
     }
     cell = cell->pNext;
   }
   taosArraySort(list, tableUidCompare);
   taosArrayRemoveDuplicate(list, tableUidCompare, NULL);
 
-  return hasTbnameCond == true ? 0 : -1;
+  if (hasTbnameCond) {
+    ret = metaGetTableTagsByUids(metaHandle, suid, list, tags);
+    removeInvalidTable(list, tags);
+  }
+  return ret;
+}
+
+/*
+ * handle invalid uid
+ */
+static int32_t removeInvalidTable(SArray* uids, SHashObj* tags) {
+  if (taosArrayGetSize(uids) <= 0) return 0;
+
+  SArray* validUid = taosArrayInit(taosArrayGetSize(uids), sizeof(int64_t));
+
+  for (int32_t i = 0; i < taosArrayGetSize(uids); i++) {
+    int64_t* uid = taosArrayGet(uids, i);
+    if (taosHashGet(tags, uid, sizeof(int64_t)) != NULL) {
+      taosArrayPush(validUid, uid);
+    }
+  }
+  taosArraySwap(uids, validUid);
+  taosArrayDestroy(validUid);
+  return 0;
 }
 static int32_t optimizeTbnameInCondImpl(void* metaHandle, int64_t suid, SArray* list, SNode* pTagCond) {
   if (nodeType(pTagCond) != QUERY_NODE_OPERATOR) {

source/util/src/tarray.c

@@ -468,12 +468,11 @@ static int32_t taosArrayPartition(SArray* pArray, int32_t i, int32_t j, __ext_co
   return i;
 }
 
-static void taosArrayQuicksortHelper(SArray* pArray, int32_t low, int32_t high, __ext_compar_fn_t fn,
-                                     const void* param) {
+static void taosArrayQuicksortImpl(SArray* pArray, int32_t low, int32_t high, __ext_compar_fn_t fn, const void* param) {
   if (low < high) {
     int32_t idx = taosArrayPartition(pArray, low, high, fn, param);
-    taosArrayQuicksortHelper(pArray, low, idx - 1, fn, param);
-    taosArrayQuicksortHelper(pArray, idx + 1, high, fn, param);
+    taosArrayQuicksortImpl(pArray, low, idx - 1, fn, param);
+    taosArrayQuicksortImpl(pArray, idx + 1, high, fn, param);
   }
 }
 
@@ -481,7 +480,7 @@ static void taosArrayQuickSort(SArray* pArray, __ext_compar_fn_t fn, const void*
   if (pArray->size <= 1) {
     return;
   }
-  taosArrayQuicksortHelper(pArray, 0, (int32_t)(taosArrayGetSize(pArray) - 1), fn, param);
+  taosArrayQuicksortImpl(pArray, 0, (int32_t)(taosArrayGetSize(pArray) - 1), fn, param);
 }
 
 static void taosArrayInsertSort(SArray* pArray, __ext_compar_fn_t fn, const void* param) {
@@ -564,3 +563,21 @@ char* taosShowStrArray(const SArray* pArray) {
   }
   return res;
 }
+void taosArraySwap(SArray* a, SArray* b) {
+  if (a == NULL || b == NULL) return;
+  size_t t = a->size;
+  a->size = b->size;
+  b->size = t;
+
+  uint32_t cap = a->capacity;
+  a->capacity = b->capacity;
+  b->capacity = cap;
+
+  uint32_t elem = a->elemSize;
+  a->elemSize = b->elemSize;
+  b->elemSize = elem;
+
+  void* data = a->pData;
+  a->pData = b->pData;
+  b->pData = data;
+}