dolphindb 2.0.506 → 2.0.507

package/browser.d.ts

@@ -124,12 +124,11 @@ export declare class DdbObj<T extends DdbValue = DdbValue> {
     datatype?: DdbType;
     /** 实际数据。不同的 DdbForm, DdbType 使用 DdbValue 中不同的类型来表示实际数据 */
     value: T;
-    /** 原始二进制数据 */
+    /** 原始二进制数据，仅在 parse_object 为 false 时通过 parse_message 生成的顶层对象有这个属性 */
     buffer?: Uint8Array;
     constructor(data: Partial<DdbObj> & {
         form: DdbForm;
         type: DdbType;
-        length: number;
     });
     static parse(buf: Uint8Array, le: boolean): DdbObj<DdbValue>;
     static parse_scalar(buf: Uint8Array, le: boolean, type: DdbType): [number, DdbValue];
@@ -275,12 +274,9 @@ export declare class DDB {
     print_object_buffer: boolean;
     print_message: boolean;
     parse_object: boolean;
-    /** message handlers */
-    handlers: DdbMessageHandler[];
-    /** resolver, rejector, promise of last rpc */
-    presolver(ddbobj: DdbObj): void;
-    prejector(error: Error): void;
-    presult: Promise<DdbObj<DdbValue>>;
+    /** DdbMessage listeners */
+    listeners: DdbMessageListener[];
+    promise: Promise<any>;
     get connected(): boolean;
     /**
         Initialize an instance of DolphinDB Client using the WebSocket URL
@@ -309,6 +305,7 @@ export declare class DDB {
         password?: string;
         python?: boolean;
     });
+    private on_message;
     /** Establish the actual WebSocket connection to the DolphinDB corresponding to the URL
         - options?:
             - url?: DolphinDB WebSocket URL. By default, the WebSocket URL passed in when the instance is initialized is used
@@ -353,31 +350,31 @@ export declare class DDB {
         - options:
             - urgent?: 决定 `行为标识` 那一行字符串的取值（只适用于 script 和 function）
             - vars?: type === 'variable' 时必传，variable 指令中待上传的变量名
-            - handler?: 处理本次 rpc 期间的消息
+            - listener?: 处理本次 rpc 期间的消息 (DdbMessage)
             - parse_object?: 在本次 rpc 期间设置 parse_object, 结束后恢复原有
                 为 false 时返回的 DdbObj 仅含有 buffer 和 le，不做解析，以便后续转发、序列化
     */
-    rpc<T extends DdbObj = DdbObj>(type: 'script' | 'function' | 'variable' | 'connect', { script, func, args, vars, urgent, handler, parse_object, }: {
+    rpc<T extends DdbObj = DdbObj>(type: 'script' | 'function' | 'variable' | 'connect', { script, func, args, vars, urgent, listener, parse_object, }: {
         script?: string;
         func?: string;
         args?: (DdbObj | string | boolean)[];
         vars?: string[];
         urgent?: boolean;
-        handler?: DdbMessageHandler;
+        listener?: DdbMessageListener;
         parse_object?: boolean;
     }): Promise<T>;
     /** eval script through websocket (script command)
         - script?: Script to execute
         - options?: execution options
             - urgent?: Urgent flag to ensure that submitted scripts are processed by urgent workers to prevent being blocked by other jobs
-            - handler?: Process messages during this rpc
+            - listener?: Process messages during this rpc (DdbMessage)
             - parse_object?: Set parse_object during this rpc, and restore the original after the end.
                 When it is false, the returned DdbObj only contains buffer and le without parsing,
                 so as to facilitate subsequent forwarding and serialization
     */
-    eval<T extends DdbObj>(script: string, { urgent, handler, parse_object, }?: {
+    eval<T extends DdbObj>(script: string, { urgent, listener, parse_object, }?: {
         urgent?: boolean;
-        handler?: DdbMessageHandler;
+        listener?: DdbMessageListener;
         parse_object?: boolean;
     }): Promise<T>;
     /** call function through websocket (function command)
@@ -389,18 +386,18 @@ export declare class DDB {
             - nodes?: When setting multiple node aliases, send them to the corresponding multiple nodes in the cluster for execution (using the pnodeRun method in DolphinDB)
             - func_type?: It must be passed when setting the node parameter, the function type needs to be specified, and it is not passed in other cases
             - add_node_alias?: Select to pass when setting the nodes parameter, otherwise not pass
-            - handler?: Process messages during this rpc
+            - listener?: Process messages during this rpc (DdbMessage)
             - parse_object?: Set parse_object during this rpc, and restore the original after the end.
                 When it is false, the returned DdbObj only contains buffer and le without parsing,
                 so as to facilitate subsequent forwarding and serialization
     */
-    call<T extends DdbObj>(func: string, args?: (DdbObj | string | boolean)[], { urgent, node, nodes, func_type, add_node_alias, handler, parse_object, }?: {
+    call<T extends DdbObj>(func: string, args?: (DdbObj | string | boolean)[], { urgent, node, nodes, func_type, add_node_alias, listener, parse_object, }?: {
         urgent?: boolean;
         node?: string;
         nodes?: string[];
         func_type?: DdbFunctionType;
         add_node_alias?: boolean;
-        handler?: DdbMessageHandler;
+        listener?: DdbMessageListener;
         parse_object?: boolean;
     }): Promise<T>;
     /** upload variable through websocket (variable command) */
@@ -408,8 +405,8 @@ export declare class DDB {
     /** Uploaded variables' name */
     vars: string[], 
     /** Uploaded variables' value */
-    args: (DdbObj | string | boolean)[], { handler, parse_object, }?: {
-        handler?: DdbMessageHandler;
+    args: (DdbObj | string | boolean)[], { listener, parse_object, }?: {
+        listener?: DdbMessageListener;
         parse_object?: boolean;
     }): Promise<DdbObj<DdbValue>>;
     /** 解析服务端响应报文，返回去掉 header 的 data buf */
@@ -419,7 +416,7 @@ export declare class DDB {
     /** 转换 js 数组为 DdbObj[] */
     to_ddbobjs(values: any[]): DdbObj<DdbValue>[];
 }
-export interface DdbMessageHandler {
+export interface DdbMessageListener {
     (message: DdbMessage, _this: DDB): any;
 }
 export interface DdbPrintMessage {

package/browser.js

@@ -890,21 +890,26 @@ class DdbObj {
         for (let i = 0; i < this.rows; i++) {
             let row = {};
             for (let j = 0; j < this.cols; j++) {
-                const { type, name, value } = this.value[j]; // column
+                const { type, name, value: values } = this.value[j]; // column
                 switch (type) {
-                    case DdbType.bool:
-                        row[name] = Boolean(value[i]);
+                    case DdbType.bool: {
+                        const value = values[i];
+                        row[name] = value === exports.nulls.int8 ?
+                            null
+                            :
+                                Boolean(value);
                         break;
+                    }
                     case DdbType.ipaddr:
-                        row[name] = value.subarray(16 * i, 16 * (i + 1));
+                        row[name] = values.subarray(16 * i, 16 * (i + 1));
                         break;
                     case DdbType.symbol_extended: {
-                        const { base, data } = value;
+                        const { base, data } = values;
                         row[name] = base[data[i]];
                         break;
                     }
                     default:
-                        row[name] = value[i];
+                        row[name] = values[i];
                 }
             }
             rows[i] = row;
@@ -1371,9 +1376,9 @@ class DDB {
         this.print_object_buffer = false;
         this.print_message = true;
         this.parse_object = true;
-        /** message handlers */
-        this.handlers = [];
-        this.presult = Promise.resolve(null);
+        /** DdbMessage listeners */
+        this.listeners = [];
+        this.promise = Promise.resolve(null);
         if (!url) {
             const _url = new URL(location.href);
             const hostname = _url.searchParams.get('hostname') || location.hostname;
@@ -1390,12 +1395,10 @@ class DDB {
         if (options.python !== undefined)
             this.python = options.python;
     }
-    /** resolver, rejector, promise of last rpc */
-    presolver(ddbobj) { }
-    prejector(error) { }
     get connected() {
         return this.websocket?.readyState === WebSocket.OPEN;
     }
+    on_message(event) { }
     /** Establish the actual WebSocket connection to the DolphinDB corresponding to the URL
         - options?:
             - url?: DolphinDB WebSocket URL. By default, the WebSocket URL passed in when the instance is initialized is used
@@ -1423,30 +1426,7 @@ class DDB {
                 await this.rpc('connect', {});
             },
             on_message: event => {
-                const buf = new Uint8Array(event.data);
-                if (this.print_message_buffer)
-                    console.log(buf);
-                const message = this.parse_message(buf);
-                if (this.handlers.length) {
-                    const _handlers = [...this.handlers].reverse();
-                    for (const handler of _handlers)
-                        handler(message, this);
-                }
-                const { type, data } = message;
-                switch (type) {
-                    case 'print':
-                        if (this.print_message)
-                            console.log(data);
-                        return;
-                    case 'object':
-                        if (this.print_object_buffer)
-                            console.log(data.buffer);
-                        this.presolver(data);
-                        return;
-                    case 'error':
-                        this.prejector(data);
-                        return;
-                }
+                this.on_message(event);
             }
         });
         await this.eval(this.python ?
@@ -1524,45 +1504,64 @@ class DDB {
     disconnect() {
         if (this.connected)
             this.websocket.close(1000);
-        this.presolver = buf => { };
-        this.prejector = error => { };
-        this.presult = Promise.resolve(null);
+        this.on_message = () => { };
+        this.promise = Promise.resolve(null);
     }
     /** rpc through websocket (function/script/variable command)
         - type: API 类型: 'script' | 'function' | 'variable'
         - options:
             - urgent?: 决定 `行为标识` 那一行字符串的取值（只适用于 script 和 function）
             - vars?: type === 'variable' 时必传，variable 指令中待上传的变量名
-            - handler?: 处理本次 rpc 期间的消息
+            - listener?: 处理本次 rpc 期间的消息 (DdbMessage)
             - parse_object?: 在本次 rpc 期间设置 parse_object, 结束后恢复原有
                 为 false 时返回的 DdbObj 仅含有 buffer 和 le，不做解析，以便后续转发、序列化
     */
-    async rpc(type, { script, func, args = [], vars = [], urgent, handler, parse_object, }) {
+    async rpc(type, { script, func, args = [], vars = [], urgent, listener, parse_object, }) {
         if (!this.websocket)
             await this.connect();
         if (!this.connected)
             throw new Error(`${this.url} is already disconnected`);
+        // this 上的当前配置需要在 message 到达后使用，先保存起来
+        const _handlers = [...this.listeners].reverse();
         // 临界区：保证多个 rpc 并发时形成 promise 链
         // ddb 世界观：需要等待上一个 rpc 结果从 server 返回之后才能发起下一个调用  
         // 违反世界观可能造成:  
         // 1. 并发多个请求只返回第一个结果（阻塞，需后续请求疏通）
         // 2. windows 下 ddb server 返回多个相同的结果
-        const ptail = this.presult;
-        let presolver;
-        let prejector;
-        const presult = this.presult = new Promise((resolve, reject) => {
-            presolver = resolve;
-            prejector = reject;
+        const ptail = this.promise;
+        let resolve;
+        let reject;
+        const promise = this.promise = new Promise((_resolve, _reject) => {
+            resolve = _resolve;
+            reject = _reject;
         });
         try {
             await ptail;
         }
         catch { }
-        this.presolver = presolver;
-        this.prejector = prejector;
-        // 临界区结束，只有一个 rpc 请求可以写 WebSocket
-        if (urgent && type !== 'script' && type !== 'function')
-            throw new Error('urgent 只适用于 script 和 funciton');
+        // 临界区结束，只有一个 rpc 函数调用运行到这里，可以独占 this.on_message 然后写 WebSocket
+        this.on_message = ({ data: buffer }) => {
+            const buf = new Uint8Array(buffer);
+            if (this.print_message_buffer)
+                console.log(buf);
+            const message = this.parse_message(buf, parse_object);
+            listener?.(message, this);
+            for (const listener of _handlers)
+                listener(message, this);
+            const { type, data } = message;
+            switch (type) {
+                case 'print':
+                    if (this.print_message)
+                        console.log(data);
+                    return;
+                case 'object':
+                    resolve(data);
+                    return;
+                case 'error':
+                    reject(data);
+                    return;
+            }
+        };
         args = this.to_ddbobjs(args);
         const command = this.enc.encode((() => {
             switch (type) {
@@ -1583,37 +1582,24 @@ class DDB {
                     return 'connect\n';
             }
         })());
-        const message = (0, utils_browser_1.concat)([
+        this.websocket.send((0, utils_browser_1.concat)([
             this.enc.encode(`API2 ${this.sid} ${command.length} / ${this.get_rpc_options({ urgent })}\n`),
             command,
             ...args.map((arg) => arg.pack())
-        ]);
-        const _parse_object = this.parse_object;
-        if (handler)
-            this.handlers.push(handler);
-        if (parse_object !== undefined)
-            this.parse_object = parse_object;
-        try {
-            this.websocket.send(message);
-            return (await presult);
-        }
-        finally {
-            if (handler)
-                this.handlers = this.handlers.filter(h => h !== handler);
-            this.parse_object = _parse_object;
-        }
+        ]));
+        return promise;
     }
     /** eval script through websocket (script command)
         - script?: Script to execute
         - options?: execution options
             - urgent?: Urgent flag to ensure that submitted scripts are processed by urgent workers to prevent being blocked by other jobs
-            - handler?: Process messages during this rpc
+            - listener?: Process messages during this rpc (DdbMessage)
             - parse_object?: Set parse_object during this rpc, and restore the original after the end.
                 When it is false, the returned DdbObj only contains buffer and le without parsing,
                 so as to facilitate subsequent forwarding and serialization
     */
-    async eval(script, { urgent, handler, parse_object, } = {}) {
-        return this.rpc('script', { script, urgent, handler, parse_object });
+    async eval(script, { urgent, listener, parse_object, } = {}) {
+        return this.rpc('script', { script, urgent, listener, parse_object });
     }
     /** call function through websocket (function command)
         - func: function name
@@ -1624,12 +1610,12 @@ class DDB {
             - nodes?: When setting multiple node aliases, send them to the corresponding multiple nodes in the cluster for execution (using the pnodeRun method in DolphinDB)
             - func_type?: It must be passed when setting the node parameter, the function type needs to be specified, and it is not passed in other cases
             - add_node_alias?: Select to pass when setting the nodes parameter, otherwise not pass
-            - handler?: Process messages during this rpc
+            - listener?: Process messages during this rpc (DdbMessage)
             - parse_object?: Set parse_object during this rpc, and restore the original after the end.
                 When it is false, the returned DdbObj only contains buffer and le without parsing,
                 so as to facilitate subsequent forwarding and serialization
     */
-    async call(func, args = [], { urgent, node, nodes, func_type, add_node_alias, handler, parse_object, } = {}) {
+    async call(func, args = [], { urgent, node, nodes, func_type, add_node_alias, listener, parse_object, } = {}) {
         if (node) {
             if (typeof func_type === 'undefined')
                 throw new Error('指定 node 时必须设置 func_type');
@@ -1659,7 +1645,7 @@ class DDB {
             func,
             args,
             urgent,
-            handler,
+            listener,
             parse_object
         });
     }
@@ -1668,10 +1654,10 @@ class DDB {
     /** Uploaded variables' name */
     vars, 
     /** Uploaded variables' value */
-    args, { handler, parse_object, } = {}) {
+    args, { listener, parse_object, } = {}) {
         if (!args.length || args.length !== vars.length)
             throw new Error('variable 指令参数为空或参数名为空，或数量不匹配');
-        return this.rpc('variable', { vars, args, handler, parse_object });
+        return this.rpc('variable', { vars, args, listener, parse_object });
     }
     /** 解析服务端响应报文，返回去掉 header 的 data buf */
     parse_message(buf, parse_object = this.parse_object) {
@@ -1709,10 +1695,12 @@ class DDB {
                 data: new Error(message)
             };
         const buf_obj = buf.subarray(i_lf_1 + 1);
+        if (this.print_object_buffer)
+            console.log(buf_obj);
         return {
             type: 'object',
             data: parse_object ?
-                Object.assign(DdbObj.parse(buf_obj, this.le), { buffer: buf_obj })
+                DdbObj.parse(buf_obj, this.le)
                 :
                     new DdbObj({
                         form: DdbForm.scalar,