@tdengine/websocket 3.0.0 → 3.1.0

package/{src/ut8Helper.ts → lib/src/common/ut8Helper.js}

@@ -1,42 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendRune = void 0;
 // Numbers fundamental to the encoding.
 // the "error" Rune or "Unicode replacement character"
-const RuneError = '\uFFFD'
+const RuneError = '\uFFFD';
 // Maximum valid Unicode code point.
-const MaxRune = '\U0010FFFF'
+const MaxRune = '\U0010FFFF';
 // Code points in the surrogate range are not valid for UTF-8.
-const surrogateMin = 0xD800
-const surrogateMax = 0xDFFF
+const surrogateMin = 0xD800;
+const surrogateMax = 0xDFFF;
 const tx = 128;
 const t2 = 192;
 const t3 = 224;
 const t4 = 240;
 const maskx = 63;
 const rune1Max = (1 << 7) - 1;
-
 const rune2Max = (1 << 11) - 1;
 const rune3Max = (1 << 16) - 1;
-
-
 // AppendRune appends the UTF-8 encoding of r to the end of p and
 // returns the extended buffer. If the rune is out of range,
 // it appends the encoding of RuneError.
-export function AppendRune(r:any) {
-    let p:Array<any> = [];
-    // console.log("== AppendRun r:");
-    // console.log(r)
+function appendRune(r) {
+    let p = [];
     if (r <= rune1Max) {
-        p.push(r & 0xff);  
+        p.push(r & 0xff);
         return Buffer.from(p).toString();
     }
     if (r <= rune2Max) {
-        p.push(t2 | ((r >> 6) & 0xff), tx | (r & 0xff) & maskx)
-    } else if ((r > MaxRune) || (surrogateMax <= r && r <= surrogateMax)) {
-        p.push(RuneError)
-    } else if (r <= rune3Max) {
-        p.push(t3 | ((r >> 12) & 0xff), tx | ((r >> 6) & 0xff) & maskx, tx | (r & 0xff) & maskx)
-    } else {
-        p.push(t4 | ((r >> 18) & 0xff), tx | ((r >> 12) & 0xff) & maskx, tx | ((r >> 6) & 0xff) & maskx, tx | (r & 0xff) & maskx)
+        p.push(t2 | ((r >> 6) & 0xff), tx | (r & 0xff) & maskx);
+    }
+    else if ((r > MaxRune) || (surrogateMax <= r && r <= surrogateMax)) {
+        p.push(RuneError);
+    }
+    else if (r <= rune3Max) {
+        p.push(t3 | ((r >> 12) & 0xff), tx | ((r >> 6) & 0xff) & maskx, tx | (r & 0xff) & maskx);
+    }
+    else {
+        p.push(t4 | ((r >> 18) & 0xff), tx | ((r >> 12) & 0xff) & maskx, tx | ((r >> 6) & 0xff) & maskx, tx | (r & 0xff) & maskx);
     }
-
     return Buffer.from(p).toString();
-}
+}
+exports.appendRune = appendRune;

package/lib/src/common/utils.d.ts

@@ -0,0 +1,5 @@
+import { WSConfig } from "./config";
+export declare function getUrl(wsConfig: WSConfig): URL;
+export declare function sleep(ms: number): Promise<void>;
+export declare function isEmpty(value: any): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/lib/src/common/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/common/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,wBAAgB,MAAM,CAAC,QAAQ,EAAC,QAAQ,GAAE,GAAG,CAe5C;AAED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAGD,wBAAgB,OAAO,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAM3C"}

