dolphindb 3.0.122 → 3.0.124

package/i18n/dict.json

@@ -103,5 +103,8 @@
     },
     "iotany sub vector 不支持非 vector 类型": {
         "en": "iotany sub vector does not support non-vector types"
+    },
+    "iotany 的 meta vector 长度至少为 2": {
+        "en": "The length of the iotany meta vector is at least 2"
     }
 }

package/index.d.ts

@@ -631,7 +631,6 @@ export interface DdbOptions {
 export interface DdbCallOptions extends DdbEvalOptions {
     node?: string;
     nodes?: string[];
-    func_type?: DdbFunctionType;
     add_node_alias?: boolean;
     skip_connection_check?: boolean;
     on_more_messages?: DdbRpcOptions['on_more_messages'];
@@ -686,6 +685,8 @@ export declare class DDB {
     ppnode_run: Promise<DdbVoid>;
     /** 首次定义 invoke 的 promise，保证并发调用 rpc 时只定义一次 invoke */
     pinvoke: Promise<DdbVoid>;
+    /** 首次定义 jsrpc 的 promise，保证并发调用 rpc 时只定义一次 jsrpc */
+    pjsrpc: Promise<DdbVoid>;
     get connected(): boolean;
     /**
         使用 WebSocket URL 初始化连接到 DolphinDB 的实例（不建立实际的网络连接）
@@ -790,8 +791,6 @@ export declare class DDB {
                 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?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
                 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?: 设置 node 参数时必传，需指定函数类型，其它情况下不传
-                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?: 设置 nodes 参数时选传，其它情况不传
                 Select to pass when setting the nodes parameter, otherwise not pass
             - listener?: 处理本次 rpc 期间的消息 (DdbMessage)
@@ -805,7 +804,7 @@ export declare class DDB {
                 将这个 flag 设为 true 跳过连接状态检查
                 (internal use) When await ddb.connect() establishes a connection for the first time, you cannot call await this.connect() again to ensure the connection status, which will lead to circular dependencies.
                  Set this flag to true to skip connection status checks */
-    call<TResult extends DdbObj>(func: string, args?: (DdbObj | string | boolean)[], { urgent, node, nodes, func_type, add_node_alias, listener, parse_object, skip_connection_check, on_more_messages }?: DdbCallOptions): Promise<TResult>;
+    call<TResult extends DdbObj>(func: string, args?: (DdbObj | string | boolean)[], { urgent, node, nodes, add_node_alias, listener, parse_object, skip_connection_check, on_more_messages }?: DdbCallOptions): Promise<TResult>;
     /** 调用 dolphindb 函数，传入 js 原生数组作为参数，返回 js 原生对象或值（调用 DdbObj.data() 后的结果）
         - func: 函数名
         - args?: `[ ]` 调用参数，可以是 js 原生数组，参数在中间且想用 server 函数的默认参数值时可以传 null 占位
@@ -813,7 +812,6 @@ export declare class DDB {
             - urgent?: 紧急 flag。使用 urgent worker 执行，防止被其它作业阻塞
             - node?: 设置结点 alias 时发送到集群中对应的结点执行 (使用 DolphinDB 中的 rpc 方法)
             - nodes?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
-            - func_type?: 设置 node 参数且参数数组为空时必传，需指定函数类型，其它情况下不传
             - add_node_alias?: 设置 nodes 参数时选传，其它情况不传
             - listener?: 处理本次 rpc 期间的消息 (DdbMessage) */
     invoke<TResult = any>(func: string, args?: any[], options?: DdbInvokeOptions): Promise<TResult>;

package/index.js

@@ -822,41 +822,20 @@ export class DdbObj {
                 ];
             }
             case DdbType.iotany: {
-                // 构造 indexes
-                const dv = new DataView(buf.buffer, buf.byteOffset);
-                let i_value_start = 0;
-                const size = Number(dv.getUint32(i_value_start, le));
-                i_value_start += 4;
-                const indexes = new Array(size * 2);
-                for (let i = 0; i < size; i++) {
-                    const type = dv.getUint32(i_value_start, le);
-                    i_value_start += 4;
-                    const idx = dv.getUint32(i_value_start, le);
-                    i_value_start += 4;
-                    indexes[i * 2] = type;
-                    indexes[i * 2 + 1] = idx;
-                }
-                // 构造 sub vector
-                const type_size = dv.getUint32(i_value_start, le);
-                i_value_start += 4;
-                const sub_vec = new Map();
-                for (let i = 0; i < type_size; i++) {
-                    const flag = dv.getUint16(i_value_start, le);
-                    i_value_start += 2;
-                    const form = flag >> 8;
-                    const sub_type = flag & 0xff;
-                    assert(form === DdbForm.vector, t('iotany sub vector 不支持非 vector 类型'));
-                    const sub_size = dv.getUint32(i_value_start, le);
-                    i_value_start += 8; // 同时跳过 sub_size 和 cols
-                    let [len, vector] = this.parse_vector_items(buf.subarray(i_value_start), le, sub_type, sub_size);
-                    vector = converts(sub_type, vector, sub_size, le);
-                    i_value_start += len;
-                    sub_vec.set(sub_type, vector);
+                const [len, anys] = this.parse_vector_items(buf, le, DdbType.any, length);
+                const metas = anys[0].data();
+                assert(metas.length >= 2, t('iotany 的 meta vector 长度至少为 2'));
+                const size = metas[0];
+                // let sub_vec_count = meta_vec[1]
+                let sub_vecs = new Map();
+                for (let i = 1; i < length; i++) {
+                    const sub_vector = anys[i];
+                    const sub_type = sub_vector.type;
+                    sub_vecs.set(sub_type, converts(sub_type, sub_vector.data(), sub_vector.length, le));
                 }
                 return [
-                    i_value_start,
-                    // 根据 indexes 数组构建最终的 value 数组
-                    seq(size, i => (sub_vec.get(indexes[i * 2]))[indexes[i * 2 + 1]])
+                    len,
+                    seq(size, i => (sub_vecs.get(metas[i + size + 2]))[metas[i + 2]])
                 ];
             }
             // 25 01 type = decimal32, form = vector
@@ -2761,6 +2740,8 @@ export class DDB {
     ppnode_run;
     /** 首次定义 invoke 的 promise，保证并发调用 rpc 时只定义一次 invoke */
     pinvoke;
+    /** 首次定义 jsrpc 的 promise，保证并发调用 rpc 时只定义一次 jsrpc */
+    pjsrpc;
     get connected() {
         return !this.error && this.lwebsocket.resource?.readyState === WebSocketOpen;
     }
@@ -3151,8 +3132,6 @@ export class DDB {
                 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?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
                 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?: 设置 node 参数时必传，需指定函数类型，其它情况下不传
-                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?: 设置 nodes 参数时选传，其它情况不传
                 Select to pass when setting the nodes parameter, otherwise not pass
             - listener?: 处理本次 rpc 期间的消息 (DdbMessage)
@@ -3166,18 +3145,41 @@ export class DDB {
                 将这个 flag 设为 true 跳过连接状态检查
                 (internal use) When await ddb.connect() establishes a connection for the first time, you cannot call await this.connect() again to ensure the connection status, which will lead to circular dependencies.
                  Set this flag to true to skip connection status checks */
-    async call(func, args = [], { urgent, node, nodes, func_type, add_node_alias, listener, parse_object, skip_connection_check, on_more_messages } = {}) {
+    async call(func, args = [], { urgent, node, nodes, add_node_alias, listener, parse_object, skip_connection_check, on_more_messages } = {}) {
+        let func_ = func;
+        let args_ = args;
         if (node) {
-            assert(func_type in DdbFunctionType, t('指定 node 时必须设置 func_type'));
-            args = [
+            try {
+                await (this.pjsrpc ??= this.eval(this.python ?
+                    '\n' +
+                        'def jsrpc (node, func_name, args):\n' +
+                        '    args_ = args\n' +
+                        '    if func_name == "invoke":\n' +
+                        '        args_[0] = funcByName(args[0])\n' +
+                        '    return rpc(node, unifiedCall, funcByName(func_name), args_)\n'
+                    :
+                        '\n' +
+                            'def jsrpc (node, func_name, args) {\n' +
+                            '    args_ = args\n' +
+                            '    if (func_name == "invoke")\n' +
+                            '        args_[0] = funcByName(args[0])\n' +
+                            '    return rpc(node, unifiedCall, funcByName(func_name), args_)\n' +
+                            '}\n', { urgent: true }));
+            }
+            catch (error) {
+                this.pjsrpc = undefined;
+                throw error;
+            }
+            func_ = 'jsrpc';
+            args_ = [
                 node,
-                new DdbFunction(func, func_type),
-                ...args
+                func,
+                new DdbVectorAny(args)
             ];
-            func = 'rpc';
         }
         if (nodes) {
-            args = [
+            func_ = 'pnode_run';
+            args_ = [
                 new DdbVectorString(nodes),
                 func,
                 new DdbVectorAny(args),
@@ -3189,11 +3191,10 @@ export class DDB {
                     return [];
                 })()
             ];
-            func = 'pnode_run';
         }
         return this.rpc('function', {
-            func,
-            args,
+            func: func_,
+            args: args_,
             urgent,
             listener,
             parse_object,
@@ -3208,25 +3209,37 @@ export class DDB {
             - urgent?: 紧急 flag。使用 urgent worker 执行，防止被其它作业阻塞
             - node?: 设置结点 alias 时发送到集群中对应的结点执行 (使用 DolphinDB 中的 rpc 方法)
             - nodes?: 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法)
-            - func_type?: 设置 node 参数且参数数组为空时必传，需指定函数类型，其它情况下不传
             - add_node_alias?: 设置 nodes 参数时选传，其它情况不传
             - listener?: 处理本次 rpc 期间的消息 (DdbMessage) */
     async invoke(func, args, options) {
-        await (this.pinvoke ??= this.eval(this.python ?
-            '\n' +
-                'def invoke (func_name, args_json):\n' +
-                '    args = fromStdJson(args_json)\n' +
-                '    if type(args) != ANY:\n' +
-                '        args = cast(args, ANY)\n' +
-                '    return unifiedCall(funcByName(func_name), args)\n'
-            :
+        try {
+            await (this.pinvoke ??= this.eval(this.python ?
                 '\n' +
-                    'def invoke (func_name, args_json) {\n' +
+                    'def invoke (func, args_json):\n' +
                     '    args = fromStdJson(args_json)\n' +
-                    '    if (type(args) != ANY)\n' +
+                    '    func_ = func\n' +
+                    '    if type(func) == STRING:\n' +
+                    '        func_ = funcByName(func)\n' +
+                    '    if type(args) != ANY:\n' +
                     '        args = cast(args, ANY)\n' +
-                    '    return unifiedCall(funcByName(func_name), args)\n' +
-                    '}\n', { urgent: true }));
+                    '    return unifiedCall(func_, args)\n'
+                :
+                    '\n' +
+                        'def invoke (func, args_json) {\n' +
+                        '    args = fromStdJson(args_json)\n' +
+                        '    func_ = func\n' +
+                        '    if (type(func) == STRING)\n' +
+                        '        func_ = funcByName(func)\n' +
+                        '    if (type(args) != ANY)\n' +
+                        '        args = cast(args, ANY)\n' +
+                        '    return unifiedCall(func_, args)\n' +
+                        '}\n', { urgent: true }));
+        }
+        catch (error) {
+            // invoke 没有正确执行时，重新将 pinvoke 赋值为 undefined
+            this.pinvoke = undefined;
+            throw error;
+        }
         // 检查 args 是否全部为简单参数，是则直接调用 call，避免 invoke 间接调用
         // 逻辑类似 DdbObj.to_ddbobjs, 需要同步修改
         let simple = true;
@@ -3243,12 +3256,8 @@ export class DDB {
                         break;
                     }
                 }
-        if (!simple) {
-            if (has_ddbobj)
-                throw new Error(t('调用 ddb.invoke 的参数中不能同时有 DdbObj 与复杂 js 原生对象'));
-            if (options?.node)
-                options.func_type = DdbFunctionType.UserDefinedFunc;
-        }
+        if (!simple && has_ddbobj)
+            throw new Error(t('调用 ddb.invoke 的参数中不能同时有 DdbObj 与复杂 js 原生对象'));
         const result = simple
             ? await this.call(func, args, options)
             : await this.call('invoke', [func, JSON.stringify(args)], options);