{"id":47845296,"url":"https://github.com/dolphindb/api-go","last_synced_at":"2026-04-03T21:10:12.786Z","repository":{"id":50301222,"uuid":"210348142","full_name":"dolphindb/api-go","owner":"dolphindb","description":null,"archived":false,"fork":false,"pushed_at":"2026-04-02T09:25:37.000Z","size":30337,"stargazers_count":20,"open_issues_count":2,"forks_count":1,"subscribers_count":8,"default_branch":"dev","last_synced_at":"2026-04-03T00:24:06.169Z","etag":null,"topics":["dolphindb","golang"],"latest_commit_sha":null,"homepage":null,"language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/dolphindb.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2019-09-23T12:20:42.000Z","updated_at":"2026-04-02T09:24:21.000Z","dependencies_parsed_at":"2023-12-15T04:23:15.019Z","dependency_job_id":"9b43fe63-67a5-4de9-aa7c-96c5a50e54a4","html_url":"https://github.com/dolphindb/api-go","commit_stats":null,"previous_names":[],"tags_count":15,"template":false,"template_full_name":null,"purl":"pkg:github/dolphindb/api-go","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dolphindb%2Fapi-go","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dolphindb%2Fapi-go/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dolphindb%2Fapi-go/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dolphindb%2Fapi-go/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/dolphindb","download_url":"https://codeload.github.com/dolphindb/api-go/tar.gz/refs/heads/dev","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dolphindb%2Fapi-go/sbom","scorecard":{"id":350180,"data":{"date":"2025-08-11","repo":{"name":"github.com/dolphindb/api-go","commit":"ddb39b93f6c688ff0483a350e3ba37ce1509ee6d"},"scorecard":{"version":"v5.2.1-40-gf6ed084d","commit":"f6ed084d17c9236477efd66e5b258b9d4cc7b389"},"score":2.7,"checks":[{"name":"Code-Review","score":0,"reason":"Found 0/30 approved changesets -- score normalized to 0","details":null,"documentation":{"short":"Determines if the project requires human code review before pull requests (aka merge requests) are merged.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#code-review"}},{"name":"Dangerous-Workflow","score":-1,"reason":"no workflows found","details":null,"documentation":{"short":"Determines if the project's GitHub Action workflows avoid dangerous patterns.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#dangerous-workflow"}},{"name":"Token-Permissions","score":-1,"reason":"No tokens found","details":null,"documentation":{"short":"Determines if the project's workflows follow the principle of least privilege.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#token-permissions"}},{"name":"Packaging","score":-1,"reason":"packaging workflow not detected","details":["Warn: no GitHub/GitLab publishing workflow detected."],"documentation":{"short":"Determines if the project is published as a package that others can easily download, install, easily update, and uninstall.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#packaging"}},{"name":"Maintained","score":0,"reason":"0 commit(s) and 0 issue activity found in the last 90 days -- score normalized to 0","details":null,"documentation":{"short":"Determines if the project is \"actively maintained\".","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#maintained"}},{"name":"SAST","score":0,"reason":"no SAST tool detected","details":["Warn: no pull requests merged into dev branch"],"documentation":{"short":"Determines if the project uses static code analysis.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#sast"}},{"name":"Binary-Artifacts","score":10,"reason":"no binaries found in the repo","details":null,"documentation":{"short":"Determines if the project has generated executable (binary) artifacts in the source repository.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#binary-artifacts"}},{"name":"CII-Best-Practices","score":0,"reason":"no effort to earn an OpenSSF best practices badge detected","details":null,"documentation":{"short":"Determines if the project has an OpenSSF (formerly CII) Best Practices Badge.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#cii-best-practices"}},{"name":"Security-Policy","score":0,"reason":"security policy file not detected","details":["Warn: no security policy file detected","Warn: no security file to analyze","Warn: no security file to analyze","Warn: no security file to analyze"],"documentation":{"short":"Determines if the project has published a security policy.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#security-policy"}},{"name":"Pinned-Dependencies","score":-1,"reason":"no dependencies found","details":null,"documentation":{"short":"Determines if the project has declared and pinned the dependencies of its build process.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#pinned-dependencies"}},{"name":"Fuzzing","score":0,"reason":"project is not fuzzed","details":["Warn: no fuzzer integrations found"],"documentation":{"short":"Determines if the project uses fuzzing.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#fuzzing"}},{"name":"License","score":10,"reason":"license file detected","details":["Info: project has a license file: LICENSE:0","Info: FSF or OSI recognized license: Apache License 2.0: LICENSE:0"],"documentation":{"short":"Determines if the project has defined a license.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#license"}},{"name":"Signed-Releases","score":-1,"reason":"no releases found","details":null,"documentation":{"short":"Determines if the project cryptographically signs release artifacts.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#signed-releases"}},{"name":"Vulnerabilities","score":7,"reason":"3 existing vulnerabilities detected","details":["Warn: Project is vulnerable to: GO-2023-2402 / GHSA-45x7-px36-x8w8","Warn: Project is vulnerable to: GO-2024-3321 / GHSA-v778-237x-gjrc","Warn: Project is vulnerable to: GO-2025-3487 / GHSA-hcg3-q754-cr77"],"documentation":{"short":"Determines if the project has open, known unfixed vulnerabilities.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#vulnerabilities"}},{"name":"Branch-Protection","score":0,"reason":"branch protection not enabled on development/release branches","details":["Warn: branch protection not enabled for branch 'dev'","Warn: branch protection not enabled for branch 'master'"],"documentation":{"short":"Determines if the default and release branches are protected with GitHub's branch protection settings.","url":"https://github.com/ossf/scorecard/blob/f6ed084d17c9236477efd66e5b258b9d4cc7b389/docs/checks.md#branch-protection"}}]},"last_synced_at":"2025-08-18T08:08:46.987Z","repository_id":50301222,"created_at":"2025-08-18T08:08:46.987Z","updated_at":"2025-08-18T08:08:46.987Z"},"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31377619,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-03T17:53:18.093Z","status":"ssl_error","status_checked_at":"2026-04-03T17:53:17.617Z","response_time":107,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["dolphindb","golang"],"created_at":"2026-04-03T21:10:08.362Z","updated_at":"2026-04-03T21:10:12.778Z","avatar_url":"https://github.com/dolphindb.png","language":"Go","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003ch1 align=\"center\"\u003eDolphinDB Go API\u003c/h1\u003e\n\n[![GitHub release](https://img.shields.io/github/release/dolphindb/api-go.svg?style=flat-square)](https://github.com/dolphindb/api-go/v3/releases/latest)\n[![PkgGoDev](https://img.shields.io/badge/go.dev-docs-007d9c?style=flat-square\u0026logo=go\u0026logoColor=white)](https://pkg.go.dev/github.com/dolphindb/api-go/v3)\n\n欢迎使用 DolphinDB Go API。您可以使用 Go API 连接 DolphinDB 数据库，进行建库建表，以及读取、写入数据等操作。\n\n- [1. Go API 概述](#1-go-api-概述)\n- [2. 安装依赖](#2-安装依赖)\n- [3. DolphinDB 基本用法](#3-dolphindb-基本用法)\n  - [3.1. 初始化 DolphinDB](#31-初始化-dolphindb)\n    - [3.1.1. NewDolphinDBClient 初始化 DolphinDB](#311-newdolphindbclient-初始化-dolphindb)\n    - [3.1.2. NewSimpleDolphinDBClient 初始化 DolphinDB](#312-newsimpledolphindbclient-初始化-dolphindb)\n  - [3.2. 通过 API 建库建表](#32-通过-api-建库建表)\n  - [3.3. 基础函数使用](#33-基础函数使用)\n    - [3.3.1. 构造数据类型](#331-构造数据类型)\n      - [3.3.1.1. NewDataType 入参对照表](#3311-newdatatype-入参对照表)\n      - [3.3.1.2. NewDataTypeListFromRawData 入参对照表](#3312-newdatatypelistfromrawdata-入参对照表)\n      - [3.3.1.3 Null 值对照表](#3313-null-值对照表)\n    - [3.3.2. 完整示例](#332-完整示例)\n  - [3.4. 初始化 DBConnectionPool](#34-初始化-dbconnectionpool)\n- [4. 读写 DolphinDB 数据表](#4-读写-dolphindb-数据表)\n  - [4.1. 保存数据到 DolphinDB 数据表](#41-保存数据到-dolphindb-数据表)\n    - [4.1.1. 同步追加数据](#411-同步追加数据)\n      - [4.1.1.1. 使用 `insert into` 追加单行数据](#4111-使用-insert-into-追加单行数据)\n      - [4.1.1.2. 使用 `tableInsert` 函数向表中批量追加数组对象](#4112-使用-tableinsert-函数向表中批量追加数组对象)\n      - [4.1.1.3. 使用 `tableInsert` 函数向表中追加 `Table` 对象](#4113-使用-tableinsert-函数向表中追加-table-对象)\n    - [4.1.2. 异步追加数据](#412-异步追加数据)\n      - [4.1.2.1. 数据表的并发写入](#4121-数据表的并发写入)\n  - [4.2. 读取和使用数据表](#42-读取和使用数据表)\n    - [4.2.1. 读取数据表](#421-读取数据表)\n    - [4.2.2. 使用 Table 对象](#422-使用-table-对象)\n  - [4.3. 批量异步追加数据](#43-批量异步追加数据)\n    - [4.3.1. MultiGoroutineTable](#431-multigoroutinetable)\n    - [Insert](#insert)\n    - [GetUnwrittenData](#getunwrittendata)\n    - [InsertUnwrittenData](#insertunwrittendata)\n    - [GetStatus](#getstatus)\n    - [WaitForGoroutineCompletion](#waitforgoroutinecompletion)\n    - [4.3.2. MultiGoroutineTable 常见错误](#432-multigoroutinetable-常见错误)\n- [5. 流数据 API](#5-流数据-api)\n  - [5.1. 接口说明](#51-接口说明)\n    - [5.1.1. PollingClient 主动轮询获取消息](#511-pollingclient-主动轮询获取消息)\n    - [5.1.2. 单协程回调 GoroutineClient](#512-单协程回调-goroutineclient)\n    - [5.1.3. 多协程回调 GoroutinePooledClient](#513-多协程回调-goroutinepooledclient)\n  - [5.2. 断线重连](#52-断线重连)\n  - [5.3. 启用 Filter](#53-启用-filter)\n  - [5.4. 取消订阅](#54-取消订阅)\n  - [5.5. 异构流表数据的处理](#55-异构流表数据的处理)\n    - [5.5.1 异构流表反序列化器](#551-异构流表反序列化器)\n    - [5.5.2. 订阅示例 1 （分区表数据源作为输入表）](#552-订阅示例-1-分区表数据源作为输入表)\n    - [5.5.3. 订阅示例 2 （内存表作为输入表）](#553-订阅示例-2-内存表作为输入表)\n- [6. 工具方法](#6-工具方法)\n  - [6.1 model 包](#61-model-包)\n    - [GetDataTypeString](#getdatatypestring)\n    - [GetDataFormString](#getdataformstring)\n    - [NewTableFromStruct](#newtablefromstruct)\n    - [NewTableFromRawData](#newtablefromrawdata)\n\n## 1. Go API 概述\n\nGo API 定义了 DataForm 接口，表示服务器端返回的[数据形式](https://www.dolphindb.cn/cn/help/130/DataTypesandStructures/DataForms/index.html)。该接口提供 `GetDataForm` 方法获取数据形式的整型表示。目前支持获取 7 种数据形式的整型表示。可以根据得到的整型表示，将 `DataForm` 强转为对应的 `DolphinDB` 的数据形式。二者对应关系见下表：\n\n| `GetDataForm` 返回值 | 实际类型   |\n| -------------------- | ---------- |\n| DfScalar(0)          | Scalar     |\n| DfVector(1)          | Vector     |\n| DfPair(2)            | Pair       |\n| DfMatrix(3)          | Matrix     |\n| DfSet(4)             | Set        |\n| DfDictionary(5)      | Dictionary |\n| DfTable(6)           | Table      |\n\n该接口也提供了 `GetDataType` 方法获取数据类型的整型表示。目前支持获取如下数据类型的整型表示：\n\n| `GetDataType` 返回值 | 实际类型   |\n| -------------------- | ---------- |\n| DtVoid(0)           | void     |\n| DtBool(1)          | bool     |\n| DtChar(2)            | char       |\n| DtShort(3)          | short     |\n| DtInt(4)             | int        |\n| DtLong(5)      | long |\n| DtDate(6)           | date      |\n| DtMonth(7)           | month     |\n| DtTime(8)          | time     |\n| DtMinute(9)            | minute       |\n| DtSecond(10)          | second     |\n| DtDatetime(11)             | datetime        |\n| DtTimestamp(12)      | timestamp |\n| DtNanoTime(13)           | nanotime      |\n| DtNanoTimestamp(14)           | nanotimestamp     |\n| DtFloat(15)          | float     |\n| DtDouble(16)            | double       |\n| DtSymbol(17)          | symbol     |\n| DtString(18)             | string        |\n| DtUUID(19)      | uuid |\n| DtFunction(20)           | function      |\n| DtHandle(21)           | handle     |\n| DtCode(22)          | code     |\n| DtDatasource(23)            | datasource       |\n| DtResource(24)          | resource     |\n| DtAny(25)             | any        |\n| DtCompress(26)      | compress |\n| DtDictionary(27)           | dictionary      |\n| DtDateHour(28)           | datehour     |\n| DtDateMinute(29)          | dateminute     |\n| DtIP(30)            | ipaddr       |\n| DtInt128(31)          | int128     |\n| DtBlob(32)             | blob        |\n| DtComplex(34)      | complex |\n| DtPoint(35)           | point      |\n| DtDuration(36)           | duration     |\n| DtDecimal32(37)          | decimal32     |\n| DtDecimal64(38)            | decimal64       |\n| DtDecimal128(39)          | decimal128     |\n| DtObject(40)             | object        |\n\n该接口还提供了 `GetDataTypeString` 方法获取数据类型的字符串表示。\n\nGo API 提供的最核心的接口是 `DolphinDB`。Go API 通过该接口在 `DolphinDB` 服务器上执行脚本和函数，并在两者之间双向传递数据。使用 `NewDolphinDBClient` 或者 `NewSimpleDolphinDBClient` 可以初始化 `DolphinDB` 实例对象。该对象提供以下主要方法：\n\n| 方法名                    | 详情                                            |\n| ------------------------- | ----------------------------------------------- |\n| Connect()       | 将会话连接到 DolphinDB 服务器                   |\n| Login(l *LoginRequest)       | 登录服务器                                      |\n| Logout()     | 登出服务器                                      |\n| RunScript(script string)         | 在 DolphinDB 服务器中运行脚本                   |\n| RunFile(fileName string)         | 读取文件中的脚本，并在 DolphinDB 服务器中运行脚本 |\n| RunFunc(s string, args []model.DataForm)    | 调用 DolphinDB 服务器上的函数                   |\n| Upload(vars map[string]model.DataForm) | 将本地数据对象上传到 DolphinDB 服务器           |\n| Close()                   | 关闭当前会话                                    |\n| IsClosed()                | 判断会话是否关闭                                |\n| IsConnected()                | 是否已建立链接                                |\n| GetSession()              | 获取当前会话的 SessionID                        |\n| RefreshTimeout(t time.Duration)              | 重置超时时间                       |\n\n还提供以下方法，进行数据库操作：\n\n| 方法名                                      | 详情                                  |\n| ------------------------------------------- | ------------------------------------- |\n| ExistsDatabase(ExistsDatabaseRequest)       | 检查数据库是否存在                    |\n| Database(DatabaseRequest)                   | 创建数据库                            |\n| DropDatabase(DropDatabaseRequest)           | 删除数据库                            |\n| ExistsTable(ExistsTableRequest)             | 检查表是否存在                        |\n| Table(TableRequest)                         | 创建内存表                            |\n| TableWithCapacity(TableWithCapacityRequest) | 创建指定容量的内存表                  |\n| SaveTable(SaveTableRequest)                 | 保存表                                |\n| LoadTable(LoadTableRequest)                 | 加载表                                |\n| LoadText(LoadTextRequest)                   | 将数据文件加载到 DolphinDB 的内存表中 |\n| SaveText(SaveTextRequest)                   | 保存文本                              |\n| PloadText(PloadTextRequest)                 | 将数据文件并行加载到内存中            |\n| LoadTableBySQL(LoadTableBySQLRequest)       | 通过 SQL 语句加载表                   |\n| DropPartition(DropPartitionRequest)         | 删除数据库的指定分区数据              |\n| DropTable(DropTableRequest)                 | 删除表                                |\n| Undef(UndefRequest)                         | 取消定义指定对象                      |\n| UndefAll()                                  | 取消定义所有对象                  |\n| ClearAllCache(ClearAllCacheRequest)         | 清除所有缓存                          |\n\n使用 `Database` 方法创建数据库后，会返回一个 `Database` 对象。该对象包含以下方法：\n\n| 方法名                                                | 详情       |\n| ----------------------------------------------------- | ---------- |\n| CreateTable(CreateTableRequest)                       | 创建维度表 |\n| CreatePartitionedTable(CreatePartitionedTableRequest) | 创建分区表 |\n\n`Go API` 的实际用例参见 [example目录](./example)。\n\n## 2. 安装依赖\n\nGo API 需要运行在 Go 1.15 或以上版本的环境。注意，Go API 只支持在 64 位的 Go 环境中运行。\n使用 `go get` 下载安装 `Go API`。\n\n```sh\ngo get -u github.com/dolphindb/api-go/v3\n```\n\n## 3. DolphinDB 基本用法\n\n### 3.1. 初始化 DolphinDB\n\nGo API 支持通过 `NewDolphinDBClient` 和 `NewSimpleDolphinDBClient` 两种方式来初始化 `DolphinDB` 实例。\n\n#### 3.1.1. NewDolphinDBClient 初始化 DolphinDB\n\nNewDolphinDBClient 仅初始化客户端，需要通过 Connect 和 Login 去连接和登录服务端。该方法支持配置行为标识。步骤如下：\n\n1. 初始化客户端\n2. 链接服务端\n3. 初始化登录请求\n4. 登录服务端\n\n```go\npackage main\n\nimport (\n    \"context\"\n\n    \"github.com/dolphindb/api-go/v3/api\"\n)\n\nfunc main() {\n    host := \"\u003cServerIP:Port\u003e\"\n    // step 1: init client\n    opt := \u0026dialer.BehaviorOptions{\n        IsClearSessionMemory : true,\n    }\n\n    db, err := api.NewDolphinDBClient(context.TODO(), host, opt)\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n\n    // step 2: connect to server\n    err = db.Connect()\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n\n    // step 3: init login request\n    loginReq := \u0026api.LoginRequest{\n        UserID:   \"userID\",\n        Password: \"password\",\n    }\n\n    // step 4: login dolphindb\n    err = db.Login(loginReq)\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n}\n```\n\n通过配置 BehaviorOptions 可以配置行为标识。可配置行为标识如下：\n\n- Priority：指定本任务优先级,可选范围为 0~8，默认为 8。\n- Parallelism：指定本任务并行度,可选范围为 0~64，默认为 64。\n- FetchSize: 指定分块返回的块大小。\n- LoadBalance: 指定是否开启负载均衡。\n- EnableHighAvailability: 指定是否开启高可用。\n- HighAvailabilitySites: 指定高可用节点地址，当从 Server 获取到的节点地址无法访问时，可通过该配置手动指定。\n- Reconnect: 指定是否开启断线重连。\n- IsReverseStreaming: 指定是否开启反向流订阅。\n- IsClearSessionMemory: 指定此任务完成后是否清理 Session 缓存。\n\n#### 3.1.2. NewSimpleDolphinDBClient 初始化 DolphinDB\n\nNewSimpleDolphinDBClient 初始化客户端，并连接和登录服务端。该方法不支持配置行为标识。\n\n```go\npackage main\n\nimport (\n    \"context\"\n\n    \"github.com/dolphindb/api-go/v3/api\"\n)\n\nfunc main() {\n    host := \"\u003cServerIP:Port\u003e\"\n\n    // new a client which has logged in the server\n    db,err := api.NewSimpleDolphinDBClient(context.TODO(), host, \"userID\", \"passWord\")\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n}\n```\n\n### 3.2. 通过 API 建库建表\n\n通过 DolphinDB 可以在服务端创建数据库和表，步骤如下:\n\n1. 初始化 DolphinDB 客户端\n2. 初始化数据库创建请求\n3. 创建数据库\n4. 初始化创建分区表请求\n5. 创建分区表\n\n```go\npackage main\n\nimport (\n    \"context\"\n\n    \"github.com/dolphindb/api-go/v3/api\"\n)\n\nfunc main() {\n    // step 1: init Dolphindb client\n    host := \"\u003cServerIP:Port\u003e\"\n    db, err := api.NewSimpleDolphinDBClient(context.TODO(), host, \"userID\", \"passWord\")\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n\n    // step 2: init create database request\n    dbReq := \u0026api.DatabaseRequest{\n        Directory:       \"dfs://db1\",\n        PartitionType:   \"VALUE\",\n        PartitionScheme: \"1..10\",\n        DBHandle:        \"example\",\n    }\n\n    // step 3: create database\n    dt, err := db.Database(dbReq)\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n\n    // step 4: init create partitioned table request\n    createReq := \u0026api.CreatePartitionedTableRequest{\n        SrcTable:             \"sourceTable\",\n        PartitionedTableName: \"tableName\",\n        PartitionColumns:     []string{\"id\"},\n    }\n\n    // step 5: create partitioned table with database handler\n    _, err = dt.CreatePartitionedTable(createReq)\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n}\n```\n\n### 3.3. 基础函数使用\n\n#### 3.3.1. 构造数据类型\n\nGo API 提供 `NewDataType` 方法构造数据类型对象，还提供 `NewDataTypeList`， `NewDataTypeListFromRawData` 以及 `NewEmptyDataTypeList` 方法构造数据类型数组，本节举例介绍常用数据类型及其数组的构造方法。\n\n- 当存在可用的数据类型对象时，可以通过 `NewDataTypeList` 构造数据类型数组。\n- 如果想用 go 类型构造数据类型数组，可以使用 `NewDataTypeListFromRawData` 方法，该方法的入参可以参考[对照表](#3312-newdatatypelistfromrawdata-入参对照表)。\n- 如果想构造指定大小的空数据类型数组，可以使用 `NewEmptyDataTypeList` 方法。然后使用数据类型数组的 `Set` 或者 `SetWithRawData` 方法填充数组。\n\n```go\npackage main\n\nimport (\n   \"fmt\"\n\n   \"github.com/dolphindb/api-go/v3/model\"\n)\n\n// new a bool datatype variable\nfunc main() {\n   // new a string datatype variable\n   dt, err := model.NewDataType(model.DtString, \"sample\")\n   if err != nil {\n        fmt.Println(err)\n        return\n   }\n\n   // print value of variable with string format\n   fmt.Println(dt.String())\n\n   // print variable datatype\n   fmt.Println(dt.DataType())\n\n   // new datatypelist with datatype variable\n   dl := model.NewDataTypeList(model.DtString, []model.DataType{dt})\n\n   // print value of variable with string format\n   fmt.Println(dl.StringList())\n\n   // print number of elements\n   fmt.Println(dl.Len())\n\n   // print variable datatype\n   fmt.Println(dt.DataType())\n\n   // new datatypelist with basic type\n   dl, err = model.NewDataTypeListFromRawData(model.DtString, []string{\"sample\", \"test\"})\n   if err != nil {\n        fmt.Println(err)\n        return\n   }\n\n   // new a scalar object\n   s := model.NewScalar(dt)\n\n   fmt.Println(s)\n\n   // new a vector object\n   vct := model.NewVector(dl)\n\n   fmt.Println(vct)\n\n   // new a pair object\n   p := model.NewPair(vct)\n\n   fmt.Println(p)\n\n   // new a matrix object\n   data, err := model.NewDataTypeListFromRawData(model.DtInt, []int32{2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10})\n   if err != nil {\n        fmt.Println(err)\n        return\n   }\n\n   rowlabel, err := model.NewDataTypeListFromRawData(model.DtInt, []int32{1, 2, 3, 4, 5})\n   if err != nil {\n        fmt.Println(err)\n        return\n   }\n\n   colLabel, err := model.NewDataTypeListFromRawData(model.DtInt, []int32{1, 2, 3, 4, 5})\n   if err != nil {\n        fmt.Println(err)\n        return\n   }\n\n   m := model.NewMatrix(model.NewVector(data), model.NewVector(rowlabel), model.NewVector(colLabel))\n\n   fmt.Println(m)\n\n   // new a set object\n   set := model.NewSet(vct)\n\n   fmt.Println(set)\n\n   // new a dictionary object\n   keys, err := model.NewDataTypeListFromRawData(model.DtString, []string{\"key1\", \"key2\"})\n   if err != nil {\n        fmt.Println(err)\n        return\n   }\n\n   values, err := model.NewDataTypeListFromRawData(model.DtString, []string{\"value1\", \"value2\"})\n   if err != nil {\n        fmt.Println(err)\n        return\n   }\n\n   dict := model.NewDictionary(model.NewVector(keys), model.NewVector(values))\n\n   fmt.Println(dict)\n\n   // new a table object\n   tb := model.NewTable([]string{\"key\"}, []*model.Vector{vct})\n\n   fmt.Println(tb)\n}\n```\n\n##### 3.3.1.1. NewDataType 入参对照表\n\n| datatype                                                     | arg        |\n| ------------------------------------------------------------ | ---------- |\n| DtChar                                                       | byte       |\n| DtBool                                                       | byte,bool  |\n| DtBlob                                                       | []byte     |\n| DtDecimal32                                                  | *model.Decimal32 |\n| DtDecimal64                                                  | *model.Decimal64 |\n| DtDecimal128                                                 | *model.Decimal128 |\n| DtComplex,DtPoint                                            | [2]float64 |\n| DtDouble                                                     | float64    |\n| DtFloat                                                      | float32    |\n| DtInt                                                        | int32      |\n| DtLong                                                       | int64      |\n| DtShort                                                      | int16      |\n| DtTimestamp,DtMonth,DtSecond,DtNanoTimestamp,DtNanoTime,DtMinute,DtDatetime,DtDateHour,DtDate | time.Time  |\n| DtAny                                                        | Dataform   |\n| DtString,DtSymbol,DtUuid,DtIP,DtInt128,DtDuration            | string     |\n\n- 注：当 datatype 为 DtBool 时，传入 0 表示 false，传入 NullBool 表示 Null，其他值表示 true。\n\n##### 3.3.1.2. NewDataTypeListFromRawData 入参对照表\n\nGolang 语法不允许一个数组里包含 nil，因此通过 Go API 传入包含空值的数组时，空值需填写为指定的方式，可以参考[Null 值对照表](#3313-null-值对照表)\n\n| datatype                                                     | args         |\n| ------------------------------------------------------------ | ------------ |\n| DtChar                                                       | []byte       |\n| DtBool                                                       | []byte,[]bool|\n| DtBlob                                                       | [][]byte     |\n| DtDecimal32                                                  | *model.Decimal32s |\n| DtDecimal64                                                  | *model.Decimal64s |\n| DtDecimal128                                                 | *model.Decimal128s |\n| DtComplex,DtPoint                                            | [][2]float64 |\n| DtDouble                                                     | []float64    |\n| DtFloat                                                      | []float32    |\n| DtInt                                                        | []int32      |\n| DtLong                                                       | []int64      |\n| DtShort                                                      | []int16      |\n| DtTimestamp,DtMonth,DtSecond,DtNanoTimestamp,DtNanoTime,DtMinute,DtDatetime,DtDateHour,DtDate | []time.Time  |\n| DtAny                                                        | []Dataform   |\n| DtString,DtSymbol,DtUuid,DtIP,DtInt128,DtDuration            | []string     |\n\n- 注：当 datatype 为 DtBool 且传入 byte 值时，传入 0 表示 false，传入 NullBool 表示 Null，其他值表示 true。\n\n##### 3.3.1.3 Null 值对照表\n\n| datatype                                                     | 空值         |\n| ------------------------------------------------------------ | ------------ |\n| DtBool                                                       | model.NullBool     |\n| DtDecimal32                                                  | model.NullDecimal32Value     |\n| DtDecimal64                                                  | model.NullDecimal64Value     |\n| DtDecimal128                                                  | model.NullDecimal128Value     |\n| DtBlob                                                       | model.NullBlob     |\n| DtChar                                                       | model.NullChar     |\n| DtComplex                                                    | model.NullComplex  |\n| DtDate,DtDateHour,DtDatetime,DtMinute,DtNanoTime,DtNanoTimestamp,DtSecond,DtMonth,DtTimestamp | model.NullTime     |\n| DtDouble                                                     | model.NullDouble   |\n| DtFloat                                                      | model.NullFloat    |\n| DtDuration                                                   | model.NullDuration |\n| DtInt                                                        | model.NullInt      |\n| DtInt128                                                     | model.NullInt128   |\n| DtIP                                                         | model.NullIP       |\n| DtLong                                                       | model.NullLong     |\n| DtPoint                                                      | model.NullPoint    |\n| DtShort                                                      | model.NullShort    |\n| DtUuid                                                       | model.NullUUID     |\n| DtAny                                                        | model.NullAny      |\n| DtString,DtSymbol                                            | model.NullString   |\n\n使用示例\n\n```go\n_, err := model.NewDataTypeListFromRawData(model.DtBool, []byte{1, 0, model.NullBool})\nif err != nil {\n    fmt.Println(err)\n    return\n}\n\n_, err = model.NewDataTypeListFromRawData(model.DtDecimal32, \u0026model.Decimal32s{Scale: 1, Value: []float64{10, model.NullDecimal32Value}})\nif err != nil {\n    fmt.Println(err)\n    return\n}\n\n_, err = model.NewDataTypeListFromRawData(model.DtDecimal64, \u0026model.Decimal64s{Scale: 1, Value: []float64{10, model.NullDecimal64Value}})\nif err != nil {\n    fmt.Println(err)\n    return\n}\n```\n\n#### 3.3.2. 完整示例\n\n```go\npackage main\n\nimport (\n    \"context\"\n    \"fmt\"\n\n    \"github.com/dolphindb/api-go/v3/api\"\n    \"github.com/dolphindb/api-go/v3/model\"\n)\n\nfunc main() {\n    host := \"\u003cServerIP:Port\u003e\"\n    db, err := api.NewSimpleDolphinDBClient(context.TODO(), host, \"userID\", \"passWord\")\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n\n    // run script on dolphindb server\n    raw, err := db.RunScript(\"schema(tablename)\")\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n\n    // print the real dataform\n    fmt.Println(raw.GetDataForm())\n\n    // get the variable with real type\n    dict := raw.(*model.Dictionary)\n    fmt.Println(dict)\n\n    // declare the specified variable ont the server\n    _, err = db.Upload(map[string]model.DataForm{\"dict\": dict})\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n\n    // run function on dolphindb server\n    _, err = db.RunFunc(\"typestr\", []model.DataForm{dict})\n    if err != nil {\n        // Handle err\n        panic(err)\n    }\n}\n```\n\n### 3.4. 初始化 DBConnectionPool\n\n`DBConnectionPool` 可以复用多个 Connection。可以直接使用 `DBConnectionPool` 的 `Execute` 方法执行任务，然后使用 `Task` 的 `GetResult` 方法获取该任务的执行结果。\n\n| 方法名                               | 详情               |\n| :----------------------------------- | :----------------- |\n| NewDBConnectionPool(opt *PoolOption) | 初始化连接池对象   |\n| Execute(tasks []*Task)               | 执行批量任务       |\n| GetPoolSize()                        | 获取连接数         |\n| Close()                              | 关闭连接池         |\n| IsClosed()                           | 检查连接池是否关闭 |\n| RefreshTimeout(t time.Duration)      | 重置超时时间       |\n\nPoolOption 参数说明：\n\n- Address：字符串，表示所连接的服务器的地址。\n- UserID / Password: 字符串，登录时的用户名和密码。\n- PoolSize：整数，表示连接池的容量。\n- LoadBalance：布尔值，表示是否开启负载均衡，开启后会根据各个数据节点的地址来创建连接池。\n- LoadBalanceAddresses: 字符串数组，用于指定数据节点。\n- EnableHighAvailability: 指定是否开启高可用。\n- HighAvailabilitySites: 指定高可用节点地址，当从 Server 获取到的节点地址无法访问时，可通过该配置手动指定。\n- Timeout: 指定每个任务执行的超时时间。\n\n`Task` 封装了查看任务执行结果的相关方法。\n\n| 方法名      | 详情                     |\n| :---------- | :----------------------- |\n| IsSuccess() | 任务是否执行成功         |\n| GetResult() | 获取脚本运行结果         |\n| GetError()  | 获取任务运行时发生的错误 |\n\n建立一个 `DBConnectionPool` 连接数为10的连接池。\n\n```go\npoolOpt := \u0026api.PoolOption{\n    Address:  \"ServerIP:Port\",\n    UserID:   \"UserID\",\n    Password: \"Password\",\n    PoolSize: 10,\n}\n\npool, err := api.NewDBConnectionPool(poolOpt)\nif err != nil {\n    fmt.Println(err)\n    return\n}\n```\n\n创建一个任务。\n\n```go\ntask := \u0026api.Task{Script: \"1..10\"}\nerr = pool.Execute([]*api.Task{task})\nif err != nil {\n    fmt.Println(err)\n    return\n}\n```\n\n检查任务是否执行成功。如果执行成功，获取相应结果；如果失败，获取错误。\n\n```go\nvar data *model.Vector\nif task.IsSuccess() {\n    data = task.GetResult().(*model.Vector)\n    fmt.Println(data)\n} else {\n    fmt.Println(task.GetError())\n}\n```\n\n输出：\n\n```txt\nvector\u003cint\u003e([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n```\n\n创建多个任务，在 `DBConnectionPool` 上并行调用。\n\n```go\ntasks := make([]*api.Task, 10)\nfor i := 0; i \u003c 10; i++ {\n    tasks[i] = \u0026api.Task{\n        Script: \"log\",\n        Args:   []model.DataForm{model.NewScalar(data.Get(i))},\n    }\n}\n\nerr = pool.Execute(tasks)\nif err != nil {\n    fmt.Println(err)\n    return\n}\n```\n\n检查任务是否都执行成功。如果执行成功，获取相应结果；如果失败，获取错误。\n\n```go\nfor _, v := range tasks {\n    if v.IsSuccess() {\n        fmt.Println(v.GetResult().String())\n    } else {\n        fmt.Println(v.GetError())\n    }\n}\n```\n\n输出：\n\n```txt\ndouble(0)\ndouble(0.6931471805599453)\ndouble(1.0986122886681096)\ndouble(1.3862943611198906)\ndouble(1.6094379124341003)\ndouble(1.791759469228055)\ndouble(1.9459101490553132)\ndouble(2.0794415416798357)\ndouble(2.1972245773362196)\ndouble(2.302585092994046)\n```\n\n## 4. 读写 DolphinDB 数据表\n\n`DolphinDB` 数据表按存储方式分为两种:\n\n- 内存表: 数据仅保存在内存中，存取速度最快。仅当前会话可见，需要通过 `share` 在会话间共享内存表，以便其它会话可以访问。可以直接使用表名加载。\n- 分布式表：数据分布在不同的节点，通过 DolphinDB 的分布式计算引擎，逻辑上仍然可以像本地表一样做统一查询。是 `DolphinDB` 推荐在生产环境下使用的数据存储方式，它支持快照级别的事务隔离，保证数据一致性。分布式表支持多副本机制，既提供了数据容错能力，又能作为数据访问的负载均衡。需要使用 loadTable 加载。\n\n下面统一使用分布式表作为示例。\n\n### 4.1. 保存数据到 DolphinDB 数据表\n\nDolphinDB 提供多种脚本语句来保存数据到内存表：\n\n- 通过 `insert into` 追加单行数据\n- 通过 `tableInsert` 函数向表中批量追加数组对象\n- 通过 `tableInsert` 函数向表中追加 `Table` 对象\n- 通过 `append!` 追加数据到内存表\n\nGo API 可以通过 `RunScript` 接口将插入数据的脚本发送至服务端执行。\n\n#### 4.1.1. 同步追加数据\n\n下面分别介绍三种方式保存数据的实例:\n\n通过 [GUI](https://github.com/dolphindb/Tutorials_EN/blob/master/gui_tutorial.md) 在 DolphinDB server 端创建一个分布式表。\n\n```go\nhost := \"ServerIP:Port\"\ndb, err := api.NewSimpleDolphinDBClient(context.TODO(), host, \"admin\", \"123456\")\nif err != nil {\n    // Handle err\n    panic(err)\n}\n\n// run script on dolphindb server\n_, err = db.RunScript(\"t = table(10000:0,`cstring`cint`ctimestamp`cdouble,[STRING,INT,TIMESTAMP,DOUBLE])\\nshare t as sharedTable\")\nif err != nil {\n    // Handle err\n    panic(err)\n}\n\n// run script on dolphindb server\n_, err = db.RunScript(\"dbPath = 'dfs://testDatabase'\\ntbName = 'tb1'\\n\" +\n    \"if(existsDatabase(dbPath)){dropDatabase(dbPath)};\\n\" +\n    \"db = database(dbPath,RANGE,2018.01.01..2018.12.31);db.createPartitionedTable(t,tbName,'ctimestamp')\")\nif err != nil {\n    // Handle err\n    panic(err)\n}\n```\n\n##### 4.1.1.1. 使用 `insert into` 追加单行数据\n\n若将单条数据记录保存到 DolphinDB 数据表，可以使用 `insert into`。\n\n```go\nfunc testSaveInsert(str string, i int, ts int64, dbl float64, db api.DolphinDB) {\n    df, err := db.RunScript(fmt.Sprintf(\"insert into loadTable('dfs://testDatabase','tb1')values('%s',%d,%d,%f)\", str, i, ts, dbl))\n    if err != nil {\n        fmt.Println(err)\n        return\n    }\n\n    fmt.Println(df)\n}\n```\n\n##### 4.1.1.2. 使用 `tableInsert` 函数向表中批量追加数组对象\n\n`tableInsert` 可将多个数组追加到 `DolphinDB` 内存表中，比较适合用来批量保存数据。\n\n- 批量追加数组对象\n\n```go\nfunc testTableInsert(strVector, intVector, timestampVector, doubleVector *model.Vector, db api.DolphinDB) {\n    args := make([]model.DataForm, 4)\n    args[0] = strVector\n    args[1] = intVector\n    args[2] = timestampVector\n    args[3] = doubleVector\n    df, err := db.RunFunc(\"tableInsert{sharedTable}\", args)\n    if err != nil {\n        fmt.Println(err)\n        return\n    }\n\n    fmt.Println(df)\n}\n```\n\n在本例中，使用了 `DolphinDB` 中的[部分应用](https://www.dolphindb.cn/cn/help/200/Functionalprogramming/PartialApplication.html)这一特性，将服务端表名以 `tableInsert{sharedTable}` 的方式固化到 `tableInsert` 中，作为一个独立函数来使用。\n\n##### 4.1.1.3. 使用 `tableInsert` 函数向表中追加 `Table` 对象\n\n`tableInsert` 函数也可以接受一个表对象作为参数，批量添加数据。Go API 将获取的数据处理后组织成 `Table` 对象后，通过 `tableInsert` 插入 `DolphinDB` 数据表。\n\n```go\nfunc testTableInsert(tableObj *model.Table, db api.DolphinDB) {\n    args := make([]model.DataForm, 1)\n    args[0] = tableObj\n    df, err := db.RunFunc(\"tableInsert{loadTable('dfs://testDatabase','tb1')}\", args)\n    if err != nil {\n        fmt.Println(err)\n        return\n    }\n\n    fmt.Println(df)\n}\n```\n\n#### 4.1.2. 异步追加数据\n\n##### 4.1.2.1. 数据表的并发写入\n\n`DolphinDB` 的数据表支持并发读写，Go API 提供 `PartitionedTableAppender` 来支持数据表的并发写入，仅支持按表写入。\n\n使用 1.30 版本以上的 server，可以通过 Go API 中的 PartitionedTableAppender 来写入分布式表。其基本原理是设计一个连接池用于多协程写入，将写入的数据按指定的分区列进行分类，并分别放入不同的连接并行写入。\n\n下面展示如何在 Go 客户端中将数据并发写入 `DolphinDB` 的分布式表。\n\n首先，在 `DolphinDB` 服务端执行以下脚本，创建分布式数据库 `\"dfs://demohash\"` 和分布式表 `\"pt\"`。其中，数据库按照 `HASH-HASH` 的组合进行二级分区。\n\n```go\nhost := \"ServerIP:Port\"\ndb, err := api.NewSimpleDolphinDBClient(context.TODO(), host, \"admin\", \"123456\")\nif err != nil {\n    // Handle err\n    panic(err)\n}\n\n// run script on dolphindb server\n_, err = db.RunScript(\"t = table(timestamp(1..10) as date,string(1..10) as sym);\\ndb1=database(\\\"\\\",HASH,[DATETIME,10]);\\n\" +\n    \"db2=database(\\\"\\\",HASH,[STRING,5])\\nif(existsDatabase(\\\"dfs://demohash\\\")){dropDatabase(\\\"dfs://demohash\\\")};\\n\" +\n    \"db = database(\\\"dfs://demohash\\\",COMPO,[db2,db1]);pt = db.createPartitionedTable(t,`pt,`sym`date)\")\nif err != nil {\n    // Handle err\n    panic(err)\n}\n```\n\n然后，使用 Go API 初始化 `PartitionedTableAppender` 对象。\n\n```go\npoolOpt := \u0026api.PoolOption{\n    Address:     \"ServerIP:Port\",\n    UserID:      \"admin\",\n    Password:    \"123456\",\n    PoolSize:    3,\n    LoadBalance: true,\n}\n\npool, err := api.NewDBConnectionPool(poolOpt)\nif err != nil {\n    fmt.Println(err)\n    return\n}\n\nappenderOpt := \u0026api.PartitionedTableAppenderOption{\n    Pool:             pool,\n    DBPath:           \"dfs://demohash\",\n    TableName:        \"pt\",\n    PartitionCol:     \"sym\",\n}\n\nappender, err := api.NewPartitionedTableAppender(appenderOpt)\nif err != nil {\n    fmt.Println(err)\n    return\n}\n```\n\n`PartitionedTableAppenderOption` 参数说明：\n\n- Pool: 表示连接池。\n- DBPath: 字符串，数据库路径。\n- TableName：字符串，表示数据表名。\n- PartitionCol：字符串，表示分布式表列名。\n- AppendFunction: 可选，自定义写入函数名，不填此参数则调用内置 tableInsert 函数。\n\n最后，将数据插入到数据表中：\n\n```go\ncolNames := []string{\"sym\", \"date\"}\n\nsym, err := model.NewDataTypeListFromRawData(model.DtString, []string{\"sample\", \"test\"})\nif err != nil {\n    fmt.Println(err)\n    return\n}\n\ndate, err := model.NewDataTypeListFromRawData(model.DtDatetime, []time.Time{time.Date(1969, 12, 31, 0, 0, 0, 0, time.UTC), time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)})\nif err != nil {\n    fmt.Println(err)\n    return\n}\n\ncol1 := model.NewVector(sym)\ncol2 := model.NewVector(date)\n\nm, err := appender.Append(model.NewTable(colNames, []*model.Vector{col1, col2}))\nif err != nil {\n    fmt.Println(err)\n    return\n}\n\nfmt.Println(m)\n```\n\n### 4.2. 读取和使用数据表\n\n#### 4.2.1. 读取数据表\n\n在 Go API 中使用如下代码可读取分布式表数据。\n\n```go\ndbPath := \"dfs://testDatabase\"\ntbName := \"tb1\"\nconn, err := api.NewSimpleDolphinDBClient(context.TODO(), \"ServerIP:Port\", \"admin\", \"123456\")\nif err != nil {\n    fmt.Println(err)\n    return\n}\n\ntb, err := conn.RunScript(fmt.Sprintf(\"select * from loadTable('%s','%s') where cdate = 2017.05.03\", dbPath, tbName))\nif err != nil {\n    fmt.Println(err)\n    return\n}\n```\n\n#### 4.2.2. 使用 Table 对象\n\nGo API 通过 `Table` 对象来存储数据表。`Table` 对象采用列式存储，无法直接读取行数据，因此需要先读取列，再读取行。\n以表对象 t 为例，其包含4个列，列名分别为 cstring, cint, ctimestamp, cdouble，数据类型分别是 STRING, INT, TIMESTAMP, DOUBLE。通过 Go API 分别打印 t 中每个列的列名和对应的值。\n\n```go\nfor _, v := range t.GetColumnNames() {\n    fmt.Println(\"ColumnName: \", v)\n    col := t.GetColumnByName(v)\n    fmt.Println(\"ColumnValue: \", col.String())\n}\n```\n\n### 4.3. 批量异步追加数据\n\nDolphinDB Go API 提供 `MultiGoroutineTable` 对象用于批量异步追加数据，并在客户端维护了一个数据缓冲队列。当服务器端忙于网络 I/O 时，客户端写协程仍然可以将数据持续写入缓冲队列（该队列由客户端维护）。写入队列后即可返回，从而避免了写协程的忙等。目前，`MultiGoroutineTable` 支持批量写入数据到内存表、分区表和维度表。\n\n注意对于异步写入：\n\n- 支持按行向表中追加数据。\n- API 客户端提交任务到缓冲队列，缓冲队列接到任务后，客户端即认为任务已完成。\n- 提供 `GetStatus` 方法查看状态。\n\n#### 4.3.1. MultiGoroutineTable\n\n`MultiGoroutineTable` 支持多协程的并发写入。\n\n`MultiGoroutineTable` 对象初始化如下：\n\n```go\nopt := \u0026multigoroutinetable.Option{\n    Database:       \"dbName\",\n    Address:        \"ServerIP:Port\",\n    UserID:         \"admin\",\n    Password:       \"123456\",\n    TableName:      \"tbName\",\n    GoroutineCount: 2,\n    PartitionCol:   \"colName\",\n    BatchSize:      1000,\n    Throttle:       1,\n}\n\nwriter, err := multigoroutinetable.NewMultiGoroutineTable(opt)\nif err != nil {\n    fmt.Println(err)\n    return\n}\n```\n\nOption 参数说明：\n\n- Address：字符串，表示所连接的服务器的地址.\n- UserID / Password: 字符串，登录时的用户名和密码。\n- Database: 字符串，表示数据库的路径或句柄。如果是内存表，则无需设置该参数。\n- TableName：字符串，表示表的名称。\n- BatchSize：整数，表示批处理的消息的数量。如果该参数值为 1，表示客户端写入数据后就立即发送给服务器；\n  如果该参数大于 1，表示数据量达到 BatchSize 时，客户端才会将数据发送给服务器。\n- Throttle：大于 0 的整数，单位为毫秒。若客户端有数据写入，但数据量不足 BatchSize，则等待 Throttle 的时间再发送数据。\n- GoroutineCount：整数，表示创建的工作协程数量，如果值为 1，表示单协程。对于维度表，其值必须为 1。\n- PartitionCol：字符串类型，默认为空，仅在 GoroutineCount 大于1时起效。对于分区表，必须指定为分区字段名；\n  如果是内存表，必须指定为表的字段名；对于维度表，该参数不起效。\n\n以下是 `MultiGoroutineTable` 对象包含的函数方法介绍：\n\n#### Insert\n\n```go\nInsert(args ...interface{}) error\n```\n\n函数说明：\n\n插入单行数据。返回一个 error 对象。\n数据类型需要与表的列存储的数据类型一致，或者为列存储的数据类型的基础类型，具体可参考[可用入参对照表](#3311-newdatatype-入参对照表)\n因写入是异步操作，所以当 error 为 nil 时，不代表写入操作成功。\n写入操作是否成功可以打印 `GetStatus` 方法返回的对象。\n\n参数说明：\n\n- args: 是变长参数，代表插入一行数据。\n\n示例：\n\n```go\nerr = writer.Insert(\"2\", time.Date(2022, time.Month(1), 1, 1, 1, 0, 0, time.UTC))\n```\n\n#### GetUnwrittenData\n\n```go\nGetUnwrittenData() [][]interface{}\n```\n\n函数说明：\n\n返回一个嵌套列表，表示未写入服务器的数据。\n\n注意\n\n1. 返回的结果以 `MultiGoroutineTable` 存储的中间变量的形式存在，只能给写入相同 schema 表的 `MultiGoroutineTable` 使用。\n\n2. 该方法获取到数据资源后，`MultiGoroutineTable` 将释放这些数据资源。\n\n示例：\n\n```go\nunwrittenData := writer.GetUnwrittenData()\n```\n\n#### InsertUnwrittenData\n\n```go\nInsertUnwrittenData(records [][]interface{}) error\n```\n\n函数说明：\n\n将通过 GetUnwrittenData 得到的数据插入数据表。返回值同 insert 方法。\n\n参数说明：\n\n- records：需要再次写入的数据。可以通过方法 GetUnwrittenData 获取该对象。\n\n示例：\n\n```go\nerr = writer.InsertUnwrittenData(unwrittenData)\n```\n\n#### GetStatus\n\n```go\nGetStatus() *Status\n```\n\n函数说明：\n\n获取 `MultiGoroutineTable` 对象当前的运行状态。\n\n返回参数说明：\n\n- Status：包含 MultiGoroutineTable 执行状态的对象。\n\n示例：\n\n```go\nstatus := writer.GetStatus()\n```\n\nstatus 属性：\n\n- IsExit：写入协程是否正在退出。\n- ErrMsg：错误信息。\n- SentRows：成功发送的总记录数。\n- UnsentRows：待发送的总记录数。\n- FailedRows：发送失败的总记录数。\n- GoroutineStatus：写入协程状态列表。\n  - GoroutineIndex：协程索引。\n  - SentRows：该协程成功发送的记录数。\n  - UnsentRows：该协程待发送的记录数。\n  - FailedRows：该协程发送失败的记录数。\n\n#### WaitForGoroutineCompletion\n\n```go\nWaitForGoroutineCompletion()\n```\n\n函数说明：\n\n调用此方法后，`MultiGoroutineTable` 会进入等待状态，待后台工作协程全部完成后退出等待状态。\n\n示例：\n\n```go\nwriter.WaitForGoroutineCompletion()\n```\n\nMultiGoroutineTable 的正常使用示例如下：\n\n```go\nconn, err := api.NewSimpleDolphinDBClient(context.TODO(), \"ServerIP:Port\", \"admin\", \"123456\")\nif err != nil {\n    return\n}\n\nbuf := bytes.NewBufferString(\"dbName = 'dfs://valuedb3'\\n\")\nbuf.WriteString(\"if (exists(dbName)){dropDatabase(dbName);}\\n\")\nbuf.WriteString(\"datetest = table(1000:0,`date`symbol`id,[DATE, SYMBOL, LONG]);\\n\")\nbuf.WriteString(\"db = database(directory= dbName, partitionType= HASH, partitionScheme=[INT, 10]);\")\nbuf.WriteString(\"pt = db.createPartitionedTable(datetest,'pdatetest','id');\")\n_, err = conn.RunScript(buf.String())\nif err != nil {\n    return\n}\n\nopt := \u0026multigoroutinetable.Option{\n    Database:       \"dfs://valuedb3\",\n    Address:        \"ServerIP:Port\",\n    UserID:         \"admin\",\n    Password:       \"123456\",\n    TableName:      \"pdatetest\",\n    GoroutineCount: 5,\n    PartitionCol:   \"id\",\n    BatchSize:      10000,\n    Throttle:       1,\n}\n\nwriter, err := multigoroutinetable.NewMultiGoroutineTable(opt)\nif err != nil {\n    return\n}\n\n// insert 100 row data\nfor ind := 0; ind \u003c 100; ind++ {\n    err = writer.Insert(time.Date(2022, time.Month(1), 1, 1, 1, 0, 0, time.UTC), \"AAAAAAAAAB\", rand.Int63()%10000)\n    if err != nil {\n        return\n    }\n}\n\n// wait for insertion to complete\nwriter.WaitForGoroutineCompletion()\n\nstatus := writer.GetStatus()\nfmt.Println(\"writeStatus: \\n\", status)\n\nraw, err := conn.RunScript(\"exec count(*) from pt\")\nif err != nil {\n    return\n}\n\nfmt.Println(raw)\n```\n\n以上代码输出结果为\n\n```sh\n\"\"\"\nwriteStatus:\nerrMsg         :\nisExit         :  false\nsentRows       :  100\nunsentRows     :  0\nsendFailedRows :  0\ngoroutineStatus   :\n    goroutineIndex: 0, sentRows: 18, unsentRows: 0, sendFailedRows: 0\n    goroutineIndex: 1, sentRows: 23, unsentRows: 0, sendFailedRows: 0\n    goroutineIndex: 2, sentRows: 19, unsentRows: 0, sendFailedRows: 0\n    goroutineIndex: 3, sentRows: 20, unsentRows: 0, sendFailedRows: 0\n    goroutineIndex: 4, sentRows: 20, unsentRows: 0, sendFailedRows: 0\n\nlong(100)\n\"\"\"\n```\n\n**注意**：使用 writer.WaitForGoroutineCompletion() 方法等待 `MultiGoroutineTable` 写入完毕，会终止 `MultiGoroutineTable` 所有工作协程，保留最后一次写入信息。此时如果需要再次将数据写入 `MultiGoroutineTable`，需要重新获取新的 `MultiGoroutineTable` 对象，才能继续写入数据。\n\n由上例可以看出，`MultiGoroutineTable` 内部使用多协程完成数据转换和写入任务。但在 `MultiGoroutineTable` 外部，API 客户端同样支持以多协程方式将数据写入 `MultiGoroutineTable`，且保证了多协程安全。\n\n#### 4.3.2. MultiGoroutineTable 常见错误\n\nMultiGoroutineTable 调用 Insert 方法插入数据时出错：\n\n- 在调用 MultiGoroutineTable 的 Insert 方法时，若插入数据的类型与表对应列的类型不匹配，则 MultiGoroutineTable 会立刻返回错误信息。\n\n示例：\n\n```go\nconn, err := api.NewSimpleDolphinDBClient(context.TODO(), \"ServerIP:Port\", \"admin\", \"123456\")\nif err != nil {\n    return\n}\n\nbuf := bytes.NewBufferString(\"dbName = 'dfs://valuedb3'\\n\")\nbuf.WriteString(\"if (exists(dbName)){dropDatabase(dbName);}\\n\")\nbuf.WriteString(\"datetest = table(1000:0,`date`symbol`id,[DATE, SYMBOL, LONG]);\\n\")\nbuf.WriteString(\"db = database(directory= dbName, partitionType= HASH, partitionScheme=[INT, 10]);\")\nbuf.WriteString(\"pt = db.createPartitionedTable(datetest,'pdatetest','id');\")\n_, err = conn.RunScript(buf.String())\nif err != nil {\n    return\n}\n\nopt := \u0026multigoroutinetable.Option{\n    Database:       \"dfs://valuedb3\",\n    Address:        \"ServerIP:Port\",\n    UserID:         \"admin\",\n    Password:       \"123456\",\n    TableName:      \"pdatetest\",\n    GoroutineCount: 5,\n    PartitionCol:   \"id\",\n    BatchSize:      10000,\n    Throttle:       1,\n}\n\nwriter, err := multigoroutinetable.NewMultiGoroutineTable(opt)\nif err != nil {\n    return\n}\n\n// insert data with wrong type\nerr = writer.Insert(time.Date(2022, time.Month(1), 1, 1, 1, 0, 0, time.UTC), 222, rand.Int63()%10000)\nif err != nil {\n    fmt.Println(err)\n    return\n}\n```\n\n以上代码输出结果为：\n\n```go\n\"\"\"\nthe type of in must be string when datatype is DtString, DtCode, DtFunction, DtHandle or DtSymbol\n\"\"\"\n```\n\n- 在调用 MultiGoroutineTable 的 Insert 方法时，若 Insert 插入数据的列数和表的列数不匹配，MultiGoroutineTable 会立刻返回错误信息。\n\n示例：\n\n```go\nconn, err := api.NewSimpleDolphinDBClient(context.TODO(), \"ServerIP:Port\", \"admin\", \"123456\")\nif err != nil {\n    return\n}\n\nbuf := bytes.NewBufferString(\"dbName = 'dfs://valuedb3'\\n\")\nbuf.WriteString(\"if (exists(dbName)){dropDatabase(dbName);}\\n\")\nbuf.WriteString(\"datetest = table(1000:0,`date`symbol`id,[DATE, SYMBOL, LONG]);\\n\")\nbuf.WriteString(\"db = database(directory= dbName, partitionType= HASH, partitionScheme=[INT, 10]);\")\nbuf.WriteString(\"pt = db.createPartitionedTable(datetest,'pdatetest','id');\")\n_, err = conn.RunScript(buf.String())\nif err != nil {\n    return\n}\n\nopt := \u0026multigoroutinetable.Option{\n    Database:       \"dfs://valuedb3\",\n    Address:        \"ServerIP:Port\",\n    UserID:         \"admin\",\n    Password:       \"123456\",\n    TableName:      \"pdatetest\",\n    GoroutineCount: 5,\n    PartitionCol:   \"id\",\n    BatchSize:      10000,\n    Throttle:       1,\n}\n\nwriter, err := multigoroutinetable.NewMultiGoroutineTable(opt)\nif err != nil {\n    return\n}\n\n// insert data with more data\nerr = writer.Insert(time.Date(2022, time.Month(1), 1, 1, 1, 0, 0, time.UTC), rand.Int63()%10000)\nif err != nil {\n    fmt.Println(err)\n    return\n}\n```\n\n以上代码输出结果为：\n\n```sh\n\"\"\"\nColumn counts don't match\n\"\"\"\n```\n\n如果 MultiGoroutineTable 在运行时连接断开，则所有工作协程被终止。继续通过 MultiGoroutineTable 向服务器写数据时，会因为工作协程终止而报错，且数据不会被写入。此时，可通过调用 MultiGoroutineTable 的 GetUnwrittenData 获取未插入的数据，并重新插入。\n\n示例：\n\n```go\nconn, err := api.NewSimpleDolphinDBClient(context.TODO(), \"ServerIP:Port\", \"admin\", \"123456\")\nif err != nil {\n    return\n}\n\nbuf := bytes.NewBufferString(\"dbName = 'dfs://valuedb3'\\n\")\nbuf.WriteString(\"if (exists(dbName)){dropDatabase(dbName);}\\n\")\nbuf.WriteString(\"datetest = table(1000:0,`date`symbol`id,[DATE, SYMBOL, LONG]);\\n\")\nbuf.WriteString(\"db = database(directory= dbName, partitionType= HASH, partitionScheme=[INT, 10]);\")\nbuf.WriteString(\"pt = db.createPartitionedTable(datetest,'pdatetest','id');\")\n_, err = conn.RunScript(buf.String())\nif err != nil {\n    return\n}\n\nopt := \u0026multigoroutinetable.Option{\n    Database:       \"dfs://valuedb3\",\n    Address:        \"ServerIP:Port\",\n    UserID:         \"admin\",\n    Password:       \"123456\",\n    TableName:      \"pdatetest\",\n    GoroutineCount: 5,\n    PartitionCol:   \"id\",\n    BatchSize:      10000,\n    Throttle:       1,\n}\n\nwriter, err := multigoroutinetable.NewMultiGoroutineTable(opt)\nif err != nil {\n    return\n}\n\n// insert data with more data\nerr = writer.Insert(time.Date(2022, time.Month(1), 1, 1, 1, 0, 0, time.UTC), rand.Int63()%10000)\nif err != nil {\n    fmt.Println(err)\n    return\n}\n\nunwriterdata := writer.GetUnwrittenData()\nfmt.Println(\"unWriterdata: \", len(unwriterdata))\n\n// renew MultiGoroutineTable object\nwriter, err = multigoroutinetable.NewMultiGoroutineTable(opt)\nif err != nil {\n    return\n}\n\nerr = writer.InsertUnwrittenData(unwriterdata)\nif err != nil {\n    return\n}\n\n// wait for insertion to complete\nwriter.WaitForGoroutineCompletion()\n\nstatus := writer.GetStatus()\nfmt.Println(\"writeStatus: \\n\", status)\n```\n\n以上代码输出结果为：\n\n```go\n\"\"\"\nunWriterdata: 10\nwriteStatus:\nerrMsg         :\nisExit         :  true\nsentRows       :  10\nunsentRows     :  0\nsendFailedRows :  0\ngoroutineStatus   :\n    goroutineIndex: 0, sentRows: 3, unsentRows: 0, sendFailedRows: 0\n    goroutineIndex: 1, sentRows: 2, unsentRows: 0, sendFailedRows: 0\n    goroutineIndex: 2, sentRows: 1, unsentRows: 0, sendFailedRows: 0\n    goroutineIndex: 3, sentRows: 3, unsentRows: 0, sendFailedRows: 0\n    goroutineIndex: 4, sentRows: 1, unsentRows: 0, sendFailedRows: 0\n\"\"\"\n```\n\n## 5. 流数据 API\n\nGo API 可以通过 API 订阅流数据。用户有三种创建订阅客户端的方式：\n\n1. PollingClient 主动轮询获取消息。\n2. 单协程回调（GoroutineClient），使用 MessageHandler 回调的方式获取新数据。\n3. 多协程回调（GoroutinePooledClient），使用 MessageHandler 回调的方式获取新数据。\n\n### 5.1. 接口说明\n\n在调用订阅函数之前，需要先封装 `SubscribeRequest` 对象:\n\n`SubscribeRequest` 参数说明:\n\n- Address: 发布端节点的地址。\n- TableName：发布表的名称。\n- ActionName：订阅任务的名称。\n- BatchSize: 整数，表示批处理的消息的数量。如果它是正数，直到消息的数量达到 batchSize 时，Handler 才会处理进来的消息。如果它没有指定或者是非正数，消息到达之后，Handler 就会马上处理消息。仅对 GoroutineClient 客户端有效。\n- Offset: 整数，表示订阅任务开始后的第一条消息所在的位置。消息是流数据表中的行。如果没有指定 offset，或它为负数或超过了流数据表的记录行数，订阅将会从流数据表的当前行开始。offset 与流数据表创建时的第一行对应。如果某些行因为内存限制被删除，在决定订阅开始的位置时，这些行仍然考虑在内。\n- AllowExists: 开启后，若已存在的订阅被再次订阅，则不会抛出异常。默认值为 false。**注意，由于 2.00.9 版本后的 DolphinDB server 此功能失效，故该参数自 1.30.22 版本起作废。**\n- Throttle: 浮点数，表示 Handler 处理到达的消息之前等待的时间，以秒为单位。默认值为 1。如果没有指定 BatchSize，Throttle 将不会起作用。仅对 GoroutineClient 客户端有效。\n- MsgAsTable：布尔值，只有设置了 batchSize 参数，该参数才会生效。表示订阅的数据是否为表。默认值是 false，表示订阅的数据是 Vector。\n- Reconnect: 布尔值，表示订阅中断后，是否会自动重订阅。\n- Filter: 一个向量，表示过滤条件。流数据表过滤列在 filter 中的数据才会发布到订阅端，不在 filter 中的数据不会发布。\n- Handler：用户自定义的回调函数，用于处理每次流入的数据，仅在支持回调的订阅客户端可用。\n\n下面分别介绍如何通过 3 种方法订阅流数据。\n\n#### 5.1.1. PollingClient 主动轮询获取消息\n\n该方法推荐用于需要通过客户机上的应用程序定期去流数据表查询是否有新增数据的场景。使用示例如下：\n\n```go\nclient := streaming.NewPollingClient(\"localhost\", 8101)\nreq := \u0026streaming.SubscribeRequest{\n    Address:    \"ServerIP:Port\",\n    TableName:  \"pub1\",\n    ActionName: \"action1\",\n    Offset:     0,\n    Reconnect:  true,\n}\n\npoller, err := client.Subscribe(req)\nif err != nil {\n    return\n}\n\nmsgs := poller.Poll(1000, 1000)\nfmt.Println(msgs)\n```\n\npoller 探测到流数据表有新增数据后，会拉取到新数据。无新数据发布时，程序会阻塞在 `poller.Poll` 方法, 直到超时。\n\n#### 5.1.2. 单协程回调 GoroutineClient\n\n使用单协程回调（GoroutineClient）、多协程回调（GoroutinePooledClient）的方式首先需要调用者定义数据处理器 Handler。Handler 需要实现 `streaming.MessageHandler` 接口。\n\n```go\ntype sampleHandler struct {}\n\nfunc (s *sampleHandler) DoEvent(msg streaming.IMessage) {\n // do something\n}\n```\n\n在启动订阅时，把 Handler 实例作为参数传入订阅函数。包括单协程回调和多协程回调两种方式。\n\nGoroutineClient 在接收到多条订阅信息时，会调用 Handler 的 DoEvent 方法，顺序处理订阅信息。\n\n```go\nclient := streaming.NewGoroutineClient(\"localhost\", 8100)\nreq := \u0026streaming.SubscribeRequest{\n    Address:    \"ServerIP:Port\",\n    TableName:  \"pub\",\n    ActionName: \"action1\",\n    Handler:    new(sampleHandler),\n    Offset:     0,\n    Reconnect:  true,\n}\n\nerr := client.Subscribe(req)\nif err != nil {\n    return\n}\n```\n\n当流数据表有新增数据时， Go API 会自动调用 sampleHandler 的 DoEvent 方法。\n\n#### 5.1.3. 多协程回调 GoroutinePooledClient\n\nGoroutinePooledClient 在接收到多条订阅信息时，并发调用 Handler 的 DoEvent 方法，构造方式同单协程回调。需额外加锁保证 DoEvent 的并发安全。\n\n```go\nclient := streaming.NewGoroutinePooledClient(\"localhost\", 8100)\nreq := \u0026streaming.SubscribeRequest{\n    Address:    \"ServerIP:Port\",\n    TableName:  \"pub\",\n    ActionName: \"action1\",\n    Handler:    new(sampleHandler),\n    Offset:     0,\n    Reconnect:  true,\n}\n\nerr := client.Subscribe(req)\nif err != nil {\n    return\n}\n```\n\n*注* 使用 GoroutinePooledClient 订阅流数据，无法保证订阅消息的处理顺序。\n\n### 5.2. 断线重连\n\n`Reconnect` 参数是一个布尔值，表示订阅意外中断后，是否会自动重新订阅。默认值为 false。\n\n若 `Reconnect` 设置为 true 时，订阅意外中断后系统是否以及如何自动重新订阅，取决于订阅中断由哪种原因导致：\n\n- 如果发布端与订阅端处于正常状态，但是网络中断，那么订阅端会在网络正常时，自动从中断位置重新订阅。\n- 如果发布端崩溃，订阅端会在发布端重启后不断尝试重新订阅。\n  - 如果发布端对流数据表启动了持久化，发布端重启后会首先读取硬盘上的数据，直到发布端读取到订阅中断位置的数据，订阅端才能成功重新订阅。\n  - 如果发布端没有对流数据表启用持久化，那么订阅端将自动重新订阅失败。\n- 如果订阅端崩溃，订阅端重启后不会自动重新订阅，需要重新执行 `Subscribe` 函数。\n\n**注意**：如果订阅的是高可用流表，则重连参数无法生效。如果因为高可用流表 leader 切换或者网络终端而导致的断连，则无法通过此参数重连。\n\n### 5.3. 启用 Filter\n\n`Filter` 参数是一个向量。该参数需要发布端配合 `setStreamTableFilterColumn` 函数一起使用。使用 `setStreamTableFilterColumn` 指定流数据表的过滤列，流数据表过滤列在 filter 中的数据才会发布到订阅端，不在 `Filter` 中的数据不会发布。\n\n以下例子将一个包含元素 1 和 2 的整数类型向量作为 `Subscribe` 的 Filter 参数：\n\n```go\ndtl, err := model.NewDataTypeListFromRawData(model.DtInt, []int32{1, 2})\nif err != nil {\n    return\n}\n\nclient := streaming.NewPollingClient(\"localhost\", 8101)\nreq := \u0026streaming.SubscribeRequest{\n    Address:    \"ServerIP:Port\",\n    TableName:  \"pub1\",\n    ActionName: \"action1\",\n    Offset:     0,\n    Reconnect:  true,\n    Filter:     model.NewVector(dtl),\n}\n\n_, err = client.Subscribe(req)\nif err != nil {\n    return\n}\n```\n\n### 5.4. 取消订阅\n\n每一个订阅都有一个订阅主题 `topic` 作为唯一标识。如果订阅时 `topic` 已经存在，那么会订阅失败。这时需要通过 `UnSubscribe` 函数取消订阅才能再次订阅。\n在使用中注意取消订阅后，通过回调获取数据的流订阅可能还会执行一会儿回调函数，然后才会结束订阅过程。\n\n```go\nerr = client.UnSubscribe(req)\nif err != nil {\n    return\n}\n```\n\n### 5.5. 异构流表数据的处理\n\nDolphinDB 自 1.30.17 及 2.00.5 版本开始，支持通过 replay 函数将多个结构不同的流数据表回放（序列化）到一个流表里，这个流表被称为异构流表。Go API 自 1.30.22 版本开始新增 `streamDeserializer` 类，用于构造异构流表反序列化器，以实现对异构流表的订阅和反序列化操作。目前异构流表的反序列化不支持 decimal 类型。\n\n#### 5.5.1 异构流表反序列化器\n\nGo API 通过 `streamDeserializer` 类来构造异构流表反序列化器，接口定义如下：\n\n构造 `streamDeserializer` 需要传入 `StreamDeserializerOption` 对象：\n\n`StreamDeserializerOption` 参数说明:\n\n- TableNames：字典对象，字典的 key 为 string 类型，字典的 value 为长度为 2 的 string 切片类型。其中 string 切片的第一个元素为数据库的名称，是内存表则填\"\"，第二个元素为表的名称，其结构与 replay 回放到异构流表的输入表结构保持一致。其结构与 replay 回放到异构流表的输入表结构保持一致。streamDeserializer 将根据 TableNames 指定的结构对注入的数据进行反序列化，必须指定。\n- Conn：已连接 DolphinDB 的 DolphinDB 对象，需要通过该连接获取回放到异构流表的输入表结构，必须指定。\n\n下例构造一个简单的异构流表反序列化器：\n\n``` go\nhost := \"localhost:8848\";\ndb, err := api.NewDolphinDBClient(context.TODO(), host, nil)\nutil.AssertNil(err)\nsdMap := make(map[string][2]string)\nsdMap[\"msg1\"] = [2]string{\"dfs://test_StreamDeserializer_pair\", \"pt1\"}\nsdMap[\"msg2\"] = [2]string{\"dfs://test_StreamDeserializer_pair\", \"pt2\"}\nopt := streaming.StreamDeserializerOption {\n    TableNames: sdMap,\n    Conn:        db,\n}\nsd, err := streaming.NewStreamDeserializer(\u0026opt)\nutil.AssertNil(err)\n```\n\n其中，TableNames 的键为不同输入表的标记，用于区分不同输入表的数据；TableNames 的值为表名，或由分区数据库地址和表名组成的列表（或元组）。订阅时，会通过构造时传入的 Conn 调用 schema 方法获得 TableNames 键值对应的表的结构，因此并不一定需要填输入表名，只需要和输入表结构一致即可。\n\n关于构造 DolphinDB 异构流表的具体脚本，请参照异构回放示例。\n\n**注意：**\n\n- 在 DolphinDB 中构造异构流表时，字典中 key 对应的表应为内存表或 replayDS 定义的数据源，请参考 replay。\n- API 端构造异构流表反序列化器时，TableNames 的值对应的表（可以为分区表、流表或者内存表）结构需要和 DolphinDB 中构造异构流表使用的表结构一致。\n\n#### 5.5.2. 订阅示例 1 （分区表数据源作为输入表）\n\n下例中，首先在 DolphinDB 中定义由两个分区表组合而成的异构流表。然后在 go 客户端定义异构流表反序列化器，放入回调类中使用。在回调中，反序列化器会根据指定表的结构反序列化数据，最后输出来自 msg1 和 msg2 的各 6 条数据。\n\n构造异构流表\n首先在 DolphinDB 中定义输出表，即要订阅的异构流表。\n\n```dolphindb\ntry{dropStreamTable(`outTables)}catch(ex){}\nshare streamTable(100:0, `timestampv`sym`blob`price1,[TIMESTAMP,SYMBOL,BLOB,DOUBLE]) as outTables\n然后定义两张输入表，均为分布式分区表。\n\nn = 6;\ndbName = 'dfs://test_StreamDeserializer_pair'\nif(existsDatabase(dbName)){\n    dropDB(dbName)}\ndb = database(dbName,RANGE,2012.01.01 2013.01.01 2014.01.01 2015.01.01 2016.01.01 2017.01.01 2018.01.01 2019.01.01)\ntable1 = table(100:0, `datetimev`timestampv`sym`price1`price2, [DATETIME, TIMESTAMP, SYMBOL, DOUBLE, DOUBLE])\ntable2 = table(100:0, `datetimev`timestampv`sym`price1, [DATETIME, TIMESTAMP, SYMBOL, DOUBLE])\ntableInsert(table1, 2012.01.01T01:21:23 + 1..n, 2018.12.01T01:21:23.000 + 1..n, take(`a`b`c,n), rand(100,n)+rand(1.0, n), rand(100,n)+rand(1.0, n))\ntableInsert(table2, 2012.01.01T01:21:23 + 1..n, 2018.12.01T01:21:23.000 + 1..n, take(`a`b`c,n), rand(100,n)+rand(1.0, n))\npt1 = db.createPartitionedTable(table1,'pt1',`datetimev).append!(table1)\npt2 = db.createPartitionedTable(table2,'pt2',`datetimev).append!(table2)\n```\n\n将分区表转为数据源后进行回放。\n\n```dolphindb\nre1 = replayDS(sqlObj=\u003cselect * from pt1\u003e, dateColumn=`datetimev, timeColumn=`timestampv)\nre2 = replayDS(sqlObj=\u003cselect * from pt2\u003e, dateColumn=`datetimev, timeColumn=`timestampv)\nd = dict(['msg1', 'msg2'], [re1, re2])\nreplay(inputTables=d, outputTables=`outTables, dateColumn=`timestampv, timeColumn=`timestampv)\n```\n\n**订阅异构流表**\n\n定义异构流表反序列化器\n\n```go\ntype sampleHandler struct {\n\tsd streaming.StreamDeserializer\n}\n\nfunc (s *sampleHandler) DoEvent(msg streaming.IMessage) {\n\tret, err := s.sd.Parse(msg)\n\tutil.AssertNil(err)\n\tfmt.Print(ret.GetSym(), \": \")\n\tfor i := 0; i \u003c ret.Size(); i++ {\n\t\tfmt.Print(ret.GetValue(i).String(), \" \")\n\t}\n\tfmt.Println()\n}\n```\n\n构造反序列化器，建立订阅。\n\n```go\nhost := \"localhost:8848\";\ndb, err := api.NewDolphinDBClient(context.TODO(), host, nil)\n\nutil.AssertNil(err)\nloginReq := \u0026api.LoginRequest{\n    UserID:   \"admin\",\n    Password: \"123456\",\n}\n\nerr = db.Connect()\nutil.AssertNil(err)\n\n// 由于需要从分区表中获取 schema，连接需要有读取分区表的权限，因此需要 login\nerr = db.Login(loginReq)\nutil.AssertNil(err)\n\nsdMap := make(map[string][2]string)\nsdMap[\"msg1\"] = [2]string{\"dfs://test_StreamDeserializer_pair\", \"pt1\"}\nsdMap[\"msg2\"] = [2]string{\"dfs://test_StreamDeserializer_pair\", \"pt2\"}\n\nopt := streaming.StreamDeserializerOption {\n    TableNames: sdMap,\n    Conn:       db,\n}\nsd, err := streaming.NewStreamDeserializer(\u0026opt)\nutil.AssertNil(err)\nsh := sampleHandler{*sd}\n\nclient := streaming.NewGoroutineClient(\"localhost\", 8848)\nreq := \u0026streaming.SubscribeRequest{\n    Address:    \"localhost:8848\",\n    TableName:  \"outTables\",\n    ActionName: \"action1\",\n    Handler:    \u0026sh,\n    Offset:     0,\n    Reconnect:  true,\n}\n\nerr = client.Subscribe(req)\nutil.AssertNil(err)\n```\n\n输出结果如下所示：\n\n```\nmsg2: datetime(2012.01.01T01:21:24) timestamp(2018.12.01T01:21:23.001) symbol(a) double(83.35676231770776)\nmsg1: datetime(2012.01.01T01:21:24) timestamp(2018.12.01T01:21:23.001) symbol(a) double(75.4657824053429) double(97.13305225968361)\nmsg2: datetime(2012.01.01T01:21:25) timestamp(2018.12.01T01:21:23.002) symbol(b) double(35.515043841674924)\nmsg1: datetime(2012.01.01T01:21:25) timestamp(2018.12.01T01:21:23.002) symbol(b) double(23.185342324199155) double(77.459053135477)\nmsg2: datetime(2012.01.01T01:21:26) timestamp(2018.12.01T01:21:23.003) symbol(c) double(52.076686951797456)\nmsg1: datetime(2012.01.01T01:21:26) timestamp(2018.12.01T01:21:23.003) symbol(c) double(37.12188130011782) double(85.8492015786469)\nmsg2: datetime(2012.01.01T01:21:27) timestamp(2018.12.01T01:21:23.004) symbol(a) double(95.41011125780642)\nmsg1: datetime(2012.01.01T01:21:27) timestamp(2018.12.01T01:21:23.004) symbol(a) double(8.328913665842265) double(46.2917776289396)\nmsg2: datetime(2012.01.01T01:21:28) timestamp(2018.12.01T01:21:23.005) symbol(b) double(61.37680379510857)\nmsg1: datetime(2012.01.01T01:21:28) timestamp(2018.12.01T01:21:23.005) symbol(b) double(58.61304935347289) double(36.23725011525676)\nmsg2: datetime(2012.01.01T01:21:29) timestamp(2018.12.01T01:21:23.006) symbol(c) double(41.78578492207453)\nmsg1: datetime(2012.01.01T01:21:29) timestamp(2018.12.01T01:21:23.006) symbol(c) double(92.92788873449899) double(20.860777587164193)\n```\n\n#### 5.5.3. 订阅示例 2 （内存表作为输入表）\n\n下例中，在 DolphinDB 中定义了一个由两个内存表构成的异构流表，并在 Go API 端使用共享内存表的表名构造反序列化器放入回调类中使用。进行订阅后，在回调中反序列化器会根据指定内存表的结构反序列化数据，输出来自 msg1 和 msg2 的各 6 条数据。\n\n**构造异构流表**\n\n``` dolphindb\ntry{dropStreamTable(`outTables)}catch(ex){}\n// 构造输出流表\nshare streamTable(100:0, `timestampv`sym`blob`price1,[TIMESTAMP,SYMBOL,BLOB,DOUBLE]) as outTables\n\nn = 6;\ntable1 = table(100:0, `datetimev`timestampv`sym`price1`price2, [DATETIME, TIMESTAMP, SYMBOL, DOUBLE, DOUBLE])\ntable2 = table(100:0, `datetimev`timestampv`sym`price1, [DATETIME, TIMESTAMP, SYMBOL, DOUBLE])\ntableInsert(table1, 2012.01.01T01:21:23 + 1..n, 2018.12.01T01:21:23.000 + 1..n, take(`a`b`c,n), rand(100,n)+rand(1.0, n), rand(100,n)+rand(1.0, n))\ntableInsert(table2, 2012.01.01T01:21:23 + 1..n, 2018.12.01T01:21:23.000 + 1..n, take(`a`b`c,n), rand(100,n)+rand(1.0, n))\nshare table1 as pt1\nshare table2 as pt2\n\nd = dict(['msg1', 'msg2'], [pt1, pt2])\nreplay(inputTables=d, outputTables=`outTables, dateColumn=`timestampv, timeColumn=`timestampv)\n```\n\n**订阅异构流表**\n\n定义异构流表反序列化器\n\n```go\ntype sampleHandler struct {\n\tsd streaming.StreamDeserializer\n}\n\nfunc (s *sampleHandler) DoEvent(msg streaming.IMessage) {\n\tret, err := s.sd.Parse(msg)\n\tutil.AssertNil(err)\n\tfmt.Print(ret.GetSym(), \": \")\n\tfor i := 0; i \u003c ret.Size(); i++ {\n\t\tfmt.Print(ret.GetValue(i).String(), \" \")\n\t}\n\tfmt.Println()\n}\n```\n\n构造异构流表反序列化器，建立订阅\n```go\nhost := \"localhost:8848\";\ndb, err := api.NewDolphinDBClient(context.TODO(), host, nil)\nutil.AssertNil(err)\nerr = db.Connect()\nutil.AssertNil(err)\n\nsdMap := make(map[string][2]string)\nsdMap[\"msg1\"] = [2]string{\"\", \"pt1\"}\nsdMap[\"msg2\"] = [2]string{\"\", \"pt2\"}\n\nopt := streaming.StreamDeserializerOption {\n    TableNames: sdMap,\n    Conn:       db,\n}\nsd, err := streaming.NewStreamDeserializer(\u0026opt)\nutil.AssertNil(err)\nsh := sampleHandler{*sd}\n\nclient := streaming.NewGoroutineClient(\"localhost\", 8848)\nreq := \u0026streaming.SubscribeRequest{\n    Address:    \"localhost:8848\",\n    TableName:  \"outTables\",\n    ActionName: \"action1\",\n    Handler:    \u0026sh,\n    Offset:     0,\n    Reconnect:  true,\n}\n\nerr = client.Subscribe(req)\nutil.AssertNil(err)\n```\n\n输出结果如下所示：\n\n```\nmsg2: datetime(2012.01.01T01:21:24) timestamp(2018.12.01T01:21:23.001) symbol(a) double(62.26562583283521)\nmsg1: datetime(2012.01.01T01:21:24) timestamp(2018.12.01T01:21:23.001) symbol(a) double(86.60560709564015) double(71.74879301246256)\nmsg2: datetime(2012.01.01T01:21:25) timestamp(2018.12.01T01:21:23.002) symbol(b) double(71.32683479157276)\nmsg1: datetime(2012.01.01T01:21:25) timestamp(2018.12.01T01:21:23.002) symbol(b) double(33.54905600566417) double(42.505714672384784)\nmsg2: datetime(2012.01.01T01:21:26) timestamp(2018.12.01T01:21:23.003) symbol(c) double(67.46220325306058)\nmsg1: datetime(2012.01.01T01:21:26) timestamp(2018.12.01T01:21:23.003) symbol(c) double(8.642998456256464) double(1.5548617043532431)\nmsg2: datetime(2012.01.01T01:21:27) timestamp(2018.12.01T01:21:23.004) symbol(a) double(89.0488296393305)\nmsg1: datetime(2012.01.01T01:21:27) timestamp(2018.12.01T01:21:23.004) symbol(a) double(11.882882460951805) double(37.95611710567027)\nmsg2: datetime(2012.01.01T01:21:28) timestamp(2018.12.01T01:21:23.005) symbol(b) double(54.69719312619418)\nmsg1: datetime(2012.01.01T01:21:28) timestamp(2018.12.01T01:21:23.005) symbol(b) double(79.26385991205461) double(74.8184056377504)\nmsg2: datetime(2012.01.01T01:21:29) timestamp(2018.12.01T01:21:23.006) symbol(c) double(36.771339072613046)\nmsg1: datetime(2012.01.01T01:21:29) timestamp(2018.12.01T01:21:23.006) symbol(c) double(25.953028398565948) double(60.92494275630452)\n```\n\n## 6. 工具方法\n\n### 6.1 model 包\n\n#### GetDataTypeString\n\n```go\nGetDataTypeString(t DataTypeByte) string\n```\n\n函数说明：\n\n根据传入的 t，得到数据类型的字符串表示。\n\n示例：\n\n```go\ndts := model.GetDataTypeString(model.DtString)\nfmt.Println(dts)\n```\n\n#### GetDataFormString\n\n```go\nGetDataFormString(t DataFormByte) string\n```\n\n函数说明：\n\n根据传入的 t，得到数据形式的字符串表示。\n\n示例：\n\n```go\ndfs := model.GetDataFormString(model.DfTable)\nfmt.Println(dfs)\n```\n\n#### NewTableFromStruct\n\n```go\nNewTableFromStruct(obj interface{}) (*Table, error)\n```\n\n函数说明：\n\n将传入的 obj 转成 Table 对象。\n\n入参说明：\n\nobj 可以为任意结构体对象，但是该结构体字段类型需要为数组，且字段带有以 `dolphindb` 开头的特定 tag，如 `dolphindb:\"column:name;type:string\"`。\n其中，column 后为列名，type 后为列数据类型(通过 model.GetDataTypeString 获取)。字段类型需要跟列数据类型匹配。\n\n示例：\n\n```go\ntype Example struct {\n    Name []string `dolphindb:\"column:name;type:string\"`\n}\n\nfunc main() {\n    val := \u0026Example{\n        Name: []string{\"Jane\",\"BOB\"},\n    }\n\n    tb,err := model.NewTableFromStruct(val)\n    if err != nil {\n        fmt.Println(err)\n        return\n    }\n    fmt.Println(tb)\n}\n```\n\n#### NewTableFromRawData\n\n```go\nNewTableFromRawData(colNames []string, colTypes []DataTypeByte, colValues []interface{}) (*Table, error)\n```\n\n函数说明：\n\n根据传入的 colNames, colTypes 和 colValues, 生成一个 Table 对象。\ncolNames 为表中列名的数组。\ncolTypes 为表中列类型的数组。\ncolValues 为表中列值的数组，可以根据[对照表](#3312-newdatatypelistfromrawdata-入参对照表)来赋值。\n\n示例：\n\n```go\nfunc main() {\n    colNames := []string{\"name\", \"id\"}\n    colTypes := []model.DataTypeByte{model.DtString, model.DtInt}\n    colValues := []interface{}{[]string{\"Tom\", \"Bob\"}, []int32{1, 2}}\n    tb, err := model.NewTableFromRawData(colNames, colTypes, colValues)\n    if err != nil {\n        return\n    }\n    fmt.Println(tb)\n}\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdolphindb%2Fapi-go","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fdolphindb%2Fapi-go","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdolphindb%2Fapi-go/lists"}