dolphindb 2.0.1012 → 2.0.1014

package/index.d.ts

@@ -320,9 +320,9 @@ export declare function int1282str(buffer: Uint8Array, le?: boolean): string;
 export interface StreamingParams {
     table: string;
     action?: string;
-    handler(message: StreamingData): any;
+    handler(message: StreamingMessage): any;
 }
-export interface StreamingData extends StreamingParams {
+export interface StreamingMessage extends StreamingParams {
     /** server 发送消息的时间 (nano seconds since epoch)   The time the server sent the message (nano seconds since epoch)
         std::chrono::system_clock::now().time_since_epoch() / std::chrono::nanoseconds(1) */
     time: bigint;
@@ -417,7 +417,7 @@ export declare class DDB {
     /** 表示本次会话执行的 SQL 标准 */
     sql: SqlStandard;
     /** 是否为流数据连接，非流数据这个字段恒为 null  Whether it is a streaming data connection, this field is always null for non-streaming data */
-    streaming: StreamingData;
+    streaming: StreamingParams;
     /** 是否打印每个 rpc 的信息用于调试 */
     verbose: boolean;
     print_message_buffer: boolean;
@@ -427,8 +427,7 @@ export declare class DDB {
     pnode_run_defined: boolean;
     /** 在 websocket 收到的第一个 error 时，
         在 connect_websocket 的 on_error 回调中构造 DdbConnectionError 并保存到 DDB 对象上，
-        这个 error 的错误信息最准确
-        this.errored 为 true 时建议 throw this.error || new DdbConnectionError(this) */
+        这个 error 的错误信息最准确 */
     error: DdbConnectionError;
     /** DdbMessage listeners */
     listeners: DdbMessageListener[];
@@ -437,7 +436,6 @@ export declare class DDB {
     /** 首次定义 pnode_run 的 promise，保证并发调用 rpc 时只定义一次 pnode_run */
     ppnode_run: Promise<DdbVoid>;
     get connected(): boolean;
-    get errored(): boolean;
     /**
         使用 WebSocket URL 初始化连接到 DolphinDB 的实例（不建立实际的网络连接）
         Initialize an instance of DolphinDB Client using the WebSocket URL (without establishing an actual network connection)
@@ -464,7 +462,7 @@ export declare class DDB {
     constructor(url: string, options?: DdbOptions);
     private on_message;
     private on_error;
-    /** 调用后会确保和数据库的连接是正常的 (this.connected === true && this.errored === false)，否则抛出错误
+    /** 调用后会确保和数据库的连接是正常的 (this.connected === true)，否则抛出错误
         这个方法是幂等的，首次调用建立实际的 WebSocket 连接到 URL 对应的 DolphinDB，然后执行自动登录，
         如果是流数据连接，还会调用 publishTable 订阅流表
         后续调用检查上面的条件
@@ -473,7 +471,7 @@ export declare class DDB {
         2. session 是有状态的，重连也无法恢复之前的状态
         3. 断线后所有之前的 ddb.call, ddb.eval 都应该抛出连接错误
         
-        After calling, it will ensure that the connection with the database is normal (this.connected === true && this.errored === false), otherwise an error will be thrown
+        After calling, it will ensure that the connection with the database is normal (this.connected === true), otherwise an error will be thrown
         This method is idempotent, the first call establishes an actual WebSocket connection to the DolphinDB corresponding to the URL, and subsequent calls check the above conditions
         After the connection is disconnected, it is forbidden to call connect again to reconnect the original ddb object. You should use new DDB() to create a new connection object because:
         1. The on_error callback is bound to a certain websocket, and it is inconvenient to unbind and rebind
@@ -584,7 +582,7 @@ export declare class DDB {
     /** 解析服务端响应报文，返回去掉 header 的 data buf */
     parse_message(buf: Uint8Array, error: DdbDatabaseError): DdbMessage;
     /** 内部的流订阅方法  Internal stream subscription method */
-    subscribe(): Promise<StreamingData>;
+    subscribe(): Promise<void>;
 }
 export interface DdbMessageListener {
     (message: DdbMessage, _this: DDB): any;

package/index.js

@@ -2162,8 +2162,7 @@ export class DDB {
     pnode_run_defined = false;
     /** 在 websocket 收到的第一个 error 时，
         在 connect_websocket 的 on_error 回调中构造 DdbConnectionError 并保存到 DDB 对象上，
-        这个 error 的错误信息最准确
-        this.errored 为 true 时建议 throw this.error || new DdbConnectionError(this) */
+        这个 error 的错误信息最准确 */
     error;
     /** DdbMessage listeners */
     listeners = [];
@@ -2174,9 +2173,6 @@ export class DDB {
     get connected() {
         return !this.error && this.lwebsocket.resource?.readyState === WebSocketOpen;
     }
-    get errored() {
-        return Boolean(this.error || (this.lwebsocket.resource && this.lwebsocket.resource.readyState !== WebSocketOpen));
-    }
     /**
         使用 WebSocket URL 初始化连接到 DolphinDB 的实例（不建立实际的网络连接）
         Initialize an instance of DolphinDB Client using the WebSocket URL (without establishing an actual network connection)
@@ -2223,7 +2219,7 @@ export class DDB {
     on_error() {
         // 这里的实现一定会被 connect, rpc 中的实现覆盖
     }
-    /** 调用后会确保和数据库的连接是正常的 (this.connected === true && this.errored === false)，否则抛出错误
+    /** 调用后会确保和数据库的连接是正常的 (this.connected === true)，否则抛出错误
         这个方法是幂等的，首次调用建立实际的 WebSocket 连接到 URL 对应的 DolphinDB，然后执行自动登录，
         如果是流数据连接，还会调用 publishTable 订阅流表
         后续调用检查上面的条件
@@ -2232,17 +2228,20 @@ export class DDB {
         2. session 是有状态的，重连也无法恢复之前的状态
         3. 断线后所有之前的 ddb.call, ddb.eval 都应该抛出连接错误
         
-        After calling, it will ensure that the connection with the database is normal (this.connected === true && this.errored === false), otherwise an error will be thrown
+        After calling, it will ensure that the connection with the database is normal (this.connected === true), otherwise an error will be thrown
         This method is idempotent, the first call establishes an actual WebSocket connection to the DolphinDB corresponding to the URL, and subsequent calls check the above conditions
         After the connection is disconnected, it is forbidden to call connect again to reconnect the original ddb object. You should use new DDB() to create a new connection object because:
         1. The on_error callback is bound to a certain websocket, and it is inconvenient to unbind and rebind
         2. The session is stateful, and the previous state cannot be restored even after reconnection
         3. After disconnection, all previous ddb.call, ddb.eval should throw a connection error */
     async connect() {
-        if (this.errored)
-            throw this.error || new DdbConnectionError(this);
         if (this.connected)
             return;
+        if (this.error)
+            throw this.error;
+        const { resource: websocket } = this.lwebsocket;
+        if (websocket && (websocket.readyState === WebSocketClosing || websocket.readyState === WebSocketClosed))
+            throw this.error = new DdbConnectionError(this);
         return this.pconnect ??= new Promise(async (resolve, reject) => {
             this.on_error = () => {
                 reject(this.error /* 一定有，不需要再 || new DdbConnectionError(this)  */);
@@ -2395,8 +2394,8 @@ export class DDB {
         // 这里也乐观的认为 this.connected && !this.errored 为 true
         return this.lwebsocket.request(async (websocket) => {
             // 独占资源后先检查状态
-            if (this.errored || !this.connected)
-                throw this.error || new DdbConnectionError(this);
+            if (this.error)
+                throw this.error;
             const args = DdbObj.to_ddbobjs(_args);
             const id = genid() % 1000;
             const rpc_id = ` (id = ${id})`;
@@ -2641,9 +2640,7 @@ export class DDB {
     }
     /** 内部的流订阅方法  Internal stream subscription method */
     async subscribe() {
-        console.log(t('订阅流表成功') + ', colnames:', 
-        // string[3](['time', 'stock', 'price'])
-        this.streaming.colnames = (await this.call('publishTable', [
+        const { value: colnames } = await this.call('publishTable', [
             'localhost',
             new DdbInt(0),
             this.streaming.table,
@@ -2651,27 +2648,25 @@ export class DDB {
             // new DdbInt(-1),  // offset
             // filter
             // allow exists
-        ], { skip_connection_check: true })).value);
-        this.streaming.window = {
+        ], { skip_connection_check: true });
+        console.log(t('订阅流表成功') + ', colnames:', 
+        // string[3](['time', 'stock', 'price'])
+        colnames);
+        let win = {
             offset: 0,
             rows: 0,
             segments: [],
         };
         // 先准备好收到 websocket message 的 callback
         this.on_message = buffer => {
-            // 复制一份，避免 handler 中异步直接使用传入的 streaming 这个对象时属性发生变化
-            let streaming = { ...this.streaming, error: null };
             try {
                 const dv = new DataView(buffer);
                 const buf = new Uint8Array(buffer);
-                streaming.time = dv.getBigInt64(1, this.le);
-                streaming.id = dv.getBigInt64(9, this.le);
                 const i_topic_end = buf.indexOf(0, 17);
-                streaming.topic = this.dec.decode(buf.subarray(17, i_topic_end));
                 // 是 column 片段组成的 any vector
-                const data = streaming.data = DdbObj.parse(buf.subarray(i_topic_end + 1), this.le);
-                let { window: win } = streaming;
-                win.rows += streaming.rows = data.value[0].rows;
+                const data = DdbObj.parse(buf.subarray(i_topic_end + 1), this.le);
+                const { rows } = data.value[0];
+                win.rows += rows;
                 win.segments.push(data);
                 if (win.rows >= winsize * 2 && win.segments.length >= 2) {
                     let winsize_ = 0;
@@ -2683,14 +2678,22 @@ export class DDB {
                     win.offset += win.rows - winsize_;
                     win.rows = winsize_;
                 }
+                this.streaming.handler({
+                    ...this.streaming,
+                    id: dv.getBigInt64(9, this.le),
+                    time: dv.getBigInt64(1, this.le),
+                    rows,
+                    topic: this.dec.decode(buf.subarray(17, i_topic_end)),
+                    colnames,
+                    data,
+                    window: win,
+                });
             }
             catch (error) {
                 // 将 error 交给 handler 处理
-                streaming.error = error;
+                this.streaming.handler({ ...this.streaming, error });
             }
-            this.streaming.handler(streaming);
         };
-        return this.streaming;
     }
 }
 // const ddb_gateway = {