dolphindb 0.0.3 → 0.0.4

package/README.md

@@ -13,61 +13,61 @@
     </a>
 </p>
 
-## 中文 | [English](./README.en.md)
+## English | [中文](./README.zh.md)
 
-## 简介
-DolphinDB JavaScript API 是一个 JavaScript 库，封装了操作 DolphinDB 数据库的能力，如：连接数据库、执行脚本、调用函数、上传变量等
+## Overview
+DolphinDB JavaScript API is a JavaScript library that encapsulates the ability to operate the DolphinDB database, such as: connecting to the database, executing scripts, calling functions, uploading variables, etc.
 
 https://www.npmjs.com/package/dolphindb
 
-## 特性
-- 使用 WebSocket 与 DolphinDB 数据库通信，用二进制格式进行数据交换
-- 支持在浏览器环境和 Node.js 环境中运行
-- 使用了 JavaScript 中的 Int32Array 等 TypedArray 处理二进制数据，性能较高
-- 单次调用支持最大 2 GB 数据的序列化上传，下载数据量不受限制
+## Features
+- Communicate with DolphinDB database using WebSocket, exchange data in binary format
+- Support running in browser environment and Node.js environment
+- Use TypedArray such as Int32Array in JavaScript to process binary data, with high performance
+- A single call supports serialized upload of up to 2GB of data, and the amount of downloaded data is not limited
 
-## 安装
+## Installation
 ```bash
-# 在机器上安装最新版的 Node.js 及浏览器
+# Install the latest version of Node.js and browser on the machine
 
-# 在项目中安装 npm 包
+# Install npm packages in your project
 npm install dolphindb
 ```
 
-## 用法
-### 0. 初始化并连接到 DolphinDB
+## Usage
+### 0. Initialize and connect to DolphinDB
 ```ts
 import DDB from 'dolphindb'
 
-// 创建数据库对象，初始化 WebSocket 连接地址
+// Create a database object and initialize the WebSocket URL
 let ddb = new DDB('ws://127.0.0.1:8848')
 
-// 建立到 DolphinDB 的 WebSocket 连接（要求 DolphinDB 数据库版本不低于 1.30.16 或 2.00.4）
+// Establish a WebSocket connection to DolphinDB (requires DolphinDB database version at least 1.30.16 or 2.00.4)
 await ddb.connect()
 ```
 
-#### connect 方法声明
+#### Connect Method Declaration
 ```ts
 async connect (
     options?: {
-        /** 默认使用实例初始化时传入的 WebSocket 链接 */
+        /** by default, the WebSocket URL passed in when the instance is initialized is used */
         ws_url?: string
         
-        /** 是否在建立连接后自动登录，默认 true */
+        /** whether to automatically log in after the connection is established, the default is true */
         login?: boolean
         
-        /** DolphinDB 登录用户名 */
+        /** DolphinDB username */
         username?: string
         
-        /** DolphinDB 登录密码 */
+        /** DolphinDB password */
         password?: string
     } = { }
 ): Promise<void>
 ```
 
 
-### 1. 调用函数
-#### 例子
+### 1. Call Functions
+#### Example
 ```ts
 import { DdbInt } from 'dolphindb'
 
@@ -76,52 +76,52 @@ const result = await ddb.call<DdbInt>('add', [new DdbInt(1), new DdbInt(1)])
 console.log(result.value === 2)  // true
 ```
 
-#### DolphinDB JavaScript API 用 DdbObj 对象来表示 DolphinDB 中的数据类型
-上面例子中，上传了两个参数 1 (对应 DolphinDB 中的 int 类型) 到 DolphinDB 数据库，作为 add 函数的参数，并接收函数调用的结果 result
+#### The DolphinDB JavaScript API uses DdbObj objects to represent data types in DolphinDB
+In the above example, two parameters 1 (corresponding to the int type in DolphinDB) are uploaded to the DolphinDB database as parameters of the add function, then the result of the function call is received.
 
-`<DdbInt>` 用于 TypeScript 推断返回值的类型
+`<DdbInt>` is used by TypeScript to infer the type of the return value
 
