dolphindb 2.0.506 → 2.0.509

package/index.d.ts

@@ -78,8 +78,22 @@ export interface DdbArrayVectorBlock {
     lengths: Uint8Array | Uint16Array | Uint32Array;
     data: DdbVectorValue;
 }
-export declare type DdbValue = null | boolean | number | [number, number] | bigint | string | string[] | Uint8Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array | BigInt64Array | Uint8Array[] | DdbObj[] | DdbFunctionDefValue | DdbSymbolExtendedValue | DdbArrayVectorBlock[];
-export declare type DdbVectorValue = string | string[] | Uint8Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array | BigInt64Array | Uint8Array[] | DdbObj[] | DdbSymbolExtendedValue | DdbArrayVectorBlock[];
+export interface DdbMatrixValue {
+    rows: DdbObj<DdbVectorValue>;
+    cols: DdbObj<DdbVectorValue>;
+    data: DdbVectorValue;
+}
+export declare type DdbScalarValue = null | boolean | number | bigint | string | Uint8Array | // uuid, ipaddr, int128, blob
+[
+    number,
+    number
+] | // complex, point
+DdbFunctionDefValue;
+export declare type DdbVectorValue = Uint8Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array | BigInt64Array | string[] | // string[]
+Uint8Array[] | // blob
+DdbObj[] | // any
+DdbSymbolExtendedValue | DdbArrayVectorBlock[];
+export declare type DdbValue = DdbScalarValue | DdbVectorValue | DdbMatrixValue;
 export declare const nulls: {
     readonly int8: -128;
     readonly int16: -32768;
@@ -123,23 +137,20 @@ export declare class DdbObj<T extends DdbValue = DdbValue> {
     rows?: number;
     /** 第 2 维 */
     cols?: number;
-    /** matrix 中值的类型，仅 matrix 才有 */
-    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];
+    static parse_scalar(buf: Uint8Array, le: boolean, type: DdbType): [number, DdbScalarValue];
     /** parse: rows, cols, items
         返回的 ddbobj.length 不包括 vector 的 type 和 form
     */
-    static parse_vector(buf: Uint8Array, le: boolean, type: DdbType): DdbObj;
+    static parse_vector(buf: Uint8Array, le: boolean, type: DdbType): DdbObj<DdbVectorValue>;
     /** 有可能没有字节对齐，不能直接使用原有 message 的 arraybuffer, 统一复制出来，让原有 arraybuffer 被回收掉比较好 */
     static parse_vector_items(buf: Uint8Array, le: boolean, type: DdbType, length: number): [
         number,
@@ -273,12 +284,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 +315,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 +360,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 +415,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 +426,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

@@ -239,34 +239,60 @@ class DdbObj {
                 });
             }
             case DdbForm.matrix: {
-                // matrix([
+                // rename!(
+                //     1..9$3:3,
                 //     [1, 2, 3],
-                //     [3, 2, 1]
-                // ])
-                // <Buffer 00 has_row_label = , has_col_label = 
-                // 04 03 type = int, form = matrix
-                // 03 00 00 00 02 00 00 00 rows = 3, cols = 2
-                // 01 00 00 00 02 00 00 00 03 00 00 00 03 00 00 00 02 00 00 00 01 00 00 00>
+                //     ['c1', 'c2', 'c3']
+                // )
+                // <Buffer 04 03 type = int, form = matrix
+                // 03 has_row_label (& 0x01) = 1, has_col_label (& 0x02) = 1
+                // row labels
+                // 04 01 type = int, form = vector
+                // 03 00 00 00 01 00 00 00 rows = 3, cols = 1
+                // 01 00 00 00 02 00 00 00 03 00 00 00 vector values
+                // col labels
+                // 12 01 type = string, form = vector
+                // 03 00 00 00 01 00 00 00 rows = 3, cols = 1
+                // 63 31 00 63 32 00 63 33 00 
+                // matrix data
+                // 04 03 type = matrix.type, form = matrix
+                // 03 00 00 00 03 00 00 00 rows = 3, cols = 3
                 const dv = new DataView(buf.buffer, buf.byteOffset + i_data);
                 const label_flags = buf_data[0];
                 const has_row_labels = Boolean(label_flags & 0x01);
                 const has_col_labels = Boolean(label_flags & 0x02);
-                if (has_row_labels || has_col_labels)
-                    throw new Error('matrix 暂不支持 row labels 和 col labels');
-                const datatype = buf_data[1];
-                const rows = dv.getUint32(3, le);
-                const cols = dv.getUint32(7, le);
-                const [len_items, value] = this.parse_vector_items(buf_data.subarray(11), le, datatype, rows * cols // 假设小于 2**32
+                let row_labels = null;
+                let col_labels = null;
+                let offset = 1;
+                if (has_row_labels) {
+                    row_labels = this.parse_vector(buf_data.subarray(offset + 2), le, buf_data[offset]);
+                    row_labels.length += 2;
+                    offset += row_labels.length;
+                }
+                if (has_col_labels) {
+                    col_labels = this.parse_vector(buf_data.subarray(offset + 2), le, buf_data[offset]);
+                    col_labels.length += 2;
+                    offset += col_labels.length;
+                }
+                if (buf_data[offset] !== type)
+                    throw new Error('matrix.datatype !== matrix.type');
+                const rows = dv.getUint32(offset + 2, le);
+                const cols = dv.getUint32(offset + 6, le);
+                const [len_items, data] = this.parse_vector_items(buf_data.subarray(offset + 10), le, type, rows * cols // 假设小于 2**32
                 );
+                offset += 10 + len_items;
                 return new this({
                     le,
                     form,
                     type,
-                    length: i_data + 11 + len_items,
+                    length: i_data + offset,
                     rows,
                     cols,
-                    datatype,
-                    value,
+                    value: {
+                        rows: row_labels,
+                        cols: col_labels,
+                        data,
+                    },
                 });
             }
             default:
@@ -494,6 +520,7 @@ class DdbObj {
             case DdbType.minute:
             case DdbType.second:
             case DdbType.datetime:
+            case DdbType.datehour:
                 return [
                     4 * length,
                     new Int32Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + 4 * length))
@@ -618,7 +645,7 @@ class DdbObj {
     }
     pack() {
         const { form, type, value } = this;
-        let header = new Uint8Array(new ArrayBuffer(2));
+        let header = new Uint8Array(2);
         header[0] = type;
         header[1] = form;
         const body = (() => {
@@ -759,12 +786,17 @@ class DdbObj {
                         value[0].pack(),
                         value[1].pack(),
                     ];
-                case DdbForm.matrix:
+                case DdbForm.matrix: {
+                    const { rows, cols, data } = value;
                     return [
-                        Uint8Array.of(0, this.datatype, this.form),
+                        Uint8Array.of((rows && 0x01) | (cols && 0x02)),
+                        ...rows ? [rows.pack()] : [],
+                        ...cols ? [cols.pack()] : [],
+                        Uint8Array.of(this.type, this.form),
                         Uint32Array.of(this.rows, this.cols),
-                        ...DdbObj.pack_vector_body(value, this.datatype, this.rows * this.cols)
+                        ...DdbObj.pack_vector_body(data, this.type, this.rows * this.cols)
                     ];
+                }
                 default:
                     throw new Error(`${DdbForm[form]} 暂不支持序列化`);
             }
@@ -792,6 +824,7 @@ class DdbObj {
             case DdbType.minute:
             case DdbType.second:
             case DdbType.datetime:
+            case DdbType.datehour:
                 return [value];
             case DdbType.float:
                 return [value];
@@ -878,7 +911,7 @@ class DdbObj {
                 case DdbForm.dict:
                     return `dict<${DdbType[this.value[0].type]}, ${DdbType[this.value[1].type]}>`;
                 case DdbForm.matrix:
-                    return `matrix<${DdbType[this.datatype]}>[${this.rows} rows][${this.cols} cols]`;
+                    return `matrix<${DdbType[this.type]}>[${this.rows} rows][${this.cols} cols]`;
                 default:
                     return `${DdbForm[this.form]} ${tname}`;
             }
@@ -907,21 +940,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 +1426,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 +1439,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 +1470,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 +1548,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 +1626,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 +1689,7 @@ class DDB {
             func,
             args,
             urgent,
-            handler,
+            listener,
             parse_object
         });
     }
@@ -1677,10 +1698,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 +1739,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,