From e2f1102622a34be4ff8813338a013a1e893fbcc4 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Wed, 19 May 2021 15:27:16 +0800
Subject: [PATCH 01/12] init

---
 src/query/src/qExecutor.c |  33 +++++++
 src/tsdb/src/tsdbRead.c   | 194 ++++++++++++++++++++++++++++++++++++--
 2 files changed, 217 insertions(+), 10 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 40759c93c4..b48436a617 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1979,6 +1979,37 @@ static bool isFirstLastRowQuery(SQueryAttr *pQueryAttr) {
   return false;
 }
 
+static bool isCachedLastQuery(SQueryAttr *pQueryAttr) {
+  for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) {
+    int32_t functionID = pQueryAttr->pExpr1[i].base.functionId;
+    if (functionID == TSDB_FUNC_LAST || functionID == TSDB_FUNC_LAST_DST) {
+      continue;
+    }
+
+    return false;
+  }
+
+  if (!TSWINDOW_IS_EQUAL(pQueryAttr->window, TSWINDOW_INITIALIZER)) {
+    return false;
+  }
+
+  if (pQueryAttr->groupbyColumn) {
+    return false;
+  }
+
+  if (pQueryAttr->interval.interval > 0) {
+    return false;
+  }
+
+  if (pQueryAttr->numOfFilterCols > 0 || pQueryAttr->havingNum > 0) {
+    return false;
+  }
+
+  return true;
+}
+
+
+
 /**
  * The following 4 kinds of query are treated as the tags query
  * tagprj, tid_tag query, count(tbname), 'abc' (user defined constant value column) query
@@ -3963,6 +3994,8 @@ static int32_t setupQueryHandle(void* tsdb, SQueryRuntimeEnv* pRuntimeEnv, int64
         }
       }
     }
+  } else if (isCachedLastQuery(pQueryAttr)) {
+    pRuntimeEnv->pQueryHandle = tsdbQueryCacheLast(tsdb, &cond, &pQueryAttr->tableGroupInfo, qId, &pQueryAttr->memRef);
   } else if (pQueryAttr->pointInterpQuery) {
     pRuntimeEnv->pQueryHandle = tsdbQueryRowsInExternalWindow(tsdb, &cond, &pQueryAttr->tableGroupInfo, qId, &pQueryAttr->memRef);
   } else {
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 9df25409de..b3460ac3b2 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -62,12 +62,20 @@ typedef struct SLoadCompBlockInfo {
   int32_t fileId;
 } SLoadCompBlockInfo;
 
+typedef struct SCacheLastColInfo {
+  int16_t  size;
+  int16_t  num;
+  int16_t  fetchIdx;
+  int16_t *idx;
+} SCacheLastColInfo;
+
 typedef struct STableCheckInfo {
   STableId      tableId;
   TSKEY         lastKey;
   STable*       pTableObj;
   SBlockInfo*   pCompInfo;
   int32_t       compSize;
+  SCacheLastColInfo cacheLast;  // cache last column chosen
   int32_t       numOfBlocks:29; // number of qualified data blocks not the original blocks
   int8_t        chosen:2;       // indicate which iterator should move forward
   bool          initBuf;        // whether to initialize the in-memory skip list iterator or not
@@ -107,7 +115,7 @@ typedef struct STsdbQueryHandle {
   SArray*        pTableCheckInfo;  // SArray<STableCheckInfo>
   int32_t        activeIndex;
   bool           checkFiles;       // check file stage
-  bool           cachelastrow;     // check if last row cached
+  int8_t         cachelastrow;     // check if last row cached
   bool           loadExternalRow;  // load time window external data rows
   bool           currentLoadExternalRows; // current load external rows
   int32_t        loadType;         // block load type
@@ -512,6 +520,8 @@ void tsdbResetQueryHandleForNewTable(TsdbQueryHandleT queryHandle, STsdbQueryCon
   pQueryHandle->next = doFreeColumnInfoData(pQueryHandle->next);
 }
 
+
+
 TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
   pCond->twindow = updateLastrowForEachGroup(groupList);
 
@@ -528,10 +538,111 @@ TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
   }
 
   assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
-  pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  if (pQueryHandle->cachelastrow) {
+    pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  }
+  
   return pQueryHandle;
 }
 
+
+
+STimeWindow updateCacheLastForEachGroup(STableGroupInfo *groupList) {
+  STimeWindow window = {INT64_MAX, INT64_MIN};
+
+  int32_t totalNumOfTable = 0;
+
+  // NOTE: starts from the buffer in case of descending timestamp order check data blocks
+  size_t numOfGroups = taosArrayGetSize(groupList->pGroupList);
+  for(int32_t j = 0; j < numOfGroups; ++j) {
+    SArray* pGroup = taosArrayGetP(groupList->pGroupList, j);
+    TSKEY   key = TSKEY_INITIAL_VAL;
+
+    STableKeyInfo keyInfo = {0};
+
+    size_t numOfTables = taosArrayGetSize(pGroup);
+    for(int32_t i = 0; i < numOfTables; ++i) {
+      STableKeyInfo* pInfo = (STableKeyInfo*) taosArrayGet(pGroup, i);
+
+      // if the lastKey equals to INT64_MIN, there is no data in this table
+      TSKEY lastKey = ((STable*)(pInfo->pTable))->lastKey;
+      if (key < lastKey) {
+        key = lastKey;
+
+        keyInfo.pTable  = pInfo->pTable;
+        keyInfo.lastKey = key;
+        pInfo->lastKey  = key;
+
+        if (key < window.skey) {
+          window.skey = key;
+        }
+
+        if (key > window.ekey) {
+          window.ekey = key;
+        }
+      }
+    }
+
+    // clear current group, unref unused table
+    for (int32_t i = 0; i < numOfTables; ++i) {
+      STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(pGroup, i);
+
+      // keyInfo.pTable may be NULL here.
+      if (pInfo->pTable != keyInfo.pTable) {
+        tsdbUnRefTable(pInfo->pTable);
+      }
+    }
+
+    taosArrayClear(pGroup);
+
+    // more than one table in each group, only one table left for each group
+    if (keyInfo.pTable != NULL) {
+      totalNumOfTable++;
+      taosArrayPush(pGroup, &keyInfo);
+    } else {
+      taosArrayDestroy(pGroup);
+
+      taosArrayRemove(groupList->pGroupList, j);
+      numOfGroups -= 1;
+      j -= 1;
+    }
+  }
+
+  // window does not being updated, so set the original
+  if (window.skey == INT64_MAX && window.ekey == INT64_MIN) {
+    window = TSWINDOW_INITIALIZER;
+    assert(totalNumOfTable == 0 && taosArrayGetSize(groupList->pGroupList) == 0);
+  }
+
+  groupList->numOfTables = totalNumOfTable;
+  return window;
+}
+
+
+TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
+  pCond->twindow = updateCacheLastForEachGroup(groupList);
+
+  // no qualified table
+  if (groupList->numOfTables == 0) {
+    return NULL;
+  }
+
+  STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, groupList, qId, pMemRef);
+  int32_t code = checkForCachedLastRow(pQueryHandle, groupList);
+  if (code != TSDB_CODE_SUCCESS) { // set the numOfTables to be 0
+    terrno = code;
+    return NULL;
+  }
+
+  assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
+  if (pQueryHandle->cachelastrow == 2) {
+    pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  }
+  
+  return pQueryHandle;
+}
+
+
 SArray* tsdbGetQueriedTableList(TsdbQueryHandleT *pHandle) {
   assert(pHandle != NULL);
 
@@ -2460,6 +2571,58 @@ static bool loadCachedLastRow(STsdbQueryHandle* pQueryHandle) {
   return false;
 }
 
+
+static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
+  // the last row is cached in buffer, return it directly.
+  // here note that the pQueryHandle->window must be the TS_INITIALIZER
+  int32_t numOfCols  = (int32_t)(QH_GET_NUM_OF_COLS(pQueryHandle));
+  size_t  numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
+  assert(numOfTables > 0 && numOfCols > 0);
+
+  SQueryFilePos* cur = &pQueryHandle->cur;
+
+  SDataRow pRow = NULL;
+  TSKEY    key  = TSKEY_INITIAL_VAL;
+  int32_t  step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1:-1;
+
+  if (pQueryHandle->activeIndex < 0) {
+    updateCacheLastForEachGroup(pQueryHandle);
+  }
+
+  if (pQueryHandle->activeIndex < numOfTables) {
+    STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
+    
+    if (pQueryHandle->cachelastrow == 1) {
+      int32_t ret = tsdbGetCachedLastRow(pCheckInfo->pTableObj, &pRow, &key);
+      if (ret != TSDB_CODE_SUCCESS) {
+        return false;
+      }
+
+      copyOneRowFromMem(pQueryHandle, pQueryHandle->outputCapacity, 0, pRow, numOfCols, pCheckInfo->pTableObj, NULL);
+      tfree(pRow);
+
+      // update the last key value
+      pCheckInfo->lastKey = key + step;
+
+      cur->rows     = 1;  // only one row
+      cur->lastKey  = key + step;
+      cur->mixBlock = true;
+      cur->win.skey = key;
+      cur->win.ekey = key;
+    } else if (pQueryHandle->cachelastrow == 2) {
+
+    } else {
+      tsdbError("invalid cachelastrow:%d", pQueryHandle->cachelastrow);
+      return false;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+
 static bool loadDataBlockFromTableSeq(STsdbQueryHandle* pQueryHandle) {
   size_t numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
   assert(numOfTables > 0);
@@ -2496,8 +2659,12 @@ bool tsdbNextDataBlock(TsdbQueryHandleT pHandle) {
   int64_t stime = taosGetTimestampUs();
   int64_t elapsedTime = stime;
 
-  if (pQueryHandle->type == TSDB_QUERY_TYPE_LAST && pQueryHandle->cachelastrow) {
-    return loadCachedLastRow(pQueryHandle);
+  if (pQueryHandle->type == TSDB_QUERY_TYPE_LAST) {
+    if (pQueryHandle->cachelastrow == 1) {
+      return loadCachedLastRow(pQueryHandle);
+    } if (pQueryHandle->cachelastrow == 2) else {
+      return loadCachedLast(pQueryHandle);
+    }
   }
 
   if (pQueryHandle->loadType == BLOCK_LOAD_TABLE_SEQ_ORDER) {
@@ -2683,7 +2850,7 @@ int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey) {
   TSDB_RLOCK_TABLE(pTable);
   *lastKey = pTable->lastKey;
 
-  if ((*lastKey) != TSKEY_INITIAL_VAL && pTable->lastRow) {
+  if ((*lastKey) != TSKEY_INITIAL_VAL && pTable->lastRow == 1) {
     *pRes = tdDataRowDup(pTable->lastRow);
     if (*pRes == NULL) {
       TSDB_RUNLOCK_TABLE(pTable);
@@ -2706,12 +2873,19 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
 
   STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(group, 0);
 
-  int32_t code = tsdbGetCachedLastRow(pInfo->pTable, &pRow, &key);
-  if (code != TSDB_CODE_SUCCESS) {
-    pQueryHandle->cachelastrow = false;
-  } else {
-    pQueryHandle->cachelastrow = (pRow != NULL);
+  int32_t code = 0;
+  
+  if (((STable*)pInfo->pTable)->lastRow == 1) {
+    code = tsdbGetCachedLastRow(pInfo->pTable, &pRow, &key);
+    if (code != TSDB_CODE_SUCCESS) {
+      pQueryHandle->cachelastrow = 0;
+    } else {
+      pQueryHandle->cachelastrow = ((STable*)pInfo->pTable)->lastRow;
+    }
+  } else if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0 && ((STable*)pInfo->pTable)->lastRow == 2){
+    pQueryHandle->cachelastrow = ((STable*)pInfo->pTable)->lastRow;
   }
+  
 
   // update the tsdb query time range
   if (pQueryHandle->cachelastrow) {

From cc50dcec6407e798270a7f12cbcd016ac8a24cf2 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 20 May 2021 10:36:59 +0800
Subject: [PATCH 02/12] update

---
 src/tsdb/src/tsdbRead.c | 281 ++++++++++++++++++++++------------------
 1 file changed, 154 insertions(+), 127 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index b3460ac3b2..a326bd07fc 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -62,12 +62,6 @@ typedef struct SLoadCompBlockInfo {
   int32_t fileId;
 } SLoadCompBlockInfo;
 
-typedef struct SCacheLastColInfo {
-  int16_t  size;
-  int16_t  num;
-  int16_t  fetchIdx;
-  int16_t *idx;
-} SCacheLastColInfo;
 
 typedef struct STableCheckInfo {
   STableId      tableId;
@@ -75,7 +69,6 @@ typedef struct STableCheckInfo {
   STable*       pTableObj;
   SBlockInfo*   pCompInfo;
   int32_t       compSize;
-  SCacheLastColInfo cacheLast;  // cache last column chosen
   int32_t       numOfBlocks:29; // number of qualified data blocks not the original blocks
   int8_t        chosen:2;       // indicate which iterator should move forward
   bool          initBuf;        // whether to initialize the in-memory skip list iterator or not
@@ -101,6 +94,12 @@ typedef struct SIOCostSummary {
   int64_t checkForNextTime;
 } SIOCostSummary;
 
+
+typedef struct SCacheLastColInfo {
+  int16_t  i;
+  int16_t  j;
+} SCacheLastColInfo;
+
 typedef struct STsdbQueryHandle {
   STsdbRepo*     pTsdb;
   SQueryFilePos  cur;              // current position
@@ -126,6 +125,7 @@ typedef struct STsdbQueryHandle {
   SReadH         rhelper;
   STableBlockInfo* pDataBlockInfo;
 
+  SCacheLastColInfo lastCols;
   SDataCols     *pDataCols;        // in order to hold current file data block
   int32_t        allocSize;        // allocated data block size
   SMemRef       *pMemRef;
@@ -546,98 +546,16 @@ TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
 }
 
 
-
-STimeWindow updateCacheLastForEachGroup(STableGroupInfo *groupList) {
-  STimeWindow window = {INT64_MAX, INT64_MIN};
-
-  int32_t totalNumOfTable = 0;
-
-  // NOTE: starts from the buffer in case of descending timestamp order check data blocks
-  size_t numOfGroups = taosArrayGetSize(groupList->pGroupList);
-  for(int32_t j = 0; j < numOfGroups; ++j) {
-    SArray* pGroup = taosArrayGetP(groupList->pGroupList, j);
-    TSKEY   key = TSKEY_INITIAL_VAL;
-
-    STableKeyInfo keyInfo = {0};
-
-    size_t numOfTables = taosArrayGetSize(pGroup);
-    for(int32_t i = 0; i < numOfTables; ++i) {
-      STableKeyInfo* pInfo = (STableKeyInfo*) taosArrayGet(pGroup, i);
-
-      // if the lastKey equals to INT64_MIN, there is no data in this table
-      TSKEY lastKey = ((STable*)(pInfo->pTable))->lastKey;
-      if (key < lastKey) {
-        key = lastKey;
-
-        keyInfo.pTable  = pInfo->pTable;
-        keyInfo.lastKey = key;
-        pInfo->lastKey  = key;
-
-        if (key < window.skey) {
-          window.skey = key;
-        }
-
-        if (key > window.ekey) {
-          window.ekey = key;
-        }
-      }
-    }
-
-    // clear current group, unref unused table
-    for (int32_t i = 0; i < numOfTables; ++i) {
-      STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(pGroup, i);
-
-      // keyInfo.pTable may be NULL here.
-      if (pInfo->pTable != keyInfo.pTable) {
-        tsdbUnRefTable(pInfo->pTable);
-      }
-    }
-
-    taosArrayClear(pGroup);
-
-    // more than one table in each group, only one table left for each group
-    if (keyInfo.pTable != NULL) {
-      totalNumOfTable++;
-      taosArrayPush(pGroup, &keyInfo);
-    } else {
-      taosArrayDestroy(pGroup);
-
-      taosArrayRemove(groupList->pGroupList, j);
-      numOfGroups -= 1;
-      j -= 1;
-    }
-  }
-
-  // window does not being updated, so set the original
-  if (window.skey == INT64_MAX && window.ekey == INT64_MIN) {
-    window = TSWINDOW_INITIALIZER;
-    assert(totalNumOfTable == 0 && taosArrayGetSize(groupList->pGroupList) == 0);
-  }
-
-  groupList->numOfTables = totalNumOfTable;
-  return window;
-}
-
-
 TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
-  pCond->twindow = updateCacheLastForEachGroup(groupList);
-
-  // no qualified table
-  if (groupList->numOfTables == 0) {
-    return NULL;
-  }
-
   STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, groupList, qId, pMemRef);
-  int32_t code = checkForCachedLastRow(pQueryHandle, groupList);
+  int32_t code = checkForCachedLast(pQueryHandle, groupList);
   if (code != TSDB_CODE_SUCCESS) { // set the numOfTables to be 0
     terrno = code;
     return NULL;
   }
 
   assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
-  if (pQueryHandle->cachelastrow == 2) {
-    pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
-  }
+  pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
   
   return pQueryHandle;
 }
@@ -2572,6 +2490,115 @@ static bool loadCachedLastRow(STsdbQueryHandle* pQueryHandle) {
 }
 
 
+static int32_t copyColsFromCacheMem(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, STable* pTable) {
+  char* pData = NULL;
+
+  STSchema* pSchema = tsdbGetTableSchema(pTable);
+  int32_t numOfCols = schemaNCols(pSchema);
+  int32_t tgNumOfCols = QH_GET_NUM_OF_COLS(pQueryHandle);
+
+  assert(numOfCols == pTable->restoreColumnNum);
+  assert(pTable->lastCols != NULL);
+  
+  int32_t i = pQueryHandle->lastCols.i, j = pQueryHandle->lastCols.j;
+  while(i < tgNumOfCols && j < numOfCols) {
+    SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+    if (pTable->lastCols[j].colId < pColInfo->info.colId) {
+      j++;
+      continue;
+    } else if (pTable->lastCols[j].colId > pColInfo->info.colId) {
+      i++;
+      continue;
+    }
+
+    if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
+      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
+    } else {
+      pData = (char*)pColInfo->pData + (capacity - numOfRows - 1) * pColInfo->info.bytes;
+    }
+
+    if (pTable->lastCols[j].bytes > 0) {
+      void* value = pTable->lastCols[j].pData;
+      switch (pColInfo->info.type) {
+        case TSDB_DATA_TYPE_BINARY:
+        case TSDB_DATA_TYPE_NCHAR:
+          memcpy(pData, value, varDataTLen(value));
+          break;
+        case TSDB_DATA_TYPE_NULL:
+        case TSDB_DATA_TYPE_BOOL:
+        case TSDB_DATA_TYPE_TINYINT:
+        case TSDB_DATA_TYPE_UTINYINT:  
+          *(uint8_t *)pData = *(uint8_t *)value;
+          break;
+        case TSDB_DATA_TYPE_SMALLINT:
+        case TSDB_DATA_TYPE_USMALLINT:
+          *(uint16_t *)pData = *(uint16_t *)value;
+          break;
+        case TSDB_DATA_TYPE_INT:
+        case TSDB_DATA_TYPE_UINT:
+          *(uint32_t *)pData = *(uint32_t *)value;
+          break;
+        case TSDB_DATA_TYPE_BIGINT:
+        case TSDB_DATA_TYPE_UBIGINT:
+          *(uint64_t *)pData = *(uint64_t *)value;
+          break;
+        case TSDB_DATA_TYPE_FLOAT:
+          SET_FLOAT_PTR(pData, value);
+          break;
+        case TSDB_DATA_TYPE_DOUBLE:
+          SET_DOUBLE_PTR(pData, value);
+          break;
+        case TSDB_DATA_TYPE_TIMESTAMP:
+          if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+            *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
+          } else {
+            *(TSKEY *)pData = *(TSKEY *)value;
+          }
+          break;
+        default:
+          memcpy(pData, value, pColInfo->info.bytes);
+      }
+
+      for (int32_t n = 0; n < tgNumOfCols; ++n) {
+        if (n == i) {
+          continue;
+        }
+        
+        SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(pData, pColInfo->info.type);
+        } else {
+          setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
+        }
+      }
+
+      ++i;
+      ++j;
+
+      if (i >= tgNumOfCols || j >= numOfCols) {
+        pQueryHandle->lastCols.i = 0;
+        pQueryHandle->lastCols.j = 0;
+        pQueryHandle->activeIndex++;
+      } else {
+        pQueryHandle->lastCols.i = i;
+        pQueryHandle->lastCols.j = j;
+      }
+
+      return 1;
+    } 
+
+    i++;
+    j++;
+  }
+
+  pQueryHandle->lastCols.i = 0;
+  pQueryHandle->lastCols.j = 0;
+  pQueryHandle->activeIndex++;
+
+  return 0;
+}
+
+
 static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   // the last row is cached in buffer, return it directly.
   // here note that the pQueryHandle->window must be the TS_INITIALIZER
@@ -2581,42 +2608,15 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
 
   SQueryFilePos* cur = &pQueryHandle->cur;
 
-  SDataRow pRow = NULL;
   TSKEY    key  = TSKEY_INITIAL_VAL;
   int32_t  step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1:-1;
 
-  if (pQueryHandle->activeIndex < 0) {
-    updateCacheLastForEachGroup(pQueryHandle);
-  }
-
-  if (pQueryHandle->activeIndex < numOfTables) {
+  while (pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
     
-    if (pQueryHandle->cachelastrow == 1) {
-      int32_t ret = tsdbGetCachedLastRow(pCheckInfo->pTableObj, &pRow, &key);
-      if (ret != TSDB_CODE_SUCCESS) {
-        return false;
-      }
-
-      copyOneRowFromMem(pQueryHandle, pQueryHandle->outputCapacity, 0, pRow, numOfCols, pCheckInfo->pTableObj, NULL);
-      tfree(pRow);
-
-      // update the last key value
-      pCheckInfo->lastKey = key + step;
-
-      cur->rows     = 1;  // only one row
-      cur->lastKey  = key + step;
-      cur->mixBlock = true;
-      cur->win.skey = key;
-      cur->win.ekey = key;
-    } else if (pQueryHandle->cachelastrow == 2) {
-
-    } else {
-      tsdbError("invalid cachelastrow:%d", pQueryHandle->cachelastrow);
-      return false;
+    if (copyColsFromCacheMem(pQueryHandle, pQueryHandle->outputCapacity, 0, numOfCols, pCheckInfo->pTableObj, NULL)) {
+      return true;
     }
-
-    return true;
   }
 
   return false;
@@ -2662,7 +2662,7 @@ bool tsdbNextDataBlock(TsdbQueryHandleT pHandle) {
   if (pQueryHandle->type == TSDB_QUERY_TYPE_LAST) {
     if (pQueryHandle->cachelastrow == 1) {
       return loadCachedLastRow(pQueryHandle);
-    } if (pQueryHandle->cachelastrow == 2) else {
+    } else if (pQueryHandle->cachelastrow == 2) {
       return loadCachedLast(pQueryHandle);
     }
   }
@@ -2875,17 +2875,14 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
 
   int32_t code = 0;
   
-  if (((STable*)pInfo->pTable)->lastRow == 1) {
+  if (((STable*)pInfo->pTable)->lastRow) {
     code = tsdbGetCachedLastRow(pInfo->pTable, &pRow, &key);
     if (code != TSDB_CODE_SUCCESS) {
       pQueryHandle->cachelastrow = 0;
     } else {
-      pQueryHandle->cachelastrow = ((STable*)pInfo->pTable)->lastRow;
+      pQueryHandle->cachelastrow = 1;
     }
-  } else if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0 && ((STable*)pInfo->pTable)->lastRow == 2){
-    pQueryHandle->cachelastrow = ((STable*)pInfo->pTable)->lastRow;
   }
-  
 
   // update the tsdb query time range
   if (pQueryHandle->cachelastrow) {
@@ -2898,6 +2895,36 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
   return code;
 }
 
+int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList) {
+  assert(pQueryHandle != NULL && groupList != NULL);
+
+  SDataRow pRow = NULL;
+  TSKEY    key = TSKEY_INITIAL_VAL;
+
+  SArray* group = taosArrayGetP(groupList->pGroupList, 0);
+  assert(group != NULL);
+
+  STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(group, 0);
+
+  int32_t code = 0;
+  
+  if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0){
+    pQueryHandle->cachelastrow = 2;
+  }
+  
+
+  // update the tsdb query time range
+  if (pQueryHandle->cachelastrow) {
+    pQueryHandle->window      = TSWINDOW_INITIALIZER;
+    pQueryHandle->checkFiles  = false;
+    pQueryHandle->activeIndex = 0;  // start from -1
+  }
+
+  tfree(pRow);
+  return code;
+}
+
+
 STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList) {
   STimeWindow window = {INT64_MAX, INT64_MIN};
 

From cf8be044de5f3ed4b0a6733183700beb3c7b7903 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 20 May 2021 14:41:21 +0800
Subject: [PATCH 03/12] fix bug

---
 src/inc/taosdef.h         |   2 +
 src/inc/tsdb.h            |   4 +
 src/query/src/qExecutor.c |   4 +-
 src/tsdb/src/tsdbRead.c   | 238 ++++++++++++++++++--------------------
 4 files changed, 119 insertions(+), 129 deletions(-)

diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index 2882faf7be..1c63a9a05d 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -33,6 +33,8 @@ extern "C" {
 #endif
 
 #define TSWINDOW_INITIALIZER ((STimeWindow) {INT64_MIN, INT64_MAX})
+#define TSWINDOW_DESC_INITIALIZER ((STimeWindow) {INT64_MAX, INT64_MIN})
+
 #define TSKEY_INITIAL_VAL    INT64_MIN
 
 // Bytes for each type.
diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 7c28d3e485..468c5ab271 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -265,6 +265,10 @@ TsdbQueryHandleT *tsdbQueryTables(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
 TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfo, uint64_t qId,
                                   SMemRef *pRef);
 
+
+TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef);
+
+
 /**
  * get the queried table object list
  * @param pHandle
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index b48436a617..c2a4c7febe 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -33,6 +33,8 @@
 #define SET_MASTER_SCAN_FLAG(runtime)  ((runtime)->scanFlag = MASTER_SCAN)
 #define SET_REVERSE_SCAN_FLAG(runtime) ((runtime)->scanFlag = REVERSE_SCAN)
 
+#define TSWINDOW_IS_EQUAL(t1, t2) (((t1).skey == (t2).skey) && ((t1).ekey == (t2).ekey))
+
 #define SWITCH_ORDER(n) (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC))
 
 #define SDATA_BLOCK_INITIALIZER (SDataBlockInfo) {{0}, 0}
@@ -1989,7 +1991,7 @@ static bool isCachedLastQuery(SQueryAttr *pQueryAttr) {
     return false;
   }
 
-  if (!TSWINDOW_IS_EQUAL(pQueryAttr->window, TSWINDOW_INITIALIZER)) {
+  if (pQueryAttr->order.order != TSDB_ORDER_DESC || !TSWINDOW_IS_EQUAL(pQueryAttr->window, TSWINDOW_DESC_INITIALIZER)) {
     return false;
   }
 
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index a326bd07fc..54833e5e78 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -94,12 +94,6 @@ typedef struct SIOCostSummary {
   int64_t checkForNextTime;
 } SIOCostSummary;
 
-
-typedef struct SCacheLastColInfo {
-  int16_t  i;
-  int16_t  j;
-} SCacheLastColInfo;
-
 typedef struct STsdbQueryHandle {
   STsdbRepo*     pTsdb;
   SQueryFilePos  cur;              // current position
@@ -124,8 +118,6 @@ typedef struct STsdbQueryHandle {
   SFSIter        fileIter;
   SReadH         rhelper;
   STableBlockInfo* pDataBlockInfo;
-
-  SCacheLastColInfo lastCols;
   SDataCols     *pDataCols;        // in order to hold current file data block
   int32_t        allocSize;        // allocated data block size
   SMemRef       *pMemRef;
@@ -146,6 +138,7 @@ typedef struct STableGroupSupporter {
 
 static STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList);
 static int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
+static int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
 static int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey);
 
 static void    changeQueryHandleForInterpQuery(TsdbQueryHandleT pHandle);
@@ -554,7 +547,6 @@ TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STab
     return NULL;
   }
 
-  assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
   pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
   
   return pQueryHandle;
@@ -2490,133 +2482,124 @@ static bool loadCachedLastRow(STsdbQueryHandle* pQueryHandle) {
 }
 
 
-static int32_t copyColsFromCacheMem(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, STable* pTable) {
-  char* pData = NULL;
-
-  STSchema* pSchema = tsdbGetTableSchema(pTable);
-  int32_t numOfCols = schemaNCols(pSchema);
-  int32_t tgNumOfCols = QH_GET_NUM_OF_COLS(pQueryHandle);
-
-  assert(numOfCols == pTable->restoreColumnNum);
-  assert(pTable->lastCols != NULL);
-  
-  int32_t i = pQueryHandle->lastCols.i, j = pQueryHandle->lastCols.j;
-  while(i < tgNumOfCols && j < numOfCols) {
-    SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
-    if (pTable->lastCols[j].colId < pColInfo->info.colId) {
-      j++;
-      continue;
-    } else if (pTable->lastCols[j].colId > pColInfo->info.colId) {
-      i++;
-      continue;
-    }
-
-    if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
-      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
-    } else {
-      pData = (char*)pColInfo->pData + (capacity - numOfRows - 1) * pColInfo->info.bytes;
-    }
-
-    if (pTable->lastCols[j].bytes > 0) {
-      void* value = pTable->lastCols[j].pData;
-      switch (pColInfo->info.type) {
-        case TSDB_DATA_TYPE_BINARY:
-        case TSDB_DATA_TYPE_NCHAR:
-          memcpy(pData, value, varDataTLen(value));
-          break;
-        case TSDB_DATA_TYPE_NULL:
-        case TSDB_DATA_TYPE_BOOL:
-        case TSDB_DATA_TYPE_TINYINT:
-        case TSDB_DATA_TYPE_UTINYINT:  
-          *(uint8_t *)pData = *(uint8_t *)value;
-          break;
-        case TSDB_DATA_TYPE_SMALLINT:
-        case TSDB_DATA_TYPE_USMALLINT:
-          *(uint16_t *)pData = *(uint16_t *)value;
-          break;
-        case TSDB_DATA_TYPE_INT:
-        case TSDB_DATA_TYPE_UINT:
-          *(uint32_t *)pData = *(uint32_t *)value;
-          break;
-        case TSDB_DATA_TYPE_BIGINT:
-        case TSDB_DATA_TYPE_UBIGINT:
-          *(uint64_t *)pData = *(uint64_t *)value;
-          break;
-        case TSDB_DATA_TYPE_FLOAT:
-          SET_FLOAT_PTR(pData, value);
-          break;
-        case TSDB_DATA_TYPE_DOUBLE:
-          SET_DOUBLE_PTR(pData, value);
-          break;
-        case TSDB_DATA_TYPE_TIMESTAMP:
-          if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-            *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
-          } else {
-            *(TSKEY *)pData = *(TSKEY *)value;
-          }
-          break;
-        default:
-          memcpy(pData, value, pColInfo->info.bytes);
-      }
-
-      for (int32_t n = 0; n < tgNumOfCols; ++n) {
-        if (n == i) {
-          continue;
-        }
-        
-        SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
-        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
-          setVardataNull(pData, pColInfo->info.type);
-        } else {
-          setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
-        }
-      }
-
-      ++i;
-      ++j;
-
-      if (i >= tgNumOfCols || j >= numOfCols) {
-        pQueryHandle->lastCols.i = 0;
-        pQueryHandle->lastCols.j = 0;
-        pQueryHandle->activeIndex++;
-      } else {
-        pQueryHandle->lastCols.i = i;
-        pQueryHandle->lastCols.j = j;
-      }
-
-      return 1;
-    } 
-
-    i++;
-    j++;
-  }
-
-  pQueryHandle->lastCols.i = 0;
-  pQueryHandle->lastCols.j = 0;
-  pQueryHandle->activeIndex++;
-
-  return 0;
-}
-
 
 static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   // the last row is cached in buffer, return it directly.
   // here note that the pQueryHandle->window must be the TS_INITIALIZER
-  int32_t numOfCols  = (int32_t)(QH_GET_NUM_OF_COLS(pQueryHandle));
+  int32_t tgNumOfCols = QH_GET_NUM_OF_COLS(pQueryHandle);
   size_t  numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
-  assert(numOfTables > 0 && numOfCols > 0);
-
-  SQueryFilePos* cur = &pQueryHandle->cur;
-
-  TSKEY    key  = TSKEY_INITIAL_VAL;
-  int32_t  step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1:-1;
+  int32_t numOfRows = 0;
+  assert(numOfTables > 0 && tgNumOfCols > 0);
 
   while (pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
+    STable* pTable = pCheckInfo->pTableObj;  
+    char* pData = NULL;
+
+    int32_t numOfCols = pTable->lastColNum;
     
-    if (copyColsFromCacheMem(pQueryHandle, pQueryHandle->outputCapacity, 0, numOfCols, pCheckInfo->pTableObj, NULL)) {
-      return true;
+    if (pTable->lastCols == NULL || pTable->lastColNum <= 0) {
+      tsdbWarn("no last cached for table, uid:%" PRIu64 ",tid:%d", pTable->tableId.uid, pTable->tableId.tid);
+      pQueryHandle->activeIndex++;
+      continue;
     }
+    
+    int32_t i = 0, j = 0;
+    while(i < tgNumOfCols && j < numOfCols) {
+      SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+      if (pTable->lastCols[j].colId < pColInfo->info.colId) {
+        j++;
+        continue;
+      } else if (pTable->lastCols[j].colId > pColInfo->info.colId) {
+        i++;
+        continue;
+      }
+    
+      if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
+        pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
+      } else {
+        pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity + numOfRows - 1) * pColInfo->info.bytes;
+      }
+    
+      if (pTable->lastCols[j].bytes > 0) {
+        void* value = pTable->lastCols[j].pData;
+        switch (pColInfo->info.type) {
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR:
+            memcpy(pData, value, varDataTLen(value));
+            break;
+          case TSDB_DATA_TYPE_NULL:
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_UTINYINT:  
+            *(uint8_t *)pData = *(uint8_t *)value;
+            break;
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_USMALLINT:
+            *(uint16_t *)pData = *(uint16_t *)value;
+            break;
+          case TSDB_DATA_TYPE_INT:
+          case TSDB_DATA_TYPE_UINT:
+            *(uint32_t *)pData = *(uint32_t *)value;
+            break;
+          case TSDB_DATA_TYPE_BIGINT:
+          case TSDB_DATA_TYPE_UBIGINT:
+            *(uint64_t *)pData = *(uint64_t *)value;
+            break;
+          case TSDB_DATA_TYPE_FLOAT:
+            SET_FLOAT_PTR(pData, value);
+            break;
+          case TSDB_DATA_TYPE_DOUBLE:
+            SET_DOUBLE_PTR(pData, value);
+            break;
+          case TSDB_DATA_TYPE_TIMESTAMP:
+            if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+              *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
+            } else {
+              *(TSKEY *)pData = *(TSKEY *)value;
+            }
+            break;
+          default:
+            memcpy(pData, value, pColInfo->info.bytes);
+        }
+    
+        for (int32_t n = 0; n < tgNumOfCols; ++n) {
+          if (n == i) {
+            continue;
+          }
+
+          SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+          if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
+            pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
+          } else {
+            pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity + numOfRows - 1) * pColInfo->info.bytes;
+          }
+
+          if (n == 0) {
+            *(TSKEY *)pData = pTable->lastCols[j].ts;
+            continue;
+          }
+          
+          if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+            setVardataNull(pData, pColInfo->info.type);
+          } else {
+            setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
+          }
+        }
+
+        numOfRows++;
+        assert(numOfRows < pQueryHandle->outputCapacity);
+      } 
+    
+      i++;
+      j++;
+    }
+
+    pQueryHandle->activeIndex++;
+
+    if (numOfRows > 0) {
+      return true;
+    }    
   }
 
   return false;
@@ -2850,7 +2833,7 @@ int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey) {
   TSDB_RLOCK_TABLE(pTable);
   *lastKey = pTable->lastKey;
 
-  if ((*lastKey) != TSKEY_INITIAL_VAL && pTable->lastRow == 1) {
+  if ((*lastKey) != TSKEY_INITIAL_VAL && pTable->lastRow) {
     *pRes = tdDataRowDup(pTable->lastRow);
     if (*pRes == NULL) {
       TSDB_RUNLOCK_TABLE(pTable);
@@ -2899,7 +2882,6 @@ int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *grou
   assert(pQueryHandle != NULL && groupList != NULL);
 
   SDataRow pRow = NULL;
-  TSKEY    key = TSKEY_INITIAL_VAL;
 
   SArray* group = taosArrayGetP(groupList->pGroupList, 0);
   assert(group != NULL);

From 308639a9e333a083ee693ced95d66dbd0b014c56 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 20 May 2021 15:37:38 +0800
Subject: [PATCH 04/12] fix bug

---
 src/tsdb/src/tsdbRead.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 54833e5e78..cf2ab0cc3f 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2491,7 +2491,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   int32_t numOfRows = 0;
   assert(numOfTables > 0 && tgNumOfCols > 0);
 
-  while (pQueryHandle->activeIndex < numOfTables) {
+  while (++pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
     STable* pTable = pCheckInfo->pTableObj;  
     char* pData = NULL;
@@ -2500,7 +2500,6 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
     
     if (pTable->lastCols == NULL || pTable->lastColNum <= 0) {
       tsdbWarn("no last cached for table, uid:%" PRIu64 ",tid:%d", pTable->tableId.uid, pTable->tableId.tid);
-      pQueryHandle->activeIndex++;
       continue;
     }
     
@@ -2595,8 +2594,6 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
       j++;
     }
 
-    pQueryHandle->activeIndex++;
-
     if (numOfRows > 0) {
       return true;
     }    
@@ -2899,7 +2896,7 @@ int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *grou
   if (pQueryHandle->cachelastrow) {
     pQueryHandle->window      = TSWINDOW_INITIALIZER;
     pQueryHandle->checkFiles  = false;
-    pQueryHandle->activeIndex = 0;  // start from -1
+    pQueryHandle->activeIndex = -1;  // start from -1
   }
 
   tfree(pRow);

From 80cd7963cd2389a8dcf857dedffaa129932ce68d Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 20 May 2021 16:16:58 +0800
Subject: [PATCH 05/12] fix bug

---
 src/tsdb/src/tsdbRead.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index cf2ab0cc3f..29d400fd56 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2490,6 +2490,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   size_t  numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
   int32_t numOfRows = 0;
   assert(numOfTables > 0 && tgNumOfCols > 0);
+  SQueryFilePos* cur = &pQueryHandle->cur;
 
   while (++pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
@@ -2517,7 +2518,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
       if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
         pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
       } else {
-        pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity + numOfRows - 1) * pColInfo->info.bytes;
+        pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity - numOfRows - 1) * pColInfo->info.bytes;
       }
     
       if (pTable->lastCols[j].bytes > 0) {
@@ -2567,11 +2568,11 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
             continue;
           }
 
-          SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+          SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
           if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
             pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
           } else {
-            pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity + numOfRows - 1) * pColInfo->info.bytes;
+            pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity - numOfRows - 1) * pColInfo->info.bytes;
           }
 
           if (n == 0) {
@@ -2595,6 +2596,9 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
     }
 
     if (numOfRows > 0) {
+      cur->rows     = numOfRows;
+      cur->mixBlock = true;
+      
       return true;
     }    
   }

From 5507e88752614360abb66ab29e2802d4d42205ea Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 21 May 2021 08:26:29 +0800
Subject: [PATCH 06/12] move ts to last row

---
 src/tsdb/src/tsdbRead.c | 52 ++++++++++++++++++++++++++++++-----------
 1 file changed, 39 insertions(+), 13 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 29d400fd56..c78739d7ce 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2491,6 +2491,8 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   int32_t numOfRows = 0;
   assert(numOfTables > 0 && tgNumOfCols > 0);
   SQueryFilePos* cur = &pQueryHandle->cur;
+  TSKEY priKey = TSKEY_INITIAL_VAL;
+  int32_t priIdx = -1;
 
   while (++pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
@@ -2515,13 +2517,9 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
         continue;
       }
     
-      if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
-        pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
-      } else {
-        pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity - numOfRows - 1) * pColInfo->info.bytes;
-      }
+      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
     
-      if (pTable->lastCols[j].bytes > 0) {
+      if (pTable->lastCols[j].bytes > 0) {        
         void* value = pTable->lastCols[j].pData;
         switch (pColInfo->info.type) {
           case TSDB_DATA_TYPE_BINARY:
@@ -2554,7 +2552,12 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
             break;
           case TSDB_DATA_TYPE_TIMESTAMP:
             if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-              *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
+              priKey = tdGetKey(*(TKEY *)value);
+              priIdx = i;
+
+              i++;
+              j++;
+              continue;
             } else {
               *(TSKEY *)pData = *(TSKEY *)value;
             }
@@ -2569,13 +2572,9 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
           }
 
           SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
-          if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
-            pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
-          } else {
-            pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity - numOfRows - 1) * pColInfo->info.bytes;
-          }
+          pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
 
-          if (n == 0) {
+          if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
             *(TSKEY *)pData = pTable->lastCols[j].ts;
             continue;
           }
@@ -2595,6 +2594,33 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
       j++;
     }
 
+    // leave the real ts column as the last row, because last function only (not stable) use the last row as res
+    if (priKey != TSKEY_INITIAL_VAL) {
+      SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, priIdx);
+      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
+    
+      *(TSKEY *)pData = priKey;
+
+      for (int32_t n = 0; n < tgNumOfCols; ++n) {
+        if (n == priIdx) {
+          continue;
+        }
+      
+        SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
+        pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
+      
+        assert (pColInfo->info.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX);
+        
+        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(pData, pColInfo->info.type);
+        } else {
+          setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
+        }
+      }
+
+      numOfRows++;
+    }
+    
     if (numOfRows > 0) {
       cur->rows     = numOfRows;
       cur->mixBlock = true;

From 2f1c18b6c1eff8505968efe82a8dbeeb7db6ca0c Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 21 May 2021 14:16:03 +0800
Subject: [PATCH 07/12] add test case

---
 tests/script/general/parser/last_cache.sim    |  71 +++
 .../general/parser/last_cache_query.sim       | 416 ++++++++++++++++++
 tests/script/general/parser/testSuite.sim     |   2 +
 3 files changed, 489 insertions(+)
 create mode 100644 tests/script/general/parser/last_cache.sim
 create mode 100644 tests/script/general/parser/last_cache_query.sim

diff --git a/tests/script/general/parser/last_cache.sim b/tests/script/general/parser/last_cache.sim
new file mode 100644
index 0000000000..9d7da9ddba
--- /dev/null
+++ b/tests/script/general/parser/last_cache.sim
@@ -0,0 +1,71 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4
+system sh/exec.sh -n dnode1 -s start
+
+sleep 100
+sql connect
+print ======================== dnode1 start
+
+$db = testdb
+
+sql create database $db cachelast 2
+sql use $db
+
+sql create stable st2 (ts timestamp, f1 int, f2 double, f3 binary(10), f4 timestamp) tags (id int)
+
+sql create table tb1 using st2 tags (1);
+sql create table tb2 using st2 tags (2);
+sql create table tb3 using st2 tags (3);
+sql create table tb4 using st2 tags (4);
+sql create table tb5 using st2 tags (1);
+sql create table tb6 using st2 tags (2);
+sql create table tb7 using st2 tags (3);
+sql create table tb8 using st2 tags (4);
+sql create table tb9 using st2 tags (5);
+sql create table tba using st2 tags (5);
+sql create table tbb using st2 tags (5);
+sql create table tbc using st2 tags (5);
+sql create table tbd using st2 tags (5);
+sql create table tbe using st2 tags (5);
+ 
+sql insert into tb1 values ("2021-05-09 10:10:10", 1, 2.0, '3',  -1000)
+sql insert into tb1 values ("2021-05-10 10:10:11", 4, 5.0, NULL, -2000)
+sql insert into tb1 values ("2021-05-12 10:10:12", 6,NULL, NULL, -3000)
+
+sql insert into tb2 values ("2021-05-09 10:11:13",-1,-2.0,'-3',  -1001)
+sql insert into tb2 values ("2021-05-10 10:11:14",-4,-5.0, NULL, -2001)
+sql insert into tb2 values ("2021-05-11 10:11:15",-6,  -7, '-8', -3001)
+
+sql insert into tb3 values ("2021-05-09 10:12:17", 7, 8.0, '9' , -1002)
+sql insert into tb3 values ("2021-05-09 10:12:17",10,11.0, NULL, -2002)
+sql insert into tb3 values ("2021-05-09 10:12:18",12,NULL, NULL, -3002)
+
+sql insert into tb4 values ("2021-05-09 10:12:19",13,14.0,'15' , -1003)
+sql insert into tb4 values ("2021-05-10 10:12:20",16,17.0, NULL, -2003)
+sql insert into tb4 values ("2021-05-11 10:12:21",18,NULL, NULL, -3003)
+
+sql insert into tb5 values ("2021-05-09 10:12:22",19,  20, '21', -1004)
+sql insert into tb6 values ("2021-05-11 10:12:23",22,  23, NULL, -2004)
+sql insert into tb7 values ("2021-05-10 10:12:24",24,NULL, '25', -3004)
+sql insert into tb8 values ("2021-05-11 10:12:25",26,NULL, '27', -4004)
+
+sql insert into tb9 values ("2021-05-09 10:12:26",28,  29, '30', -1005)
+sql insert into tba values ("2021-05-10 10:12:27",31,  32, NULL, -2005)
+sql insert into tbb values ("2021-05-10 10:12:28",33,NULL, '35', -3005)
+sql insert into tbc values ("2021-05-11 10:12:29",36,  37, NULL, -4005)
+sql insert into tbd values ("2021-05-11 10:12:29",NULL,NULL,NULL,NULL )
+
+run general/parser/last_cache_query.sim
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+
+system sh/exec.sh -n dnode1 -s start
+
+run general/parser/last_cache_query.sim
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+
+
+
diff --git a/tests/script/general/parser/last_cache_query.sim b/tests/script/general/parser/last_cache_query.sim
new file mode 100644
index 0000000000..2acd000585
--- /dev/null
+++ b/tests/script/general/parser/last_cache_query.sim
@@ -0,0 +1,416 @@
+
+sleep 100
+sql connect
+
+$db = testdb
+
+sql use $db
+
+print "test tb1"
+
+sql select last(ts) from tb1
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+
+
+sql select last(f1) from tb1
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 6 then 
+  print $data00
+  return -1
+endi
+
+sql select last(*) from tb1
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 5.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 3 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
+
+sql select last(tb1.*,ts,f4) from tb1
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 5.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 3 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+if $data05 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data06 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
+
+
+
+print "test tb2"
+
+sql select last(ts) from tb2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-11 10:11:15.000@ then 
+  print $data00
+  return -1
+endi
+
+
+sql select last(f1) from tb2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != -6 then 
+  print $data00
+  return -1
+endi
+
+sql select last(*) from tb2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-11 10:11:15.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != -6 then 
+  return -1
+endi
+if $data02 != -7.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != -8 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:56.999@ then 
+  if $data04 != @70-01-01 07:59:57.-01@ then
+    return -1
+  endi
+endi
+
+
+sql select last(tb2.*,ts,f4) from tb2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-11 10:11:15.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != -6 then 
+  return -1
+endi
+if $data02 != -7.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != -8 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:56.999@ then 
+  if $data04 != @70-01-01 07:59:57.-01@ then
+    return -1
+  endi
+endi
+if $data05 != @21-05-11 10:11:15.000@ then 
+  print $data00
+  return -1
+endi
+if $data06 != @70-01-01 07:59:56.999@ then 
+  if $data04 != @70-01-01 07:59:57.-01@ then
+    return -1
+  endi
+endi
+
+
+
+
+
+
+
+print "test tbd"
+sql select last(*) from tbd
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-11 10:12:29.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != NULL then 
+  return -1
+endi
+if $data02 != NULL then 
+  print $data02
+  return -1
+endi
+if $data03 != NULL then 
+  return -1
+endi
+if $data04 != NULL then 
+  return -1
+endi
+
+
+
+print "test tbe"
+sql select last(*) from tbe
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+print "test stable"
+sql select last(ts) from st2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+
+
+sql select last(f1) from st2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 6 then 
+  print $data00
+  return -1
+endi
+
+sql select last(*) from st2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 37.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 27 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
+
+sql select last(st2.*,ts,f4) from st2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 37.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 27 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+if $data05 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data06 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
+
+sql select last(*) from st2 group by id
+if $rows != 5 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 5.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 21 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+if $data05 != 1 then 
+  return -1
+endi
+if $data10 != @21-05-11 10:12:23.000@ then 
+  return -1
+endi
+if $data11 != 22 then 
+  return -1
+endi
+if $data12 != 23.000000000 then 
+  print $data02
+  return -1
+endi
+if $data13 != -8 then 
+  return -1
+endi
+if $data14 != @70-01-01 07:59:57.996@ then 
+if $data14 != @70-01-01 07:59:58.-04@ then 
+  print $data14
+  return -1
+endi
+endi
+if $data15 != 2 then 
+  return -1
+endi
+if $data20 != @21-05-10 10:12:24.000@ then 
+  return -1
+endi
+if $data21 != 24 then 
+  return -1
+endi
+if $data22 != 8.000000000 then 
+  print $data02
+  return -1
+endi
+if $data23 != 25 then 
+  return -1
+endi
+if $data24 != @70-01-01 07:59:56.996@ then 
+if $data24 != @70-01-01 07:59:57.-04@ then 
+  return -1
+endi
+endi
+if $data25 != 3 then 
+  return -1
+endi
+if $data30 != @21-05-11 10:12:25.000@ then 
+  return -1
+endi
+if $data31 != 26 then 
+  return -1
+endi
+if $data32 != 17.000000000 then 
+  print $data02
+  return -1
+endi
+if $data33 != 27 then 
+  return -1
+endi
+if $data34 != @70-01-01 07:59:55.996@ then 
+if $data34 != @70-01-01 07:59:56.-04@ then 
+  return -1
+endi
+endi
+if $data35 != 4 then 
+  return -1
+endi
+if $data40 != @21-05-11 10:12:29.000@ then 
+  return -1
+endi
+if $data41 != 36 then 
+  return -1
+endi
+if $data42 != 37.000000000 then 
+  print $data02
+  return -1
+endi
+if $data43 != 35 then 
+  return -1
+endi
+if $data44 != @70-01-01 07:59:55.995@ then 
+if $data44 != @70-01-01 07:59:56.-05@ then 
+  return -1
+endi
+endi
+if $data45 != 5 then 
+  return -1
+endi
+
+
+print "test tbn"
+sql create table tbn (ts timestamp, f1 int, f2 double, f3 binary(10), f4 timestamp)
+sql insert into tbn values ("2021-05-09 10:10:10", 1, 2.0, '3',  -1000)
+sql insert into tbn values ("2021-05-10 10:10:11", 4, 5.0, NULL, -2000)
+sql insert into tbn values ("2021-05-12 10:10:12", 6,NULL, NULL, -3000)
+sql insert into tbn values ("2021-05-13 10:10:12", NULL,NULL, NULL,NULL)
+
+sql select last(*) from tbn;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-13 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 5.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 3 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index 1294b093c2..6a3b71e773 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -59,4 +59,6 @@ run general/parser/having.sim
 run general/parser/having_child.sim
 run general/parser/slimit_alter_tags.sim
 run general/parser/binary_escapeCharacter.sim
+run general/parser/between_and.sim
+run general/parser/last_cache.sim
 

From 23313ecf677314f3d9fd373bd5808e6d32fc0c25 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 21 May 2021 15:14:36 +0800
Subject: [PATCH 08/12] fix bug

---
 src/tsdb/src/tsdbRead.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index c78739d7ce..f40c496bf4 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2571,7 +2571,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
             continue;
           }
 
-          SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
+          pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
           pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
 
           if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
@@ -2596,7 +2596,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
 
     // leave the real ts column as the last row, because last function only (not stable) use the last row as res
     if (priKey != TSKEY_INITIAL_VAL) {
-      SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, priIdx);
+      pColInfo = taosArrayGet(pQueryHandle->pColumns, priIdx);
       pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
     
       *(TSKEY *)pData = priKey;

From 9be55c32b127f343457458cc23c4c58a7c7830de Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 21 May 2021 15:16:53 +0800
Subject: [PATCH 09/12] fix bug

---
 src/tsdb/src/tsdbRead.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index f40c496bf4..491a4b2db0 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2493,6 +2493,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   SQueryFilePos* cur = &pQueryHandle->cur;
   TSKEY priKey = TSKEY_INITIAL_VAL;
   int32_t priIdx = -1;
+  SColumnInfoData* pColInfo = NULL;
 
   while (++pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
@@ -2508,7 +2509,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
     
     int32_t i = 0, j = 0;
     while(i < tgNumOfCols && j < numOfCols) {
-      SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+      pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
       if (pTable->lastCols[j].colId < pColInfo->info.colId) {
         j++;
         continue;
@@ -2606,7 +2607,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
           continue;
         }
       
-        SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
+        pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
         pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
       
         assert (pColInfo->info.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX);

From 6eeb539807eda232ad6300afe1b27c0b1ce5e2a1 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Sat, 22 May 2021 15:04:59 +0800
Subject: [PATCH 10/12] fix bug

---
 src/inc/tsdb.h            | 2 ++
 src/query/src/qExecutor.c | 2 +-
 src/tsdb/src/tsdbRead.c   | 9 +++++++--
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 468c5ab271..7c8819777d 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -268,6 +268,8 @@ TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
 
 TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef);
 
+bool isTsdbCacheLastRow(TsdbQueryHandleT* pQueryHandle);
+
 
 /**
  * get the queried table object list
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index c2a4c7febe..1d41bc42b0 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -4243,7 +4243,7 @@ static SSDataBlock* doTableScan(void* param, bool *newgroup) {
     }
 
     if (++pTableScanInfo->current >= pTableScanInfo->times) {
-      if (pTableScanInfo->reverseTimes <= 0) {
+      if (pTableScanInfo->reverseTimes <= 0 || isTsdbCacheLastRow(pTableScanInfo->pQueryHandle)) {
         return NULL;
       } else {
         break;
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 491a4b2db0..626602576f 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -547,7 +547,9 @@ TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STab
     return NULL;
   }
 
-  pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  if (pQueryHandle->cachelastrow) {
+    pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  }
   
   return pQueryHandle;
 }
@@ -2873,6 +2875,10 @@ int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey) {
   return TSDB_CODE_SUCCESS;
 }
 
+bool isTsdbCacheLastRow(TsdbQueryHandleT* pQueryHandle) {
+  return ((STsdbQueryHandle *)pQueryHandle)->cachelastrow > 0;
+}
+
 int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList) {
   assert(pQueryHandle != NULL && groupList != NULL);
 
@@ -2921,7 +2927,6 @@ int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *grou
   if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0){
     pQueryHandle->cachelastrow = 2;
   }
-  
 
   // update the tsdb query time range
   if (pQueryHandle->cachelastrow) {

From ca4e75b69a6926fe5cc5c741d3f0da70bcdaa776 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Wed, 26 May 2021 18:30:31 +0800
Subject: [PATCH 11/12] fix bug

---
 src/tsdb/src/tsdbRead.c | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 626602576f..50acda0d95 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -138,7 +138,7 @@ typedef struct STableGroupSupporter {
 
 static STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList);
 static int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
-static int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
+static int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle);
 static int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey);
 
 static void    changeQueryHandleForInterpQuery(TsdbQueryHandleT pHandle);
@@ -541,7 +541,7 @@ TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
 
 TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
   STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, groupList, qId, pMemRef);
-  int32_t code = checkForCachedLast(pQueryHandle, groupList);
+  int32_t code = checkForCachedLast(pQueryHandle);
   if (code != TSDB_CODE_SUCCESS) { // set the numOfTables to be 0
     terrno = code;
     return NULL;
@@ -2502,9 +2502,9 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
     STable* pTable = pCheckInfo->pTableObj;  
     char* pData = NULL;
 
-    int32_t numOfCols = pTable->lastColNum;
+    int32_t numOfCols = pTable->maxColNum;
     
-    if (pTable->lastCols == NULL || pTable->lastColNum <= 0) {
+    if (pTable->lastCols == NULL || pTable->maxColNum <= 0) {
       tsdbWarn("no last cached for table, uid:%" PRIu64 ",tid:%d", pTable->tableId.uid, pTable->tableId.tid);
       continue;
     }
@@ -2912,19 +2912,12 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
   return code;
 }
 
-int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList) {
-  assert(pQueryHandle != NULL && groupList != NULL);
-
-  SDataRow pRow = NULL;
-
-  SArray* group = taosArrayGetP(groupList->pGroupList, 0);
-  assert(group != NULL);
-
-  STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(group, 0);
+int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle) {
+  assert(pQueryHandle != NULL);
 
   int32_t code = 0;
   
-  if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0){
+  if (pQueryHandle->pTsdb && atomic_load_8(&pQueryHandle->pTsdb->hasCachedLastColumn)){
     pQueryHandle->cachelastrow = 2;
   }
 
@@ -2935,7 +2928,6 @@ int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *grou
     pQueryHandle->activeIndex = -1;  // start from -1
   }
 
-  tfree(pRow);
   return code;
 }
 

From 11026023e237bc6f3e039e4fdd3dfa34e952901f Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 27 May 2021 11:52:02 +0800
Subject: [PATCH 12/12] fix windows compile error

---
 src/tsdb/src/tsdbRead.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 50acda0d95..0a39dba021 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2488,7 +2488,7 @@ static bool loadCachedLastRow(STsdbQueryHandle* pQueryHandle) {
 static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   // the last row is cached in buffer, return it directly.
   // here note that the pQueryHandle->window must be the TS_INITIALIZER
-  int32_t tgNumOfCols = QH_GET_NUM_OF_COLS(pQueryHandle);
+  int32_t tgNumOfCols = (int32_t)QH_GET_NUM_OF_COLS(pQueryHandle);
   size_t  numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
   int32_t numOfRows = 0;
   assert(numOfTables > 0 && tgNumOfCols > 0);