feat: stmt2 supports the decimal data type

.github/workflows/enterprise.yml

@@ -18,13 +18,13 @@ jobs:
         node-version: [16.x, 20.x]
     steps:
       - name: Get TDengine
-        run: wget "${{ secrets.NIGHTLY_TDENGINE_ENTERPRISE_BASE_URL }}/tsdb-nightly-3.0.tar.gz?v=$(date +%s)" -O tsdb-nightly-3.0.tar.gz
+        run: wget "${{ secrets.NIGHTLY_TDENGINE_ENTERPRISE_BASE_URL }}/tsdb-nightly-main.tar.gz?v=$(date +%s)" -O tsdb-nightly-main.tar.gz
 
       - name: Install TDengine
         run: |
-          tar -zxf tsdb-nightly-3.0.tar.gz
-          rm -rf tsdb-nightly-3.0.tar.gz
-          cd tsdb-nightly-3.0
+          tar -zxf tsdb-nightly-main.tar.gz
+          rm -rf tsdb-nightly-main.tar.gz
+          cd tsdb-nightly-main
           sudo ./install.sh
 
       - name: Start TDengine

nodejs/src/common/constant.ts

@@ -34,8 +34,10 @@ export const TDengineTypeName: IndexableString = {
     14: "BIGINT UNSIGNED",
     15: "JSON",
     16: "VARBINARY",
+    17: "DECIMAL",
     18: "BLOB",
     20: "GEOMETRY",
+    21: "DECIMAL64",
 };
 
 export const ColumnsBlockType: StringIndexable = {
@@ -105,6 +107,8 @@ export const TDengineTypeLength: NumberIndexable = {
     [TDengineTypeCode.SMALLINT_UNSIGNED]: 2,
     [TDengineTypeCode.INT_UNSIGNED]: 4,
     [TDengineTypeCode.BIGINT_UNSIGNED]: 8,
+    [TDengineTypeCode.DECIMAL]: 16,
+    [TDengineTypeCode.DECIMAL64]: 8,
 };
 
 export const PrecisionLength: StringIndexable = {

nodejs/src/common/taosResult.ts

@@ -476,9 +476,7 @@ export function readSolidDataToArray(
                     result.push(null);
                 } else {
                     let decimalVal = dataBuffer.getBigInt64(colBlockHead, true);
-                    result.push(
-                        decimalToString(decimalVal.toString(), BigInt(scale))
-                    );
+                    result.push(decimalToString(decimalVal.toString(), BigInt(scale)));
                 }
             }
             break;
@@ -489,22 +487,10 @@ export function readSolidDataToArray(
                 if (isNull(bitMapArr, i)) {
                     result.push(null);
                 } else {
-                    let decimalHighPart = dataBuffer.getBigInt64(
-                        colBlockHead + 8,
-                        true
-                    );
-                    const decimalLowPart = dataBuffer.getBigUint64(
-                        colBlockHead,
-                        true
-                    );
-                    const decimalCombined =
-                        (decimalHighPart << 64n) | decimalLowPart;
-                    result.push(
-                        decimalToString(
-                            decimalCombined.toString(),
-                            BigInt(scale)
-                        )
-                    );
+                    let decimalHighPart = dataBuffer.getBigInt64(colBlockHead + 8, true);
+                    const decimalLowPart = dataBuffer.getBigUint64(colBlockHead, true);
+                    const decimalCombined = (decimalHighPart << 64n) | decimalLowPart;
+                    result.push(decimalToString(decimalCombined.toString(), BigInt(scale)));
                 }
             }
             break;

nodejs/src/common/utils.ts

@@ -190,8 +190,7 @@ export function decimalToString(
         } else {
             const integerPart = absStr.slice(0, absStr.length - scale);
             const decimalPart = absStr.slice(absStr.length - scale);
-            decimalStr =
-                (isNegative ? "-" : "") + integerPart + "." + decimalPart;
+            decimalStr = (isNegative ? "-" : "") + integerPart + "." + decimalPart;
         }
     }
     return decimalStr;

