Merge pull request #20741 from taosdata/enh/TD-21161-3.0

enh: column/row max length support up to 64K

docs/examples/c/async_query_example.c

@@ -8,7 +8,7 @@
 #include <sys/time.h>
 #include <taos.h>
 
-typedef int16_t VarDataLenT;
+typedef uint16_t VarDataLenT;
 
 #define TSDB_NCHAR_SIZE sizeof(int32_t)
 #define VARSTR_HEADER_SIZE sizeof(VarDataLenT)

docs/examples/c/query_example.c

@@ -6,7 +6,7 @@
 #include <string.h>
 #include <taos.h>
 
-typedef int16_t VarDataLenT;
+typedef uint16_t VarDataLenT;
 
 #define TSDB_NCHAR_SIZE sizeof(int32_t)
 #define VARSTR_HEADER_SIZE sizeof(VarDataLenT)

include/libs/function/function.h

@@ -99,11 +99,11 @@ typedef struct SSubsidiaryResInfo {
 } SSubsidiaryResInfo;
 
 typedef struct SResultDataInfo {
-  int16_t precision;
-  int16_t scale;
-  int16_t type;
-  int16_t bytes;
-  int32_t interBufSize;
+  int16_t  precision;
+  int16_t  scale;
+  int16_t  type;
+  uint16_t bytes;
+  int32_t  interBufSize;
 } SResultDataInfo;
 
 #define GET_RES_INFO(ctx)        ((ctx)->resultInfo)

include/libs/parser/parser.h

@@ -114,7 +114,7 @@ STableDataCxt* smlInitTableDataCtx(SQuery* query, STableMeta* pTableMeta);
 
 int32_t smlBindData(SQuery* handle, bool dataFormat, SArray* tags, SArray* colsSchema, SArray* cols,
                     STableMeta* pTableMeta, char* tableName, const char* sTableName, int32_t sTableNameLen, int32_t ttl,
-                    char* msgBuf, int16_t msgBufLen);
+                    char* msgBuf, int32_t msgBufLen);
 int32_t smlBuildOutput(SQuery* handle, SHashObj* pVgHash);
 int     rawBlockBindData(SQuery *query, STableMeta* pTableMeta, void* data, SVCreateTbReq* pCreateTb, TAOS_FIELD *fields, int numFields, bool needChangeLength);
 

include/util/tdef.h

