Merge pull request #14931 from taosdata/feature/3.0_debug_wxy

fix: a problem of last_row function plan

source/libs/parser/src/parAstParser.c

@@ -118,36 +118,33 @@ static bool needGetTableIndex(SNode* pStmt) {
   return false;
 }
 
-static int32_t collectMetaKeyFromRealTableImpl(SCollectMetaKeyCxt* pCxt, SRealTableNode* pRealTable,
+static int32_t collectMetaKeyFromRealTableImpl(SCollectMetaKeyCxt* pCxt, const char* pDb, const char* pTable,
                                                AUTH_TYPE authType) {
-  int32_t code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, pRealTable->table.dbName, pRealTable->table.tableName,
-                                         pCxt->pMetaCache);
+  int32_t code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, pDb, pTable, pCxt->pMetaCache);
   if (TSDB_CODE_SUCCESS == code) {
-    code = reserveTableVgroupInCache(pCxt->pParseCxt->acctId, pRealTable->table.dbName, pRealTable->table.tableName,
-                                     pCxt->pMetaCache);
+    code = reserveTableVgroupInCache(pCxt->pParseCxt->acctId, pDb, pTable, pCxt->pMetaCache);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = reserveUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, pRealTable->table.dbName, authType,
-                                  pCxt->pMetaCache);
+    code = reserveUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, pDb, authType, pCxt->pMetaCache);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = reserveDbVgInfoInCache(pCxt->pParseCxt->acctId, pRealTable->table.dbName, pCxt->pMetaCache);
+    code = reserveDbVgInfoInCache(pCxt->pParseCxt->acctId, pDb, pCxt->pMetaCache);
   }
   if (TSDB_CODE_SUCCESS == code && needGetTableIndex(pCxt->pStmt)) {
-    code = reserveTableIndexInCache(pCxt->pParseCxt->acctId, pRealTable->table.dbName, pRealTable->table.tableName,
-                                    pCxt->pMetaCache);
+    code = reserveTableIndexInCache(pCxt->pParseCxt->acctId, pDb, pTable, pCxt->pMetaCache);
   }
-  if (TSDB_CODE_SUCCESS == code && (0 == strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_DNODE_VARIABLES))) {
+  if (TSDB_CODE_SUCCESS == code && (0 == strcmp(pTable, TSDB_INS_TABLE_DNODE_VARIABLES))) {
     code = reserveDnodeRequiredInCache(pCxt->pMetaCache);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = reserveDbCfgInCache(pCxt->pParseCxt->acctId, pRealTable->table.dbName, pCxt->pMetaCache);
+    code = reserveDbCfgInCache(pCxt->pParseCxt->acctId, pDb, pCxt->pMetaCache);
   }
   return code;
 }
 
 static EDealRes collectMetaKeyFromRealTable(SCollectMetaKeyFromExprCxt* pCxt, SRealTableNode* pRealTable) {
-  pCxt->errCode = collectMetaKeyFromRealTableImpl(pCxt->pComCxt, pRealTable, AUTH_TYPE_READ);
+  pCxt->errCode = collectMetaKeyFromRealTableImpl(pCxt->pComCxt, pRealTable->table.dbName, pRealTable->table.tableName,
+                                                  AUTH_TYPE_READ);
   return TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_CONTINUE : DEAL_RES_ERROR;
 }
 
