Merge branch '2.4' into fix/TD-12614-2.4

src/client/src/tscProfile.c

@@ -170,6 +170,16 @@ void tscAddIntoStreamList(SSqlStream *pStream) {
   STscObj *       pObj = pStream->pSql->pTscObj;
 
   pthread_mutex_lock(&pObj->mutex);
+  //check if newly added stream node is present
+  //in the streamList to prevent loop in the list
+  SSqlStream *iter = pObj->streamList;
+  while (iter) {
+    if (pStream == iter) {
+      pthread_mutex_unlock(&pObj->mutex);
+      return;
+    }
+    iter = iter->next;
+  }
 
   pStream->next = pObj->streamList;
   if (pObj->streamList) pObj->streamList->prev = pStream;

src/client/src/tscSQLParser.c

@@ -2864,6 +2864,13 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         char val[8] = {0};
 
         int64_t tickPerSec = 0;
+        char *exprToken = tcalloc(pParamElem[1].pNode->exprToken.n + 1, sizeof(char));
+        memcpy(exprToken, pParamElem[1].pNode->exprToken.z, pParamElem[1].pNode->exprToken.n);
+        if (pParamElem[1].pNode->exprToken.type == TK_NOW || strstr(exprToken, "now")) {
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        }
+        tfree(exprToken);
+
         if ((TSDB_DATA_TYPE_NULL == pParamElem[1].pNode->value.nType) || tVariantDump(&pParamElem[1].pNode->value, (char*) &tickPerSec, TSDB_DATA_TYPE_BIGINT, true) < 0) {
           return TSDB_CODE_TSC_INVALID_OPERATION;
         }
@@ -2878,7 +2885,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
           return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg10);
         } else if (tickPerSec <= 0) {
           return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg16);
-        } 
+        }
 
         tscExprAddParams(&pExpr->base, (char*) &tickPerSec, TSDB_DATA_TYPE_BIGINT, LONG_BYTES);
         if (functionId == TSDB_FUNC_DERIVATIVE) {
@@ -4918,14 +4925,14 @@ static int32_t validateNullExpr(tSqlExpr* pExpr, STableMeta* pTableMeta, int32_t
     if (IS_VAR_DATA_TYPE(pSchema[index].type) || pSchema[index].type == TSDB_DATA_TYPE_JSON) {
       return TSDB_CODE_SUCCESS;
     }
-    
+
     char *v = strndup(pRight->exprToken.z, pRight->exprToken.n);
     int32_t len = strRmquote(v, pRight->exprToken.n);
     if (len > 0) {
       uint32_t type = 0;
       tGetToken(v, &type);
 
-      if (type == TK_NULL) {        
+      if (type == TK_NULL) {
         free(v);
         return invalidOperationMsg(msgBuf, msg);
       }

src/client/src/tscUtil.c

@@ -1479,6 +1479,18 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
           break;
         }
       }
+
+      // set input data order to param[1]
+      if(pex->base.functionId == TSDB_FUNC_FIRST || pex->base.functionId  ==  TSDB_FUNC_FIRST_DST ||
+         pex->base.functionId == TSDB_FUNC_LAST  || pex->base.functionId  ==  TSDB_FUNC_LAST_DST) {
+        // set input order
+        SQueryInfo* pInputQI = pSqlObjList[0]->cmd.pQueryInfo;
+        if(pInputQI) {
+          pex->base.numOfParams = 3;
+          pex->base.param[2].nType = TSDB_DATA_TYPE_INT;
+          pex->base.param[2].i64 = pInputQI->order.order;
+        }
+      }
     }
 
     tscDebug("0x%"PRIx64" create QInfo 0x%"PRIx64" to execute the main query while all nest queries are ready", pSql->self, pSql->self);
@@ -4303,6 +4315,11 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
 
       // create sub query to handle the sub query.
       SQueryInfo* pq = tscGetQueryInfo(&psub->cmd);
+      STableMetaInfo* pSubMeta = tscGetMetaInfo(pq, 0);
+      if (UTIL_TABLE_IS_SUPER_TABLE(pSubMeta) &&
+          pq->command == TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
+        psub->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
+      }
       executeQuery(psub, pq);
     }
 

