dolphindb 2.0.603 → 2.0.801

package/index.js

@@ -4,8 +4,8 @@ import DayjsCustomParseFormat from 'dayjs/plugin/customParseFormat.js';
 dayjs.extend(DayjsCustomParseFormat);
 import ipaddrjs from 'ipaddr.js';
 const { fromByteArray: buf2ipaddr } = ipaddrjs;
+import { concat, assert, inspect, typed_array_to_buffer } from 'xshell/utils.js';
 import { connect_websocket } from 'xshell/net.js';
-import { concat, inspect, typed_array_to_buffer } from 'xshell/utils.js';
 export var DdbForm;
 (function (DdbForm) {
     DdbForm[DdbForm["scalar"] = 0] = "scalar";
@@ -62,7 +62,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;
@@ -114,7 +118,15 @@ export const nulls = {
     bytes16: Uint8Array.from(new Array(16).fill(0))
 };
 export const timezone_offset = 1000 * 60 * new Date().getTimezoneOffset();
-/** 可以表示所有 DolphinDB 数据库中的数据类型 */
+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 = {}));
+/** Can represent data types in all DolphinDB databases */
 export class DdbObj {
     static dec = new TextDecoder('utf-8');
     static enc = new TextEncoder();
@@ -146,7 +158,7 @@ export class DdbObj {
     rows;
     /** 第 2 维 */
     cols;
-    /** 实际数据。不同的 DdbForm, DdbType 使用 DdbValue 中不同的类型来表示实际数据 */
+    /** The actual data. Different DdbForm, DdbType use different types in DdbValue to represent actual data */
     value;
     /** 原始二进制数据，仅在 parse_object 为 false 时通过 parse_message 生成的顶层对象有这个属性 */
     buffer;
@@ -331,8 +343,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
@@ -443,38 +454,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} 暂时不支持解析`);
@@ -635,7 +638,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;
@@ -670,7 +673,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);
@@ -710,6 +713,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
@@ -813,10 +841,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)];
@@ -824,8 +849,16 @@ 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} 暂时不支持序列化`);
+                            throw new Error(`${DdbType[type] || type} serialization is not currently supported`);
                     }
                 case DdbForm.vector:
                 case DdbForm.pair:
@@ -845,12 +878,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),
@@ -862,43 +890,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),
@@ -907,7 +919,7 @@ export class DdbObj {
                     ];
                 }
                 default:
-                    throw new Error(`${DdbForm[form]} 暂不支持序列化`);
+                    throw new Error(`${DdbForm[form]} serialization is not currently supported`);
             }
         })();
         if (!body)
