@tdengine/websocket 3.1.8 → 3.2.0

package/lib/src/stmt/FieldBindParams.d.ts

@@ -0,0 +1,9 @@
+export declare class FieldBindParams {
+    params: any[];
+    dataType: string;
+    typeLen: number;
+    columnType: number;
+    bindType: number;
+    constructor(params: any[], dataType: string, typeLen: number, columnType: number, bindType: number);
+}
+//# sourceMappingURL=FieldBindParams.d.ts.map

package/lib/src/stmt/FieldBindParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldBindParams.d.ts","sourceRoot":"","sources":["../../../src/stmt/FieldBindParams.ts"],"names":[],"mappings":"AACA,qBAAa,eAAe;IACxB,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;gBACL,MAAM,EAAC,GAAG,EAAE,EAAE,QAAQ,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,EAAE,UAAU,EAAC,MAAM,EAAE,QAAQ,EAAC,MAAM;CAOhG"}

package/lib/src/stmt/FieldBindParams.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldBindParams = void 0;
+class FieldBindParams {
+    constructor(params, dataType, typeLen, columnType, bindType) {
+        this.params = [...params];
+        this.dataType = dataType;
+        this.typeLen = typeLen;
+        this.columnType = columnType;
+        this.bindType = bindType;
+    }
+}
+exports.FieldBindParams = FieldBindParams;

package/lib/src/stmt/wsColumnInfo.d.ts

@@ -0,0 +1,12 @@
+export declare class ColumnInfo {
+    data: ArrayBuffer;
+    length: number;
+    type: number;
+    typeLen: number;
+    isNull?: number[];
+    _rows: number;
+    _haveLength: number;
+    _dataLengths?: number[];
+    constructor([length, data]: [number, ArrayBuffer], type: number, typeLen: number, rows: number, isNull?: number[], dataLengths?: number[], haveLength?: number);
+}
+//# sourceMappingURL=wsColumnInfo.d.ts.map

package/lib/src/stmt/wsColumnInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsColumnInfo.d.ts","sourceRoot":"","sources":["../../../src/stmt/wsColumnInfo.ts"],"names":[],"mappings":"AACA,qBAAa,UAAU;IACnB,IAAI,EAAC,WAAW,CAAC;IACjB,MAAM,EAAC,MAAM,CAAC;IACd,IAAI,EAAC,MAAM,CAAC;IACZ,OAAO,EAAC,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAK;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;gBACZ,CAAC,MAAM,EAAC,IAAI,CAAC,EAAC,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,IAAI,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM,EACrF,MAAM,CAAC,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE,UAAU,GAAE,MAAU;CAWxE"}

package/lib/src/stmt/wsColumnInfo.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnInfo = void 0;
+class ColumnInfo {
+    constructor([length, data], type, typeLen, rows, isNull, dataLengths, haveLength = 0) {
+        this._haveLength = 0;
+        this.data = data;
+        this.type = type;
+        this.length = length;
+        this.typeLen = typeLen;
+        this._rows = rows;
+        this.isNull = isNull;
+        this._dataLengths = dataLengths;
+        this._haveLength = haveLength;
+    }
+}
+exports.ColumnInfo = ColumnInfo;

package/lib/src/stmt/wsParams1.d.ts

@@ -0,0 +1,14 @@
+import { IDataEncoder, StmtBindParams } from "./wsParamsBase";
+export declare class Stmt1BindParams extends StmtBindParams implements IDataEncoder {
+    constructor(precision?: number);
+    encode(): void;
+    mergeParams(bindParams: StmtBindParams): void;
+    addParams(params: any[], dataType: string, typeLen: number, columnType: number): void;
+    setTimestamp(params: any[]): void;
+    private encodeDigitColumns;
+    private encodeVarLengthColumn;
+    private getBinaryColumnArrayBuffer;
+    private encodeNcharColumn;
+    private countBigintDigits;
+}
+//# sourceMappingURL=wsParams1.d.ts.map