-- result 是一个 `DdbInt`，也是 `DdbObj<number>`
-- result.form 是 `DdbForm.scalar`
-- result.type 是 `DdbType.int`
-- result.value 是 JavaScript 中原生的 `number` (int 的取值范围及精度可以用 JavaScript 的 number 准确表示)
+- result is a `DdbInt`, which is also a `DdbObj<number>`
+- result.form is a `DdbForm.scalar`
+- result.type is a `DdbType.int`
+- result.value is native `number` in JavaScript (the value range and precision of int can be accurately represented by JavaScript number)
 
 ```ts
-/** 可以表示所有 DolphinDB 数据库中的数据类型 */
+/** Can represent all data types in DolphinDB databases */
 class DdbObj <T extends DdbValue = DdbValue> {
-    /** 是否为小端 (little endian) */
+    /** is it little endian */
     le: boolean
     
-    /** 数据形式 https://www.dolphindb.cn/cn/help/DataTypesandStructures/DataForms/index.html */
+    /** data form https://www.dolphindb.cn/cn/help/DataTypesandStructures/DataForms/index.html */
     form: DdbForm
     
-    /** 数据类型 https://www.dolphindb.cn/cn/help/DataTypesandStructures/DataTypes/index.html */
+    /** data type  https://www.dolphindb.cn/cn/help/DataTypesandStructures/DataTypes/index.html */
     type: DdbType
     
-    /** 占用 parse 时传入的 buf 的长度 */
+    /** consumed length in buf parsed */
     length: number
     
     /** table name / column name */
     name?: string
     
     /**
-        最低维、第 1 维
+        Lowest dimension
         - vector: rows = n, cols = 1
         - pair:   rows = 2, cols = 1
         - matrix: rows = n, cols = m
-        - set:    同 vector
-        - dict:   包含 keys, values 向量
-        - table:  同 matrix
+        - set:    the same as vector
+        - dict:   include keys, values vector
+        - table:  the same as matrix
     */
     rows?: number
     
-    /** 第 2 维 */
+    /** 2nd dimension */
     cols?: number
     
-    /** matrix 中值的类型，仅 matrix 才有 */
+    /** the type of the value in matrix (only matrix has this field) */
     datatype?: DdbType
     
-    /** 实际数据。不同的 DdbForm, DdbType 使用 DdbValue 中不同的类型来表示实际数据 */
+    /** the actual data. Different DdbForm, DdbType use different types in DdbValue to represent actual data */
     value: T
     
     constructor (data: Partial<DdbObj> & { form: DdbForm, type: DdbType, length: number }) {
@@ -140,7 +140,7 @@ class DdbInt extends DdbObj<number> {
     }
 }
 
-// ... 还有很多快捷类，如 DdbString, DdbLong, DdbDouble, DdbVectorDouble, DdbVectorAny 等
+// ... There are also many utility classes, such as DdbString, DdbLong, DdbDouble, DdbVectorDouble, DdbVectorAny, etc.
 
 type DdbValue = 
     null | boolean | number | [number, number] | bigint | string | string[] | 
@@ -178,38 +178,38 @@ enum DdbType {
 }
 ```
 
-#### `call` 方法声明
+#### `call` Method Declaration
 ```ts
 async call <T extends DdbObj> (
-    /** 函数名 */
+    /** function name */
     func: string,
     
-    /** 调用参数 (传入的原生 string 和 boolean 会被自动转换为 DdbObj<string> 和 DdbObj<boolean>) */
+    /** function arguments (The incoming native string and boolean will be automatically converted to DdbObj<string> and DdbObj<boolean>) */
     args?: (DdbObj | string | boolean)[] = [ ],
     
-    /** 调用选项 */
+    /** calling options */
     options?: {
-        /** 紧急 flag。使用 urgent worker 执行，防止被其它作业阻塞 */
+        /** Urgent flag. Use urgent worker to execute to prevent being blocked by other jobs */
         urgent?: boolean
         
-        /** 设置结点 alias 时发送到集群中对应的结点执行 (使用 DolphinDB 中的 rpc 方法) */
+        /** When the node alias is set, the function is sent to the corresponding node in the cluster for execution (using the rpc method in DolphinDB) */
         node?: string
         
-        /** 设置多个结点 alias 时发送到集群中对应的多个结点执行 (使用 DolphinDB 中的 pnodeRun 方法) */
+        /** When setting multiple node aliases, send them to the corresponding multiple nodes in the cluster for execution (using the pnodeRun method in DolphinDB) */
         nodes?: string[]
         
-        /** 设置 node 参数时必传，需指定函数类型，其它情况下不传 */
+        /** It must be passed when setting the node parameter, the function type needs to be specified, and it is not passed in other cases */
         func_type?: DdbFunctionType
         
-        /** 设置 nodes 参数时选传，其它情况不传 */
+        /** It may be  passed when setting the nodes parameter, otherwise may not be passed */
         add_node_alias?: boolean
     } = { }
 ): Promise<T>
 ```
 
 
