dolphindb 2.0.603 → 2.0.801

package/browser.js

@@ -4,8 +4,8 @@ dayjs.extend(DayjsCustomParseFormat);
 import ipaddrjs from 'ipaddr.js';
 const { fromByteArray: buf2ipaddr } = ipaddrjs;
 import 'xshell/prototype.browser.js';
-import { blue } from 'xshell/chalk.browser.js';
-import { concat } from 'xshell/utils.browser.js';
+import { blue, cyan, green, grey, magenta } from 'xshell/chalk.browser.js';
+import { concat, assert } from 'xshell/utils.browser.js';
 import { connect_websocket } from 'xshell/net.browser.js';
 export var DdbForm;
 (function (DdbForm) {
@@ -63,7 +63,11 @@ export var DdbType;
     DdbType[DdbType["complex"] = 34] = "complex";
     DdbType[DdbType["point"] = 35] = "point";
     DdbType[DdbType["duration"] = 36] = "duration";
-    DdbType[DdbType["object"] = 37] = "object";
+    DdbType[DdbType["decimal32"] = 37] = "decimal32";
+    DdbType[DdbType["decimal64"] = 38] = "decimal64";
+    DdbType[DdbType["decimal128"] = 39] = "decimal128";
+    DdbType[DdbType["object"] = 40] = "object";
+    DdbType[DdbType["pynone"] = 41] = "pynone";
     DdbType[DdbType["symbol_extended"] = 145] = "symbol_extended";
 })(DdbType = DdbType || (DdbType = {}));
 export var DdbFunctionType;
@@ -115,6 +119,14 @@ export const nulls = {
     bytes16: Uint8Array.from(new Array(16).fill(0))
 };
 export const timezone_offset = 1000 * 60 * new Date().getTimezoneOffset();
