dolphindb 2.0.603 → 2.0.800

package/browser.js

@@ -5,7 +5,7 @@ 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 { 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) {
         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,31 @@ export class DdbObj {
         return values.map(value => this.to_ddbobj(value));
     }
     to_cols() {
+        assert(this.form === DdbForm.table, 'form must be DdbForm.table, otherwise it cannot to_cols');
         return this.value.map(col => {
             let col_ = {
                 title: col.name,
                 dataIndex: col.name,
             };
             switch (col.type) {
+                case DdbType.char:
+                    col_.render = (value) => format(DdbType.char, value, this.le);
+                    break;
                 case DdbType.timestamp:
-                    col_.render = value => timestamp2str(value);
+                    col_.render = (value) => timestamp2str(value);
                     break;
                 case DdbType.date:
-                    col_.render = value => date2str(value);
+                    col_.render = (value) => date2str(value);
                     break;
                 case DdbType.ipaddr:
-                    col_.render = value => ipaddr2str(value, this.le);
+                    col_.render = (value) => ipaddr2str(value, this.le);
                     break;
             }
             return col_;
         });
     }
     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 +1220,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,8 +1235,23 @@ 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 formatter = (() => {
+        const { decimals } = options;
+        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 String((value === null || value === nulls.int8) ?
@@ -1228,20 +1269,20 @@ export function format(type, value, le, options = {}) {
                         :
                             value);
         case DdbType.short:
-            return String((value === null || value === nulls.int16) ?
-                null
+            return (value === null || value === nulls.int16) ?
+                'null'
                 :
-                    value);
+                    default_formatter.format(value);
         case DdbType.int:
-            return String((value === null || value === nulls.int32) ?
-                null
+            return (value === null || value === nulls.int32) ?
+                'null'
                 :
-                    value);
+                    default_formatter.format(value);
         case DdbType.long:
             return (value === null || value === nulls.int64) ?
                 'null'
                 :
-                    String(value);
+                    default_formatter.format(value);
         case DdbType.date:
             return (value === null || value === nulls.int32) ?
                 'null'
@@ -1291,12 +1332,12 @@ export function format(type, value, le, options = {}) {
             return (value === null || value === nulls.float32) ?
                 'null'
                 :
-                    String(value);
+                    formatter.format(value);
         case DdbType.double:
             return (value === null || value === nulls.double) ?
                 'null'
                 :
-                    String(value);
+                    formatter.format(value);
         case DdbType.symbol:
         case DdbType.string:
             return value.quote('single');
@@ -1323,30 +1364,32 @@ export function format(type, value, le, options = {}) {
                 :
                     DdbObj.dec.decode(value)).quote('single');
         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]}`;
         }
+        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');
+            return (data < 0 ? '-' : '') + (scale ? `${s.slice(0, -scale) || '0'}.${s.slice(-scale)}` : s);
+        }
         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, a null value returns a 'null' string */
 export function formati(obj, index, options = {}) {
     if (64 <= obj.type && obj.type < 128) { // array vector
         // 因为 array vector 目前只支持：Logical, Integral（不包括 INT128, COMPRESS 类型）, Floating, Temporal
@@ -1402,6 +1445,16 @@ 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');
+            return (x < 0 ? '-' : '') + (scale ? `${s.slice(0, -scale) || '0'}.${s.slice(-scale)}` : s);
+        }
         default:
             return format(obj.type, obj.value[index], obj.le, options);
     }
@@ -1816,8 +1869,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 +1882,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 +1913,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 +1938,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 +1971,7 @@ export function int1282str(buffer, le = true) {
     return [...buf].map(x => x.toString(16)
         .padStart(2, '0')).join('');
 }
+export const winsize = 40;
 export class DDB {
     /** 当前的 session id (http 或 tcp) */
     sid = '0';
@@ -1949,7 +1995,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 +2020,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 +2038,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,8 +2049,13 @@ 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) {
+        console.log('This is the default on_message before calling this.rpc, it should not be called unless the server pushes the message first after the connection is established');
+        console.log(event.data);
     }
-    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
@@ -2009,34 +2063,42 @@ 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
     */
-    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;
+    async connect({ url, autologin, username, password, python, streaming } = {}) {
+        if (url !== undefined)
+            this.url = url;
+        if (autologin !== undefined)
+            this.autologin = autologin;
+        if (username !== undefined)
+            this.username = username;
+        if (password !== undefined)
+            this.password = password;
+        if (python !== undefined)
+            this.python = python;
+        if (streaming !== undefined)
+            this.streaming = streaming;
         this.disconnect();
         await connect_websocket(this.url, {
-            protocols: this.python ? ['python'] : [],
+            protocols: (() => {
+                if (this.streaming)
+                    return 'streaming';
+                if (this.python)
+                    return 'python';
+            })(),
             on_open: async (event, websocket) => {
                 this.websocket = websocket;
-                await this.rpc('connect', {});
+                if (this.streaming)
+                    await this.subscribe();
+                else
+                    await this.rpc('connect', {});
             },
             on_message: (event) => {
                 this.on_message(event);
             }
         });
-        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 });
+        if (!this.streaming && this.autologin)
+            await this.call('login', [this.username, this.password], { urgent: true });
     }
     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;
@@ -2254,8 +2316,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 +2353,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 +2382,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 +2391,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.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