@@ -996,11 +1008,17 @@ 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]} 暂不支持序列化`);
         }
     }
-    [inspect.custom](depth, options, _inspect) {
+    [inspect.custom](depth, _options, _inspect) {
+        const options = { nullstr: true, quote: true, ..._options };
         const type = this.inspect_type();
         const data = (() => {
             switch (this.form) {
@@ -1075,6 +1093,15 @@ export class DdbObj {
                                 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));
@@ -1137,8 +1164,7 @@ export class DdbObj {
         return values.map(value => this.to_ddbobj(value));
     }
     to_rows() {
-        if (this.form !== DdbForm.table)
-            throw new Error('this.form is not DdbForm.table, cannot 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 = {};
@@ -1170,13 +1196,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];
@@ -1188,8 +1211,23 @@ export class DdbObj {
         return obj;
     }
 }
+/** 整数一定用这个 number formatter, InspectOptions.decimals 不传也用这个 */
+let default_formatter = Intl.NumberFormat('en-US', { maximumFractionDigits: 20 });
+let _decimals = 20;
+/** 缓存，为了优化性能，通常 options.decimals 都是不变的 */
+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) {
+export function format(type, value, le, options = {}) {
+    const { decimals } = 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;
+    })();
     switch (type) {
         case DdbType.bool:
             return inspect((value === null || value === nulls.int8) ?
@@ -1207,111 +1245,123 @@ export function format(type, value, le, options) {
                         :
                             value, options);
         case DdbType.short:
-            return inspect((value === null || value === nulls.int16) ?
-                null
+            return value === null || value === nulls.int16 ?
+                inspect(null, options)
                 :
-                    value, options);
+                    options.colors ?
+                        default_formatter.format(value).green
+                        :
+                            default_formatter.format(value);
         case DdbType.int:
-            return inspect((value === null || value === nulls.int32) ?
-                null
+            return value === null || value === nulls.int32 ?
+                inspect(null, options)
                 :
-                    value, options);
+                    options.colors ?
+                        default_formatter.format(value).green
+                        :
+                            default_formatter.format(value);
         case DdbType.long:
-            return (value === null || value === nulls.int64) ?
-                'null'
+            return value === null || value === nulls.int64 ?
+                inspect(null, options)
                 :
                     options.colors ?
-                        String(value).green
+                        default_formatter.format(value).green
                         :
-                            String(value);
+                            default_formatter.format(value);
         case DdbType.date:
             return (value === null || value === nulls.int32) ?
-                'null'
+                inspect(null, options)
                 :
                     options.colors ?
-                        date2str(value).green
+                        date2str(value).magenta
                         :
                             date2str(value);
         case DdbType.month:
             return (value === null || value === nulls.int32) ?
-                'null'
+                inspect(null, options)
                 :
                     options.colors ?
-                        month2str(value).green
+                        month2str(value).magenta
                         :
                             month2str(value);
         case DdbType.time:
             return (value === null || value === nulls.int32) ?
-                'null'
+                inspect(null, options)
                 :
                     options.colors ?
-                        time2str(value).green
+                        time2str(value).magenta
                         :
                             time2str(value);
         case DdbType.minute:
             return (value === null || value === nulls.int32) ?
-                'null'
+                inspect(null, options)
                 :
                     options.colors ?
-                        minute2str(value).green
+                        minute2str(value).magenta
                         :
                             minute2str(value);
         case DdbType.second:
             return (value === null || value === nulls.int32) ?
-                'null'
+                inspect(null, options)
                 :
                     options.colors ?
-                        second2str(value).green
+                        second2str(value).magenta
                         :
                             second2str(value);
         case DdbType.datetime:
             return (value === null || value === nulls.int32) ?
-                'null'
+                inspect(null, options)
                 :
                     options.colors ?
-                        datetime2str(value).green
+                        datetime2str(value).magenta
                         :
                             datetime2str(value);
         case DdbType.timestamp:
             return (value === null || value === nulls.int64) ?
-                'null'
+                inspect(null, options)
                 :
                     options.colors ?
-                        timestamp2str(value).green
+                        timestamp2str(value).magenta
                         :
                             timestamp2str(value);
         case DdbType.nanotime:
             return (value === null || value === nulls.int64) ?
-                'null'
+                inspect(null, options)
                 :
                     options.colors ?
-                        nanotime2str(value).green
+                        nanotime2str(value).magenta
                         :
                             nanotime2str(value);
         case DdbType.nanotimestamp:
             return (value === null || value === nulls.int64) ?
-                'null'
+                inspect(null, options)
                 :
                     options.colors ?
-                        nanotimestamp2str(value).green
+                        nanotimestamp2str(value).magenta
                         :
                             nanotimestamp2str(value);
         case DdbType.float:
             return (value === null || value === nulls.float32) ?
-                'null'
+                inspect(null, options)
                 :
-                    inspect(value, options);
+                    options.colors ?
+                        formatter.format(value).green
+                        :
+                            formatter.format(value);
         case DdbType.double:
             return (value === null || value === nulls.double) ?
-                'null'
+                inspect(null, options)
                 :
-                    inspect(value, options);
+                    options.colors ?
+                        formatter.format(value).green
+                        :
+                            formatter.format(value);
         case DdbType.symbol:
         case DdbType.string:
             return inspect(value, options);
         case DdbType.uuid:
             return options.colors ?
-                uuid2str(value, le).green
+                uuid2str(value, le).cyan
                 :
                     uuid2str(value, le);
         case DdbType.functiondef:
@@ -1325,12 +1375,12 @@ export function format(type, value, le, options) {
                 'null'
                 :
                     options.colors ?
-                        datehour2str(value).green
+                        datehour2str(value).magenta
                         :
                             datehour2str(value);
         case DdbType.ipaddr:
             return options.colors ?
-                ipaddr2str(value, le).green
+                ipaddr2str(value, le).cyan
                 :
                     ipaddr2str(value, le);
         case DdbType.int128:
@@ -1344,30 +1394,27 @@ export function format(type, value, le, options) {
                 :
                     DdbObj.dec.decode(value), options);
         case DdbType.point: {
-            let [x, y] = value;
-            if (x === nulls.double)
-                x = null;
-            if (y === nulls.double)
-                y = null;
-            return options.colors ?
-                `(${String(x).green}, ${String(y).green})`
-                :
-                    `(${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 options.colors ?
-                `${String(x).green}+${`${String(y)}i`.green}`
-                :
-                    `${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;
             const str = `${data}${DdbDurationUnit[unit]}`;
+            return options.colors ? str.magenta : 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 'null';
+            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 options.colors ? str.green : str;
         }
         default:
@@ -1375,7 +1422,7 @@ export function format(type, value, le, options) {
     }
 }
 /** formatted vector, the index-th item in the collection is a string, a null value returns a 'null' string */
-export function formati(obj, index, options) {
+export function formati(obj, index, options = {}) {
     if (64 <= obj.type && obj.type < 128) { // array vector
         // 因为 array vector 目前只支持：Logical, Integral（不包括 INT128, COMPRESS 类型）, Floating, Temporal
         // 都对应 TypedArray 中的一格，所以 lengths.length 等于 block 中的 row 的个数
@@ -1409,12 +1456,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:
@@ -1430,6 +1474,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 ? str.green : str;
+        }
         default:
             return format(obj.type, obj.value[index], obj.le, options);
     }
@@ -1844,8 +1899,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());
 }
@@ -1858,12 +1912,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('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)');
     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'));
@@ -1891,12 +1943,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 +
@@ -1918,15 +1968,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
         +
@@ -1954,6 +2001,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';
@@ -1977,6 +2032,8 @@ 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;
@@ -2000,11 +2057,12 @@ 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')
         
-        // 使用 HTTPS 加密
+        // Encrypt with HTTPS
         let ddbsecure = new DDB('wss://dolphindb.com', {
             autologin: true,
             username: 'admin',
@@ -2022,43 +2080,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
+        It is a power, and 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.rpc 之前默认的 on_message, 不应该被调用到，除非建立连接后 server 先推送了 message');
+                };
+                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;
@@ -2094,11 +2163,9 @@ export class DDB {
     disconnect() {
         if (this.connected)
             this.websocket.close(1000);
-        this.on_message = () => { };
-        this.presult = Promise.resolve(null);
-        this.pconnect = Promise.resolve();
     }
     /** 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）
@@ -2108,24 +2175,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) => {
@@ -2275,8 +2330,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),
@@ -2313,10 +2367,21 @@ export class DDB {
     vars, 
     /** Uploaded variables' value */
     args, { listener, parse_object, } = {}) {
-        if (!args.length || args.length !== vars.length)
-            throw new Error('variable command parameter is empty or parameter name is empty, or the number does not match');
+        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
@@ -2331,8 +2396,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) {
@@ -2340,34 +2405,141 @@ 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(typed_array_to_buffer(buf_obj));
+            console.log(typed_array_to_buffer(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);
+                        }
+                        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())
+            ]));
+        });
+    }
 }
 //# sourceMappingURL=index.js.map