@@ -232,13 +232,7 @@ typedef enum ELogicConditionType {
 #define TSDB_QUERY_ID_LEN   26
 #define TSDB_TRANS_OPER_LEN 16
 
-/**
- *  In some scenarios uint16_t (0~65535) is used to store the row len.
- *  - Firstly, we use 65531(65535 - 4), as the SDataRow/SKVRow contains 4 bits header.
- *  - Secondly, if all cols are VarDataT type except primary key, we need 4 bits to store the offset, thus
- *    the final value is 65531-(4096-1)*4 = 49151.
- */
-#define TSDB_MAX_BYTES_PER_ROW 49151
+#define TSDB_MAX_BYTES_PER_ROW 65531  // 49151:65531
 #define TSDB_MAX_TAGS_LEN      16384
 #define TSDB_MAX_TAGS          128
 
@@ -410,9 +404,9 @@ typedef enum ELogicConditionType {
 #define TSDB_EXPLAIN_RESULT_ROW_SIZE    (16 * 1024)
 #define TSDB_EXPLAIN_RESULT_COLUMN_NAME "QUERY_PLAN"
 
-#define TSDB_MAX_FIELD_LEN             16384
-#define TSDB_MAX_BINARY_LEN            (TSDB_MAX_FIELD_LEN - TSDB_KEYSIZE)  // keep 16384
-#define TSDB_MAX_NCHAR_LEN             (TSDB_MAX_FIELD_LEN - TSDB_KEYSIZE)  // keep 16384
+#define TSDB_MAX_FIELD_LEN             65519               // 16384:65519
+#define TSDB_MAX_BINARY_LEN            TSDB_MAX_FIELD_LEN  // 16384-8:65519
+#define TSDB_MAX_NCHAR_LEN             TSDB_MAX_FIELD_LEN  // 16384-8:65519
 #define PRIMARYKEY_TIMESTAMP_COL_ID    1
 #define COL_REACH_END(colId, maxColId) ((colId) > (maxColId))
 

source/client/inc/clientInt.h

@@ -361,7 +361,7 @@ void       stopAllRequests(SHashObj* pRequests);
 
 // conn level
 int  hbRegisterConn(SAppHbMgr* pAppHbMgr, int64_t tscRefId, int64_t clusterId, int8_t connType);
-void hbDeregisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, void* param);
+void hbDeregisterConn(STscObj* pTscObj, SClientHbKey connKey);
 
 typedef struct SSqlCallbackWrapper {
   SParseContext* pParseCtx;

source/client/src/clientEnv.c

@@ -244,7 +244,7 @@ void destroyTscObj(void *pObj) {
   tscTrace("begin to destroy tscObj %" PRIx64 " p:%p", tscId, pTscObj);
 
   SClientHbKey connKey = {.tscRid = pTscObj->id, .connType = pTscObj->connType};
-  hbDeregisterConn(pTscObj->pAppInfo->pAppHbMgr, connKey, pTscObj->passInfo.fp);
+  hbDeregisterConn(pTscObj, connKey);
 
   destroyAllRequests(pTscObj->pRequests);
   taosHashCleanup(pTscObj->pRequests);

source/client/src/clientHb.c

@@ -994,6 +994,7 @@ SAppHbMgr *appHbMgrInit(SAppInstInfo *pAppInstInfo, char *key) {
   // init stat
   pAppHbMgr->startTime = taosGetTimestampMs();
   pAppHbMgr->connKeyCnt = 0;
+  pAppHbMgr->passKeyCnt = 0;
   pAppHbMgr->reportCnt = 0;
   pAppHbMgr->reportBytes = 0;
   pAppHbMgr->key = taosStrdup(key);
@@ -1154,7 +1155,8 @@ int hbRegisterConn(SAppHbMgr *pAppHbMgr, int64_t tscRefId, int64_t clusterId, in
   }
 }
 
-void hbDeregisterConn(SAppHbMgr *pAppHbMgr, SClientHbKey connKey, void *param) {
+void hbDeregisterConn(STscObj *pTscObj, SClientHbKey connKey) {
+  SAppHbMgr    *pAppHbMgr = pTscObj->pAppInfo->pAppHbMgr;
   SClientHbReq *pReq = taosHashAcquire(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
   if (pReq) {
     tFreeClientHbReq(pReq);
@@ -1167,7 +1169,10 @@ void hbDeregisterConn(SAppHbMgr *pAppHbMgr, SClientHbKey connKey, void *param) {
   }
 
   atomic_sub_fetch_32(&pAppHbMgr->connKeyCnt, 1);
-  if (param) {
+
+  taosThreadMutexLock(&pTscObj->mutex);
+  if (pTscObj->passInfo.fp) {
     atomic_sub_fetch_32(&pAppHbMgr->passKeyCnt, 1);
   }
-}
+  taosThreadMutexUnlock(&pTscObj->mutex);
+}
\ No newline at end of file

source/client/src/clientMain.c

@@ -134,11 +134,15 @@ int taos_set_notify_cb(TAOS *taos, __taos_notify_fn_t fp, void *param, int type)
 
   switch (type) {
     case TAOS_NOTIFY_PASSVER: {
-      pObj->passInfo.fp = fp;
-      pObj->passInfo.param = param;
-      if (fp) {
+      taosThreadMutexLock(&pObj->mutex);
+      if (fp && !pObj->passInfo.fp) {
         atomic_add_fetch_32(&pObj->pAppInfo->pAppHbMgr->passKeyCnt, 1);
+      } else if (!fp && pObj->passInfo.fp) {
+        atomic_sub_fetch_32(&pObj->pAppInfo->pAppHbMgr->passKeyCnt, 1);
       }
+      pObj->passInfo.fp = fp;
+      pObj->passInfo.param = param;
+      taosThreadMutexUnlock(&pObj->mutex);
       break;
     }
     default: {

source/client/src/clientSml.c

@@ -558,15 +558,21 @@ static int32_t smlGenerateSchemaAction(SSchema *colField, SHashObj *colHash, SSm
   return 0;
 }
 
+#define BOUNDARY 1024
 static int32_t smlFindNearestPowerOf2(int32_t length, uint8_t type) {
   int32_t result = 1;
-  while (result <= length) {
-    result *= 2;
+  if (length >= BOUNDARY){
+    result = length;
+  }else{
+    while (result <= length) {
+      result <<= 1;
+    }
   }
+
   if (type == TSDB_DATA_TYPE_BINARY && result > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) {
     result = TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE;
-  } else if (type == TSDB_DATA_TYPE_NCHAR && result > (TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
-    result = (TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
+  } else if (type == TSDB_DATA_TYPE_NCHAR && result > (TSDB_MAX_NCHAR_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
+    result = (TSDB_MAX_NCHAR_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;
   }
 
   if (type == TSDB_DATA_TYPE_NCHAR) {
@@ -649,6 +655,17 @@ static int32_t smlBuildFieldsList(SSmlHandle *info, SSchema *schemaField, SHashO
       field->bytes = getBytes(kv->type, kv->length);
     }
   }
+
+  int32_t maxLen = isTag ? TSDB_MAX_TAGS_LEN : TSDB_MAX_BYTES_PER_ROW;
+  int32_t len = 0;
+  for (int j = 0; j < taosArrayGetSize(results); ++j) {
+    SField *field = taosArrayGet(results, j);
+    len += field->bytes;
+  }
+  if (len > maxLen) {
+    return isTag ? TSDB_CODE_PAR_INVALID_TAGS_LENGTH : TSDB_CODE_PAR_INVALID_ROW_LENGTH;
+  }
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -781,11 +798,15 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
       code = smlBuildFieldsList(info, NULL, NULL, sTableData->tags, pTags, 0, true);
       if (code != TSDB_CODE_SUCCESS) {
         uError("SML:0x%" PRIx64 " smlBuildFieldsList tag1 failed. %s", info->id, pName.tname);
+        taosArrayDestroy(pColumns);
+        taosArrayDestroy(pTags);
         goto end;
       }
       code = smlBuildFieldsList(info, NULL, NULL, sTableData->cols, pColumns, 0, false);
       if (code != TSDB_CODE_SUCCESS) {
         uError("SML:0x%" PRIx64 " smlBuildFieldsList col1 failed. %s", info->id, pName.tname);
+        taosArrayDestroy(pColumns);
+        taosArrayDestroy(pTags);
         goto end;
       }
       code = smlSendMetaMsg(info, &pName, pColumns, pTags, NULL, SCHEMA_ACTION_CREATE_STABLE);
@@ -837,6 +858,23 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
                                   pTableMeta->tableInfo.numOfColumns, true);
         if (code != TSDB_CODE_SUCCESS) {
           uError("SML:0x%" PRIx64 " smlBuildFieldsList tag2 failed. %s", info->id, pName.tname);
+          taosArrayDestroy(pColumns);
+          taosArrayDestroy(pTags);
+          goto end;
+        }
+
+        if (taosArrayGetSize(pTags) + pTableMeta->tableInfo.numOfColumns > TSDB_MAX_COLUMNS) {
+          uError("SML:0x%" PRIx64 " too many columns than 4096", info->id);
+          code = TSDB_CODE_PAR_TOO_MANY_COLUMNS;
+          taosArrayDestroy(pColumns);
+          taosArrayDestroy(pTags);
+          goto end;
+        }
+        if (taosArrayGetSize(pTags) > TSDB_MAX_TAGS) {
+          uError("SML:0x%" PRIx64 " too many tags than 128", info->id);
+          code = TSDB_CODE_PAR_INVALID_TAGS_NUM;
+          taosArrayDestroy(pColumns);
+          taosArrayDestroy(pTags);
           goto end;
         }
 
@@ -891,6 +929,16 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
                                   pTableMeta->tableInfo.numOfColumns, false);
         if (code != TSDB_CODE_SUCCESS) {
           uError("SML:0x%" PRIx64 " smlBuildFieldsList col2 failed. %s", info->id, pName.tname);
+          taosArrayDestroy(pColumns);
+          taosArrayDestroy(pTags);
+          goto end;
+        }
+
+        if (taosArrayGetSize(pColumns) + pTableMeta->tableInfo.numOfTags > TSDB_MAX_COLUMNS) {
+          uError("SML:0x%" PRIx64 " too many columns than 4096", info->id);
+          code = TSDB_CODE_PAR_TOO_MANY_COLUMNS;
+          taosArrayDestroy(pColumns);
+          taosArrayDestroy(pTags);
           goto end;
         }
 
@@ -1498,8 +1546,11 @@ static int smlProcess(SSmlHandle *info, char *lines[], char *rawLine, char *rawL
 
   do {
     code = smlModifyDBSchemas(info);
-    if (code == 0) break;
-    taosMsleep(500);
+    if (code == 0 || code == TSDB_CODE_SML_INVALID_DATA || code == TSDB_CODE_PAR_TOO_MANY_COLUMNS ||
+        code == TSDB_CODE_PAR_INVALID_TAGS_NUM || code == TSDB_CODE_PAR_INVALID_ROW_LENGTH ||
+        code == TSDB_CODE_PAR_INVALID_TAGS_LENGTH)
+      break;
+    taosMsleep(100);
     uInfo("SML:0x%" PRIx64 " smlModifyDBSchemas retry code:%s, times:%d", info->id, tstrerror(code), retryNum);
   } while (retryNum++ < taosHashGetSize(info->superTables) * MAX_RETRY_TIMES);
 

source/client/src/clientSmlJson.c

@@ -575,7 +575,7 @@ static int32_t smlConvertJSONString(SSmlKv *pVal, char *typeStr, cJSON *value) {
     uError("OTD:invalid type(%s) for JSON String", typeStr);
     return TSDB_CODE_TSC_INVALID_JSON_TYPE;
   }
-  pVal->length = (int16_t)strlen(value->valuestring);
+  pVal->length = strlen(value->valuestring);
 
   if (pVal->type == TSDB_DATA_TYPE_BINARY && pVal->length > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) {
     return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;

source/client/src/clientSmlLine.c

@@ -236,7 +236,7 @@ static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd, SSmlLin
       PROCESS_SLASH(value, valueLen)
     }
 
-    if (unlikely(valueLen > (TSDB_MAX_NCHAR_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)) {
+    if (unlikely(valueLen > (TSDB_MAX_TAGS_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)) {
       return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
     }
 

source/client/src/clientSmlTelnet.c

@@ -158,7 +158,7 @@ static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SS
       return TSDB_CODE_TSC_INVALID_VALUE;
     }
 
-    if (unlikely(valueLen > (TSDB_MAX_NCHAR_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)) {
+    if (unlikely(valueLen > (TSDB_MAX_TAGS_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)) {
       return TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN;
     }
 

source/dnode/mnode/impl/src/mndFunc.c

@@ -556,7 +556,7 @@ RETRIEVE_FUNC_OVER:
   return code;
 }
 
-static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t len) {
+static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int32_t len) {
   char *msg = "unknown";
   if (type >= sizeof(tDataTypes) / sizeof(tDataTypes[0])) {
     return msg;

source/libs/executor/src/timewindowoperator.c

@@ -1114,7 +1114,7 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI
 
   bool    masterScan = true;
   int32_t numOfOutput = pOperator->exprSupp.numOfExprs;
-  int16_t bytes = pStateColInfoData->info.bytes;
+  int32_t bytes = pStateColInfoData->info.bytes;
 
   SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pInfo->tsSlotId);
   TSKEY*           tsList = (TSKEY*)pColInfoData->pData;

source/libs/function/inc/tpercentile.h

@@ -53,7 +53,7 @@ typedef int32_t (*__perc_hash_func_t)(struct tMemBucket *pBucket, const void *va
 typedef struct tMemBucket {
   int16_t            numOfSlots;
   int16_t            type;
-  int16_t            bytes;
+  int32_t            bytes;
   int32_t            total;
   int32_t            elemPerPage;  // number of elements for each object
   int32_t            maxCapacity;  // maximum allowed number of elements that can be sort directly to get the result
@@ -67,7 +67,7 @@ typedef struct tMemBucket {
   SHashObj          *groupPagesMap;  // disk page map for different groups;
 } tMemBucket;
 
-tMemBucket *tMemBucketCreate(int16_t nElemSize, int16_t dataType, double minval, double maxval);
+tMemBucket *tMemBucketCreate(int32_t nElemSize, int16_t dataType, double minval, double maxval);
 
 void tMemBucketDestroy(tMemBucket *pBucket);
 

source/libs/function/src/builtinsimpl.c

@@ -196,11 +196,11 @@ typedef struct SMavgInfo {
 } SMavgInfo;
 
 typedef struct SSampleInfo {
-  int32_t samples;
-  int32_t totalPoints;
-  int32_t numSampled;
-  uint8_t colType;
-  int16_t colBytes;
+  int32_t  samples;
+  int32_t  totalPoints;
+  int32_t  numSampled;
+  uint8_t  colType;
+  uint16_t colBytes;
 
   STuplePos nullTuplePos;
   bool      nullTupleSaved;
@@ -220,7 +220,7 @@ typedef struct STailInfo {
   int32_t     numAdded;
   int32_t     offset;
   uint8_t     colType;
-  int16_t     colBytes;
+  uint16_t    colBytes;
   STailItem** pItems;
 } STailInfo;
 
@@ -233,7 +233,7 @@ typedef struct SUniqueItem {
 typedef struct SUniqueInfo {
   int32_t   numOfPoints;
   uint8_t   colType;
-  int16_t   colBytes;
+  uint16_t  colBytes;
   bool      hasNull;  // null is not hashable, handle separately
   SHashObj* pHash;
   char      pItems[];
@@ -247,13 +247,13 @@ typedef struct SModeItem {
 
 typedef struct SModeInfo {
   uint8_t   colType;
-  int16_t   colBytes;
+  uint16_t  colBytes;
   SHashObj* pHash;
 
   STuplePos nullTuplePos;
   bool      nullTupleSaved;
 
-  char*     buf; // serialize data buffer
+  char* buf;  // serialize data buffer
 } SModeInfo;
 
 typedef struct SDerivInfo {

source/libs/function/src/tpercentile.c

@@ -236,7 +236,7 @@ static void resetSlotInfo(tMemBucket *pBucket) {
   }
 }
 
-tMemBucket *tMemBucketCreate(int16_t nElemSize, int16_t dataType, double minval, double maxval) {
+tMemBucket *tMemBucketCreate(int32_t nElemSize, int16_t dataType, double minval, double maxval) {
   tMemBucket *pBucket = (tMemBucket *)taosMemoryCalloc(1, sizeof(tMemBucket));
   if (pBucket == NULL) {
     return NULL;

source/libs/parser/src/parAstCreater.c

@@ -1208,7 +1208,7 @@ SDataType createDataType(uint8_t type) {
 }
 
 SDataType createVarLenDataType(uint8_t type, const SToken* pLen) {
-  SDataType dt = {.type = type, .precision = 0, .scale = 0, .bytes = taosStr2Int16(pLen->z, NULL, 10)};
+  SDataType dt = {.type = type, .precision = 0, .scale = 0, .bytes = taosStr2Int32(pLen->z, NULL, 10)};
   return dt;
 }
 

source/libs/parser/src/parInsertSml.c

@@ -250,7 +250,7 @@ end:
 
 int32_t smlBindData(SQuery* query, bool dataFormat, SArray* tags, SArray* colsSchema, SArray* cols,
                     STableMeta* pTableMeta, char* tableName, const char* sTableName, int32_t sTableNameLen, int32_t ttl,
-                    char* msgBuf, int16_t msgBufLen) {
+                    char* msgBuf, int32_t msgBufLen) {
   SMsgBuf pBuf = {.buf = msgBuf, .len = msgBufLen};
 
   SSchema*       pTagsSchema = getTableTagSchema(pTableMeta);

source/libs/parser/src/parTranslater.c

@@ -4498,8 +4498,8 @@ static int32_t checkTableTagsSchema(STranslateContext* pCxt, SHashObj* pHash, SN
       code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_ONLY_ONE_JSON_TAG);
     }
     if (TSDB_CODE_SUCCESS == code) {
-      if ((TSDB_DATA_TYPE_VARCHAR == pTag->dataType.type && calcTypeBytes(pTag->dataType) > TSDB_MAX_BINARY_LEN) ||
-          (TSDB_DATA_TYPE_NCHAR == pTag->dataType.type && calcTypeBytes(pTag->dataType) > TSDB_MAX_NCHAR_LEN)) {
+      if ((TSDB_DATA_TYPE_VARCHAR == pTag->dataType.type && calcTypeBytes(pTag->dataType) > TSDB_MAX_TAGS_LEN) ||
+          (TSDB_DATA_TYPE_NCHAR == pTag->dataType.type && calcTypeBytes(pTag->dataType) > TSDB_MAX_TAGS_LEN)) {
         code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN);
       }
     }
@@ -5245,7 +5245,7 @@ static int32_t checkAlterSuperTableBySchema(STranslateContext* pCxt, SAlterTable
     }
 
     if (TSDB_ALTER_TABLE_UPDATE_TAG_BYTES == pStmt->alterType) {
-      if (calcTypeBytes(pStmt->dataType) > TSDB_MAX_FIELD_LEN) {
+      if (calcTypeBytes(pStmt->dataType) > TSDB_MAX_TAGS_LEN) {
         return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN);
       }
 

source/libs/scalar/src/sclfunc.c

@@ -12,7 +12,7 @@ typedef double (*_double_fn)(double);
 typedef double (*_double_fn_2)(double, double);
 typedef int (*_conv_fn)(int);
 typedef void (*_trim_fn)(char *, char *, int32_t, int32_t);
-typedef int16_t (*_len_fn)(char *, int32_t);
+typedef uint16_t (*_len_fn)(char *, int32_t);
 
 /** Math functions **/
 static double tlog(double v) { return log(v); }
@@ -286,9 +286,9 @@ static int32_t doScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
 }
 
 /** String functions **/
-static int16_t tlength(char *input, int32_t type) { return varDataLen(input); }
+static VarDataLenT tlength(char *input, int32_t type) { return varDataLen(input); }
 
-static int16_t tcharlength(char *input, int32_t type) {
+static VarDataLenT tcharlength(char *input, int32_t type) {
   if (type == TSDB_DATA_TYPE_VARCHAR) {
     return varDataLen(input);
   } else {  // NCHAR
@@ -377,7 +377,7 @@ static int32_t doLengthFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t concatCopyHelper(const char *input, char *output, bool hasNchar, int32_t type, int16_t *dataLen) {
+static int32_t concatCopyHelper(const char *input, char *output, bool hasNchar, int32_t type, VarDataLenT *dataLen) {
   if (hasNchar && type == TSDB_DATA_TYPE_VARCHAR) {
     TdUcs4 *newBuf = taosMemoryCalloc((varDataLen(input) + 1) * TSDB_NCHAR_SIZE, 1);
     int32_t len = varDataLen(input);
@@ -457,7 +457,7 @@ int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
       continue;
     }
 
-    int16_t dataLen = 0;
+    VarDataLenT dataLen = 0;
     for (int32_t i = 0; i < inputNum; ++i) {
       int32_t rowIdx = (pInput[i].numOfRows == 1) ? 0 : k;
       input[i] = colDataGetData(pInputData[i], rowIdx);
@@ -526,8 +526,8 @@ int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
       continue;
     }
 
-    int16_t dataLen = 0;
-    bool    hasNull = false;
+    VarDataLenT dataLen = 0;
+    bool        hasNull = false;
     for (int32_t i = 1; i < inputNum; ++i) {
       if (colDataIsNull_s(pInputData[i], k) || IS_NULL_TYPE(GET_PARAM_TYPE(&pInput[i]))) {
         hasNull = true;
@@ -695,7 +695,7 @@ int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 /** Conversion functions **/
 int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   int16_t inputType = GET_PARAM_TYPE(&pInput[0]);
-  int16_t inputLen = GET_PARAM_BYTES(&pInput[0]);
+  int32_t inputLen = GET_PARAM_BYTES(&pInput[0]);
   int16_t outputType = GET_PARAM_TYPE(&pOutput[0]);
   int64_t outputLen = GET_PARAM_BYTES(&pOutput[0]);
 

source/libs/tdb/src/db/tdbBtree.c

@@ -1814,6 +1814,11 @@ int tdbBtreeNext(SBTC *pBtc, void **ppKey, int *kLen, void **ppVal, int *vLen) {
 
     *ppVal = pVal;
     *vLen = cd.vLen;
+  } else {
+    if (TDB_CELLDECODER_FREE_VAL(&cd)) {
+      tdbTrace("tdb/btree-next2 decoder: %p pVal free: %p", &cd, cd.pVal);
+      tdbFree(cd.pVal);
+    }
   }
 
   ret = tdbBtcMoveToNext(pBtc);

source/util/src/tcompare.c

@@ -1241,7 +1241,7 @@ int32_t taosArrayCompareString(const void *a, const void *b) {
 int32_t comparestrPatternMatch(const void *pLeft, const void *pRight) {
   SPatternCompareInfo pInfo = PATTERN_COMPARE_INFO_INITIALIZER;
 
-  ASSERT(varDataLen(pRight) <= TSDB_MAX_FIELD_LEN);
+  ASSERT(varDataTLen(pRight) <= TSDB_MAX_FIELD_LEN);
   size_t pLen = varDataLen(pRight);
   size_t sz = varDataLen(pLeft);
 

tests/parallel_test/cases.task

@@ -338,6 +338,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/delete_childtable.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/delete_normaltable.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/keep_expired.py
+,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/stmt_error.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/drop.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 1-insert/drop.py -N 3 -M 3 -i False -n 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/join2.py

tests/script/api/passwdTest.c

@@ -33,8 +33,7 @@
 #define nUser    10
 #define USER_LEN 24
 
-void Test(TAOS *taos, char *qstr);
-void createUers(TAOS *taos, const char *host, char *qstr);
+void createUsers(TAOS *taos, const char *host, char *qstr);
 void passVerTestMulti(const char *host, char *qstr);
 
 int   nPassVerNotified = 0;
@@ -98,14 +97,14 @@ int main(int argc, char *argv[]) {
     printf("failed to connect to server, reason:%s\n", "null taos" /*taos_errstr(taos)*/);
     exit(1);
   }
-  createUers(taos, argv[1], qstr);
+  createUsers(taos, argv[1], qstr);
   passVerTestMulti(argv[1], qstr);
 
   taos_close(taos);
   taos_cleanup();
 }
 
-void createUers(TAOS *taos, const char *host, char *qstr) {
+void createUsers(TAOS *taos, const char *host, char *qstr) {
   // users
   for (int i = 0; i < nUser; ++i) {
     sprintf(users[i], "user%d", i);

tests/system-test/1-insert/boundary.py

@@ -166,6 +166,61 @@ class TDTestCase:
         else:
             tdLog.exit("error info is not true")
         tdSql.execute('drop database db')
+
+    def row_col_tag_maxlen_check(self):
+        tdSql.prepare()
+        tdSql.execute('use db')
+        tdSql.execute('create table if not exists stb1 (ts timestamp, c1 int,c2 binary(1000)) tags (city binary(16382))')
+        tdSql.error('create table if not exists stb1 (ts timestamp, c1 int,c2 binary(1000)) tags (city binary(16383))')
+        tdSql.execute('create table if not exists stb2 (ts timestamp, c0 tinyint, c1 int, c2 nchar(16379)) tags (city binary(16382))')
+        tdSql.error('create table if not exists stb2 (ts timestamp, c0 smallint, c1 int, c2 nchar(16379)) tags (city binary(16382))')
+        tdSql.execute('create table if not exists stb3 (ts timestamp, c1 int, c2 binary(65517)) tags (city binary(16382))')
+        tdSql.error('create table if not exists stb3 (ts timestamp, c0 bool, c1 int, c2 binary(65517)) tags (city binary(16382))')
+        # prepare the column and tag data
+        char100='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN0123456789'
+        tag_max_16382=''
+        binary_max_65517 = ''
+        nchar_max_16379=''
+        for num in range(163):
+            nchar_max_16379 += char100
+            for num in range(4):
+                binary_max_65517 += char100
+        
+        nchar_max_16379 += '0123456789012345678901234567890123456789012345678901234567890123456789012345678'
+        tag_max_16382 = nchar_max_16379
+        tag_max_16382 += '9ab'
+
+        for num in range(3):
+            binary_max_65517 += char100
+        binary_max_65517 += '01234567890123456'
+
+        # insert/query and check
+        tdSql.execute(f"create table ct1 using stb1 tags('{tag_max_16382}')")
+        tdSql.execute(f"create table ct2 using stb2 tags('{tag_max_16382}')")
+        tdSql.execute(f"create table ct3 using stb3 tags('{tag_max_16382}')")
+        tdSql.execute(f"insert into ct1 values (now,1,'nchar_max_16379')")
+        tdSql.execute(f"insert into ct2 values (now,1,1,'{nchar_max_16379}')")
+        tdSql.execute(f"insert into ct3 values (now,1,'{binary_max_65517}')")
+
+        tdSql.query("select * from stb1")
+        tdSql.checkEqual(tdSql.queryResult[0][3],tag_max_16382)
+
+        tdSql.query("select * from ct2")
+        tdSql.checkEqual(tdSql.queryResult[0][3],nchar_max_16379)
+
+        tdSql.query("select * from stb2")
+        tdSql.checkEqual(tdSql.queryResult[0][3],nchar_max_16379)
+        tdSql.checkEqual(tdSql.queryResult[0][4],tag_max_16382)
+
+        tdSql.query("select * from ct3")
+        tdSql.checkEqual(tdSql.queryResult[0][2],binary_max_65517)
+
+        tdSql.query("select * from stb3")
+        tdSql.checkEqual(tdSql.queryResult[0][2],binary_max_65517)
+        tdSql.checkEqual(tdSql.queryResult[0][3],tag_max_16382)
+
+        tdSql.execute('drop database db')
+
     def run(self):
         self.dbname_length_check()
         self.tbname_length_check()
@@ -174,6 +229,7 @@ class TDTestCase:
         self.username_length_check()
         self.password_length_check()
         self.sql_length_check()
+        self.row_col_tag_maxlen_check()
 
     def stop(self):
         tdSql.close()

tests/system-test/1-insert/influxdb_line_taosc_insert.py

@@ -439,7 +439,7 @@ class TDTestCase:
         for input_sql in [self.genLongSql(127, 1)[0], self.genLongSql(1, 4093)[0]]:
             tdCom.cleanTb(dbname="test")
             self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
-        for input_sql in [self.genLongSql(129, 1)[0], self.genLongSql(1, 4095)[0]]:
+        for input_sql in [self.genLongSql(128, 1)[0], self.genLongSql(1, 4094)[0]]:
             tdCom.cleanTb(dbname="test")
             try:
                 self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
@@ -578,10 +578,16 @@ class TDTestCase:
 
         # binary
         stb_name = tdCom.getLongName(7, "letters")
-        input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(16374, "letters")}" c0=f 1626006833639000000'
+        input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(4091, "letters")}" c0=f 1626006833639000000'
         self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
 
-        input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(16375, "letters")}" c0=f 1626006833639000000'
+        input_sql = f'{stb_name},t0="a",t1="{tdCom.getLongName(4088, "letters")}" c0=f 1626006833639000000'
+        try:
+            self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        except SchemalessError as err:
+            tdSql.checkNotEqual(err.errno, 0)
+
+        input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(4092, "letters")}" c0=f 1626006833639000000'
         try:
             self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
         except SchemalessError as err:
@@ -590,10 +596,10 @@ class TDTestCase:
         # nchar
         # * legal nchar could not be larger than 16374/4
         stb_name = tdCom.getLongName(7, "letters")
-        input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4093, "letters")}" c0=f 1626006833639000000'
+        input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4090, "letters")}" c0=f 1626006833639000000'
         self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
 
-        input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4094, "letters")}" c0=f 1626006833639000000'
+        input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4091, "letters")}" c0=f 1626006833639000000'
         try:
             self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
         except SchemalessError as err:
@@ -672,28 +678,34 @@ class TDTestCase:
             except SchemalessError as err:
                 tdSql.checkNotEqual(err.errno, 0)
 
-        # # # binary
-        # stb_name = tdCom.getLongName(7, "letters")
-        # input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(16374, "letters")}" 1626006833639000000'
-        # self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        # binary
+        stb_name = tdCom.getLongName(7, "letters")
+        input_sql = f'{stb_name},t0=t c0=1i32,c1="{tdCom.getLongName(65517, "letters")}" 1626006833639000000'
+        self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
 
-        # input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(16375, "letters")}" 1626006833639000000'
-        # try:
-        #     self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
-        # except SchemalessError as err:
-        #     tdSql.checkNotEqual(err.errno, 0)
+        input_sql = f'{stb_name},t0=t c0=1i32,c1="{tdCom.getLongName(65517, "letters")},c2=f" 1626006833639000000'
+        try:
+            self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        except SchemalessError as err:
+            tdSql.checkNotEqual(err.errno, 0)
 
-        # # nchar
-        # # * legal nchar could not be larger than 16374/4
-        # stb_name = tdCom.getLongName(7, "letters")
-        # input_sql = f'{stb_name},t0=t c0=f,c1=L"{tdCom.getLongName(4093, "letters")}" 1626006833639000000'
-        # self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(65518, "letters")}" 1626006833639000000'
+        try:
+            self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        except SchemalessError as err:
+            tdSql.checkNotEqual(err.errno, 0)
 
-        # input_sql = f'{stb_name},t0=t c0=f,c1=L"{tdCom.getLongName(4094, "letters")}" 1626006833639000000'
-        # try:
-        #     self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
-        # except SchemalessError as err:
-        #     tdSql.checkNotEqual(err.errno, 0)
+        # nchar
+        # * legal nchar could not be larger than 16374/4
+        stb_name = tdCom.getLongName(7, "letters")
+        input_sql = f'{stb_name},t0=t c0=1i32,c1=L"{tdCom.getLongName(16379, "letters")}",c2=f 1626006833639000000'
+        self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+
+        input_sql = f'{stb_name},t0=t c0=1i32,c1=L"{tdCom.getLongName(16380, "letters")}",c2=1i16 1626006833639000000'
+        try:
+            self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        except SchemalessError as err:
+            tdSql.checkNotEqual(err.errno, 0)
 
     def tagColIllegalValueCheckCase(self):
 
@@ -884,7 +896,7 @@ class TDTestCase:
         tdSql.checkRows(2)
         tdSql.checkNotEqual(tb_name1, tb_name3)
 
-    # * tag binary max is 16384, col+ts binary max  49151
+    # * tag binary max is 16384-2, col+ts binary max 65531
     def tagColBinaryMaxLengthCheckCase(self):
         """
             every binary and nchar must be length+2
@@ -896,35 +908,59 @@ class TDTestCase:
         self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
 
         # * every binary and nchar must be length+2, so here is two tag, max length could not larger than 16384-2*2
-        input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(16374, "letters")}",t2="{tdCom.getLongName(5, "letters")}" c0=f 1626006833639000000'
+        stb_name = tdCom.getLongName(8, "letters")
+        input_sql = f'{stb_name},t0=f,t1="{tdCom.getLongName(4091, "letters")}", c0=f 1626006833639000000'
         self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
 
         tdSql.query(f"select * from {stb_name}")
-        tdSql.checkRows(2)
-        input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(16374, "letters")}",t2="{tdCom.getLongName(6, "letters")}" c0=f 1626006833639000000'
+        tdSql.checkRows(1)
+        
+        input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(4092, "letters")}", c0=f 1626006833639000000'
         try:
             self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
             raise Exception("should not reach here")
         except SchemalessError as err:
             tdSql.checkNotEqual(err.errno, 0)
         tdSql.query(f"select * from {stb_name}")
-        tdSql.checkRows(2)
+        tdSql.checkRows(1)
 
+        
+        stb_name = tdCom.getLongName(9, "letters")
         # # * check col，col+ts max in describe ---> 16143
-        input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(16374, "letters")}",c2="{tdCom.getLongName(16374, "letters")}",c3="{tdCom.getLongName(16374, "letters")}",c4="{tdCom.getLongName(12, "letters")}" 1626006833639000000'
+        input_sql = f'{stb_name},t0=t c0=1i32,c1="{tdCom.getLongName(65517, "letters")}" 1626006833639000000'
         self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
 
+        input_sql = f'{stb_name},t0=t c0=1i32,c1="{tdCom.getLongName(65517, "letters")}",c2=f 1626006833639000000'
+        try:
+            self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        except SchemalessError as err:
+            tdSql.checkNotEqual(err.errno, 0)
+
         tdSql.query(f"select * from {stb_name}")
-        tdSql.checkRows(3)
-        input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(16374, "letters")}",c2="{tdCom.getLongName(16374, "letters")}",c3="{tdCom.getLongName(16374, "letters")}",c4="{tdCom.getLongName(13, "letters")}" 1626006833639000000'
+        tdSql.checkRows(1)
+
+
+        stb_name = tdCom.getLongName(10, "letters")        
+        input_sql = f'{stb_name},t0=t c0=1i16,c1="{tdCom.getLongName(49133, "letters")}",c2="{tdCom.getLongName(16384, "letters")}" 1626006833639000000'
+        self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        
+        input_sql = f'{stb_name},t0=t c0=1i16,c1="{tdCom.getLongName(49133, "letters")}",c2="{tdCom.getLongName(16384, "letters")},c3=t" 1626006833639000000'
         try:
             self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
         except SchemalessError as err:
             tdSql.checkNotEqual(err.errno, 0)
+
         tdSql.query(f"select * from {stb_name}")
-        tdSql.checkRows(3)
+        tdSql.checkRows(1)
+
+        input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(16374, "letters")}",c2="{tdCom.getLongName(16374, "letters")}",c3="{tdCom.getLongName(16374, "letters")}",c4="{tdCom.getLongName(13, "letters")}" 1626006833639000000'
+        try:
+            self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        except SchemalessError as err:
+            tdSql.checkNotEqual(err.errno, 0)
 
-    # * tag nchar max is 16374/4, col+ts nchar max  49151
+
+    # * tag nchar max is (16384-2)/4, col+ts nchar max 65531
     def tagColNcharMaxLengthCheckCase(self):
         """
             check nchar length limit
@@ -935,30 +971,31 @@ class TDTestCase:
         input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000'
         code = self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
 
-        # * legal nchar could not be larger than 16374/4
-        input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(1, "letters")}" c0=f 1626006833639000000'
-        self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
-        tdSql.query(f"select * from {stb_name}")
-        tdSql.checkRows(2)
-        input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(2, "letters")}" c0=f 1626006833639000000'
-        try:
-            self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
-        except SchemalessError as err:
-            tdSql.checkNotEqual(err.errno, 0)
-        tdSql.query(f"select * from {stb_name}")
-        tdSql.checkRows(2)
+        # * legal tag nchar could not be larger than (16384-2)/4
+        # input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(1, "letters")}" c0=f 1626006833639000000'
+        # self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        # tdSql.query(f"select * from {stb_name}")
+        # tdSql.checkRows(2)
+        # input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(2, "letters")}" c0=f 1626006833639000000'
+        # try:
+        #     self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
+        # except SchemalessError as err:
+        #     tdSql.checkNotEqual(err.errno, 0)
+        # tdSql.query(f"select * from {stb_name}")
+        # tdSql.checkRows(2)
 
         input_sql = f'{stb_name},t0=t c0=f,c1=L"{tdCom.getLongName(4093, "letters")}",c2=L"{tdCom.getLongName(4093, "letters")}",c3=L"{tdCom.getLongName(4093, "letters")}",c4=L"{tdCom.getLongName(4, "letters")}" 1626006833639000000'
         self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
         tdSql.query(f"select * from {stb_name}")
-        tdSql.checkRows(3)
+        tdSql.checkRows(2)
+
         input_sql = f'{stb_name},t0=t c0=f,c1=L"{tdCom.getLongName(4093, "letters")}",c2=L"{tdCom.getLongName(4093, "letters")}",c3=L"{tdCom.getLongName(4093, "letters")}",c4=L"{tdCom.getLongName(5, "letters")}" 1626006833639000000'
         try:
             self._conn.schemaless_insert([input_sql], TDSmlProtocolType.LINE.value, TDSmlTimestampType.NANO_SECOND.value)
         except SchemalessError as err:
             tdSql.checkNotEqual(err.errno, 0)
         tdSql.query(f"select * from {stb_name}")
-        tdSql.checkRows(3)
+        tdSql.checkRows(2)
 
     def batchInsertCheckCase(self):
         """
@@ -1274,13 +1311,13 @@ class TDTestCase:
         self.idSeqCheckCase()
         self.idUpperCheckCase()
         self.noIdCheckCase()
-        # self.maxColTagCheckCase()
+        self.maxColTagCheckCase()
         self.idIllegalNameCheckCase()
         self.idStartWithNumCheckCase()
         self.nowTsCheckCase()
         self.dateFormatTsCheckCase()
         self.illegalTsCheckCase()
-        # self.tagValueLengthCheckCase()
+        self.tagValueLengthCheckCase()
         self.colValueLengthCheckCase()
         self.tagColIllegalValueCheckCase()
         self.duplicateIdTagColInsertCheckCase()
@@ -1290,8 +1327,8 @@ class TDTestCase:
         self.tagColAddDupIDCheckCase()
         self.tagColAddCheckCase()
         self.tagMd5Check()
-        # self.tagColBinaryMaxLengthCheckCase()
-        # self.tagColNcharMaxLengthCheckCase()
+        self.tagColBinaryMaxLengthCheckCase()
+        self.tagColNcharMaxLengthCheckCase()
         self.batchInsertCheckCase()
         self.multiInsertCheckCase(10)
         self.batchErrorInsertCheckCase()

tests/system-test/1-insert/stmt_error.py

+# encoding:UTF-8
+from taos import *
+
+from ctypes import *
+from datetime import datetime
+import taos
+
+import taos
+import time
+
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+class TDTestCase:
+    def __init__(self):
+        self.err_case = 0
+        self.curret_case = 0
+
+    def caseDescription(self):
+
+        '''
+        case1 <wenzhouwww>: [TD-11899] : this is an test case for check stmt error use .
+        '''
+        return
+    
+    def init(self, conn, logSql, replicaVar=1):
+        self.replicaVar = int(replicaVar)
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+    def conn(self):
+    # type: () -> taos.TaosConnection
+        return connect()
+
+    def test_stmt_insert(self,conn):
+        # type: (TaosConnection) -> None
+
+        dbname = "pytest_taos_stmt"
+        try:
+            conn.execute("drop database if exists %s" % dbname)
+            conn.execute("create database if not exists %s" % dbname)
+            conn.select_db(dbname)
+
+            conn.execute(
+                "create table if not exists log(ts timestamp, bo bool, nil tinyint, ti tinyint, si smallint, ii int,\
+                bi bigint, tu tinyint unsigned, su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+                ff float, dd double, bb binary(65059), nn nchar(100), tt timestamp)",
+            )
+            conn.load_table_info("log")
+            
+
+            stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+            params = new_bind_params(16)
+            params[0].timestamp(1626861392589, PrecisionEnum.Milliseconds)
+            params[1].bool(True)
+            params[2].tinyint(None)
+            params[3].tinyint(2)
+            params[4].smallint(3)
+            params[5].int(4)
+            params[6].bigint(5)
+            params[7].tinyint_unsigned(6)
+            params[8].smallint_unsigned(7)
+            params[9].int_unsigned(8)
+            params[10].bigint_unsigned(9)
+            params[11].float(10.1)
+            params[12].double(10.11)
+            binaryStr = '123456789'
+            for i in range(1301):
+                binaryStr += "1234567890abcdefghij1234567890abcdefghij12345hello"
+            params[13].binary(binaryStr)
+            params[14].nchar("stmt")
+            params[15].timestamp(1626861392589, PrecisionEnum.Milliseconds)
+
+            stmt.bind_param(params)
+            stmt.execute()
+
+            assert stmt.affected_rows == 1
+            stmt.close()
+
+            querystmt=conn.statement("select ?, bo, nil, ti, si, ii,bi, tu, su, iu, bu, ff, dd, bb, nn, tt from log")
+            queryparam=new_bind_params(1)
+            print(type(queryparam))
+            queryparam[0].binary("ts")
+            querystmt.bind_param(queryparam)
+            querystmt.execute()
+            result=querystmt.use_result()
+
+            row=result.fetch_all()
+            print(row)
+
+            assert row[0][1] == True
+            assert row[0][2] == None
+            for i in range(3, 10):
+                assert row[0][i] == i - 1
+            #float == may not work as expected
+            # assert row[0][11] == c_float(10.1)
+            assert row[0][12] == 10.11
+            assert row[0][13][65054:] == "hello"
+            assert row[0][14] == "stmt"
+
+            conn.execute("drop database if exists %s" % dbname)
+            conn.close()
+
+        except Exception as err:
+            conn.execute("drop database if exists %s" % dbname)
+            conn.close()
+            raise err
+
+    def test_stmt_insert_error(self,conn):
+        # type: (TaosConnection) -> None
+
+        dbname = "pytest_taos_stmt_error"
+        try:
+            conn.execute("drop database if exists %s" % dbname)
+            conn.execute("create database if not exists %s" % dbname)
+            conn.select_db(dbname)
+
+            conn.execute(
+                "create table if not exists log(ts timestamp, bo bool, nil tinyint, ti tinyint, si smallint, ii int,\
+                bi bigint, tu tinyint unsigned, su smallint unsigned, iu int unsigned, bu bigint unsigned, \
+                ff float, dd double, bb binary(100), nn nchar(100), tt timestamp , error_data int )",
+            )
+            conn.load_table_info("log")
+            
+
+            stmt = conn.statement("insert into log values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,1000)")
+            params = new_bind_params(16)
+            params[0].timestamp(1626861392589, PrecisionEnum.Milliseconds)
+            params[1].bool(True)
+            params[2].tinyint(None)
+            params[3].tinyint(2)
+            params[4].smallint(3)
+            params[5].int(4)
+            params[6].bigint(5)
+            params[7].tinyint_unsigned(6)
+            params[8].smallint_unsigned(7)
+            params[9].int_unsigned(8)
+            params[10].bigint_unsigned(9)
+            params[11].float(10.1)
+            params[12].double(10.11)
+            params[13].binary("hello")
+            params[14].nchar("stmt")
+            params[15].timestamp(1626861392589, PrecisionEnum.Milliseconds)
+
+            stmt.bind_param(params)
+            stmt.execute()
+
+            conn.close()
+
+        except Exception as err:
+            conn.execute("drop database if exists %s" % dbname)
+            conn.close()
+            raise err
+
+    def test_stmt_insert_error_null_timestamp(self,conn):
+
+        dbname = "pytest_taos_stmt_error_null_ts"
+        try:
+            conn.execute("drop database if exists %s" % dbname)
+            conn.execute("create database if not exists %s" % dbname)
+            conn.execute("alter database %s keep 36500" % dbname)
+            conn.select_db(dbname)
+
+            conn.execute("create stable STB(ts timestamp, n int) tags(b int)")
+
+            stmt = conn.statement("insert into ? using STB tags(?) values(?, ?)")
+            params = new_bind_params(1)
+            params[0].int(4);
+            stmt.set_tbname_tags("ct", params);
+
+            multi_params = new_multi_binds(2);
+            multi_params[0].timestamp([9223372036854775808])
+            multi_params[1].int([123])
+            stmt.bind_param_batch(multi_params)
+
+            stmt.execute()
+            result = stmt.use_result()
+
+            result.close()
+            stmt.close()
+
+            stmt = conn.statement("select * from STB")
+            stmt.execute()
+            result = stmt.use_result()
+            print(result.affected_rows)
+            row  = result.next()
+            print(row)
+
+            result.close()
+            stmt.close()
+            conn.close()
+
+        except Exception as err:
+            conn.close()
+            raise err
+    
+    def run(self):
+        
+        self.test_stmt_insert(self.conn())
+        try:
+            self.test_stmt_insert_error(self.conn())
+        except Exception as error :
+            
+            if str(error)=='[0x0200]: no mix usage for ? and values':
+                tdLog.info('=========stmt error occured for bind part column ==============')
+            else:
+                tdLog.exit("expect error(%s) not occured" % str(error))
+
+        try:    
+            self.test_stmt_insert_error_null_timestamp(self.conn())
+            tdLog.exit("expect error not occured - 1")
+        except Exception as error :
+            if str(error)=='[0x060b]: Timestamp data out of range':
+                tdLog.info('=========stmt error occured  for bind part column(NULL Timestamp) ==============')
+            else:
+                tdLog.exit("expect error(%s) not occured - 2" % str(error))
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file

tests/system-test/runAllOne.sh

@@ -287,6 +287,7 @@ python3 ./test.py -f 1-insert/tb_100w_data_order.py -P
 python3 ./test.py -f 1-insert/delete_childtable.py -P
 python3 ./test.py -f 1-insert/delete_normaltable.py -P
 python3 ./test.py -f 1-insert/keep_expired.py -P
+python3 ./test.py -f 1-insert/stmt_error.py -P
 python3 ./test.py -f 1-insert/drop.py -P
 python3 ./test.py -f 2-query/join2.py -P
 python3 ./test.py -f 2-query/union1.py -P

tests/system-test/win-test-file

@@ -218,6 +218,7 @@ python3 ./test.py -f 1-insert/delete_stable.py
 python3 ./test.py -f 1-insert/delete_childtable.py
 python3 ./test.py -f 1-insert/delete_normaltable.py
 python3 ./test.py -f 1-insert/keep_expired.py
+python3 ./test.py -f 1-insert/stmt_error.py
 python3 ./test.py -f 1-insert/drop.py
 python3 ./test.py -f 1-insert/drop.py -N 3 -M 3 -i False -n 3
 python3 ./test.py -f 2-query/join2.py

tools/shell/src/shellEngine.c

@@ -712,7 +712,7 @@ int32_t shellCalcColWidth(TAOS_FIELD *field, int32_t precision) {
 
     case TSDB_DATA_TYPE_NCHAR:
     case TSDB_DATA_TYPE_JSON: {
-      int16_t bytes = field->bytes * TSDB_NCHAR_SIZE;
+      uint16_t bytes = field->bytes * TSDB_NCHAR_SIZE;
       if (bytes > shell.args.displayWidth) {
         return TMAX(shell.args.displayWidth, width);
       } else {