@tdengine/websocket 3.0.0 → 3.1.1

package/lib/example/all_type_query.d.ts

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

package/lib/example/all_type_query.d.ts.map

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

package/lib/example/all_type_query.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../src/common/config");
+const src_1 = require("../src");
+let dsn = 'ws://127.0.0.1:6041';
+async function json_tag_example() {
+    let wsSql = null;
+    try {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        wsSql = await (0, src_1.sqlConnect)(conf);
+        console.log("Connected to " + dsn + " successfully.");
+        // create database
+        await wsSql.exec('CREATE DATABASE IF NOT EXISTS example_json_tag');
+        console.log("Create database example_json_tag successfully.");
+        // create table
+        await wsSql.exec('create table if not exists example_json_tag.stb (ts timestamp, v int) tags(jt json)');
+        console.log("Create stable example_json_tag.stb successfully");
+        let insertQuery = 'INSERT INTO ' +
+            'example_json_tag.tb1 USING example_json_tag.stb TAGS(\'{"name":"value"}\') ' +
+            "values(now, 1) ";
+        let taosResult = await wsSql.exec(insertQuery);
+        console.log("Successfully inserted " + taosResult.getAffectRows() + " rows to example_json_tag.stb.");
+        let sql = 'SELECT ts, v, jt FROM example_json_tag.stb limit 100';
+        let wsRows = await wsSql.query(sql);
+        while (await wsRows.next()) {
+            let row = wsRows.getData();
+            if (row) {
+                console.log('ts: ' + row[0] + ', v: ' + row[1] + ', jt:  ' + row[2]);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Failed to create database example_json_tag or stable stb, ErrCode: ${err.code}, ErrMessage: ${err.message}`);
+    }
+    finally {
+        if (wsSql) {
+            await wsSql.close();
+        }
+    }
+}
+async function all_type_example() {
+    let wsSql = null;
+    try {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        wsSql = await (0, src_1.sqlConnect)(conf);
+        console.log("Connected to " + dsn + " successfully.");
+        // create database
+        await wsSql.exec('CREATE DATABASE IF NOT EXISTS all_type_example');
+        console.log("Create database all_type_example successfully.");
+        // create table
+        await wsSql.exec('create table if not exists all_type_example.stb (ts timestamp, ' +
+            'int_col INT, double_col DOUBLE, bool_col BOOL, binary_col BINARY(100),' +
+            'nchar_col NCHAR(100), varbinary_col VARBINARY(100), geometry_col GEOMETRY(100)) ' +
+            'tags(int_tag INT, double_tag DOUBLE, bool_tag BOOL, binary_tag BINARY(100),' +
+            'nchar_tag NCHAR(100), varbinary_tag VARBINARY(100), geometry_tag GEOMETRY(100));');
+        console.log("Create stable all_type_example.stb successfully");
+        let insertQuery = "INSERT INTO all_type_example.tb1 using all_type_example.stb "
+            + "tags(1, 1.1, true, 'binary_value', 'nchar_value', '\\x98f46e', 'POINT(100 100)') "
+            + "values(now, 1, 1.1, true, 'binary_value', 'nchar_value', '\\x98f46e', 'POINT(100 100)')";
+        let taosResult = await wsSql.exec(insertQuery);
+        console.log("Successfully inserted " + taosResult.getAffectRows() + " rows to all_type_example.stb.");
+        let sql = 'SELECT * FROM all_type_example.stb limit 100';
+        let wsRows = await wsSql.query(sql);
+        let meta = wsRows.getMeta();
+        console.log("wsRow:meta:=>", meta);
+        while (await wsRows.next()) {
+            let row = wsRows.getData();
+            console.log(row);
+        }
+    }
+    catch (err) {
+        console.error(`Failed to create database all_type_example or stable stb, ErrCode: ${err.code}, ErrMessage: ${err.message}`);
+    }
+    finally {
+        if (wsSql) {
+            await wsSql.close();
+        }
+    }
+}
+async function test() {
+    await json_tag_example();
+    await all_type_example();
+    (0, src_1.destroy)();
+}
+test();

package/lib/example/all_type_stmt.d.ts

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

package/lib/example/all_type_stmt.d.ts.map

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

package/lib/example/all_type_stmt.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../src/common/config");
+const src_1 = require("../src");
+const log_1 = require("../src/common/log");
+let dsn = 'ws://127.0.0.1:6041';
+async function json_tag_example() {
+    let wsSql = null;
+    try {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        wsSql = await (0, src_1.sqlConnect)(conf);
+        console.log("Connected to " + dsn + " successfully.");
+        // create database
+        await wsSql.exec('CREATE DATABASE IF NOT EXISTS example_json_tag');
+        console.log("Create database example_json_tag successfully.");
+        await wsSql.exec('use example_json_tag');
+        // create table
+        await wsSql.exec('create table if not exists stb (ts timestamp, v int) tags(jt json)');
+        console.log("Create stable example_json_tag.stb successfully");
+        let stmt = await wsSql.stmtInit();
+        await stmt.prepare("INSERT INTO ? using stb tags(?) VALUES (?,?)");
+        await stmt.setTableName(`tb1`);
+        let tagParams = stmt.newStmtParam();
+        tagParams.setJson(['{"name":"value"}']);
+        await stmt.setTags(tagParams);
+        let bindParams = stmt.newStmtParam();
+        const currentMillis = new Date().getTime();
+        bindParams.setTimestamp([currentMillis]);
+        bindParams.setInt([1]);
+        await stmt.bind(bindParams);
+        await stmt.batch();
+        await stmt.exec();
+        await stmt.close();
+        let sql = 'SELECT ts, v, jt FROM example_json_tag.stb limit 100';
+        let wsRows = await wsSql.query(sql);
+        while (await wsRows.next()) {
+            let row = wsRows.getData();
+            if (row) {
+                console.log('ts: ' + row[0] + ', v: ' + row[1] + ', jt:  ' + row[2]);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Failed to create database example_json_tag or stable stb, ErrCode: ${err.code}, ErrMessage: ${err.message}`);
+    }
+    finally {
+        if (wsSql) {
+            await wsSql.close();
+        }
+    }
+}
+async function all_type_example() {
+    let wsSql = null;
+    let stmt = null;
+    try {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        wsSql = await (0, src_1.sqlConnect)(conf);
+        console.log("Connected to " + dsn + " successfully.");
+        // create database
+        await wsSql.exec('CREATE DATABASE IF NOT EXISTS all_type_example');
+        console.log("Create database all_type_example successfully.");
+        await wsSql.exec('use all_type_example');
+        // create table
+        await wsSql.exec('create table if not exists stb (ts timestamp, ' +
+            'int_col INT, double_col DOUBLE, bool_col BOOL, binary_col BINARY(100),' +
+            'nchar_col NCHAR(100), varbinary_col VARBINARY(100), geometry_col GEOMETRY(100)) ' +
+            'tags(int_tag INT, double_tag DOUBLE, bool_tag BOOL, binary_tag BINARY(100),' +
+            'nchar_tag NCHAR(100), varbinary_tag VARBINARY(100), geometry_tag GEOMETRY(100));');
+        console.log("Create stable all_type_example.stb successfully");
+        let geometryData = new Uint8Array([0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x59, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, 0x40,]).buffer;
+        const encoder = new TextEncoder();
+        let vbData = encoder.encode(`Hello, world!`).buffer;
+        stmt = await wsSql.stmtInit();
+        await stmt.prepare("INSERT INTO ? using stb tags(?,?,?,?,?,?,?) VALUES (?,?,?,?,?,?,?,?)");
+        await stmt.setTableName(`tb1`);
+        let tagParams = stmt.newStmtParam();
+        tagParams.setInt([1]);
+        tagParams.setDouble([1.1]);
+        tagParams.setBoolean([true]);
+        tagParams.setVarchar(["hello"]);
+        tagParams.setNchar(["stmt"]);
+        tagParams.setGeometry([geometryData]);
+        tagParams.setVarBinary([vbData]);
+        await stmt.setTags(tagParams);
+        let bindParams = stmt.newStmtParam();
+        const currentMillis = new Date().getTime();
+        bindParams.setTimestamp([currentMillis]);
+        bindParams.setInt([1]);
+        bindParams.setDouble([1.1]);
+        bindParams.setBoolean([true]);
+        bindParams.setVarchar(["hello"]);
+        bindParams.setNchar(["stmt"]);
+        bindParams.setGeometry([geometryData]);
+        bindParams.setVarBinary([vbData]);
+        await stmt.bind(bindParams);
+        await stmt.batch();
+        await stmt.exec();
+        let sql = 'SELECT * FROM all_type_example.stb limit 100';
+        let wsRows = await wsSql.query(sql);
+        let meta = wsRows.getMeta();
+        console.log("wsRow:meta:=>", meta);
+        while (await wsRows.next()) {
+            let row = wsRows.getData();
+            console.log(row);
+        }
+    }
+    catch (err) {
+        console.error(`Failed to create database all_type_example or stable stb, ErrCode: ${err.code}, ErrMessage: ${err.message}`);
+    }
+    finally {
+        if (stmt) {
+            await stmt.close();
+        }
+        if (wsSql) {
+            await wsSql.close();
+        }
+    }
+}
+async function test() {
+    (0, log_1.setLevel)("debug");
+    await json_tag_example();
+    await all_type_example();
+    (0, src_1.destroy)();
+}
+test();

package/lib/example/basicBatchTmq.d.ts

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

package/lib/example/basicBatchTmq.d.ts.map

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

package/lib/example/basicBatchTmq.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../src/common/config");
+const constant_1 = require("../src/tmq/constant");
+const src_1 = require("../src");
+const db = 'power';
+const stable = 'meters';
+const url = 'ws://localhost:6041';
+const topic = 'topic_meters';
+const topics = [topic];
+const groupId = "group-50";
+const clientId = "client-50";
+async function createConsumer() {
+    let configMap = new Map([
+        [constant_1.TMQConstants.GROUP_ID, groupId],
+        [constant_1.TMQConstants.CLIENT_ID, clientId],
+        [constant_1.TMQConstants.CONNECT_USER, "root"],
+        [constant_1.TMQConstants.CONNECT_PASS, "taosdata"],
+        [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
+        [constant_1.TMQConstants.WS_URL, url],
+        [constant_1.TMQConstants.ENABLE_AUTO_COMMIT, 'false'],
+        [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, '1000']
+    ]);
+    try {
+        let conn = await (0, src_1.tmqConnect)(configMap);
+        console.log(`Create consumer successfully, host: ${url}, groupId: ${groupId}, clientId: ${clientId}`);
+        return conn;
+    }
+    catch (err) {
+        console.error(`Failed to create websocket consumer, topic: ${topic}, groupId: ${groupId}, clientId: ${clientId}, ErrCode: ${err.code}, ErrMessage: ${err.message}`);
+        throw err;
+    }
+}
+// ANCHOR_END: create_consumer 
+async function prepare() {
+    let conf = new config_1.WSConfig('ws://localhost:6041');
+    conf.setUser('root');
+    conf.setPwd('taosdata');
+    conf.setDb(db);
+    const createDB = `CREATE DATABASE IF NOT EXISTS ${db}`;
+    const createStable = `CREATE STABLE IF NOT EXISTS ${db}.${stable} (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);`;
+    let wsSql = await (0, src_1.sqlConnect)(conf);
+    await wsSql.exec(createDB);
+    await wsSql.exec(createStable);
+    let createTopic = `CREATE TOPIC IF NOT EXISTS ${topics[0]} AS SELECT * FROM ${db}.${stable}`;
+    await wsSql.exec(createTopic);
+    wsSql.close();
+}
+async function insert() {
+    let conf = new config_1.WSConfig('ws://localhost:6041');
+    conf.setUser('root');
+    conf.setPwd('taosdata');
+    conf.setDb(db);
+    let wsSql = await (0, src_1.sqlConnect)(conf);
+    for (let i = 0; i < 10000; i++) {
+        await wsSql.exec(`INSERT INTO d1001 USING ${stable} (location, groupId) TAGS ("California.SanFrancisco", 3) VALUES (NOW + ${i}a, ${10 + i}, ${200 + i}, ${0.32 + i})`);
+    }
+    await wsSql.close();
+    console.log("insert fininsh!!!!!");
+}
+async function subscribe(consumer) {
+    // ANCHOR: commit 
+    try {
+        let count = 0;
+        await consumer.subscribe(topics);
+        let bFinish = false;
+        let bBegin = false;
+        const startTime = new Date().getTime();
+        while (!bFinish) {
+            let res = await consumer.poll(100);
+            for (let [key, value] of res) {
+                // Add your data processing logic here
+                let data = value.getData();
+                if (data) {
+                    if (data.length == 0 && bBegin) {
+                        bFinish = true;
+                        break;
+                    }
+                    else if (data.length > 0) {
+                        bBegin = true;
+                    }
+                    count += data.length;
+                    console.log("poll end ------>", count);
+                }
+            }
+            // await consumer.commit();
+        }
+        const endTime = new Date().getTime();
+        console.log(count, endTime - startTime);
+    }
+    catch (err) {
+        console.error(`Failed to poll data, topic: ${topic}, groupId: ${groupId}, clientId: ${clientId}, ErrCode: ${err.code}, ErrMessage: ${err.message}`);
+        throw err;
+    }
+    // ANCHOR_END: commit
+}
+async function consumer() {
+    // ANCHOR: unsubscribe
+    (0, src_1.setLogLevel)("debug");
+    let consumer = null;
+    try {
+        // await prepare();
+        consumer = await createConsumer();
+        // const allPromises = [];
+        // allPromises.push(subscribe(consumer));
+        // allPromises.push(insert());
+        // await Promise.all(allPromises);
+        // await insert();
+        await subscribe(consumer);
+        await consumer.unsubscribe();
+        console.log("Consumer unsubscribed successfully.");
+    }
+    catch (err) {
+        console.error(`Failed to unsubscribe consumer, topic: ${topic}, groupId: ${groupId}, clientId: ${clientId}, ErrCode: ${err.code}, ErrMessage: ${err.message}`);
+        throw err;
+    }
+    finally {
+        if (consumer) {
+            await consumer.close();
+            console.log("Consumer closed successfully.");
+        }
+        (0, src_1.destroy)();
+    }
+    // ANCHOR_END: unsubscribe
+}
+async function test() {
+    await consumer();
+}
+test();

package/lib/example/basicSchemaless.d.ts

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

package/lib/example/basicSchemaless.d.ts.map

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

package/lib/example/basicSchemaless.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../src/common/config");
+const wsProto_1 = require("../src/sql/wsProto");
+const src_1 = require("../src");
+let dsn = 'ws://root:taosdata@localhost:6041';
+let db = 'power';
+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\"}}";
+const dropDB = `drop database if exists ${db}`;
+async function Prepare() {
+    let conf = new config_1.WSConfig(dsn);
+    conf.setUser('root');
+    conf.setPwd('taosdata');
+    let wsSql = await (0, src_1.sqlConnect)(conf);
+    const topics = ['pwer_meters_topic'];
+    let dropTopic = `DROP TOPIC IF EXISTS ${topics[0]};`;
+    await wsSql.exec(dropTopic);
+    await wsSql.exec(dropDB);
+    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);');
+    wsSql.close();
+}
+(async () => {
+    let wsSchemaless = null;
+    try {
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        conf.setDb('power');
+        wsSchemaless = await (0, src_1.sqlConnect)(conf);
+        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);
+        wsSchemaless.close();
+    }
+    catch (e) {
+        console.error(e);
+    }
+    finally {
+        if (wsSchemaless) {
+            await wsSchemaless.close();
+        }
+        (0, src_1.destroy)();
+    }
+})();

