dolphindb 3.0.38 → 3.0.39

package/index.d.ts

@@ -24,7 +24,8 @@ export declare enum DdbForm {
     /** 节点内部通信可能会使用，调用函数执行脚本一般不会返回这种类型 */
     chunk = 8,
     /** sysobj */
-    object = 9
+    object = 9,
+    tensor = 10
 }
 /** DolphinDB DataType
     对应的 array vector 类型为 64 + 基本类型
@@ -173,6 +174,35 @@ export interface DdbMatrixValue {
     cols: DdbVectorObj | null;
     data: DdbVectorValue;
 }
+/** 工具，取得某个 DdbType 的字节数 */
+export declare const ddb_tensor_bytes: Record<DdbType.bool | DdbType.char | DdbType.short | DdbType.int | DdbType.long | DdbType.float | DdbType.double, number>;
+type TensorElem = TensorData | boolean | number | bigint | null | string;
+interface TensorData extends Array<TensorElem> {
+}
+interface DdbTensorMetadata {
+    /** Tensor 的元素的数据类型 */
+    data_type: DdbType;
+    /** Tensor 类型 */
+    tensor_type: number;
+    /** 设备类型 */
+    device_type: number;
+    /** Tensor Flags */
+    tensor_flags: number;
+    /** 维度 */
+    dimensions: number;
+    /** shape, shape[i] 表示第 i 个维度的 size */
+    shape: number[];
+    /** strides, strides[i] 表示在第 i 个维度，一个元素与下一个元素的距离 */
+    strides: number[];
+    /** 保留值 */
+    preserve_value: bigint;
+    /** 元素个数 */
+    elem_count: number;
+}
+export interface DdbTensorValue extends DdbTensorMetadata {
+    /** 数据 */
+    data: Uint8Array;
+}
 export type DdbDictValue = [DdbVectorObj, DdbVectorObj];
 export interface DdbChartValue {
     /** 原属性 chartType  original: chartType */
@@ -207,7 +237,7 @@ export type DdbVectorValue = null | Uint8Array | Int8Array | Int16Array | Int32A
 Uint8Array[] | // blob
 DdbObj[] | // any
 DdbSymbolExtendedValue | DdbArrayVectorValue | DdbDecimal32VectorValue | DdbDecimal64VectorValue | DdbDecimal128VectorValue | DdbDurationVectorValue;
-export type DdbValue = DdbScalarValue | DdbVectorValue | DdbMatrixValue | DdbDictValue | DdbChartValue;
+export type DdbValue = DdbScalarValue | DdbVectorValue | DdbMatrixValue | DdbDictValue | DdbChartValue | DdbTensorValue;
 export type DdbStringObj = DdbObj<string>;
 export type DdbVectorObj<TValue extends DdbVectorValue = DdbVectorValue> = DdbObj<TValue>;
 export type DdbVectorAnyObj = DdbVectorObj<DdbObj[]>;
@@ -216,6 +246,7 @@ export type DdbTableObj<TColumns extends DdbVectorObj[] = DdbVectorObj[]> = DdbO
 export type DdbDictObj<TKeys extends DdbVectorObj = DdbVectorObj, TValues extends DdbVectorObj = DdbVectorObj> = DdbObj<[TKeys, TValues]>;
 export type DdbMatrixObj<TValue extends DdbMatrixValue = DdbMatrixValue> = DdbObj<TValue>;
 export type DdbChartObj = DdbObj<DdbChartValue>;
+export type DdbTensorObj = DdbObj<DdbTensorValue>;
 /** DdbObj.data() 返回的表格对象 */
 export interface DdbTableData<TRow = any> {
     /** 表名 */
@@ -227,6 +258,11 @@ export interface DdbTableData<TRow = any> {
     /** 表格数据，每一行的对象组成的数组 */
     data: TRow[];
 }
+/** DdbObj.data() 返回的 Tensor 对象 */
+export interface DdbTensorData extends DdbTensorMetadata {
+    /** 数据 */
+    data: TensorData;
+}
 /** DdbObj.data() 返回的矩阵对象 */
 export interface DdbMatrixData {
     /** 原始数据类型 */
@@ -302,6 +338,20 @@ export declare class DdbObj<TValue extends DdbValue = DdbValue> {
         - 图对应 DdbChartValue */
     data<TResult extends any[]>(this: DdbVectorObj, options?: ConvertOptions): TResult;
     data<TResult = any>(this: DdbObj, options?: ConvertOptions): TResult;
+    /** 构建 Tensor
+        @param buildParams 构建参数
+        @param limit 限制每个维度最大元素个数（仅用于 log，不作他用）
+        @returns  */
+    static parse_tensor(buildParams: {
+        currentDim: number;
+        dimensions: number;
+        rawData: Uint8Array;
+        le: boolean;
+        dataByte: number;
+        dataType: DdbType;
+        shape: number[];
+        strides: number[];
+    }, limit?: number): TensorData;
     [inspect.custom](depth: number, _options: InspectOptions, _inspect: any): string;
     inspect_type(): string;
     /** 自动转换 js string, boolean 为 DdbObj */
@@ -347,7 +397,7 @@ 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 | Int32Array | BigInt64Array | string[] | Int8Array | Int16Array | Float32Array | Float64Array | Uint8Array[] | number[] | DdbFunctionDefValue | DdbDurationValue | DdbDecimal32Value | DdbDecimal64Value | DdbDecimal32VectorValue | DdbDecimal64VectorValue | DdbDecimal128VectorValue | BigInt128Array | DdbSymbolExtendedValue | DdbArrayVectorValue | DdbMatrixValue | DdbObj<DdbValue>[] | DdbDurationVectorValue | DdbChartValue;
+export declare function convert(type: DdbType, value: DdbValue, le: boolean, { blob }?: ConvertOptions): string | number | bigint | boolean | Uint8Array | Int32Array | BigInt64Array | string[] | Int8Array | Int16Array | Float32Array | Float64Array | Uint8Array[] | number[] | DdbFunctionDefValue | DdbDurationValue | DdbDecimal32Value | DdbDecimal64Value | DdbDecimal32VectorValue | DdbDecimal64VectorValue | DdbDecimal128VectorValue | BigInt128Array | DdbSymbolExtendedValue | DdbArrayVectorValue | DdbMatrixValue | DdbObj<DdbValue>[] | DdbDurationVectorValue | DdbTensorValue | DdbChartValue;
 /** 转换一个向量到 js 原生数组 */
 export declare function converts(type: DdbType, value: DdbVectorValue, rows: number, le: boolean, options?: ConvertOptions): any[];
 export declare class DdbVoid extends DdbObj<undefined> {

package/index.js

@@ -30,6 +30,7 @@ export var DdbForm;
     DdbForm[DdbForm["chunk"] = 8] = "chunk";
     /** sysobj */
     DdbForm[DdbForm["object"] = 9] = "object";
+    DdbForm[DdbForm["tensor"] = 10] = "tensor";
 })(DdbForm || (DdbForm = {}));
 /** DolphinDB DataType
     对应的 array vector 类型为 64 + 基本类型
@@ -126,6 +127,16 @@ export var DdbVoidType;
     DdbVoidType[DdbVoidType["default"] = 2] = "default";
 })(DdbVoidType || (DdbVoidType = {}));
 export const dictables = new Set([DdbType.any, DdbType.string, DdbType.double, DdbType.float, DdbType.int, DdbType.long]);
+/** 工具，取得某个 DdbType 的字节数 */
+export const ddb_tensor_bytes = {
+    [DdbType.bool]: 1,
+    [DdbType.char]: 1,
+    [DdbType.short]: 2,
+    [DdbType.int]: 4,
+    [DdbType.long]: 8,
+    [DdbType.float]: 4,
+    [DdbType.double]: 8,
+};
 /** 可以表示所有 DolphinDB 数据库中的数据类型  Can represent data types in all DolphinDB databases */
 export class DdbObj {
     static dec = new TextDecoder('utf-8');
@@ -363,6 +374,47 @@ export class DdbObj {
                     },
                 });
             }
+            case DdbForm.tensor: {
+                // 元数据
+                const tensorType = buf[2];
+                const deviceType = buf[3];
+                const dv = new DataView(buf.buffer, buf.byteOffset);
+                const tensorFlags = dv.getUint32(4, le);
+                const dimensions = dv.getInt32(8, le);
+                const shapes = [];
+                const strides = [];
+                const shapeStart = 12;
+                const stridesStart = shapeStart + dimensions * 8;
+                const preserveValueStart = stridesStart + dimensions * 8;
+                const preserveValue = dv.getBigInt64(preserveValueStart, le);
+                const storageStart = preserveValueStart + 8;
+                const elemCount = dv.getBigInt64(storageStart, le);
+                const dataStart = storageStart + 8;
+                for (let d = 0; d < dimensions; d++) {
+                    const getNumOffset = d * 8;
+                    shapes.push(Number(dv.getBigInt64(shapeStart + getNumOffset, le)));
+                    strides.push(Number(dv.getBigInt64(stridesStart + getNumOffset, le)));
+                }
+                const dataBuffer = buf.subarray(dataStart);
+                return new this({
+                    le,
+                    form,
+                    type,
+                    length: i_data + buf_data.length,
+                    value: {
+                        data_type: type,
+                        tensor_type: tensorType,
+                        device_type: deviceType,
+                        tensor_flags: tensorFlags,
+                        dimensions,
+                        shape: shapes,
+                        strides,
+                        preserve_value: preserveValue,
+                        elem_count: Number(elemCount),
+                        data: dataBuffer
+                    }
+                });
+            }
             default:
                 return new this({
                     le,
@@ -1163,10 +1215,99 @@ export class DdbObj {
                     data: seq(rows, i => seq(ncolumns, j => jsdata[j * rows + i]))
                 };
             }
+            case DdbForm.tensor: {
+                const { data_type, tensor_type, device_type, tensor_flags, dimensions, shape, strides, preserve_value, elem_count, data, } = this.value;
+                const dataByte = ddb_tensor_bytes[data_type];
+                const returnData = {
+                    data_type,
+                    tensor_type,
+                    device_type,
+                    tensor_flags,
+                    dimensions,
+                    shape,
+                    strides,
+                    preserve_value,
+                    elem_count,
+                    data: DdbObj.parse_tensor({ currentDim: 0, dimensions, rawData: data, le: this.le, dataByte, dataType: data_type, shape, strides })
+                };
+                return returnData;
+            }
             default:
                 throw new Error(t('{{form}} {{type}} 暂不支持 data()', { form, type: get_type_name(type) }));
         }
     }