package/lib/src/stmt/wsParams1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsParams1.d.ts","sourceRoot":"","sources":["../../../src/stmt/wsParams1.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE9D,qBAAa,eAAgB,SAAQ,cAAe,YAAW,YAAY;gBAC3D,SAAS,CAAC,EAAC,MAAM;IAI7B,MAAM,IAAI,IAAI;IAId,WAAW,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI;IAI7C,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAgBrF,YAAY,CAAC,MAAM,EAAE,GAAG,EAAE;IAwE1B,OAAO,CAAC,kBAAkB;IA2B1B,OAAO,CAAC,qBAAqB;IAiD7B,OAAO,CAAC,0BAA0B;IAyBlC,OAAO,CAAC,iBAAiB;IAuDzB,OAAO,CAAC,iBAAiB;CAa5B"}

package/lib/src/stmt/wsParams1.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stmt1BindParams = void 0;
+const constant_1 = require("../common/constant");
+const wsError_1 = require("../common/wsError");
+const taosResult_1 = require("../common/taosResult");
+const utils_1 = require("../common/utils");
+const wsColumnInfo_1 = require("./wsColumnInfo");
+const wsParamsBase_1 = require("./wsParamsBase");
+class Stmt1BindParams extends wsParamsBase_1.StmtBindParams {
+    constructor(precision) {
+        super(precision);
+    }
+    encode() {
+        return;
+    }
+    mergeParams(bindParams) {
+        return;
+    }
+    addParams(params, dataType, typeLen, columnType) {
+        if (!params || params.length == 0) {
+            throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "StmtBindParams params is invalid!");
+        }
+        if (dataType === "number" || dataType === "bigint" || dataType === "boolean") {
+            this._params.push(this.encodeDigitColumns(params, dataType, typeLen, columnType));
+        }
+        else {
+            if (columnType === constant_1.TDengineTypeCode.NCHAR) {
+                this._params.push(this.encodeNcharColumn(params));
+            }
+            else {
+                this._params.push(this.encodeVarLengthColumn(params, columnType));
+            }
+        }
+    }
+    setTimestamp(params) {
+        if (!params || params.length == 0) {
+            throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "SeTimestampColumn params is invalid!");
+        }
+        //computing bitmap length
+        let bitMapLen = (0, taosResult_1.bitmapLen)(params.length);
+        //Computing the length of data
+        let arrayBuffer = new ArrayBuffer(bitMapLen + constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.TIMESTAMP] * params.length);
+        //bitmap get data range
+        let bitmapBuffer = new DataView(arrayBuffer);
+        //skip bitmap get data range 
+        let dataBuffer = new DataView(arrayBuffer, bitMapLen);
+        if (this._rows > 0) {
+            if (this._rows !== params.length) {
+                throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "wrong row length!");
+            }
+        }
+        else {
+            this._rows = params.length;
+        }
+        for (let i = 0; i < params.length; i++) {
+            if (!(0, utils_1.isEmpty)(params[i])) {
+                if (params[i] instanceof Date) {
+                    let date = params[i];
+                    //node only support milliseconds, need fill 0
+                    if (this.precisionLength == constant_1.PrecisionLength['us']) {
+                        let ms = date.getTime() * 1000;
+                        dataBuffer.setBigInt64(i * 8, BigInt(ms), true);
+                    }
+                    else if (this.precisionLength == constant_1.PrecisionLength['ns']) {
+                        let ns = date.getTime() * 1000 * 1000;
+                        dataBuffer.setBigInt64(i * 8, BigInt(ns), true);
+                    }
+                    else {
+                        dataBuffer.setBigInt64(i * 8, BigInt(date.getTime()), true);
+                    }
+                }
+                else if (typeof params[i] == 'bigint' || typeof params[i] == 'number') {
+                    let data;
+                    if (typeof params[i] == 'number') {
+                        data = BigInt(params[i]);
+                    }
+                    else {
+                        data = params[i];
+                    }
+                    //statistical bits of digit
+                    let digit = this.countBigintDigits(data);
+                    //check digit same table Precision 
+                    if (this.precisionLength == constant_1.PrecisionLength['ns']) {
+                        if (this.precisionLength <= digit) {
+                            dataBuffer.setBigInt64(i * 8, data, true);
+                        }
+                        else {
+                            throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "SeTimestampColumn params precisionLength is invalid! param:=" + params[i]);
+                        }
+                    }
+                    else if (this.precisionLength == digit) {
+                        dataBuffer.setBigInt64(i * 8, data, true);
+                    }
+                    else {
+                        throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "SeTimestampColumn params is invalid! param:=" + params[i]);
+                    }
+                }
+            }
+            else {
+                //set bitmap bit is null
+                let charOffset = (0, taosResult_1.getCharOffset)(i);
+                let nullVal = (0, taosResult_1.setBitmapNull)(dataBuffer.getInt8(charOffset), i);
+                bitmapBuffer.setInt8(charOffset, nullVal);
+            }
+        }
+        this._dataTotalLen += arrayBuffer.byteLength;
+        this._params.push(new wsColumnInfo_1.ColumnInfo([constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.TIMESTAMP] * params.length, arrayBuffer], constant_1.TDengineTypeCode.TIMESTAMP, constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.TIMESTAMP], this._rows));
+    }
+    encodeDigitColumns(params, dataType = 'number', typeLen, columnType) {
+        let bitMapLen = (0, taosResult_1.bitmapLen)(params.length);
+        let arrayBuffer = new ArrayBuffer(typeLen * params.length + bitMapLen);
+        let bitmapBuffer = new DataView(arrayBuffer);
+        let dataBuffer = new DataView(arrayBuffer, bitMapLen);
+        if (this._rows > 0) {
+            if (this._rows !== params.length) {
+                throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "wrong row length!");
+            }
+        }
+        else {
+            this._rows = params.length;
+        }
+        for (let i = 0; i < params.length; i++) {
+            if (!(0, utils_1.isEmpty)(params[i])) {
+                this.writeDataToBuffer(dataBuffer, params[i], dataType, typeLen, columnType, i);
+            }
+            else {
+                //set bitmap bit is null
+                let charOffset = (0, taosResult_1.getCharOffset)(i);
+                let nullVal = (0, taosResult_1.setBitmapNull)(bitmapBuffer.getUint8(charOffset), i);
+                bitmapBuffer.setInt8(charOffset, nullVal);
+            }
+        }
+        this._dataTotalLen += dataBuffer.buffer.byteLength;
+        return new wsColumnInfo_1.ColumnInfo([typeLen * params.length, dataBuffer.buffer], columnType, typeLen, this._rows);
+    }
+    encodeVarLengthColumn(params, columnType) {
+        let data = [];
+        let dataLength = 0;
+        //create params length buffer
+        let paramsLenBuffer = new ArrayBuffer(constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.INT] * params.length);
+        let paramsLenView = new DataView(paramsLenBuffer);
+        if (this._rows > 0) {
+            if (this._rows !== params.length) {
+                throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "wrong row length!");
+            }
+        }
+        else {
+            this._rows = params.length;
+        }
+        for (let i = 0; i < params.length; i++) {
+            //get param length offset 4byte
+            let offset = constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.INT] * i;
+            if (!(0, utils_1.isEmpty)(params[i])) {
+                //save param length offset 4byte
+                paramsLenView.setInt32(offset, dataLength, true);
+                if (typeof params[i] == 'string') {
+                    //string TextEncoder
+                    let encode = new TextEncoder();
+                    let value = encode.encode(params[i]).buffer;
+                    data.push(value);
+                    //add offset length
+                    dataLength += value.byteLength + constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.SMALLINT];
+                }
+                else if (params[i] instanceof ArrayBuffer) {
+                    //input arraybuffer, save not need encode
+                    let value = params[i];
+                    dataLength += value.byteLength + constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.SMALLINT];
+                    data.push(value);
+                }
+                else {
+                    throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "getColumString params is invalid! param_type:=" + typeof params[i]);
+                }
+            }
+            else {
+                //set length -1, param is null
+                for (let j = 0; j < constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.INT]; j++) {
+                    paramsLenView.setInt8(offset + j, 255);
+                }
+            }
+        }
+        this._dataTotalLen += paramsLenBuffer.byteLength + dataLength;
+        return new wsColumnInfo_1.ColumnInfo([dataLength, this.getBinaryColumnArrayBuffer(data, paramsLenView.buffer, dataLength)], columnType, 0, this._rows);
+    }
+    //splicing encode params to arraybuffer
+    getBinaryColumnArrayBuffer(data, paramsLenBuffer, dataLength) {
+        //create arraybuffer 
+        let paramsBuffer = new ArrayBuffer(paramsLenBuffer.byteLength + dataLength);
+        //get length data range
+        const paramsUint8 = new Uint8Array(paramsBuffer);
+        const paramsLenView = new Uint8Array(paramsLenBuffer);
+        paramsUint8.set(paramsLenView, 0);
+        //get data range
+        const paramsView = new DataView(paramsBuffer, paramsLenBuffer.byteLength);
+        let offset = 0;
+        for (let i = 0; i < data.length; i++) {
+            //save param field length
+            paramsView.setInt16(offset, data[i].byteLength, true);
+            const dataView = new DataView(data[i]);
+            //save data
+            for (let j = 0; j < data[i].byteLength; j++) {
+                paramsView.setUint8(offset + 2 + j, dataView.getUint8(j));
+            }
+            offset += data[i].byteLength + 2;
+        }
+        return paramsBuffer;
+    }
+    //encode nchar type params
+    encodeNcharColumn(params) {
+        let data = [];
+        let dataLength = 0;
+        let indexBuffer = new ArrayBuffer(constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.INT] * params.length);
+        let indexView = new DataView(indexBuffer);
+        if (this._rows > 0) {
+            if (this._rows !== params.length) {
+                throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "wrong row length!");
+            }
+        }
+        else {
+            this._rows = params.length;
+        }
+        for (let i = 0; i < params.length; i++) {
+            let offset = constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.INT] * i;
+            if (!(0, utils_1.isEmpty)(params[i])) {
+                indexView.setInt32(offset, dataLength, true);
+                if (typeof params[i] == 'string') {
+                    let codes = [];
+                    let strNcharParams = params[i];
+                    for (let j = 0; j < params[i].length; j++) {
+                        //get char, cn char need 3~4 byte
+                        codes.push(strNcharParams.charCodeAt(j));
+                    }
+                    let ncharBuffer = new ArrayBuffer(codes.length * 4);
+                    let ncharView = new DataView(ncharBuffer);
+                    for (let j = 0; j < codes.length; j++) {
+                        //1char, save into uint32
+                        ncharView.setUint32(j * 4, codes[j], true);
+                    }
+                    data.push(ncharBuffer);
+                    dataLength += codes.length * 4 + constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.SMALLINT];
+                }
+                else if (params[i] instanceof ArrayBuffer) {
+                    let value = params[i];
+                    dataLength += value.byteLength + constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.SMALLINT];
+                    data.push(value);
+                }
+                else {
+                    throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "getColumString params is invalid! param_type:=" + typeof params[i]);
+                }
+            }
+            else {
+                //set length -1, param is null
+                for (let j = 0; j < constant_1.TDengineTypeLength[constant_1.TDengineTypeCode.INT]; j++) {
+                    indexView.setInt8(offset + j, 255);
+                }
+            }
+        }
+        this._dataTotalLen += indexBuffer.byteLength + dataLength;
+        return new wsColumnInfo_1.ColumnInfo([dataLength, this.getBinaryColumnArrayBuffer(data, indexView.buffer, dataLength)], constant_1.TDengineTypeCode.NCHAR, 0, this._rows);
+    }
+    countBigintDigits(numeral) {
+        if (numeral === 0n) {
+            return 1;
+        }
+        let count = 0;
+        let temp = numeral;
+        while (temp !== 0n) {
+            temp /= 10n;
+            count++;
+        }
+        return count;
+    }
+}
+exports.Stmt1BindParams = Stmt1BindParams;