package/lib/src/common/utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = exports.sleep = exports.getUrl = void 0;
+function getUrl(wsConfig) {
+    let url = new URL(wsConfig.getUrl());
+    if (wsConfig.getUser()) {
+        url.username = wsConfig.getUser() || '';
+    }
+    if (wsConfig.getPwd()) {
+        url.password = wsConfig.getPwd() || '';
+    }
+    let token = wsConfig.getToken();
+    if (token) {
+        url.searchParams.set("token", token);
+    }
+    url.pathname = '/ws';
+    return url;
+}
+exports.getUrl = getUrl;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;
+function isEmpty(value) {
+    if (value === null || value === undefined)
+        return true;
+    // if (typeof value === 'string' && value.trim() === '') return true;  
+    if (Array.isArray(value) && value.length === 0)
+        return true;
+    // if (typeof value === 'object' && Object.keys(value).length === 0) return true;  
+    return false;
+}
+exports.isEmpty = isEmpty;

package/lib/src/common/wsError.d.ts

@@ -0,0 +1,29 @@
+export declare class TDWebSocketClientError extends Error {
+    code: number;
+    constructor(code: number, message?: string);
+}
+export declare class WebSocketQueryError extends TDWebSocketClientError {
+}
+export declare class WebSocketInterfaceError extends TDWebSocketClientError {
+}
+export declare class WebSocketQueryInterFaceError extends WebSocketInterfaceError {
+}
+export declare class TaosResultError extends TDWebSocketClientError {
+}
+export declare class TaosError extends TDWebSocketClientError {
+}
+export declare enum ErrorCode {
+    ERR_INVALID_PARAMS = 100,
+    ERR_INVALID_URL = 101,
+    ERR_WS_NO_CALLBACK = 102,
+    ERR_INVALID_MESSAGE_TYPE = 103,
+    ERR_WEBSOCKET_CONNECTION_FAIL = 104,
+    ERR_WEBSOCKET_QUERY_TIMEOUT = 105,
+    ERR_INVALID_AUTHENTICATION = 106,
+    ERR_UNSUPPORTED_TDENGINE_TYPE = 107,
+    ERR_CONNECTION_CLOSED = 108,
+    ERR_INVALID_FETCH_MESSAGE_DATA = 109,
+    ERR_WEBSOCKET_CONNECTION_ARRIVED_LIMIT = 110,
+    ERR_PARTITIONS_TOPIC_VGROUP_LENGTH_NOT_EQUAL = 111
+}
+//# sourceMappingURL=wsError.d.ts.map

package/lib/src/common/wsError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsError.d.ts","sourceRoot":"","sources":["../../../src/common/wsError.ts"],"names":[],"mappings":"AAAA,qBAAa,sBAAuB,SAAQ,KAAK;IAC7C,IAAI,EAAC,MAAM,CAAK;gBACJ,IAAI,EAAC,MAAM,EAAE,OAAO,GAAE,MAAW;CAahD;AACD,qBAAa,mBAAoB,SAAQ,sBAAsB;CAAI;AACnE,qBAAa,uBAAwB,SAAQ,sBAAsB;CAAG;AACtE,qBAAa,4BAA6B,SAAQ,uBAAuB;CAAE;AAC3E,qBAAa,eAAgB,SAAQ,sBAAsB;CAAE;AAC7D,qBAAa,SAAU,SAAQ,sBAAsB;CAAE;AAEvD,oBAAY,SAAS;IACjB,kBAAkB,MAAM;IACxB,eAAe,MAAM;IACrB,kBAAkB,MAAM;IACxB,wBAAwB,MAAM;IAC9B,6BAA6B,MAAM;IACnC,2BAA2B,MAAM;IACjC,0BAA0B,MAAM;IAChC,6BAA6B,MAAM;IACnC,qBAAqB,MAAM;IAC3B,8BAA8B,MAAM;IACpC,sCAAsC,MAAM;IAC5C,4CAA4C,MAAM;CAErD"}

