dolphindb 3.0.21 → 3.0.23

package/README.md

@@ -448,7 +448,7 @@ let sddb = new DDB('ws://192.168.0.43:8800', {
     streaming: {
         table: 'Streaming table name to subscribe to',
         
-        // Streaming data processing callback, the type of message is StreamingData
+        // Streaming data processing callback, the type of message is StreamingMessage
         handler (message) {
             console.log(message)
         }
@@ -459,17 +459,17 @@ let sddb = new DDB('ws://192.168.0.43:8800', {
 await sddb.connect()
 ```
 
-The streaming data received after the connection is established will be used as the message parameter of the handler. The type of the message is StreamingData, as follows:
+The streaming data received after the connection is established will be used as the message parameter of the handler. The type of the message is StreamingMessage, as follows:
 
 ```ts
 export interface StreamingParams {
     table: string
     action?: string
     
-    handler (message: StreamingData): any
+    handler (message: StreamingMessage): any
 }
 
-export interface StreamingData extends StreamingParams {
+export interface StreamingMessage <TRows = any> extends StreamingParams {
     /**
         The time the server sent the message (nano seconds since epoch)  
         std::chrono::system_clock::now().time_since_epoch() / std::chrono::nanoseconds(1)
@@ -479,18 +479,16 @@ export interface StreamingData extends StreamingParams {
     /** message id */
     id: bigint
     
-    colnames: string[]
-    
     /** Subscription topic, which is the name of a subscription.
         It is a string consisting of the alias of the node where the subscription table is located, the stream data table name, and the subscription task name (if actionName is specified), separated by `/`
     */
     topic: string
     
     /** Streaming data, the type is any vector, each element of which corresponds to a column (without name) of the subscribed table, and the content in the column (DdbObj<DdbVectorValue>) is the new data value */
-    data: DdbObj<DdbVectorObj[]>
+    obj: DdbObj<DdbVectorObj[]>
     
-    /** Number of new streaming data rows */
-    rows: number
+    /** Streaming data, each element of the data attribute in the object corresponds to a row in the incremental data of the subscribed table */
+    data: DdbTableData<TRows>
     
     window: {
         /** The establishment of the connection starts offset = 0, and gradually increases as the window moves */
@@ -500,7 +498,7 @@ export interface StreamingData extends StreamingParams {
         rows: number
         
         /** An array of data received each time */
-        segments: DdbObj<DdbVectorObj[]>[]
+        segments: DdbTableData<TRows>[]
     }
     
     /** After successfully subscribed, if the subsequently pushed message is parsed incorrectly, the error will be set and the handler will be called. */

package/README.zh.md

@@ -49,7 +49,11 @@ https://www.npmjs.com/package/dolphindb
             await ddb.connect()
             
             console.log(
-                await ddb.eval('1 + 1')
+                await ddb.execute('1 + 1')
+            )
+            
+            console.log(
+                await ddb.invoke('add', [1, 1])
             )
         </script>
     </body>
@@ -127,7 +131,54 @@ let ddb = new DDB('ws://127.0.0.1:8848', {
 
 
 ### 调用函数
-#### 例子
+#### `invoke` 方法
+##### `invoke` 方法代码示例
+```ts
+const result = await ddb.invoke('add', [1, 1])
+// TypeScript: const result = await ddb.invoke<number>('add', [1, 1])
+
+console.log(result === 2)  // true
+```
+
+上面例子中，上传了两个参数 1 (对应 DolphinDB 中的 int 类型) 到 DolphinDB 数据库，作为 add 函数的参数，并接收函数调用的结果 result
+
+`<number>` 用于 TypeScript 推断返回值的类型
+
+##### `invoke` 方法声明
+```ts
+/** 调用 dolphindb 函数，传入 js 原生数组作为参数，返回 js 原生对象或值（调用 DdbObj.data() 后的结果）*/
+async invoke <TResult = any> (
+    /** 函数名 */
+    func: string, 
+    
+    /** `[ ]` 调用参数，可以是 js 原生数组 */
+    args?: any[], 
+    
+    /** 调用选项 */
+    options?: {
+        /** 紧急 flag。使用 urgent worker 执行，防止被其它作业阻塞 */
+        urgent?: boolean
+        
+        /** 设置结点 alias 时发送到集群中对应的结点执行 (使用 DolphinDB 中的 rpc 方法) */
+        node?: string
+        
+        /** 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法) */
+        nodes?: string[]
+        
+        /** 设置 node 参数且参数数组为空时必传，需指定函数类型，其它情况下不传 */
+        func_type?: DdbFunctionType
+        
+        /** 设置 nodes 参数时选传，其它情况不传 */
+        add_node_alias?: boolean
+        
+        /** 处理本次 rpc 期间的消息 (DdbMessage) */
+        listener?: DdbMessageListener
+    } = { }
+): Promise<TResult>
+```
+
+#### `call` 方法
+##### `call` 方法代码示例
 ```ts
 import { DdbInt } from 'dolphindb'
 
@@ -137,7 +188,7 @@ const result = await ddb.call('add', [new DdbInt(1), new DdbInt(1)])
 console.log(result.value === 2)  // true
 ```
 
-##### 用 DdbObj 对象来表示 DolphinDB 中的数据类型
+###### 用 DdbObj 对象来表示 DolphinDB 中的数据类型
 
 上面例子中，上传了两个参数 1 (对应 DolphinDB 中的 int 类型) 到 DolphinDB 数据库，作为 add 函数的参数，并接收函数调用的结果 result
 
@@ -244,7 +295,7 @@ enum DdbType {
 }
 ```
 
-##### 无快捷类的类型
+###### 无快捷类的类型
 
 对于没有快捷类的类型，可指定 form 和 type 手动创建 DdbObj 对象
 
@@ -284,7 +335,7 @@ const obj = new DdbSetInt(
 )
 ```
 
-#### scalar 形式的 NULL 对象
+###### scalar 形式的 NULL 对象
 
 scalar 形式的 NULL 对象，其对应 DdbObj 的 value 为 JavaScript 中的 null：
 
@@ -296,8 +347,7 @@ new DdbInt(null)
 new DdbDouble(null)
 ```
 
-
-#### `call` 方法声明
+##### `call` 方法声明
 ```ts
 async call <T extends DdbObj> (
     /** 函数名 */
@@ -326,9 +376,50 @@ async call <T extends DdbObj> (
 ): Promise<T>
 ```
 
-
 ### 执行脚本
-#### 例子
+#### `execute` 方法
+##### `execute` 方法代码示例
+```ts
+const result = await ddb.execute(
+    'def foo (a, b) {\n' +
+    '    return a + b\n' +
+    '}\n' +
+    'foo(1l, 1l)\n'
+)
+
+// TypeScript:
+// const result = await ddb.execute<bigint>(...)
+
+console.log(result.value === 2n)  // true
+```
+
+上面例子中，通过字符串上传了一段脚本到 DolphinDB 数据库执行，并接收最后一条语句 `foo(1l, 1l)` 执行结果 result
+
+`<bigint>` 用于 TypeScript 推断返回值的类型
+
+- result 是一个 `bigint`
+
+只要 WebSocket 连接不断开，在后续的会话中 `foo` 这个自定义函数会一直存在，可复用，比如后续通过 `await ddb.invoke<number>('foo', [1, 1])` 调用这个自定义函数
+
+##### `execute` 方法声明
+```ts
+/** 执行 dolphindb 脚本，返回 js 原生对象或值（调用 DdbObj.data() 后的结果）*/
+async execute <TResult = any> (
+    /** 执行的脚本 */
+    script: string, 
+    
+    /** 执行选项 */
+    options?: {
+        /** 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞 */
+        urgent?: boolean
+        /** listener?: 处理本次 rpc 期间的消息 (DdbMessage) */
+        listener?: DdbMessageListener
+    }
+): Promise<TResult>
+```
+
+#### `eval` 方法
+##### `eval` 方法代码示例
 ```ts
 const result = await ddb.eval(
     'def foo (a, b) {\n' +
@@ -353,10 +444,9 @@ console.log(result.value === 2n)  // true
 - result.type 是 `DdbType.long`
 - result.value 是 JavaScript 中原生的 `bigint` (long 的精度不能用 JavaScript 的 number 准确表示，但可以用 bigint 表示)
 
-只要 WebSocket 连接不断开，在后续的会话中 `foo` 这个自定义函数会一直存在，可复用，比如后续通过 `await ddb.call<DdbInt>('foo', [new DdbInt(1), new DdbInt(1)])` 调用这个自定义函数
-
-#### `eval` 方法声明
+##### `eval` 方法声明
 ```ts
+/** 执行 dolphindb 脚本，返回 DdbObj 对象）*/
 async eval <T extends DdbObj> (
     /** 执行的脚本 */
     script: string,
@@ -369,7 +459,6 @@ async eval <T extends DdbObj> (
 ): Promise<T>
 ```
 
-
 ### 上传变量
 #### 例子
 ```ts
@@ -445,7 +534,7 @@ let sddb = new DDB('ws://192.168.0.43:8800', {
     streaming: {
         table: '要订阅的流表名称',
         
-        // 流数据处理回调, message 的类型是 StreamingData
+        // 流数据处理回调, message 的类型是 StreamingMessage
         handler (message) {
             console.log(message)
         }
@@ -456,38 +545,30 @@ let sddb = new DDB('ws://192.168.0.43:8800', {
 await sddb.connect()
 ```
 
-连接建立后接收到的流数据会作为 message 参数调用 handler, message 的类型是 StreamingData, 如下:
+连接建立后接收到的流数据会作为 message 参数调用 handler, message 的类型是 StreamingMessage, 如下:
 
 ```ts
 export interface StreamingParams {
     table: string
     action?: string
     
-    handler (message: StreamingData): any
+    handler (message: StreamingMessage): any
 }
 
-export interface StreamingData extends StreamingParams {
-    /**
-        server 发送消息的时间 (nano seconds since epoch)  
-        std::chrono::system_clock::now().time_since_epoch() / std::chrono::nanoseconds(1)
-    */
+export interface StreamingMessage <TRows = any> extends StreamingParams {
+    /** server 发送消息的时间 (nano seconds since epoch)  
+        std::chrono::system_clock::now().time_since_epoch() / std::chrono::nanoseconds(1) */
     time: bigint
     
     /** message id */
     id: bigint
     
-    colnames: string[]
-    
     /** 订阅主题，即一个订阅的名称。
-        它是一个字符串，由订阅表所在节点的别名、流数据表名称和订阅任务名称（如果指定了 actionName）组合而成，使用 `/` 分隔
-    */
+        它是一个字符串，由订阅表所在节点的别名、流数据表名称和订阅任务名称（如果指定了 actionName）组合而成，使用 `/` 分隔 */
     topic: string
     
-    /** 流数据，类型是 any vector, 其中的每一个元素对应被订阅表的一个列 (没有 name)，列 (DdbObj<DdbVectorValue>) 中的内容是新增的数据值 */
-    data: DdbObj<DdbVectorObj[]>
-    
-    /** 新增的流数据行数 */
-    rows: number
+    /** 流数据 */
+    data: DdbTableData<TRows>
     
     window: {
         /** 建立连接开始 offset = 0, 随着 window 的移动逐渐增加 */
@@ -497,7 +578,7 @@ export interface StreamingData extends StreamingParams {
         rows: number
         
         /** 每次接收到的 data 组成的数组 */
-        segments: DdbObj<DdbVectorObj[]>[]
+        segments: DdbTableData<TRows>[]
     }
     
     /** 成功订阅后，后续推送过来的 message 解析错误，则会设置 error 并调用 handler */

package/browser.d.ts

@@ -300,8 +300,8 @@ export declare class DdbObj<TValue extends DdbValue = DdbValue> {
         - 矩阵对应 DdbMatrixData
         - 字典对应普通的 js 对象 Record<string, any>
         - 图对应 DdbChartValue */
-    data<TResult extends any[]>(this: DdbVectorObj): TResult;
-    data<TResult = any>(this: DdbObj): TResult;
+    data<TResult extends any[]>(this: DdbVectorObj, options?: ConvertOptions): TResult;
+    data<TResult = any>(this: DdbObj, options?: ConvertOptions): TResult;
     toString(options?: InspectOptions): string;
     inspect_type(): string;
     /** 自动转换 js string, boolean 为 DdbObj */
@@ -353,9 +353,13 @@ export interface InspectOptions {
 export declare function format(type: DdbType, value: DdbValue, le: boolean, options?: InspectOptions): string;
 /** 格式化向量、集合中的第 index 项为字符串，空值返回 'null' 字符串  formatted vector, the index-th item in the collection is a string, a null value returns a 'null' string */
 export declare function formati(obj: DdbVectorObj, index: number, options?: InspectOptions): string;
-export declare function convert(type: DdbType, value: DdbValue, le: boolean): string | number | bigint | boolean | Uint8Array | DdbFunctionDefValue | DdbDurationValue | DdbDecimal32Value | DdbDecimal64Value | DdbDecimal32VectorValue | Int32Array | DdbDecimal64VectorValue | BigInt64Array | DdbDecimal128VectorValue | BigInt128Array | DdbSymbolExtendedValue | string[] | Int8Array | Int16Array | Float32Array | Float64Array | DdbArrayVectorValue | DdbMatrixValue | Uint8Array[] | DdbObj<DdbValue>[] | DdbDurationVectorValue | DdbChartValue | number[];
+export interface ConvertOptions {
+    /** `'string'` blob 类型数据的格式 */
+    blob?: 'string' | 'binary';
+}
+export declare function convert(type: DdbType, value: DdbValue, le: boolean, { blob }?: ConvertOptions): string | number | bigint | boolean | Uint8Array | DdbFunctionDefValue | DdbDurationValue | DdbDecimal32Value | DdbDecimal64Value | DdbDecimal32VectorValue | Int32Array | DdbDecimal64VectorValue | BigInt64Array | DdbDecimal128VectorValue | BigInt128Array | DdbSymbolExtendedValue | string[] | Int8Array | Int16Array | Float32Array | Float64Array | DdbArrayVectorValue | DdbMatrixValue | Uint8Array[] | DdbObj<DdbValue>[] | DdbDurationVectorValue | DdbChartValue | number[];
 /** 转换一个向量到 js 原生数组 */
-export declare function converts(type: DdbType, value: DdbVectorValue, rows: number, le: boolean): any[];
+export declare function converts(type: DdbType, value: DdbVectorValue, rows: number, le: boolean, options?: ConvertOptions): any[];
 export declare class DdbVoid extends DdbObj<undefined> {
     constructor(value?: DdbVoidType);
 }
@@ -499,31 +503,28 @@ export interface StreamingParams {
     };
     handler(message: StreamingMessage): any;
 }
-export interface StreamingMessage extends StreamingParams {
+export interface StreamingMessage<TRows = any> extends StreamingParams {
     /** server 发送消息的时间 (nano seconds since epoch)   The time the server sent the message (nano seconds since epoch)
         std::chrono::system_clock::now().time_since_epoch() / std::chrono::nanoseconds(1) */
     time: bigint;
     /** message id */
     id: bigint;
-    colnames: string[];
-    /** 最新的 server 有可能先推一个 table schema 过来 */
-    schema?: DdbTableObj;
     /** 订阅主题，即一个订阅的名称。  Subscription topic, which is the name of a subscription.
         它是一个字符串，由订阅表所在节点的别名、流数据表名称和订阅任务名称（如果指定了 actionName）组合而成，使用 `/` 分隔
         It is a string consisting of the alias of the node where the subscription table is located, the stream data table name, and the subscription task name (if actionName is specified), separated by `/` */
     topic: string;
     /** 流数据，类型是 any vector, 其中的每一个元素对应被订阅表的一个列 (没有 name)，列 (DdbObj<DdbVectorValue>) 中的内容是新增的数据值
         Stream data, the type is any vector, each element of which corresponds to a column (without name) of the subscribed table, and the content in the column (DdbObj<DdbVectorValue>) is the new data value */
-    data: DdbObj<DdbVectorObj[]>;
-    /** 新增的流数据行数  Number of new streaming data rows */
-    rows: number;
+    obj: DdbObj<DdbVectorObj[]>;
+    /** 流数据 */
+    data: DdbTableData<TRows>;
     window: {
         /** 建立连接开始 offset = 0, 随着 window 的移动逐渐增加  The establishment of the connection starts offset = 0, and gradually increases as the window moves */
         offset: number;
         /** segments 中 segment.row 的总和  sum of segment.row in segments */
         rows: number;
         /** 每次接收到的 data 组成的数组  An array of data received each time */
-        segments: DdbObj<DdbVectorObj[]>[];
+        segments: DdbTableData<TRows>[];
     };
     /** 成功订阅后，后续推送过来的 message 解析错误，则会设置 error 并调用 handler
         After successfully subscribed, if the subsequently pushed message is parsed incorrectly, the error will be set and the handler will be called. */

package/browser.js

@@ -5,7 +5,7 @@ import ipaddrjs from 'ipaddr.js';
 const { fromByteArray: buf2ipaddr } = ipaddrjs;
 import 'xshell/prototype.browser.js';
 import { blue, cyan, green, grey, magenta } from 'xshell/chalk.browser.js';
-import { concat, assert, Lock, genid, seq, zip_object } from 'xshell/utils.browser.js';
+import { concat, assert, Lock, genid, seq, zip_object, decode } from 'xshell/utils.browser.js';
 import { connect_websocket } from 'xshell/net.browser.js';
 import { t } from './i18n/index.js';
 export const nulls = {
@@ -1125,20 +1125,20 @@ export class DdbObj {
                 throw new Error(t('vector {{type}} 暂不支持序列化', { type: get_type_name(type) }));
         }
     }
-    data() {
+    data(options) {
         const { form, type, value, le, rows, name } = this;
         switch (form) {
             case DdbForm.scalar:
-                return convert(type, value, le);
+                return convert(type, value, le, options);
             case DdbForm.vector:
             case DdbForm.pair:
             case DdbForm.set: {
-                const data = converts(type, value, rows, le);
+                const data = converts(type, value, rows, le, options);
                 return (form === DdbForm.set ? new Set(data) : data);
             }
             case DdbForm.table: {
                 const cols = value;
-                const jscols = cols.map(col => col.data());
+                const jscols = cols.map(col => col.data(options));
                 const keys = cols.map(({ name }) => name);
                 return {
                     name: name || '',
@@ -1149,20 +1149,20 @@ export class DdbObj {
             }
             case DdbForm.dict: {
                 const [keys, values] = value;
-                return zip_object(keys.data(), values.data());
+                return zip_object(keys.data(options), values.data(options));
             }
             case DdbForm.chart:
                 return value;
             case DdbForm.matrix: {
                 const ncolumns = this.cols;
                 const { rows: _rows, cols: _cols, data } = value;
-                const jsdata = converts(type, data, rows * ncolumns, le);
+                const jsdata = converts(type, data, rows * ncolumns, le, options);
                 return {
                     type,
                     nrows: rows,
                     ncolumns,
-                    rows: _rows?.data(),
-                    columns: _cols?.data(),
+                    rows: _rows?.data(options),
+                    columns: _cols?.data(options),
                     data: seq(rows, i => seq(ncolumns, j => jsdata[j * rows + i]))
                 };
             }
@@ -1768,7 +1768,7 @@ export function formati(obj, index, options = {}) {
         }
     }
 }
-export function convert(type, value, le) {
+export function convert(type, value, le, { blob = 'string' } = {}) {
     switch (type) {
         case DdbType.void:
             return value === DdbVoidType.null ? null : undefined;
@@ -1794,8 +1794,9 @@ export function convert(type, value, le) {
         case DdbType.handle:
         case DdbType.datasource:
         case DdbType.resource:
-        case DdbType.blob:
             return value;
+        case DdbType.blob:
+            return blob === 'string' ? decode(value) : value;
         case DdbType.complex:
         case DdbType.point: {
             const [x, y] = value;
@@ -1828,7 +1829,7 @@ export function convert(type, value, le) {
     }
 }
 /** 转换一个向量到 js 原生数组 */
-export function converts(type, value, rows, le) {
+export function converts(type, value, rows, le, options) {
     if (type < 64 || type >= 128)
         switch (type) {
             // 可以直接用下标取值再转换的类型
@@ -1858,7 +1859,7 @@ export function converts(type, value, rows, le) {
             case DdbType.resource:
             case DdbType.functiondef:
             case DdbType.blob:
-                return Array.prototype.map.call(value, (x) => convert(type, x, le));
+                return Array.prototype.map.call(value, (x) => convert(type, x, le, options));
             case DdbType.void:
                 return [];
             case DdbType.symbol_extended: {
@@ -1871,14 +1872,12 @@ export function converts(type, value, rows, le) {
             case DdbType.uuid:
             case DdbType.ipaddr:
             case DdbType.int128:
-                return seq(rows, i => convert(type, value.subarray(16 * i, 16 * (i + 1)), le));
+                return seq(rows, i => convert(type, value.subarray(16 * i, 16 * (i + 1)), le, options));
             case DdbType.decimal32:
             case DdbType.decimal64:
             case DdbType.decimal128: {
                 const { scale, data } = value;
-                // todo: 用 Array.prototype.map.call 时对 BigInt128Array 这个代理对象无效？为什么只能通过下标访问？
-                return seq(rows, i => {
-                    const x = data[i];
+                return Array.prototype.map.call(data, (x) => {
                     if (is_decimal_null_value(type, x))
                         return '';
                     const s = String(x < 0 ? -x : x).padStart(scale, '0');
@@ -1886,7 +1885,7 @@ export function converts(type, value, rows, le) {
                 });
             }
             case DdbType.any:
-                return value.map(x => x.data());
+                return value.map(x => x.data(options));
             default:
                 throw new Error(String(DdbType[type] || type) + '[]' + t(' 暂时不支持转换为 js 对象'));
         }
@@ -1900,16 +1899,16 @@ export function converts(type, value, rows, le) {
                         case DdbType.decimal32:
                         case DdbType.decimal64:
                         case DdbType.decimal128:
-                            return converts(type_, { scale: value.scale, data: data.subarray(acc_len, acc_len + length) }, length, le);
+                            return converts(type_, { scale: value.scale, data: data.subarray(acc_len, acc_len + length) }, length, le, options);
                         case DdbType.complex:
                         case DdbType.point:
-                            return converts(type_, data.subarray(acc_len, acc_len + 2 * length), length, le);
+                            return converts(type_, data.subarray(acc_len, acc_len + 2 * length), length, le, options);
                         case DdbType.uuid:
                         case DdbType.int128:
                         case DdbType.ipaddr:
-                            return converts(type_, data.subarray(acc_len, acc_len + 16 * length), length, le);
+                            return converts(type_, data.subarray(acc_len, acc_len + 16 * length), length, le, options);
                         default:
-                            return converts(type_, data.subarray(acc_len, acc_len + length), length, le);
+                            return converts(type_, data.subarray(acc_len, acc_len + length), length, le, options);
                     }
                 })();
                 acc_len += length;
@@ -3066,8 +3065,9 @@ export class DDB {
             rows: 0,
             segments: [],
         };
-        let schema;
-        const { value: colnames } = await this.call('publishTable', [
+        // 流表推送过来的第一条数据是 schema，需要特殊处理
+        let first = true;
+        const { value: columns } = await this.call('publishTable', [
             'localhost',
             new DdbInt(0),
             this.streaming.table,
@@ -3081,41 +3081,56 @@ export class DDB {
             // 先准备好收到 websocket message 的 callback
             on_more_messages: buffer => {
                 try {
+                    let data;
                     const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
                     const i_topic_end = buffer.indexOf(0, 17);
                     // 首个 message 一定是 table schema, 后续消息是 column 片段组成的 any vector
-                    const data = DdbObj.parse(buffer.subarray(i_topic_end + 1), this.le);
+                    const obj = DdbObj.parse(buffer.subarray(i_topic_end + 1), this.le);
                     // server 推数据时遇到错误会返回 string，一般格式为 error.xxx: 错误信息
-                    if (data.form === DdbForm.scalar && data.type === DdbType.string) {
+                    if (obj.form === DdbForm.scalar && obj.type === DdbType.string) {
                         this.disconnect();
-                        const value = data.value;
+                        const value = obj.value;
                         throw new Error(value.slice(value.indexOf(':') + 1).trim());
                     }
-                    if (!schema) {
-                        schema = data;
-                        return;
+                    if (first) {
+                        data = obj.data();
+                        data.name ||= this.streaming.table;
+                        first = false;
                     }
-                    const { rows } = data.value[0];
-                    win.rows += 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].value[0].rows;
-                        win.segments = win.segments.slice(i);
-                        win.offset += win.rows - winsize_;
-                        win.rows = winsize_;
+                    else {
+                        const { rows } = obj.value[0];
+                        const types = [];
+                        const js_cols = [];
+                        // 遍历每一列
+                        obj.value.forEach(({ type, value }) => {
+                            types.push(type);
+                            js_cols.push(converts(type, value, rows, obj.le));
+                        });
+                        data = {
+                            name: this.streaming.table || '',
+                            columns,
+                            types,
+                            data: seq(rows, i => zip_object(columns, seq(columns.length, j => js_cols[j][i])))
+                        };
+                        win.rows += 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].data.length;
+                            win.segments = win.segments.slice(i);
+                            win.offset += win.rows - winsize_;
+                            win.rows = winsize_;
+                        }
                     }
                     this.streaming.handler({
                         ...this.streaming,
                         id: dv.getBigInt64(9, this.le),
                         time: dv.getBigInt64(1, this.le),
-                        rows,
                         topic: this.dec.decode(buffer.subarray(17, i_topic_end)),
-                        colnames,
-                        schema,
+                        obj,
                         data,
                         window: win,
                     });
@@ -3126,9 +3141,9 @@ export class DDB {
                 }
             }
         });
-        console.log(t('订阅流表成功') + ', colnames:', 
+        console.log(t('订阅流表成功') + ', columns:', 
         // string[3](['time', 'stock', 'price'])
-        colnames);
+        columns);
     }
 }
 /** https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements
@@ -3206,6 +3221,14 @@ export class BigInt128Array {
                     return true;
                 }
                 return Reflect.set(target, key, value);
+            },
+            has(target, key) {
+                if (typeof key === 'string') {
+                    const index = Number(key);
+                    if (Number.isInteger(index) && index >= 0 && index < target.length)
+                        return true;
+                }
+                return Reflect.has(target, key);
             }
         });
     }