@tdengine/websocket 3.0.0 → 3.1.0

package/lib/test/bulkPulling/queryTables.test.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("../../src/client/wsConnectorPool");
+const config_1 = require("../../src/common/config");
+const wsSql_1 = require("../../src/sql/wsSql");
+const utils_1 = require("../utils");
+// const DSN = 'ws://root:taosdata@127.0.0.1:6041'
+let dsn = 'ws://root:taosdata@localhost:6041';
+let conf = new config_1.WSConfig(dsn);
+const resultMap = new Map();
+resultMap.set("POINT (4.0 8.0)", (0, utils_1.hexToBytes)("010100000000000000000010400000000000002040"));
+resultMap.set("POINT (3.0 5.0)", (0, utils_1.hexToBytes)("010100000000000000000008400000000000001440"));
+resultMap.set("LINESTRING (1.000000 1.000000, 2.000000 2.000000, 5.000000 5.000000)", (0, utils_1.hexToBytes)("010200000003000000000000000000f03f000000000000f03f0000000000000040000000000000004000000000000014400000000000001440"));
+resultMap.set("POLYGON ((3.000000 6.000000, 5.000000 6.000000, 5.000000 8.000000, 3.000000 8.000000, 3.000000 6.000000))", (0, utils_1.hexToBytes)("010300000001000000050000000000000000000840000000000000184000000000000014400000000000001840000000000000144000000000000020400000000000000840000000000000204000000000000008400000000000001840"));
+resultMap.set("POINT (7.0 9.0)", (0, utils_1.hexToBytes)("01010000000000000000001c400000000000002240"));
+resultMap.set("0x7661726332", (0, utils_1.hexToBytes)("307837363631373236333332"));
+resultMap.set("0x7661726333", (0, utils_1.hexToBytes)("307837363631373236333333"));
+resultMap.set("0x7661726334", (0, utils_1.hexToBytes)("307837363631373236333334"));
+resultMap.set("0x7661726335", (0, utils_1.hexToBytes)("307837363631373236333335"));
+const table = 'ws_q_n';
+const stable = 'ws_q_s';
+const tableCN = 'ws_q_n_cn';
+const stableCN = 'ws_q_s_cn';
+const db = 'ws_q_db';
+const jsonTable = 'ws_q_j';
+const jsonTableCN = 'ws_q_j_cn';
+const createDB = `create database if not exists ${db} keep 3650`;
+const dropDB = `drop database if exists ${db}`;
+const useDB = `use ${db}`;
+const stableTags = [true, -1, -2, -3, BigInt(-4), 1, 2, 3, BigInt(4), parseFloat(3.1415.toFixed(5)), parseFloat(3.14159265.toFixed(15)), 'varchar_tag_1', 'nchar_tag_1'];
+const stableCNTags = [false, -1 * 2, -2 * 2, -3 * 2, BigInt(-4 * 2), 1 * 2, 2 * 2, 3 * 2, BigInt(4 * 2), parseFloat((3.1415 * 2).toFixed(5)), parseFloat((3.14159265 * 2).toFixed(15)), 'varchar_标签_壹', 'nchar_标签_贰'];
+const tableValues = [
+    [BigInt(1656677710000), 0, -1, -2, BigInt(-3), 0, 1, 2, BigInt(3), parseFloat(3.1415.toFixed(5)), parseFloat(3.14159265.toFixed(15)), 'varchar_col_1', 'nchar_col_1', true, 'NULL', 'POINT (4.0 8.0)', '0x7661726332'],
+    [BigInt(1656677720000), -1, -2, -3, BigInt(-4), 1, 2, 3, BigInt(4), parseFloat((3.1415 * 2).toFixed(5)), parseFloat((3.14159265 * 2).toFixed(15)), 'varchar_col_2', 'nchar_col_2', false, 'NULL', 'POINT (3.0 5.0)', '0x7661726333'],
+    [BigInt(1656677730000), -2, -3, -4, BigInt(-5), 2, 3, 4, BigInt(5), parseFloat((3.1415 * 3).toFixed(5)), parseFloat((3.14159265 * 3).toFixed(15)), 'varchar_col_3', 'nchar_col_3', true, 'NULL', 'LINESTRING (1.000000 1.000000, 2.000000 2.000000, 5.000000 5.000000)', '0x7661726334'],
+    [BigInt(1656677740000), -3, -4, -5, BigInt(-6), 3, 4, 5, BigInt(6), parseFloat((3.1415 * 4).toFixed(5)), parseFloat((3.14159265 * 4).toFixed(15)), 'varchar_col_4', 'nchar_col_4', false, 'NULL', 'POLYGON ((3.000000 6.000000, 5.000000 6.000000, 5.000000 8.000000, 3.000000 8.000000, 3.000000 6.000000))', '0x7661726335'],
+    [BigInt(1656677750000), -4, -5, -6, BigInt(-7), 4, 5, 6, BigInt(7), parseFloat((3.1415 * 5).toFixed(5)), parseFloat((3.14159265 * 5).toFixed(15)), 'varchar_col_5', 'nchar_col_5', true, 'NULL', 'POINT (7.0 9.0)', '0x7661726335'],
+];
+const tableCNValues = [
+    [BigInt(1656677760000), 0, -1, -2, BigInt(-3), 0, 1, 2, BigInt(3), parseFloat(3.1415.toFixed(5)), parseFloat(3.14159265.toFixed(15)), 'varchar_列_壹', 'nchar_列_甲', true, 'NULL', 'POINT (4.0 8.0)', '0x7661726332'],
+    [BigInt(1656677770000), -1, -2, -3, BigInt(-4), 1, 2, 3, BigInt(4), parseFloat((3.1415 * 2).toFixed(5)), parseFloat((3.14159265 * 2).toFixed(15)), 'varchar_列_贰', 'nchar_列_乙', false, 'NULL', 'POINT (3.0 5.0)', '0x7661726333'],
+    [BigInt(1656677780000), -2, -3, -4, BigInt(-5), 2, 3, 4, BigInt(5), parseFloat((3.1415 * 3).toFixed(5)), parseFloat((3.14159265 * 3).toFixed(15)), 'varchar_列_叁', 'nchar_列_丙', true, 'NULL', 'LINESTRING (1.000000 1.000000, 2.000000 2.000000, 5.000000 5.000000)', '0x7661726334'],
+    [BigInt(1656677790000), -3, -4, -5, BigInt(-6), 3, 4, 5, BigInt(6), parseFloat((3.1415 * 4).toFixed(5)), parseFloat((3.14159265 * 4).toFixed(15)), 'varchar_列_肆', 'nchar_列_丁', false, 'NULL', 'POLYGON ((3.000000 6.000000, 5.000000 6.000000, 5.000000 8.000000, 3.000000 8.000000, 3.000000 6.000000))', '0x7661726335'],
+    [BigInt(1656677800000), -4, -5, -6, BigInt(-7), 4, 5, 6, BigInt(7), parseFloat((3.1415 * 5).toFixed(5)), parseFloat((3.14159265 * 5).toFixed(15)), 'varchar_列_伍', 'nchar_列_戊', true, 'NULL', 'POINT (7.0 9.0)', '0x7661726335'],
+];
+const jsonTags = ["{\"key1\":\"taos\",\"key2\":null,\"key3\":\"TDengine\",\"key4\":0,\"key5\":false}"];
+const jsonTagsCN = ["{\"key1\":\"taosdata\",\"key2\":null,\"key3\":\"TDengine涛思数据\",\"key4\":1,\"key5\":true}"];
+const selectStable = `select * from ${stable}`;
+const selectStableCN = `select * from ${stableCN}`;
+const selectTable = `select * from ${table}`;
+const selectTableCN = `select * from ${tableCN}`;
+const selectJsonTable = `select * from ${jsonTable}`;
+const selectJsonTableCN = `select * from ${jsonTableCN}`;
+beforeAll(async () => {
+    let ws = await wsSql_1.WsSql.open(conf);
+    await ws.exec(dropDB);
+    await ws.exec(createDB);
+    await ws.exec(useDB);
+    await ws.exec((0, utils_1.createSTable)(stable));
+    await ws.exec((0, utils_1.createSTable)(stableCN));
+    await ws.exec((0, utils_1.createTable)(table));
+    await ws.exec((0, utils_1.createTable)(tableCN));
+    await ws.exec((0, utils_1.createSTableJSON)(jsonTable));
+    await ws.exec((0, utils_1.createSTableJSON)(jsonTableCN));
+    await ws.close();
+});
+describe('ws.query(stable)', () => {
+    jest.setTimeout(20 * 1000);
+    test('Insert query stable without CN character', async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insert = (0, utils_1.insertStable)(tableValues, stableTags, stable);
+        let insertRes = await ws.exec(insert);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectStable);
+        let expectMeta = utils_1.tableMeta.concat(utils_1.tagMeta);
+        let expectData = (0, utils_1.expectStableData)(tableValues, stableTags);
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    // //   console.log(i, index, d, expectData[i][index])
+                    if (expectMeta[index].name == 'geo' || expectMeta[index].name == 'vbinary') {
+                        let buffer = resultMap.get(expectData[i][index]);
+                        if (buffer) {
+                            let dbData = d;
+                            console.log(i, index, dbData, expectData[i][index], buffer, (0, utils_1.compareUint8Arrays)(new Uint8Array(dbData), new Uint8Array(buffer)));
+                            expect((0, utils_1.compareUint8Arrays)(new Uint8Array(dbData), new Uint8Array(buffer))).toBe(true);
+                        }
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+    test('query stable with CN character', async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insertCN = (0, utils_1.insertStable)(tableCNValues, stableCNTags, stableCN);
+        // console.log(insertCN)
+        let insertRes = await ws.exec(insertCN);
+        // console.log(insertRes)
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectStableCN);
+        let expectMeta = utils_1.tableMeta.concat(utils_1.tagMeta);
+        let expectData = (0, utils_1.expectStableData)(tableCNValues, stableCNTags);
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == 'geo' || expectMeta[index].name == 'vbinary') {
+                        let buffer = resultMap.get(expectData[i][index]);
+                        if (buffer) {
+                            let dbData = d;
+                            console.log(i, index, dbData, expectData[i][index], buffer, (0, utils_1.compareUint8Arrays)(new Uint8Array(dbData), new Uint8Array(buffer)));
+                            expect((0, utils_1.compareUint8Arrays)(new Uint8Array(dbData), new Uint8Array(buffer))).toBe(true);
+                        }
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+});
+describe('ws.query(table)', () => {
+    test('Insert query normal table without CN character', async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insert = (0, utils_1.insertNTable)(tableValues, table);
+        // console.log(insert)
+        let insertRes = await ws.exec(insert);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectTable);
+        let expectMeta = utils_1.tableMeta;
+        let expectData = tableValues;
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                // console.log(meta,expectMeta[index]);
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == 'geo' || expectMeta[index].name == 'vbinary') {
+                        expect(d).toBeTruthy();
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+    test('Insert query normal table with CN character', async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insertCN = (0, utils_1.insertNTable)(tableCNValues, tableCN);
+        // console.log(insertCN)
+        let insertRes = await ws.exec(insertCN);
+        // console.log(insertRes)
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectTableCN);
+        let expectMeta = utils_1.tableMeta;
+        let expectData = tableCNValues;
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                // console.log(meta, expectMeta[index]);
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == 'geo' || expectMeta[index].name == 'vbinary') {
+                        expect(d).toBeTruthy();
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+});
+describe('ws.query(jsonTable)', () => {
+    test('Insert and query json data from table without CN', async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insert = (0, utils_1.insertStable)(tableValues, jsonTags, jsonTable);
+        // console.log(insert)
+        let insertRes = await ws.exec(insert);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectJsonTable);
+        let expectMeta = utils_1.tableMeta.concat(utils_1.jsonMeta);
+        let expectData = (0, utils_1.expectStableData)(tableValues, jsonTags);
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                //   console.log(meta);
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == 'geo' || expectMeta[index].name == 'vbinary') {
+                        expect(d).toBeTruthy();
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+    test('Insert and query json data from table with CN', async () => {
+        let ws = await wsSql_1.WsSql.open(conf);
+        await ws.exec(useDB);
+        let insert = (0, utils_1.insertStable)(tableCNValues, jsonTagsCN, jsonTableCN);
+        // console.log(insert)
+        let insertRes = await ws.exec(insert);
+        expect(insertRes.getAffectRows()).toBe(5);
+        let queryRes = await ws.exec(selectJsonTableCN);
+        let expectMeta = utils_1.tableMeta.concat(utils_1.jsonMeta);
+        let expectData = (0, utils_1.expectStableData)(tableCNValues, jsonTagsCN);
+        let actualMeta = queryRes.getMeta();
+        let actualData = queryRes.getData();
+        await ws.close();
+        if (actualData && actualMeta) {
+            actualMeta.forEach((meta, index) => {
+                //   console.log(meta);
+                expect(meta.name).toBe(expectMeta[index].name);
+                expect(meta.type).toBe(expectMeta[index].type);
+                expect(meta.length).toBe(expectMeta[index].length);
+            });
+            for (let i = 0; i < actualData.length; i++) {
+                actualData[i].forEach((d, index) => {
+                    if (expectMeta[index].name == 'geo' || expectMeta[index].name == 'vbinary') {
+                        expect(d).toBeTruthy();
+                    }
+                    else {
+                        expect(d).toBe(expectData[i][index]);
+                    }
+                });
+            }
+        }
+        else {
+            throw new Error("retrieve empty result");
+        }
+    });
+});
+afterAll(async () => {
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});
+//--detectOpenHandles --maxConcurrency=1 --forceExit

package/lib/test/bulkPulling/schemaless.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schemaless.test.d.ts.map

package/lib/test/bulkPulling/schemaless.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaless.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/schemaless.test.ts"],"names":[],"mappings":""}

package/lib/test/bulkPulling/schemaless.test.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("../../src/client/wsConnectorPool");
+const config_1 = require("../../src/common/config");
+const wsProto_1 = require("../../src/sql/wsProto");
+const wsSql_1 = require("../../src/sql/wsSql");
+let dns = 'ws://localhost:6041';
+beforeAll(async () => {
+    let conf = new config_1.WSConfig(dns);
+    conf.setUser('root');
+    conf.setPwd('taosdata');
+    let wsSql = await wsSql_1.WsSql.open(conf);
+    await wsSql.exec('create database if not exists power KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;');
+    await wsSql.exec('CREATE STABLE if not exists power.meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);');
+    await wsSql.close();
+});
+describe('TDWebSocket.WsSchemaless()', () => {
+    jest.setTimeout(20 * 1000);
+    let influxdbData = "st,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000";
+    let telnetData = "stb0_0 1626006833 4 host=host0 interface=eth0";
+    let jsonData = "{\"metric\": \"meter_current\",\"timestamp\": 1626846400,\"value\": 10.3, \"tags\": {\"groupid\": 2, \"location\": \"California.SanFrancisco\", \"id\": \"d1001\"}}";
+    test('normal connect', async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        conf.setDb('power');
+        let wsSchemaless = await wsSql_1.WsSql.open(conf);
+        expect(wsSchemaless.state()).toBeGreaterThan(0);
+        await wsSchemaless.close();
+    });
+    test('connect db with error', async () => {
+        expect.assertions(1);
+        let wsSchemaless = null;
+        try {
+            let conf = new config_1.WSConfig(dns);
+            conf.setUser('root');
+            conf.setPwd('taosdata');
+            conf.setDb('jest');
+            wsSchemaless = await wsSql_1.WsSql.open(conf);
+        }
+        catch (e) {
+            console.log(e);
+            expect(e.message).toMatch('Database not exist');
+        }
+        finally {
+            if (wsSchemaless) {
+                await wsSchemaless.close();
+            }
+        }
+    });
+    test('normal insert', async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        conf.setDb('power');
+        let wsSchemaless = await wsSql_1.WsSql.open(conf);
+        expect(wsSchemaless.state()).toBeGreaterThan(0);
+        await wsSchemaless.schemalessInsert([influxdbData], wsProto_1.SchemalessProto.InfluxDBLineProtocol, wsProto_1.Precision.NANO_SECONDS, 0);
+        await wsSchemaless.schemalessInsert([telnetData], wsProto_1.SchemalessProto.OpenTSDBTelnetLineProtocol, wsProto_1.Precision.SECONDS, 0);
+        await wsSchemaless.schemalessInsert([jsonData], wsProto_1.SchemalessProto.OpenTSDBJsonFormatProtocol, wsProto_1.Precision.SECONDS, 0);
+        await wsSchemaless.close();
+    });
+    test('normal wsSql insert', async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        conf.setDb('power');
+        let wsSchemaless = await wsSql_1.WsSql.open(conf);
+        expect(wsSchemaless.state()).toBeGreaterThan(0);
+        await wsSchemaless.schemalessInsert([influxdbData], wsProto_1.SchemalessProto.InfluxDBLineProtocol, wsProto_1.Precision.NOT_CONFIGURED, 0);
+        await wsSchemaless.schemalessInsert([influxdbData], wsProto_1.SchemalessProto.InfluxDBLineProtocol, wsProto_1.Precision.NANO_SECONDS, 0);
+        await wsSchemaless.schemalessInsert([telnetData], wsProto_1.SchemalessProto.OpenTSDBTelnetLineProtocol, wsProto_1.Precision.SECONDS, 0);
+        await wsSchemaless.schemalessInsert([jsonData], wsProto_1.SchemalessProto.OpenTSDBJsonFormatProtocol, wsProto_1.Precision.SECONDS, 0);
+        await wsSchemaless.close();
+    });
+    test('SchemalessProto error', async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        conf.setDb('power');
+        let wsSchemaless = await wsSql_1.WsSql.open(conf);
+        expect(wsSchemaless.state()).toBeGreaterThan(0);
+        try {
+            await wsSchemaless.schemalessInsert([influxdbData], wsProto_1.SchemalessProto.OpenTSDBTelnetLineProtocol, wsProto_1.Precision.NANO_SECONDS, 0);
+        }
+        catch (e) {
+            expect(e.message).toMatch('invalid timestamp');
+        }
+        await wsSchemaless.close();
+    });
+});
+afterAll(async () => {
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

package/lib/test/bulkPulling/sql.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sql.test.d.ts.map

package/lib/test/bulkPulling/sql.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/sql.test.ts"],"names":[],"mappings":""}

package/lib/test/bulkPulling/sql.test.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("../../src/client/wsConnectorPool");
+const config_1 = require("../../src/common/config");
+const wsSql_1 = require("../../src/sql/wsSql");
+beforeAll(async () => {
+    let dns = 'ws://localhost:6041';
+    let conf = new config_1.WSConfig(dns);
+    conf.setUser('root');
+    conf.setPwd('taosdata');
+    let wsSql = await wsSql_1.WsSql.open(conf);
+    await wsSql.exec('create database if not exists power KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;');
+    await wsSql.exec('use power');
+    await wsSql.exec('CREATE STABLE if not exists power.meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);');
+    await wsSql.close();
+});
+describe('TDWebSocket.WsSql()', () => {
+    jest.setTimeout(20 * 1000);
+    test('normal connect', async () => {
+        let dsn = 'ws://root:taosdata@localhost:6041';
+        let wsSql = null;
+        let conf = new config_1.WSConfig(dsn);
+        conf.setDb('power');
+        wsSql = await wsSql_1.WsSql.open(conf);
+        expect(wsSql.state()).toBeGreaterThan(0);
+        await wsSql.close();
+    });
+    test('connect db with error', async () => {
+        expect.assertions(1);
+        let wsSql = null;
+        try {
+            let dsn = 'ws://root:taosdata@localhost:6041';
+            let conf = new config_1.WSConfig(dsn);
+            conf.setDb('jest');
+            wsSql = await wsSql_1.WsSql.open(conf);
+        }
+        catch (e) {
+            let err = e;
+            expect(err.message).toMatch('Database not exist');
+        }
+        finally {
+            if (wsSql) {
+                await wsSql.close();
+            }
+        }
+    });
+    test('get taosc version', async () => {
+        let dsn = 'ws://root:taosdata@localhost:6041';
+        let conf = new config_1.WSConfig(dsn);
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let version = await wsSql.version();
+        await wsSql.close();
+        console.log(version);
+        expect(version).toBeTruthy();
+    });
+    test('show databases', async () => {
+        let dsn = 'ws://root:taosdata@localhost:6041';
+        let conf = new config_1.WSConfig(dsn);
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec('show databases');
+        await wsSql.close();
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+    });
+    test('create databases', async () => {
+        let dsn = 'ws://root:taosdata@localhost:6041';
+        let conf = new config_1.WSConfig(dsn);
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec('create database if not exists power KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;');
+        await wsSql.close();
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+    });
+    test('create stable', async () => {
+        let dsn = 'ws://root:taosdata@localhost:6041';
+        let conf = new config_1.WSConfig(dsn);
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec('use power');
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+        taosResult = await wsSql.exec('CREATE STABLE if not exists meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);');
+        await wsSql.close();
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+    });
+    test('insert recoder', async () => {
+        let dsn = 'ws://root:taosdata@localhost:6041';
+        let conf = new config_1.WSConfig(dsn);
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec('use power');
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+        taosResult = await wsSql.exec('describe meters');
+        console.log(taosResult);
+        taosResult = await wsSql.exec('INSERT INTO d1001 USING meters (location, groupid) TAGS ("California.SanFrancisco", 3) VALUES (NOW, 10.2, 219, 0.32)');
+        console.log(taosResult);
+        expect(taosResult.getAffectRows()).toBeGreaterThanOrEqual(1);
+        await wsSql.close();
+    });
+    test('query sql', async () => {
+        let dsn = 'ws://root:taosdata@localhost:6041';
+        let conf = new config_1.WSConfig(dsn);
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec('use power');
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+        for (let i = 0; i < 10; i++) {
+            let wsRows = await wsSql.query('select * from meters limit 3');
+            expect(wsRows).toBeTruthy();
+            let meta = wsRows.getMeta();
+            expect(meta).toBeTruthy();
+            console.log("wsRow:meta:=>", meta);
+            while (await wsRows.next()) {
+                let result = await wsRows.getData();
+                expect(result).toBeTruthy();
+            }
+            await wsRows.close();
+        }
+        await wsSql.close();
+    });
+});
+afterAll(async () => {
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

package/lib/test/bulkPulling/stmt.func.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stmt.func.test.d.ts.map

package/lib/test/bulkPulling/stmt.func.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stmt.func.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/stmt.func.test.ts"],"names":[],"mappings":""}