+export var StreamingStatusCode;
+(function (StreamingStatusCode) {
+    StreamingStatusCode[StreamingStatusCode["ok"] = 0] = "ok";
+    StreamingStatusCode[StreamingStatusCode["connection_existed"] = 1] = "connection_existed";
+    StreamingStatusCode[StreamingStatusCode["not_leader"] = 2] = "not_leader";
+    StreamingStatusCode[StreamingStatusCode["other"] = 3] = "other";
+    StreamingStatusCode[StreamingStatusCode["error"] = 4] = "error";
+})(StreamingStatusCode = StreamingStatusCode || (StreamingStatusCode = {}));
 /** 可以表示所有 DolphinDB 数据库中的数据类型 */
 export class DdbObj {
     static dec = new TextDecoder('utf-8');
@@ -332,8 +344,7 @@ export class DdbObj {
                     col_labels.length += 2;
                     offset += col_labels.length;
                 }
-                if (buf_data[offset] !== type)
-                    throw new Error('matrix.datatype !== matrix.type');
+                assert(buf_data[offset] === type, '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
@@ -444,38 +455,30 @@ export class DdbObj {
             case DdbType.uuid:
             case DdbType.ipaddr:
             case DdbType.int128:
-                return [
-                    16,
-                    buf.slice(0, 16)
-                ];
+                return [16, buf.slice(0, 16)];
             case DdbType.blob: {
                 const dv = new DataView(buf.buffer, buf.byteOffset);
                 const length = dv.getUint32(0, le);
-                return [
-                    4 + length,
-                    buf.slice(4, 4 + length)
-                ];
+                return [4 + length, buf.slice(4, 4 + length)];
             }
             case DdbType.complex:
             case DdbType.point: {
                 const dv = new DataView(buf.buffer, buf.byteOffset);
-                return [
-                    16,
-                    [
-                        dv.getFloat64(0, le),
-                        dv.getFloat64(8, le)
-                    ]
-                ];
+                return [16, [dv.getFloat64(0, le), dv.getFloat64(8, le)]];
             }
             case DdbType.duration: {
                 const dv = new DataView(buf.buffer, buf.byteOffset);
-                return [
-                    8,
-                    {
-                        unit: dv.getUint32(4, le),
-                        data: dv.getInt32(0, le)
-                    }
-                ];
+                return [8, { unit: dv.getUint32(4, le), data: dv.getInt32(0, le) }];
+            }
+            case DdbType.decimal32: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                const data = dv.getInt32(4, le);
+                return [8, { scale: dv.getInt32(0, le), data: data === nulls.int32 ? null : data }];
+            }
+            case DdbType.decimal64: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                const data = dv.getBigInt64(4, le);
+                return [12, { scale: dv.getInt32(0, le), data: data === nulls.int64 ? null : data }];
             }
             default:
                 throw new Error(`${DdbType[type] || type} 暂时不支持解析`);
@@ -636,7 +639,7 @@ export class DdbObj {
                 // 02 00 00 00 symbol base size = 2
                 // 00 61 61 00 以 \0 分割的字符串
                 // 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00 01 00 00 00>
-                const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+                const dv = new DataView(buf.buffer, buf.byteOffset);
                 const base_id = dv.getUint32(0, le);
                 const base_size = dv.getUint32(4, le);
                 let base_length = 0;
@@ -671,7 +674,7 @@ export class DdbObj {
                 // 04 00 00 00 61 62 63 64 
                 // 04 00 00 00 61 62 63 64>
                 let value = new Array(length);
-                const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+                const dv = new DataView(buf.buffer, buf.byteOffset);
                 let i_head = 0;
                 for (let i = 0; i < length; i++) {
                     const sublen = dv.getUint32(i_head, le);
@@ -711,6 +714,31 @@ export class DdbObj {
                     values
                 ];
             }
+            // 25 01 type = decimal32, form = vector
+            // 02 00 00 00 01 00 00 00
+            // 00 00 00 00 scale = 0
+            // 01 00 00 00 data[0] = 1
+            // 3a 01 00 00 data[1] = 0x013a = 314
+            case DdbType.decimal32: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                return [
+                    4 + 4 * length,
+                    {
+                        scale: dv.getInt32(0, le),
+                        data: new Int32Array(buf.buffer.slice(buf.byteOffset + 4, buf.byteOffset + 4 + 4 * length))
+                    }
+                ];
+            }
+            case DdbType.decimal64: {
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                return [
+                    4 + 8 * length,
+                    {
+                        scale: dv.getInt32(0, le),
+                        data: new BigInt64Array(buf.buffer.slice(buf.byteOffset + 4, buf.byteOffset + 4 + 8 * length))
+                    }
+                ];
+            }
             // case DdbType.duration: -> 实际会返回一个 any vector
             // [2y, 1M, 3d, 7H, 11m, 12s, 15ms, 16us, 17ns]
             // <Buffer 19 01 type = any, form = vector
@@ -814,10 +842,7 @@ export class DdbObj {
                         case DdbType.int128:
                             return [this.value];
                         case DdbType.blob:
-                            return [
-                                Uint32Array.of(this.value.byteLength),
-                                this.value
-                            ];
+                            return [Uint32Array.of(this.value.byteLength), this.value];
                         case DdbType.complex:
                         case DdbType.point:
                             return [Float64Array.from(this.value)];
@@ -825,6 +850,14 @@ export class DdbObj {
                             const { unit, data } = this.value;
                             return [Int32Array.of(data, unit)];
                         }
+                        case DdbType.decimal32: {
+                            const { scale, data } = this.value;
+                            return [Int32Array.of(scale, data === null ? nulls.int32 : data)];
+                        }
+                        case DdbType.decimal64: {
+                            const { scale, data } = this.value;
+                            return [Int32Array.of(scale), BigInt64Array.of(data === null ? nulls.int64 : data)];
+                        }
                         default:
                             throw new Error(`${DdbType[type] || type} 暂时不支持序列化`);
                     }
@@ -846,12 +879,7 @@ export class DdbObj {
                         ...DdbObj.pack_vector_body(value, type, this.rows)
                     ];
                 case DdbForm.set:
-                    return [
-                        new DdbObj({
-                            ...this,
-                            form: DdbForm.vector,
-                        }).pack()
-                    ];
+                    return [new DdbObj({ ...this, form: DdbForm.vector }).pack()];
                 case DdbForm.table:
                     return [
                         Uint32Array.of(this.rows, this.cols),
@@ -863,43 +891,27 @@ export class DdbObj {
                         ...this.value.map(col => col.pack())
                     ];
                 case DdbForm.dict:
-                    return [
-                        value[0].pack(),
-                        value[1].pack(),
-                    ];
+                    return [value[0].pack(), value[1].pack()];
                 case DdbForm.chart: {
-                    const { type, stacking, bin_start, bin_end, bin_count, titles: { chart, x_axis, y_axis, }, extras, data } = this.value;
+                    const { type, stacking, bin_start, bin_end, bin_count, titles: { chart, x_axis, y_axis }, extras, data } = this.value;
                     const { value: [keys, values] } = new DdbDict({
                         chartType: new DdbInt(type),
                         stacking,
-                        ...bin_start ? {
-                            binStart: bin_start,
-                            binEnd: bin_end
-                        } : {},
-                        ...bin_count ? {
-                            binCount: bin_count
-                        } : {},
+                        ...bin_start ? { binStart: bin_start, binEnd: bin_end } : {},
+                        ...bin_count ? { binCount: bin_count } : {},
                         title: new DdbVectorString([chart, x_axis, y_axis]),
                         ...extras ? (() => {
                             const { multi_y_axes, ...extras_other } = extras;
-                            return {
-                                extras: new DdbDict({
-                                    multiYAxes: multi_y_axes,
-                                    ...extras_other
-                                })
-                            };
+                            return { extras: new DdbDict({ multiYAxes: multi_y_axes, ...extras_other }) };
                         })() : {},
                         data,
                     });
-                    return [
-                        keys.pack(),
-                        values.pack(),
-                    ];
+                    return [keys.pack(), values.pack()];
                 }
                 case DdbForm.matrix: {
                     const { rows, cols, data } = value;
                     return [
-                        Uint8Array.of((rows && 0x01) | (cols && 0x02)),
+                        Uint8Array.of((rows ? 0x01 : 0x00) | (cols ? 0x02 : 0x00)),
                         ...rows ? [rows.pack()] : [],
                         ...cols ? [cols.pack()] : [],
                         Uint8Array.of(this.type, this.form),
@@ -908,7 +920,7 @@ export class DdbObj {
                     ];
                 }
                 default:
-                    throw new Error(`${DdbForm[form]} Serialization is not currently supported`);
+                    throw new Error(`${DdbForm[form]} serialization is not currently supported`);
             }
         })();
         if (!body)
@@ -997,16 +1009,21 @@ export class DdbObj {
                     data
                 ];
             }
+            case DdbType.decimal32:
+            case DdbType.decimal64: {
+                const { scale, data } = value;
+                return [Int32Array.of(scale), data];
+            }
             default:
                 throw new Error(`vector ${DdbType[type]} 暂不支持序列化`);
         }
     }
