dolphindb 2.0.505 → 2.0.506

package/index.d.ts

@@ -252,7 +252,6 @@ export declare class DDB {
     /** utf-8 text decoder */
     dec: TextDecoder;
     enc: TextEncoder;
-    print_buffer: boolean;
     /** DolphinDB WebSocket URL
         e.g. `ws://127.0.0.1:8848/`, `wss://dolphindb.com`
     */
@@ -270,13 +269,16 @@ export declare class DDB {
     password: string;
     /** python session flag (2048) */
     python: boolean;
+    print_message_buffer: boolean;
+    print_object_buffer: boolean;
+    print_message: boolean;
     parse_object: boolean;
-    /** message handler */
-    on_message({ type, data }: DdbMessage, _this: DDB): void;
+    /** message handlers */
+    handlers: DdbMessageHandler[];
     /** resolver, rejector, promise of last rpc */
-    presolver(message: DdbMessage): void;
+    presolver(ddbobj: DdbObj): void;
     prejector(error: Error): void;
-    presult: Promise<DdbMessage>;
+    presult: Promise<DdbObj<DdbValue>>;
     get connected(): boolean;
     /**
         Initialize an instance of DolphinDB Client using the WebSocket URL
@@ -349,30 +351,30 @@ export declare class DDB {
         - options:
             - urgent?: 决定 `行为标识` 那一行字符串的取值（只适用于 script 和 function）
             - vars?: type === 'variable' 时必传，variable 指令中待上传的变量名
-            - on_message?:   在该次 rpc 期间设置 message handler, 结束后恢复原有
+            - handler?: 处理本次 rpc 期间的消息
             - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
                 不做解析，以便后续转发、序列化
     */
-    rpc<T extends DdbObj = DdbObj>(type: 'script' | 'function' | 'variable' | 'connect', { script, func, args, vars, urgent, on_message, parse_object, }: {
+    rpc<T extends DdbObj = DdbObj>(type: 'script' | 'function' | 'variable' | 'connect', { script, func, args, vars, urgent, handler, parse_object, }: {
         script?: string;
         func?: string;
         args?: (DdbObj | string | boolean)[];
         vars?: string[];
         urgent?: boolean;
-        on_message?: DDB['on_message'];
+        handler?: DdbMessageHandler;
         parse_object?: boolean;
     }): Promise<T>;
     /** eval script through websocket (script command)
         - script?: 执行的脚本
         - options?: 执行选项
             - urgent?: 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞
-            - on_message?: 在该次 rpc 期间设置 message handler, 结束后恢复原有
+            - handler?: 处理本次 rpc 期间的消息
             - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
                 不做解析，以便后续转发、序列化
     */
-    eval<T extends DdbObj>(script: string, { urgent, on_message, parse_object, }?: {
+    eval<T extends DdbObj>(script: string, { urgent, handler, parse_object, }?: {
         urgent?: boolean;
-        on_message?: DDB['on_message'];
+        handler?: DdbMessageHandler;
         parse_object?: boolean;
     }): Promise<T>;
     /** call function through websocket (function command)
@@ -384,17 +386,17 @@ export declare class DDB {
             - nodes?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
             - func_type?: 设置 node 参数时必传，需指定函数类型，其它情况下不传
             - add_node_alias?: 设置 nodes 参数时选传，其它情况不传
-            - on_message?: 在该次 rpc 期间设置 message handler, 结束后恢复原有
+            - handler?: 处理本次 rpc 期间的消息
             - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
                 不做解析，以便后续转发、序列化
     */
-    call<T extends DdbObj>(func: string, args?: (DdbObj | string | boolean)[], { urgent, node, nodes, func_type, add_node_alias, on_message, parse_object, }?: {
+    call<T extends DdbObj>(func: string, args?: (DdbObj | string | boolean)[], { urgent, node, nodes, func_type, add_node_alias, handler, parse_object, }?: {
         urgent?: boolean;
         node?: string;
         nodes?: string[];
         func_type?: DdbFunctionType;
         add_node_alias?: boolean;
-        on_message?: DDB['on_message'];
+        handler?: DdbMessageHandler;
         parse_object?: boolean;
     }): Promise<T>;
     /** upload variable through websocket (variable command) */
@@ -402,8 +404,8 @@ export declare class DDB {
     /** Uploaded variables' name */
     vars: string[], 
     /** Uploaded variables' value */
-    args: (DdbObj | string | boolean)[], { on_message, parse_object, }?: {
-        on_message?: DDB['on_message'];
+    args: (DdbObj | string | boolean)[], { handler, parse_object, }?: {
+        handler?: DdbMessageHandler;
         parse_object?: boolean;
     }): Promise<DdbObj<DdbValue>>;
     /** 解析服务端响应报文，返回去掉 header 的 data buf */
@@ -413,6 +415,9 @@ export declare class DDB {
     /** 转换 js 数组为 DdbObj[] */
     to_ddbobjs(values: any[]): DdbObj<DdbValue>[];
 }
+export interface DdbMessageHandler {
+    (message: DdbMessage, _this: DDB): any;
+}
 export interface DdbPrintMessage {
     type: 'print';
     data: string;
@@ -421,5 +426,9 @@ export interface DdbObjectMessage {
     type: 'object';
     data: DdbObj;
 }
-export declare type DdbMessage = DdbPrintMessage | DdbObjectMessage;
+export interface DdbErrorMessage {
+    type: 'error';
+    data: Error;
+}
+export declare type DdbMessage = DdbPrintMessage | DdbObjectMessage | DdbErrorMessage;
 export default DDB;

package/index.js

@@ -884,10 +884,16 @@ class DdbObj {
             }
         })();
         const data = (() => {
-            if (this.form === DdbForm.pair)
-                return `${(0, utils_js_1.inspect)(this.value[0], options)}, ${(0, utils_js_1.inspect)(this.value[1], options)}`;
-            if (this.form === DdbForm.scalar && this.type === DdbType.functiondef)
-                return (0, utils_js_1.inspect)(this.value.name, options);
+            switch (this.form) {
+                case DdbForm.pair:
+                    return `${(0, utils_js_1.inspect)(this.value[0], options)}, ${(0, utils_js_1.inspect)(this.value[1], options)}`;
+                case DdbForm.scalar:
+                    switch (this.type) {
+                        case DdbType.functiondef:
+                            return (0, utils_js_1.inspect)(this.value.name, options);
+                    }
+                    break;
+            }
             if (this.value instanceof Uint8Array)
                 return (0, utils_js_1.inspect)((0, utils_js_1.typed_array_to_buffer)(this.value), options);
             return (0, utils_js_1.inspect)(this.value, options);
@@ -1367,7 +1373,6 @@ class DDB {
         /** utf-8 text decoder */
         this.dec = new TextDecoder('utf-8');
         this.enc = new TextEncoder();
-        this.print_buffer = false;
         this.websocket = null;
         /** little endian (server) */
         this.le = true;
@@ -1379,7 +1384,12 @@ class DDB {
         this.password = '123456';
         /** python session flag (2048) */
         this.python = false;
+        this.print_message_buffer = false;
+        this.print_object_buffer = false;
+        this.print_message = true;
         this.parse_object = true;
+        /** message handlers */
+        this.handlers = [];
         this.presult = Promise.resolve(null);
         this.url = url;
         if (options.autologin !== undefined)
@@ -1391,20 +1401,8 @@ class DDB {
         if (options.python !== undefined)
             this.python = options.python;
     }
-    /** message handler */
-    on_message({ type, data }, _this) {
-        switch (type) {
-            case 'print':
-                console.log(data);
-                return;
-            case 'object':
-                if (this.print_buffer)
-                    console.log((0, utils_js_1.typed_array_to_buffer)(data.buffer));
-                return;
-        }
-    }
     /** resolver, rejector, promise of last rpc */
-    presolver(message) { }
+    presolver(ddbobj) { }
     prejector(error) { }
     get connected() {
         return this.websocket?.readyState === ws_1.WebSocket.OPEN;
@@ -1437,35 +1435,66 @@ class DDB {
             },
             on_message: event => {
                 const buf = new Uint8Array(event.data);
-                try {
-                    const message = this.parse_message(buf);
-                    this.on_message(message, this);
-                    if (message.type === 'print')
-                        return;
-                    this.presolver(message);
+                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);
                 }
-                catch (error) {
-                    this.prejector(error);
+                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;
                 }
             }
         });
-        if (!this.python)
-            await this.eval('def pnode_run (nodes, func_name, args, add_node_alias = true) {\n' +
+        await this.eval(this.python ?
+            'def pnode_run (nodes, func_name, args, add_node_alias):\n' +
                 '    nargs = size(args)\n' +
                 '    func = funcByName(func_name)\n' +
                 '    \n' +
-                '    if (!nargs)\n' +
+                '    if not nargs:\n' +
                 '        return pnodeRun(func, nodes, add_node_alias)\n' +
                 '    \n' +
-                '    args_partial = array(any, 1 + nargs, 1 + nargs)\n' +
-                '    args_partial[0] = func\n' +
-                '    args_partial[1:] = args\n' +
+                '    args_partial = [ ]\n' +
+                '    args_partial.append(func)\n' +
+                '    for a in args:\n' +
+                '        args_partial.append(a)\n' +
+                '    \n' +
                 '    return pnodeRun(\n' +
                 '        unifiedCall(partial, args_partial),\n' +
                 '        nodes,\n' +
                 '        add_node_alias\n' +
-                '    )\n' +
-                '}\n', { urgent: true });
+                '    )\n'
+            :
+                'def pnode_run (nodes, func_name, args, add_node_alias = true) {\n' +
+                    '    nargs = size(args)\n' +
+                    '    func = funcByName(func_name)\n' +
+                    '    \n' +
+                    '    if (!nargs)\n' +
+                    '        return pnodeRun(func, nodes, add_node_alias)\n' +
+                    '    \n' +
+                    '    args_partial = array(any, 1 + nargs, 1 + nargs)\n' +
+                    '    args_partial[0] = func\n' +
+                    '    args_partial[1:] = args\n' +
+                    '    return pnodeRun(\n' +
+                    '        unifiedCall(partial, args_partial),\n' +
+                    '        nodes,\n' +
+                    '        add_node_alias\n' +
+                    '    )\n' +
+                    '}\n', { urgent: true });
         if (this.autologin)
             if (this.python)
                 await this.eval(`login(${this.username.quote('double')}, ${this.password.quote('double')})`, { urgent: true });
@@ -1515,11 +1544,11 @@ class DDB {
         - options:
             - urgent?: 决定 `行为标识` 那一行字符串的取值（只适用于 script 和 function）
             - vars?: type === 'variable' 时必传，variable 指令中待上传的变量名
-            - on_message?:   在该次 rpc 期间设置 message handler, 结束后恢复原有
+            - handler?: 处理本次 rpc 期间的消息
             - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
                 不做解析，以便后续转发、序列化
     */
-    async rpc(type, { script, func, args = [], vars = [], urgent, on_message, parse_object, }) {
+    async rpc(type, { script, func, args = [], vars = [], urgent, handler, parse_object, }) {
         if (!this.websocket)
             await this.connect();
         if (!this.connected)
@@ -1570,19 +1599,18 @@ class DDB {
             command,
             ...args.map((arg) => arg.pack())
         ]);
-        const _on_message = this.on_message;
         const _parse_object = this.parse_object;
-        if (on_message)
-            this.on_message = on_message;
+        if (handler)
+            this.handlers.push(handler);
         if (parse_object !== undefined)
             this.parse_object = parse_object;
         try {
             this.websocket.send(message);
-            const { data } = (await presult);
-            return data;
+            return (await presult);
         }
         finally {
-            this.on_message = _on_message;
+            if (handler)
+                this.handlers = this.handlers.filter(h => h !== handler);
             this.parse_object = _parse_object;
         }
     }
@@ -1590,12 +1618,12 @@ class DDB {
         - script?: 执行的脚本
         - options?: 执行选项
             - urgent?: 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞
-            - on_message?: 在该次 rpc 期间设置 message handler, 结束后恢复原有
+            - handler?: 处理本次 rpc 期间的消息
             - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
                 不做解析，以便后续转发、序列化
     */
-    async eval(script, { urgent, on_message, parse_object, } = {}) {
-        return this.rpc('script', { script, urgent, on_message, parse_object });
+    async eval(script, { urgent, handler, parse_object, } = {}) {
+        return this.rpc('script', { script, urgent, handler, parse_object });
     }
     /** call function through websocket (function command)
         - func: 函数名
@@ -1606,13 +1634,11 @@ class DDB {
             - nodes?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
             - func_type?: 设置 node 参数时必传，需指定函数类型，其它情况下不传
             - add_node_alias?: 设置 nodes 参数时选传，其它情况不传
-            - on_message?: 在该次 rpc 期间设置 message handler, 结束后恢复原有
+            - handler?: 处理本次 rpc 期间的消息
             - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
                 不做解析，以便后续转发、序列化
     */
-    async call(func, args = [], { urgent, node, nodes, func_type, add_node_alias, on_message, parse_object, } = {}) {
-        if (this.python)
-            throw new Error('call doesn\'t support python session yet');
+    async call(func, args = [], { urgent, node, nodes, func_type, add_node_alias, handler, parse_object, } = {}) {
         if (node) {
             if (typeof func_type === 'undefined')
                 throw new Error('指定 node 时必须设置 func_type');
@@ -1642,7 +1668,7 @@ class DDB {
             func,
             args,
             urgent,
-            on_message,
+            handler,
             parse_object
         });
     }
@@ -1651,10 +1677,10 @@ class DDB {
     /** Uploaded variables' name */
     vars, 
     /** Uploaded variables' value */
-    args, { on_message, parse_object, } = {}) {
+    args, { handler, parse_object, } = {}) {
         if (!args.length || args.length !== vars.length)
-            throw new Error('variable 指令参数为空或参数名为空，或数量不匹配');
-        return this.rpc('variable', { vars, args, on_message, parse_object });
+            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 });
     }
     /** 解析服务端响应报文，返回去掉 header 的 data buf */
     parse_message(buf, parse_object = this.parse_object) {
@@ -1687,7 +1713,10 @@ class DDB {
         /** 'OK' 表示成功，其它文本表示失败 */
         const message = this.dec.decode(buf.subarray(i_ls_1, i_lf_1));
         if (message !== 'OK')
-            throw new Error(message);
+            return {
+                type: 'error',
+                data: new Error(message)
+            };
         const buf_obj = buf.subarray(i_lf_1 + 1);
         return {
             type: 'object',