package/lib/src/stmt/wsParams2.d.ts

@@ -0,0 +1,14 @@
+import { IDataEncoder, StmtBindParams } from "./wsParamsBase";
+import { StmtFieldInfo } from "./wsProto";
+export declare class Stmt2BindParams extends StmtBindParams implements IDataEncoder {
+    private _fields;
+    protected paramIndex: number;
+    constructor(paramsCount?: number, precision?: number, fields?: Array<StmtFieldInfo>);
+    addParams(params: any[], dataType: string, typeLen: number, columnType: number): void;
+    mergeParams(bindParams: StmtBindParams): void;
+    encode(): void;
+    private encodeVarColumns;
+    private encodeDigitColumns;
+    private encodeTimestampColumn;
+}
+//# sourceMappingURL=wsParams2.d.ts.map

package/lib/src/stmt/wsParams2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsParams2.d.ts","sourceRoot":"","sources":["../../../src/stmt/wsParams2.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAI9D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,qBAAa,eAAgB,SAAQ,cAAe,YAAW,YAAY;IACvE,OAAO,CAAC,OAAO,CAAuB;IACtC,SAAS,CAAC,UAAU,EAAC,MAAM,CAAK;gBACpB,WAAW,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAKlF,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IA4BrF,WAAW,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI;IAa7C,MAAM,IAAI,IAAI;IAgCd,OAAO,CAAC,gBAAgB;IAmCxB,OAAO,CAAC,kBAAkB;IAyB1B,OAAO,CAAC,qBAAqB;CAgChC"}