+    /** 构建 Tensor
+        @param buildParams 构建参数
+        @param limit 限制每个维度最大元素个数（仅用于 log，不作他用）
+        @returns  */
+    static parse_tensor(buildParams, limit = -1) {
+        const { currentDim, dimensions, rawData, le, dataByte, dataType, shape, strides } = buildParams;
+        const tensor = [];
+        const dv = new DataView(rawData.buffer, rawData.byteOffset);
+        for (let i = 0; i < shape[currentDim]; i++)
+            if (currentDim >= dimensions - 1) {
+                if (limit > 0 && i >= limit) {
+                    tensor.push('...');
+                    break;
+                }
+                // 直接转换到对应的数组
+                const offset = i * dataByte * Number(strides[currentDim]);
+                switch (dataType) {
+                    case DdbType.bool: {
+                        const value = dv.getInt8(offset);
+                        tensor.push(value === nulls.int8 ? null : Boolean(value));
+                        break;
+                    }
+                    case DdbType.char: {
+                        const value = dv.getInt8(offset);
+                        tensor.push(value === nulls.int8 ? null : value);
+                        break;
+                    }
+                    case DdbType.short: {
+                        const value = dv.getInt16(offset, le);
+                        tensor.push(value === nulls.int16 ? null : value);
+                        break;
+                    }
+                    case DdbType.int: {
+                        const value = dv.getInt32(offset, le);
+                        tensor.push(value === nulls.int32 ? null : value);
+                        break;
+                    }
+                    case DdbType.long: {
+                        const value = dv.getBigInt64(offset, le);
+                        tensor.push(value === nulls.int64 ? null : value);
+                        break;
+                    }
+                    case DdbType.float: {
+                        const value = dv.getFloat32(offset, le);
+                        tensor.push(value === nulls.float32 ? null : value);
+                        break;
+                    }
+                    case DdbType.double: {
+                        const value = dv.getFloat64(offset, le);
+                        tensor.push(value === nulls.double ? null : value);
+                        break;
+                    }
+                }
+            }
+            else {
+                // 起点
+                const start = strides[currentDim] * i * dataByte;
+                // 终点
+                const end = start + strides[currentDim] * 1 * dataByte;
+                tensor.push(DdbObj.parse_tensor({
+                    currentDim: currentDim + 1,
+                    dimensions,
+                    rawData: rawData.subarray(Number(start), Number(end)),
+                    le,
+                    dataByte,
+                    shape,
+                    strides,
+                    dataType
+                }, limit));
+            }
+        return tensor;
+    }
     [inspect.custom](depth, _options, _inspect) {
         const options = { nullstr: true, ..._options };
         const type = this.inspect_type();
@@ -1295,6 +1436,20 @@ export class DdbObj {
                         }
                     }
                 }