@@ -454,11 +451,13 @@ static int32_t collectMetaKeyFromShowTransactions(SCollectMetaKeyCxt* pCxt, SSho
 }
 
 static int32_t collectMetaKeyFromDelete(SCollectMetaKeyCxt* pCxt, SDeleteStmt* pStmt) {
-  return collectMetaKeyFromRealTableImpl(pCxt, (SRealTableNode*)pStmt->pFromTable, AUTH_TYPE_WRITE);
+  STableNode* pTable = (STableNode*)pStmt->pFromTable;
+  return collectMetaKeyFromRealTableImpl(pCxt, pTable->dbName, pTable->tableName, AUTH_TYPE_WRITE);
 }
 
 static int32_t collectMetaKeyFromInsert(SCollectMetaKeyCxt* pCxt, SInsertStmt* pStmt) {
-  int32_t code = collectMetaKeyFromRealTableImpl(pCxt, (SRealTableNode*)pStmt->pTable, AUTH_TYPE_WRITE);
+  STableNode* pTable = (STableNode*)pStmt->pTable;
+  int32_t     code = collectMetaKeyFromRealTableImpl(pCxt, pTable->dbName, pTable->tableName, AUTH_TYPE_WRITE);
   if (TSDB_CODE_SUCCESS == code) {
     code = collectMetaKeyFromQuery(pCxt, pStmt->pQuery);
   }
@@ -471,14 +470,7 @@ static int32_t collectMetaKeyFromShowBlockDist(SCollectMetaKeyCxt* pCxt, SShowTa
   strcpy(name.tname, pStmt->tableName);
   int32_t code = catalogRemoveTableMeta(pCxt->pParseCxt->pCatalog, &name);
   if (TSDB_CODE_SUCCESS == code) {
-    code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, pCxt->pMetaCache);
-  }
-
-  if (TSDB_CODE_SUCCESS == code) {
-    code = reserveTableVgroupInCache(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, pCxt->pMetaCache);
-  }
-  if (TSDB_CODE_SUCCESS == code) {
-    code = reserveDbVgInfoInCache(pCxt->pParseCxt->acctId, pStmt->dbName, pCxt->pMetaCache);
+    code = collectMetaKeyFromRealTableImpl(pCxt, pStmt->dbName, pStmt->tableName, AUTH_TYPE_READ);
   }
   return code;
 }

source/libs/parser/test/mockCatalog.cpp