package/lib/src/stmt/wsParams2.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stmt2BindParams = void 0;
+const constant_1 = require("../common/constant");
+const wsError_1 = require("../common/wsError");
+const utils_1 = require("../common/utils");
+const wsColumnInfo_1 = require("./wsColumnInfo");
+const wsParamsBase_1 = require("./wsParamsBase");
+const taosResult_1 = require("../common/taosResult");
+const FieldBindParams_1 = require("./FieldBindParams");
+const json_bigint_1 = __importDefault(require("json-bigint"));
+class Stmt2BindParams extends wsParamsBase_1.StmtBindParams {
+    constructor(paramsCount, precision, fields) {
+        super(precision, paramsCount);
+        this.paramIndex = 0;
+        this._fields = fields || [];
+    }
+    addParams(params, dataType, typeLen, columnType) {
+        if (!params || params.length == 0) {
+            throw new wsError_1.TaosError(wsError_1.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) {
+                        throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, `StmtBindParams params type is not match! ${this.paramIndex} ${this.paramsCount} ${json_bigint_1.default.stringify({ dataType, columnType })} vs ${json_bigint_1.default.stringify({ dataType: this._fieldParams[this.paramIndex].dataType, columnType: this._fieldParams[this.paramIndex].columnType })}`);
+                    }
+                    this._fieldParams[this.paramIndex].params.push(...params);
+                }
+                else {
+                    let bindType = this._fields[this.paramIndex].bind_type || 0;
+                    this._fieldParams[this.paramIndex] = new FieldBindParams_1.FieldBindParams(params, dataType, typeLen, columnType, bindType);
+                    this._bindCount++;
+                }
+                this.paramIndex++;
+                if (this.paramIndex >= this.paramsCount) {
+                    this.paramIndex = 0;
+                }
+            }
+            else {
+                this._fieldParams.push(new FieldBindParams_1.FieldBindParams(params, dataType, typeLen, columnType, constant_1.FieldBindType.TAOS_FIELD_COL));
+            }
+        }
+    }
+    mergeParams(bindParams) {
+        if (!bindParams || !bindParams._fieldParams || bindParams._fieldParams.length === 0 || !this._fieldParams) {
+            throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "StmtBindParams params is invalid!");
+        }
+        this.paramIndex = 0;
+        for (let i = 0; i < bindParams._fieldParams.length; i++) {
+            let fieldParam = bindParams._fieldParams[i];
+            if (fieldParam) {
+                this.addParams(fieldParam.params, fieldParam.dataType, fieldParam.typeLen, fieldParam.columnType);
+            }
+        }
+    }
+    encode() {
+        this.paramIndex = 0;
+        if (!this._fieldParams || this._fieldParams.length == 0) {
+            throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "StmtBindParams params is invalid!");
+        }
+        if (this._rows > 0) {
+            if (this._rows !== this._fieldParams[0].params.length) {
+                throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "wrong row length!");
+            }
+        }
+        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 = (0, taosResult_1._isVarType)(fieldParam.columnType);
+            if (isVarType == constant_1.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(fieldParam.params, fieldParam.dataType, fieldParam.typeLen, fieldParam.columnType));
+            }
+        }
+    }
+    encodeVarColumns(params, dataType = 'number', typeLen, columnType) {
+        let isNull = [];
+        let dataLengths = [];
+        // TotalLength(4) + Type (4) + Num(4) + IsNull(1) * size + haveLength(1) + BufferLength(4) + 4 * v.length + totalLength
+        // 17 + (5 * params.length) + totalLength;
+        let totalLength = 17 + (5 * params.length);
+        const bytes = [];
+        for (let i = 0; i < params.length; i++) {
+            if (!(0, utils_1.isEmpty)(params[i])) {
+                isNull.push(0);
+                if (typeof params[i] == 'string') {
+                    let encoder = new TextEncoder().encode(params[i]);
+                    let length = encoder.length;
+                    totalLength += length;
+                    dataLengths.push(length);
+                    bytes.push(...encoder);
+                }
+                else if (params[i] instanceof ArrayBuffer) {
+                    //input arraybuffer, save not need encode
+                    let value = params[i];
+                    totalLength += value.byteLength;
+                    dataLengths.push(value.byteLength);
+                    bytes.push(...new Uint8Array(value));
+                }
+                else {
+                    throw new wsError_1.TaosError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "getColumString params is invalid! param_type:=" + typeof params[i]);
+                }
+            }
+            else {
+                isNull.push(1);
+            }
+        }
+        this._dataTotalLen += totalLength;
+        const dataBuffer = new Uint8Array(bytes).buffer;
+        return new wsColumnInfo_1.ColumnInfo([totalLength, dataBuffer], columnType, typeLen, this._rows, isNull, dataLengths, 1);
+    }
+    encodeDigitColumns(params, dataType = 'number', typeLen, columnType) {
+        let isNull = [];
+        // TotalLength(4) + Type (4) + Num(4) + IsNull(1) * size + haveLength(1) + BufferLength(4) + size * dataLen    
+        let dataLength = 17 + (typeLen + 1) * params.length;
+        let arrayBuffer = new ArrayBuffer(typeLen * params.length);
+        let dataBuffer = new DataView(arrayBuffer);
+        for (let i = 0; i < params.length; i++) {
+            if (!(0, utils_1.isEmpty)(params[i])) {
+                isNull.push(0);
+                this.writeDataToBuffer(dataBuffer, params[i], dataType, typeLen, columnType, i);
+            }
+            else {
+                isNull.push(1);
+                if (dataType === 'bigint') {
+                    this.writeDataToBuffer(dataBuffer, BigInt(0), dataType, typeLen, columnType, i);
+                }
+                else {
+                    this.writeDataToBuffer(dataBuffer, 0, dataType, typeLen, columnType, i);
+                }
+            }
+        }
+        this._dataTotalLen += dataLength;
+        return new wsColumnInfo_1.ColumnInfo([dataLength, dataBuffer.buffer], columnType, typeLen, this._rows, isNull);
+    }
+    encodeTimestampColumn(params, typeLen, columnType) {
+        let timeStamps = [];
+        for (let i = 0; i < params.length; i++) {
+            if (!(0, utils_1.isEmpty)(params[i])) {
+                let timeStamp = BigInt(0);
+                if (params[i] instanceof Date) {
+                    let date = params[i];
+                    //node only support milliseconds, need fill 0
+                    if (this.precisionLength == constant_1.PrecisionLength['us']) {
+                        timeStamp = BigInt(date.getTime() * 1000);
+                    }
+                    else if (this.precisionLength == constant_1.PrecisionLength['ns']) {
+                        timeStamp = BigInt(date.getTime() * 1000 * 1000);
+                    }
+                    else {
+                        timeStamp = BigInt(date.getTime());
+                    }
+                }
+                else if (typeof params[i] == 'bigint' || typeof params[i] == 'number') {
+                    if (typeof params[i] == 'number') {
+                        timeStamp = BigInt(params[i]);
+                    }
+                    else {
+                        timeStamp = params[i];
+                    }
+                }
+                timeStamps.push(timeStamp);
+            }
+            else {
+                //set bitmap bit is null
+                timeStamps.push(null);
+            }
+        }
+        return this.encodeDigitColumns(timeStamps, 'bigint', typeLen, columnType);
+    }
+}
+exports.Stmt2BindParams = Stmt2BindParams;