-### 2. 执行脚本
-#### 例子
+### 2. Execute Script
+#### Example
 ```ts
 import type { DdbLong } from 'dolphindb'
 
@@ -223,34 +223,34 @@ const result = await ddb.eval<DdbLong>(
 console.log(result.value === 2n)  // true
 ```
 
-上面例子中，通过字符串上传了一段脚本到 DolphinDB 数据库执行，并接收最后一条语句 `foo(1l, 1l)` 执行结果 result
+In the above example, a script is uploaded through a string to the DolphinDB database for execution, and the execution result of the last statement `foo(1l, 1l)` is received.
 
-`<DdbLong>` 用于 TypeScript 推断返回值的类型
+`<DdbLong>` is used by TypeScript to infer the type of the return value
 
-- result 是一个 `DdbLong`，也是 `DdbObj<bigint>`
-- result.form 是 `DdbForm.scalar`
-- result.type 是 `DdbType.long`
-- result.value 是 JavaScript 中原生的 `bigint` (long 的精度不能用 JavaScript 的 number 准确表示，但可以用 bigint 表示)
+- result is a `DdbLong`, which is also a `DdbObj<bigint>`
+- result.form is `DdbForm.scalar`
+- result.type is `DdbType.long`
+- result.value is the native `bigint` in JavaScript (the precision of long cannot be accurately represented by JavaScript number, but it can be represented by bigint)
 
-只要 WebSocket 连接不断开，在后续的会话中 `foo` 这个自定义函数会一直存在，可复用，比如后续通过 `await ddb.call<DdbInt>('foo', [new DdbInt(1), new DdbInt(1)])` 调用这个自定义函数
+As long as the WebSocket connection is not disconnected, the custom function `foo` will always exist in the subsequent session and can be reused, for example, you can use `await ddb.call<DdbInt>('foo', [new DdbInt(1), new DdbInt(1)])` to call this custom function
 
-#### `eval` 方法声明
+#### `eval` Method Declaration
 ```ts
 async eval <T extends DdbObj> (
-    /** 执行的脚本 */
+    /** the script to execute */
     script: string,
     
-    /** 执行选项 */
+    /** calling options */
     options: {
-        /** 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞 */
+        /** Urgent flag. Use urgent worker to execute to prevent being blocked by other jobs */
         urgent?: boolean
     } = { }
 ): Promise<T>
 ```
 
 
-### 3. 上传变量
-#### 例子
+### 3. Upload Variables
+#### Example
 ```ts
 import { DdbVectorDouble } from 'dolphindb'
 
@@ -260,17 +260,17 @@ a.fill(1.0)
 ddb.upload(['bar1', 'bar2'], [new DdbVectorDouble(a), new DdbVectorDouble(a)])
 ```
 
-上面的例子中，上传了 `bar1`, `bar2` 两个变量，变量值是长度为 10000 的 double 向量
+In the above example, two variables `bar1`, `bar2` are uploaded, and the variable value is a double vector of length 10000
 
-只要 WebSocket 连接不断开，在后续的会话中 `bar1`, `bar2` 这些变量会一直存在，可复用
+As long as the WebSocket connection is not disconnected, the variables `bar1`, `bar2` will always exist in the subsequent session and can be reused
 
-#### `upload` 方法声明
+#### `upload` Method Declaration
 ```ts
 async upload (
-    /** 上传的变量名 */
+    /** variable names */
     vars: string[],
     
-    /** 上传的变量值 */
+    /** variable values */
     args: (DdbObj | string | boolean)[]
 ): Promise<void>
 ```

package/README.zh.md