-    toString(colors = false) {
+    toString(options = { nullstr: true, quote: true }) {
         const type = this.inspect_type();
         const data = (() => {
             switch (this.form) {
                 case DdbForm.scalar:
-                    return format(this.type, this.value, this.le);
+                    return format(this.type, this.value, this.le, options);
                 case DdbForm.vector:
                 case DdbForm.pair:
                 case DdbForm.set: {
@@ -1037,7 +1054,7 @@ export class DdbObj {
                             for (const length of lengths) {
                                 let _items = new Array(Math.min(limit, length));
                                 for (let i = 0; i < _items.length; i++)
-                                    _items[i] = format(_type, data[acc_len + i], this.le);
+                                    _items[i] = format(_type, data[acc_len + i], this.le, options);
                                 items[i_items++] = format_array(_items, length > limit);
                                 acc_len += length;
                             }
@@ -1063,7 +1080,7 @@ export class DdbObj {
                             const len_data = value.length / 16;
                             let items = new Array(Math.min(limit, len_data));
                             for (let i = 0; i < items.length; i++)
-                                items[i] = format(this.type, value.subarray(16 * i, 16 * (i + 1)), this.le);
+                                items[i] = format(this.type, value.subarray(16 * i, 16 * (i + 1)), this.le, options);
                             return format_array(items, len_data > limit);
                         }
                         case DdbType.complex:
@@ -1073,24 +1090,33 @@ export class DdbObj {
                             const len_data = value.length / 2;
                             let items = new Array(Math.min(limit, len_data));
                             for (let i = 0; i < items.length; i++)
-                                items[i] = format(this.type, value.subarray(2 * i, 2 * (i + 1)), this.le);
+                                items[i] = format(this.type, value.subarray(2 * i, 2 * (i + 1)), this.le, options);
                             return format_array(items, len_data > limit);
                         }
+                        case DdbType.decimal32:
+                        case DdbType.decimal64: {
+                            const limit = 50;
+                            const { data } = this.value;
+                            let items = new Array(Math.min(limit, data.length));
+                            for (let i = 0; i < items.length; i++)
+                                items[i] = formati(this, i, options);
+                            return format_array(items, data.length > limit);
+                        }
                         default: {
                             const limit = 50;
                             let items = new Array(Math.min(limit, this.value.length));
                             for (let i = 0; i < items.length; i++)
-                                items[i] = format(this.type, this.value[i], this.le);
+                                items[i] = format(this.type, this.value[i], this.le, options);
                             return format_array(items, this.value.length > limit);
                         }
                     }
                 }
                 case DdbForm.chart:
-                    return JSON.stringify(this.value, (key, value) => key === 'data' ? value.toString() : value, 4);
+                    return JSON.stringify(this.value, (key, value) => key === 'data' ? value.toString(options) : value, 4);
             }
             return String(this.value);
         })();
-        return `${colors ? blue(type) : type}(${this.name ? `'${this.name}', ` : ''}${data})\n`;
+        return `${options?.colors ? blue(type) : type}(${this.name ? `'${this.name}', ` : ''}${data})\n`;
     }
     inspect_type() {
         const tname = DdbType[this.type];
@@ -1138,28 +1164,15 @@ export class DdbObj {
         return values.map(value => this.to_ddbobj(value));
     }
     to_cols() {
-        return this.value.map(col => {
-            let col_ = {
-                title: col.name,
-                dataIndex: col.name,
-            };
-            switch (col.type) {
-                case DdbType.timestamp:
-                    col_.render = value => timestamp2str(value);
-                    break;
-                case DdbType.date:
-                    col_.render = value => date2str(value);
-                    break;
-                case DdbType.ipaddr:
-                    col_.render = value => ipaddr2str(value, this.le);
-                    break;
-            }
-            return col_;
-        });
+        assert(this.form === DdbForm.table, 'form must be DdbForm.table, otherwise it cannot to_cols');
+        return this.value.map(col => ({
+            title: col.name,
+            dataIndex: col.name,
+            render: (value) => format(col.type, value, col.le, { nullstr: false, quote: false })
+        }));
     }
     to_rows() {
-        if (this.form !== DdbForm.table)
-            throw new Error('this.form is not DdbForm.table, cannot call to_rows');
+        assert(this.form === DdbForm.table, 'form must be DdbForm.table, otherwise it cannot to_rows');
         let rows = new Array(this.rows);
         for (let i = 0; i < this.rows; i++) {
             let row = {};
@@ -1191,13 +1204,10 @@ export class DdbObj {
         return rows;
     }
     to_dict({ strip, deep, } = {}) {
-        if (this.form !== DdbForm.dict)
-            throw new Error('this.form is not DdbForm.dict and cannot be converted to js object');
+        assert(this.form === DdbForm.dict, 'this.form must be DdbForm.dict, otherwise to_dict cannot be called to convert to js object');
         const [{ value: keys, type: key_type }, { value: values, type: value_type }] = this.value;
-        if (key_type !== DdbType.string || value_type !== DdbType.any)
-            throw new Error('Not dict<string, any>, automatic conversion to js object is not supported for the time being');
-        if (deep && !strip)
-            throw new Error('strip = true must be set when deep = true');
+        assert(key_type === DdbType.string && value_type === DdbType.any, 'Currently only supports automatic conversion of dict<string, any> to js object');
+        assert(!(deep && !strip), 'strip = true must be set when deep = true');
         let obj = {};
         for (let i = 0; i < this.rows; i++) {
             let value = values[i];
@@ -1209,144 +1219,222 @@ export class DdbObj {
         return obj;
     }
 }
+/** Integer must use this number formatter, InspectOptions.decimals also use this if not passed */
+let default_formatter = Intl.NumberFormat('en-US', { maximumFractionDigits: 20 });
+let _decimals = 20;
+/** Cache, in order to optimize performance, usually options.decimals are unchanged */
+let _formatter = Intl.NumberFormat('en-US', { maximumFractionDigits: 20 });
 /** Formats a single element (value) as a string according to DdbType, null returns a 'null' string */
 export function format(type, value, le, options = {}) {
+    const { decimals, nullstr = false, colors = false, quote = false } = options;
+    const formatter = (() => {
+        if (decimals === undefined || decimals === null)
+            return default_formatter;
+        if (decimals !== _decimals) {
+            _decimals = decimals;
+            _formatter = Intl.NumberFormat('en-US', { maximumFractionDigits: decimals, minimumFractionDigits: decimals });
+        }
+        return _formatter;
+    })();
+    function get_nullstr() {
+        return nullstr ?
+            colors ? grey('null') : 'null'
+            :
+                '';
+    }
     switch (type) {
         case DdbType.bool:
-            return String((value === null || value === nulls.int8) ?
-                null
-                :
-                    Boolean(value));
+            if (value === null || value === nulls.int8)
+                return get_nullstr();
+            else {
+                const str = String(Boolean(value));
+                return colors ? blue(str) : str;
+            }
         case DdbType.char:
-            return String((value === null || value === nulls.int8) ?
-                null
-                :
-                    // ascii printable
-                    // http://facweb.cs.depaul.edu/sjost/it212/documents/ascii-pr.htm
-                    (32 <= value && value <= 126) ?
-                        String.fromCharCode(value).quote()
-                        :
-                            value);
+            if (value === null || value === nulls.int8)
+                return get_nullstr();
+            else {
+                let str = 
+                // ascii printable
+                // http://facweb.cs.depaul.edu/sjost/it212/documents/ascii-pr.htm
+                (32 <= value && value <= 126) ?
+                    String.fromCharCode(value)
+                    :
+                        '\\' + String(value);
+                if (quote)
+                    str = str.quote();
+                return colors ? green(str) : str;
+            }
         case DdbType.short:
-            return String((value === null || value === nulls.int16) ?
-                null
-                :
-                    value);
+            if (value === null || value === nulls.int16)
+                return get_nullstr();
+            else {
+                const str = default_formatter.format(value);
+                return colors ? green(str) : str;
+            }
         case DdbType.int:
-            return String((value === null || value === nulls.int32) ?
-                null
-                :
-                    value);
+            if (value === null || value === nulls.int32)
+                return get_nullstr();
+            else {
+                const str = default_formatter.format(value);
+                return colors ? green(str) : str;
+            }
         case DdbType.long:
-            return (value === null || value === nulls.int64) ?
-                'null'
-                :
-                    String(value);
+            if (value === null || value === nulls.int64)
+                return get_nullstr();
+            else {
+                const str = default_formatter.format(value);
+                return colors ? green(str) : str;
+            }
         case DdbType.date:
-            return (value === null || value === nulls.int32) ?
-                'null'
-                :
-                    date2str(value);
+            if (value === null || value === nulls.int16)
+                return get_nullstr();
+            else {
+                const str = date2str(value);
+                return colors ? magenta(str) : str;
+            }
         case DdbType.month:
-            return (value === null || value === nulls.int32) ?
-                'null'
-                :
-                    month2str(value);
+            if (value === null || value === nulls.int32)
+                return get_nullstr();
+            else {
+                const str = month2str(value);
+                return colors ? magenta(str) : str;
+            }
         case DdbType.time:
-            return (value === null || value === nulls.int32) ?
-                'null'
-                :
-                    time2str(value);
+            if (value === null || value === nulls.int32)
+                return get_nullstr();
+            else {
+                const str = time2str(value);
+                return colors ? magenta(str) : str;
+            }
         case DdbType.minute:
-            return (value === null || value === nulls.int32) ?
-                'null'
-                :
-                    minute2str(value);
+            if (value === null || value === nulls.int16)
+                return get_nullstr();
+            else {
+                const str = minute2str(value);
+                return colors ? magenta(str) : str;
+            }
         case DdbType.second:
-            return (value === null || value === nulls.int32) ?
-                'null'
-                :
-                    second2str(value);
+            if (value === null || value === nulls.int32)
+                return get_nullstr();
+            else {
+                const str = second2str(value);
+                return colors ? magenta(str) : str;
+            }
         case DdbType.datetime:
-            return (value === null || value === nulls.int32) ?
-                'null'
-                :
-                    datetime2str(value);
+            if (value === null || value === nulls.int32)
+                return get_nullstr();
+            else {
+                const str = datetime2str(value);
+                return colors ? magenta(str) : str;
+            }
         case DdbType.timestamp:
-            return (value === null || value === nulls.int64) ?
-                'null'
-                :
-                    timestamp2str(value);
+            if (value === null || value === nulls.int64)
+                return get_nullstr();
+            else {
+                const str = timestamp2str(value);
+                return colors ? magenta(str) : str;
+            }
         case DdbType.nanotime:
-            return (value === null || value === nulls.int64) ?
-                'null'
-                :
-                    nanotime2str(value);
+            if (value === null || value === nulls.int64)
+                return get_nullstr();
+            else {
+                const str = nanotime2str(value);
+                return colors ? magenta(str) : str;
+            }
         case DdbType.nanotimestamp:
-            return (value === null || value === nulls.int64) ?
-                'null'
-                :
-                    nanotimestamp2str(value);
+            if (value === null || value === nulls.int64)
+                return get_nullstr();
+            else {
+                const str = nanotimestamp2str(value);
+                return colors ? magenta(str) : str;
+            }
         case DdbType.float:
-            return (value === null || value === nulls.float32) ?
-                'null'
-                :
-                    String(value);
+            if (value === null || value === nulls.float32)
+                return get_nullstr();
+            else {
+                const str = formatter.format(value);
+                return colors ? green(str) : str;
+            }
         case DdbType.double:
-            return (value === null || value === nulls.double) ?
-                'null'
-                :
-                    String(value);
+            if (value === null || value === nulls.double)
+                return get_nullstr();
+            else {
+                const str = formatter.format(value);
+                return colors ? green(str) : str;
+            }
         case DdbType.symbol:
-        case DdbType.string:
-            return value.quote('single');
-        case DdbType.uuid:
-            return uuid2str(value, le);
-        case DdbType.functiondef:
-            return value.name.quote('single');
+        case DdbType.string: {
+            let str = value;
+            if (quote)
+                str = str.quote('single');
+            return colors ? cyan(str) : str;
+        }
+        case DdbType.uuid: {
+            const str = uuid2str(value, le);
+            return colors ? cyan(str) : str;
+        }
+        case DdbType.functiondef: {
+            const str = value.name.quote('single');
+            return colors ? cyan(str) : str;
+        }
         case DdbType.handle:
         case DdbType.code:
-        case DdbType.resource:
-            return value.quote('single');
+        case DdbType.resource: {
+            const str = value.quote('single');
+            return colors ? cyan(str) : str;
+        }
         case DdbType.datehour:
-            return (value === null || value === nulls.int32) ?
-                'null'
-                :
-                    datehour2str(value);
-        case DdbType.ipaddr:
-            return ipaddr2str(value, le);
-        case DdbType.int128:
-            return int1282str(value, le);
-        case DdbType.blob:
-            return (value.length > 100 ?
+            if (value === null || value === nulls.int32)
+                return get_nullstr();
+            else {
+                const str = datehour2str(value);
+                return colors ? magenta(str) : str;
+            }
+        case DdbType.ipaddr: {
+            const str = ipaddr2str(value, le);
+            return colors ? cyan(str) : str;
+        }
+        case DdbType.int128: {
+            const str = int1282str(value, le);
+            return colors ? cyan(str) : str;
+        }
+        case DdbType.blob: {
+            const str = value.length > 100 ?
                 DdbObj.dec.decode(value.subarray(0, 98)) + '…'
                 :
-                    DdbObj.dec.decode(value)).quote('single');
+                    DdbObj.dec.decode(value);
+            return colors ? cyan(str) : str;
+        }
         case DdbType.point: {
-            let [x, y] = value;
-            if (x === nulls.double)
-                x = null;
-            if (y === nulls.double)
-                y = null;
-            return `(${String(x)}, ${String(y)})`;
+            const [x, y] = value;
+            return `(${format(DdbType.double, x, le, options)}, ${format(DdbType.double, y, le, options)})`;
         }
         case DdbType.complex: {
-            let [x, y] = value;
-            if (x === nulls.double)
-                x = null;
-            if (y === nulls.double)
-                y = null;
-            return `${String(x)}+${String(y)}i`;
+            const [x, y] = value;
+            return `${format(DdbType.double, x, le, options)}+${format(DdbType.double, y, le, options)}i`;
         }
         case DdbType.duration: {
             const { data, unit } = value;
-            return `${data}${DdbDurationUnit[unit]}`;
+            const str = `${data}${DdbDurationUnit[unit]}`;
+            return colors ? magenta(str) : str;
+        }
+        case DdbType.decimal32:
+        case DdbType.decimal64: {
+            const { scale, data } = value;
+            if (data === null ||
+                (data === nulls.int64 && type === DdbType.decimal64) ||
+                (data === nulls.int32 && type === DdbType.decimal32))
+                return get_nullstr();
+            const s = String(data < 0 ? -data : data).padStart(scale, '0');
+            const str = (data < 0 ? '-' : '') + (scale ? `${s.slice(0, -scale) || '0'}.${s.slice(-scale)}` : s);
+            return colors ? green(str) : str;
         }
         default:
             return String(value);
     }
 }
-/** Format vector, the index-th item in the collection is a string, a null value returns a 'null' string */
+/** formatted vector, the index-th item in the collection is a string */
 export function formati(obj, index, options = {}) {
     if (64 <= obj.type && obj.type < 128) { // array vector
         // 因为 array vector 目前只支持：Logical, Integral（不包括 INT128, COMPRESS 类型）, Floating, Temporal
@@ -1381,12 +1469,9 @@ export function formati(obj, index, options = {}) {
         }
     }
     switch (obj.type) {
-        case DdbType.string:
-        case DdbType.symbol:
-            return obj.value[index];
         case DdbType.symbol_extended: {
             const { base, data } = obj.value;
-            return base[data[index]];
+            return format(DdbType.string, base[data[index]], obj.le, options);
         }
         case DdbType.uuid:
         case DdbType.int128:
@@ -1402,6 +1487,17 @@ export function formati(obj, index, options = {}) {
         case DdbType.complex:
         case DdbType.point:
             return format(obj.type, obj.value.subarray(2 * index, 2 * (index + 1)), obj.le, options);
+        case DdbType.decimal32:
+        case DdbType.decimal64: {
+            const { scale, data } = obj.value;
+            const x = data[index];
+            if (x === nulls.int64 && obj.type === DdbType.decimal64 ||
+                x === nulls.int32 && obj.type === DdbType.decimal32)
+                return '';
+            const s = String(x < 0 ? -x : x).padStart(scale, '0');
+            const str = (x < 0 ? '-' : '') + (scale ? `${s.slice(0, -scale) || '0'}.${s.slice(-scale)}` : s);
+            return options.colors ? green(str) : str;
+        }
         default:
             return format(obj.type, obj.value[index], obj.le, options);
     }
@@ -1816,8 +1912,7 @@ export function datehour2str(datehour, format = 'YYYY.MM.DDTHH') {
 export function str2timestamp(str, format = 'YYYY.MM.DD HH:mm:ss.SSS') {
     if (!str || str === 'null')
         return nulls.int64;
-    if (str.length !== format.length)
-        throw new Error('The length of the timestamp string is not equal to the length of the format string');
+    assert('The length of the timestamp string must be equal to the length of the format string');
     return BigInt(-timezone_offset +
         dayjs(str, format).valueOf());
 }
@@ -1830,12 +1925,10 @@ export function nanotime2str(nanotime, format = 'HH:mm:ss.SSSSSSSSS') {
     if (nanotime < 0n)
         return String(nanotime);
     const i_second_start = format.indexOf('ss');
-    if (i_second_start === -1)
-        throw new Error('格式串必须包含秒的格式 (ss)');
+    assert(i_second_start !== -1, 'The format string must contain the format for seconds (ss)');
     const i_second_end = i_second_start + 2;
     const i_nanosecond_start = format.indexOf('SSSSSSSSS', i_second_end);
-    if (i_nanosecond_start === -1)
-        throw new Error('格式串必须包含纳秒的格式 (SSSSSSSSS)');
+    assert(i_nanosecond_start !== -1, 'Format string must contain nanosecond format (SSSSSSSSS)');
     return (dayjs(timezone_offset + (Number(nanotime) / 1000000)).format(format.slice(0, i_second_end)) +
         format.slice(i_second_end, i_nanosecond_start) +
         String(nanotime % 1000000000n).padStart(9, '0'));
@@ -1863,12 +1956,10 @@ export function nanotimestamp2str(nanotimestamp, format = 'YYYY.MM.DD HH:mm:ss.S
     if (nanotimestamp === null || nanotimestamp === nulls.int64)
         return 'null';
     const i_second_start = format.indexOf('ss');
-    if (i_second_start === -1)
-        throw new Error('The format string must contain the format for seconds (ss)');
+    assert(i_second_start !== -1, 'The format string must contain the format for seconds (ss)');
     const i_second_end = i_second_start + 2;
     const i_nanosecond_start = format.indexOf('SSSSSSSSS', i_second_end);
-    if (i_nanosecond_start === -1)
-        throw new Error('The format string must contain the format for nanoseconds (SSSSSSSSS)');
+    assert(i_nanosecond_start !== -1, 'Format string must contain nanosecond format (SSSSSSSSS)');
     const remainder = nanotimestamp % 1000000000n;
     const borrow = remainder < 0n;
     return (dayjs(timezone_offset +
@@ -1890,15 +1981,12 @@ export function nanotimestamp2str(nanotimestamp, format = 'YYYY.MM.DD HH:mm:ss.S
 export function str2nanotimestamp(str, format = 'YYYY.MM.DD HH:mm:ss.SSSSSSSSS') {
     if (!str || str === 'null')
         return nulls.int64;
-    if (str.length !== format.length)
-        throw new Error('nanotimestamp string length is not equal to format string length');
+    assert(str.length === format.length, 'nanotimestamp string length must be equal to format string length');
     const i_second_start = format.indexOf('ss');
-    if (i_second_start === -1)
-        throw new Error('The format string must contain the format for seconds (ss)');
+    assert(i_second_start !== -1, 'The format string must contain the format for seconds (ss)');
     const i_second_end = i_second_start + 2;
     const i_nanosecond_start = format.indexOf('SSSSSSSSS', i_second_end);
-    if (i_nanosecond_start === -1)
-        throw new Error('Format string must contain nanosecond format (SSSSSSSSS)');
+    assert(i_nanosecond_start !== -1, 'Format string must contain nanosecond format (SSSSSSSSS)');
     return (BigInt(-timezone_offset +
         dayjs(str.slice(0, i_second_end), format.slice(0, i_second_end)).valueOf()) * 1000000n
         +
@@ -1926,6 +2014,14 @@ export function int1282str(buffer, le = true) {
     return [...buf].map(x => x.toString(16)
         .padStart(2, '0')).join('');
 }
+export const winsize = 40;
+export class ConnectionError extends Error {
+    ddb;
+    constructor(ddb) {
+        super(`websocket is disconnected: ${ddb.url}`);
+        this.ddb = ddb;
+    }
+}
 export class DDB {
     /** 当前的 session id (http 或 tcp) */
     sid = '0';
@@ -1949,7 +2045,9 @@ export class DDB {
     password = '123456';
     /** python session flag (2048) */
     python = false;
-    // 内部选项, 状态
+    /** Whether it is a streaming data connection, this field is always null for non-streaming data */
+    streaming = null;
+    // --- 内部选项, 状态
     print_message_buffer = false;
     print_object_buffer = false;
     print_message = true;
@@ -1972,6 +2070,7 @@ export class DDB {
             - username?: DolphinDB username, default `'admin'`
             - password?: DolphinDB password, default `'123456'`
             - python?: set python session flag, default `false`
+            - streaming?: When this option is set, the WebSocket connection is only used for streaming data
         
         @example
         let ddb = new DDB('ws://127.0.0.1:8848')
@@ -1989,7 +2088,7 @@ export class DDB {
             const _url = new URL(location.href);
             const hostname = _url.searchParams.get('hostname') || location.hostname;
             const port = _url.searchParams.get('port') || location.port;
-            url = `${location.protocol === 'https:' ? 'wss' : 'ws'}://${hostname}${port ? `:${port}` : ''}/`;
+            url = `${location.protocol === 'https:' ? 'wss' : 'ws'}://${hostname}:${port}/`;
         }
         this.url = url;
         if (options.autologin !== undefined)
@@ -2000,43 +2099,54 @@ export class DDB {
             this.password = options.password;
         if (options.python !== undefined)
             this.python = options.python;
+        if (options.streaming !== undefined)
+            this.streaming = options.streaming;
     }
-    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
-            - autologin?: Whether to log in automatically after establishing a connection, default `true`
-            - username?: DolphinDB username, default `'admin'`
-            - password?: DolphinDB password, default `'123456'`
-            - python?: set python session flag, default `false`
-    */
-    async connect(options = {}) {
-        if (options.url !== undefined)
-            this.url = options.url;
-        if (options.autologin !== undefined)
-            this.autologin = options.autologin;
-        if (options.username !== undefined)
-            this.username = options.username;
-        if (options.password !== undefined)
-            this.password = options.password;
-        if (options.python !== undefined)
-            this.python = options.python;
-        this.disconnect();
-        await connect_websocket(this.url, {
-            protocols: this.python ? ['python'] : [],
-            on_open: async (event, websocket) => {
-                this.websocket = websocket;
-                await this.rpc('connect', {});
-            },
-            on_message: (event) => {
-                this.on_message(event);
-            }
+    on_message(event) {
+        // 这里的实现一定会被 connect 中的实现覆盖
+    }
+    /** Establish a actual websocket connection to the DolphindB corresponding to the URL
+        After calling, it will ensure that it has been connected to the database (ensure that websocket.ReadyState is open), otherwise an error will be reported
+        this.autologin automatically log in when it is true */
+    async connect() {
+        if (this.connected)
+            return;
+        const ptail = this.pconnect;
+        let resolve;
+        this.pconnect = new Promise((_resolve, _reject) => {
+            resolve = _resolve;
         });
-        if (this.autologin)
-            if (this.python)
-                await this.eval(`login(${this.username.quote('double')}, ${this.password.quote('double')})`, { urgent: true });
-            else
-                await this.call('login', [this.username, this.password], { urgent: true });
+        await ptail;
+        try {
+            if (!this.connected) {
+                this.on_message = (event) => {
+                    assert(false, 'This is the default on_message before calling this.rpc, and it should not be called. Unless the server pushed message first after the connection is established');
+                };
+                this.presult = Promise.resolve(null);
+                this.pnode_run_defined = false;
+                this.websocket = await connect_websocket(this.url, {
+                    protocols: (() => {
+                        if (this.streaming)
+                            return 'streaming';
+                        if (this.python)
+                            return 'python';
+                    })(),
+                    on_message: (event) => {
+                        this.on_message(event);
+                    }
+                });
+                if (this.streaming)
+                    await this.subscribe();
+                else {
+                    await this.rpc('connect', {});
+                    if (this.autologin)
+                        await this.call('login', [this.username, this.password], { urgent: true });
+                }
+            }
+        }
+        finally {
+            resolve();
+        }
     }
     get_rpc_options({ urgent = false, secondary = false, async: _async = false, pickle = false, clear = false, api = false, compress = false, cancellable = true, priority = urgent ? 8 : 4, parallelism = 8, root_id = '', limit, } = {}) {
         let flag = 0;
@@ -2072,12 +2182,9 @@ export class DDB {
     disconnect() {
         if (this.connected)
             this.websocket.close(1000);
-        this.on_message = () => { };
-        this.presult = Promise.resolve(null);
-        this.pconnect = Promise.resolve();
-        this.pnode_run_defined = false;
     }
     /** rpc through websocket (function/script/variable command)
+        When the DDB is not connected, the call will be automatically connected. When the connection is disconnected, the call will throw the Connectionerror
         - type: API 类型: 'script' | 'function' | 'variable'
         - options:
             - urgent?: 决定 `行为标识` 那一行字符串的取值（只适用于 script 和 function）
@@ -2087,24 +2194,12 @@ export class DDB {
                 为 false 时返回的 DdbObj 仅含有 buffer 和 le，不做解析，以便后续转发、序列化
     */
     async rpc(type, { script, func, args = [], vars = [], urgent, listener, parse_object, }) {
-        if (!this.websocket) {
-            const ptail = this.pconnect;
-            let resolve;
-            this.pconnect = new Promise((_resolve, _reject) => {
-                resolve = _resolve;
-            });
-            await ptail;
-            try {
-                if (!this.websocket)
-                    await this.connect();
-            }
-            finally {
-                resolve();
-            }
-        }
+        if (!this.websocket)
+            await this.connect();
         if (!this.connected)
-            throw new Error(`${this.url} is already disconnected`);
+            throw new ConnectionError(this);
         if (func === 'pnode_run' && !this.pnode_run_defined) {
+            // 保证并发调用 rpc 时只定义一次 pnode_run
             const ptail = this.ppnoderun;
             let resolve;
             this.ppnoderun = new Promise((_resolve, _reject) => {
@@ -2254,8 +2349,7 @@ export class DDB {
     */
     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');
+            assert(func_type in DdbFunctionType, 'func_type must be set when specifying node');
             args = [
                 node,
                 new DdbFunction(func, func_type),
@@ -2292,10 +2386,21 @@ export class DDB {
     vars, 
     /** Uploaded variables' value */
     args, { listener, parse_object, } = {}) {
-        if (!args.length || args.length !== vars.length)
-            throw new Error('variable 指令参数为空或参数名为空，或数量不匹配');
+        assert(args.length && args.length === vars.length, 'variable command parameter cannot be empty and parameter name cannot be empty, and the number should match');
         return this.rpc('variable', { vars, args, listener, parse_object });
     }
+    /** Cancel all console jobs corresponding to the current session id */
+    async cancel() {
+        let ddb = new DDB(this.url, this);
+        try {
+            await ddb.eval(`jobs = exec rootJobId from getConsoleJobs() where sessionId = ${this.sid}\n` +
+                'if (size(jobs))\n' +
+                '    cancelConsoleJob(jobs)\n', { urgent: true });
+        }
+        finally {
+            ddb.disconnect();
+        }
+    }
     /** 解析服务端响应报文，返回去掉 header 的 data buf */
     parse_message(buf, parse_object = this.parse_object) {
         // MSG\n
@@ -2310,8 +2415,8 @@ export class DDB {
         // 'OK\n'
         // '\x04\x00\x02\x00\x00\x00'
         /** index of line feed 0 */
-        const i_lf_0 = buf.indexOf(0x0a); // '\n'
-        const parts = this.dec.decode(buf.subarray(0, i_lf_0)).split(' ');
+        const ilf0 = buf.indexOf(0x0a); // '\n'
+        const parts = this.dec.decode(buf.subarray(0, ilf0)).split(' ');
         /** session id */
         const sid = parts[0];
         if (sid !== this.sid) {
@@ -2319,35 +2424,142 @@ export class DDB {
             this.sid = sid;
         }
         /** 返回对象的数量 */
-        const n_obj = Number(parts[1]);
+        const nobj = Number(parts[1]);
         /** 大小端: 协议中大端为 0, 小端为 1 */
         this.le = Number(parts[2]) !== 0;
-        const i_ls_1 = i_lf_0 + 1;
-        const i_lf_1 = buf.indexOf(0x0a, i_ls_1); // '\n'
+        const ils1 = ilf0 + 1;
+        const ilf1 = buf.indexOf(0x0a, ils1); // '\n'
         /** 'OK' 表示成功，其它文本表示失败 */
-        const message = this.dec.decode(buf.subarray(i_ls_1, i_lf_1));
+        const message = this.dec.decode(buf.subarray(ils1, ilf1));
         if (message !== 'OK')
             return {
                 type: 'error',
                 data: new Error(message)
             };
-        const buf_obj = buf.subarray(i_lf_1 + 1);
+        const bufobj = buf.subarray(ilf1 + 1);
         if (this.print_object_buffer)
-            console.log(buf_obj);
+            console.log(bufobj);
         return {
             type: 'object',
             data: parse_object ?
-                DdbObj.parse(buf_obj, this.le)
+                DdbObj.parse(bufobj, this.le)
                 :
                     new DdbObj({
                         form: DdbForm.scalar,
                         type: DdbType.void,
                         length: 0,
                         le: this.le,
-                        buffer: buf_obj,
+                        buffer: bufobj,
                     })
         };
     }
+    /** Internal stream subscription method */
+    async subscribe() {
+        const args = DdbObj.to_ddbobjs([
+            new DdbVectorString(this.autologin ?
+                [this.username, this.password]
+                :
+                    // 不自动登录也要传空的 string vector, 否则 server 无法解析
+                    []),
+            // todo: 还有用吗？需要获取客户端 IP 吗
+            'localhost',
+            // todo: 端口还有用吗？
+            new DdbInt(0),
+            this.streaming.table,
+            (this.streaming.action ||= `api_js_${new Date().getTime()}`),
+            // new DdbInt(-1),  // offset
+            // filter
+            // allow exists
+        ]);
+        return new Promise((resolve, reject) => {
+            let first = true;
+            let second = true;
+            // 先准备好收到 websocket message 的 callback
+            this.on_message = ({ data: buffer }) => {
+                if (first) {
+                    first = false;
+                    try {
+                        const dv = new DataView(buffer);
+                        const status = dv.getUint8(1);
+                        this.le = Boolean(dv.getUint8(2));
+                        const nobjs = dv.getUint32(3, this.le);
+                        // 解析返回数据，从 server 实现看其实只有一个 DdbObj
+                        let offset = 7;
+                        let objs = new Array(nobjs);
+                        const buf = new Uint8Array(buffer);
+                        for (let i = 0; i < nobjs; i++) {
+                            const obj = DdbObj.parse(buf.subarray(offset), this.le);
+                            offset += obj.length;
+                            objs[i] = obj;
+                            console.log(`订阅流表的响应数据: objs[${i}]: ${obj.toString()}`);
+                        }
+                        this.streaming.colnames = objs[0].value;
+                        if (status === StreamingStatusCode.ok)
+                            console.log('Subscribed to streaming table:', { status: StreamingStatusCode[status], result: objs[0] });
+                        else
+                            reject(new Error(`Failed to subscribe to streaming table: { status: ${StreamingStatusCode[status]}, error: '${objs[0]?.value}' }`));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }
+                else {
+                    try {
+                        const dv = new DataView(buffer);
+                        const buf = new Uint8Array(buffer);
+                        let { streaming } = this;
+                        streaming.time = dv.getBigInt64(1, this.le);
+                        streaming.id = dv.getBigInt64(9, this.le);
+                        const i_topic_end = buf.indexOf(0, 17);
+                        streaming.topic = this.dec.decode(buf.subarray(17, i_topic_end));
+                        if (second) {
+                            second = false;
+                            // 是 table
+                            streaming.schema = DdbObj.parse(buf.subarray(i_topic_end + 1), this.le);
+                            console.log('Received streaming table schema:', streaming.schema);
+                            streaming.window = {
+                                offset: 0,
+                                rows: 0,
+                                segments: [],
+                            };
+                            assert(streaming.schema.rows === 0, 'schema.rows === 0');
+                            resolve(streaming.schema);
+                        }
+                        else {
+                            // 是 column 片段组成的 any vector
+                            const data = streaming.data = DdbObj.parse(buf.subarray(i_topic_end + 1), this.le);
+                            let { window: win } = streaming;
+                            win.rows += data.value[0].rows;
+                            win.segments.push(data);
+                            if (win.rows >= winsize * 2 && win.segments.length >= 2) {
+                                let winsize_ = 0;
+                                let i = win.segments.length - 1;
+                                // 往前移动至首个累计 winsize_ 超过 winsize 的位置
+                                for (; winsize_ < winsize; i--)
+                                    winsize_ += win.segments[i].rows;
+                                win.segments = win.segments.slice(i);
+                                win.offset += win.rows - winsize_;
+                                win.rows = winsize_;
+                                console.log('exceeds winsize, shrink window.segments', win);
+                            }
+                            streaming.handler(streaming);
+                        }
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }
+            };
+            // 发送订阅 websocket message
+            this.websocket.send(concat([
+                Uint8Array.of(1, // from = SubscriberFromType::FROM_API
+                1, // type = SubscriberRPCType::RPC_START
+                Number(DDB.le_client)),
+                Uint32Array.of(args.length),
+                ...args.map(obj => obj.pack())
+            ]));
+        });
+    }
 }
 export let ddb = window.ddb = new DDB();
 //# sourceMappingURL=browser.js.map