+                case DdbForm.tensor: {
+                    const tensorVal = this.value;
+                    const retd = DdbObj.parse_tensor({
+                        currentDim: 0,
+                        dimensions: tensorVal.dimensions,
+                        rawData: tensorVal.data,
+                        le: this.le,
+                        dataByte: ddb_tensor_bytes[tensorVal.data_type],
+                        dataType: tensorVal.data_type,
+                        shape: tensorVal.shape,
+                        strides: tensorVal.strides
+                    }, 5);
+                    return inspect(retd, options).replaceAll("\'...\'", '...');
+                }
             }
             if (this.value instanceof Uint8Array)
                 return inspect(typed_array_to_buffer(this.value), options);
@@ -1329,6 +1484,8 @@ export class DdbObj {
                 return `chart<${DdbChartType[this.value.type]}>`;
             case DdbForm.matrix:
                 return `matrix<${tname}>[${this.rows}r][${this.cols}c]`;
+            case DdbForm.tensor:
+                return `tensor<${generate_array_type(DdbType[this.value.data_type], this.value.shape)}>`;
             default:
                 return `${DdbForm[this.form]} ${tname}`;
         }
@@ -3343,6 +3500,13 @@ function set_big_uint_128(dataView, byte_offset, value, le = true) {
 function set_big_int_128(dataview, byte_offset, value, le = true) {
     set_big_uint_128(dataview, byte_offset, value, le);
 }
+function generate_array_type(baseType, dimensions) {
+    let result = baseType;
+    dimensions.forEach(dimension => {
+        result += `[${dimension}]`;
+    });
+    return result;
+}
 // 大端
 // const dataBE = new ArrayBuffer(16)
 // const dataViewBE = new DataView(dataBE)