dolphindb 2.0.504 → 2.0.505

package/browser.d.ts

@@ -75,11 +75,10 @@ export interface DdbArrayVectorBlock {
     lengths: Uint8Array | Uint16Array | Uint32Array;
     data: DdbVectorValue;
 }
-export declare type DdbValue = null | boolean | number | [number, number] | bigint | string | string[] | Uint8Array | Int16Array | Int32Array | Float32Array | Float64Array | BigInt64Array | Uint8Array[] | DdbObj[] | DdbFunctionDefValue | DdbSymbolExtendedValue | DdbArrayVectorBlock[];
-export declare type DdbVectorValue = string | string[] | Uint8Array | Int16Array | Int32Array | Float32Array | Float64Array | BigInt64Array | Uint8Array[] | DdbObj[] | DdbSymbolExtendedValue | DdbArrayVectorBlock[];
+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 declare const nulls: {
-    readonly bool: 128;
-    readonly char: "€";
+    readonly int8: -128;
     readonly int16: -32768;
     readonly int32: -2147483648;
     readonly int64: -9223372036854775808n;
@@ -125,6 +124,8 @@ export declare class DdbObj<T extends DdbValue = DdbValue> {
     datatype?: DdbType;
     /** 实际数据。不同的 DdbForm, DdbType 使用 DdbValue 中不同的类型来表示实际数据 */
     value: T;
+    /** 原始二进制数据 */
+    buffer?: Uint8Array;
     constructor(data: Partial<DdbObj> & {
         form: DdbForm;
         type: DdbType;
@@ -159,7 +160,7 @@ export declare class DdbBool extends DdbObj<boolean> {
     constructor(value: boolean | null);
 }
 export declare class DdbChar extends DdbObj<string> {
-    constructor(value: string | null);
+    constructor(value: string | number | null);
 }
 export declare class DdbInt extends DdbObj<number> {
     constructor(value: number | null);
@@ -270,13 +271,13 @@ export declare class DDB {
     password: string;
     /** python session flag (2048) */
     python: boolean;
-    message_hook: (message: Uint8Array) => any;
-    /** print message handler */
-    printer(message: string): void;
+    parse_object: boolean;
+    /** message handler */
+    on_message({ type, data }: DdbMessage, _this: DDB): void;
     /** resolver, rejector, promise of last rpc */
-    presolver(buf: Uint8Array): void;
+    presolver(message: DdbMessage): void;
     prejector(error: Error): void;
-    presult: Promise<Uint8Array>;
+    presult: Promise<DdbMessage>;
     get connected(): boolean;
     /**
         Initialize an instance of DolphinDB Client using the WebSocket URL
@@ -349,58 +350,80 @@ export declare class DDB {
         - options:
             - urgent?: 决定 `行为标识` 那一行字符串的取值（只适用于 script 和 function）
             - vars?: type === 'variable' 时必传，variable 指令中待上传的变量名
+            - on_message?:   在该次 rpc 期间设置 message handler, 结束后恢复原有
+            - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
+                不做解析，以便后续转发、序列化
     */
-    rpc<T extends DdbObj = DdbObj>(type: 'script' | 'function' | 'variable' | 'connect', { script, func, args, vars, urgent, }: {
+    rpc<T extends DdbObj = DdbObj>(type: 'script' | 'function' | 'variable' | 'connect', { script, func, args, vars, urgent, on_message, parse_object, }: {
         script?: string;
         func?: string;
         args?: (DdbObj | string | boolean)[];
         vars?: string[];
         urgent?: boolean;
+        on_message?: DDB['on_message'];
+        parse_object?: boolean;
     }): Promise<T>;
-    /** eval script through websocket (script command) */
-    eval<T extends DdbObj>(
-    /** 执行的脚本 */
-    script: string, 
-    /** 执行选项 */
-    { urgent }?: {
-        /** 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞 */
+    /** eval script through websocket (script command)
+        - 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
+            - on_message?: Set the message handler during this rpc, and restore the original after the end
+            - 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, on_message, parse_object, }?: {
         urgent?: boolean;
+        on_message?: DDB['on_message'];
+        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 参数时选传，其它情况不传
+        - 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
+            - on_message?: Set the message handler during this rpc, and restore the original after the end
+            - 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 }?: {
+    call<T extends DdbObj>(func: string, args?: (DdbObj | string | boolean)[], { urgent, node, nodes, func_type, add_node_alias, on_message, parse_object, }?: {
         urgent?: boolean;
         node?: string;
         nodes?: string[];
         func_type?: DdbFunctionType;
         add_node_alias?: boolean;
+        on_message?: DDB['on_message'];
+        parse_object?: boolean;
     }): Promise<T>;
     /** upload variable through websocket (variable command) */
     upload(
     /** Uploaded variables' name */
     vars: string[], 
     /** Uploaded variables' value */
-    args: (DdbObj | string | boolean)[]): Promise<DdbObj<DdbValue>>;
+    args: (DdbObj | string | boolean)[], { on_message, parse_object, }?: {
+        on_message?: DDB['on_message'];
+        parse_object?: boolean;
+    }): Promise<DdbObj<DdbValue>>;
     /** 解析服务端响应报文，返回去掉 header 的 data buf */
-    parse_message(buf: Uint8Array): {
-        type: "message";
-        data: string;
-    } | {
-        type: "object";
-        data: Uint8Array;
-    };
+    parse_message(buf: Uint8Array, parse_object?: boolean): DdbMessage;
     /** 自动转换 js string, boolean 为 DdbObj */
     to_ddbobj(value: DdbObj | string | boolean): DdbObj;
     /** 转换 js 数组为 DdbObj[] */
     to_ddbobjs(values: any[]): DdbObj<DdbValue>[];
 }
+export interface DdbPrintMessage {
+    type: 'print';
+    data: string;
+}
+export interface DdbObjectMessage {
+    type: 'object';
+    data: DdbObj;
+}
+export declare type DdbMessage = DdbPrintMessage | DdbObjectMessage;
 export declare let ddb: DDB;
 export default ddb;

package/browser.js

@@ -7,6 +7,7 @@ const customParseFormat_js_1 = tslib_1.__importDefault(require("dayjs/plugin/cus
 dayjs_1.default.extend(customParseFormat_js_1.default);
 require("xshell/prototype.browser");
 const utils_browser_1 = require("xshell/utils.browser");
+const net_browser_js_1 = require("xshell/net.browser.js");
 var DdbForm;
 (function (DdbForm) {
     DdbForm[DdbForm["scalar"] = 0] = "scalar";
@@ -72,8 +73,7 @@ var DdbFunctionType;
     DdbFunctionType[DdbFunctionType["JitPartialFunc"] = 8] = "JitPartialFunc";
 })(DdbFunctionType = exports.DdbFunctionType || (exports.DdbFunctionType = {}));
 exports.nulls = {
-    bool: 0x80,
-    char: '\x80',
+    int8: -0x80,
     int16: -32768,
     int32: -2147483648,
     int64: -0x8000000000000000n,
@@ -247,12 +247,14 @@ class DdbObj {
             case DdbType.void:
                 return [1, null];
             case DdbType.bool: {
-                const value = buf[0];
-                return [1, value === exports.nulls.bool ? null : Boolean(value)];
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                const value = dv.getInt8(0);
+                return [1, value === exports.nulls.int8 ? null : Boolean(value)];
             }
             case DdbType.char: {
-                const value = String.fromCharCode(buf[0]);
-                return [1, value === exports.nulls.char ? null : value];
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                const value = dv.getInt8(0);
+                return [1, value === exports.nulls.int8 ? null : value];
             }
             case DdbType.short: {
                 const dv = new DataView(buf.buffer, buf.byteOffset);
@@ -437,11 +439,10 @@ class DdbObj {
     static parse_vector_items(buf, le, type, length) {
         switch (type) {
             case DdbType.bool:
-                return [length, buf.slice(0, length)];
             case DdbType.char:
                 return [
                     length,
-                    this.dec.decode(buf.subarray(0, length))
+                    new Int8Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + length))
                 ];
             case DdbType.short:
                 return [
@@ -591,17 +592,17 @@ class DdbObj {
                             return [Uint8Array.of(1)];
                         case DdbType.bool:
                             return [
-                                Uint8Array.of(value === null ?
-                                    exports.nulls.bool
+                                Int8Array.of(value === null ?
+                                    exports.nulls.int8
                                     :
                                         Number(value))
                             ];
                         case DdbType.char:
                             return [
-                                Uint8Array.of((value === null ?
-                                    exports.nulls.char
+                                Int8Array.of((value === null ?
+                                    exports.nulls.int8
                                     :
-                                        value).charCodeAt(0))
+                                        value))
                             ];
                         case DdbType.short:
                             return [
@@ -743,7 +744,7 @@ class DdbObj {
             case DdbType.bool:
                 return [value];
             case DdbType.char:
-                return [this.enc.encode(value)];
+                return [value];
             case DdbType.short:
                 return [value];
             case DdbType.int:
@@ -846,10 +847,18 @@ class DdbObj {
             }
         })();
         const data = (() => {
-            if (this.form === DdbForm.pair)
-                return `${this.value[0]}, ${this.value[1]}`;
-            if (this.form === DdbForm.scalar && this.type === DdbType.functiondef)
-                return `'${this.value.name}'`;
+            switch (this.form) {
+                case DdbForm.pair:
+                    return `${this.value[0]}, ${this.value[1]}`;
+                case DdbForm.scalar:
+                    switch (this.type) {
+                        case DdbType.functiondef:
+                            return `'${this.value.name}'`;
+                        case DdbType.string:
+                            return `'${this.value}'`;
+                    }
+                    break;
+            }
             return this.value;
         })();
         return `${type}(${this.name ? `'${this.name}', ` : ''}${data})\n`;
@@ -949,7 +958,10 @@ class DdbChar extends DdbObj {
             form: DdbForm.scalar,
             type: DdbType.char,
             length: 1,
-            value,
+            value: typeof value === 'string' ?
+                value.charCodeAt(0)
+                :
+                    value
         });
     }
 }
@@ -1355,7 +1367,7 @@ class DDB {
         this.password = '123456';
         /** python session flag (2048) */
         this.python = false;
-        this.message_hook = null;
+        this.parse_object = true;
         this.presult = Promise.resolve(null);
         if (!url) {
             const _url = new URL(location.href);
@@ -1373,12 +1385,16 @@ class DDB {
         if (options.python !== undefined)
             this.python = options.python;
     }
-    /** print message handler */
-    printer(message) {
-        console.log(message);
+    /** message handler */
+    on_message({ type, data }, _this) {
+        switch (type) {
+            case 'print':
+                console.log(data);
+                return;
+        }
     }
     /** resolver, rejector, promise of last rpc */
-    presolver(buf) { }
+    presolver(message) { }
     prejector(error) { }
     get connected() {
         return this.websocket?.readyState === WebSocket.OPEN;
@@ -1403,40 +1419,25 @@ class DDB {
         if (options.python !== undefined)
             this.python = options.python;
         this.disconnect();
-        let websocket = new WebSocket(this.url, this.python ? ['python'] : []);
-        // https://stackoverflow.com/questions/11821096/what-is-the-difference-between-an-arraybuffer-and-a-blob/39951543
-        websocket.binaryType = 'arraybuffer';
-        this.websocket = websocket;
-        await new Promise((resolve, reject) => {
-            websocket.addEventListener('open', async (event) => {
-                console.log(`${websocket.url} opened`);
+        await (0, net_browser_js_1.connect_websocket)(this.url, {
+            protocols: this.python ? ['python'] : [],
+            on_open: async (event, websocket) => {
+                this.websocket = websocket;
                 await this.rpc('connect', {});
-                resolve();
-            });
-            websocket.addEventListener('close', event => {
-                console.log(`${websocket.url} closed with code = ${event.code}, reason = '${event.reason}'`);
-            });
-            websocket.addEventListener('error', event => {
-                const message = `${websocket.url} errored`;
-                console.error(message, event);
-                reject(Object.assign(new Error(message), { event }));
-            });
-            websocket.addEventListener('message', event => {
+            },
+            on_message: event => {
                 const buf = new Uint8Array(event.data);
-                if (this.message_hook)
-                    this.message_hook(buf);
                 try {
-                    const { type, data } = this.parse_message(buf);
-                    if (type === 'message') {
-                        this.printer(data);
+                    const message = this.parse_message(buf);
+                    this.on_message(message, this);
+                    if (message.type === 'print')
                         return;
-                    }
-                    this.presolver(data);
+                    this.presolver(message);
                 }
                 catch (error) {
                     this.prejector(error);
                 }
-            });
+            }
         });
         if (!this.python)
             await this.eval('def pnode_run (nodes, func_name, args, add_node_alias = true) {\n' +
@@ -1490,7 +1491,7 @@ class DDB {
                 limit,
             ] : [],
         ];
-        return `/ ${options.join('_')}`;
+        return options.join('_');
     }
     disconnect() {
         if (this.connected)
@@ -1504,8 +1505,11 @@ class DDB {
         - options:
             - urgent?: 决定 `行为标识` 那一行字符串的取值（只适用于 script 和 function）
             - vars?: type === 'variable' 时必传，variable 指令中待上传的变量名
+            - on_message?:   在该次 rpc 期间设置 message handler, 结束后恢复原有
+            - parse_object?: 在该次 rpc 期间设置 parse_object, 结束后恢复原有，为 false 时返回的 DdbObj 仅含有 buffer 和 le，
+                不做解析，以便后续转发、序列化
     */
-    async rpc(type, { script, func, args = [], vars = [], urgent, }) {
+    async rpc(type, { script, func, args = [], vars = [], urgent, on_message, parse_object, }) {
         if (!this.websocket)
             await this.connect();
         if (!this.connected)
@@ -1552,33 +1556,53 @@ class DDB {
             }
         })());
         const message = (0, utils_browser_1.concat)([
-            this.enc.encode(`API2 ${this.sid} ${command.length}${this.get_rpc_options({ urgent })}\n`),
+            this.enc.encode(`API2 ${this.sid} ${command.length} / ${this.get_rpc_options({ urgent })}\n`),
             command,
             ...args.map((arg) => arg.pack())
         ]);
-        this.websocket.send(message);
-        return DdbObj.parse(await presult, // data_buf
-        this.le);
+        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;
+        }
     }
-    /** eval script through websocket (script command) */
-    async eval(
-    /** 执行的脚本 */
-    script, 
-    /** 执行选项 */
-    { urgent } = {}) {
-        return this.rpc('script', { script, urgent });
+    /** eval script through websocket (script command)
+        - 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
+            - on_message?: Set the message handler during this rpc, and restore the original after the end
+            - 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 });
     }
     /** 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 参数时选传，其它情况不传
+        - 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
+            - on_message?: Set the message handler during this rpc, and restore the original after the end
+            - 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 } = {}) {
+    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');
         if (node) {
@@ -1610,6 +1634,8 @@ class DDB {
             func,
             args,
             urgent,
+            on_message,
+            parse_object
         });
     }
     /** upload variable through websocket (variable command) */
@@ -1617,19 +1643,19 @@ class DDB {
     /** Uploaded variables' name */
     vars, 
     /** Uploaded variables' value */
-    args) {
+    args, { on_message, parse_object, } = {}) {
         if (!args.length || args.length !== vars.length)
             throw new Error('variable 指令参数为空或参数名为空，或数量不匹配');
-        return this.rpc('variable', { vars, args });
+        return this.rpc('variable', { vars, args, on_message, parse_object });
     }
     /** 解析服务端响应报文，返回去掉 header 的 data buf */
-    parse_message(buf) {
+    parse_message(buf, parse_object = this.parse_object) {
         // MSG\n
         // <message>\0
         // 'M'.codePointAt(0).to_hex_str()
         if (buf[0] === 0x4d && buf[1] === 0x53 && buf[2] === 0x47 && buf[3] === 0x0a)
             return {
-                type: 'message',
+                type: 'print',
                 data: this.dec.decode(buf.subarray(4))
             };
         // '1166953221 1 1\n'
@@ -1654,9 +1680,19 @@ class DDB {
         const message = this.dec.decode(buf.subarray(i_ls_1, i_lf_1));
         if (message !== 'OK')
             throw new Error(message);
+        const buf_obj = buf.subarray(i_lf_1 + 1);
         return {
             type: 'object',
-            data: buf.subarray(i_lf_1 + 1)
+            data: parse_object ?
+                Object.assign(DdbObj.parse(buf_obj, this.le), { buffer: buf_obj })
+                :
+                    new DdbObj({
+                        form: DdbForm.scalar,
+                        type: DdbType.void,
+                        length: 0,
+                        le: this.le,
+                        buffer: buf_obj,
+                    })
         };
     }
     /** 自动转换 js string, boolean 为 DdbObj */