@@ -0,0 +1,277 @@
+# DolphinDB JavaScript API
+
+<p align='center'>
+    <img src='./ddb.svg' alt='DolphinDB' width='256'>
+</p>
+
+<p align='center'>
+    <a href='https://www.npmjs.com/package/dolphindb' target='_blank'>
+        <img alt='npm version' src='https://img.shields.io/npm/v/dolphindb.svg?style=flat-square&color=brightgreen' />
+    </a>
+    <a href='https://www.npmjs.com/package/dolphindb' target='_blank'>
+        <img alt='npm downloads' src='https://img.shields.io/npm/dt/dolphindb?style=flat-square&color=brightgreen' />
+    </a>
+</p>
+
+## [English](./README.md) | 中文
+
+## 简介
+DolphinDB JavaScript API 是一个 JavaScript 库，封装了操作 DolphinDB 数据库的能力，如：连接数据库、执行脚本、调用函数、上传变量等
+
+https://www.npmjs.com/package/dolphindb
+
+## 特性
+- 使用 WebSocket 与 DolphinDB 数据库通信，用二进制格式进行数据交换
+- 支持在浏览器环境和 Node.js 环境中运行
+- 使用了 JavaScript 中的 Int32Array 等 TypedArray 处理二进制数据，性能较高
+- 单次调用支持最大 2 GB 数据的序列化上传，下载数据量不受限制
+
+## 安装
+```bash
+# 在机器上安装最新版的 Node.js 及浏览器
+
+# 在项目中安装 npm 包
+npm install dolphindb
+```
+
+## 用法
+### 0. 初始化并连接到 DolphinDB
+```ts
+import DDB from 'dolphindb'
+
+// 创建数据库对象，初始化 WebSocket 连接地址
+let ddb = new DDB('ws://127.0.0.1:8848')
+
+// 建立到 DolphinDB 的 WebSocket 连接（要求 DolphinDB 数据库版本不低于 1.30.16 或 2.00.4）
+await ddb.connect()
+```
+
+#### connect 方法声明
+```ts
+async connect (
+    options?: {
+        /** 默认使用实例初始化时传入的 WebSocket 链接 */
+        ws_url?: string
+        
+        /** 是否在建立连接后自动登录，默认 true */
+        login?: boolean
+        
+        /** DolphinDB 登录用户名 */
+        username?: string
+        
+        /** DolphinDB 登录密码 */
+        password?: string
+    } = { }
+): Promise<void>
+```
+
+
+### 1. 调用函数
+#### 例子
+```ts
+import { DdbInt } from 'dolphindb'
+
+const result = await ddb.call<DdbInt>('add', [new DdbInt(1), new DdbInt(1)])
+
+console.log(result.value === 2)  // true
+```
+
+#### DolphinDB JavaScript API 用 DdbObj 对象来表示 DolphinDB 中的数据类型
+上面例子中，上传了两个参数 1 (对应 DolphinDB 中的 int 类型) 到 DolphinDB 数据库，作为 add 函数的参数，并接收函数调用的结果 result
+
+`<DdbInt>` 用于 TypeScript 推断返回值的类型
+
+- result 是一个 `DdbInt`，也是 `DdbObj<number>`
+- result.form 是 `DdbForm.scalar`
+- result.type 是 `DdbType.int`
+- result.value 是 JavaScript 中原生的 `number` (int 的取值范围及精度可以用 JavaScript 的 number 准确表示)
+
+```ts
+/** 可以表示所有 DolphinDB 数据库中的数据类型 */
+class DdbObj <T extends DdbValue = DdbValue> {
+    /** 是否为小端 (little endian) */
+    le: boolean
+    
+    /** 数据形式 https://www.dolphindb.cn/cn/help/DataTypesandStructures/DataForms/index.html */
+    form: DdbForm
+    
+    /** 数据类型 https://www.dolphindb.cn/cn/help/DataTypesandStructures/DataTypes/index.html */
+    type: DdbType
+    
+    /** 占用 parse 时传入的 buf 的长度 */
+    length: number
+    
+    /** table name / column name */
+    name?: string
+    
+    /**
+        最低维、第 1 维
+        - vector: rows = n, cols = 1
+        - pair:   rows = 2, cols = 1
+        - matrix: rows = n, cols = m
+        - set:    同 vector
+        - dict:   包含 keys, values 向量
+        - table:  同 matrix
+    */
+    rows?: number
+    
+    /** 第 2 维 */
+    cols?: number
+    
+    /** matrix 中值的类型，仅 matrix 才有 */
+    datatype?: DdbType
+    
+    /** 实际数据。不同的 DdbForm, DdbType 使用 DdbValue 中不同的类型来表示实际数据 */
+    value: T
+    
+    constructor (data: Partial<DdbObj> & { form: DdbForm, type: DdbType, length: number }) {
+        Object.assign(this, data)
+    }
+}
+
+class DdbInt extends DdbObj<number> {
+    constructor (value: number) {
+        super({
+            form: DdbForm.scalar,
+            type: DdbType.int,
+            length: 4,
+            value
+        })
+    }
+}
+
+// ... 还有很多快捷类，如 DdbString, DdbLong, DdbDouble, DdbVectorDouble, DdbVectorAny 等
+
+type DdbValue = 
+    null | boolean | number | [number, number] | bigint | string | string[] | 
+    Uint8Array | Int16Array | Int32Array | Float32Array | Float64Array | BigInt64Array | Uint8Array[] | 
+    DdbObj[] | DdbFunctionDefValue | DdbSymbolExtendedValue
+    
+
+enum DdbForm {
+    scalar = 0,
+    vector = 1,
+    pair = 2,
+    matrix = 3,
+    set = 4,
+    dict = 5,
+    table = 6,
+    chart = 7,
+    chunk = 8,
+}
+
+
+enum DdbType {
+    void = 0,
+    bool = 1,
+    char = 2,
+    short = 3,
+    int = 4,
+    long = 5,
+    // ...
+    timestamp = 12,
+    // ...
+    double = 16,
+    symbol = 17,
+    string = 18,
+    // ...
+}
+```
+
+#### `call` 方法声明
+```ts
+async call <T extends DdbObj> (
+    /** 函数名 */
+    func: string,
+    
+    /** 调用参数 (传入的原生 string 和 boolean 会被自动转换为 DdbObj<string> 和 DdbObj<boolean>) */
+    args?: (DdbObj | string | boolean)[] = [ ],
+    
+    /** 调用选项 */
+    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
+    } = { }
+): Promise<T>
+```
+
+
+### 2. 执行脚本
+#### 例子
+```ts
+import type { DdbLong } from 'dolphindb'
+
+const result = await ddb.eval<DdbLong>(
+    'def foo (a, b) {\n' +
+    '    return a + b\n' +
+    '}\n' +
+    'foo(1l, 1l)\n'
+)
+
+console.log(result.value === 2n)  // true
+```
+
+上面例子中，通过字符串上传了一段脚本到 DolphinDB 数据库执行，并接收最后一条语句 `foo(1l, 1l)` 执行结果 result
+
+`<DdbLong>` 用于 TypeScript 推断返回值的类型
+
+- result 是一个 `DdbLong`，也是 `DdbObj<bigint>`
+- result.form 是 `DdbForm.scalar`
+- 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` 方法声明
+```ts
+async eval <T extends DdbObj> (
+    /** 执行的脚本 */
+    script: string,
+    
+    /** 执行选项 */
+    options: {
+        /** 紧急 flag，确保提交的脚本使用 urgent worker 处理，防止被其它作业阻塞 */
+        urgent?: boolean
+    } = { }
+): Promise<T>
+```
+
+
+### 3. 上传变量
+#### 例子
+```ts
+import { DdbVectorDouble } from 'dolphindb'
+
+let a = new Array(10000)
+a.fill(1.0)
+
+ddb.upload(['bar1', 'bar2'], [new DdbVectorDouble(a), new DdbVectorDouble(a)])
+```
+
+上面的例子中，上传了 `bar1`, `bar2` 两个变量，变量值是长度为 10000 的 double 向量
+
+只要 WebSocket 连接不断开，在后续的会话中 `bar1`, `bar2` 这些变量会一直存在，可复用
+
+#### `upload` 方法声明
+```ts
+async upload (
+    /** 上传的变量名 */
+    vars: string[],
+    
+    /** 上传的变量值 */
+    args: (DdbObj | string | boolean)[]
+): Promise<void>
+```
+

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "dolphindb",
     "description": "DolphinDB JavaScript API",
-    "version": "0.0.3",
+    "version": "0.0.4",
     "type": "commonjs",
     "main": "./index.js",
     "browser": "./browser.js",

package/README.en.md

@@ -1,277 +0,0 @@
-# DolphinDB JavaScript API
-
-<p align='center'>
-    <img src='./ddb.svg' alt='DolphinDB' width='256'>
-</p>
-
-<p align='center'>
-    <a href='https://www.npmjs.com/package/dolphindb' target='_blank'>
-        <img alt='npm version' src='https://img.shields.io/npm/v/dolphindb.svg?style=flat-square&color=brightgreen' />
-    </a>
-    <a href='https://www.npmjs.com/package/dolphindb' target='_blank'>
-        <img alt='npm downloads' src='https://img.shields.io/npm/dt/dolphindb?style=flat-square&color=brightgreen' />
-    </a>
-</p>
-
-## [中文](./README.md) | English
-
-## Overview
-DolphinDB JavaScript API is a JavaScript library that encapsulates the ability to operate the DolphinDB database, such as: connecting to the database, executing scripts, calling functions, uploading variables, etc.
-
-https://www.npmjs.com/package/dolphindb
-
-## Features
-- Communicate with DolphinDB database using WebSocket, exchange data in binary format
-- Support running in browser environment and Node.js environment
-- Use TypedArray such as Int32Array in JavaScript to process binary data, with high performance
-- A single call supports serialized upload of up to 2GB of data, and the amount of downloaded data is not limited
-
-## Installation
-```bash
-# Install the latest version of Node.js and browser on the machine
-
-# Install npm packages in your project
-npm install dolphindb
-```
-
-## Usage
-### 0. Initialize and connect to DolphinDB
-```ts
-import DDB from 'dolphindb'
-
-// Create a database object and initialize the WebSocket URL
-let ddb = new DDB('ws://127.0.0.1:8848')
-
-// Establish a WebSocket connection to DolphinDB (requires DolphinDB database version at least 1.30.16 or 2.00.4)
-await ddb.connect()
-```
-
-#### Connect Method Declaration
-```ts
-async connect (
-    options?: {
-        /** by default, the WebSocket URL passed in when the instance is initialized is used */
-        ws_url?: string
-        
-        /** whether to automatically log in after the connection is established, the default is true */
-        login?: boolean
-        
-        /** DolphinDB username */
-        username?: string
-        
-        /** DolphinDB password */
-        password?: string
-    } = { }
-): Promise<void>
-```
-
-
-### 1. Call Functions
-#### Example
-```ts
-import { DdbInt } from 'dolphindb'
-
-const result = await ddb.call<DdbInt>('add', [new DdbInt(1), new DdbInt(1)])
-
-console.log(result.value === 2)  // true
-```
-
-#### The DolphinDB JavaScript API uses DdbObj objects to represent data types in DolphinDB
-In the above example, two parameters 1 (corresponding to the int type in DolphinDB) are uploaded to the DolphinDB database as parameters of the add function, then the result of the function call is received.
-
-`<DdbInt>` is used by TypeScript to infer the type of the return value
-
-- result is a `DdbInt`, which is also a `DdbObj<number>`
-- result.form is a `DdbForm.scalar`
-- result.type is a `DdbType.int`
-- result.value is native `number` in JavaScript (the value range and precision of int can be accurately represented by JavaScript number)
-
-```ts
-/** Can represent all data types in DolphinDB databases */
-class DdbObj <T extends DdbValue = DdbValue> {
-    /** is it little endian */
-    le: boolean
-    
-    /** data form https://www.dolphindb.cn/cn/help/DataTypesandStructures/DataForms/index.html */
-    form: DdbForm
-    
-    /** data type  https://www.dolphindb.cn/cn/help/DataTypesandStructures/DataTypes/index.html */
-    type: DdbType
-    
-    /** consumed length in buf parsed */
-    length: number
-    
-    /** table name / column name */
-    name?: string
-    
-    /**
-        Lowest dimension
-        - vector: rows = n, cols = 1
-        - pair:   rows = 2, cols = 1
-        - matrix: rows = n, cols = m
-        - set:    the same as vector
-        - dict:   include keys, values vector
-        - table:  the same as matrix
-    */
-    rows?: number
-    
-    /** 2nd dimension */
-    cols?: number
-    
-    /** the type of the value in matrix (only matrix has this field) */
-    datatype?: DdbType
-    
-    /** the actual data. Different DdbForm, DdbType use different types in DdbValue to represent actual data */
-    value: T
-    
-    constructor (data: Partial<DdbObj> & { form: DdbForm, type: DdbType, length: number }) {
-        Object.assign(this, data)
-    }
-}
-
-class DdbInt extends DdbObj<number> {
-    constructor (value: number) {
-        super({
-            form: DdbForm.scalar,
-            type: DdbType.int,
-            length: 4,
-            value
-        })
-    }
-}
-
-// ... There are also many utility classes, such as DdbString, DdbLong, DdbDouble, DdbVectorDouble, DdbVectorAny, etc.
-
-type DdbValue = 
-    null | boolean | number | [number, number] | bigint | string | string[] | 
-    Uint8Array | Int16Array | Int32Array | Float32Array | Float64Array | BigInt64Array | Uint8Array[] | 
-    DdbObj[] | DdbFunctionDefValue | DdbSymbolExtendedValue
-    
-
-enum DdbForm {
-    scalar = 0,
-    vector = 1,
-    pair = 2,
-    matrix = 3,
-    set = 4,
-    dict = 5,
-    table = 6,
-    chart = 7,
-    chunk = 8,
-}
-
-
-enum DdbType {
-    void = 0,
-    bool = 1,
-    char = 2,
-    short = 3,
-    int = 4,
-    long = 5,
-    // ...
-    timestamp = 12,
-    // ...
-    double = 16,
-    symbol = 17,
-    string = 18,
-    // ...
-}
-```
-
-#### `call` Method Declaration
-```ts
-async call <T extends DdbObj> (
-    /** function name */
-    func: string,
-    
-    /** function arguments (The incoming native string and boolean will be automatically converted to DdbObj<string> and DdbObj<boolean>) */
-    args?: (DdbObj | string | boolean)[] = [ ],
-    
-    /** calling options */
-    options?: {
-        /** Urgent flag. Use urgent worker to execute to prevent being blocked by other jobs */
-        urgent?: boolean
-        
-        /** When the node alias is set, the function is sent to the corresponding node in the cluster for execution (using the rpc method in DolphinDB) */
-        node?: string
-        
-        /** When setting multiple node aliases, send them to the corresponding multiple nodes in the cluster for execution (using the pnodeRun method in DolphinDB) */
-        nodes?: string[]
-        
-        /** It must be passed when setting the node parameter, the function type needs to be specified, and it is not passed in other cases */
-        func_type?: DdbFunctionType
-        
-        /** It may be  passed when setting the nodes parameter, otherwise may not be passed */
-        add_node_alias?: boolean
-    } = { }
-): Promise<T>
-```
-
-
-### 2. Execute Script
-#### Example
-```ts
-import type { DdbLong } from 'dolphindb'
-
-const result = await ddb.eval<DdbLong>(
-    'def foo (a, b) {\n' +
-    '    return a + b\n' +
-    '}\n' +
-    'foo(1l, 1l)\n'
-)
-
-console.log(result.value === 2n)  // true
-```
-
-In the above example, a script is uploaded through a string to the DolphinDB database for execution, and the execution result of the last statement `foo(1l, 1l)` is received.
-
-`<DdbLong>` is used by TypeScript to infer the type of the return value
-
-- result is a `DdbLong`, which is also a `DdbObj<bigint>`
-- result.form is `DdbForm.scalar`
-- result.type is `DdbType.long`
-- result.value is the native `bigint` in JavaScript (the precision of long cannot be accurately represented by JavaScript number, but it can be represented by bigint)
-
-As long as the WebSocket connection is not disconnected, the custom function `foo` will always exist in the subsequent session and can be reused, for example, you can use `await ddb.call<DdbInt>('foo', [new DdbInt(1), new DdbInt(1)])` to call this custom function
-
-#### `eval` Method Declaration
-```ts
-async eval <T extends DdbObj> (
-    /** the script to execute */
-    script: string,
-    
-    /** calling options */
-    options: {
-        /** Urgent flag. Use urgent worker to execute to prevent being blocked by other jobs */
-        urgent?: boolean
-    } = { }
-): Promise<T>
-```
-
-
-### 3. Upload Variables
-#### Example
-```ts
-import { DdbVectorDouble } from 'dolphindb'
-
-let a = new Array(10000)
-a.fill(1.0)
-
-ddb.upload(['bar1', 'bar2'], [new DdbVectorDouble(a), new DdbVectorDouble(a)])
-```
-
-In the above example, two variables `bar1`, `bar2` are uploaded, and the variable value is a double vector of length 10000
-
-As long as the WebSocket connection is not disconnected, the variables `bar1`, `bar2` will always exist in the subsequent session and can be reused
-
-#### `upload` Method Declaration
-```ts
-async upload (
-    /** variable names */
-    vars: string[],
-    
-    /** variable values */
-    args: (DdbObj | string | boolean)[]
-): Promise<void>
-```
-