Merge branch '3.0' of https://github.com/taosdata/TDengine into feat/row_refact

source/common/src/ttime.c

@@ -528,14 +528,14 @@ int32_t convertStringToTimestamp(int16_t type, char *inputData, int64_t timePrec
     }
     taosMemoryFree(newColData);
   } else if (type == TSDB_DATA_TYPE_NCHAR) {
-    newColData = taosMemoryCalloc(1,  charLen / TSDB_NCHAR_SIZE + 1);
+    newColData = taosMemoryCalloc(1,  charLen + TSDB_NCHAR_SIZE);
     int len = taosUcs4ToMbs((TdUcs4 *)varDataVal(inputData), charLen, newColData);
     if (len < 0){
       taosMemoryFree(newColData);
       return TSDB_CODE_FAILED;
     }
     newColData[len] = 0;
-    bool ret = taosParseTime(newColData, timeVal, len + 1, (int32_t)timePrec, tsDaylight);
+    int32_t ret = taosParseTime(newColData, timeVal, len + 1, (int32_t)timePrec, tsDaylight);
     if (ret != TSDB_CODE_SUCCESS) {
       taosMemoryFree(newColData);
       return ret;

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

@@ -155,44 +155,52 @@ int metaTbCursorNext(SMTbCursor *pTbCur) {
 }
 
 SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, bool isinline) {
-  void           *pKey = NULL;
-  void           *pVal = NULL;
-  int             kLen = 0;
-  int             vLen = 0;
-  int             ret;
-  SSkmDbKey       skmDbKey;
-  SSchemaWrapper *pSW = NULL;
-  SSchema        *pSchema = NULL;
-  void           *pBuf;
-  SDecoder        coder = {0};
+  void           *pData = NULL;
+  int             nData = 0;
+  int64_t         version;
+  SSchemaWrapper  schema = {0};
+  SSchemaWrapper *pSchema = NULL;
+  SDecoder        dc = {0};
 
-  // fetch
-  skmDbKey.uid = uid;
-  skmDbKey.sver = sver;
-  pKey = &skmDbKey;
-  kLen = sizeof(skmDbKey);
   metaRLock(pMeta);
-  ret = tdbTbGet(pMeta->pSkmDb, pKey, kLen, &pVal, &vLen);
-  metaULock(pMeta);
-  if (ret < 0) {
-    return NULL;
+  if (sver < 0) {
+    if (tdbTbGet(pMeta->pUidIdx, &uid, sizeof(uid), &pData, &nData) < 0) {
+      goto _err;
     }
 
-  // decode
-  pBuf = pVal;
-  pSW = taosMemoryMalloc(sizeof(SSchemaWrapper));
+    version = *(int64_t *)pData;
+
+    tdbTbGet(pMeta->pTbDb, &(STbDbKey){.uid = uid, .version = version}, sizeof(STbDbKey), &pData, &nData);
 
-  tDecoderInit(&coder, pVal, vLen);
-  tDecodeSSchemaWrapper(&coder, pSW);
-  pSchema = taosMemoryMalloc(sizeof(SSchema) * pSW->nCols);
-  memcpy(pSchema, pSW->pSchema, sizeof(SSchema) * pSW->nCols);
-  tDecoderClear(&coder);
+    SMetaEntry me = {0};
+    tDecoderInit(&dc, pData, nData);
+    metaDecodeEntry(&dc, &me);
+    if (me.type == TSDB_SUPER_TABLE) {
+      pSchema = tCloneSSchemaWrapper(&me.stbEntry.schemaRow);
+    } else if (me.type == TSDB_NORMAL_TABLE) {
+    } else {
+      ASSERT(0);
+    }
+    tDecoderClear(&dc);
+  } else {
+    if (tdbTbGet(pMeta->pSkmDb, &(SSkmDbKey){.uid = uid, .sver = sver}, sizeof(SSkmDbKey), &pData, &nData) < 0) {
+      goto _err;
+    }
 
-  pSW->pSchema = pSchema;
+    tDecoderInit(&dc, pData, nData);
+    tDecodeSSchemaWrapper(&dc, &schema);
+    pSchema = tCloneSSchemaWrapper(&schema);
+    tDecoderClear(&dc);
+  }
 
-  tdbFree(pVal);
+  metaULock(pMeta);
+  tdbFree(pData);
+  return pSchema;
 
-  return pSW;
+_err:
+  metaULock(pMeta);
+  tdbFree(pData);
+  return NULL;
 }
 
 struct SMCtbCursor {

source/libs/function/src/builtins.c

@@ -156,6 +156,14 @@ static int32_t translatePercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
+  //param0
+  SNode* pParamNode0 = nodesListGetNode(pFunc->pParameterList, 0);
+  if (nodeType(pParamNode0) != QUERY_NODE_COLUMN) {
+    return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+                           "The first parameter of PERCENTILE function can only be column");
+  }
+
+  //param1
   SValueNode* pValue = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1);
 
   if (pValue->datum.i < 0 || pValue->datum.i > 100) {
@@ -170,6 +178,7 @@ static int32_t translatePercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
+  //set result type
   pFunc->node.resType = (SDataType){.bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes, .type = TSDB_DATA_TYPE_DOUBLE};
   return TSDB_CODE_SUCCESS;
 }
@@ -188,30 +197,47 @@ static int32_t translateApercentile(SFunctionNode* pFunc, char* pErrBuf, int32_t
     return invaildFuncParaNumErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
-  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
-  if (!IS_NUMERIC_TYPE(para1Type) || !IS_INTEGER_TYPE(para2Type)) {
-    return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
+  //param0
+  SNode* pParamNode0 = nodesListGetNode(pFunc->pParameterList, 0);
+  if (nodeType(pParamNode0) != QUERY_NODE_COLUMN) {
+    return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+                           "The first parameter of APERCENTILE function can only be column");
   }
 
-  SNode* pParamNode = nodesListGetNode(pFunc->pParameterList, 1);
-  if (nodeType(pParamNode) != QUERY_NODE_VALUE) {
+  //param1
+  SNode* pParamNode1 = nodesListGetNode(pFunc->pParameterList, 1);
+  if (nodeType(pParamNode1) != QUERY_NODE_VALUE) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
-  SValueNode* pValue = (SValueNode*)pParamNode;
+  SValueNode* pValue = (SValueNode*)pParamNode1;
   if (pValue->datum.i < 0 || pValue->datum.i > 100) {
     return invaildFuncParaValueErrMsg(pErrBuf, len, pFunc->functionName);
   }
 
   pValue->notReserved = true;
 
+  uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
+  uint8_t para2Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 1))->resType.type;
+  if (!IS_NUMERIC_TYPE(para1Type) || !IS_INTEGER_TYPE(para2Type)) {
+    return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
+  }
+
+  //param2
   if (3 == numOfParams) {
-    SNode* pPara3 = nodesListGetNode(pFunc->pParameterList, 2);
-    if (QUERY_NODE_VALUE != nodeType(pPara3) || !validAperventileAlgo((SValueNode*)pPara3)) {
+    uint8_t para3Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 2))->resType.type;
+    if (!IS_VAR_DATA_TYPE(para3Type)) {
+      return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
+    }
+
+    SNode* pParamNode2 = nodesListGetNode(pFunc->pParameterList, 2);
+    if (QUERY_NODE_VALUE != nodeType(pParamNode2) || !validAperventileAlgo((SValueNode*)pParamNode2)) {
       return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
                              "Third parameter algorithm of apercentile must be 'default' or 't-digest'");
     }