src/kit/shell/src/shellCheck.c

@@ -131,7 +131,7 @@ static void *shellCheckThreadFp(void *arg) {
     char *tbname = tbNames[t];
     if (tbname == NULL) break;
 
-    snprintf(sql, SHELL_SQL_LEN, "select last_row(_c0) from %s;", tbname);
+    snprintf(sql, SHELL_SQL_LEN, "select count(*) from %s;", tbname);
 
     TAOS_RES *pSql = taos_query(pThread->taos, sql);
     int32_t   code = taos_errno(pSql);

src/mnode/inc/mnodeVgroup.h

@@ -43,7 +43,7 @@ void    mnodeCheckUnCreatedVgroup(SDnodeObj *pDnode, SVnodeLoad *pVloads, int32_
 int32_t mnodeCreateVgroup(struct SMnodeMsg *pMsg);
 void    mnodeDropVgroup(SVgObj *pVgroup, void *ahandle);
 void    mnodeAlterVgroup(SVgObj *pVgroup, void *ahandle);
-int32_t mnodeGetAvailableVgroup(struct SMnodeMsg *pMsg, SVgObj **pVgroup, int32_t *sid);
+int32_t mnodeGetAvailableVgroup(struct SMnodeMsg *pMsg, SVgObj **pVgroup, int32_t *sid, int32_t vgId);
 
 int32_t mnodeAddTableIntoVgroup(SVgObj *pVgroup, SCTableObj *pTable, bool needCheck);
 void    mnodeRemoveTableFromVgroup(SVgObj *pVgroup, SCTableObj *pTable);

src/mnode/src/mnodeTable.c

@@ -48,6 +48,12 @@
 #define CREATE_CTABLE_RETRY_TIMES 10
 #define CREATE_CTABLE_RETRY_SEC   14
 
+// informal
+#define META_SYNC_TABLE_NAME "_taos_meta_sync_table_name_taos_"
+#define META_SYNC_TABLE_NAME_LEN 32
+static int32_t tsMetaSyncOption = 0;
+// informal
+
 int64_t          tsCTableRid = -1;
 static void *    tsChildTableSdb;
 int64_t          tsSTableRid = -1;
@@ -1726,6 +1732,9 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
     cols++;
 
     numOfRows++;
+
+    mDebug("stable: %s, uid: %" PRIu64, prefix, pTable->uid);
+
     mnodeDecTableRef(pTable);
   }
 
@@ -2227,9 +2236,19 @@ static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) {
     if (pMsg->pTable == NULL) {
       SVgObj *pVgroup = NULL;
       int32_t tid = 0;
-      code = mnodeGetAvailableVgroup(pMsg, &pVgroup, &tid);
+      int32_t vgId = 0;
+
+      if (tsMetaSyncOption) {
+        char *pTbName = strchr(pCreate->tableName, '.');
+        if (pTbName && (pTbName = strchr(pTbName + 1, '.'))) {
+          if (0 == strncmp(META_SYNC_TABLE_NAME, ++pTbName, META_SYNC_TABLE_NAME_LEN)) {
+            vgId = atoi(pTbName + META_SYNC_TABLE_NAME_LEN);
+          }
+        }
+      }
+      code = mnodeGetAvailableVgroup(pMsg, &pVgroup, &tid, vgId);
       if (code != TSDB_CODE_SUCCESS) {
-        mDebug("msg:%p, app:%p table:%s, failed to get available vgroup, reason:%s", pMsg, pMsg->rpcMsg.ahandle,
+        mError("msg:%p, app:%p table:%s, failed to get available vgroup, reason:%s", pMsg, pMsg->rpcMsg.ahandle,
                pCreate->tableName, tstrerror(code));
         return code;
       }

src/mnode/src/mnodeVgroup.c

@@ -428,10 +428,47 @@ static int32_t mnodeAllocVgroupIdPool(SVgObj *pInputVgroup) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t mnodeGetAvailableVgroup(SMnodeMsg *pMsg, SVgObj **ppVgroup, int32_t *pSid) {
+int32_t mnodeGetAvailableVgroup(SMnodeMsg *pMsg, SVgObj **ppVgroup, int32_t *pSid, int32_t vgId) {
   SDbObj *pDb = pMsg->pDb;
   pthread_mutex_lock(&pDb->mutex);
   
+  if (vgId > 0) {
+    for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
+      SVgObj *pVgroup = pDb->vgList[v];
+      if (pVgroup == NULL) {
+        mError("db:%s, vgroup: %d is null", pDb->name, v);
+        pthread_mutex_unlock(&pDb->mutex);
+        return TSDB_CODE_MND_APP_ERROR;
+      }
+
+      if (pVgroup->vgId != (uint32_t)vgId) {  // find the target vgId
+        continue;
+      }
+
+      int32_t sid = taosAllocateId(pVgroup->idPool);
+      if (sid <= 0) {
+        int curMaxId = taosIdPoolMaxSize(pVgroup->idPool);
+        if ((taosUpdateIdPool(pVgroup->idPool, curMaxId + 1) < 0) || ((sid = taosAllocateId(pVgroup->idPool)) <= 0)) {
+          mError("msg:%p, app:%p db:%s, no enough sid in vgId:%d", pMsg, pMsg->rpcMsg.ahandle, pDb->name,
+                 pVgroup->vgId);
+          pthread_mutex_unlock(&pDb->mutex);
+          return TSDB_CODE_MND_APP_ERROR;
+        }
+      }
+      mDebug("vgId:%d, alloc tid:%d", pVgroup->vgId, sid);
+
+      *pSid = sid;
+      *ppVgroup = pVgroup;
+      pDb->vgListIndex = v;
+
+      pthread_mutex_unlock(&pDb->mutex);
+      return TSDB_CODE_SUCCESS;
+    }
+    pthread_mutex_unlock(&pDb->mutex);
+    mError("db:%s, vgroup: %d not exist", pDb->name, vgId);
+    return TSDB_CODE_MND_APP_ERROR;
+  }
+
   for (int32_t v = 0; v < pDb->numOfVgroups; ++v) {
     int vgIndex = (v + pDb->vgListIndex) % pDb->numOfVgroups;
     SVgObj *pVgroup = pDb->vgList[vgIndex];

src/plugins/monitor/src/monMain.c

@@ -458,14 +458,18 @@ static void monBuildMonitorSql(char *sql, int32_t cmd) {
              ", expire_time int, timeseries_used int, timeseries_total int)",
              tsMonitorDbName);
   } else if (cmd == MON_CMD_CREATE_MT_RESTFUL) {
+    int usedLen = 0, len = 0;
     int pos = snprintf(sql, SQL_LENGTH,
                        "create table if not exists %s.restful_info(ts timestamp", tsMonitorDbName);
+    usedLen += pos;
     for (int i = 0; i < tListLen(monHttpStatusTable); ++i) {
-      pos += snprintf(sql + pos, SQL_LENGTH, ", `%s(%d)` int",
+      len = snprintf(sql + pos, SQL_LENGTH - usedLen, ", %s_%d int",
                                 monHttpStatusTable[i].name,
                                 monHttpStatusTable[i].code);
+      usedLen += len;
+      pos += len;
     }
-    snprintf(sql + pos, SQL_LENGTH,
+    snprintf(sql + pos, SQL_LENGTH - usedLen,
              ") tags (dnode_id int, dnode_ep binary(%d))",
              TSDB_EP_LEN);
   } else if (cmd == MON_CMD_CREATE_TB_RESTFUL) {

taosadapter @ 47fb0b3e

-Subproject commit 273b5219f8bcc604e43beebc6f1f95abed85170a
+Subproject commit 47fb0b3e627ddadf1ca983c1d75b9a4e44cd98fd

src/query/src/qAggMain.c

@@ -1620,33 +1620,65 @@ static bool first_last_function_setup(SQLFunctionCtx *pCtx, SResultRowCellInfo*
 
 // todo opt for null block
 static void first_function(SQLFunctionCtx *pCtx) {
-  if (pCtx->order == TSDB_ORDER_DESC) {
-    return;
-  }
-  
+  SResultRowCellInfo* pResInfo = GET_RES_INFO(pCtx);
   int32_t notNullElems = 0;
-  
-  // handle the null value
-  for (int32_t i = 0; i < pCtx->size; ++i) {
-    char *data = GET_INPUT_DATA(pCtx, i);
-    if (pCtx->hasNull && isNull(data, pCtx->inputType)) {
-      continue;
-    }
-    
-    memcpy(pCtx->pOutput, data, pCtx->inputBytes);
-    if (pCtx->ptsList != NULL) {
-      TSKEY k = GET_TS_DATA(pCtx, i);
-      DO_UPDATE_TAG_COLUMNS(pCtx, k);
+  int32_t step = 1;
+  int32_t i = 0;
+  bool inputAsc = true;
+
+  // input data come from sub query, input data order equal to sub query order
+  if(pCtx->numOfParams == 3) {
+    if(pCtx->param[2].nType == TSDB_DATA_TYPE_INT && pCtx->param[2].i64 == TSDB_ORDER_DESC) {
+      step = -1;
+      i = pCtx->size - 1;
+      inputAsc = false;
+    }
+  } else if (pCtx->order == TSDB_ORDER_DESC) {
+    return ;
+  }
+
+  if(pCtx->order == TSDB_ORDER_ASC && inputAsc) {
+    for (int32_t m = 0; m < pCtx->size; ++m, i+=step) {
+      char *data = GET_INPUT_DATA(pCtx, i);
+      if (pCtx->hasNull && isNull(data, pCtx->inputType)) {
+        continue;
+      }
+      
+      memcpy(pCtx->pOutput, data, pCtx->inputBytes);
+      if (pCtx->ptsList != NULL) {
+        TSKEY k = GET_TS_DATA(pCtx, i);
+        DO_UPDATE_TAG_COLUMNS(pCtx, k);
+      }
+
+      SResultRowCellInfo *pInfo = GET_RES_INFO(pCtx);
+      pInfo->hasResult = DATA_SET_FLAG;
+      pInfo->complete = true;
+      
+      notNullElems++;
+      break;
     }
+  } else {  // desc order
+    for (int32_t m = 0; m < pCtx->size; ++m, i+=step) {
+      char *data = GET_INPUT_DATA(pCtx, i);
+      if (pCtx->hasNull && isNull(data, pCtx->inputType) && (!pCtx->requireNull)) {
+        continue;
+      }
 
-    SResultRowCellInfo *pInfo = GET_RES_INFO(pCtx);
-    pInfo->hasResult = DATA_SET_FLAG;
-    pInfo->complete = true;
-    
-    notNullElems++;
-    break;
+      TSKEY ts = pCtx->ptsList ? GET_TS_DATA(pCtx, i) : 0;
+
+      char* buf = GET_ROWCELL_INTERBUF(pResInfo);
+      if (pResInfo->hasResult != DATA_SET_FLAG || (*(TSKEY*)buf) > ts) {
+        pResInfo->hasResult = DATA_SET_FLAG;
+        memcpy(pCtx->pOutput, data, pCtx->inputBytes);
+
+        *(TSKEY*)buf = ts;
+        DO_UPDATE_TAG_COLUMNS(pCtx, ts);
+      }
+
+      notNullElems++;
+      break;
+    }
   }
-  
   SET_VAL(pCtx, notNullElems, 1);
 }
 
@@ -1730,16 +1762,23 @@ static void first_dist_func_merge(SQLFunctionCtx *pCtx) {
  *    least one data in this block that is not null.(TODO opt for this case)
  */
 static void last_function(SQLFunctionCtx *pCtx) {
-  if (pCtx->order != pCtx->param[0].i64) {
+  SResultRowCellInfo* pResInfo = GET_RES_INFO(pCtx);
+  int32_t notNullElems = 0;
+  int32_t step = -1;
+  int32_t i = pCtx->size - 1;
+
+  // input data come from sub query, input data order equal to sub query order
+  if(pCtx->numOfParams == 3) {
+    if(pCtx->param[2].nType == TSDB_DATA_TYPE_INT && pCtx->param[2].i64 == TSDB_ORDER_DESC) {
+      step = 1;
+      i = 0;
+    }
+  } else if (pCtx->order != pCtx->param[0].i64) {
     return;
   }
 
-  SResultRowCellInfo* pResInfo = GET_RES_INFO(pCtx);
-
-  int32_t notNullElems = 0;
   if (pCtx->order == TSDB_ORDER_DESC) {
-
-    for (int32_t i = pCtx->size - 1; i >= 0; --i) {
+    for (int32_t m = pCtx->size - 1; m >= 0; --m, i += step) {
       char *data = GET_INPUT_DATA(pCtx, i);
       if (pCtx->hasNull && isNull(data, pCtx->inputType) && (!pCtx->requireNull)) {
         continue;
@@ -1756,7 +1795,7 @@ static void last_function(SQLFunctionCtx *pCtx) {
       break;
     }
   } else {  // ascending order
-    for (int32_t i = pCtx->size - 1; i >= 0; --i) {
+    for (int32_t m = pCtx->size - 1; m >= 0; --m, i += step) {
       char *data = GET_INPUT_DATA(pCtx, i);
       if (pCtx->hasNull && isNull(data, pCtx->inputType) && (!pCtx->requireNull)) {
         continue;

src/query/src/qExecutor.c

@@ -5612,6 +5612,18 @@ static int32_t getTableScanOrder(STableScanInfo* pTableScanInfo) {
   return pTableScanInfo->order;
 }
 
+// check all SQLFunctionCtx is completed
+static bool allCtxCompleted(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx) {
+  // only one false, return false
+  for(int32_t i = 0; i < pOperator->numOfOutput; i++) {
+    if(pCtx[i].resultInfo == NULL)
+      return false;
+    if(!pCtx[i].resultInfo->complete)
+      return false;
+  }
+  return true;
+}
+
 // this is a blocking operator
 static SSDataBlock* doAggregate(void* param, bool* newgroup) {
   SOperatorInfo* pOperator = (SOperatorInfo*) param;
@@ -5650,6 +5662,9 @@ static SSDataBlock* doAggregate(void* param, bool* newgroup) {
     // the pDataBlock are always the same one, no need to call this again
     setInputDataBlock(pOperator, pInfo->pCtx, pBlock, order);
     doAggregateImpl(pOperator, pQueryAttr->window.skey, pInfo->pCtx, pBlock);
+    // if all pCtx is completed, then query should be over
+    if(allCtxCompleted(pOperator, pInfo->pCtx))
+      break;    
   }
 
   doSetOperatorCompleted(pOperator);

src/query/src/qFill.c

@@ -101,7 +101,6 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, void** data, char** srcData
       setNullValueForRow(pFillInfo, data, pFillInfo->numOfCols, index);
     }
   } else if (pFillInfo->type == TSDB_FILL_LINEAR) {
-    // TODO : linear interpolation supports NULL value
     if (prev != NULL && !outOfBound) {
       for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) {
         SFillColInfo* pCol = &pFillInfo->pFillCol[i];
@@ -121,6 +120,10 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, void** data, char** srcData
         bool exceedMax = false, exceedMin = false;
         point1 = (SPoint){.key = *(TSKEY*)(prev), .val = prev + pCol->col.offset};
         point2 = (SPoint){.key = ts, .val = srcData[i] + pFillInfo->index * bytes};
+        if (isNull(point2.val, type)) {
+          setNull(val1, pCol->col.type, bytes);
+          continue;
+        }
         point  = (SPoint){.key = pFillInfo->currentKey, .val = val1};
         taosGetLinearInterpolationVal(&point, type, &point1, &point2, type, &exceedMax, &exceedMin);
       }

tests/develop-test/2-query/ts_2016.py

+###################################################################
+#           Copyright (c) 2021 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+from util.log import *
+from util.cases import *
+from util.sql import *
+
+
+class TDTestCase:
+    def caseDescription(self):
+        '''
+        case1<shenglian zhou>: [TS-2016]fix select * from (select * from empty_stable) 
+        ''' 
+        return
+    
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+        self._conn = conn
+
+    def run(self):
+        print("running {}".format(__file__))
+        tdSql.execute("drop database if exists td12229")
+        tdSql.execute("create database if not exists td12229")
+        tdSql.execute('use td12229')
+
+        tdSql.execute('create stable st(ts timestamp , value int ) tags (ind int)') 
+        tdSql.execute('insert into tb1 using st tags(1) values(now ,1)') 
+        tdSql.execute('insert into tb1 using st tags(1) values(now+1s ,2)') 
+        tdSql.execute('insert into tb1 using st tags(1) values(now+2s ,3)') 
+        tdSql.execute('create stable ste(ts timestamp , value int ) tags (ind int)') 
+        tdSql.query('select * from st')
+        tdSql.checkRows(3)
+        tdSql.query('select * from (select * from ste)')
+        tdSql.checkRows(0)
+        tdSql.query('select * from st union all select * from ste')
+        tdSql.checkRows(3)
+        tdSql.query('select * from ste union all select * from st')
+        tdSql.checkRows(3)
+        tdSql.query('select elapsed(ts) from ste group by tbname union all select elapsed(ts) from st group by tbname;')
+        tdSql.checkRows(1)
+        tdSql.query('select elapsed(ts) from st group by tbname union all select elapsed(ts) from ste group by tbname;')
+        tdSql.checkRows(1)
+        tdSql.execute('drop database td12229')
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/develop-test/fulltest-query.sh

@@ -2,3 +2,4 @@ python3 ./test.py -f 2-query/ts_hidden_column.py
 python3 ./test.py -f 2-query/union-order.py
 python3 ./test.py -f 2-query/session_two_stage.py
 python3 ./test.py -f 2-query/timeline_agg_func_groupby.py
+python3 ./test.py -f 2-query/ts_2016.py

tests/pytest/fulltest-query.sh

@@ -143,7 +143,7 @@ python3 ./test.py -f stream/stream1.py
 python3 ./test.py -f stream/stream2.py
 #python3 ./test.py -f stream/parser.py
 python3 ./test.py -f stream/history.py
-python3 ./test.py -f stream/sys.py
+#python3 ./test.py -f stream/sys.py
 python3 ./test.py -f stream/table_1.py
 python3 ./test.py -f stream/table_n.py
 python3 ./test.py -f stream/showStreamExecTimeisNull.py
@@ -195,4 +195,4 @@ python3 ./test.py -f functions/function_percentile2.py
 python3 ./test.py -f functions/variable_httpDbNameMandatory.py
 ######## system-test
 #python3 ./test.py -f ../system-test/2-query/9-others/TD-11389.py # this case will run when this bug fix  TD-11389
-#======================p5-end===============
\ No newline at end of file
+#======================p5-end===============

tests/pytest/fulltest.sh

@@ -229,7 +229,8 @@ python3 test.py -f tools/taosdemoAllTest/taosdemoTestInsertAllType.py
 python3 test.py -f tools/taosdemoAllTest/taosdemoTestInsertShell.py
 
 #query
-python3 test.py -f query/distinctOneColTb.py
+python3 ./test.py -f query/queryBase.py
+python3 ./test.py -f query/distinctOneColTb.py
 python3 ./test.py -f query/filter.py
 python3 ./test.py -f query/filterCombo.py
 python3 ./test.py -f query/queryNormal.py

tests/pytest/functions/function_derivative.py

@@ -140,6 +140,9 @@ class TDTestCase:
                 tdSql.error("select derivative(col, 1s, 1) from tb2")
                 tdSql.error("select derivative(col, 10s, 0) from tb2")
                 tdSql.error("select derivative(col, 999ms, 0) from tb2")
+                tdSql.error("select derivative(col, now, 0) from tb2") #TD-11983 now not allowed in second param
+                tdSql.error("select derivative(col, now+3d-8h+6m, 0) from tb2") #TD-11983 now not allowed in second param
+                tdSql.error("select derivative(col, 3d-8h+now+6m, 0) from tb2") #TD-11983 now not allowed in second param
 
             tdSql.error("select derivative(col, 10s, 1) from stb")
             tdSql.error("select derivative(col, 10s, 1) from stb group by col")
@@ -150,6 +153,9 @@ class TDTestCase:
             tdSql.error("select derivative(col, 10y, 0) from stb group by tbname")      #TD-10399, DB error: syntax error near '10y, 0) from stb group by tbname;'
             tdSql.error("select derivative(col, -106752d, 0) from stb group by tbname") #TD-10398 overflow tips
             tdSql.error("select derivative(col, 106751991168d, 0) from stb group by tbname") #TD-10398 overflow tips
+            tdSql.error("select derivative(col, now, 1) from stb") #TD-11983 now not allowed in second param
+            tdSql.error("select derivative(col, now+3d-8h+6m, 1) from stb") #TD-11983 now not allowed in second param
+            tdSql.error("select derivative(col, 3d-8h+now+6m, 1) from stb") #TD-11983 now not allowed in second param
 
     def run(self):
         tdSql.prepare()        

tests/pytest/functions/function_elapsed_case.py

@@ -345,7 +345,9 @@ class ElapsedCase:
         tdSql.error("select elapsed(*) from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")
         tdSql.error("select elapsed(ts, '1s') from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")
         tdSql.error("select elapsed(ts, i) from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")
-        #tdSql.error("select elapsed(ts, now) from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")
+        tdSql.error("select elapsed(ts, now) from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")
+        tdSql.error("select elapsed(ts, now-7d+2h-3m+2s) from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")
+        tdSql.error("select elapsed(ts, 7d+2h+now+3m+2s) from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")
         tdSql.error("select elapsed(ts, ts) from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")
         tdSql.error("select elapsed(ts + 1) from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")
         tdSql.error("select elapsed(ts, 1b) from t1 where ts > '2021-11-22 00:00:00' and ts < '2021-11-23 00:00:00'")

tests/pytest/query/queryBase.py

+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+#
+#     query base function test case
+#
+
+import sys
+
+from numpy.lib.function_base import insert
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+import numpy as np
+
+# constant define
+WAITS = 5 # wait seconds
+
+class TDTestCase:
+    #
+    # --------------- main frame -------------------
+    #
+    
+    def caseDescription(self):
+        '''
+        Query moudle base api or keyword test case:
+        case1: api first() last() 
+        case2: none
+        '''
+        return 
+
+    # init
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+        tdSql.prepare()
+        self.create_tables();
+        self.ts = 1500000000000
+
+
+    # run case  
+    def run(self):
+        # insert data
+        self.insert_data("t1", self.ts, 1*10000, 30000, 0);
+        self.insert_data("t2", self.ts, 2*10000, 30000, 100000);
+        self.insert_data("t3", self.ts, 3*10000, 30000, 200000);
+        # test base case
+        self.case_first()
+        tdLog.debug(" QUERYBASE first() api ............ [OK]")
+        # test advance case
+        self.case_last()
+        tdLog.debug(" QUERYBASE last() api  ............ [OK]")
+
+    # stop 
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+    #
+    # --------------- case  -------------------
+    #
+
+    # create table
+    def create_tables(self):
+        # super table
+        tdSql.execute("create table st(ts timestamp, i1 int) tags(area int)");
+        # child table
+        tdSql.execute("create table t1 using st tags(1)");
+        tdSql.execute("create table t2 using st tags(2)");
+        tdSql.execute("create table t3 using st tags(3)");
+        return 
+
+    # insert data1
+    def insert_data(self, tbname, ts_start, count, batch_num, base):
+        pre_insert = "insert into %s values"%tbname
+        sql = pre_insert
+        tdLog.debug("doing insert table %s rows=%d ..."%(tbname, count))
+        for i in range(count):
+            sql += " (%d,%d)"%(ts_start + i*1000, base + i)
+            if i >0 and i%batch_num == 0:
+                tdSql.execute(sql)
+                sql = pre_insert
+        # end sql        
+        if sql != pre_insert:
+            tdSql.execute(sql)
+
+        tdLog.debug("INSERT TABLE DATA ............ [OK]")
+        return
+
+    # first case base 
+    def case_first(self):
+        # 
+        # last base function
+        #
+
+        # base t1 table
+        sql = "select first(*) from t1 where ts>='2017-07-14 12:40:00' order by ts asc;"
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 7200)
+        sql = "select first(*) from t1 where ts>='2017-07-14 12:40:00' order by ts desc;" # desc
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 7200)
+        # super table st
+        sql = "select first(*)  from st where ts>='2017-07-14 11:40:00' and ts<='2017-07-14 12:40:00' and tbname in('t1') order by ts;"
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 3600)
+        sql = "select first(*)  from st where ts>='2017-07-14 11:40:00' and ts<='2017-07-14 12:40:00' and tbname in('t1') order by ts desc;" # desc
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 3600)
+        # sub query
+        sql = "select first(*) from ( select sum(i1)  from st where ts>='2017-07-14 11:40:00' and ts<'2017-07-14 12:40:00' interval(10m) order by ts asc );"
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 187019100)
+        sql = "select first(*) from ( select sum(i1)  from st where ts>='2017-07-14 11:40:00' and ts<'2017-07-14 12:40:00' interval(10m) order by ts desc );" # desc
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 187019100)
+        return 
+
+    # last case
+    def case_last(self):
+        # 
+        #  last base test
+        #
+        
+        # base t1 table
+        sql = "select last(*) from t1 where ts<='2017-07-14 12:40:00' order by ts asc;"
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 7200)
+        sql = "select last(*) from t1 where ts<='2017-07-14 12:40:00' order by ts desc;" # desc
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 7200)        
+        # super table st
+        sql = "select last(*)  from st where ts>='2017-07-14 11:40:00' and ts<='2017-07-14 12:40:00' and tbname in('t1') order by ts;"
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 7200)
+        sql = "select last(*)  from st where ts>='2017-07-14 11:40:00' and ts<='2017-07-14 12:40:00' and tbname in('t1') order by ts desc;" # desc
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 7200)
+        
+        # sub query
+        sql = "select last(*) from ( select sum(i1)  from st where ts>='2017-07-14 11:40:00' and ts<'2017-07-14 12:40:00'  interval(10m) order by ts asc );"
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 192419100)
+        sql = "select last(*) from ( select sum(i1)  from st where ts>='2017-07-14 11:40:00' and ts<'2017-07-14 12:40:00'  interval(10m) order by ts desc );" # desc
+        tdSql.waitedQuery(sql, 1, WAITS)
+        tdSql.checkData(0, 1, 192419100)
+ 
+
+#
+# add case with filename
+#
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file

tests/pytest/query/queryTbnameUpperLower.py

@@ -26,6 +26,8 @@ class TDTestCase:
         '''
         tdCom.cleanTb()
         table_name = tdCom.getLongName(8, "letters_mixed")
+        while table_name.islower():
+            table_name = tdCom.getLongName(8, "letters_mixed")
         table_name_sub = f'{table_name}_sub'
         tb_name_lower = table_name_sub.lower()
         tb_name_upper = table_name_sub.upper()