package/lib/example/basicSql.d.ts

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

package/lib/example/basicSql.d.ts.map

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

package/lib/example/basicSql.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../src/common/config");
+const src_1 = require("../src");
+let dsn = 'ws://root:taosdata@localhost:6041';
+(async () => {
+    let wsSql = null;
+    let wsRows = null;
+    let reqId = 0;
+    try {
+        (0, src_1.setLogLevel)("debug");
+        let conf = new config_1.WSConfig(dsn);
+        conf.setUser('root');
+        conf.setPwd('taosdata');
+        wsSql = await (0, src_1.sqlConnect)(conf);
+        let version = await wsSql.version();
+        console.log(version);
+        let taosResult = await wsSql.exec('show databases', reqId++);
+        console.log(taosResult);
+        taosResult = await wsSql.exec('create database if not exists power KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;', reqId++);
+        console.log(taosResult);
+        taosResult = await wsSql.exec('use power', reqId++);
+        console.log(taosResult);
+        taosResult = await wsSql.exec('CREATE STABLE if not exists meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);', reqId++);
+        console.log(taosResult);
+        taosResult = await wsSql.exec('describe meters', reqId++);
+        console.log(taosResult);
+        taosResult = await wsSql.exec('INSERT INTO d1001 USING meters TAGS ("California.SanFrancisco", 3) VALUES (NOW, 10.2, 219, 0.32)', reqId++);
+        console.log(taosResult);
+        for (let i = 0; i < 100; i++) {
+            wsRows = await wsSql.query('select * from meters', reqId++);
+            let meta = wsRows.getMeta();
+            console.log("wsRow:meta:=>", meta);
+            while (await wsRows.next()) {
+                let result = wsRows.getData();
+                console.log('queryRes.Scan().then=>', result);
+            }
+            wsRows.close();
+        }
+    }
+    catch (err) {
+        console.error(err.code, err.message);
+    }
+    finally {
+        if (wsRows) {
+            await wsRows.close();
+        }
+        if (wsSql) {
+            await wsSql.close();
+        }
+        (0, src_1.destroy)();
+        console.log("finish!");
+    }
+})();