nodejs/src/stmt/wsParams1.ts

@@ -34,12 +34,6 @@ export class Stmt1BindParams extends StmtBindParams implements IDataEncoder {
                 "StmtBindParams params is invalid!"
             );
         }
-        if (columnType === TDengineTypeCode.BLOB) {
-            throw new TaosError(
-                ErrorCode.ERR_INVALID_PARAMS,
-                "BLOB parameters are not supported for stmt1"
-            );
-        }
         if (
             dataType === "number" ||
             dataType === "bigint" ||

nodejs/src/stmt/wsParams2.ts

@@ -2,6 +2,8 @@ import {
     ColumnsBlockType,
     FieldBindType,
     PrecisionLength,
+    TDengineTypeCode,
+    TDengineTypeName,
 } from "../common/constant";
 import { ErrorCode, TaosError } from "../common/wsError";
 import { isEmpty } from "../common/utils";
@@ -16,35 +18,25 @@ export class Stmt2BindParams extends StmtBindParams implements IDataEncoder {
     private _fields: Array<StmtFieldInfo>;
     protected paramIndex: number = 0;
 
-    constructor(
-        paramsCount?: number,
-        precision?: number,
-        fields?: Array<StmtFieldInfo>
-    ) {
+    constructor(paramsCount?: number, precision?: number, fields?: Array<StmtFieldInfo>) {
         super(precision, paramsCount);
         this._fields = fields || [];
     }
 
-    addParams(
-        params: any[],
-        dataType: string,
-        typeLen: number,
-        columnType: number
-    ): void {
+    addParams(params: any[], dataType: string, typeLen: number, columnType: number): void {
         if (!params || params.length == 0) {
             throw new TaosError(
                 ErrorCode.ERR_INVALID_PARAMS,
                 "StmtBindParams params is invalid!"
             );
         }
+
         if (this._fieldParams) {
             if (this.paramsCount > 0) {
                 if (this._fieldParams[this.paramIndex]) {
                     if (
-                        this._fieldParams[this.paramIndex].dataType !==
-                        dataType ||
-                        this._fieldParams[this.paramIndex].columnType !==
-                        columnType
+                        this._fieldParams[this.paramIndex].dataType !== dataType ||
+                        this._fieldParams[this.paramIndex].columnType !== columnType
                     ) {
                         throw new TaosError(
                             ErrorCode.ERR_INVALID_PARAMS,
@@ -53,11 +45,8 @@ export class Stmt2BindParams extends StmtBindParams implements IDataEncoder {
                                 dataType,
                                 columnType,
                             })} vs ${JSONBig.stringify({
-                                dataType:
-                                    this._fieldParams[this.paramIndex].dataType,
-                                columnType:
-                                    this._fieldParams[this.paramIndex]
-                                        .columnType,
+                                dataType: this._fieldParams[this.paramIndex].dataType,
+                                columnType: this._fieldParams[this.paramIndex].columnType,
                             })}`
                         );
                     }
@@ -103,6 +92,7 @@ export class Stmt2BindParams extends StmtBindParams implements IDataEncoder {
                 "StmtBindParams params is invalid!"
             );
         }
+
         this.paramIndex = 0;
         for (let i = 0; i < bindParams._fieldParams.length; i++) {
             let fieldParam = bindParams._fieldParams[i];
@@ -117,6 +107,44 @@ export class Stmt2BindParams extends StmtBindParams implements IDataEncoder {
         }
     }
 
+    setDecimal(params: any[]) {
+        if (!params || params.length == 0) {
+            throw new TaosError(
+                ErrorCode.ERR_INVALID_PARAMS,
+                "SetDecimalColumn params is invalid!"
+            );
+        }
+        for (let i = 0; i < params.length; i++) {
+            if (!isEmpty(params[i]) && typeof params[i] !== "string") {
+                throw new TaosError(
+                    ErrorCode.ERR_INVALID_PARAMS,
+                    "SetDecimalColumn params is invalid!"
+                );
+            }
+        }
+        this.addParams(
+            params,
+            TDengineTypeName[TDengineTypeCode.DECIMAL],
+            0,
+            TDengineTypeCode.DECIMAL
+        );
+    }
+
+    setBlob(params: any[]) {
+        if (!params || params.length == 0) {
+            throw new TaosError(
+                ErrorCode.ERR_INVALID_PARAMS,
+                "SetBlobColumn params is invalid!"
+            );
+        }
+        this.addParams(
+            params,
+            TDengineTypeName[TDengineTypeCode.BLOB],
+            0,
+            TDengineTypeCode.BLOB
+        );
+    }
+
     encode(): void {
         this.paramIndex = 0;
         if (!this._fieldParams || this._fieldParams.length == 0) {
@@ -136,42 +164,38 @@ export class Stmt2BindParams extends StmtBindParams implements IDataEncoder {
         } else {
             this._rows = this._fieldParams[0].params.length;
         }
+
         for (let i = 0; i < this._fieldParams.length; i++) {
             let fieldParam = this._fieldParams[i];
             if (!fieldParam) {
                 continue;
             }
 
-            let isVarType = _isVarType(fieldParam.columnType);
-            if (isVarType == ColumnsBlockType.SOLID) {
-                if (fieldParam.dataType === "TIMESTAMP") {
-                    this._params.push(
-                        this.encodeTimestampColumn(
-                            fieldParam.params,
-                            fieldParam.typeLen,
-                            fieldParam.columnType
-                        )
-                    );
-                } else {
-                    this._params.push(
-                        this.encodeDigitColumns(
-                            fieldParam.params,
-                            fieldParam.dataType,
-                            fieldParam.typeLen,
-                            fieldParam.columnType
-                        )
-                    );
-                }
-            } else {
-                this._params.push(
-                    this.encodeVarColumns(
+            const isSolidType = _isVarType(fieldParam.columnType) === ColumnsBlockType.SOLID;
+            const useSolidEncoder = isSolidType &&
+                fieldParam.columnType !== TDengineTypeCode.DECIMAL &&
+                fieldParam.columnType !== TDengineTypeCode.DECIMAL64;
+
+            const columnInfo = useSolidEncoder
+                ? fieldParam.dataType === TDengineTypeName[TDengineTypeCode.TIMESTAMP]
+                    ? this.encodeTimestampColumn(
+                        fieldParam.params,
+                        fieldParam.typeLen,
+                        fieldParam.columnType
+                    )
+                    : this.encodeDigitColumns(
                         fieldParam.params,
                         fieldParam.dataType,
                         fieldParam.typeLen,
                         fieldParam.columnType
                     )
+                : this.encodeVarColumns(
+                    fieldParam.params,
+                    fieldParam.dataType,
+                    fieldParam.typeLen,
+                    fieldParam.columnType
                 );
-            }
+            this._params.push(columnInfo);
         }
     }
 
@@ -210,6 +234,7 @@ export class Stmt2BindParams extends StmtBindParams implements IDataEncoder {
                 }
             } else {
                 isNull.push(1);
+                dataLengths.push(0);
             }
         }
         this._dataTotalLen += totalLength;
@@ -299,10 +324,7 @@ export class Stmt2BindParams extends StmtBindParams implements IDataEncoder {
                     } else {
                         timeStamp = BigInt(date.getTime());
                     }
-                } else if (
-                    typeof params[i] == "bigint" ||
-                    typeof params[i] == "number"
-                ) {
+                } else if (typeof params[i] == "bigint" || typeof params[i] == "number") {
                     if (typeof params[i] == "number") {
                         timeStamp = BigInt(params[i]);
                     } else {

nodejs/src/stmt/wsParamsBase.ts

@@ -307,13 +307,10 @@ export abstract class StmtBindParams {
     }
 
     setBlob(params: any[]) {
-        if (!params || params.length == 0) {
-            throw new TaosError(
-                ErrorCode.ERR_INVALID_PARAMS,
-                "SetBlobColumn params is invalid!"
-            );
-        }
-        this.addParams(params, TDengineTypeName[18], 0, TDengineTypeCode.BLOB);
+        throw new TaosError(
+            ErrorCode.ERR_UNSUPPORTED_TDENGINE_TYPE,
+            "setBlob is not supported in stmt1, please use stmt2 instead!"
+        );
     }
 
     setGeometry(params: any[]) {
@@ -326,6 +323,13 @@ export abstract class StmtBindParams {
         this.addParams(params, TDengineTypeName[20], 0, TDengineTypeCode.GEOMETRY);
     }
 
+    setDecimal(params: any[]) {
+        throw new TaosError(
+            ErrorCode.ERR_UNSUPPORTED_TDENGINE_TYPE,
+            "setDecimal is not supported in stmt1, please use stmt2 instead!"
+        );
+    }
+
     setTimestamp(params: any[]) {
         if (!params || params.length == 0) {
             throw new TaosError(
@@ -375,28 +379,23 @@ export abstract class StmtBindParams {
                     dataBuffer.setUint16(i * 2, params, true);
                     break;
                 }
-
                 case TDengineTypeCode.INT: {
                     dataBuffer.setInt32(i * 4, params, true);
                     break;
                 }
-
                 case TDengineTypeCode.INT_UNSIGNED: {
                     dataBuffer.setUint32(i * 4, params, true);
                     break;
                 }
-
                 case TDengineTypeCode.BIGINT:
                 case TDengineTypeCode.TIMESTAMP: {
                     dataBuffer.setBigInt64(i * 8, params, true);
                     break;
                 }
-
                 case TDengineTypeCode.BIGINT_UNSIGNED: {
                     dataBuffer.setBigUint64(i * 8, params, true);
                     break;
                 }
-
                 case TDengineTypeCode.FLOAT: {
                     dataBuffer.setFloat32(i * 4, params, true);
                     break;

nodejs/src/stmt/wsProto.ts

@@ -188,8 +188,7 @@ export function stmt2BinaryBlockEncode(
         colSizeList: new Array<number>(listLength),
     };
 
-    const hasTableName =
-        toBeBindTableNameIndex != null && toBeBindTableNameIndex >= 0;
+    const hasTableName = toBeBindTableNameIndex != null && toBeBindTableNameIndex >= 0;
     const hasTags = toBeBindTagCount > 0;
     for (let i = 0; i < listLength; i++) {
         const tableInfo = stmtTableInfoList[i];
@@ -238,10 +237,8 @@ export function stmt2BinaryBlockEncode(
         result.totalColSize += size;
     }
 
-    let totalSize =
-        result.totalTableNameSize + result.totalTagSize + result.totalColSize;
-    let toBeBindTableNameCount =
-        toBeBindTableNameIndex != null && toBeBindTableNameIndex >= 0 ? 1 : 0;
+    let totalSize = result.totalTableNameSize + result.totalTagSize + result.totalColSize;
+    let toBeBindTableNameCount = toBeBindTableNameIndex != null && toBeBindTableNameIndex >= 0 ? 1 : 0;
     totalSize +=
         stmtTableInfoList.length *
         (toBeBindTableNameCount * 2 +
@@ -295,8 +292,7 @@ export function stmt2BinaryBlockEncode(
     if (toBeBindColCount > 0) {
         let skipSize = 0;
         if (toBeBindTableNameCount > 0) {
-            skipSize +=
-                result.totalTableNameSize + 2 * stmtTableInfoList.length;
+            skipSize += result.totalTableNameSize + 2 * stmtTableInfoList.length;
         }
 
         if (toBeBindTagCount > 0) {