package/lib/src/common/wsError.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = exports.TaosError = exports.TaosResultError = exports.WebSocketQueryInterFaceError = exports.WebSocketInterfaceError = exports.WebSocketQueryError = exports.TDWebSocketClientError = void 0;
+class TDWebSocketClientError extends Error {
+    constructor(code, message = '') {
+        super(message);
+        this.code = 0;
+        this.name = new.target.name;
+        this.code = code;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, new.target);
+        }
+        if (typeof Object.setPrototypeOf === 'function') {
+            Object.setPrototypeOf(this, new.target.prototype);
+        }
+        else {
+            this.__proto__ = new.target.prototype;
+        }
+    }
+}
+exports.TDWebSocketClientError = TDWebSocketClientError;
+class WebSocketQueryError extends TDWebSocketClientError {
+}
+exports.WebSocketQueryError = WebSocketQueryError;
+class WebSocketInterfaceError extends TDWebSocketClientError {
+}
+exports.WebSocketInterfaceError = WebSocketInterfaceError;
+class WebSocketQueryInterFaceError extends WebSocketInterfaceError {
+}
+exports.WebSocketQueryInterFaceError = WebSocketQueryInterFaceError;
+class TaosResultError extends TDWebSocketClientError {
+}
+exports.TaosResultError = TaosResultError;
+class TaosError extends TDWebSocketClientError {
+}
+exports.TaosError = TaosError;
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["ERR_INVALID_PARAMS"] = 100] = "ERR_INVALID_PARAMS";
+    ErrorCode[ErrorCode["ERR_INVALID_URL"] = 101] = "ERR_INVALID_URL";
+    ErrorCode[ErrorCode["ERR_WS_NO_CALLBACK"] = 102] = "ERR_WS_NO_CALLBACK";
+    ErrorCode[ErrorCode["ERR_INVALID_MESSAGE_TYPE"] = 103] = "ERR_INVALID_MESSAGE_TYPE";
+    ErrorCode[ErrorCode["ERR_WEBSOCKET_CONNECTION_FAIL"] = 104] = "ERR_WEBSOCKET_CONNECTION_FAIL";
+    ErrorCode[ErrorCode["ERR_WEBSOCKET_QUERY_TIMEOUT"] = 105] = "ERR_WEBSOCKET_QUERY_TIMEOUT";
+    ErrorCode[ErrorCode["ERR_INVALID_AUTHENTICATION"] = 106] = "ERR_INVALID_AUTHENTICATION";
+    ErrorCode[ErrorCode["ERR_UNSUPPORTED_TDENGINE_TYPE"] = 107] = "ERR_UNSUPPORTED_TDENGINE_TYPE";
+    ErrorCode[ErrorCode["ERR_CONNECTION_CLOSED"] = 108] = "ERR_CONNECTION_CLOSED";
+    ErrorCode[ErrorCode["ERR_INVALID_FETCH_MESSAGE_DATA"] = 109] = "ERR_INVALID_FETCH_MESSAGE_DATA";
+    ErrorCode[ErrorCode["ERR_WEBSOCKET_CONNECTION_ARRIVED_LIMIT"] = 110] = "ERR_WEBSOCKET_CONNECTION_ARRIVED_LIMIT";
+    ErrorCode[ErrorCode["ERR_PARTITIONS_TOPIC_VGROUP_LENGTH_NOT_EQUAL"] = 111] = "ERR_PARTITIONS_TOPIC_VGROUP_LENGTH_NOT_EQUAL";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));

package/{src/wsOptions.ts → lib/src/common/wsOptions.d.ts}

@@ -2,13 +2,15 @@ export interface User {
     user?: string;
     passwd?: string;
 }
-
 export interface Uri {
     scheme: string;
     url?: string;
     host?: string | undefined | null;
     path: '/rest/sql/' | string;
     port?: number | undefined | null;
-    query?: { [key: string]: string };
+    query?: {
+        [key: string]: string;
+    };
     fragment?: string | undefined | null;
 }
+//# sourceMappingURL=wsOptions.d.ts.map

package/lib/src/common/wsOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsOptions.d.ts","sourceRoot":"","sources":["../../../src/common/wsOptions.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,IAAI;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,GAAG;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACjC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACjC,KAAK,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;CACxC"}

package/lib/src/common/wsOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/index.d.ts