package/lib/example/basicStmt.d.ts

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

package/lib/example/basicStmt.d.ts.map

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

package/lib/example/basicStmt.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../src/common/config");
+const src_1 = require("../src");
+let db = 'power';
+let stable = 'meters';
+let numOfSubTable = 10;
+let numOfRow = 10;
+function getRandomInt(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+let dsn = 'ws://root:taosdata@localhost:6041';
+async function Prepare() {
+    let conf = new config_1.WSConfig(dsn);
+    let wsSql = await (0, src_1.sqlConnect)(conf);
+    await wsSql.exec(`create database if not exists ${db} KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;`);
+    await wsSql.exec(`CREATE STABLE if not exists ${db}.${stable} (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);`);
+    wsSql.close();
+}
+(async () => {
+    let stmt = null;
+    let connector = null;
+    try {
+        await Prepare();
+        let wsConf = new config_1.WSConfig(dsn);
+        wsConf.setDb(db);
+        connector = await (0, src_1.sqlConnect)(wsConf);
+        stmt = await connector.stmtInit();
+        await stmt.prepare(`INSERT INTO ? USING ${db}.${stable} (location, groupId) TAGS (?, ?) VALUES (?, ?, ?, ?)`);
+        for (let i = 0; i < numOfSubTable; i++) {
+            await stmt.setTableName(`d_bind_${i}`);
+            let tagParams = stmt.newStmtParam();
+            tagParams.setVarchar([`location_${i}`]);
+            tagParams.setInt([i]);
+            await stmt.setTags(tagParams);
+            let timestampParams = [];
+            let currentParams = [];
+            let voltageParams = [];
+            let phaseParams = [];
+            const currentMillis = new Date().getTime();
+            for (let j = 0; j < numOfRow; j++) {
+                timestampParams.push(currentMillis + j);
+                currentParams.push(Math.random() * 30);
+                voltageParams.push(getRandomInt(100, 300));
+                phaseParams.push(Math.random());
+            }
+            let bindParams = stmt.newStmtParam();
+            bindParams.setTimestamp(timestampParams);
+            bindParams.setFloat(currentParams);
+            bindParams.setInt(voltageParams);
+            bindParams.setFloat(phaseParams);
+            await stmt.bind(bindParams);
+            await stmt.batch();
+            await stmt.exec();
+            console.log(`d_bind_${i} insert ` + stmt.getLastAffected() + " rows.");
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    finally {
+        if (stmt) {
+            await stmt.close();
+        }
+        if (connector) {
+            await connector.close();
+        }
+        (0, src_1.destroy)();
+    }
+})();

package/lib/example/basicTmq.d.ts

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

package/lib/example/basicTmq.d.ts.map

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

package/lib/example/basicTmq.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../src/common/config");
+const constant_1 = require("../src/tmq/constant");
+const src_1 = require("../src");
+const stable = 'meters';
+const db = 'power';
+const topics = ['topic_ws_map'];
+let dropTopic = `DROP TOPIC IF EXISTS ${topics[0]};`;
+let configMap = new Map([
+    [constant_1.TMQConstants.GROUP_ID, "gId_11"],
+    [constant_1.TMQConstants.CONNECT_USER, "root"],
+    [constant_1.TMQConstants.CONNECT_PASS, "taosdata"],
+    [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
+    [constant_1.TMQConstants.CLIENT_ID, 'test_tmq_client11'],
+    [constant_1.TMQConstants.WS_URL, 'ws://localhost:6041'],
+    [constant_1.TMQConstants.ENABLE_AUTO_COMMIT, 'false'],
+    [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, '1000']
+]);
+let dsn = 'ws://root:taosdata@localhost:6041';
+async function Prepare() {
+    let conf = new config_1.WSConfig(dsn);
+    const createDB = `create database if not exists ${db} KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;`;
+    const createStable = `CREATE STABLE if not exists ${db}.${stable} (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);`;
+    let createTopic = `create topic if not exists ${topics[0]} as select * from ${db}.${stable}`;
+    const useDB = `use ${db}`;
+    let ws = await (0, src_1.sqlConnect)(conf);
+    await ws.exec(createDB);
+    await ws.exec(useDB);
+    await ws.exec(createStable);
+    await ws.exec(createTopic);
+    for (let i = 0; i < 1000; i++) {
+        await ws.exec(`INSERT INTO d1001 USING ${stable} (location, groupId) TAGS ("California.SanFrancisco", 3) VALUES (NOW + ${i}a, ${10 + i}, ${200 + i}, ${0.32 + i})`);
+    }
+    await ws.close();
+}
+(async () => {
+    let consumer = null;
+    try {
+        (0, src_1.setLogLevel)("debug");
+        await Prepare();
+        consumer = await (0, src_1.tmqConnect)(configMap);
+        await consumer.subscribe(topics);
+        for (let i = 0; i < 5; i++) {
+            let res = await consumer.poll(100);
+            for (let [key, value] of res) {
+                console.log(key, value.getMeta());
+                let data = value.getData();
+                if (data) {
+                    console.log(data.length);
+                }
+            }
+            // await consumer.commit();
+        }
+        // let assignment = await consumer.assignment()
+        // console.log(assignment)
+        // await consumer.seekToBeginning(assignment)
+        // assignment = await consumer.assignment()
+        // for(let i in assignment) {
+        //     console.log("seek after:", assignment[i])
+        // }
+        await consumer.unsubscribe();
+    }
+    catch (e) {
+        console.error(e);
+    }
+    finally {
+        if (consumer) {
+            await consumer.close();
+        }
+        (0, src_1.destroy)();
+    }
+})();