@@ -159,8 +159,8 @@ void generatePerformanceSchema(MockCatalogService* mcs) {
  *          c4         |       column       |       DOUBLE       |    8     |
  *          c5         |       column       |       DOUBLE       |    8     |
  */
-void generateTestTables(MockCatalogService* mcs) {
-  ITableBuilder& builder = mcs->createTableBuilder("test", "t1", TSDB_NORMAL_TABLE, 6)
+void generateTestTables(MockCatalogService* mcs, const std::string& db) {
+  ITableBuilder& builder = mcs->createTableBuilder(db, "t1", TSDB_NORMAL_TABLE, 6)
                                .setPrecision(TSDB_TIME_PRECISION_MILLI)
                                .setVgid(1)
                                .addColumn("ts", TSDB_DATA_TYPE_TIMESTAMP)
@@ -193,9 +193,9 @@ void generateTestTables(MockCatalogService* mcs) {
  *         jtag        |        tag         |        json        |    --    |
  * Child Table: st2s1, st2s2
  */
-void generateTestStables(MockCatalogService* mcs) {
+void generateTestStables(MockCatalogService* mcs, const std::string& db) {
   {
-    ITableBuilder& builder = mcs->createTableBuilder("test", "st1", TSDB_SUPER_TABLE, 3, 3)
+    ITableBuilder& builder = mcs->createTableBuilder(db, "st1", TSDB_SUPER_TABLE, 3, 3)
                                  .setPrecision(TSDB_TIME_PRECISION_MILLI)
                                  .addColumn("ts", TSDB_DATA_TYPE_TIMESTAMP)
                                  .addColumn("c1", TSDB_DATA_TYPE_INT)
@@ -204,20 +204,20 @@ void generateTestStables(MockCatalogService* mcs) {
                                  .addTag("tag2", TSDB_DATA_TYPE_BINARY, 20)
                                  .addTag("tag3", TSDB_DATA_TYPE_TIMESTAMP);
     builder.done();
-    mcs->createSubTable("test", "st1", "st1s1", 1);
-    mcs->createSubTable("test", "st1", "st1s2", 2);
-    mcs->createSubTable("test", "st1", "st1s3", 1);
+    mcs->createSubTable(db, "st1", "st1s1", 1);
+    mcs->createSubTable(db, "st1", "st1s2", 2);
+    mcs->createSubTable(db, "st1", "st1s3", 1);
   }
   {
-    ITableBuilder& builder = mcs->createTableBuilder("test", "st2", TSDB_SUPER_TABLE, 3, 1)
+    ITableBuilder& builder = mcs->createTableBuilder(db, "st2", TSDB_SUPER_TABLE, 3, 1)
                                  .setPrecision(TSDB_TIME_PRECISION_MILLI)
                                  .addColumn("ts", TSDB_DATA_TYPE_TIMESTAMP)
                                  .addColumn("c1", TSDB_DATA_TYPE_INT)
                                  .addColumn("c2", TSDB_DATA_TYPE_BINARY, 20)
                                  .addTag("jtag", TSDB_DATA_TYPE_JSON);
     builder.done();
-    mcs->createSubTable("test", "st2", "st2s1", 1);
-    mcs->createSubTable("test", "st2", "st2s2", 2);
+    mcs->createSubTable(db, "st2", "st2s1", 1);
+    mcs->createSubTable(db, "st2", "st2s2", 2);
   }
 }
 
@@ -237,6 +237,11 @@ void generateDatabases(MockCatalogService* mcs) {
   mcs->createDatabase(TSDB_INFORMATION_SCHEMA_DB);
   mcs->createDatabase(TSDB_PERFORMANCE_SCHEMA_DB);
   mcs->createDatabase("test");
+  generateTestTables(g_mockCatalogService.get(), "test");
+  generateTestStables(g_mockCatalogService.get(), "test");
+  mcs->createDatabase("cache_db", false, 1);
+  generateTestTables(g_mockCatalogService.get(), "cache_db");
+  generateTestStables(g_mockCatalogService.get(), "cache_db");
   mcs->createDatabase("rollup_db", true);
 }
 
@@ -369,11 +374,8 @@ void generateMetaData() {
   generateDatabases(g_mockCatalogService.get());
   generateInformationSchema(g_mockCatalogService.get());
   generatePerformanceSchema(g_mockCatalogService.get());
-  generateTestTables(g_mockCatalogService.get());
-  generateTestStables(g_mockCatalogService.get());
   generateFunctions(g_mockCatalogService.get());
   generateDnodes(g_mockCatalogService.get());
-  g_mockCatalogService->showTables();
 }
 
 void destroyMetaDataEnv() { g_mockCatalogService.reset(); }

source/libs/parser/test/mockCatalogService.cpp

@@ -334,11 +334,12 @@ class MockCatalogServiceImpl {
     dnode_.insert(std::make_pair(dnodeId, epSet));
   }
 
-  void createDatabase(const std::string& db, bool rollup) {
+  void createDatabase(const std::string& db, bool rollup, int8_t cacheLast) {
     SDbCfgInfo cfg = {0};
     if (rollup) {
       cfg.pRetensions = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SRetention));
     }
+    cfg.cacheLast = cacheLast;
     dbCfg_.insert(std::make_pair(db, cfg));
   }
 
@@ -627,7 +628,9 @@ void MockCatalogService::createDnode(int32_t dnodeId, const std::string& host, i
   impl_->createDnode(dnodeId, host, port);
 }
 
-void MockCatalogService::createDatabase(const std::string& db, bool rollup) { impl_->createDatabase(db, rollup); }
+void MockCatalogService::createDatabase(const std::string& db, bool rollup, int8_t cacheLast) {
+  impl_->createDatabase(db, rollup, cacheLast);
+}
 
 int32_t MockCatalogService::catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta) const {
   return impl_->catalogGetTableMeta(pTableName, pTableMeta);

source/libs/parser/test/mockCatalogService.h

@@ -63,7 +63,7 @@ class MockCatalogService {
   void createFunction(const std::string& func, int8_t funcType, int8_t outputType, int32_t outputLen, int32_t bufSize);
   void createSmaIndex(const SMCreateSmaReq* pReq);
   void createDnode(int32_t dnodeId, const std::string& host, int16_t port);
-  void createDatabase(const std::string& db, bool rollup = false);
+  void createDatabase(const std::string& db, bool rollup = false, int8_t cacheLast = 0);
 
   int32_t catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta) const;
   int32_t catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo) const;

source/libs/parser/test/parShowToUse.cpp

@@ -179,6 +179,12 @@ TEST_F(ParserShowToUseTest, showTables) {
   run("SHOW test.tables like 'c%'");
 }
 
+TEST_F(ParserShowToUseTest, showTableDistributed) {
+  useDb("root", "test");
+
+  run("SHOW TABLE DISTRIBUTED st1");
+}
+
 // todo SHOW topics
 
 TEST_F(ParserShowToUseTest, showUsers) {

source/libs/planner/src/planOptimizer.c

@@ -2011,11 +2011,13 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
   SNode* pNode = NULL;
   FOREACH(pNode, pAgg->pAggFuncs) {
     SFunctionNode* pFunc = (SFunctionNode*)pNode;
-    int32_t        len = snprintf(pFunc->functionName, sizeof(pFunc->functionName), "_cache_last_row");
-    pFunc->functionName[len] = '\0';
-    int32_t code = fmGetFuncInfo(pFunc, NULL, 0);
-    if (TSDB_CODE_SUCCESS != code) {
-      return code;
+    if (FUNCTION_TYPE_LAST_ROW == pFunc->funcType) {
+      int32_t len = snprintf(pFunc->functionName, sizeof(pFunc->functionName), "_cache_last_row");
+      pFunc->functionName[len] = '\0';
+      int32_t code = fmGetFuncInfo(pFunc, NULL, 0);
+      if (TSDB_CODE_SUCCESS != code) {
+        return code;
+      }
     }
   }
   pAgg->hasLastRow = false;

source/libs/planner/test/planBasicTest.cpp

@@ -98,6 +98,24 @@ TEST_F(PlanBasicTest, interpFunc) {
 }
 
 TEST_F(PlanBasicTest, lastRowFunc) {
+  useDb("root", "cache_db");
+
+  run("SELECT LAST_ROW(c1) FROM t1");
+
+  run("SELECT LAST_ROW(*) FROM t1");
+
+  run("SELECT LAST_ROW(c1, c2) FROM t1");
+
+  run("SELECT LAST_ROW(c1), c2 FROM t1");
+
+  run("SELECT LAST_ROW(c1) FROM st1");
+
+  run("SELECT LAST_ROW(c1) FROM st1 PARTITION BY TBNAME");
+
+  run("SELECT LAST_ROW(c1), SUM(c3) FROM t1");
+}
+
+TEST_F(PlanBasicTest, lastRowFuncWithoutCache) {
   useDb("root", "test");
 
   run("SELECT LAST_ROW(c1) FROM t1");

tests/system-test/2-query/tsbsQuery.py

@@ -85,7 +85,7 @@ class TDTestCase:
         # tdSql.checkRows(10)
 
         # test partition interval Pseudo time-column
-        tdSql.query("SELECT count(ms1)/144  FROM (SELECT _wstartts as ts1,model, fleet,avg(status) AS ms1 FROM diagnostics WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z'  partition by model, fleet interval(10m)) WHERE ts1 >= '2016-01-01T00:00:00Z' AND ts1 < '2016-01-05T00:00:01Z' AND ms1<1;")
+        tdSql.query("SELECT count(ms1)/144  FROM (SELECT _wstart as ts1,model, fleet,avg(status) AS ms1 FROM diagnostics WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z'  partition by model, fleet interval(10m)) WHERE ts1 >= '2016-01-01T00:00:00Z' AND ts1 < '2016-01-05T00:00:01Z' AND ms1<1;")
 
 
         # test