#4983

Committed 13 Mar 2026 03:38AM UTC coverage: 68.653% (+0.07%) from 68.587%

Build # #4983

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

feat/6641435300-save-audit-in-self (#34738)

Coverage Stats

434 of 584 new or added lines in 10 files covered. (74.32%)

434 existing lines in 121 files now uncovered.

212745 of 309883 relevant lines covered (68.65%)

134272959.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.4

/source/libs/executor/src/cachescanoperator.c

/*
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
 *
 * This program is free software: you can use, redistribute, and/or modify
 * it under the terms of the GNU Affero General Public License, version 3
 * or later ("AGPL"), as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "function.h"
#include "os.h"
#include "tname.h"

#include "tdatablock.h"
#include "tmsg.h"

#include "executorInt.h"
#include "functionMgt.h"
#include "operator.h"
#include "querytask.h"
#include "tcompare.h"
#include "thash.h"
#include "ttypes.h"

#include "storageapi.h"

typedef struct SCacheRowsScanInfo {
  SSDataBlock*    pRes;
  SReadHandle     readHandle;
  void*           pLastrowReader;
  SColMatchInfo   matchInfo;
  int32_t*        pSlotIds;
  int32_t*        pDstSlotIds;
  SExprSupp       pseudoExprSup;
  int32_t         retrieveType;
  int32_t         currentGroupIndex;
  SSDataBlock*    pBufferedRes;
  SArray*         pUidList;
  SArray*         pCidList;
  STableListInfo* pTableList;
  SArray*         pFuncTypeList;
  int32_t         numOfPks;
  SColumnInfo     pkCol;
  bool            gotAll;
} SCacheRowsScanInfo;

static int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes);
static void    destroyCacheScanOperator(void* param);
static int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTaskInfo, int32_t** pSlotIds,
                                      int32_t** pDstSlotIds);

#define SCAN_ROW_TYPE(_t) ((_t) ? CACHESCAN_RETRIEVE_LAST : CACHESCAN_RETRIEVE_LAST_ROW)

static int32_t setColIdForCacheReadBlock(SSDataBlock* pBlock, SLastRowScanPhysiNode* pScan) {
  int32_t code = TSDB_CODE_SUCCESS;
  int32_t lino = 0;
  SNode*  pNode;
  int32_t idx = 0;
  FOREACH(pNode, pScan->pTargets) {
    if (nodeType(pNode) == QUERY_NODE_COLUMN) {
      SColumnNode*     pCol = (SColumnNode*)pNode;
      SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, idx);
      QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);
      pColInfo->info.colId = pCol->colId;
    }
    idx++;
  }

  for (; idx < pBlock->pDataBlock->size; ++idx) {
    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, idx);
    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);
    if (pScan->scan.pScanPseudoCols) {
      FOREACH(pNode, pScan->scan.pScanPseudoCols) {
        STargetNode* pTarget = (STargetNode*)pNode;
        if (pColInfo->info.slotId == pTarget->slotId) {
          pColInfo->info.colId = 0;
          break;
        }
      }
    }
  }

_end:
  if (code != TSDB_CODE_SUCCESS) {
    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
  }
  return code;
}

int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle,
                                    STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,
                                    SOperatorInfo** pOptrInfo) {
  QRY_PARAM_CHECK(pOptrInfo);

  int32_t             code = TSDB_CODE_SUCCESS;
  int32_t             lino = 0;
  int32_t             numOfCols = 0;
  SNodeList*          pScanCols = pScanNode->scan.pScanCols;
  SCacheRowsScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SCacheRowsScanInfo));
  SOperatorInfo*      pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));

  if (pInfo == NULL || pOperator == NULL) {
    code = terrno;
    goto _error;
  }

  pInfo->pTableList = pTableListInfo;
  pInfo->readHandle = *readHandle;

  SDataBlockDescNode* pDescNode = pScanNode->scan.node.pOutputDataBlockDesc;
  pInfo->pRes = createDataBlockFromDescNode(pDescNode);
  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);

  code = extractColMatchInfo(pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);
  QUERY_CHECK_CODE(code, lino, _error);

  // todo: the pk information should comes from the physical plan
  // pk info may not in pScanCols, so extract primary key from pInfo->matchInfo may failed
  SSchemaInfo* pSchemaInfo = taosArrayGet(pTaskInfo->schemaInfos, 0);
  if (pSchemaInfo != NULL) {
    if (pSchemaInfo->sw->pSchema[1].flags & COL_IS_KEY) {  // is primary key
      SSchema* pColSchema = &pSchemaInfo->sw->pSchema[1];
      pInfo->numOfPks = 1;
      pInfo->pkCol.type = pColSchema->type;
      pInfo->pkCol.bytes = pColSchema->bytes;
      pInfo->pkCol.pk = 1;
    }
  } else {
    for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) {
      SColMatchItem* pItem = taosArrayGet(pInfo->matchInfo.pList, i);
      QUERY_CHECK_NULL(pItem, code, lino, _error, terrno);
      if (pItem->isPk) {
        pInfo->numOfPks += 1;
        pInfo->pkCol.type = pItem->dataType.type;    // only record one primary key
        pInfo->pkCol.bytes = pItem->dataType.bytes;  // only record one primary key
        pInfo->pkCol.pk = 1;
      }
    }
  }

  SArray* pCidList = taosArrayInit(numOfCols, sizeof(int16_t));
  QUERY_CHECK_NULL(pCidList, code, lino, _error, terrno);

  pInfo->pFuncTypeList = taosArrayInit(taosArrayGetSize(pScanNode->pFuncTypes), sizeof(int32_t));
  QUERY_CHECK_NULL(pInfo->pFuncTypeList, code, lino, _error, terrno);

  void* tmp = taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes);
  if (!tmp && taosArrayGetSize(pScanNode->pFuncTypes) > 0) {
    QUERY_CHECK_NULL(tmp, code, lino, _error, terrno);
  }

  for (int i = 0; i < TARRAY_SIZE(pInfo->matchInfo.pList); ++i) {
    SColMatchItem* pColInfo = taosArrayGet(pInfo->matchInfo.pList, i);
    QUERY_CHECK_NULL(pColInfo, code, lino, _error, terrno);

    void*          tmp = taosArrayPush(pCidList, &pColInfo->colId);
    QUERY_CHECK_NULL(tmp, code, lino, _error, terrno);
    if (pInfo->pFuncTypeList != NULL && taosArrayGetSize(pInfo->pFuncTypeList) > i) {
      void* pFuncType = taosArrayGet(pInfo->pFuncTypeList, i);
      QUERY_CHECK_NULL(pFuncType, code, lino, _error, terrno);
      pColInfo->funcType = *(int32_t*)pFuncType;
    }
  }
  pInfo->pCidList = pCidList;

  code = extractCacheScanSlotId(pInfo->matchInfo.pList, pTaskInfo, &pInfo->pSlotIds, &pInfo->pDstSlotIds);
  QUERY_CHECK_CODE(code, lino, _error);

  int32_t totalTables = 0;
  code = tableListGetSize(pTableListInfo, &totalTables);
  QUERY_CHECK_CODE(code, lino, _error);

  int32_t capacity = 0;

  pInfo->pUidList = taosArrayInit(4, sizeof(int64_t));
  QUERY_CHECK_NULL(pInfo->pUidList, code, lino, _error, terrno);

  // partition by tbname
  if (oneTableForEachGroup(pTableListInfo) || (totalTables == 1)) {
    pInfo->retrieveType = CACHESCAN_RETRIEVE_TYPE_ALL | SCAN_ROW_TYPE(pScanNode->ignoreNull);

    STableKeyInfo* pList = tableListGetInfo(pTableListInfo, 0);
    if (totalTables) QUERY_CHECK_NULL(pList, code, lino, _error, terrno);

    uint64_t suid = tableListGetSuid(pTableListInfo);
    code = pInfo->readHandle.api.cacheFn.openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, totalTables,
                                                    taosArrayGetSize(pInfo->matchInfo.pList), pCidList, pInfo->pSlotIds,
                                                    suid, &pInfo->pLastrowReader, pTaskInfo->id.str,
                                                    pScanNode->pFuncTypes, &pInfo->pkCol, pInfo->numOfPks);
    QUERY_CHECK_CODE(code, lino, _error);

    capacity = TMIN(totalTables, 4096);

    pInfo->pBufferedRes = NULL;
    code = createOneDataBlock(pInfo->pRes, false, &pInfo->pBufferedRes);
    QUERY_CHECK_CODE(code, lino, _error);

    code = setColIdForCacheReadBlock(pInfo->pBufferedRes, pScanNode);
    QUERY_CHECK_CODE(code, lino, _error);

    code = blockDataEnsureCapacity(pInfo->pBufferedRes, capacity);
    QUERY_CHECK_CODE(code, lino, _error);
  } else {  // by tags
    pInfo->retrieveType = CACHESCAN_RETRIEVE_TYPE_SINGLE | SCAN_ROW_TYPE(pScanNode->ignoreNull);
    capacity = 1;  // only one row output
    code = setColIdForCacheReadBlock(pInfo->pRes, pScanNode);
    QUERY_CHECK_CODE(code, lino, _error);
  }

  initResultSizeInfo(&pOperator->resultInfo, capacity);
  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
  QUERY_CHECK_CODE(code, lino, _error);

  if (pScanNode->scan.pScanPseudoCols != NULL) {
    SExprSupp* p = &pInfo->pseudoExprSup;
    code = createExprInfo(pScanNode->scan.pScanPseudoCols, NULL, &p->pExprInfo, &p->numOfExprs);
    TSDB_CHECK_CODE(code, lino, _error);

    p->pCtx =
        createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore);
    QUERY_CHECK_NULL(p->pCtx, code, lino, _error, terrno);
  }

  setOperatorInfo(pOperator, "CachedRowScanOperator", QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN, false, OP_NOT_OPENED,
                  pInfo, pTaskInfo);
  pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);

  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doScanCacheNext, NULL, destroyCacheScanOperator, optrDefaultBufFn,
                                         NULL, optrDefaultGetNextExtFn, NULL);

  pOperator->cost.openCost = 0;

  *pOptrInfo = pOperator;
  return code;

_error:
  pTaskInfo->code = code;
  if (code != TSDB_CODE_SUCCESS) {
    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
  }
  if (pInfo != NULL) {
    pInfo->pTableList = NULL;
    destroyCacheScanOperator(pInfo);
  }
  if (pOperator != NULL) {
    pOperator->info = NULL;
    destroyOperator(pOperator);
  }
  return code;
}

static int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
  int32_t code = TSDB_CODE_SUCCESS;
  int32_t lino = 0;
  if (pOperator->status == OP_EXEC_DONE) {
    (*ppRes) = NULL;
    return code;
  }

  SCacheRowsScanInfo* pInfo = pOperator->info;
  SExecTaskInfo*      pTaskInfo = pOperator->pTaskInfo;
  STableListInfo*     pTableList = pInfo->pTableList;
  SStoreCacheReader*  pReaderFn = &pInfo->readHandle.api.cacheFn;
  SSDataBlock*        pBufRes = pInfo->pBufferedRes;

  uint64_t suid = tableListGetSuid(pTableList);
  int32_t  size = 0;
  code = tableListGetSize(pTableList, &size);
  QUERY_CHECK_CODE(code, lino, _end);

  if (size == 0) {
    setOperatorCompleted(pOperator);
    (*ppRes) = NULL;
    return code;
  }

  blockDataCleanup(pInfo->pRes);

  // check if it is a group by tbname
  if ((pInfo->retrieveType & CACHESCAN_RETRIEVE_TYPE_ALL) == CACHESCAN_RETRIEVE_TYPE_ALL) {
    if (isTaskKilled(pTaskInfo)) {
      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
    }

    if (!pInfo->gotAll) {
      blockDataCleanup(pBufRes);
      taosArrayClear(pInfo->pUidList);

      code = pReaderFn->retrieveRows(pInfo->pLastrowReader, pBufRes, pInfo->pSlotIds, pInfo->pDstSlotIds,
                                     pInfo->pUidList, &pInfo->gotAll);
      QUERY_CHECK_CODE(code, lino, _end);
    }

    SSDataBlock* pRes = pInfo->pRes;

    if (pBufRes->info.rows > 0) {
      code = copyDataBlock(pRes, pBufRes);
      QUERY_CHECK_CODE(code, lino, _end);

      void* pUid = taosArrayGet(pInfo->pUidList, 0);
      QUERY_CHECK_NULL(pUid, code, lino, _end, terrno);

      pRes->info.id.uid = *(tb_uid_t*)pUid;
      pRes->info.rows = pBufRes->info.rows;
      pRes->info.scanFlag = MAIN_SCAN;

      SExprSupp* pSup = &pInfo->pseudoExprSup;
      code = addTagPseudoColumnData(&pInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pRes, pRes->info.rows,
                                    pTaskInfo, NULL);
      QUERY_CHECK_CODE(code, lino, _end);

      pRes->info.id.groupId = tableListGetTableGroupId(pTableList, pRes->info.id.uid);
      (*ppRes) = pRes;
      return code;
    } else {
      setOperatorCompleted(pOperator);
      (*ppRes) = NULL;
      return code;
    }
  } else {
    size_t totalGroups = tableListGetOutputGroups(pTableList);

    while (pInfo->currentGroupIndex < totalGroups) {
      if (isTaskKilled(pTaskInfo)) {
        T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
      }

      STableKeyInfo* pList = NULL;
      int32_t        num = 0;

      code = tableListGetGroupList(pTableList, pInfo->currentGroupIndex, &pList, &num);
      QUERY_CHECK_CODE(code, lino, _end);

      if (NULL == pInfo->pLastrowReader) {
        int32_t tmpRes = pReaderFn->openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, num,
                                               taosArrayGetSize(pInfo->matchInfo.pList), pInfo->pCidList,
                                               pInfo->pSlotIds, suid, &pInfo->pLastrowReader, pTaskInfo->id.str,
                                               pInfo->pFuncTypeList, &pInfo->pkCol, pInfo->numOfPks);

        if (tmpRes != TSDB_CODE_SUCCESS) {
          pInfo->currentGroupIndex += 1;
          taosArrayClear(pInfo->pUidList);
          continue;
        }
      } else {
        code = pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num);
        QUERY_CHECK_CODE(code, lino, _end);
      }

      taosArrayClear(pInfo->pUidList);

      code = pReaderFn->retrieveRows(pInfo->pLastrowReader, pInfo->pRes, pInfo->pSlotIds, pInfo->pDstSlotIds,
                                     pInfo->pUidList, NULL);
      QUERY_CHECK_CODE(code, lino, _end);

      pInfo->currentGroupIndex += 1;

      // check for tag values
      if (pInfo->pRes->info.rows > 0) {
        SExprSupp* pSup = &pInfo->pseudoExprSup;

        STableKeyInfo* pKeyInfo = &((STableKeyInfo*)pList)[0];
        pInfo->pRes->info.id.groupId = pKeyInfo->groupId;

        if (taosArrayGetSize(pInfo->pUidList) > 0) {
          void* pUid = taosArrayGet(pInfo->pUidList, 0);
          QUERY_CHECK_NULL(pUid, code, lino, _end, terrno);
          pInfo->pRes->info.id.uid = *(tb_uid_t*)pUid;
          if (pInfo->pseudoExprSup.numOfExprs > 0) {
            code = addTagPseudoColumnData(&pInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pInfo->pRes,
                                          pInfo->pRes->info.rows, pTaskInfo, NULL);
            QUERY_CHECK_CODE(code, lino, _end);
          }
        }

        // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
        (*ppRes) = pInfo->pRes;
        return code;
      } else {
        // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
      }
    }

    pReaderFn->closeReader(pInfo->pLastrowReader);
    pInfo->pLastrowReader = NULL;
    setOperatorCompleted(pOperator);
    (*ppRes) = NULL;
    return code;
  }

_end:
  if (code != TSDB_CODE_SUCCESS) {
    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
    pTaskInfo->code = code;
    T_LONG_JMP(pTaskInfo->env, code);
  }
  return code;
}

void destroyCacheScanOperator(void* param) {
  SCacheRowsScanInfo* pInfo = (SCacheRowsScanInfo*)param;
  blockDataDestroy(pInfo->pRes);
  blockDataDestroy(pInfo->pBufferedRes);
  taosMemoryFreeClear(pInfo->pSlotIds);
  taosMemoryFreeClear(pInfo->pDstSlotIds);
  taosArrayDestroy(pInfo->pCidList);
  taosArrayDestroy(pInfo->pFuncTypeList);
  taosArrayDestroy(pInfo->pUidList);
  taosArrayDestroy(pInfo->matchInfo.pList);
  tableListDestroy(pInfo->pTableList);

  if (pInfo->pLastrowReader != NULL && pInfo->readHandle.api.cacheFn.closeReader != NULL) {
    pInfo->readHandle.api.cacheFn.closeReader(pInfo->pLastrowReader);
    pInfo->pLastrowReader = NULL;
  }

  cleanupExprSupp(&pInfo->pseudoExprSup);
  taosMemoryFreeClear(param);
}

int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTaskInfo, int32_t** pSlotIds,
                               int32_t** pDstSlotIds) {
  size_t numOfCols = taosArrayGetSize(pColMatchInfo);

  *pSlotIds = taosMemoryMalloc(numOfCols * sizeof(int32_t));
  if (*pSlotIds == NULL) {
    return terrno;
  }

  *pDstSlotIds = taosMemoryMalloc(numOfCols * sizeof(int32_t));
  if (*pDstSlotIds == NULL) {
    taosMemoryFreeClear(*pSlotIds);
    return terrno;
  }

  SSchemaInfo*    pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos);
  SSchemaWrapper* pWrapper = pSchemaInfo->sw;

  for (int32_t i = 0; i < numOfCols; ++i) {
    SColMatchItem* pColMatch = taosArrayGet(pColMatchInfo, i);
    if (!pColMatch) {
      return terrno;
    }
    bool           found = false;
    for (int32_t j = 0; j < pWrapper->nCols; ++j) {
      /*      if (pColMatch->colId == pWrapper->pSchema[j].colId && pColMatch->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
        (*pSlotIds)[pColMatch->dstSlotId] = -1;
        break;
        }*/

      if (pColMatch->colId == pWrapper->pSchema[j].colId) {
        (*pSlotIds)[i] = j;
        (*pDstSlotIds)[i] = pColMatch->dstSlotId;
        found = true;
        break;
      }
    }
    if (!found) {
      (*pSlotIds)[i] = -1;
      (*pDstSlotIds)[i] = pColMatch->dstSlotId;
    }
  }

  return TSDB_CODE_SUCCESS;
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	*/
15
16	#include "function.h"
17	#include "os.h"
18	#include "tname.h"
19
20	#include "tdatablock.h"
21	#include "tmsg.h"
22
23	#include "executorInt.h"
24	#include "functionMgt.h"
25	#include "operator.h"
26	#include "querytask.h"
27	#include "tcompare.h"
28	#include "thash.h"
29	#include "ttypes.h"
30
31	#include "storageapi.h"
32
33	typedef struct SCacheRowsScanInfo {
34	SSDataBlock* pRes;
35	SReadHandle readHandle;
36	void* pLastrowReader;
37	SColMatchInfo matchInfo;
38	int32_t* pSlotIds;
39	int32_t* pDstSlotIds;
40	SExprSupp pseudoExprSup;
41	int32_t retrieveType;
42	int32_t currentGroupIndex;
43	SSDataBlock* pBufferedRes;
44	SArray* pUidList;
45	SArray* pCidList;
46	STableListInfo* pTableList;
47	SArray* pFuncTypeList;
48	int32_t numOfPks;
49	SColumnInfo pkCol;
50	bool gotAll;
51	} SCacheRowsScanInfo;
52
53	static int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes);
54	static void destroyCacheScanOperator(void* param);
55	static int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTaskInfo, int32_t** pSlotIds,
56	int32_t** pDstSlotIds);
57
58	#define SCAN_ROW_TYPE(_t) ((_t) ? CACHESCAN_RETRIEVE_LAST : CACHESCAN_RETRIEVE_LAST_ROW)
59
60	static int32_t setColIdForCacheReadBlock(SSDataBlock* pBlock, SLastRowScanPhysiNode* pScan) {	638,755✔
61	int32_t code = TSDB_CODE_SUCCESS;	638,755✔
62	int32_t lino = 0;	638,755✔
63	SNode* pNode;
64	int32_t idx = 0;	638,755✔
65	FOREACH(pNode, pScan->pTargets) {	2,399,774✔
66	if (nodeType(pNode) == QUERY_NODE_COLUMN) {	1,761,292✔
67	SColumnNode* pCol = (SColumnNode*)pNode;	1,761,019✔
68	SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, idx);	1,761,019✔
69	QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);	1,761,019✔
70	pColInfo->info.colId = pCol->colId;	1,761,019✔
71	}
72	idx++;	1,761,019✔
73	}
74
75	for (; idx < pBlock->pDataBlock->size; ++idx) {	648,090✔
76	SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, idx);	9,108✔
77	QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);	9,108✔
78	if (pScan->scan.pScanPseudoCols) {	9,108✔
79	FOREACH(pNode, pScan->scan.pScanPseudoCols) {	5,796✔
80	STargetNode* pTarget = (STargetNode*)pNode;	3,312✔
81	if (pColInfo->info.slotId == pTarget->slotId) {	3,312✔
82	pColInfo->info.colId = 0;	×
83	break;	×
84	}
85	}
86	}
87	}
88
89	_end:	638,755✔
90	if (code != TSDB_CODE_SUCCESS) {	638,755✔
91	qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));	×
92	}
93	return code;	638,755✔
94	}
95
96	int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle,	638,498✔
97	STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,
98	SOperatorInfo** pOptrInfo) {
99	QRY_PARAM_CHECK(pOptrInfo);	638,498✔
100
101	int32_t code = TSDB_CODE_SUCCESS;	638,998✔
102	int32_t lino = 0;	638,998✔
103	int32_t numOfCols = 0;	638,998✔
104	SNodeList* pScanCols = pScanNode->scan.pScanCols;	638,584✔
105	SCacheRowsScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SCacheRowsScanInfo));	638,584✔
106	SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));	638,584✔
107
108	if (pInfo == NULL \|\| pOperator == NULL) {	638,584✔
UNCOV 109	code = terrno;	×
110	goto _error;	×
111	}
112
113	pInfo->pTableList = pTableListInfo;	638,584✔
114	pInfo->readHandle = *readHandle;	638,584✔
115
116	SDataBlockDescNode* pDescNode = pScanNode->scan.node.pOutputDataBlockDesc;	638,584✔
117	pInfo->pRes = createDataBlockFromDescNode(pDescNode);	639,412✔
118	QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);	638,755✔
119
120	code = extractColMatchInfo(pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);	638,755✔
121	QUERY_CHECK_CODE(code, lino, _error);	638,568✔
122
123	// todo: the pk information should comes from the physical plan
124	// pk info may not in pScanCols, so extract primary key from pInfo->matchInfo may failed
125	SSchemaInfo* pSchemaInfo = taosArrayGet(pTaskInfo->schemaInfos, 0);	638,568✔
126	if (pSchemaInfo != NULL) {	638,518✔
127	if (pSchemaInfo->sw->pSchema[1].flags & COL_IS_KEY) { // is primary key	638,518✔
128	SSchema* pColSchema = &pSchemaInfo->sw->pSchema[1];	174,216✔
129	pInfo->numOfPks = 1;	174,873✔
130	pInfo->pkCol.type = pColSchema->type;	174,873✔
131	pInfo->pkCol.bytes = pColSchema->bytes;	173,559✔
132	pInfo->pkCol.pk = 1;	174,216✔
133	}
134	} else {
135	for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) {	×
136	SColMatchItem* pItem = taosArrayGet(pInfo->matchInfo.pList, i);	×
137	QUERY_CHECK_NULL(pItem, code, lino, _error, terrno);	×
138	if (pItem->isPk) {	×
139	pInfo->numOfPks += 1;	×
140	pInfo->pkCol.type = pItem->dataType.type; // only record one primary key	×
141	pInfo->pkCol.bytes = pItem->dataType.bytes; // only record one primary key	×
142	pInfo->pkCol.pk = 1;	×
143	}
144	}
145	}
146
147	SArray* pCidList = taosArrayInit(numOfCols, sizeof(int16_t));	638,534✔
148	QUERY_CHECK_NULL(pCidList, code, lino, _error, terrno);	638,341✔
149
150	pInfo->pFuncTypeList = taosArrayInit(taosArrayGetSize(pScanNode->pFuncTypes), sizeof(int32_t));	638,341✔
151	QUERY_CHECK_NULL(pInfo->pFuncTypeList, code, lino, _error, terrno);	639,412✔
152
153	void* tmp = taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes);	638,341✔
154	if (!tmp && taosArrayGetSize(pScanNode->pFuncTypes) > 0) {	638,568✔
155	QUERY_CHECK_NULL(tmp, code, lino, _error, terrno);	×
156	}
157
158	for (int i = 0; i < TARRAY_SIZE(pInfo->matchInfo.pList); ++i) {	2,154,427✔
159	SColMatchItem* pColInfo = taosArrayGet(pInfo->matchInfo.pList, i);	1,515,379✔
160	QUERY_CHECK_NULL(pColInfo, code, lino, _error, terrno);	1,514,071✔
161
162	void* tmp = taosArrayPush(pCidList, &pColInfo->colId);	1,514,071✔
163	QUERY_CHECK_NULL(tmp, code, lino, _error, terrno);	1,517,814✔
164	if (pInfo->pFuncTypeList != NULL && taosArrayGetSize(pInfo->pFuncTypeList) > i) {	1,517,814✔
165	void* pFuncType = taosArrayGet(pInfo->pFuncTypeList, i);	×
166	QUERY_CHECK_NULL(pFuncType, code, lino, _error, terrno);	×
167	pColInfo->funcType = (int32_t)pFuncType;	×
168	}
169	}
170	pInfo->pCidList = pCidList;	639,412✔
171
172	code = extractCacheScanSlotId(pInfo->matchInfo.pList, pTaskInfo, &pInfo->pSlotIds, &pInfo->pDstSlotIds);	639,412✔
173	QUERY_CHECK_CODE(code, lino, _error);	638,112✔
174
175	int32_t totalTables = 0;	638,112✔
176	code = tableListGetSize(pTableListInfo, &totalTables);	638,112✔
177	QUERY_CHECK_CODE(code, lino, _error);	638,948✔
178
179	int32_t capacity = 0;	638,948✔
180
181	pInfo->pUidList = taosArrayInit(4, sizeof(int64_t));	638,948✔
182	QUERY_CHECK_NULL(pInfo->pUidList, code, lino, _error, terrno);	639,412✔
183
184	// partition by tbname
185	if (oneTableForEachGroup(pTableListInfo) \|\| (totalTables == 1)) {	992,554✔
186	pInfo->retrieveType = CACHESCAN_RETRIEVE_TYPE_ALL \| SCAN_ROW_TYPE(pScanNode->ignoreNull);	354,878✔
187
188	STableKeyInfo* pList = tableListGetInfo(pTableListInfo, 0);	355,292✔
189	if (totalTables) QUERY_CHECK_NULL(pList, code, lino, _error, terrno);	355,292✔
190
191	uint64_t suid = tableListGetSuid(pTableListInfo);	355,292✔
192	code = pInfo->readHandle.api.cacheFn.openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, totalTables,	1,065,876✔
193	taosArrayGetSize(pInfo->matchInfo.pList), pCidList, pInfo->pSlotIds,	355,292✔
194	suid, &pInfo->pLastrowReader, pTaskInfo->id.str,	355,292✔
195	pScanNode->pFuncTypes, &pInfo->pkCol, pInfo->numOfPks);
196	QUERY_CHECK_CODE(code, lino, _error);	355,292✔
197
198	capacity = TMIN(totalTables, 4096);	355,292✔
199
200	pInfo->pBufferedRes = NULL;	355,292✔
201	code = createOneDataBlock(pInfo->pRes, false, &pInfo->pBufferedRes);	355,292✔
202	QUERY_CHECK_CODE(code, lino, _error);	355,292✔
203
204	code = setColIdForCacheReadBlock(pInfo->pBufferedRes, pScanNode);	355,292✔
205	QUERY_CHECK_CODE(code, lino, _error);	355,292✔
206
207	code = blockDataEnsureCapacity(pInfo->pBufferedRes, capacity);	355,292✔
208	QUERY_CHECK_CODE(code, lino, _error);	355,292✔
209	} else { // by tags
210	pInfo->retrieveType = CACHESCAN_RETRIEVE_TYPE_SINGLE \| SCAN_ROW_TYPE(pScanNode->ignoreNull);	283,463✔
211	capacity = 1; // only one row output	283,463✔
212	code = setColIdForCacheReadBlock(pInfo->pRes, pScanNode);	283,463✔
213	QUERY_CHECK_CODE(code, lino, _error);	283,463✔
214	}
215
216	initResultSizeInfo(&pOperator->resultInfo, capacity);	638,755✔
217	code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);	638,255✔
218	QUERY_CHECK_CODE(code, lino, _error);	638,755✔
219
220	if (pScanNode->scan.pScanPseudoCols != NULL) {	638,755✔
221	SExprSupp* p = &pInfo->pseudoExprSup;	180,552✔
222	code = createExprInfo(pScanNode->scan.pScanPseudoCols, NULL, &p->pExprInfo, &p->numOfExprs);	180,138✔
223	TSDB_CHECK_CODE(code, lino, _error);	180,552✔
224
225	p->pCtx =	180,552✔
226	createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore);	180,552✔
227	QUERY_CHECK_NULL(p->pCtx, code, lino, _error, terrno);	180,552✔
228	}
229
230	setOperatorInfo(pOperator, "CachedRowScanOperator", QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN, false, OP_NOT_OPENED,	639,412✔
231	pInfo, pTaskInfo);
232	pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);	638,755✔
233
234	pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doScanCacheNext, NULL, destroyCacheScanOperator, optrDefaultBufFn,	638,755✔
235	NULL, optrDefaultGetNextExtFn, NULL);
236
237	pOperator->cost.openCost = 0;	638,755✔
238
239	*pOptrInfo = pOperator;	638,098✔
240	return code;	639,412✔
241
242	_error:	×
243	pTaskInfo->code = code;	×
244	if (code != TSDB_CODE_SUCCESS) {	×
245	qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));	×
246	}
247	if (pInfo != NULL) {	×
248	pInfo->pTableList = NULL;	×
249	destroyCacheScanOperator(pInfo);	×
250	}
251	if (pOperator != NULL) {	×
252	pOperator->info = NULL;	×
253	destroyOperator(pOperator);	×
254	}
255	return code;	×
256	}
257
258	static int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {	1,234,379✔
259	int32_t code = TSDB_CODE_SUCCESS;	1,234,379✔
260	int32_t lino = 0;	1,234,379✔
261	if (pOperator->status == OP_EXEC_DONE) {	1,234,379✔
262	(*ppRes) = NULL;	×
263	return code;	×
264	}
265
266	SCacheRowsScanInfo* pInfo = pOperator->info;	1,235,036✔
267	SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;	1,235,036✔
268	STableListInfo* pTableList = pInfo->pTableList;	1,235,036✔
269	SStoreCacheReader* pReaderFn = &pInfo->readHandle.api.cacheFn;	1,235,036✔
270	SSDataBlock* pBufRes = pInfo->pBufferedRes;	1,235,036✔
271
272	uint64_t suid = tableListGetSuid(pTableList);	1,235,036✔
273	int32_t size = 0;	1,234,379✔
274	code = tableListGetSize(pTableList, &size);	1,234,379✔
275	QUERY_CHECK_CODE(code, lino, _end);	1,235,036✔
276
277	if (size == 0) {	1,235,036✔
278	setOperatorCompleted(pOperator);	102,414✔
279	(*ppRes) = NULL;	102,414✔
280	return code;	102,414✔
281	}
282
283	blockDataCleanup(pInfo->pRes);	1,132,622✔
284
285	// check if it is a group by tbname
286	if ((pInfo->retrieveType & CACHESCAN_RETRIEVE_TYPE_ALL) == CACHESCAN_RETRIEVE_TYPE_ALL) {	1,132,622✔
287	if (isTaskKilled(pTaskInfo)) {	754,564✔
288	T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);	×
289	}
290
291	if (!pInfo->gotAll) {	754,564✔
292	blockDataCleanup(pBufRes);	754,564✔
293	taosArrayClear(pInfo->pUidList);	754,564✔
294
295	code = pReaderFn->retrieveRows(pInfo->pLastrowReader, pBufRes, pInfo->pSlotIds, pInfo->pDstSlotIds,	754,564✔
296	pInfo->pUidList, &pInfo->gotAll);
297	QUERY_CHECK_CODE(code, lino, _end);	754,564✔
298	}
299
300	SSDataBlock* pRes = pInfo->pRes;	754,564✔
301
302	if (pBufRes->info.rows > 0) {	754,564✔
303	code = copyDataBlock(pRes, pBufRes);	399,272✔
304	QUERY_CHECK_CODE(code, lino, _end);	398,858✔
305
306	void* pUid = taosArrayGet(pInfo->pUidList, 0);	398,858✔
307	QUERY_CHECK_NULL(pUid, code, lino, _end, terrno);	398,858✔
308
309	pRes->info.id.uid = (tb_uid_t)pUid;	398,858✔
310	pRes->info.rows = pBufRes->info.rows;	398,858✔
311	pRes->info.scanFlag = MAIN_SCAN;	399,272✔
312
313	SExprSupp* pSup = &pInfo->pseudoExprSup;	399,272✔
314	code = addTagPseudoColumnData(&pInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pRes, pRes->info.rows,	399,272✔
315	pTaskInfo, NULL);
316	QUERY_CHECK_CODE(code, lino, _end);	399,272✔
317
318	pRes->info.id.groupId = tableListGetTableGroupId(pTableList, pRes->info.id.uid);	399,272✔
319	(*ppRes) = pRes;	399,272✔
320	return code;	399,272✔
321	} else {
322	setOperatorCompleted(pOperator);	355,292✔
323	(*ppRes) = NULL;	355,292✔
324	return code;	355,292✔
325	}
326	} else {
327	size_t totalGroups = tableListGetOutputGroups(pTableList);	378,058✔
328
329	while (pInfo->currentGroupIndex < totalGroups) {	379,057✔
330	if (isTaskKilled(pTaskInfo)) {	198,008✔
331	T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);	×
332	}
333
334	STableKeyInfo* pList = NULL;	198,008✔
335	int32_t num = 0;	198,008✔
336
337	code = tableListGetGroupList(pTableList, pInfo->currentGroupIndex, &pList, &num);	198,008✔
338	QUERY_CHECK_CODE(code, lino, _end);	198,008✔
339
340	if (NULL == pInfo->pLastrowReader) {	198,008✔
341	int32_t tmpRes = pReaderFn->openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, num,	545,118✔
342	taosArrayGetSize(pInfo->matchInfo.pList), pInfo->pCidList,	181,706✔
343	pInfo->pSlotIds, suid, &pInfo->pLastrowReader, pTaskInfo->id.str,	181,706✔
344	pInfo->pFuncTypeList, &pInfo->pkCol, pInfo->numOfPks);
345
346	if (tmpRes != TSDB_CODE_SUCCESS) {	181,049✔
347	pInfo->currentGroupIndex += 1;	×
348	taosArrayClear(pInfo->pUidList);	×
349	continue;	×
350	}
351	} else {
352	code = pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num);	16,302✔
353	QUERY_CHECK_CODE(code, lino, _end);	16,302✔
354	}
355
356	taosArrayClear(pInfo->pUidList);	197,351✔
357
358	code = pReaderFn->retrieveRows(pInfo->pLastrowReader, pInfo->pRes, pInfo->pSlotIds, pInfo->pDstSlotIds,	198,008✔
359	pInfo->pUidList, NULL);
360	QUERY_CHECK_CODE(code, lino, _end);	198,008✔
361
362	pInfo->currentGroupIndex += 1;	198,008✔
363
364	// check for tag values
365	if (pInfo->pRes->info.rows > 0) {	198,008✔
366	SExprSupp* pSup = &pInfo->pseudoExprSup;	195,695✔
367
368	STableKeyInfo* pKeyInfo = &((STableKeyInfo*)pList)[0];	195,695✔
369	pInfo->pRes->info.id.groupId = pKeyInfo->groupId;	195,695✔
370
371	if (taosArrayGetSize(pInfo->pUidList) > 0) {	195,695✔
372	void* pUid = taosArrayGet(pInfo->pUidList, 0);	195,695✔
373	QUERY_CHECK_NULL(pUid, code, lino, _end, terrno);	196,352✔
374	pInfo->pRes->info.id.uid = (tb_uid_t)pUid;	196,352✔
375	if (pInfo->pseudoExprSup.numOfExprs > 0) {	196,352✔
376	code = addTagPseudoColumnData(&pInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pInfo->pRes,	37,803✔
377	pInfo->pRes->info.rows, pTaskInfo, NULL);	37,803✔
378	QUERY_CHECK_CODE(code, lino, _end);	37,803✔
379	}
380	}
381
382	// pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
383	(*ppRes) = pInfo->pRes;	195,695✔
384	return code;	195,695✔
385	} else {
386	// pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
387	}
388	}
389
390	pReaderFn->closeReader(pInfo->pLastrowReader);	181,706✔
391	pInfo->pLastrowReader = NULL;	181,706✔
392	setOperatorCompleted(pOperator);	181,706✔
393	(*ppRes) = NULL;	181,049✔
394	return code;	181,049✔
395	}
396
397	_end:	×
398	if (code != TSDB_CODE_SUCCESS) {	×
399	qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));	×
400	pTaskInfo->code = code;	×
401	T_LONG_JMP(pTaskInfo->env, code);	×
402	}
403	return code;	×
404	}
405
406	void destroyCacheScanOperator(void* param) {	639,412✔
407	SCacheRowsScanInfo* pInfo = (SCacheRowsScanInfo*)param;	639,412✔
408	blockDataDestroy(pInfo->pRes);	639,412✔
409	blockDataDestroy(pInfo->pBufferedRes);	639,412✔
410	taosMemoryFreeClear(pInfo->pSlotIds);	639,412✔
411	taosMemoryFreeClear(pInfo->pDstSlotIds);	638,755✔
412	taosArrayDestroy(pInfo->pCidList);	637,441✔
413	taosArrayDestroy(pInfo->pFuncTypeList);	638,098✔
414	taosArrayDestroy(pInfo->pUidList);	638,098✔
415	taosArrayDestroy(pInfo->matchInfo.pList);	639,412✔
416	tableListDestroy(pInfo->pTableList);	639,412✔
417
418	if (pInfo->pLastrowReader != NULL && pInfo->readHandle.api.cacheFn.closeReader != NULL) {	638,755✔
419	pInfo->readHandle.api.cacheFn.closeReader(pInfo->pLastrowReader);	355,292✔
420	pInfo->pLastrowReader = NULL;	355,292✔
421	}
422
423	cleanupExprSupp(&pInfo->pseudoExprSup);	638,755✔
424	taosMemoryFreeClear(param);	639,412✔
425	}	639,412✔
426
427	int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTaskInfo, int32_t** pSlotIds,	637,841✔
428	int32_t** pDstSlotIds) {
429	size_t numOfCols = taosArrayGetSize(pColMatchInfo);	637,841✔
430
431	pSlotIds = taosMemoryMalloc(numOfCols sizeof(int32_t));	638,755✔
432	if (*pSlotIds == NULL) {	638,998✔
433	return terrno;	×
434	}
435
436	pDstSlotIds = taosMemoryMalloc(numOfCols sizeof(int32_t));	637,927✔
437	if (*pDstSlotIds == NULL) {	638,120✔
438	taosMemoryFreeClear(*pSlotIds);	×
439	return terrno;	×
440	}
441
442	SSchemaInfo* pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos);	637,220✔
443	SSchemaWrapper* pWrapper = pSchemaInfo->sw;	638,291✔
444
445	for (int32_t i = 0; i < numOfCols; ++i) {	2,153,077✔
446	SColMatchItem* pColMatch = taosArrayGet(pColMatchInfo, i);	1,514,965✔
447	if (!pColMatch) {	1,514,622✔
448	return terrno;	×
449	}
450	bool found = false;	1,515,693✔
451	for (int32_t j = 0; j < pWrapper->nCols; ++j) {	8,218,797✔
452	/* if (pColMatch->colId == pWrapper->pSchema[j].colId && pColMatch->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
453	(*pSlotIds)[pColMatch->dstSlotId] = -1;
454	break;
455	}*/
456
457	if (pColMatch->colId == pWrapper->pSchema[j].colId) {	8,214,175✔
458	(*pSlotIds)[i] = j;	1,514,286✔
459	(*pDstSlotIds)[i] = pColMatch->dstSlotId;	1,513,430✔
460	found = true;	1,515,622✔
461	break;	1,515,622✔
462	}
463	}
464	if (!found) {	1,516,688✔
465	(*pSlotIds)[i] = -1;	×
466	(*pDstSlotIds)[i] = pColMatch->dstSlotId;	×
467	}
468	}
469
470	return TSDB_CODE_SUCCESS;	638,112✔
471	}

taosdata / TDengine / #4983

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous