@tdengine/websocket 3.0.0

package/src/constant.ts

@@ -0,0 +1,74 @@
+interface IndexableString {
+    [index: number]: string
+}
+
+interface StringIndexable {
+    [index: string]: number
+}
+
+export const TDengineTypeName: IndexableString = {
+    0: 'NULL',
+    1: 'BOOL',
+    2: 'TINYINT',
+    3: 'SMALLINT',
+    4: 'INT',
+    5: 'BIGINT',
+    6: 'FLOAT',
+    7: 'DOUBLE',
+    8: 'VARCHAR',
+    9: 'TIMESTAMP',
+    10: 'NCHAR',
+    11: 'TINYINT UNSIGNED',
+    12: 'SMALLINT UNSIGNED',
+    13: 'INT UNSIGNED',
+    14: 'BIGINT UNSIGNED',
+    15: 'JSON',
+}
+
+export const ColumnsBlockType: StringIndexable = {
+    'SOLID': 0,
+    'VARCHAR': 1,
+    'NCHAR': 2
+}
+
+
+export const TDengineTypeCode: StringIndexable = {
+    'NULL': 0,
+    'BOOL': 1,
+    'TINYINT': 2,
+    'SMALLINT': 3,
+    'INT': 4,
+    'BIGINT': 5,
+    'FLOAT': 6,
+    'DOUBLE': 7,
+    'BINARY': 8,
+    'VARCHAR': 8,
+    'TIMESTAMP': 9,
+    'NCHAR': 10,
+    'TINYINT UNSIGNED': 11,
+    'SMALLINT UNSIGNED': 12,
+    'INT UNSIGNED': 13,
+    'BIGINT UNSIGNED': 14,
+    'JSON': 15,
+}
+
+export const TDenginePrecision: IndexableString = {
+    0: 'MILLISECOND',
+    1: "MICROSECOND",
+    2: "NANOSECOND",
+}
+
+export const TDengineTypeLength: StringIndexable = {
+    'BOOL': 1,
+    'TINYINT': 1,
+    'SMALLINT': 2,
+    'INT': 4,
+    'BIGINT': 8,
+    'FLOAT': 4,
+    'DOUBLE': 8,
+    'TIMESTAMP': 8,
+    'TINYINT UNSIGNED': 1,
+    'SMALLINT UNSIGNED': 2,
+    'INT UNSIGNED': 4,
+    'BIGINT UNSIGNED': 8,
+}

package/src/taosResult.ts

@@ -0,0 +1,269 @@
+import { WSFetchBlockResponse, WSFetchResponse, WSQueryResponse } from "./wsQueryResponse";
+import { ColumnsBlockType, TDengineTypeCode, TDengineTypeName } from './constant'
+import { TaosResultError, WebSocketQueryInterFaceError } from "./wsError";
+import { AppendRune } from "./ut8Helper"
+
+export class TaosResult {
+    meta: Array<ResponseMeta> | null;
+    data: Array<Array<any>> | null;
+    precision: number = 0;
+    affectRows: number = 0;
+    /** unit nano seconds */
+    timing: bigint;
+    constructor(queryResponse: WSQueryResponse) {
+        if (queryResponse.is_update == true) {
+            this.meta = null
+            this.data = null
+        } else {
+            if (queryResponse.fields_count && queryResponse.fields_names && queryResponse.fields_types && queryResponse.fields_lengths) {
+                let _meta = [];
+                for (let i = 0; i < queryResponse.fields_count; i++) {
+                    _meta.push({
+                        name: queryResponse.fields_names[i],
+                        type: queryResponse.fields_types[i],
+                        length: queryResponse.fields_lengths[i]
+                    })
+                }
+                this.meta = _meta;
+            } else {
+                throw new TaosResultError(`fields_count,fields_names,fields_types,fields_lengths of the update query response should be null`)
+            }
+            this.data = [];
+        }
+
+        this.affectRows = queryResponse.affected_rows
+        this.timing = queryResponse.timing
+        this.precision = queryResponse.precision
+        // console.log(`typeof this.timing:${typeof this.timing}, typeof fetchResponse.timing:${typeof queryResponse.timing}`)
+    }
+
+    setRows(fetchResponse: WSFetchResponse) {
+        this.affectRows += fetchResponse.rows;
+        // console.log(`typeof this.timing:${typeof this.timing}, typeof fetchResponse.timing:${typeof fetchResponse.timing}`)
+        this.timing = this.timing + fetchResponse.timing
+    }
+
+    setData(fetchBlockResponse: WSFetchBlockResponse) {
+        if (this.data) {
+            this.data.push([])
+        } else {
+            throw new TaosResultError(`update query response cannot set data`)
+        }
+
+    }
+    /**
+     * Mapping the WebSocket response type code to TDengine's type name. 
+     */
+    getTDengineMeta(): Array<TDengineMeta> | null {
+        if (this.meta) {
+            let _ = new Array<TDengineMeta>()
+            this.meta.forEach(m => {
+                _.push({
+                    name: m.name,
+                    type: TDengineTypeName[m.type],
+                    length: m.length
+                })
+            })
+            return _;
+        } else {
+            return null;
+        }
+    }
+
+}
+
+interface TDengineMeta {
+    name: string,
+    type: string,
+    length: number,
+}
+interface ResponseMeta {
+    name: string,
+    type: number,
+    length: number,
+}
+
+export function parseBlock(fetchResponse: WSFetchResponse, blocks: WSFetchBlockResponse, taosResult: TaosResult): TaosResult {
+
+    if (taosResult.meta && taosResult.data) {
+        let metaList = taosResult.meta;
+
+        // console.log(typeof taosResult.timing)
+        // console.log(typeof blocks.timing)
+        // console.log(blocks.id)
+
+        taosResult.timing = BigInt(taosResult.timing) + blocks.timing
+
+        const INT_32_SIZE = 4;
+
+        // Offset num of bytes from rawBlockBuffer.
+        let bufferOffset = (4 * 5) + 8 + (4 + 1) * metaList.length
+        let colLengthBlockSize = INT_32_SIZE * metaList.length
+        // console.log("===colLengthBlockSize:" + colLengthBlockSize)
+
+        let bitMapSize = (fetchResponse.rows + (1 << 3) - 1) >> 3
+
+        // whole raw block ArrayBuffer
+        let dataBuffer = blocks.data.slice(bufferOffset);
+
+        // record the head of column in block
+        let colBlockHead = 0;
+        for (let i = 0; i < fetchResponse.rows; i++) {
+            let row = [];
+            // point to the head of the column in the block
+            colBlockHead = 0 + colLengthBlockSize;
+            // point to the head of columns's data in the block (include bitMap and offsetArray)
+            let colDataHead = colBlockHead;
+            // traverse row after row. 
+            for (let j = 0; j < metaList.length; j++) {
+
+                let isVarType = _isVarTye(metaList[j])
+                // console.log("== dataBuffer Length:" + dataBuffer.byteLength)
+                // console.log("== loop i:" + i + "J=" + j + "col:" + metaList[j].name + "type:" + metaList[j].type)
+                // console.log("== loop isVarType:" + isVarType);
+                if (isVarType == ColumnsBlockType.SOLID) {
+
+                    colDataHead = colBlockHead + bitMapSize + metaList[j].length * i
+
+                    let byteArrayIndex = i >> 3;
+                    let bitwiseOffset = 7 - (i & 7)
+                    let bitMapArr = dataBuffer.slice(colBlockHead, colBlockHead + bitMapSize)
+                    // console.log("==i:" + i + "byteArrayIndex=" + byteArrayIndex)
+                    // console.log("== loop colblockhead:" + colBlockHead)
+                    // console.log("== loop bitmap:" + bitMapSize)
+                    // console.log("== loop bitMap length=" + bitMapArr.byteLength)
+                    // console.log("==loop bitMap bitwiseoffset:" + bitwiseOffset + "byteArrayIndex:" + byteArrayIndex)
+                    let bitFlag = ((new DataView(bitMapArr).getUint8(byteArrayIndex)) & (1 << bitwiseOffset)) >> bitwiseOffset
+
+                    if (bitFlag == 1) {
+                        row.push("NULL")
+                    } else {
+                        row.push(readSolidData(dataBuffer, colDataHead, metaList[j]))
+                    }
+                    // console.log("=====(new DataView(dataBuffer, INT_32_SIZE * j, INT_32_SIZE).getInt32(0))=" + (new DataView(dataBuffer, INT_32_SIZE * j, INT_32_SIZE).getInt32(0, true)));
+                    colBlockHead = colBlockHead + bitMapSize + (new DataView(dataBuffer, INT_32_SIZE * j, INT_32_SIZE).getInt32(0, true))
+
+                } else {
+                    // if null check
+                    let varOffset = new DataView(dataBuffer, colBlockHead + (INT_32_SIZE * i), INT_32_SIZE).getInt32(0, true)
+                    // console.log("== var type offset:" + varOffset)
+                    if (varOffset == -1) {
+                        row.push("NULL")
+                        colBlockHead = colBlockHead + INT_32_SIZE * fetchResponse.rows + (new DataView(dataBuffer, j * INT_32_SIZE, INT_32_SIZE).getInt32(0, true))
+                    } else {
+                        colDataHead = colBlockHead + INT_32_SIZE * fetchResponse.rows + varOffset
+                        let dataLength = (new DataView(dataBuffer, colDataHead, 2).getInt16(0, true))
+                        // console.log("== loop var type length:" + dataLength)
+                        if (isVarType == ColumnsBlockType.VARCHAR) {
+
+                            row.push(readVarchar(dataBuffer, colDataHead + 2, dataLength))
+
+                        } else {
+                            row.push(readNchar(dataBuffer, colDataHead + 2, dataLength))
+                        }
+                        colBlockHead = colBlockHead + INT_32_SIZE * fetchResponse.rows + (new DataView(dataBuffer, j * INT_32_SIZE, INT_32_SIZE).getInt32(0, true))
+                    }
+                }
+            }
+            taosResult.data.push(row);
+        }
+        return taosResult;
+    } else {
+        throw new TaosResultError("cannot fetch block for an update query.")
+    }
+
+}
+
+function _isVarTye(meta: ResponseMeta): Number {
+    switch (meta.type) {
+        case TDengineTypeCode['NCHAR']: {
+            return ColumnsBlockType['NCHAR']
+        }
+        case TDengineTypeCode['VARCHAR']: {
+            return ColumnsBlockType['VARCHAR']
+        }
+        case TDengineTypeCode['BINARY']: {
+            return ColumnsBlockType['VARCHAR']
+        }
+        case TDengineTypeCode['JSON']: {
+            return ColumnsBlockType['VARCHAR']
+        }
+        default: {
+            return ColumnsBlockType['SOLID']
+        }
+    }
+}
+
+function readSolidData(dataBuffer: ArrayBuffer, colDataHead: number, meta: ResponseMeta): Number | Boolean | BigInt {
+
+    switch (meta.type) {
+        case TDengineTypeCode['BOOL']: {
+            return (Boolean)(new DataView(dataBuffer, colDataHead, 1).getInt8(0))
+        }
+        case TDengineTypeCode['TINYINT']: {
+            return (new DataView(dataBuffer, colDataHead, 1).getInt8(0))
+        }
+        case TDengineTypeCode['SMALLINT']: {
+            return (new DataView(dataBuffer, colDataHead, 2).getInt16(0, true))
+        }
+        case TDengineTypeCode['INT']: {
+            return (new DataView(dataBuffer, colDataHead, 4).getInt32(0, true))
+        }
+        case TDengineTypeCode['BIGINT']: {
+            return (new DataView(dataBuffer, colDataHead, 8).getBigInt64(0, true))
+        }
+        case TDengineTypeCode['TINYINT UNSIGNED']: {
+            return (new DataView(dataBuffer, colDataHead, 1).getUint8(0))
+        }
+        case TDengineTypeCode['SMALLINT UNSIGNED']: {
+            return (new DataView(dataBuffer, colDataHead, 2).getUint16(0, true))
+        }
+        case TDengineTypeCode['INT UNSIGNED']: {
+            return (new DataView(dataBuffer, colDataHead, 4).getUint32(0, true))
+        }
+        case TDengineTypeCode['BIGINT UNSIGNED']: {
+            return (new DataView(dataBuffer, colDataHead, 8).getBigUint64(0, true))
+        }
+        case TDengineTypeCode['FLOAT']: {
+            return (parseFloat(new DataView(dataBuffer, colDataHead, 4).getFloat32(0, true).toFixed(5)) )
+        }
+        case TDengineTypeCode['DOUBLE']: {
+            return (parseFloat(new DataView(dataBuffer, colDataHead, 8).getFloat64(0, true).toFixed(15)))
+        }
+        case TDengineTypeCode['TIMESTAMP']: {
+            return (new DataView(dataBuffer, colDataHead, 8).getBigInt64(0, true))
+            // could change 
+        }
+        default: {
+            throw new WebSocketQueryInterFaceError(`unspported type ${meta.type} for column ${meta.name}`)
+        }
+    }
+}
+
+
+function readVarchar(dataBuffer: ArrayBuffer, colDataHead: number, length: number): string {
+    let data = "";
+    data += new TextDecoder().decode(dataBuffer.slice(colDataHead, colDataHead + length))
+    return data;
+}
+
+function readNchar(dataBuffer: ArrayBuffer, colDataHead: number, length: number): string {
+    let decoder = new TextDecoder();
+    let data = "";
+    let buff: ArrayBuffer = dataBuffer.slice(colDataHead, colDataHead + length);
+    for (let i = 0; i < length / 4; i++) {
+        // console.log("== readNchar data:" + new DataView(buff, i * 4, 4).getUint32(0, true))
+        data += AppendRune(new DataView(buff, i * 4, 4).getUint32(0, true))
+
+    }
+    return data;
+}
+
+
+function iteratorBuff(arr: ArrayBuffer) {
+    let buf = Buffer.from(arr);
+    for (const value of buf) {
+        console.log(value.toString())
+    }
+
+}

package/src/tdengineWebsocket.ts

@@ -0,0 +1,39 @@
+
+import { execute } from './wsQuery'
+import { TaosResult } from './taosResult'
+import { WSInterface } from './wsQueryInterface'
+import { WSConnResponse } from './wsQueryResponse'
+
+ 
+export class TDengineWebSocket {
+    _wsInterface: WSInterface
+    _data: Array<any> = []
+    _meta: Array<any> = []
+
+    constructor(url: string) {
+        this._wsInterface = new WSInterface(new URL(url))
+    }
+
+    connect(database?:string):Promise<WSConnResponse> {
+        return this._wsInterface.connect(database)
+    }
+
+    state(){
+        return this._wsInterface.getState();
+    }
+
+    /**
+     * return client version.
+     */
+    version(): Promise<string> {
+        return this._wsInterface.version()
+    }
+
+    query(sql:string):Promise<TaosResult>{
+        return execute(sql,this._wsInterface)
+    }
+    close() {
+        this._wsInterface.close();
+    }
+
+} 

package/src/ut8Helper.ts

@@ -0,0 +1,42 @@
+// Numbers fundamental to the encoding.
+// the "error" Rune or "Unicode replacement character"
+const RuneError = '\uFFFD'
+// Maximum valid Unicode code point.
+const MaxRune = '\U0010FFFF'
+// Code points in the surrogate range are not valid for UTF-8.
+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)
+    if (r <= rune1Max) {
+        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)
+    }
+
+    return Buffer.from(p).toString();
+}

package/src/wsClient.ts

@@ -0,0 +1,196 @@
+import { ICloseEvent, IMessageEvent, w3cwebsocket } from "websocket";
+import { TDWebSocketClientError, WebSocketQueryError } from './wsError'
+
+interface MessageId {
+    action: string,
+    req_id: bigint,
+    id?: bigint
+}
+
+interface MessageAction {
+    reject: Function,
+    resolve: Function,
+    timer: ReturnType<typeof setTimeout>,
+}
+
+var _msgActionRegister: Map<MessageId, MessageAction> = new Map();
+
+export class TDWebSocketClient {
+    private _wsConn: w3cwebsocket;
+    _wsURL: URL;
+    _timeout = 5000;
+
+    // create ws
+    constructor(url: URL) {
+
+        // return w3bsocket3
+        if (url) {
+            this._wsURL = url;
+            let origin = url.origin;
+            let pathname = url.pathname;
+            let search = url.search;
+
+            this._wsConn = new w3cwebsocket(origin.concat(pathname).concat(search));
+
+            // this._wsConn.onopen = this._onopen
+
+            this._wsConn.onerror = function (err: Error) { throw err }
+
+            this._wsConn.onclose = this._onclose
+
+            this._wsConn.onmessage = this._onmessage
+            this._wsConn._binaryType = "arraybuffer"
+        } else {
+            throw new WebSocketQueryError("websocket URL must be defined")
+        }
+
+
+    }
+
+    Ready(): Promise<TDWebSocketClient> {
+        return new Promise((resolve, reject) => {
+            this._wsConn.onopen = () => {
+                // console.log("websocket connection opened")
+                resolve(this);
+            }
+        })
+    }
+
+    private _onclose(e: ICloseEvent) {
+        return new Promise((resolve, reject) => {
+            resolve("websocket connection closed")
+        })
+    }
+
+
+    private _onmessage(event: any) {
+        let data = event.data;
+        // console.log("[wsClient._onMessage()._msgActionRegister]\n")
+        // console.log(_msgActionRegister)
+
+        // console.log("===="+ (Object.prototype.toString.call(data)))
+
+        if (Object.prototype.toString.call(data) === '[object ArrayBuffer]') {
+            let id = new DataView(data, 8, 8).getBigUint64(0, true)
+            // console.log("fetch block response id:" + id)
+
+            let action: MessageAction | any = undefined;
+
+            _msgActionRegister.forEach((v: MessageAction, k: MessageId) => {
+                if (k.id == id) {
+                    action = v
+                    _msgActionRegister.delete(k)
+                }
+            })
+            if (action) {
+                action.resolve(data);
+            }
+            else {
+                _msgActionRegister.clear()
+                throw new TDWebSocketClientError(`no callback registered for fetch_block with id=${id}`);
+            }
+
+        } else if (Object.prototype.toString.call(data) === '[object Blob]') {
+            data.arrayBuffer().then((d: ArrayBuffer) => {
+                let id = new DataView(d, 8, 8).getBigUint64(0, true)
+                // console.log("fetch block response id:" + id)
+
+                let action: MessageAction | any = undefined;
+
+                _msgActionRegister.forEach((v: MessageAction, k: MessageId) => {
+                    if (k.id == id) {
+                        action = v
+                        _msgActionRegister.delete(k)
+                    }
+                })
+                if (action) {
+                    action.resolve(d);
+                }
+                else {
+                    _msgActionRegister.clear()
+                    throw new TDWebSocketClientError(`no callback registered for fetch_block with id=${id}`);
+                }
+            })
+
+        } else if (Object.prototype.toString.call(data) === '[object String]') {
+            let msg = JSON.parse(data)
+            // console.log("[_onmessage.stringType]==>:" + data);
+            let action: MessageAction | any = undefined;
+
+            _msgActionRegister.forEach((v: MessageAction, k: MessageId) => {
+                if (k.action == 'version') {
+                    action = v
+                    _msgActionRegister.delete(k)
+                }
+                if (k.req_id == msg.req_id && k.action == msg.action) {
+                    action = v
+                    _msgActionRegister.delete(k)
+                }
+            })
+            if (action) {
+                action.resolve(msg);
+            }
+            else {
+                _msgActionRegister.clear()
+                throw new TDWebSocketClientError(`no callback registered for ${msg.action} with req_id=${msg.req_id}`);
+            }
+        } else {
+            _msgActionRegister.clear()
+            throw new TDWebSocketClientError(`invalid message type ${Object.prototype.toString.call(data)}`)
+        }
+    }
+
+    close() {
+        if (this._wsConn) {
+            _msgActionRegister.clear();
+            this._wsConn.close();
+        } else {
+            throw new TDWebSocketClientError("WebSocket connection is undefined.")
+        }
+    }
+
+    readyState(): number {
+        return this._wsConn.readyState;
+    }
+
+    sendMsg(message: string, register: Boolean = true) {
+        // console.log("[wsClient.sendMessage()]===>" + message)
+        let msg = JSON.parse(message);
+        // console.log(typeof msg.args.id)
+        if (msg.args.id) {
+            msg.args.id = BigInt(msg.args.id)
+        }
+        // console.log("[wsClient.sendMessage.msg]===>\n")
+        // console.log(msg)
+
+        return new Promise((resolve, reject) => {
+            if (this._wsConn && this._wsConn.readyState > 0) {
+                if (register) {
+
+                    this._registerCallback({ action: msg.action, req_id: msg.args.req_id, id: msg.args.id === undefined ? msg.args.id : BigInt(msg.args.id) }, resolve, reject)
+                    // console.log("[wsClient.sendMessage._msgActionRegister]===>\n")
+                    // console.log(_msgActionRegister)
+                }
+                this._wsConn.send(message)
+            } else {
+                reject(new WebSocketQueryError(`WebSocket connection is not ready,status :${this._wsConn?.readyState}`))
+            }
+        })
+    }
+
+    private _registerCallback(id: MessageId, res: (args: unknown) => void, rej: (reason: any) => void) {
+        // console.log("register messageId:"+ JSON.stringify(id))
+        _msgActionRegister.set(id,
+            {
+                reject: rej,
+                resolve: res,
+                timer: setTimeout(() => rej(new WebSocketQueryError(`action:${id.action},req_id:${id.req_id} timeout with ${this._timeout} milliseconds`)), this._timeout)
+            })
+    }
+
+    configTimeout(ms: number) {
+        this._timeout = ms;
+    }
+
+}
+

package/src/wsError.ts

@@ -0,0 +1,5 @@
+export class TDWebSocketClientError extends Error { }
+export class WebSocketQueryError extends TDWebSocketClientError { }
+export class WebSocketInterfaceError extends TDWebSocketClientError {}
+export class WebSocketQueryInterFaceError extends WebSocketInterfaceError{}
+export class TaosResultError extends Error{};

package/src/wsOptions.ts

@@ -0,0 +1,14 @@
+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 };
+    fragment?: string | undefined | null;
+}

package/src/wsQuery.ts

@@ -0,0 +1,30 @@
+import { TaosResult } from './taosResult';
+import { WSInterface } from './wsQueryInterface'
+export async function execute(sql: string, wsInterface: WSInterface): Promise<TaosResult> {
+    let taosResult;
+    let wsQueryResponse = await wsInterface.query(sql);
+    try {
+        taosResult = new TaosResult(wsQueryResponse);
+        if (wsQueryResponse.is_update == true) {
+            return taosResult;
+        } else {
+            while (true) {
+                let wsFetchResponse = await wsInterface.fetch(wsQueryResponse)
+                // console.log("[wsQuery.execute.wsFetchResponse]==>\n")
+                // console.log(wsFetchResponse)
+                // console.log(typeof BigInt(8))
+                // console.log(typeof wsFetchResponse.timing)
+                if (wsFetchResponse.completed == true) {
+                    break;
+                } else {
+                    taosResult.setRows(wsFetchResponse)
+                    let tmp: TaosResult = await wsInterface.fetchBlock(wsFetchResponse, taosResult)
+                    taosResult = tmp;
+                }
+            }
+            return taosResult;
+        }
+    } finally {
+        wsInterface.freeResult(wsQueryResponse)
+    }
+}