+
+    pValue = (SValueNode*)pParamNode2;
+    pValue->notReserved = true;
   }
 
   pFunc->node.resType = (SDataType){.bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes, .type = TSDB_DATA_TYPE_DOUBLE};

source/libs/function/src/builtinsimpl.c

@@ -1965,7 +1965,7 @@ bool apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResult
   if (pCtx->numOfParams == 2) {
     pInfo->algo = APERCT_ALGO_DEFAULT;
   } else if (pCtx->numOfParams == 3) {
-    pInfo->algo = getApercentileAlgo(pCtx->param[2].param.pz);
+    pInfo->algo = getApercentileAlgo(varDataVal(pCtx->param[2].param.pz));
     if (pInfo->algo == APERCT_ALGO_UNKNOWN) {
       return false;
     }

source/libs/scalar/src/sclfunc.c

@@ -925,11 +925,10 @@ int32_t toUnixtimestampFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
     int32_t ret = convertStringToTimestamp(type, input, timePrec, &timeVal);
     if (ret != TSDB_CODE_SUCCESS) {
       colDataAppendNULL(pOutput->columnData, i);
-      continue;
-    }
-
+    } else {
       colDataAppend(pOutput->columnData, i, (char *)&timeVal, false);
     }
+  }
 
   pOutput->numOfRows = pInput->numOfRows;