dolphindb 2.0.506 → 2.0.507

package/index.d.ts

@@ -127,12 +127,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];
@@ -273,12 +272,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
@@ -307,6 +303,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
@@ -351,52 +348,54 @@ export declare class DDB {
         - options:
             - urgent?: 决定 `行为标识` 那一行字符串的取值（只适用于 script 和 function）
             - vars?: type === 'variable' 时必传，variable 指令中待上传的变量名
-            - handler?: 处理本次 rpc 期间的消息
+            - handler?: Process messages during this 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?: 执行的脚本
-        - options?: 执行选项
-            - urgent?: 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞
-            - handler?: 处理本次 rpc 期间的消息
-            - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
-                不做解析，以便后续转发、序列化
+        - 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
+            - 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)
-        - func: 函数名
-        - args?: `[ ]` 调用参数 (传入的原生 string 和 boolean 会被自动转换为 DdbObj<string> 和 DdbObj<boolean>)
-        - options?: 调用选项
-            - urgent?: 紧急 flag。使用 urgent worker 执行，防止被其它作业阻塞
-            - node?: 设置结点 alias 时发送到集群中对应的结点执行 (使用 DolphinDB 中的 rpc 方法)
-            - nodes?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
-            - func_type?: 设置 node 参数时必传，需指定函数类型，其它情况下不传
-            - add_node_alias?: 设置 nodes 参数时选传，其它情况不传
-            - handler?: 处理本次 rpc 期间的消息
-            - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
-                不做解析，以便后续转发、序列化
+        - func: function name
+        - args?: `[ ]` Call parameters (the incoming native string and boolean will be automatically converted to DdbObj<string> and DdbObj<boolean>)
+        - options?: call options
+            - urgent?: Emergency flag. Use urgent worker execution to prevent being blocked by other jobs
+            - node?: When the node alias is set, it is sent to the corresponding node in the cluster for execution (using the rpc method in DolphinDB)
+            - 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
+            - 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) */
@@ -404,8 +403,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 */
@@ -415,7 +414,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/index.js

@@ -907,21 +907,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;
@@ -1388,9 +1393,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);
         this.url = url;
         if (options.autologin !== undefined)
             this.autologin = options.autologin;
@@ -1401,12 +1406,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 === ws_1.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
@@ -1434,30 +1437,7 @@ class DDB {
                 await this.rpc('connect', {});
             },
             on_message: event => {
-                const buf = new Uint8Array(event.data);
-                if (this.print_message_buffer)
-                    console.log((0, utils_js_1.typed_array_to_buffer)(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((0, utils_js_1.typed_array_to_buffer)(data.buffer));
-                        this.presolver(data);
-                        return;
-                    case 'error':
-                        this.prejector(data);
-                        return;
-                }
+                this.on_message(event);
             }
         });
         await this.eval(this.python ?
@@ -1535,45 +1515,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 期间的消息
+            - handler?: Process messages during this 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((0, utils_js_1.typed_array_to_buffer)(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) {
@@ -1594,51 +1593,40 @@ class DDB {
                     return 'connect\n';
             }
         })());
-        const message = (0, utils_js_1.concat)([
+        this.websocket.send((0, utils_js_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?: 执行的脚本
-        - options?: 执行选项
-            - urgent?: 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞
-            - handler?: 处理本次 rpc 期间的消息
-            - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
-                不做解析，以便后续转发、序列化
+        - 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
+            - 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: 函数名
-        - args?: `[ ]` 调用参数 (传入的原生 string 和 boolean 会被自动转换为 DdbObj<string> 和 DdbObj<boolean>)
-        - options?: 调用选项
-            - urgent?: 紧急 flag。使用 urgent worker 执行，防止被其它作业阻塞
-            - node?: 设置结点 alias 时发送到集群中对应的结点执行 (使用 DolphinDB 中的 rpc 方法)
-            - nodes?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
-            - func_type?: 设置 node 参数时必传，需指定函数类型，其它情况下不传
-            - add_node_alias?: 设置 nodes 参数时选传，其它情况不传
-            - handler?: 处理本次 rpc 期间的消息
-            - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
-                不做解析，以便后续转发、序列化
+        - func: function name
+        - args?: `[ ]` Call parameters (the incoming native string and boolean will be automatically converted to DdbObj<string> and DdbObj<boolean>)
+        - options?: call options
+            - urgent?: Emergency flag. Use urgent worker execution to prevent being blocked by other jobs
+            - node?: When the node alias is set, it is sent to the corresponding node in the cluster for execution (using the rpc method in DolphinDB)
+            - 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
+            - 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');
@@ -1668,7 +1656,7 @@ class DDB {
             func,
             args,
             urgent,
-            handler,
+            listener,
             parse_object
         });
     }
@@ -1677,10 +1665,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 command parameter is empty or parameter name is empty, or the number does not match');
-        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) {
@@ -1718,10 +1706,12 @@ class DDB {
                 data: new Error(message)
             };
         const buf_obj = buf.subarray(i_lf_1 + 1);
+        if (this.print_object_buffer)
+            console.log((0, utils_js_1.typed_array_to_buffer)(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,