@@ -0,0 +1,9 @@
+import { WsSql } from './sql/wsSql';
+import { WSConfig } from './common/config';
+import { WsConsumer } from './tmq/wsTmq';
+declare let sqlConnect: (conf: WSConfig) => Promise<WsSql>;
+declare let tmqConnect: (configMap: Map<string, string>) => Promise<WsConsumer>;
+declare let setLogLevel: (level: string) => void;
+declare let destroy: () => void;
+export { sqlConnect, tmqConnect, setLogLevel, destroy };
+//# sourceMappingURL=index.d.ts.map

package/lib/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAKzC,QAAA,IAAI,UAAU,SAAgB,QAAQ,mBAQrC,CAAC;AAEF,QAAA,IAAI,UAAU,cAAqB,IAAI,MAAM,EAAE,MAAM,CAAC,wBAOrD,CAAC;AAEF,QAAA,IAAI,WAAW,UAAW,MAAM,SAE/B,CAAC;AAEF,QAAA,IAAI,OAAO,YAEV,CAAC;AACF,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC"}

package/lib/src/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroy = exports.setLogLevel = exports.tmqConnect = exports.sqlConnect = void 0;
+const wsSql_1 = require("./sql/wsSql");
+const wsTmq_1 = require("./tmq/wsTmq");
+const log_1 = __importStar(require("./common/log"));
+const wsConnectorPool_1 = require("./client/wsConnectorPool");
+let sqlConnect = async (conf) => {
+    try {
+        return await wsSql_1.WsSql.open(conf);
+    }
+    catch (err) {
+        log_1.default.error(err);
+        throw err;
+    }
+};
+exports.sqlConnect = sqlConnect;
+let tmqConnect = async (configMap) => {
+    try {
+        return await wsTmq_1.WsConsumer.newConsumer(configMap);
+    }
+    catch (err) {
+        log_1.default.error(err);
+        throw err;
+    }
+};
+exports.tmqConnect = tmqConnect;
+let setLogLevel = (level) => {
+    (0, log_1.setLevel)(level);
+};
+exports.setLogLevel = setLogLevel;
+let destroy = () => {
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+};
+exports.destroy = destroy;

package/lib/src/sql/wsProto.d.ts

@@ -0,0 +1,26 @@
+export interface SchemalessMessageInfo {
+    action: string;
+    args: SchemalessParamsInfo;
+}
+export interface SchemalessParamsInfo {
+    req_id?: number | undefined | null;
+    protocol: number;
+    ttl?: number;
+    precision: string;
+    data: string;
+}
+export declare enum Precision {
+    NOT_CONFIGURED = "",
+    HOURS = "h",
+    MINUTES = "m",
+    SECONDS = "s",
+    MILLI_SECONDS = "ms",
+    MICRO_SECONDS = "u",
+    NANO_SECONDS = "ns"
+}
+export declare enum SchemalessProto {
+    InfluxDBLineProtocol = 1,
+    OpenTSDBTelnetLineProtocol = 2,
+    OpenTSDBJsonFormatProtocol = 3
+}
+//# sourceMappingURL=wsProto.d.ts.map

package/lib/src/sql/wsProto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsProto.d.ts","sourceRoot":"","sources":["../../../src/sql/wsProto.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,oBAAoB,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACjC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,oBAAY,SAAS;IACjB,cAAc,KAAK;IACnB,KAAK,MAAM;IACX,OAAO,MAAM;IACb,OAAO,MAAM;IACb,aAAa,OAAO;IACpB,aAAa,MAAM;IACnB,YAAY,OAAO;CACtB;AAED,oBAAY,eAAe;IACvB,oBAAoB,IAAU;IAC9B,0BAA0B,IAAI;IAC9B,0BAA0B,IAAI;CACjC"}

