dolphindb 2.0.505 → 2.0.508

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:
@@ -618,7 +644,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 +785,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]} 暂不支持序列化`);
             }
@@ -878,16 +909,22 @@ 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}`;
             }
         })();
         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);
@@ -901,21 +938,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;
@@ -1367,7 +1409,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,8 +1420,13 @@ 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;
-        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;
@@ -1391,24 +1437,10 @@ 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) { }
-    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
@@ -1436,36 +1468,44 @@ class DDB {
                 await this.rpc('connect', {});
             },
             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);
-                }
-                catch (error) {
-                    this.prejector(error);
-                }
+                this.on_message(event);
             }
         });
-        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 });
@@ -1506,45 +1546,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 指令中待上传的变量名
-            - on_message?:   在该次 rpc 期间设置 message handler, 结束后恢复原有
+            - handler?: Process messages during this rpc (DdbMessage)
             - 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, 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) {
@@ -1565,54 +1624,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 _on_message = this.on_message;
-        const _parse_object = this.parse_object;
-        if (on_message)
-            this.on_message = on_message;
-        if (parse_object !== undefined)
-            this.parse_object = parse_object;
-        try {
-            this.websocket.send(message);
-            const { data } = (await presult);
-            return data;
-        }
-        finally {
-            this.on_message = _on_message;
-            this.parse_object = _parse_object;
-        }
+        ]));
+        return promise;
     }
     /** eval script through websocket (script command)
-        - script?: 执行的脚本
-        - options?: 执行选项
-            - urgent?: 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞
-            - on_message?: 在该次 rpc 期间设置 message handler, 结束后恢复原有
-            - 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, on_message, parse_object, } = {}) {
-        return this.rpc('script', { script, urgent, on_message, 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 参数时选传，其它情况不传
-            - on_message?: 在该次 rpc 期间设置 message handler, 结束后恢复原有
-            - 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, 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, listener, parse_object, } = {}) {
         if (node) {
             if (typeof func_type === 'undefined')
                 throw new Error('指定 node 时必须设置 func_type');
@@ -1642,7 +1687,7 @@ class DDB {
             func,
             args,
             urgent,
-            on_message,
+            listener,
             parse_object
         });
     }
@@ -1651,10 +1696,10 @@ class DDB {
     /** Uploaded variables' name */
     vars, 
     /** Uploaded variables' value */
-    args, { on_message, parse_object, } = {}) {
+    args, { listener, 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, listener, parse_object });
     }
     /** 解析服务端响应报文，返回去掉 header 的 data buf */
     parse_message(buf, parse_object = this.parse_object) {
@@ -1687,12 +1732,17 @@ 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);
+        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,