package/lib/src/stmt/wsParamsBase.d.ts

@@ -0,0 +1,45 @@
+import { FieldBindParams } from "./FieldBindParams";
+import { ColumnInfo } from "./wsColumnInfo";
+export interface IDataEncoder {
+    encode(): void;
+    addParams(params: any[], dataType: string, typeLen: number, columnType: number): void;
+    mergeParams(bindParams: StmtBindParams): void;
+}
+export declare abstract class StmtBindParams {
+    protected readonly precisionLength: number;
+    protected readonly _params: ColumnInfo[];
+    _fieldParams?: FieldBindParams[];
+    protected _dataTotalLen: number;
+    protected paramsCount: number;
+    protected _rows: number;
+    protected _bindCount: number;
+    constructor(precision?: number, paramsCount?: number);
+    abstract encode(): void;
+    abstract addParams(params: any[], dataType: string, typeLen: number, columnType: number): void;
+    addBindFieldParams(fieldParams: FieldBindParams): void;
+    abstract mergeParams(bindParams: StmtBindParams): void;
+    getBindCount(): number;
+    getDataRows(): number;
+    getDataTotalLen(): number;
+    getParams(): ColumnInfo[];
+    setBoolean(params: any[]): void;
+    setTinyInt(params: any[]): void;
+    setUTinyInt(params: any[]): void;
+    setSmallInt(params: any[]): void;
+    setUSmallInt(params: any[]): void;
+    setInt(params: any[]): void;
+    setUInt(params: any[]): void;
+    setBigint(params: any[]): void;
+    setUBigint(params: any[]): void;
+    setFloat(params: any[]): void;
+    setDouble(params: any[]): void;
+    setVarchar(params: any[]): void;
+    setBinary(params: any[]): void;
+    setNchar(params: any[]): void;
+    setJson(params: any[]): void;
+    setVarBinary(params: any[]): void;
+    setGeometry(params: any[]): void;
+    setTimestamp(params: any[]): void;
+    protected writeDataToBuffer(dataBuffer: DataView, params: any, dataType: string | undefined, typeLen: number, columnType: number, i: number): void;
+}
+//# sourceMappingURL=wsParamsBase.d.ts.map