package/lib/src/sql/wsProto.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemalessProto = exports.Precision = void 0;
+var Precision;
+(function (Precision) {
+    Precision["NOT_CONFIGURED"] = "";
+    Precision["HOURS"] = "h";
+    Precision["MINUTES"] = "m";
+    Precision["SECONDS"] = "s";
+    Precision["MILLI_SECONDS"] = "ms";
+    Precision["MICRO_SECONDS"] = "u";
+    Precision["NANO_SECONDS"] = "ns";
+})(Precision || (exports.Precision = Precision = {}));
+var SchemalessProto;
+(function (SchemalessProto) {
+    SchemalessProto[SchemalessProto["InfluxDBLineProtocol"] = 1] = "InfluxDBLineProtocol";
+    SchemalessProto[SchemalessProto["OpenTSDBTelnetLineProtocol"] = 2] = "OpenTSDBTelnetLineProtocol";
+    SchemalessProto[SchemalessProto["OpenTSDBJsonFormatProtocol"] = 3] = "OpenTSDBJsonFormatProtocol";
+})(SchemalessProto || (exports.SchemalessProto = SchemalessProto = {}));

package/lib/src/sql/wsRows.d.ts

@@ -0,0 +1,16 @@
+import { TDengineMeta } from '../common/taosResult';
+import { WSQueryResponse } from '../client/wsResponse';
+import { WsClient } from '../client/wsClient';
+export declare class WSRows {
+    private _wsClient;
+    private readonly _wsQueryResponse;
+    private _taosResult;
+    private _isClose;
+    constructor(wsInterface: WsClient, resp: WSQueryResponse);
+    next(): Promise<boolean>;
+    private getBlockData;
+    getMeta(): Array<TDengineMeta> | null;
+    getData(): Array<any> | undefined;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=wsRows.d.ts.map

package/lib/src/sql/wsRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsRows.d.ts","sourceRoot":"","sources":["../../../src/sql/wsRows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,sBAAsB,CAAC;AAEhE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAG9C,qBAAa,MAAM;IACf,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkB;IACnD,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,QAAQ,CAAW;gBACf,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,eAAe;IAOlD,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;YAoBhB,YAAY;IAkB1B,OAAO,IAAG,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI;IAIpC,OAAO,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,SAAS;IAc3B,KAAK,IAAG,OAAO,CAAC,IAAI,CAAC;CAQ9B"}

package/lib/src/sql/wsRows.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSRows = void 0;
+const taosResult_1 = require("../common/taosResult");
+const wsError_1 = require("../common/wsError");
+const log_1 = __importDefault(require("../common/log"));
+class WSRows {
+    constructor(wsInterface, resp) {
+        this._wsClient = wsInterface;
+        this._wsQueryResponse = resp;
+        this._taosResult = new taosResult_1.TaosResult(resp);
+        this._isClose = false;
+    }
+    async next() {
+        if (this._wsQueryResponse.is_update || this._isClose) {
+            log_1.default.debug("WSRows::Next::End=>", this._taosResult, this._isClose);
+            return false;
+        }
+        let data = this._taosResult.getData();
+        if (this._taosResult && data != null) {
+            if (data && Array.isArray(this._taosResult.getData()) && data.length > 0) {
+                return true;
+            }
+        }
+        this._taosResult = await this.getBlockData();
+        if (this._taosResult.getData()) {
+            return true;
+        }
+        return false;
+    }
+    async getBlockData() {
+        try {
+            let wsFetchResponse = await this._wsClient.fetch(this._wsQueryResponse);
+            log_1.default.debug("[wsQuery.execute.wsFetchResponse]==>\n", wsFetchResponse);
+            if (wsFetchResponse.completed) {
+                this.close();
+                this._taosResult.setData(null);
+            }
+            else {
+                this._taosResult.setRowsAndTime(wsFetchResponse.rows, wsFetchResponse.timing);
+                return await this._wsClient.fetchBlock(wsFetchResponse, this._taosResult);
+            }
+            return this._taosResult;
+        }
+        catch (err) {
+            this.close();
+            throw new wsError_1.TaosResultError(err.code, err.message);
+        }
+    }
+    getMeta() {
+        return this._taosResult.getMeta();
+    }
+    getData() {
+        if (this._wsQueryResponse.is_update) {
+            return undefined;
+        }
+        let data = this._taosResult.getData();
+        if (this._taosResult && data != null) {
+            if (Array.isArray(data) && data.length > 0) {
+                return data.pop();
+            }
+        }
+        return undefined;
+    }
+    async close() {
+        if (this._isClose) {
+            return;
+        }
+        this._isClose = true;
+        await this._wsClient.freeResult(this._wsQueryResponse);
+    }
+}
+exports.WSRows = WSRows;

package/lib/src/sql/wsSql.d.ts

@@ -0,0 +1,24 @@
+import { WSRows } from './wsRows';
+import { TaosResult } from '../common/taosResult';
+import { WSConfig } from '../common/config';
+import { Precision, SchemalessProto } from './wsProto';
+import { WsStmt } from '../stmt/wsStmt';
+export declare class WsSql {
+    private wsConfig;
+    private _wsClient;
+    constructor(wsConfig: WSConfig);
+    static open(wsConfig: WSConfig): Promise<WsSql>;
+    state(): number;
+    /**
+     * return client version.
+     */
+    version(): Promise<string>;
+    close(): Promise<void>;
+    schemalessInsert(lines: Array<string>, protocol: SchemalessProto, precision: Precision, ttl: number, reqId?: number): Promise<void>;
+    stmtInit(reqId?: number): Promise<WsStmt>;
+    exec(sql: string, reqId?: number, action?: string): Promise<TaosResult>;
+    private executeSchemalessInsert;
+    query(sql: string, reqId?: number): Promise<WSRows>;
+    private getSql;
+}
+//# sourceMappingURL=wsSql.d.ts.map

package/lib/src/sql/wsSql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsSql.d.ts","sourceRoot":"","sources":["../../../src/sql/wsSql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAGjD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAG3C,OAAO,EAAE,SAAS,EAAyB,eAAe,EAAE,MAAM,WAAW,CAAA;AAC7E,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAKvC,qBAAa,KAAK;IACd,OAAO,CAAC,QAAQ,CAAU;IAC1B,OAAO,CAAC,SAAS,CAAW;gBAChB,QAAQ,EAAC,QAAQ;WAMhB,IAAI,CAAC,QAAQ,EAAC,QAAQ,GAAE,OAAO,CAAC,KAAK,CAAC;IAmBnD,KAAK;IAIL;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAI1B,KAAK,IAAG,OAAO,CAAC,IAAI,CAAC;IAIrB,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BnI,QAAQ,CAAC,KAAK,CAAC,EAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAuBxC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,GAAC,MAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;YA6BvE,uBAAuB;IAa/B,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASxD,OAAO,CAAC,MAAM;CAYjB"}

package/lib/src/sql/wsSql.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsSql = void 0;
+const wsRows_1 = require("./wsRows");
+const taosResult_1 = require("../common/taosResult");
+const wsClient_1 = require("../client/wsClient");
+const wsError_1 = require("../common/wsError");
+const utils_1 = require("../common/utils");
+const wsStmt_1 = require("../stmt/wsStmt");
+const reqid_1 = require("../common/reqid");
+const constant_1 = require("../common/constant");
+const log_1 = __importDefault(require("../common/log"));
+class WsSql {
+    constructor(wsConfig) {
+        let url = (0, utils_1.getUrl)(wsConfig);
+        this._wsClient = new wsClient_1.WsClient(url, wsConfig.getTimeOut());
+        this.wsConfig = wsConfig;
+    }
+    static async open(wsConfig) {
+        if (!wsConfig.getUrl()) {
+            throw new wsError_1.WebSocketInterfaceError(wsError_1.ErrorCode.ERR_INVALID_URL, 'invalid url, password or username needed.');
+        }
+        let wsSql = new WsSql(wsConfig);
+        let database = wsConfig.getDb();
+        try {
+            await wsSql._wsClient.connect(database);
+            if (database && database.length > 0) {
+                await wsSql.exec(`use ${database}`);
+            }
+            return wsSql;
+        }
+        catch (e) {
+            log_1.default.error(e.code, e.message);
+            throw (e);
+        }
+    }
+    state() {
+        return this._wsClient.getState();
+    }
+    /**
+     * return client version.
+     */
+    async version() {
+        return await this._wsClient.version();
+    }
+    async close() {
+        await this._wsClient.close();
+    }
+    async schemalessInsert(lines, protocol, precision, ttl, reqId) {
+        let data = '';
+        if (!lines || lines.length == 0 || !protocol) {
+            throw new wsError_1.TaosResultError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, 'WsSchemaless Insert params is error!');
+        }
+        lines.forEach((element, index) => {
+            data += element;
+            if (index < lines.length - 1) {
+                data += '\n';
+            }
+        });
+        let queryMsg = {
+            action: 'insert',
+            args: {
+                req_id: reqid_1.ReqId.getReqID(reqId),
+                protocol: protocol,
+                precision: precision,
+                data: data,
+                ttl: ttl,
+            },
+        };
+        return await this.executeSchemalessInsert(queryMsg);
+    }
+    async stmtInit(reqId) {
+        if (this._wsClient) {
+            try {
+                let precision = constant_1.PrecisionLength["ms"];
+                if (this.wsConfig.getDb()) {
+                    let sql = "select `precision` from information_schema.ins_databases where name = '" + this.wsConfig.getDb() + "'";
+                    let result = await this.exec(sql);
+                    let data = result.getData();
+                    if (data && data[0] && data[0][0]) {
+                        precision = constant_1.PrecisionLength[data[0][0]];
+                    }
+                }
+                return await wsStmt_1.WsStmt.newStmt(this._wsClient, precision, reqId);
+            }
+            catch (e) {
+                log_1.default.error(e.code, e.message);
+                throw (e);
+            }
+        }
+        throw (new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "stmt connect closed"));
+    }
+    async exec(sql, reqId, action = 'query') {
+        try {
+            let wsQueryResponse = await this._wsClient.exec(this.getSql(sql, reqId, action));
+            let taosResult = new taosResult_1.TaosResult(wsQueryResponse);
+            if (wsQueryResponse.is_update) {
+                return taosResult;
+            }
+            else {
+                try {
+                    while (true) {
+                        let wsFetchResponse = await this._wsClient.fetch(wsQueryResponse);
+                        if (wsFetchResponse.completed) {
+                            break;
+                        }
+                        else {
+                            taosResult.setRowsAndTime(wsFetchResponse.rows, wsFetchResponse.timing);
+                            taosResult = await this._wsClient.fetchBlock(wsFetchResponse, taosResult);
+                        }
+                    }
+                    return taosResult;
+                }
+                catch (err) {
+                    throw new wsError_1.TaosResultError(err.code, err.message);
+                }
+                finally {
+                    this._wsClient.freeResult(wsQueryResponse);
+                }
+            }
+        }
+        catch (err) {
+            throw new wsError_1.TaosResultError(err.code, err.message);
+        }
+    }
+    async executeSchemalessInsert(queryMsg) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let reqMsg = JSON.stringify(queryMsg);
+                let result = await this._wsClient.exec(reqMsg);
+                log_1.default.debug("executeSchemalessInsert:", reqMsg, result);
+                resolve();
+            }
+            catch (e) {
+                reject(new wsError_1.TaosResultError(e.code, e.message));
+            }
+        });
+    }
+    async query(sql, reqId) {
+        try {
+            let wsQueryResponse = await this._wsClient.exec(this.getSql(sql, reqId));
+            return new wsRows_1.WSRows(this._wsClient, wsQueryResponse);
+        }
+        catch (err) {
+            throw new wsError_1.TaosResultError(err.code, err.message);
+        }
+    }
+    getSql(sql, reqId, action = 'query') {
+        // construct msg
+        let queryMsg = {
+            action: action,
+            args: {
+                req_id: reqid_1.ReqId.getReqID(reqId),
+                sql: sql,
+                id: 0
+            },
+        };
+        return JSON.stringify(queryMsg);
+    }
+}
+exports.WsSql = WsSql;