package/lib/src/stmt/wsParamsBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsParamsBase.d.ts","sourceRoot":"","sources":["../../../src/stmt/wsParamsBase.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAG5C,MAAM,WAAW,YAAY;IACzB,MAAM,IAAI,IAAI,CAAC;IACf,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACtF,WAAW,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI,CAAC;CACjD;AAED,8BAAsB,cAAc;IAChC,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAC,MAAM,CAAwB;IACjE,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC;IACzC,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;IACjC,SAAS,CAAC,aAAa,EAAC,MAAM,CAAK;IACnC,SAAS,CAAC,WAAW,EAAE,MAAM,CAAK;IAClC,SAAS,CAAC,KAAK,SAAK;IACpB,SAAS,CAAC,UAAU,SAAK;gBAEb,SAAS,CAAC,EAAC,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;IAcnD,QAAQ,CAAC,MAAM,IAAI,IAAI;IAEvB,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAE9F,kBAAkB,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;IAUtD,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI;IAGtD,YAAY,IAAI,MAAM;IAItB,WAAW,IAAI,MAAM;IAIrB,eAAe,IAAI,MAAM;IAKlB,SAAS,IAAI,UAAU,EAAE;IAIhC,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE;IAOxB,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE;IAOxB,WAAW,CAAC,MAAM,EAAE,GAAG,EAAE;IAQzB,WAAW,CAAC,MAAM,EAAE,GAAG,EAAE;IASzB,YAAY,CAAC,MAAM,EAAE,GAAG,EAAE;IAQ1B,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE;IAQpB,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE;IAQrB,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE;IAQvB,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE;IAQxB,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE;IAQtB,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE;IAQvB,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE;IAQxB,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE;IAQvB,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE;IAOtB,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE;IAQrB,YAAY,CAAC,MAAM,EAAE,GAAG,EAAE;IAO1B,WAAW,CAAC,MAAM,EAAE,GAAG,EAAE;IAQzB,YAAY,CAAC,MAAM,EAAE,GAAG,EAAE;IAQ1B,SAAS,CAAC,iBAAiB,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,YAAW,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,EAAC,MAAM,GAAG,IAAI;CAmEnJ"}