├── .codecov.yml ├── .editorconfig ├── .gitattributes ├── .github ├── ISSUE_TEMPLATE │ └── bug_report.md ├── dependabot.yml ├── pull_request_template.md ├── release.yml ├── stale.yml └── workflows │ ├── cover.yml │ ├── e2e.yml │ ├── pr.yml │ └── x.yml ├── .gitignore ├── .golangci.yml ├── AUTHORS ├── LICENSE ├── Makefile ├── README.md ├── _golden ├── test_arr_ipv6_block.hex ├── test_arr_ipv6_block.raw ├── test_arr_str_block.hex └── test_arr_str_block.raw ├── block_fuzz_test.go ├── ch.go ├── chpool ├── client.go ├── client_test.go ├── common_test.go ├── conn.go ├── doc.go ├── pool.go └── pool_test.go ├── cht ├── cht.go ├── cht_test.go ├── clickhouse.server.xml ├── clickhouse.users.xml ├── config.go ├── config_test.go ├── doc.go ├── local_test.go ├── log.go ├── log_test.go └── tls │ ├── clickhouse_test_ca.crt │ ├── clickhouse_test_ca.key │ ├── clickhouse_test_client.crt │ ├── clickhouse_test_client.key │ ├── clickhouse_test_server.crt │ ├── clickhouse_test_server.key │ └── tls_test.go ├── client.go ├── client_test.go ├── compress ├── _golden │ ├── data_compressed_lz4.hex │ ├── data_compressed_lz4.raw │ ├── data_compressed_lz4_hc.hex │ ├── data_compressed_lz4_hc.raw │ ├── data_compressed_lz4hc.hex │ ├── data_compressed_lz4hc.raw │ ├── data_compressed_none.hex │ ├── data_compressed_none.raw │ ├── data_compressed_zstd.hex │ ├── data_compressed_zstd.raw │ ├── data_raw.hex │ └── data_raw.raw ├── compress.go ├── compress_test.go ├── fuzz_test.go ├── method_enum.go ├── reader.go ├── reader_test.go └── writer.go ├── compression_enum.go ├── error_test.go ├── example_test.go ├── examples └── insert │ └── main.go ├── go.coverage.sh ├── go.mod ├── go.sum ├── go.test.sh ├── handshake.go ├── handshake_test.go ├── insert_bench_test.go ├── internal ├── cmd │ ├── app │ │ └── app.go │ ├── ch-bench-numbers-concurrent │ │ └── main.go │ ├── ch-bench-numbers │ │ └── main.go │ ├── ch-bench-rnd │ │ ├── README.md │ │ └── main.go │ ├── ch-bench-server │ │ └── main.go │ ├── ch-bench-str │ │ └── main.go │ ├── ch-bench-trace-id │ │ └── main.go │ ├── ch-compression │ │ └── main.go │ ├── ch-dl │ │ ├── go.mod │ │ ├── go.sum │ │ └── main.go │ ├── ch-ex-numbers │ │ └── main.go │ ├── ch-insert-lag │ │ └── main.go │ ├── ch-low-cord │ │ └── main.go │ ├── ch-native-dump │ │ ├── main.go │ │ └── test.sh │ └── ch-version │ │ └── main.go ├── e2e │ └── e2e.go ├── gold │ ├── _golden │ │ ├── file.hex │ │ ├── file.raw │ │ └── hello.txt │ ├── gold.go │ └── gold_test.go ├── version │ ├── version.go │ └── version_test.go └── ztest │ ├── doc.go │ ├── logger.go │ └── logger_test.go ├── otel_test.go ├── otelch ├── keys.go ├── otelch.go └── version.go ├── ping.go ├── ping_test.go ├── proto ├── _golden │ ├── block_int8_uint64.hex │ ├── block_int8_uint64.raw │ ├── block_title_data.hex │ ├── block_title_data.raw │ ├── buffer.hex │ ├── buffer.raw │ ├── client_hello.hex │ ├── client_hello.raw │ ├── client_info.hex │ ├── client_info.raw │ ├── client_info_otel.hex │ ├── client_info_otel.raw │ ├── col_arr_byte128.hex │ ├── col_arr_byte128.raw │ ├── col_arr_byte16.hex │ ├── col_arr_byte16.raw │ ├── col_arr_byte256.hex │ ├── col_arr_byte256.raw │ ├── col_arr_byte32.hex │ ├── col_arr_byte32.raw │ ├── col_arr_byte512.hex │ ├── col_arr_byte512.raw │ ├── col_arr_byte64.hex │ ├── col_arr_byte64.raw │ ├── col_arr_byte8.hex │ ├── col_arr_byte8.raw │ ├── col_arr_decimal128.hex │ ├── col_arr_decimal128.raw │ ├── col_arr_decimal256.hex │ ├── col_arr_decimal256.raw │ ├── col_arr_decimal32.hex │ ├── col_arr_decimal32.raw │ ├── col_arr_decimal64.hex │ ├── col_arr_decimal64.raw │ ├── col_arr_enum16.hex │ ├── col_arr_enum16.raw │ ├── col_arr_enum8.hex │ ├── col_arr_enum8.raw │ ├── col_arr_float32.hex │ ├── col_arr_float32.raw │ ├── col_arr_float64.hex │ ├── col_arr_float64.raw │ ├── col_arr_int128.hex │ ├── col_arr_int128.raw │ ├── col_arr_int16.hex │ ├── col_arr_int16.raw │ ├── col_arr_int256.hex │ ├── col_arr_int256.raw │ ├── col_arr_int32.hex │ ├── col_arr_int32.raw │ ├── col_arr_int64.hex │ ├── col_arr_int64.raw │ ├── col_arr_int8.hex │ ├── col_arr_int8.raw │ ├── col_arr_int8_manual.hex │ ├── col_arr_int8_manual.raw │ ├── col_arr_ipv4.hex │ ├── col_arr_ipv4.raw │ ├── col_arr_ipv6.hex │ ├── col_arr_ipv6.raw │ ├── col_arr_low_cardinality_u8_str.hex │ ├── col_arr_low_cardinality_u8_str.raw │ ├── col_arr_of_low_cord_str.hex │ ├── col_arr_of_low_cord_str.raw │ ├── col_arr_of_str.hex │ ├── col_arr_of_str.raw │ ├── col_arr_uint128.hex │ ├── col_arr_uint128.raw │ ├── col_arr_uint16.hex │ ├── col_arr_uint16.raw │ ├── col_arr_uint256.hex │ ├── col_arr_uint256.raw │ ├── col_arr_uint32.hex │ ├── col_arr_uint32.raw │ ├── col_arr_uint64.hex │ ├── col_arr_uint64.raw │ ├── col_arr_uint8.hex │ ├── col_arr_uint8.raw │ ├── col_bool.hex │ ├── col_bool.raw │ ├── col_byte128.hex │ ├── col_byte128.raw │ ├── col_byte16.hex │ ├── col_byte16.raw │ ├── col_byte256.hex │ ├── col_byte256.raw │ ├── col_byte32.hex │ ├── col_byte32.raw │ ├── col_byte512.hex │ ├── col_byte512.raw │ ├── col_byte64.hex │ ├── col_byte64.raw │ ├── col_byte8.hex │ ├── col_byte8.raw │ ├── col_date.hex │ ├── col_date.raw │ ├── col_date32.hex │ ├── col_date32.raw │ ├── col_datetime.hex │ ├── col_datetime.raw │ ├── col_datetime64.hex │ ├── col_datetime64.raw │ ├── col_decimal128.hex │ ├── col_decimal128.raw │ ├── col_decimal256.hex │ ├── col_decimal256.raw │ ├── col_decimal32.hex │ ├── col_decimal32.raw │ ├── col_decimal64.hex │ ├── col_decimal64.raw │ ├── col_enum16.hex │ ├── col_enum16.raw │ ├── col_enum8.hex │ ├── col_enum8.raw │ ├── col_fixed_str.hex │ ├── col_fixed_str.raw │ ├── col_float32.hex │ ├── col_float32.raw │ ├── col_float64.hex │ ├── col_float64.raw │ ├── col_int128.hex │ ├── col_int128.raw │ ├── col_int16.hex │ ├── col_int16.raw │ ├── col_int256.hex │ ├── col_int256.raw │ ├── col_int32.hex │ ├── col_int32.raw │ ├── col_int64.hex │ ├── col_int64.raw │ ├── col_int8.hex │ ├── col_int8.raw │ ├── col_interval.hex │ ├── col_interval.raw │ ├── col_ipv4.hex │ ├── col_ipv4.raw │ ├── col_ipv4_netaddr.hex │ ├── col_ipv4_netaddr.raw │ ├── col_ipv6.hex │ ├── col_ipv6.raw │ ├── col_ipv6_netaddr.hex │ ├── col_ipv6_netaddr.raw │ ├── col_json_str.hex │ ├── col_json_str.raw │ ├── col_json_str_bytes.hex │ ├── col_json_str_bytes.raw │ ├── col_low_cardinality_i_str_k_8.hex │ ├── col_low_cardinality_i_str_k_8.raw │ ├── col_low_cardinality_of_str.hex │ ├── col_low_cardinality_of_str.raw │ ├── col_map_of_low_cardinality_str_str.hex │ ├── col_map_of_low_cardinality_str_str.raw │ ├── col_map_of_str_str.hex │ ├── col_map_of_str_str.raw │ ├── col_nothing_nullable.hex │ ├── col_nothing_nullable.raw │ ├── col_nullable_of_str.hex │ ├── col_nullable_of_str.raw │ ├── col_nullable_str.hex │ ├── col_nullable_str.raw │ ├── col_point.hex │ ├── col_point.raw │ ├── col_str.hex │ ├── col_str.raw │ ├── col_str_bytes.hex │ ├── col_str_bytes.raw │ ├── col_tuple_named_str_int64.hex │ ├── col_tuple_named_str_int64.raw │ ├── col_tuple_str_int64.hex │ ├── col_tuple_str_int64.raw │ ├── col_uint128.hex │ ├── col_uint128.raw │ ├── col_uint16.hex │ ├── col_uint16.raw │ ├── col_uint256.hex │ ├── col_uint256.raw │ ├── col_uint32.hex │ ├── col_uint32.raw │ ├── col_uint64.hex │ ├── col_uint64.raw │ ├── col_uint8.hex │ ├── col_uint8.raw │ ├── col_uuid.hex │ ├── col_uuid.raw │ ├── column_of_byte_arr_16.hex │ ├── column_of_byte_arr_16.raw │ ├── column_of_bytes.hex │ ├── column_of_bytes.raw │ ├── column_of_json_bytes.hex │ ├── column_of_json_bytes.raw │ ├── column_of_str.hex │ ├── column_of_str.raw │ ├── progress.hex │ ├── progress.raw │ ├── query_create_db.hex │ ├── query_create_db.raw │ ├── query_otel.hex │ ├── query_otel.raw │ ├── type │ │ ├── Block.hex │ │ ├── Block.raw │ │ ├── ClientData.hex │ │ ├── ClientData.raw │ │ ├── Exception.hex │ │ ├── Exception.raw │ │ ├── Profile.hex │ │ ├── Profile.raw │ │ ├── ServerHello.hex │ │ ├── ServerHello.raw │ │ ├── TableColumns.hex │ │ └── TableColumns.raw │ ├── uint256_100.hex │ └── uint256_100.raw ├── _testdata │ ├── select_lc.raw │ └── test_dump_native.raw ├── block.go ├── block_test.go ├── bool.go ├── buffer.go ├── buffer_test.go ├── client_code.go ├── client_code_enum.go ├── client_data.go ├── client_data_test.go ├── client_hello.go ├── client_hello_test.go ├── client_info.go ├── client_info_interface_enum.go ├── client_info_query_enum.go ├── client_info_test.go ├── cmd │ └── ch-gen-col │ │ ├── infer.go.tmpl │ │ ├── main.go │ │ ├── main.go.tmpl │ │ ├── safe.go.tmpl │ │ ├── test.go.tmpl │ │ └── unsafe.go.tmpl ├── col_arr.go ├── col_arr_go123.go ├── col_arr_go123_test.go ├── col_arr_test.go ├── col_auto.go ├── col_auto_gen.go ├── col_auto_test.go ├── col_bool.go ├── col_bool_safe.go ├── col_bool_test.go ├── col_bool_unsafe.go ├── col_date.go ├── col_date32.go ├── col_date32_gen.go ├── col_date32_gen_test.go ├── col_date32_safe_gen.go ├── col_date32_unsafe_gen.go ├── col_date_gen.go ├── col_date_gen_test.go ├── col_date_safe_gen.go ├── col_date_unsafe_gen.go ├── col_datetime.go ├── col_datetime64.go ├── col_datetime64_gen_test.go ├── col_datetime64_safe_gen.go ├── col_datetime64_unsafe_gen.go ├── col_datetime_gen_test.go ├── col_datetime_safe_gen.go ├── col_datetime_unsafe_gen.go ├── col_decimal128_gen.go ├── col_decimal128_gen_test.go ├── col_decimal128_safe_gen.go ├── col_decimal128_unsafe_gen.go ├── col_decimal256_gen.go ├── col_decimal256_gen_test.go ├── col_decimal256_safe_gen.go ├── col_decimal256_unsafe_gen.go ├── col_decimal32_gen.go ├── col_decimal32_gen_test.go ├── col_decimal32_safe_gen.go ├── col_decimal32_unsafe_gen.go ├── col_decimal64_gen.go ├── col_decimal64_gen_test.go ├── col_decimal64_safe_gen.go ├── col_decimal64_unsafe_gen.go ├── col_enum.go ├── col_enum16_gen.go ├── col_enum16_gen_test.go ├── col_enum16_safe_gen.go ├── col_enum16_unsafe_gen.go ├── col_enum8_gen.go ├── col_enum8_gen_test.go ├── col_enum8_safe_gen.go ├── col_enum8_unsafe_gen.go ├── col_fixed_str.go ├── col_fixed_str_test.go ├── col_fixedstr128_gen.go ├── col_fixedstr128_gen_test.go ├── col_fixedstr128_safe_gen.go ├── col_fixedstr128_unsafe_gen.go ├── col_fixedstr16_gen.go ├── col_fixedstr16_gen_test.go ├── col_fixedstr16_safe_gen.go ├── col_fixedstr16_unsafe_gen.go ├── col_fixedstr256_gen.go ├── col_fixedstr256_gen_test.go ├── col_fixedstr256_safe_gen.go ├── col_fixedstr256_unsafe_gen.go ├── col_fixedstr32_gen.go ├── col_fixedstr32_gen_test.go ├── col_fixedstr32_safe_gen.go ├── col_fixedstr32_unsafe_gen.go ├── col_fixedstr512_gen.go ├── col_fixedstr512_gen_test.go ├── col_fixedstr512_safe_gen.go ├── col_fixedstr512_unsafe_gen.go ├── col_fixedstr64_gen.go ├── col_fixedstr64_gen_test.go ├── col_fixedstr64_safe_gen.go ├── col_fixedstr64_unsafe_gen.go ├── col_fixedstr8_gen.go ├── col_fixedstr8_gen_test.go ├── col_fixedstr8_safe_gen.go ├── col_fixedstr8_unsafe_gen.go ├── col_float32_gen.go ├── col_float32_gen_test.go ├── col_float32_safe_gen.go ├── col_float32_unsafe_gen.go ├── col_float64_gen.go ├── col_float64_gen_test.go ├── col_float64_safe_gen.go ├── col_float64_unsafe_gen.go ├── col_int128_gen.go ├── col_int128_gen_test.go ├── col_int128_safe_gen.go ├── col_int128_unsafe_gen.go ├── col_int16_gen.go ├── col_int16_gen_test.go ├── col_int16_safe_gen.go ├── col_int16_unsafe_gen.go ├── col_int256_gen.go ├── col_int256_gen_test.go ├── col_int256_safe_gen.go ├── col_int256_unsafe_gen.go ├── col_int32_gen.go ├── col_int32_gen_test.go ├── col_int32_safe_gen.go ├── col_int32_unsafe_gen.go ├── col_int64_gen.go ├── col_int64_gen_test.go ├── col_int64_safe_gen.go ├── col_int64_unsafe_gen.go ├── col_int8_gen.go ├── col_int8_gen_test.go ├── col_int8_safe_gen.go ├── col_int8_unsafe_gen.go ├── col_interval.go ├── col_interval_test.go ├── col_ipv4_gen.go ├── col_ipv4_gen_test.go ├── col_ipv4_safe_gen.go ├── col_ipv4_unsafe_gen.go ├── col_ipv6_gen.go ├── col_ipv6_gen_test.go ├── col_ipv6_safe_gen.go ├── col_ipv6_unsafe_gen.go ├── col_json_str.go ├── col_json_str_test.go ├── col_low_cardinality.go ├── col_low_cardinality_enum.go ├── col_low_cardinality_raw.go ├── col_low_cardinality_raw_test.go ├── col_low_cardinality_test.go ├── col_map.go ├── col_map_go123.go ├── col_map_go123_test.go ├── col_map_test.go ├── col_nothing.go ├── col_nothing_test.go ├── col_nullable.go ├── col_nullable_test.go ├── col_point.go ├── col_point_test.go ├── col_raw.go ├── col_raw_of.go ├── col_raw_of_test.go ├── col_raw_test.go ├── col_str.go ├── col_str_test.go ├── col_tuple.go ├── col_tuple_test.go ├── col_uint128_gen.go ├── col_uint128_gen_test.go ├── col_uint128_safe_gen.go ├── col_uint128_unsafe_gen.go ├── col_uint16_gen.go ├── col_uint16_gen_test.go ├── col_uint16_safe_gen.go ├── col_uint16_unsafe_gen.go ├── col_uint256_gen.go ├── col_uint256_gen_test.go ├── col_uint256_safe_gen.go ├── col_uint256_unsafe_gen.go ├── col_uint32_gen.go ├── col_uint32_gen_test.go ├── col_uint32_safe_gen.go ├── col_uint32_unsafe_gen.go ├── col_uint64_gen.go ├── col_uint64_gen_test.go ├── col_uint64_safe_gen.go ├── col_uint64_unsafe_gen.go ├── col_uint8_gen.go ├── col_uint8_gen_test.go ├── col_uint8_safe_gen.go ├── col_uuid.go ├── col_uuid_safe.go ├── col_uuid_test.go ├── col_uuid_unsafe.go ├── column.go ├── column_test.go ├── compression.go ├── compression_enum.go ├── date.go ├── date32.go ├── date32_test.go ├── date_test.go ├── datetime.go ├── datetime64.go ├── datetime64_test.go ├── datetime_test.go ├── decimal.go ├── decimal_test.go ├── dump_external_test.go ├── dump_test.go ├── enum16.go ├── enum8.go ├── error.go ├── error_codes.go ├── error_enum.go ├── error_test.go ├── exception.go ├── exception_test.go ├── feature.go ├── feature_enum.go ├── gen.go ├── gold_test.go ├── int128.go ├── int128_test.go ├── int256.go ├── int256_test.go ├── interval_enum.go ├── ipv4.go ├── ipv4_test.go ├── ipv6.go ├── ipv6_test.go ├── profile.go ├── profile_enum.go ├── profile_events.go ├── profile_test.go ├── progress.go ├── progress_test.go ├── proto.go ├── proto_test.go ├── query.go ├── query_fuzz_test.go ├── query_test.go ├── reader.go ├── reader_test.go ├── reset.go ├── results.go ├── server_code.go ├── server_code_enum.go ├── server_hello.go ├── server_hello_test.go ├── server_log.go ├── slice_unsafe.go ├── stage.go ├── stage_enum.go ├── table_columns.go ├── table_columns_test.go └── writer.go ├── query.go ├── query_metrics.go ├── query_params.go ├── query_params_test.go ├── query_raw_test.go ├── query_test.go ├── server.go ├── server_test.go ├── tools.go ├── tracing_test.go └── tuple_test.go /.codecov.yml: -------------------------------------------------------------------------------- 1 | ignore: 2 | - "**/main.go" 3 | - "**/*_enum.go" 4 | - "*_enum.go" 5 | - "./internal/cht/*" 6 | - "./internal/e2e/*" 7 | - "./internal/cmd/*" 8 | - "./internal/gold/*" 9 | coverage: 10 | status: 11 | project: false 12 | patch: false 13 | -------------------------------------------------------------------------------- /.editorconfig: -------------------------------------------------------------------------------- 1 | # http://editorconfig.org/ 2 | 3 | root = true 4 | 5 | [*] 6 | charset = utf-8 7 | insert_final_newline = true 8 | trim_trailing_whitespace = true 9 | end_of_line = lf 10 | 11 | [{*.go, go.mod, *.tpl}] 12 | indent_style = tab 13 | indent_size = 4 14 | 15 | [{*.yml,*.yaml}] 16 | indent_style = space 17 | indent_size = 2 18 | 19 | [*.py] 20 | indent_style = space 21 | indent_size = 4 22 | 23 | # Makefiles always use tabs for indentation 24 | [Makefile] 25 | indent_style = tab 26 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | *.raw linguist-generated 2 | *.tpl linguist-language=Go 3 | *.raw binary 4 | *.hex text 5 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | title: '' 5 | labels: bug 6 | assignees: '' 7 | 8 | --- 9 | 10 | 11 | ### Describe the bug 12 | 13 | ### Steps to reproduce 14 | 1. 15 | 2. 16 | 3. 17 | 18 | ### Expected behaviour 19 | 20 | ### Code example 21 | ```go 22 | ``` 23 | ### Error log 24 | 25 | ### Configuration 26 | #### Environment 27 | * Client version: 28 | * Language version: 29 | * OS: 30 | 31 | #### ClickHouse server 32 | * ClickHouse Server version: 33 | * ClickHouse Server non-default settings, if any: 34 | * `CREATE TABLE` statements for tables involved: 35 | * Sample data for all these tables, use [clickhouse-obfuscator](https://github.com/ClickHouse/ClickHouse/blob/master/programs/obfuscator/Obfuscator.cpp#L42-L80) if necessary 36 | -------------------------------------------------------------------------------- /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | updates: 3 | - package-ecosystem: gomod 4 | directory: "/" 5 | schedule: 6 | interval: daily 7 | groups: 8 | opentelemetry: 9 | patterns: 10 | - "go.opentelemetry.io/*" 11 | - package-ecosystem: github-actions 12 | directory: "/" 13 | schedule: 14 | interval: daily 15 | -------------------------------------------------------------------------------- /.github/pull_request_template.md: -------------------------------------------------------------------------------- 1 | ## Summary 2 | 3 | 4 | ## Checklist 5 | Delete items not relevant to your PR: 6 | - [ ] Unit and integration tests covering the common scenarios were added 7 | - [ ] A human-readable description of the changes was provided to include in CHANGELOG 8 | - [ ] For significant changes, documentation in https://github.com/ClickHouse/clickhouse-docs was updated with further explanations or tutorials 9 | -------------------------------------------------------------------------------- /.github/release.yml: -------------------------------------------------------------------------------- 1 | changelog: 2 | exclude: 3 | authors: 4 | - dependabot 5 | -------------------------------------------------------------------------------- /.github/stale.yml: -------------------------------------------------------------------------------- 1 | # Number of days of inactivity before an issue becomes stale 2 | daysUntilStale: 366 3 | 4 | # Number of days of inactivity before a stale issue is closed 5 | daysUntilClose: 30 6 | 7 | # Issues with these labels will never be considered stale 8 | exemptLabels: 9 | - pinned 10 | - security 11 | - bug 12 | - blocked 13 | - protected 14 | - triaged 15 | 16 | # Label to use when marking an issue as stale 17 | staleLabel: stale 18 | 19 | # Comment to post when marking an issue as stale. Set to `false` to disable 20 | markComment: > 21 | This issue has been automatically marked as stale because it has not had 22 | recent activity. It will be closed if no further activity occurs. Thank you 23 | for your contributions. 24 | 25 | # Comment to post when closing a stale issue. Set to `false` to disable 26 | closeComment: false -------------------------------------------------------------------------------- /.github/workflows/pr.yml: -------------------------------------------------------------------------------- 1 | name: pr 2 | 3 | on: 4 | pull_request: 5 | 6 | # Common Go workflows from go faster 7 | # See https://github.com/go-faster/x 8 | jobs: 9 | commit: 10 | uses: go-faster/x/.github/workflows/commit.yml@main 11 | -------------------------------------------------------------------------------- /.github/workflows/x.yml: -------------------------------------------------------------------------------- 1 | name: x 2 | 3 | on: 4 | push: 5 | branches: [main] 6 | pull_request: 7 | 8 | # Common Go workflows from go faster 9 | # See https://github.com/go-faster/x 10 | jobs: 11 | test: 12 | uses: go-faster/x/.github/workflows/test.yml@main 13 | lint: 14 | uses: go-faster/x/.github/workflows/lint.yml@main 15 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Binaries for programs and plugins 2 | *.exe 3 | *.exe~ 4 | *.dll 5 | *.so 6 | *.dylib 7 | 8 | # Test binary, built with `go test -c` 9 | *.test 10 | 11 | # Output of the go coverage tool, specifically when used with LiteIDE 12 | *.out 13 | 14 | # Dependency directories (remove the comment below to include it) 15 | # vendor/ 16 | 17 | # Editors 18 | .idea/ 19 | -------------------------------------------------------------------------------- /AUTHORS: -------------------------------------------------------------------------------- 1 | ClickHouse, LLC. 2 | The Go Faster Authors 3 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | test: 2 | @./go.test.sh 3 | .PHONY: test 4 | 5 | coverage: 6 | @./go.coverage.sh 7 | .PHONY: coverage 8 | 9 | test_fast: 10 | go test ./... 11 | 12 | tidy: 13 | go mod tidy 14 | -------------------------------------------------------------------------------- /_golden/test_arr_ipv6_block.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 00 02 ff ff ff ff 00 01 03 03 66 6f 6f 0b 41 |...........foo.A| 2 | 00000010 72 72 61 79 28 49 50 76 36 29 00 02 00 00 00 00 |rray(IPv6)......| 3 | 00000020 00 00 00 06 00 00 00 00 00 00 00 08 00 00 00 00 |................| 4 | 00000030 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 |................| 5 | 00000040 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00 00 |................| 6 | 00000050 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00 00 |................| 7 | 00000060 00 00 00 04 00 00 00 00 00 00 00 00 00 00 00 00 |................| 8 | 00000070 00 00 00 05 00 00 00 00 00 00 00 00 00 00 00 00 |................| 9 | 00000080 00 00 00 06 00 00 00 00 00 00 00 00 00 00 00 00 |................| 10 | 00000090 00 00 00 20 01 0d b8 00 00 00 00 00 00 00 00 00 |... ............| 11 | 000000a0 00 00 00 20 02 00 00 00 00 00 00 00 00 00 00 00 |... ............| 12 | 000000b0 00 00 00 |...| 13 | -------------------------------------------------------------------------------- /_golden/test_arr_ipv6_block.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/_golden/test_arr_ipv6_block.raw -------------------------------------------------------------------------------- /_golden/test_arr_str_block.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 00 02 ff ff ff ff 00 01 03 03 66 6f 6f 0d 41 |...........foo.A| 2 | 00000010 72 72 61 79 28 53 74 72 69 6e 67 29 00 02 00 00 |rray(String)....| 3 | 00000020 00 00 00 00 00 06 00 00 00 00 00 00 00 08 00 00 |................| 4 | 00000030 00 00 00 00 00 03 66 6f 6f 03 62 61 72 01 31 01 |......foo.bar.1.| 5 | 00000040 32 01 33 01 34 00 09 31 32 33 31 32 33 31 32 33 |2.3.4..123123123| 6 | -------------------------------------------------------------------------------- /_golden/test_arr_str_block.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/_golden/test_arr_str_block.raw -------------------------------------------------------------------------------- /ch.go: -------------------------------------------------------------------------------- 1 | // Package ch implements ClickHouse client. 2 | package ch 3 | -------------------------------------------------------------------------------- /chpool/client.go: -------------------------------------------------------------------------------- 1 | package chpool 2 | 3 | import ( 4 | "context" 5 | "time" 6 | 7 | "github.com/jackc/puddle/v2" 8 | 9 | "github.com/ClickHouse/ch-go" 10 | ) 11 | 12 | // Client is an acquired *ch.Client from a Pool. 13 | type Client struct { 14 | res *puddle.Resource[*connResource] 15 | p *Pool 16 | } 17 | 18 | // Release returns client to the pool. 19 | func (c *Client) Release() { 20 | if c.res == nil { 21 | return 22 | } 23 | 24 | client := c.client() 25 | 26 | if client.IsClosed() || time.Since(c.res.CreationTime()) > c.p.options.MaxConnLifetime { 27 | c.res.Destroy() 28 | return 29 | } 30 | 31 | c.res.Release() 32 | } 33 | 34 | func (c *Client) Do(ctx context.Context, q ch.Query) (err error) { 35 | return c.client().Do(ctx, q) 36 | } 37 | 38 | func (c *Client) Ping(ctx context.Context) error { 39 | return c.client().Ping(ctx) 40 | } 41 | 42 | func (c *Client) client() *ch.Client { 43 | return c.res.Value().client 44 | } 45 | -------------------------------------------------------------------------------- /chpool/client_test.go: -------------------------------------------------------------------------------- 1 | package chpool 2 | 3 | import ( 4 | "context" 5 | "testing" 6 | 7 | "github.com/stretchr/testify/require" 8 | ) 9 | 10 | func TestClient_Do(t *testing.T) { 11 | t.Parallel() 12 | p := PoolConn(t) 13 | conn, err := p.Acquire(context.Background()) 14 | require.NoError(t, err) 15 | defer conn.Release() 16 | 17 | testDo(t, conn) 18 | } 19 | 20 | func TestClient_Ping(t *testing.T) { 21 | t.Parallel() 22 | p := PoolConn(t) 23 | 24 | conn, err := p.Acquire(context.Background()) 25 | require.NoError(t, err) 26 | defer conn.Release() 27 | 28 | require.NoError(t, conn.Ping(context.Background())) 29 | } 30 | -------------------------------------------------------------------------------- /chpool/conn.go: -------------------------------------------------------------------------------- 1 | package chpool 2 | 3 | import ( 4 | "github.com/jackc/puddle/v2" 5 | 6 | "github.com/ClickHouse/ch-go" 7 | ) 8 | 9 | type connResource struct { 10 | client *ch.Client 11 | clients []Client 12 | } 13 | 14 | func (cr *connResource) getConn(p *Pool, res *puddle.Resource[*connResource]) *Client { 15 | if len(cr.clients) == 0 { 16 | cr.clients = make([]Client, 128) 17 | } 18 | 19 | c := &cr.clients[len(cr.clients)-1] 20 | cr.clients = cr.clients[0 : len(cr.clients)-1] 21 | 22 | c.res = res 23 | c.p = p 24 | 25 | return c 26 | } 27 | -------------------------------------------------------------------------------- /chpool/doc.go: -------------------------------------------------------------------------------- 1 | // Package chpool is a connection pool for ch. 2 | package chpool 3 | -------------------------------------------------------------------------------- /cht/config_test.go: -------------------------------------------------------------------------------- 1 | package cht 2 | 3 | import ( 4 | "bytes" 5 | "encoding/xml" 6 | "testing" 7 | 8 | "github.com/stretchr/testify/require" 9 | ) 10 | 11 | func logXML(t testing.TB, v interface{}) { 12 | buf := new(bytes.Buffer) 13 | e := xml.NewEncoder(buf) 14 | e.Indent("", " ") 15 | require.NoError(t, e.Encode(v)) 16 | t.Log(buf) 17 | } 18 | 19 | func TestKeeperConfig(t *testing.T) { 20 | v := KeeperConfig{ 21 | TCPPort: 2181, 22 | ServerID: 1, 23 | 24 | Raft: RaftConfig{ 25 | Servers: []RaftServer{ 26 | { 27 | ID: 1, 28 | Port: 9444, 29 | Hostname: "zoo1", 30 | }, 31 | }, 32 | }, 33 | } 34 | t.Run("Standalone", func(t *testing.T) { 35 | logXML(t, v) 36 | }) 37 | t.Run("Embedded", func(t *testing.T) { 38 | logXML(t, Config{ 39 | Keeper: &v, 40 | Macros: Map{ 41 | "shard": "01", 42 | "replica": "01", 43 | }, 44 | ZooKeeper: []ZooKeeperNode{ 45 | {Port: 2181, Host: "127.0.0.1"}, 46 | }, 47 | }) 48 | }) 49 | } 50 | -------------------------------------------------------------------------------- /cht/doc.go: -------------------------------------------------------------------------------- 1 | // Package cht implements running ClickHouse for tests. 2 | package cht 3 | -------------------------------------------------------------------------------- /cht/tls/clickhouse_test_ca.crt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIIBxDCCAWoCCQCC7Dz9F36rcTAKBggqhkjOPQQDAjBqMQswCQYDVQQGEwJVUzER 3 | MA8GA1UECAwIQ29sb3JhZG8xDzANBgNVBAcMBkRlbnZlcjEYMBYGA1UECgwPQ2xp 4 | Y2tIb3VzZSBJbmMuMR0wGwYDVQQDDBRjbGlja2hvdXNlX3Rlc3Rfcm9vdDAeFw0y 5 | MzA0MjYyMTM4MzhaFw00MzA0MjYyMTM4MzhaMGoxCzAJBgNVBAYTAlVTMREwDwYD 6 | VQQIDAhDb2xvcmFkbzEPMA0GA1UEBwwGRGVudmVyMRgwFgYDVQQKDA9DbGlja0hv 7 | dXNlIEluYy4xHTAbBgNVBAMMFGNsaWNraG91c2VfdGVzdF9yb290MFkwEwYHKoZI 8 | zj0CAQYIKoZIzj0DAQcDQgAE8ajzpmv1YDspmgGcE+KjB2SxAQJ2/awkkP/SBvjw 9 | enD0ibQG5fyA5vxhPv7ImbnqebPS1NXwIt4HCkLXKVPDnzAKBggqhkjOPQQDAgNI 10 | ADBFAiAlQ8IWL7OQua7/dFaE8xbFy/hoKnLvuigDg9MAJNJUXwIhAIa0c3pT6z9P 11 | OX2Sw5mfl/YEDTgsG033S1MeAha3707H 12 | -----END CERTIFICATE----- 13 | -------------------------------------------------------------------------------- /cht/tls/clickhouse_test_ca.key: -------------------------------------------------------------------------------- 1 | -----BEGIN EC PARAMETERS----- 2 | BggqhkjOPQMBBw== 3 | -----END EC PARAMETERS----- 4 | -----BEGIN EC PRIVATE KEY----- 5 | MHcCAQEEIJnlsMN+3VCxicEQcANLIM+4gMiItWwFam3moYINelVfoAoGCCqGSM49 6 | AwEHoUQDQgAE8ajzpmv1YDspmgGcE+KjB2SxAQJ2/awkkP/SBvjwenD0ibQG5fyA 7 | 5vxhPv7ImbnqebPS1NXwIt4HCkLXKVPDnw== 8 | -----END EC PRIVATE KEY----- 9 | -------------------------------------------------------------------------------- /cht/tls/clickhouse_test_client.crt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIIBuDCCAV8CCQCvYwZhuT/WEjAKBggqhkjOPQQDAjBqMQswCQYDVQQGEwJVUzER 3 | MA8GA1UECAwIQ29sb3JhZG8xDzANBgNVBAcMBkRlbnZlcjEYMBYGA1UECgwPQ2xp 4 | Y2tIb3VzZSBJbmMuMR0wGwYDVQQDDBRjbGlja2hvdXNlX3Rlc3Rfcm9vdDAeFw0y 5 | MzA0MjYyMjAzMjZaFw00MzA0MjYyMjAzMjZaMF8xCzAJBgNVBAYTAlVTMREwDwYD 6 | VQQIDAhDb2xvcmFkbzEPMA0GA1UEBwwGRGVudmVyMRgwFgYDVQQKDA9DbGlja0hv 7 | dXNlIEluYy4xEjAQBgNVBAMMCWNlcnRfdXNlcjBZMBMGByqGSM49AgEGCCqGSM49 8 | AwEHA0IABIEhqR0FcbBp0ZdQ6t9c9+rxRVS8TZXlPY2kGlFMkW5AY8/Y05L1q7Cx 9 | mJiwZl6+4U/j8m0EhtVREywb1PENR20wCgYIKoZIzj0EAwIDRwAwRAIgRp0AWMOq 10 | OA8lJTd1h2GrAWDMpiNamMUvLyksxLq5SrgCIA5AwncaSEqGHboq1zHMj0Qnqnua 11 | JQJAbhcsh4sxk8AY 12 | -----END CERTIFICATE----- 13 | -------------------------------------------------------------------------------- /cht/tls/clickhouse_test_client.key: -------------------------------------------------------------------------------- 1 | -----BEGIN EC PARAMETERS----- 2 | BggqhkjOPQMBBw== 3 | -----END EC PARAMETERS----- 4 | -----BEGIN EC PRIVATE KEY----- 5 | MHcCAQEEIJOyEogF0IPoVr1hkJ9wjp/6zhUH1LDgtay+OjG1/9XnoAoGCCqGSM49 6 | AwEHoUQDQgAEgSGpHQVxsGnRl1Dq31z36vFFVLxNleU9jaQaUUyRbkBjz9jTkvWr 7 | sLGYmLBmXr7hT+PybQSG1VETLBvU8Q1HbQ== 8 | -----END EC PRIVATE KEY----- 9 | -------------------------------------------------------------------------------- /cht/tls/clickhouse_test_server.crt: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIICrjCCAlSgAwIBAgIJAK9jBmG5P9YRMAoGCCqGSM49BAMCMGoxCzAJBgNVBAYT 3 | AlVTMREwDwYDVQQIDAhDb2xvcmFkbzEPMA0GA1UEBwwGRGVudmVyMRgwFgYDVQQK 4 | DA9DbGlja0hvdXNlIEluYy4xHTAbBgNVBAMMFGNsaWNraG91c2VfdGVzdF9yb290 5 | MB4XDTIzMDQyNjIxNTAxOVoXDTQzMDQyNjIxNTAxOVowbTELMAkGA1UEBhMCVVMx 6 | ETAPBgNVBAgMCENvbG9yYWRvMQ8wDQYDVQQHDAZEZW52ZXIxGDAWBgNVBAoMD0Ns 7 | aWNrSG91c2UgSW5jLjEgMB4GA1UEAwwXc2VydmVyMS5jbGlja2hvdXNlLnRlc3Qw 8 | WTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARhjivoy18D47i18Jqg6m9yI17ndMWA 9 | kuyPhXFLgW1PpU2wk3DvpUbkKUxUPlKsNwuHEKJ4kcparrrwWGxKT2Dmo4HfMIHc 10 | MIGEBgNVHSMEfTB7oW6kbDBqMQswCQYDVQQGEwJVUzERMA8GA1UECAwIQ29sb3Jh 11 | ZG8xDzANBgNVBAcMBkRlbnZlcjEYMBYGA1UECgwPQ2xpY2tIb3VzZSBJbmMuMR0w 12 | GwYDVQQDDBRjbGlja2hvdXNlX3Rlc3Rfcm9vdIIJAILsPP0XfqtxMAkGA1UdEwQC 13 | MAAwCwYDVR0PBAQDAgTwMDsGA1UdEQQ0MDKCF3NlcnZlcjEuY2xpY2tob3VzZS50 14 | ZXN0ghdzZXJ2ZXIyLmNsaWNraG91c2UudGVzdDAKBggqhkjOPQQDAgNIADBFAiBM 15 | 71Vx9q964BRd9+N0zpbax+N+jWFJQfkOic4wlsPZ7QIhAPBU9Kfbi3Iwy3XwWBOv 16 | YZsvoFRxUfG2RRRlz5cGgKIa 17 | -----END CERTIFICATE----- 18 | -------------------------------------------------------------------------------- /cht/tls/clickhouse_test_server.key: -------------------------------------------------------------------------------- 1 | -----BEGIN EC PARAMETERS----- 2 | BggqhkjOPQMBBw== 3 | -----END EC PARAMETERS----- 4 | -----BEGIN EC PRIVATE KEY----- 5 | MHcCAQEEIHU7VYTo4pduP7Q2wlE4zgg0Ruh3KFlwfdz1EHIanFgIoAoGCCqGSM49 6 | AwEHoUQDQgAEYY4r6MtfA+O4tfCaoOpvciNe53TFgJLsj4VxS4FtT6VNsJNw76VG 7 | 5ClMVD5SrDcLhxCieJHKWq668FhsSk9g5g== 8 | -----END EC PRIVATE KEY----- 9 | -------------------------------------------------------------------------------- /compress/_golden/data_compressed_lz4.hex: -------------------------------------------------------------------------------- 1 | 00000000 c5 bc bc 07 c1 1e c4 71 fd 74 af 8d 5b 0f 00 c5 |.......q.t..[...| 2 | 00000010 82 26 00 00 00 af 00 00 00 7f 48 65 6c 6c 6f 21 |.&........Hello!| 3 | 00000020 0a 07 00 82 00 93 00 00 9a 00 b0 6c 6f 21 0a 48 |...........lo!.H| 4 | 00000030 65 6c 6c 6f 21 0a |ello!.| 5 | -------------------------------------------------------------------------------- /compress/_golden/data_compressed_lz4.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/compress/_golden/data_compressed_lz4.raw -------------------------------------------------------------------------------- /compress/_golden/data_compressed_lz4_hc.hex: -------------------------------------------------------------------------------- 1 | 00000000 34 39 ad b3 8d 96 d2 87 bb 3b aa 1e 3f 4b 64 f5 |49.......;..?Kd.| 2 | 00000010 82 1d 00 00 00 af 00 00 00 8f 48 65 6c 6c 6f 21 |..........Hello!| 3 | 00000020 0a 48 07 00 8d 70 48 65 6c 6c 6f 21 0a |.H...pHello!.| 4 | -------------------------------------------------------------------------------- /compress/_golden/data_compressed_lz4_hc.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/compress/_golden/data_compressed_lz4_hc.raw -------------------------------------------------------------------------------- /compress/_golden/data_compressed_lz4hc.hex: -------------------------------------------------------------------------------- 1 | 00000000 34 39 ad b3 8d 96 d2 87 bb 3b aa 1e 3f 4b 64 f5 |49.......;..?Kd.| 2 | 00000010 82 1d 00 00 00 af 00 00 00 8f 48 65 6c 6c 6f 21 |..........Hello!| 3 | 00000020 0a 48 07 00 8d 70 48 65 6c 6c 6f 21 0a |.H...pHello!.| 4 | -------------------------------------------------------------------------------- /compress/_golden/data_compressed_lz4hc.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/compress/_golden/data_compressed_lz4hc.raw -------------------------------------------------------------------------------- /compress/_golden/data_compressed_none.hex: -------------------------------------------------------------------------------- 1 | 00000000 fc ed 07 b8 c5 59 e9 8c 16 61 17 0f 6c 52 72 df |.....Y...a..lRr.| 2 | 00000010 02 b8 00 00 00 af 00 00 00 48 65 6c 6c 6f 21 0a |.........Hello!.| 3 | 00000020 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 |Hello!.Hello!.He| 4 | 00000030 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c |llo!.Hello!.Hell| 5 | 00000040 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 |o!.Hello!.Hello!| 6 | 00000050 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 |.Hello!.Hello!.H| 7 | 00000060 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c |ello!.Hello!.Hel| 8 | 00000070 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f |lo!.Hello!.Hello| 9 | 00000080 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a |!.Hello!.Hello!.| 10 | 00000090 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 |Hello!.Hello!.He| 11 | 000000a0 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c |llo!.Hello!.Hell| 12 | 000000b0 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 |o!.Hello!.Hello!| 13 | 000000c0 0a 48 65 6c 6c 6f 21 0a |.Hello!.| 14 | -------------------------------------------------------------------------------- /compress/_golden/data_compressed_none.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/compress/_golden/data_compressed_none.raw -------------------------------------------------------------------------------- /compress/_golden/data_compressed_zstd.hex: -------------------------------------------------------------------------------- 1 | 00000000 16 77 b8 46 2a 48 37 48 80 40 e8 7d e7 8e 0d 09 |.w.F*H7H.@.}....| 2 | 00000010 90 25 00 00 00 af 00 00 00 28 b5 2f fd 04 00 7d |.%.......(./...}| 3 | 00000020 00 00 38 48 65 6c 6c 6f 21 0a 01 54 07 03 2b 25 |..8Hello!..T..+%| 4 | 00000030 05 eb 3d ca 06 |..=..| 5 | -------------------------------------------------------------------------------- /compress/_golden/data_compressed_zstd.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/compress/_golden/data_compressed_zstd.raw -------------------------------------------------------------------------------- /compress/_golden/data_raw.hex: -------------------------------------------------------------------------------- 1 | 00000000 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 |Hello!.Hello!.He| 2 | 00000010 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c |llo!.Hello!.Hell| 3 | 00000020 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 |o!.Hello!.Hello!| 4 | 00000030 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 |.Hello!.Hello!.H| 5 | 00000040 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c |ello!.Hello!.Hel| 6 | 00000050 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f |lo!.Hello!.Hello| 7 | 00000060 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a |!.Hello!.Hello!.| 8 | 00000070 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 |Hello!.Hello!.He| 9 | 00000080 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c |llo!.Hello!.Hell| 10 | 00000090 6f 21 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 |o!.Hello!.Hello!| 11 | 000000a0 0a 48 65 6c 6c 6f 21 0a 48 65 6c 6c 6f 21 0a |.Hello!.Hello!.| 12 | -------------------------------------------------------------------------------- /compress/_golden/data_raw.raw: -------------------------------------------------------------------------------- 1 | Hello! 2 | Hello! 3 | Hello! 4 | Hello! 5 | Hello! 6 | Hello! 7 | Hello! 8 | Hello! 9 | Hello! 10 | Hello! 11 | Hello! 12 | Hello! 13 | Hello! 14 | Hello! 15 | Hello! 16 | Hello! 17 | Hello! 18 | Hello! 19 | Hello! 20 | Hello! 21 | Hello! 22 | Hello! 23 | Hello! 24 | Hello! 25 | Hello! 26 | -------------------------------------------------------------------------------- /compress/fuzz_test.go: -------------------------------------------------------------------------------- 1 | package compress 2 | 3 | import ( 4 | "bytes" 5 | "encoding/binary" 6 | "io" 7 | "testing" 8 | 9 | "github.com/go-faster/city" 10 | "github.com/stretchr/testify/require" 11 | ) 12 | 13 | func FuzzWriter_Compress(f *testing.F) { 14 | f.Add([]byte("Hello, world!")) 15 | f.Add([]byte{}) 16 | f.Add([]byte{1, 2, 3, 4, 5}) 17 | f.Fuzz(func(t *testing.T, data []byte) { 18 | w := NewWriter(LevelZero, LZ4) 19 | require.NoError(t, w.Compress(data)) 20 | 21 | r := NewReader(bytes.NewReader(w.Data)) 22 | out := make([]byte, len(data)) 23 | _, err := io.ReadFull(r, out) 24 | require.NoError(t, err) 25 | require.Equal(t, data, out) 26 | }) 27 | } 28 | 29 | func FuzzReader_Read(f *testing.F) { 30 | for _, data := range [][]byte{ 31 | {}, 32 | []byte("Hello, world!"), 33 | {1, 2, 3, 4, 5}, 34 | } { 35 | w := NewWriter(LevelZero, LZ4) 36 | require.NoError(f, w.Compress(data)) 37 | f.Add(w.Data) 38 | } 39 | 40 | f.Fuzz(func(t *testing.T, data []byte) { 41 | if len(data) > headerSize { 42 | h := city.CH128(data[hMethod:]) 43 | binary.LittleEndian.PutUint64(data[0:8], h.Low) 44 | binary.LittleEndian.PutUint64(data[8:16], h.High) 45 | } 46 | 47 | r := NewReader(bytes.NewReader(data)) 48 | out := make([]byte, len(data)) 49 | _, _ = io.ReadFull(r, out) 50 | }) 51 | } 52 | -------------------------------------------------------------------------------- /compress/reader_test.go: -------------------------------------------------------------------------------- 1 | package compress 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/go-faster/city" 7 | "github.com/stretchr/testify/require" 8 | ) 9 | 10 | func TestFormatU128(t *testing.T) { 11 | v := city.CH128([]byte("Moscow")) 12 | require.Equal(t, "6ddf3eeebf17df2e559d40c605f3ae22", FormatU128(v)) 13 | } 14 | -------------------------------------------------------------------------------- /error_test.go: -------------------------------------------------------------------------------- 1 | package ch 2 | 3 | import ( 4 | "context" 5 | "io" 6 | "testing" 7 | 8 | "github.com/go-faster/errors" 9 | "github.com/stretchr/testify/assert" 10 | "github.com/stretchr/testify/require" 11 | "go.uber.org/multierr" 12 | 13 | "github.com/ClickHouse/ch-go/proto" 14 | ) 15 | 16 | func TestError(t *testing.T) { 17 | err := errors.Wrap(multierr.Append( 18 | errors.Wrap(io.EOF, "foo"), 19 | errors.Wrap(context.Canceled, "bar"), 20 | ), "parent") 21 | 22 | t.Log(err) 23 | assert.ErrorIs(t, err, io.EOF) 24 | assert.ErrorIs(t, err, context.Canceled) 25 | } 26 | 27 | func TestException_Error(t *testing.T) { 28 | err := errors.Wrap(multierr.Append( 29 | errors.Wrap(&Exception{ 30 | Code: proto.ErrBadArguments, 31 | }, "foo"), 32 | errors.Wrap(context.Canceled, "bar"), 33 | ), "parent") 34 | 35 | var ex *Exception 36 | require.ErrorAs(t, err, &ex) 37 | 38 | require.True(t, IsException(err), "IsException should be true") 39 | e, ok := AsException(err) 40 | require.True(t, ok) 41 | require.NotNil(t, e) 42 | 43 | require.True(t, IsErr(err, proto.ErrBadArguments)) 44 | require.False(t, IsErr(err, proto.ErrTableIsDropped)) 45 | require.False(t, IsErr(io.EOF, proto.ErrBadArguments)) 46 | } 47 | -------------------------------------------------------------------------------- /example_test.go: -------------------------------------------------------------------------------- 1 | package ch 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | 7 | "github.com/ClickHouse/ch-go/proto" 8 | ) 9 | 10 | func ExampleQuery_multipleInputColumns() { 11 | var ( 12 | body proto.ColStr 13 | name proto.ColStr 14 | sevText proto.ColEnum 15 | sevNumber proto.ColUInt8 16 | 17 | ts = new(proto.ColDateTime64).WithPrecision(proto.PrecisionNano) 18 | arr = new(proto.ColStr).Array() // Array(String) 19 | now = time.Date(2010, 1, 1, 10, 22, 33, 345678, time.UTC) 20 | ) 21 | // Append 10 rows. 22 | for i := 0; i < 10; i++ { 23 | body.AppendBytes([]byte("Hello")) 24 | ts.Append(now) 25 | name.Append("name") 26 | sevText.Values = append(sevText.Values, "INFO") 27 | sevNumber = append(sevNumber, 10) 28 | arr.Append([]string{"foo", "bar", "baz"}) 29 | } 30 | input := proto.Input{ 31 | {Name: "ts", Data: ts}, 32 | {Name: "severity_text", Data: &sevText}, 33 | {Name: "severity_number", Data: sevNumber}, 34 | {Name: "body", Data: body}, 35 | {Name: "name", Data: name}, 36 | {Name: "arr", Data: arr}, 37 | } 38 | fmt.Println(input.Into("logs")) 39 | 40 | // Output: 41 | // INSERT INTO "logs" ("ts","severity_text","severity_number","body","name","arr") VALUES 42 | } 43 | -------------------------------------------------------------------------------- /go.coverage.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | 5 | go test -race -v -coverpkg=./... -coverprofile=profile.out ./... 6 | go tool cover -func profile.out 7 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module github.com/ClickHouse/ch-go 2 | 3 | go 1.23.0 4 | 5 | toolchain go1.24.1 6 | 7 | require ( 8 | github.com/cenkalti/backoff/v4 v4.3.0 9 | github.com/dmarkham/enumer v1.5.11 10 | github.com/dustin/go-humanize v1.0.1 11 | github.com/go-faster/city v1.0.1 12 | github.com/go-faster/errors v0.7.1 13 | github.com/google/uuid v1.6.0 14 | github.com/hashicorp/go-version v1.7.0 15 | github.com/jackc/puddle/v2 v2.2.2 16 | github.com/klauspost/compress v1.18.0 17 | github.com/pierrec/lz4/v4 v4.1.22 18 | github.com/segmentio/asm v1.2.0 19 | github.com/stretchr/testify v1.10.0 20 | go.opentelemetry.io/otel v1.36.0 21 | go.opentelemetry.io/otel/metric v1.36.0 22 | go.opentelemetry.io/otel/sdk v1.36.0 23 | go.opentelemetry.io/otel/trace v1.36.0 24 | go.uber.org/multierr v1.11.0 25 | go.uber.org/zap v1.27.0 26 | golang.org/x/sync v0.14.0 27 | ) 28 | 29 | require ( 30 | github.com/davecgh/go-spew v1.1.1 // indirect 31 | github.com/go-logr/logr v1.4.2 // indirect 32 | github.com/go-logr/stdr v1.2.2 // indirect 33 | github.com/pascaldekloe/name v1.0.1 // indirect 34 | github.com/pmezard/go-difflib v1.0.0 // indirect 35 | go.opentelemetry.io/auto/sdk v1.1.0 // indirect 36 | golang.org/x/mod v0.23.0 // indirect 37 | golang.org/x/sys v0.33.0 // indirect 38 | golang.org/x/tools v0.30.0 // indirect 39 | gopkg.in/yaml.v3 v3.0.1 // indirect 40 | ) 41 | -------------------------------------------------------------------------------- /go.test.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | 5 | echo "test" 6 | go test --timeout 5m ./... 7 | 8 | echo "test -race" 9 | go test --timeout 5m -race ./... 10 | -------------------------------------------------------------------------------- /handshake_test.go: -------------------------------------------------------------------------------- 1 | package ch 2 | 3 | import ( 4 | "context" 5 | "testing" 6 | 7 | "github.com/stretchr/testify/require" 8 | 9 | "github.com/ClickHouse/ch-go/cht" 10 | "github.com/ClickHouse/ch-go/proto" 11 | ) 12 | 13 | func TestDial_Exception(t *testing.T) { 14 | t.Parallel() 15 | ctx := context.Background() 16 | server := cht.New(t) 17 | 18 | client, err := Dial(ctx, Options{ 19 | Address: server.TCP, 20 | Password: "invalid_password", 21 | }) 22 | 23 | var e *Exception 24 | require.Nil(t, client) 25 | require.ErrorAs(t, err, &e) 26 | require.Truef(t, IsErr(err, proto.ErrAuthenticationFailed, proto.ErrRequiredPassword), "got %v", err) 27 | } 28 | -------------------------------------------------------------------------------- /internal/cmd/app/app.go: -------------------------------------------------------------------------------- 1 | // Package app is helper for simple cli apps. 2 | package app 3 | 4 | import ( 5 | "context" 6 | "fmt" 7 | "os" 8 | 9 | "go.uber.org/zap" 10 | ) 11 | 12 | func Run(run func(ctx context.Context, lg *zap.Logger) error) { 13 | lg, err := zap.NewDevelopment() 14 | if err != nil { 15 | panic(err) 16 | } 17 | if err := run(context.Background(), lg); err != nil { 18 | fmt.Fprintf(os.Stderr, "Error: %+v\n", err) 19 | os.Exit(2) 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /internal/cmd/ch-bench-rnd/README.md: -------------------------------------------------------------------------------- 1 | # Results 2 | 3 | 4 | ``` 5 | String 2.908s 1.0 GB 344 MB/sec 28.66 million rows/sec 6 | Array(String) 1.452s 724 MB 499 MB/sec 19.13 million rows/sec 7 | UInt8 166ms 500 MB 3.0 GB/sec 3.01 billion rows/sec 8 | Float64 633ms 4.0 GB 6.3 GB/sec 789.69 million rows/sec 9 | DateTime 347ms 2.0 GB 5.8 GB/sec 1.44 billion rows/sec 10 | UInt64 629ms 4.0 GB 6.4 GB/sec 795.15 million rows/sec 11 | Array(UInt64) 1.824s 10 GB 5.5 GB/sec 274.18 million rows/sec 12 | Nullable(UInt64) 903ms 4.5 GB 5.0 GB/sec 553.77 million rows/sec 13 | UUID 1.531s 8.0 GB 5.2 GB/sec 326.56 million rows/sec 14 | ``` 15 | -------------------------------------------------------------------------------- /internal/cmd/ch-compression/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | "os" 7 | 8 | "github.com/go-faster/errors" 9 | 10 | "github.com/ClickHouse/ch-go" 11 | "github.com/ClickHouse/ch-go/proto" 12 | ) 13 | 14 | func run(ctx context.Context) error { 15 | c, err := ch.Dial(ctx, ch.Options{ 16 | Compression: ch.CompressionNone, 17 | }) 18 | if err != nil { 19 | return errors.Wrap(err, "dial") 20 | } 21 | defer func() { _ = c.Close() }() 22 | 23 | var result proto.Results 24 | selectStr := ch.Query{ 25 | Body: "SELECT 'foo' AS s", 26 | Result: result.Auto(), 27 | } 28 | 29 | if err := c.Do(ctx, selectStr); err != nil { 30 | return errors.Wrap(err, "select") 31 | } 32 | 33 | return nil 34 | } 35 | 36 | func main() { 37 | if err := run(context.Background()); err != nil { 38 | fmt.Fprintf(os.Stderr, "Error: %+v\n", err) 39 | os.Exit(2) 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /internal/cmd/ch-dl/go.mod: -------------------------------------------------------------------------------- 1 | module dl 2 | 3 | go 1.23.0 4 | 5 | toolchain go1.24.2 6 | 7 | require ( 8 | github.com/go-faster/errors v0.5.0 9 | github.com/google/go-github/v43 v43.0.0 10 | github.com/klauspost/compress v1.15.1 11 | golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be 12 | ) 13 | 14 | require ( 15 | github.com/golang/protobuf v1.3.2 // indirect 16 | github.com/google/go-querystring v1.1.0 // indirect 17 | golang.org/x/crypto v0.36.0 // indirect 18 | golang.org/x/net v0.38.0 // indirect 19 | google.golang.org/appengine v1.6.7 // indirect 20 | ) 21 | -------------------------------------------------------------------------------- /internal/cmd/ch-ex-numbers/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | 7 | "github.com/ClickHouse/ch-go" 8 | "github.com/ClickHouse/ch-go/proto" 9 | ) 10 | 11 | func main() { 12 | ctx := context.Background() 13 | c, err := ch.Dial(ctx, ch.Options{}) 14 | if err != nil { 15 | panic(err) 16 | } 17 | var ( 18 | numbers int 19 | data proto.ColUInt64 20 | ) 21 | if err := c.Do(ctx, ch.Query{ 22 | Body: "SELECT number FROM system.numbers LIMIT 500000000", 23 | OnResult: func(ctx context.Context, b proto.Block) error { 24 | numbers += len(data) 25 | return nil 26 | }, 27 | Result: proto.Results{ 28 | {Name: "number", Data: &data}, 29 | }, 30 | }); err != nil { 31 | panic(err) 32 | } 33 | fmt.Println("numbers:", numbers) 34 | } 35 | -------------------------------------------------------------------------------- /internal/cmd/ch-native-dump/test.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Pipe generated native data to clickhouse-local and check that the number of rows is correct. 4 | go run ./internal/cmd/ch-native-dump | clickhouse local \ 5 | --structure "event Enum8('WatchEvent'=1, 'PushEvent'=2, 'IssuesEvent'=3, 'PullRequestEvent'=4), repo Int64, actor Int64, time DateTime" \ 6 | --input-format Native \ 7 | -q "SELECT count() FROM table" 8 | 9 | # Result should be 10000. 10 | -------------------------------------------------------------------------------- /internal/cmd/ch-version/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/ClickHouse/ch-go/internal/version" 7 | ) 8 | 9 | func main() { 10 | fmt.Println("version", version.Get()) 11 | } 12 | -------------------------------------------------------------------------------- /internal/e2e/e2e.go: -------------------------------------------------------------------------------- 1 | // Package e2e implements end to end testing utilities. 2 | package e2e 3 | 4 | import ( 5 | "os" 6 | "strconv" 7 | "testing" 8 | ) 9 | 10 | // Env variable for E2E tests. 11 | const Env = "CH_E2E" 12 | 13 | type Status byte 14 | 15 | const ( 16 | NotSet Status = iota // N/A 17 | Enabled // explicitly enabled 18 | Disabled // explicitly disabled 19 | ) 20 | 21 | // Get reports current end-to-end status. 22 | func Get(tb testing.TB) Status { 23 | tb.Helper() 24 | s, ok := os.LookupEnv(Env) 25 | if !ok || s == "" { 26 | return NotSet 27 | } 28 | v, err := strconv.ParseBool(s) 29 | if err != nil { 30 | tb.Fatalf("E2E: %s=%s is invalid: %v", Env, s, err) 31 | } 32 | if v { 33 | return Enabled 34 | } 35 | return Disabled 36 | } 37 | -------------------------------------------------------------------------------- /internal/gold/_golden/file.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 02 03 48 69 21 |...Hi!| 2 | -------------------------------------------------------------------------------- /internal/gold/_golden/file.raw: -------------------------------------------------------------------------------- 1 | Hi! -------------------------------------------------------------------------------- /internal/gold/_golden/hello.txt: -------------------------------------------------------------------------------- 1 | Hello, world! 2 | -------------------------------------------------------------------------------- /internal/gold/gold_test.go: -------------------------------------------------------------------------------- 1 | package gold_test 2 | 3 | import ( 4 | "os" 5 | "testing" 6 | 7 | "github.com/ClickHouse/ch-go/internal/gold" 8 | ) 9 | 10 | func TestStr(t *testing.T) { 11 | gold.Str(t, "Hello, world!\n", "hello.txt") 12 | } 13 | 14 | func TestBytes(t *testing.T) { 15 | gold.Bytes(t, append([]byte{1, 2, 3}, "Hi!"...)) 16 | } 17 | 18 | func TestMain(m *testing.M) { 19 | // Explicitly registering flags for golden files. 20 | gold.Init() 21 | 22 | os.Exit(m.Run()) 23 | } 24 | -------------------------------------------------------------------------------- /internal/version/version_test.go: -------------------------------------------------------------------------------- 1 | package version 2 | 3 | import ( 4 | "runtime/debug" 5 | "testing" 6 | 7 | "github.com/stretchr/testify/require" 8 | ) 9 | 10 | func TestExtract(t *testing.T) { 11 | for _, tc := range []struct { 12 | Name string 13 | Input debug.BuildInfo 14 | Output Value 15 | }{ 16 | { 17 | Name: "Empty", 18 | Output: Value{Name: "dev", Raw: "0.0.1-dev"}, 19 | }, 20 | { 21 | Name: "Main", 22 | Input: debug.BuildInfo{ 23 | Main: debug.Module{ 24 | Path: "github.com/ClickHouse/ch-go/foo/bar", 25 | Version: "1.5.10", 26 | }, 27 | }, 28 | Output: Value{Major: 1, Minor: 5, Patch: 10, Raw: "1.5.10"}, 29 | }, 30 | { 31 | Name: "Invalid", 32 | Input: debug.BuildInfo{ 33 | Main: debug.Module{ 34 | Path: "github.com/ClickHouse/ch-go/foo/bar", 35 | Version: "bad", 36 | }, 37 | }, 38 | Output: Value{Name: "dev", Raw: "0.0.1-dev"}, 39 | }, 40 | { 41 | Name: "Dependency", 42 | Input: debug.BuildInfo{ 43 | Deps: []*debug.Module{ 44 | { 45 | Path: "github.com/ClickHouse/ch-go", 46 | Version: "2.110.145-alpha.0", 47 | }, 48 | }, 49 | }, 50 | Output: Value{Major: 2, Minor: 110, Patch: 145, Name: "alpha.0", Raw: "2.110.145-alpha.0"}, 51 | }, 52 | } { 53 | t.Run(tc.Name, func(t *testing.T) { 54 | require.Equal(t, tc.Output, Extract(&tc.Input)) 55 | }) 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /internal/ztest/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2016 Uber Technologies, Inc. 2 | // 3 | // Permission is hereby granted, free of charge, to any person obtaining a copy 4 | // of this software and associated documentation files (the "Software"), to deal 5 | // in the Software without restriction, including without limitation the rights 6 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | // copies of the Software, and to permit persons to whom the Software is 8 | // furnished to do so, subject to the following conditions: 9 | // 10 | // The above copyright notice and this permission notice shall be included in 11 | // all copies or substantial portions of the Software. 12 | // 13 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 19 | // THE SOFTWARE. 20 | 21 | // Package ztest provides a variety of helpers for testing log output. 22 | package ztest 23 | -------------------------------------------------------------------------------- /otelch/otelch.go: -------------------------------------------------------------------------------- 1 | // Package otelch provide OpenTelemetry instrumentation for go-faster/ch. 2 | package otelch 3 | 4 | // Name of instrumentation. 5 | const Name = "github.com/ClickHouse/ch-go" 6 | -------------------------------------------------------------------------------- /otelch/version.go: -------------------------------------------------------------------------------- 1 | package otelch 2 | 3 | import "github.com/ClickHouse/ch-go/internal/version" 4 | 5 | // Version is the current release version of the ch instrumentation. 6 | func Version() string { 7 | return version.Get().Raw 8 | } 9 | 10 | // SemVersion is the semantic version to be supplied to tracer/meter creation. 11 | func SemVersion() string { 12 | return "semver:" + Version() 13 | } 14 | -------------------------------------------------------------------------------- /ping_test.go: -------------------------------------------------------------------------------- 1 | package ch 2 | 3 | import ( 4 | "context" 5 | "testing" 6 | 7 | "github.com/stretchr/testify/require" 8 | ) 9 | 10 | func TestClient_Ping(t *testing.T) { 11 | t.Parallel() 12 | require.NoError(t, Conn(t).Ping(context.Background())) 13 | } 14 | -------------------------------------------------------------------------------- /proto/_golden/block_int8_uint64.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 00 02 ff ff ff ff 00 02 05 05 63 6f 75 6e 74 |...........count| 2 | 00000010 04 49 6e 74 38 00 01 02 03 04 05 05 75 73 65 72 |.Int8.......user| 3 | 00000020 73 06 55 49 6e 74 36 34 00 83 6c 53 00 00 00 00 |s.UInt64..lS....| 4 | 00000030 00 3c ae 02 00 00 00 00 00 c9 96 0e 00 00 00 00 |.<..............| 5 | 00000040 00 78 f7 17 01 00 00 00 00 da 76 08 00 00 00 00 |.x........v.....| 6 | 00000050 00 |.| 7 | -------------------------------------------------------------------------------- /proto/_golden/block_int8_uint64.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/block_int8_uint64.raw -------------------------------------------------------------------------------- /proto/_golden/block_title_data.hex: -------------------------------------------------------------------------------- 1 | 00000000 02 02 05 74 69 74 6c 65 06 53 74 72 69 6e 67 00 |...title.String.| 2 | 00000010 03 46 6f 6f 03 42 61 72 04 64 61 74 61 05 49 6e |.Foo.Bar.data.In| 3 | 00000020 74 36 34 00 01 00 00 00 00 00 00 00 02 00 00 00 |t64.............| 4 | 00000030 00 00 00 00 |....| 5 | -------------------------------------------------------------------------------- /proto/_golden/block_title_data.raw: -------------------------------------------------------------------------------- 1 | titleStringFooBardataInt64 -------------------------------------------------------------------------------- /proto/_golden/buffer.hex: -------------------------------------------------------------------------------- 1 | 00000000 0d 48 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 01 02 |.Hello, world!..| 2 | 00000010 03 00 04 00 00 00 05 00 00 00 00 00 00 00 6e 00 |..............n.| 3 | 00000020 00 00 00 00 00 00 1f 3a 00 00 00 00 00 00 01 02 |.......:........| 4 | 00000030 00 03 00 00 00 04 00 00 00 00 00 00 00 64 00 00 |.............d..| 5 | 00000040 00 00 00 00 00 3c b1 07 00 00 00 00 00 64 c8 01 |.....<.......d..| 6 | 00000050 72 01 02 03 04 01 00 01 36 cd 8f 3f ec 51 b8 1e |r.......6..?.Q..| 7 | 00000060 85 45 7f 40 |.E.@| 8 | -------------------------------------------------------------------------------- /proto/_golden/buffer.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/buffer.raw -------------------------------------------------------------------------------- /proto/_golden/client_hello.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 02 63 68 01 01 a8 c0 02 06 67 69 74 68 75 62 |..ch......github| 2 | 00000010 03 6e 65 6f 00 |.neo.| 3 | -------------------------------------------------------------------------------- /proto/_golden/client_hello.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/client_hello.raw -------------------------------------------------------------------------------- /proto/_golden/client_info.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 00 24 32 33 61 64 32 63 30 37 2d 32 66 36 38 |..$23ad2c07-2f68| 2 | 00000010 2d 34 30 30 35 2d 39 62 61 63 2d 64 61 38 66 34 |-4005-9bac-da8f4| 3 | 00000020 36 37 62 64 64 33 62 09 30 2e 30 2e 30 2e 30 3a |67bdd3b.0.0.0.0:| 4 | 00000030 30 00 00 00 00 00 00 00 00 01 06 65 72 6e 61 64 |0..........ernad| 5 | 00000040 6f 05 6e 65 78 75 73 0b 43 6c 69 63 6b 48 6f 75 |o.nexus.ClickHou| 6 | 00000050 73 65 20 15 0b b2 a9 03 00 00 04 00 |se .........| 7 | -------------------------------------------------------------------------------- /proto/_golden/client_info.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/client_info.raw -------------------------------------------------------------------------------- /proto/_golden/client_info_otel.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 00 24 34 30 63 32 36 38 61 64 2d 64 65 35 30 |..$40c268ad-de50| 2 | 00000010 2d 34 33 34 64 2d 61 33 39 31 2d 38 30 30 64 61 |-434d-a391-800da| 3 | 00000020 39 61 61 37 30 63 33 09 30 2e 30 2e 30 2e 30 3a |9aa70c3.0.0.0.0:| 4 | 00000030 30 00 00 00 00 00 00 00 00 01 04 75 73 65 72 08 |0..........user.| 5 | 00000040 68 6f 73 74 6e 61 6d 65 04 4e 61 6d 65 15 0b 9d |hostname.Name...| 6 | 00000050 a9 03 00 00 04 01 08 07 06 05 04 03 02 01 10 0f |................| 7 | 00000060 0e 0d 0c 0b 0a 09 08 07 06 05 04 03 02 01 00 00 |................| 8 | 00000070 00 00 00 |...| 9 | -------------------------------------------------------------------------------- /proto/_golden/client_info_otel.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/client_info_otel.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_byte128.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_byte128.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_byte16.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_byte16.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_byte256.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_byte256.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_byte32.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_byte32.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_byte512.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_byte512.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_byte64.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_byte64.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_byte8.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_byte8.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_decimal128.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_decimal128.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_decimal256.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_decimal256.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_decimal32.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_decimal32.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_decimal64.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_decimal64.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_enum16.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_enum16.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_enum8.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_enum8.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_float32.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_float32.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_float64.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_float64.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_int128.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_int128.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_int16.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_int16.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_int256.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_int256.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_int32.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_int32.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_int64.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_int64.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_int8.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_int8.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_int8_manual.hex: -------------------------------------------------------------------------------- 1 | 00000000 02 00 00 00 00 00 00 00 05 00 00 00 00 00 00 00 |................| 2 | 00000010 09 00 00 00 00 00 00 00 0e 00 00 00 00 00 00 00 |................| 3 | 00000020 14 00 00 00 00 00 00 00 0a 0c 0d 0f 11 10 12 14 |................| 4 | 00000030 16 13 15 17 19 1b 16 18 1a 1c 1e 20 |........... | 5 | -------------------------------------------------------------------------------- /proto/_golden/col_arr_int8_manual.raw: -------------------------------------------------------------------------------- 1 |   2 |  -------------------------------------------------------------------------------- /proto/_golden/col_arr_ipv4.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_ipv4.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_ipv6.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_ipv6.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_low_cardinality_u8_str.hex: -------------------------------------------------------------------------------- 1 | 00000000 03 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 |................| 2 | 00000010 06 00 00 00 00 00 00 00 08 00 00 00 00 00 00 00 |................| 3 | 00000020 0c 00 00 00 00 00 00 00 00 06 00 00 00 00 00 00 |................| 4 | 00000030 03 00 00 00 00 00 00 00 03 66 6f 6f 03 62 61 72 |.........foo.bar| 5 | 00000040 03 62 61 7a 0c 00 00 00 00 00 00 00 00 01 02 00 |.baz............| 6 | 00000050 01 01 00 00 01 01 01 01 |........| 7 | -------------------------------------------------------------------------------- /proto/_golden/col_arr_low_cardinality_u8_str.raw: -------------------------------------------------------------------------------- 1 |  foobarbaz  -------------------------------------------------------------------------------- /proto/_golden/col_arr_of_low_cord_str.hex: -------------------------------------------------------------------------------- 1 | 00000000 05 00 00 00 00 00 00 00 07 00 00 00 00 00 00 00 |................| 2 | 00000010 00 06 00 00 00 00 00 00 03 00 00 00 00 00 00 00 |................| 3 | 00000020 03 66 6f 6f 03 62 61 72 03 62 61 7a 07 00 00 00 |.foo.bar.baz....| 4 | 00000030 00 00 00 00 00 01 00 00 02 00 02 |...........| 5 | -------------------------------------------------------------------------------- /proto/_golden/col_arr_of_low_cord_str.raw: -------------------------------------------------------------------------------- 1 | foobarbaz -------------------------------------------------------------------------------- /proto/_golden/col_arr_of_str.hex: -------------------------------------------------------------------------------- 1 | 00000000 05 00 00 00 00 00 00 00 07 00 00 00 00 00 00 00 |................| 2 | 00000010 03 66 6f 6f 03 62 61 72 03 66 6f 6f 03 66 6f 6f |.foo.bar.foo.foo| 3 | 00000020 03 62 61 7a 03 66 6f 6f 03 62 61 7a |.baz.foo.baz| 4 | -------------------------------------------------------------------------------- /proto/_golden/col_arr_of_str.raw: -------------------------------------------------------------------------------- 1 | foobarfoofoobazfoobaz -------------------------------------------------------------------------------- /proto/_golden/col_arr_uint128.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_uint128.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_uint16.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_uint16.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_uint256.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_uint256.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_uint32.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_uint32.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_uint64.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_uint64.raw -------------------------------------------------------------------------------- /proto/_golden/col_arr_uint8.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_arr_uint8.raw -------------------------------------------------------------------------------- /proto/_golden/col_bool.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 00 00 01 00 00 01 00 00 01 00 00 01 00 00 01 |................| 2 | 00000010 00 00 01 00 00 01 00 00 01 00 00 01 00 00 01 00 |................| 3 | 00000020 00 01 00 00 01 00 00 01 00 00 01 00 00 01 00 00 |................| 4 | 00000030 01 00 |..| 5 | -------------------------------------------------------------------------------- /proto/_golden/col_bool.raw: -------------------------------------------------------------------------------- 1 |  -------------------------------------------------------------------------------- /proto/_golden/col_byte16.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_byte8.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_date.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 00 01 00 02 00 03 00 04 00 05 00 06 00 07 00 |................| 2 | 00000010 08 00 09 00 0a 00 0b 00 0c 00 0d 00 0e 00 0f 00 |................| 3 | 00000020 10 00 11 00 12 00 13 00 14 00 15 00 16 00 17 00 |................| 4 | 00000030 18 00 19 00 1a 00 1b 00 1c 00 1d 00 1e 00 1f 00 |................| 5 | 00000040 20 00 21 00 22 00 23 00 24 00 25 00 26 00 27 00 | .!.".#.$.%.&.'.| 6 | 00000050 28 00 29 00 2a 00 2b 00 2c 00 2d 00 2e 00 2f 00 |(.).*.+.,.-.../.| 7 | 00000060 30 00 31 00 |0.1.| 8 | -------------------------------------------------------------------------------- /proto/_golden/col_date.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_date32.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 00 00 00 01 00 00 00 02 00 00 00 03 00 00 00 |................| 2 | 00000010 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 |................| 3 | 00000020 08 00 00 00 09 00 00 00 0a 00 00 00 0b 00 00 00 |................| 4 | 00000030 0c 00 00 00 0d 00 00 00 0e 00 00 00 0f 00 00 00 |................| 5 | 00000040 10 00 00 00 11 00 00 00 12 00 00 00 13 00 00 00 |................| 6 | 00000050 14 00 00 00 15 00 00 00 16 00 00 00 17 00 00 00 |................| 7 | 00000060 18 00 00 00 19 00 00 00 1a 00 00 00 1b 00 00 00 |................| 8 | 00000070 1c 00 00 00 1d 00 00 00 1e 00 00 00 1f 00 00 00 |................| 9 | 00000080 20 00 00 00 21 00 00 00 22 00 00 00 23 00 00 00 | ...!..."...#...| 10 | 00000090 24 00 00 00 25 00 00 00 26 00 00 00 27 00 00 00 |$...%...&...'...| 11 | 000000a0 28 00 00 00 29 00 00 00 2a 00 00 00 2b 00 00 00 |(...)...*...+...| 12 | 000000b0 2c 00 00 00 2d 00 00 00 2e 00 00 00 2f 00 00 00 |,...-......./...| 13 | 000000c0 30 00 00 00 31 00 00 00 |0...1...| 14 | -------------------------------------------------------------------------------- /proto/_golden/col_date32.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_datetime.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 00 00 00 01 00 00 00 02 00 00 00 03 00 00 00 |................| 2 | 00000010 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 |................| 3 | 00000020 08 00 00 00 09 00 00 00 0a 00 00 00 0b 00 00 00 |................| 4 | 00000030 0c 00 00 00 0d 00 00 00 0e 00 00 00 0f 00 00 00 |................| 5 | 00000040 10 00 00 00 11 00 00 00 12 00 00 00 13 00 00 00 |................| 6 | 00000050 14 00 00 00 15 00 00 00 16 00 00 00 17 00 00 00 |................| 7 | 00000060 18 00 00 00 19 00 00 00 1a 00 00 00 1b 00 00 00 |................| 8 | 00000070 1c 00 00 00 1d 00 00 00 1e 00 00 00 1f 00 00 00 |................| 9 | 00000080 20 00 00 00 21 00 00 00 22 00 00 00 23 00 00 00 | ...!..."...#...| 10 | 00000090 24 00 00 00 25 00 00 00 26 00 00 00 27 00 00 00 |$...%...&...'...| 11 | 000000a0 28 00 00 00 29 00 00 00 2a 00 00 00 2b 00 00 00 |(...)...*...+...| 12 | 000000b0 2c 00 00 00 2d 00 00 00 2e 00 00 00 2f 00 00 00 |,...-......./...| 13 | 000000c0 30 00 00 00 31 00 00 00 |0...1...| 14 | -------------------------------------------------------------------------------- /proto/_golden/col_datetime.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_datetime64.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_decimal128.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_decimal32.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 00 00 00 01 00 00 00 02 00 00 00 03 00 00 00 |................| 2 | 00000010 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 |................| 3 | 00000020 08 00 00 00 09 00 00 00 0a 00 00 00 0b 00 00 00 |................| 4 | 00000030 0c 00 00 00 0d 00 00 00 0e 00 00 00 0f 00 00 00 |................| 5 | 00000040 10 00 00 00 11 00 00 00 12 00 00 00 13 00 00 00 |................| 6 | 00000050 14 00 00 00 15 00 00 00 16 00 00 00 17 00 00 00 |................| 7 | 00000060 18 00 00 00 19 00 00 00 1a 00 00 00 1b 00 00 00 |................| 8 | 00000070 1c 00 00 00 1d 00 00 00 1e 00 00 00 1f 00 00 00 |................| 9 | 00000080 20 00 00 00 21 00 00 00 22 00 00 00 23 00 00 00 | ...!..."...#...| 10 | 00000090 24 00 00 00 25 00 00 00 26 00 00 00 27 00 00 00 |$...%...&...'...| 11 | 000000a0 28 00 00 00 29 00 00 00 2a 00 00 00 2b 00 00 00 |(...)...*...+...| 12 | 000000b0 2c 00 00 00 2d 00 00 00 2e 00 00 00 2f 00 00 00 |,...-......./...| 13 | 000000c0 30 00 00 00 31 00 00 00 |0...1...| 14 | -------------------------------------------------------------------------------- /proto/_golden/col_decimal32.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_decimal64.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_enum16.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 00 01 00 02 00 03 00 04 00 05 00 06 00 07 00 |................| 2 | 00000010 08 00 09 00 0a 00 0b 00 0c 00 0d 00 0e 00 0f 00 |................| 3 | 00000020 10 00 11 00 12 00 13 00 14 00 15 00 16 00 17 00 |................| 4 | 00000030 18 00 19 00 1a 00 1b 00 1c 00 1d 00 1e 00 1f 00 |................| 5 | 00000040 20 00 21 00 22 00 23 00 24 00 25 00 26 00 27 00 | .!.".#.$.%.&.'.| 6 | 00000050 28 00 29 00 2a 00 2b 00 2c 00 2d 00 2e 00 2f 00 |(.).*.+.,.-.../.| 7 | 00000060 30 00 31 00 |0.1.| 8 | -------------------------------------------------------------------------------- /proto/_golden/col_enum16.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_enum8.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................| 2 | 00000010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f |................| 3 | 00000020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f | !"#$%&'()*+,-./| 4 | 00000030 30 31 |01| 5 | -------------------------------------------------------------------------------- /proto/_golden/col_enum8.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_fixed_str.hex: -------------------------------------------------------------------------------- 1 | 00000000 2c 26 b4 6b 68 ff c6 8f f9 9b 45 3c 1d 30 41 34 |,&.kh.....E<.0A4| 2 | 00000010 13 42 2d 70 64 83 bf a0 f9 8a 5e 88 62 66 e7 ae |.B-pd.....^.bf..| 3 | 00000020 fc de 2b 2e db a5 6b f4 08 60 1f b7 21 fe 9b 5c |..+...k..`..!..\| 4 | 00000030 33 8d 10 ee 42 9e a0 4f ae 55 11 b6 8f bf 8f b9 |3...B..O.U......| 5 | 00000040 de e9 1d db 90 59 79 36 30 2c fd 43 41 e4 09 c8 |.....Yy60,.CA...| 6 | 00000050 77 79 ed 9e 0e 8c 8f de 58 0e 0a f6 cd ac e1 79 |wy......X......y| 7 | 00000060 76 92 c3 ad 35 40 bb 80 3c 02 0b 3a ee 66 cd 88 |v...5@..<..:.f..| 8 | 00000070 87 12 32 34 ea 0c 6e 71 43 c0 ad d7 3f f4 31 ed |..24..nqC...?.1.| 9 | 00000080 e3 b0 c4 42 98 fc 1c 14 9a fb f4 c8 99 6f b9 24 |...B.........o.$| 10 | 00000090 27 ae 41 e4 64 9b 93 4c a4 95 99 1b 78 52 b8 55 |'.A.d..L....xR.U| 11 | 000000a0 6b 86 b2 73 ff 34 fc e1 9d 6b 80 4e ff 5a 3f 57 |k..s.4...k.N.Z?W| 12 | 000000b0 47 ad a4 ea a2 2f 1d 49 c0 1e 52 dd b7 87 5b 4b |G..../.I..R...[K| 13 | -------------------------------------------------------------------------------- /proto/_golden/col_fixed_str.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/col_fixed_str.raw -------------------------------------------------------------------------------- /proto/_golden/col_float32.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 00 00 00 00 00 80 3f 00 00 00 40 00 00 40 40 |.......?...@..@@| 2 | 00000010 00 00 80 40 00 00 a0 40 00 00 c0 40 00 00 e0 40 |...@...@...@...@| 3 | 00000020 00 00 00 41 00 00 10 41 00 00 20 41 00 00 30 41 |...A...A.. A..0A| 4 | 00000030 00 00 40 41 00 00 50 41 00 00 60 41 00 00 70 41 |..@A..PA..`A..pA| 5 | 00000040 00 00 80 41 00 00 88 41 00 00 90 41 00 00 98 41 |...A...A...A...A| 6 | 00000050 00 00 a0 41 00 00 a8 41 00 00 b0 41 00 00 b8 41 |...A...A...A...A| 7 | 00000060 00 00 c0 41 00 00 c8 41 00 00 d0 41 00 00 d8 41 |...A...A...A...A| 8 | 00000070 00 00 e0 41 00 00 e8 41 00 00 f0 41 00 00 f8 41 |...A...A...A...A| 9 | 00000080 00 00 00 42 00 00 04 42 00 00 08 42 00 00 0c 42 |...B...B...B...B| 10 | 00000090 00 00 10 42 00 00 14 42 00 00 18 42 00 00 1c 42 |...B...B...B...B| 11 | 000000a0 00 00 20 42 00 00 24 42 00 00 28 42 00 00 2c 42 |.. B..$B..(B..,B| 12 | 000000b0 00 00 30 42 00 00 34 42 00 00 38 42 00 00 3c 42 |..0B..4B..8B..<1><2><3><4><5><6><7><8><9><10><11><12><13><14><15><16><17><18><19><20><21><22><23><24><25><26><27><28><29><30><31><32><33><34><35><36><37><38><39><40><41><42><43><44><45><46><47><48><49> 2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_tuple_str_int64.raw: -------------------------------------------------------------------------------- 1 | <0><1><2><3><4><5><6><7><8><9><10><11><12><13><14><15><16><17><18><19><20><21><22><23><24><25><26><27><28><29><30><31><32><33><34><35><36><37><38><39><40><41><42><43><44><45><46><47><48><49> 2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_uint128.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_uint16.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 00 01 00 02 00 03 00 04 00 05 00 06 00 07 00 |................| 2 | 00000010 08 00 09 00 0a 00 0b 00 0c 00 0d 00 0e 00 0f 00 |................| 3 | 00000020 10 00 11 00 12 00 13 00 14 00 15 00 16 00 17 00 |................| 4 | 00000030 18 00 19 00 1a 00 1b 00 1c 00 1d 00 1e 00 1f 00 |................| 5 | 00000040 20 00 21 00 22 00 23 00 24 00 25 00 26 00 27 00 | .!.".#.$.%.&.'.| 6 | 00000050 28 00 29 00 2a 00 2b 00 2c 00 2d 00 2e 00 2f 00 |(.).*.+.,.-.../.| 7 | 00000060 30 00 31 00 |0.1.| 8 | -------------------------------------------------------------------------------- /proto/_golden/col_uint16.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_uint32.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 00 00 00 01 00 00 00 02 00 00 00 03 00 00 00 |................| 2 | 00000010 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 |................| 3 | 00000020 08 00 00 00 09 00 00 00 0a 00 00 00 0b 00 00 00 |................| 4 | 00000030 0c 00 00 00 0d 00 00 00 0e 00 00 00 0f 00 00 00 |................| 5 | 00000040 10 00 00 00 11 00 00 00 12 00 00 00 13 00 00 00 |................| 6 | 00000050 14 00 00 00 15 00 00 00 16 00 00 00 17 00 00 00 |................| 7 | 00000060 18 00 00 00 19 00 00 00 1a 00 00 00 1b 00 00 00 |................| 8 | 00000070 1c 00 00 00 1d 00 00 00 1e 00 00 00 1f 00 00 00 |................| 9 | 00000080 20 00 00 00 21 00 00 00 22 00 00 00 23 00 00 00 | ...!..."...#...| 10 | 00000090 24 00 00 00 25 00 00 00 26 00 00 00 27 00 00 00 |$...%...&...'...| 11 | 000000a0 28 00 00 00 29 00 00 00 2a 00 00 00 2b 00 00 00 |(...)...*...+...| 12 | 000000b0 2c 00 00 00 2d 00 00 00 2e 00 00 00 2f 00 00 00 |,...-......./...| 13 | 000000c0 30 00 00 00 31 00 00 00 |0...1...| 14 | -------------------------------------------------------------------------------- /proto/_golden/col_uint32.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_uint64.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_uint8.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................| 2 | 00000010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f |................| 3 | 00000020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f | !"#$%&'()*+,-./| 4 | 00000030 30 31 |01| 5 | -------------------------------------------------------------------------------- /proto/_golden/col_uint8.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/col_uuid.raw: -------------------------------------------------------------------------------- 1 |  2 |  !"#$%&'()*+,-./01 -------------------------------------------------------------------------------- /proto/_golden/column_of_byte_arr_16.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 2 | 00000010 00 00 00 00 00 00 00 00 00 00 0e 00 00 00 00 00 |................| 3 | -------------------------------------------------------------------------------- /proto/_golden/column_of_byte_arr_16.raw: -------------------------------------------------------------------------------- 1 |  -------------------------------------------------------------------------------- /proto/_golden/column_of_bytes.hex: -------------------------------------------------------------------------------- 1 | 00000000 05 48 65 6c 6c 6f 05 57 6f 72 6c 64 |.Hello.World| 2 | -------------------------------------------------------------------------------- /proto/_golden/column_of_bytes.raw: -------------------------------------------------------------------------------- 1 | HelloWorld -------------------------------------------------------------------------------- /proto/_golden/column_of_json_bytes.hex: -------------------------------------------------------------------------------- 1 | 00000000 11 7b 22 78 22 3a 20 35 2c 20 22 79 22 3a 20 31 |.{"x": 5, "y": 1| 2 | 00000010 30 7d 1b 7b 22 61 22 3a 20 22 74 65 73 74 22 2c |0}.{"a": "test",| 3 | 00000020 20 22 62 22 3a 20 22 74 65 73 74 32 22 7d 21 7b | "b": "test2"}!{| 4 | 00000030 22 61 22 3a 20 22 6f 62 6a 20 74 65 73 74 22 2c |"a": "obj test",| 5 | 00000040 20 22 62 22 3a 20 7b 22 63 22 3a 20 32 30 7d 7d | "b": {"c": 20}}| 6 | -------------------------------------------------------------------------------- /proto/_golden/column_of_json_bytes.raw: -------------------------------------------------------------------------------- 1 | {"x": 5, "y": 10}{"a": "test", "b": "test2"}!{"a": "obj test", "b": {"c": 20}} -------------------------------------------------------------------------------- /proto/_golden/column_of_str.hex: -------------------------------------------------------------------------------- 1 | 00000000 03 66 6f 6f 03 62 61 72 03 62 61 7a |.foo.bar.baz| 2 | -------------------------------------------------------------------------------- /proto/_golden/column_of_str.raw: -------------------------------------------------------------------------------- 1 | foobarbaz -------------------------------------------------------------------------------- /proto/_golden/progress.hex: -------------------------------------------------------------------------------- 1 | 00000000 64 f8 8e 25 e8 07 b9 03 8f c7 05 00 |d..%........| 2 | -------------------------------------------------------------------------------- /proto/_golden/progress.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/progress.raw -------------------------------------------------------------------------------- /proto/_golden/query_create_db.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 24 32 33 61 64 32 63 30 37 2d 32 66 36 38 2d |.$23ad2c07-2f68-| 2 | 00000010 34 30 30 35 2d 39 62 61 63 2d 64 61 38 66 34 36 |4005-9bac-da8f46| 3 | 00000020 37 62 64 64 33 62 01 00 24 32 33 61 64 32 63 30 |7bdd3b..$23ad2c0| 4 | 00000030 37 2d 32 66 36 38 2d 34 30 30 35 2d 39 62 61 63 |7-2f68-4005-9bac| 5 | 00000040 2d 64 61 38 66 34 36 37 62 64 64 33 62 09 30 2e |-da8f467bdd3b.0.| 6 | 00000050 30 2e 30 2e 30 3a 30 00 00 00 00 00 00 00 00 01 |0.0.0:0.........| 7 | 00000060 06 65 72 6e 61 64 6f 05 6e 65 78 75 73 0b 43 6c |.ernado.nexus.Cl| 8 | 00000070 69 63 6b 48 6f 75 73 65 20 15 0b b2 a9 03 00 00 |ickHouse .......| 9 | 00000080 04 00 00 00 02 00 15 43 52 45 41 54 45 20 44 41 |.......CREATE DA| 10 | 00000090 54 41 42 41 53 45 20 74 65 73 74 3b |TABASE test;| 11 | -------------------------------------------------------------------------------- /proto/_golden/query_create_db.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/query_create_db.raw -------------------------------------------------------------------------------- /proto/_golden/query_otel.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 24 61 37 65 34 63 38 39 30 2d 64 66 32 31 2d |.$a7e4c890-df21-| 2 | 00000010 34 63 65 61 2d 62 34 61 31 2d 39 62 38 36 38 65 |4cea-b4a1-9b868e| 3 | 00000020 35 31 34 33 36 36 01 03 6e 65 6f 24 36 38 66 36 |514366..neo$68f6| 4 | 00000030 30 37 66 62 2d 35 39 65 34 2d 34 63 63 37 2d 62 |07fb-59e4-4cc7-b| 5 | 00000040 35 35 64 2d 37 30 65 36 64 63 34 65 37 63 39 33 |55d-70e6dc4e7c93| 6 | 00000050 0c 31 2e 31 2e 31 2e 31 3a 31 34 34 38 00 00 00 |.1.1.1.1:1448...| 7 | 00000060 00 00 00 00 00 01 05 61 67 65 6e 74 05 6e 65 78 |.......agent.nex| 8 | 00000070 75 73 06 4d 61 74 72 69 78 15 0e e3 99 03 06 75 |us.Matrix......u| 9 | 00000080 2d 39 37 64 63 00 c0 53 01 00 00 00 00 04 03 02 |-97dc..S........| 10 | 00000090 01 00 00 00 00 00 00 00 00 00 00 00 0a 09 08 07 |................| 11 | 000000a0 06 00 01 00 00 00 00 06 73 65 63 72 65 74 02 01 |........secret..| 12 | 000000b0 15 43 52 45 41 54 45 20 44 41 54 41 42 41 53 45 |.CREATE DATABASE| 13 | 000000c0 20 74 65 73 74 3b 00 | test;.| 14 | -------------------------------------------------------------------------------- /proto/_golden/query_otel.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/query_otel.raw -------------------------------------------------------------------------------- /proto/_golden/type/Block.hex: -------------------------------------------------------------------------------- 1 | 00000000 01 01 02 de 07 00 00 00 0f 0a |..........| 2 | -------------------------------------------------------------------------------- /proto/_golden/type/Block.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/type/Block.raw -------------------------------------------------------------------------------- /proto/_golden/type/ClientData.hex: -------------------------------------------------------------------------------- 1 | 00000000 03 46 6f 6f |.Foo| 2 | -------------------------------------------------------------------------------- /proto/_golden/type/ClientData.raw: -------------------------------------------------------------------------------- 1 | Foo -------------------------------------------------------------------------------- /proto/_golden/type/Exception.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/type/Exception.raw -------------------------------------------------------------------------------- /proto/_golden/type/Profile.hex: -------------------------------------------------------------------------------- 1 | 00000000 06 d2 09 f3 ac 0e a8 03 01 a5 12 00 |............| 2 | -------------------------------------------------------------------------------- /proto/_golden/type/Profile.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/type/Profile.raw -------------------------------------------------------------------------------- /proto/_golden/type/ServerHello.hex: -------------------------------------------------------------------------------- 1 | 00000000 00 11 43 6c 69 63 6b 48 6f 75 73 65 20 73 65 72 |..ClickHouse ser| 2 | 00000010 76 65 72 15 0b b2 a9 03 0d 45 75 72 6f 70 65 2f |ver......Europe/| 3 | 00000020 4d 6f 73 63 6f 77 05 61 6c 70 68 61 03 |Moscow.alpha.| 4 | -------------------------------------------------------------------------------- /proto/_golden/type/ServerHello.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ClickHouse/ch-go/71e91b174684056f50a2941a58642b11a049025d/proto/_golden/type/ServerHello.raw -------------------------------------------------------------------------------- /proto/_golden/type/TableColumns.hex: -------------------------------------------------------------------------------- 1 | 00000000 0b 00 30 63 6f 6c 75 6d 6e 73 20 66 6f 72 6d 61 |..0columns forma| 2 | 00000010 74 20 76 65 72 73 69 6f 6e 3a 20 31 0a 31 20 63 |t version: 1.1 c| 3 | 00000020 6f 6c 75 6d 6e 73 3a 0a 60 69 64 60 20 55 49 6e |olumns:.`id` UIn| 4 | 00000030 74 38 0a |t8.| 5 | -------------------------------------------------------------------------------- /proto/_golden/type/TableColumns.raw: -------------------------------------------------------------------------------- 1 | 0columns format version: 1 2 | 1 columns: 3 | `id` UInt8 4 | -------------------------------------------------------------------------------- /proto/_golden/uint256_100.hex: -------------------------------------------------------------------------------- 1 | 00000000 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |d...............| 2 | 00000010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 3 | -------------------------------------------------------------------------------- /proto/_golden/uint256_100.raw: -------------------------------------------------------------------------------- 1 | d -------------------------------------------------------------------------------- /proto/_testdata/select_lc.raw: -------------------------------------------------------------------------------- 1 | vArray(LowCardinality(String)) foobarbaz  -------------------------------------------------------------------------------- /proto/_testdata/test_dump_native.raw: -------------------------------------------------------------------------------- 1 | idInt8vStringFirstidInt8vStringSecondThird -------------------------------------------------------------------------------- /proto/bool.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | const ( 4 | boolTrue uint8 = 1 5 | boolFalse uint8 = 0 6 | ) 7 | -------------------------------------------------------------------------------- /proto/client_code.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | //go:generate go run github.com/dmarkham/enumer -type ClientCode -trimprefix ClientCode -output client_code_enum.go 4 | 5 | // ClientCode is sent from client to server. 6 | type ClientCode byte 7 | 8 | // Possible client codes. 9 | const ( 10 | ClientCodeHello ClientCode = 0 // client part of "handshake" 11 | ClientCodeQuery ClientCode = 1 // query start 12 | ClientCodeData ClientCode = 2 // data block (can be compressed) 13 | ClientCodeCancel ClientCode = 3 // query cancel 14 | ClientCodePing ClientCode = 4 // ping request to server 15 | ClientTablesStatusRequest ClientCode = 5 // tables status request 16 | ) 17 | 18 | // Encode to buffer. 19 | func (c ClientCode) Encode(b *Buffer) { b.PutByte(byte(c)) } 20 | -------------------------------------------------------------------------------- /proto/client_data.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "github.com/go-faster/errors" 4 | 5 | type ClientData struct { 6 | TableName string 7 | } 8 | 9 | func (c ClientData) EncodeAware(b *Buffer, version int) { 10 | if FeatureTempTables.In(version) { 11 | b.PutString(c.TableName) 12 | } 13 | } 14 | 15 | func (c *ClientData) DecodeAware(r *Reader, version int) error { 16 | if FeatureTempTables.In(version) { 17 | v, err := r.Str() 18 | if err != nil { 19 | return errors.Wrap(err, "temp tables") 20 | } 21 | c.TableName = v 22 | } 23 | return nil 24 | } 25 | -------------------------------------------------------------------------------- /proto/client_data_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "testing" 4 | 5 | func TestClientData_EncodeAware(t *testing.T) { 6 | Gold(t, ClientData{ 7 | TableName: "Foo", 8 | }) 9 | } 10 | -------------------------------------------------------------------------------- /proto/client_hello_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/require" 7 | 8 | "github.com/ClickHouse/ch-go/internal/gold" 9 | ) 10 | 11 | func TestClientHello_Encode(t *testing.T) { 12 | var b Buffer 13 | v := ClientHello{ 14 | Name: "ch", 15 | Major: 1, 16 | Minor: 1, 17 | ProtocolVersion: 41000, 18 | Database: "github", 19 | User: "neo", 20 | Password: "", 21 | } 22 | b.Encode(v) 23 | gold.Bytes(t, b.Buf, "client_hello") 24 | t.Run("Decode", func(t *testing.T) { 25 | var dec ClientHello 26 | buf := skipCode(t, b.Buf, int(ClientCodeHello)) 27 | requireDecode(t, buf, &dec) 28 | require.Equal(t, v, dec) 29 | requireNoShortRead(t, buf, &dec) 30 | }) 31 | } 32 | 33 | func BenchmarkClientHello_Encode(b *testing.B) { 34 | buf := new(Buffer) 35 | h := &ClientHello{ 36 | Name: "ClickHouse Go Faster Client", 37 | Major: 1, 38 | Minor: 1, 39 | ProtocolVersion: 411337, 40 | Database: "github", 41 | User: "neo", 42 | Password: "go faster", 43 | } 44 | h.Encode(buf) 45 | b.SetBytes(int64(len(buf.Buf))) 46 | b.ReportAllocs() 47 | 48 | for i := 0; i < b.N; i++ { 49 | buf.Reset() 50 | h.Encode(buf) 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /proto/cmd/ch-gen-col/infer.go.tmpl: -------------------------------------------------------------------------------- 1 | {{- /*gotype: github.com/ClickHouse/ch-go/proto/cmd/ch-gen-col.Variants*/ -}} 2 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 3 | 4 | package proto 5 | 6 | func inferGenerated(t ColumnType) Column { 7 | switch t { 8 | {{- range . }} 9 | case {{ .ColumnType }}: 10 | return new({{ .Type }}) 11 | {{- end }} 12 | default: 13 | return nil 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /proto/col_arr_go123.go: -------------------------------------------------------------------------------- 1 | //go:build go1.23 2 | 3 | package proto 4 | 5 | import "iter" 6 | 7 | // RowRange returns a [iter.Seq] iterator over i-th row. 8 | func (c ColArr[T]) RowRange(i int) iter.Seq[T] { 9 | var start int 10 | end := int(c.Offsets[i]) 11 | if i > 0 { 12 | start = int(c.Offsets[i-1]) 13 | } 14 | 15 | return func(yield func(T) bool) { 16 | for idx := start; idx < end; idx++ { 17 | if !yield(c.Data.Row(idx)) { 18 | return 19 | } 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /proto/col_arr_go123_test.go: -------------------------------------------------------------------------------- 1 | //go:build go1.23 2 | 3 | package proto 4 | 5 | import ( 6 | "testing" 7 | 8 | "github.com/stretchr/testify/require" 9 | ) 10 | 11 | func TestColArrRange(t *testing.T) { 12 | var ( 13 | enc = new(ColStr).Array() 14 | expected = [][]string{ 15 | {"foo", "bar", "foo", "foo", "baz"}, 16 | {"foo", "baz"}, 17 | } 18 | ) 19 | enc.AppendArr(expected) 20 | 21 | var buf Buffer 22 | enc.EncodeColumn(&buf) 23 | 24 | var ( 25 | dec = new(ColStr).Array() 26 | got [][]string 27 | ) 28 | require.NoError(t, dec.DecodeColumn(buf.Reader(), enc.Rows())) 29 | for rowIdx := range dec.Rows() { 30 | var row []string 31 | for e := range dec.RowRange(rowIdx) { 32 | row = append(row, e) 33 | } 34 | got = append(got, row) 35 | } 36 | require.Equal(t, expected, got) 37 | } 38 | -------------------------------------------------------------------------------- /proto/col_bool.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | // ColBool is Bool column. 4 | type ColBool []bool 5 | 6 | // Compile-time assertions for ColBool. 7 | var ( 8 | _ ColInput = ColBool{} 9 | _ ColResult = (*ColBool)(nil) 10 | _ Column = (*ColBool)(nil) 11 | _ ColumnOf[bool] = (*ColBool)(nil) 12 | ) 13 | 14 | func (c ColBool) Row(i int) bool { 15 | return c[i] 16 | } 17 | 18 | func (c *ColBool) Append(v bool) { 19 | *c = append(*c, v) 20 | } 21 | 22 | func (c *ColBool) AppendArr(vs []bool) { 23 | *c = append(*c, vs...) 24 | } 25 | 26 | // Type returns ColumnType of Bool. 27 | func (ColBool) Type() ColumnType { 28 | return ColumnTypeBool 29 | } 30 | 31 | // Rows returns count of rows in column. 32 | func (c ColBool) Rows() int { 33 | return len(c) 34 | } 35 | 36 | // Reset resets data in row, preserving capacity for efficiency. 37 | func (c *ColBool) Reset() { 38 | *c = (*c)[:0] 39 | } 40 | 41 | // Array is helper that creates Array(Bool). 42 | func (c *ColBool) Array() *ColArr[bool] { 43 | return &ColArr[bool]{ 44 | Data: c, 45 | } 46 | } 47 | 48 | // Nullable is helper that creates Nullable(Bool). 49 | func (c *ColBool) Nullable() *ColNullable[bool] { 50 | return &ColNullable[bool]{ 51 | Values: c, 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /proto/col_bool_safe.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | package proto 4 | 5 | import "github.com/go-faster/errors" 6 | 7 | // EncodeColumn encodes Bool rows to *Buffer. 8 | func (c ColBool) EncodeColumn(b *Buffer) { 9 | start := len(b.Buf) 10 | b.Buf = append(b.Buf, make([]byte, len(c))...) 11 | dst := b.Buf[start:] 12 | for i, v := range c { 13 | dst[i] = boolToByte(v) 14 | } 15 | } 16 | 17 | func boolToByte(b bool) byte { 18 | if b { 19 | return boolTrue 20 | } 21 | return boolFalse 22 | } 23 | 24 | // DecodeColumn decodes Bool rows from *Reader. 25 | func (c *ColBool) DecodeColumn(r *Reader, rows int) error { 26 | data, err := r.ReadRaw(rows) 27 | if err != nil { 28 | return errors.Wrap(err, "read") 29 | } 30 | v := *c 31 | v = append(v, make([]bool, rows)...) 32 | for i := range data { 33 | switch data[i] { 34 | case boolTrue: 35 | v[i] = true 36 | case boolFalse: 37 | v[i] = false 38 | default: 39 | return errors.Errorf("[%d]: bad value %d for Bool", i, data[i]) 40 | } 41 | } 42 | *c = v 43 | return nil 44 | } 45 | 46 | // WriteColumn encodes ColBool rows to *Writer. 47 | func (c ColBool) WriteColumn(w *Writer) { 48 | if len(c) == 0 { 49 | return 50 | } 51 | w.ChainBuffer(c.EncodeColumn) 52 | } 53 | -------------------------------------------------------------------------------- /proto/col_bool_unsafe.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | package proto 4 | 5 | import ( 6 | "unsafe" 7 | 8 | "github.com/go-faster/errors" 9 | ) 10 | 11 | // EncodeColumn encodes Bool rows to *Buffer. 12 | func (c ColBool) EncodeColumn(b *Buffer) { 13 | if len(c) == 0 { 14 | return 15 | } 16 | offset := len(b.Buf) 17 | b.Buf = append(b.Buf, make([]byte, len(c))...) 18 | s := *(*slice)(unsafe.Pointer(&c)) // #nosec G103 19 | src := *(*[]byte)(unsafe.Pointer(&s)) // #nosec G103 20 | dst := b.Buf[offset:] 21 | copy(dst, src) 22 | } 23 | 24 | // DecodeColumn decodes Bool rows from *Reader. 25 | func (c *ColBool) DecodeColumn(r *Reader, rows int) error { 26 | if rows == 0 { 27 | return nil 28 | } 29 | *c = append(*c, make([]bool, rows)...) 30 | s := *(*slice)(unsafe.Pointer(c)) // #nosec G103 31 | dst := *(*[]byte)(unsafe.Pointer(&s)) // #nosec G103 32 | if err := r.ReadFull(dst); err != nil { 33 | return errors.Wrap(err, "read full") 34 | } 35 | return nil 36 | } 37 | 38 | // WriteColumn writes Bool rows to *Writer. 39 | func (c ColBool) WriteColumn(w *Writer) { 40 | if len(c) == 0 { 41 | return 42 | } 43 | s := *(*slice)(unsafe.Pointer(&c)) // #nosec G103 44 | src := *(*[]byte)(unsafe.Pointer(&s)) // #nosec G103 45 | w.ChainWrite(src) 46 | } 47 | -------------------------------------------------------------------------------- /proto/col_date.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "time" 4 | 5 | func (c *ColDate) Append(v time.Time) { 6 | *c = append(*c, ToDate(v)) 7 | } 8 | 9 | func (c *ColDate) AppendArr(vs []time.Time) { 10 | var dates = make([]Date, len(vs)) 11 | 12 | for i, v := range vs { 13 | dates[i] = ToDate(v) 14 | } 15 | 16 | *c = append(*c, dates...) 17 | } 18 | 19 | func (c ColDate) Row(i int) time.Time { 20 | return c[i].Time() 21 | } 22 | 23 | // LowCardinality returns LowCardinality for Enum8. 24 | func (c *ColDate) LowCardinality() *ColLowCardinality[time.Time] { 25 | return &ColLowCardinality[time.Time]{ 26 | index: c, 27 | } 28 | } 29 | 30 | // Array is helper that creates Array of Enum8. 31 | func (c *ColDate) Array() *ColArr[time.Time] { 32 | return &ColArr[time.Time]{ 33 | Data: c, 34 | } 35 | } 36 | 37 | // Nullable is helper that creates Nullable(Enum8). 38 | func (c *ColDate) Nullable() *ColNullable[time.Time] { 39 | return &ColNullable[time.Time]{ 40 | Values: c, 41 | } 42 | } 43 | 44 | // NewArrDate returns new Array(Date). 45 | func NewArrDate() *ColArr[time.Time] { 46 | return &ColArr[time.Time]{ 47 | Data: new(ColDate), 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /proto/col_date32.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "time" 4 | 5 | func (c *ColDate32) Append(v time.Time) { 6 | *c = append(*c, ToDate32(v)) 7 | } 8 | 9 | func (c *ColDate32) AppendArr(vs []time.Time) { 10 | var dates = make([]Date32, len(vs)) 11 | 12 | for i, v := range vs { 13 | dates[i] = ToDate32(v) 14 | } 15 | 16 | *c = append(*c, dates...) 17 | } 18 | 19 | func (c ColDate32) Row(i int) time.Time { 20 | return c[i].Time() 21 | } 22 | 23 | // LowCardinality returns LowCardinality for Enum8. 24 | func (c *ColDate32) LowCardinality() *ColLowCardinality[time.Time] { 25 | return &ColLowCardinality[time.Time]{ 26 | index: c, 27 | } 28 | } 29 | 30 | // Array is helper that creates Array of Enum8. 31 | func (c *ColDate32) Array() *ColArr[time.Time] { 32 | return &ColArr[time.Time]{ 33 | Data: c, 34 | } 35 | } 36 | 37 | // Nullable is helper that creates Nullable(Enum8). 38 | func (c *ColDate32) Nullable() *ColNullable[time.Time] { 39 | return &ColNullable[time.Time]{ 40 | Values: c, 41 | } 42 | } 43 | 44 | // NewArrDate32 returns new Array(Date32). 45 | func NewArrDate32() *ColArr[time.Time] { 46 | return &ColArr[time.Time]{ 47 | Data: new(ColDate32), 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /proto/col_date32_gen.go: -------------------------------------------------------------------------------- 1 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 2 | 3 | package proto 4 | 5 | // ColDate32 represents Date32 column. 6 | type ColDate32 []Date32 7 | 8 | // Compile-time assertions for ColDate32. 9 | var ( 10 | _ ColInput = ColDate32{} 11 | _ ColResult = (*ColDate32)(nil) 12 | _ Column = (*ColDate32)(nil) 13 | ) 14 | 15 | // Rows returns count of rows in column. 16 | func (c ColDate32) Rows() int { 17 | return len(c) 18 | } 19 | 20 | // Reset resets data in row, preserving capacity for efficiency. 21 | func (c *ColDate32) Reset() { 22 | *c = (*c)[:0] 23 | } 24 | 25 | // Type returns ColumnType of Date32. 26 | func (ColDate32) Type() ColumnType { 27 | return ColumnTypeDate32 28 | } 29 | -------------------------------------------------------------------------------- /proto/col_date32_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Date32 rows from *Reader. 16 | func (c *ColDate32) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 32 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | Date32(binary.LittleEndian.Uint32(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Date32 rows to *Buffer. 40 | func (c ColDate32) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 32 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint32( 50 | b.Buf[offset:offset+size], 51 | uint32(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColDate32) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_date32_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Date32 rows from *Reader. 14 | func (c *ColDate32) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]Date32, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 32 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Date32 rows to *Buffer. 31 | func (c ColDate32) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 32 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColDate32) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 32 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_date_gen.go: -------------------------------------------------------------------------------- 1 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 2 | 3 | package proto 4 | 5 | // ColDate represents Date column. 6 | type ColDate []Date 7 | 8 | // Compile-time assertions for ColDate. 9 | var ( 10 | _ ColInput = ColDate{} 11 | _ ColResult = (*ColDate)(nil) 12 | _ Column = (*ColDate)(nil) 13 | ) 14 | 15 | // Rows returns count of rows in column. 16 | func (c ColDate) Rows() int { 17 | return len(c) 18 | } 19 | 20 | // Reset resets data in row, preserving capacity for efficiency. 21 | func (c *ColDate) Reset() { 22 | *c = (*c)[:0] 23 | } 24 | 25 | // Type returns ColumnType of Date. 26 | func (ColDate) Type() ColumnType { 27 | return ColumnTypeDate 28 | } 29 | -------------------------------------------------------------------------------- /proto/col_date_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Date rows from *Reader. 16 | func (c *ColDate) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 16 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | Date(binary.LittleEndian.Uint16(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Date rows to *Buffer. 40 | func (c ColDate) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 16 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint16( 50 | b.Buf[offset:offset+size], 51 | uint16(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColDate) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_date_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Date rows from *Reader. 14 | func (c *ColDate) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]Date, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 16 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Date rows to *Buffer. 31 | func (c ColDate) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 16 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColDate) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 16 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_decimal128_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Decimal128 rows from *Reader. 16 | func (c *ColDecimal128) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 128 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | Decimal128(binUInt128(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Decimal128 rows to *Buffer. 40 | func (c ColDecimal128) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 128 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binPutUInt128( 50 | b.Buf[offset:offset+size], 51 | UInt128(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColDecimal128) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_decimal256_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Decimal256 rows from *Reader. 16 | func (c *ColDecimal256) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 256 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | Decimal256(binUInt256(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Decimal256 rows to *Buffer. 40 | func (c ColDecimal256) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 256 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binPutUInt256( 50 | b.Buf[offset:offset+size], 51 | UInt256(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColDecimal256) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_enum16_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Enum16 rows from *Reader. 16 | func (c *ColEnum16) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 16 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | Enum16(binary.LittleEndian.Uint16(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Enum16 rows to *Buffer. 40 | func (c ColEnum16) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 16 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint16( 50 | b.Buf[offset:offset+size], 51 | uint16(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColEnum16) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_enum16_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Enum16 rows from *Reader. 14 | func (c *ColEnum16) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]Enum16, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 16 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Enum16 rows to *Buffer. 31 | func (c ColEnum16) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 16 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColEnum16) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 16 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_enum8_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Enum8 rows from *Reader. 16 | func (c *ColEnum8) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | data, err := r.ReadRaw(rows) 21 | if err != nil { 22 | return errors.Wrap(err, "read") 23 | } 24 | v := *c 25 | v = append(v, make([]Enum8, rows)...) 26 | for i := range data { 27 | v[i] = Enum8(data[i]) 28 | } 29 | *c = v 30 | return nil 31 | } 32 | 33 | // EncodeColumn encodes Enum8 rows to *Buffer. 34 | func (c ColEnum8) EncodeColumn(b *Buffer) { 35 | v := c 36 | if len(v) == 0 { 37 | return 38 | } 39 | start := len(b.Buf) 40 | b.Buf = append(b.Buf, make([]byte, len(v))...) 41 | for i := range v { 42 | b.Buf[i+start] = uint8(v[i]) 43 | } 44 | } 45 | 46 | func (c ColEnum8) WriteColumn(w *Writer) { 47 | w.ChainBuffer(c.EncodeColumn) 48 | } 49 | -------------------------------------------------------------------------------- /proto/col_enum8_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Enum8 rows from *Reader. 14 | func (c *ColEnum8) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]Enum8, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | dst := *(*[]byte)(unsafe.Pointer(&s)) 21 | if err := r.ReadFull(dst); err != nil { 22 | return errors.Wrap(err, "read full") 23 | } 24 | return nil 25 | } 26 | 27 | // EncodeColumn encodes Enum8 rows to *Buffer. 28 | func (c ColEnum8) EncodeColumn(b *Buffer) { 29 | v := c 30 | if len(v) == 0 { 31 | return 32 | } 33 | offset := len(b.Buf) 34 | b.Buf = append(b.Buf, make([]byte, len(v))...) 35 | s := *(*slice)(unsafe.Pointer(&v)) 36 | src := *(*[]byte)(unsafe.Pointer(&s)) 37 | dst := b.Buf[offset:] 38 | copy(dst, src) 39 | } 40 | 41 | func (c ColEnum8) WriteColumn(w *Writer) { 42 | v := c 43 | if len(v) == 0 { 44 | return 45 | } 46 | src := *(*[]byte)(unsafe.Pointer(&v)) 47 | w.ChainWrite(src) 48 | } 49 | -------------------------------------------------------------------------------- /proto/col_fixedstr128_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes FixedStr128 rows from *Reader. 16 | func (c *ColFixedStr128) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 128 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | *(*[128]byte)(data[i : i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes FixedStr128 rows to *Buffer. 40 | func (c ColFixedStr128) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 128 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | copy( 50 | b.Buf[offset:offset+size], 51 | vv[:], 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColFixedStr128) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_fixedstr16_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes FixedStr16 rows from *Reader. 16 | func (c *ColFixedStr16) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 16 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | *(*[16]byte)(data[i : i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes FixedStr16 rows to *Buffer. 40 | func (c ColFixedStr16) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 16 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | copy( 50 | b.Buf[offset:offset+size], 51 | vv[:], 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColFixedStr16) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_fixedstr256_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes FixedStr256 rows from *Reader. 16 | func (c *ColFixedStr256) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 256 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | *(*[256]byte)(data[i : i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes FixedStr256 rows to *Buffer. 40 | func (c ColFixedStr256) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 256 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | copy( 50 | b.Buf[offset:offset+size], 51 | vv[:], 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColFixedStr256) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_fixedstr32_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes FixedStr32 rows from *Reader. 16 | func (c *ColFixedStr32) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 32 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | *(*[32]byte)(data[i : i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes FixedStr32 rows to *Buffer. 40 | func (c ColFixedStr32) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 32 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | copy( 50 | b.Buf[offset:offset+size], 51 | vv[:], 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColFixedStr32) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_fixedstr512_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes FixedStr512 rows from *Reader. 16 | func (c *ColFixedStr512) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 512 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | *(*[512]byte)(data[i : i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes FixedStr512 rows to *Buffer. 40 | func (c ColFixedStr512) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 512 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | copy( 50 | b.Buf[offset:offset+size], 51 | vv[:], 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColFixedStr512) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_fixedstr64_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes FixedStr64 rows from *Reader. 16 | func (c *ColFixedStr64) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 64 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | *(*[64]byte)(data[i : i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes FixedStr64 rows to *Buffer. 40 | func (c ColFixedStr64) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 64 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | copy( 50 | b.Buf[offset:offset+size], 51 | vv[:], 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColFixedStr64) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_fixedstr8_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes FixedStr8 rows from *Reader. 16 | func (c *ColFixedStr8) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | *(*[8]byte)(data[i : i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes FixedStr8 rows to *Buffer. 40 | func (c ColFixedStr8) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | copy( 50 | b.Buf[offset:offset+size], 51 | vv[:], 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColFixedStr8) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_fixedstr8_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes FixedStr8 rows from *Reader. 14 | func (c *ColFixedStr8) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([][8]byte, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes FixedStr8 rows to *Buffer. 31 | func (c ColFixedStr8) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColFixedStr8) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_float32_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Float32 rows from *Reader. 14 | func (c *ColFloat32) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]float32, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 32 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Float32 rows to *Buffer. 31 | func (c ColFloat32) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 32 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColFloat32) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 32 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_float64_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Float64 rows from *Reader. 14 | func (c *ColFloat64) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]float64, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 64 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Float64 rows to *Buffer. 31 | func (c ColFloat64) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 64 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColFloat64) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 64 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_int128_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Int128 rows from *Reader. 16 | func (c *ColInt128) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 128 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | Int128(binUInt128(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Int128 rows to *Buffer. 40 | func (c ColInt128) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 128 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binPutUInt128( 50 | b.Buf[offset:offset+size], 51 | UInt128(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColInt128) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_int128_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Int128 rows from *Reader. 14 | func (c *ColInt128) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]Int128, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 128 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Int128 rows to *Buffer. 31 | func (c ColInt128) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 128 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColInt128) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 128 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_int16_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Int16 rows from *Reader. 16 | func (c *ColInt16) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 16 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | int16(binary.LittleEndian.Uint16(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Int16 rows to *Buffer. 40 | func (c ColInt16) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 16 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint16( 50 | b.Buf[offset:offset+size], 51 | uint16(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColInt16) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_int16_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Int16 rows from *Reader. 14 | func (c *ColInt16) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]int16, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 16 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Int16 rows to *Buffer. 31 | func (c ColInt16) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 16 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColInt16) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 16 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_int256_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Int256 rows from *Reader. 16 | func (c *ColInt256) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 256 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | Int256(binUInt256(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Int256 rows to *Buffer. 40 | func (c ColInt256) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 256 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binPutUInt256( 50 | b.Buf[offset:offset+size], 51 | UInt256(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColInt256) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_int256_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Int256 rows from *Reader. 14 | func (c *ColInt256) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]Int256, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 256 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Int256 rows to *Buffer. 31 | func (c ColInt256) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 256 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColInt256) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 256 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_int32_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Int32 rows from *Reader. 16 | func (c *ColInt32) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 32 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | int32(binary.LittleEndian.Uint32(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Int32 rows to *Buffer. 40 | func (c ColInt32) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 32 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint32( 50 | b.Buf[offset:offset+size], 51 | uint32(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColInt32) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_int32_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Int32 rows from *Reader. 14 | func (c *ColInt32) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]int32, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 32 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Int32 rows to *Buffer. 31 | func (c ColInt32) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 32 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColInt32) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 32 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_int64_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Int64 rows from *Reader. 16 | func (c *ColInt64) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 64 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | int64(binary.LittleEndian.Uint64(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes Int64 rows to *Buffer. 40 | func (c ColInt64) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 64 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint64( 50 | b.Buf[offset:offset+size], 51 | uint64(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColInt64) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_int64_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Int64 rows from *Reader. 14 | func (c *ColInt64) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]int64, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 64 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes Int64 rows to *Buffer. 31 | func (c ColInt64) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 64 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColInt64) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 64 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_int8_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes Int8 rows from *Reader. 16 | func (c *ColInt8) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | data, err := r.ReadRaw(rows) 21 | if err != nil { 22 | return errors.Wrap(err, "read") 23 | } 24 | v := *c 25 | v = append(v, make([]int8, rows)...) 26 | for i := range data { 27 | v[i] = int8(data[i]) 28 | } 29 | *c = v 30 | return nil 31 | } 32 | 33 | // EncodeColumn encodes Int8 rows to *Buffer. 34 | func (c ColInt8) EncodeColumn(b *Buffer) { 35 | v := c 36 | if len(v) == 0 { 37 | return 38 | } 39 | start := len(b.Buf) 40 | b.Buf = append(b.Buf, make([]byte, len(v))...) 41 | for i := range v { 42 | b.Buf[i+start] = uint8(v[i]) 43 | } 44 | } 45 | 46 | func (c ColInt8) WriteColumn(w *Writer) { 47 | w.ChainBuffer(c.EncodeColumn) 48 | } 49 | -------------------------------------------------------------------------------- /proto/col_int8_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes Int8 rows from *Reader. 14 | func (c *ColInt8) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]int8, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | dst := *(*[]byte)(unsafe.Pointer(&s)) 21 | if err := r.ReadFull(dst); err != nil { 22 | return errors.Wrap(err, "read full") 23 | } 24 | return nil 25 | } 26 | 27 | // EncodeColumn encodes Int8 rows to *Buffer. 28 | func (c ColInt8) EncodeColumn(b *Buffer) { 29 | v := c 30 | if len(v) == 0 { 31 | return 32 | } 33 | offset := len(b.Buf) 34 | b.Buf = append(b.Buf, make([]byte, len(v))...) 35 | s := *(*slice)(unsafe.Pointer(&v)) 36 | src := *(*[]byte)(unsafe.Pointer(&s)) 37 | dst := b.Buf[offset:] 38 | copy(dst, src) 39 | } 40 | 41 | func (c ColInt8) WriteColumn(w *Writer) { 42 | v := c 43 | if len(v) == 0 { 44 | return 45 | } 46 | src := *(*[]byte)(unsafe.Pointer(&v)) 47 | w.ChainWrite(src) 48 | } 49 | -------------------------------------------------------------------------------- /proto/col_ipv4_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes IPv4 rows from *Reader. 16 | func (c *ColIPv4) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 32 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | IPv4(binary.LittleEndian.Uint32(data[i:i+size])), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes IPv4 rows to *Buffer. 40 | func (c ColIPv4) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 32 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint32( 50 | b.Buf[offset:offset+size], 51 | uint32(vv), 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColIPv4) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_ipv4_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes IPv4 rows from *Reader. 14 | func (c *ColIPv4) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]IPv4, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 32 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes IPv4 rows to *Buffer. 31 | func (c ColIPv4) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 32 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColIPv4) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 32 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_ipv6_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes IPv6 rows from *Reader. 16 | func (c *ColIPv6) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 128 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | binIPv6(data[i:i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes IPv6 rows to *Buffer. 40 | func (c ColIPv6) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 128 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binPutIPv6( 50 | b.Buf[offset:offset+size], 51 | vv, 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColIPv6) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_ipv6_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes IPv6 rows from *Reader. 14 | func (c *ColIPv6) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]IPv6, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 128 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes IPv6 rows to *Buffer. 31 | func (c ColIPv6) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 128 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColIPv6) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 128 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_map_go123.go: -------------------------------------------------------------------------------- 1 | //go:build go1.23 2 | 3 | package proto 4 | 5 | import "iter" 6 | 7 | // RowRange returns a [iter.Seq2] iterator over i-th row. 8 | func (c ColMap[K, V]) RowRange(i int) iter.Seq2[K, V] { 9 | var start int 10 | end := int(c.Offsets[i]) 11 | if i > 0 { 12 | start = int(c.Offsets[i-1]) 13 | } 14 | 15 | return func(yield func(K, V) bool) { 16 | for idx := start; idx < end; idx++ { 17 | if !yield( 18 | c.Keys.Row(idx), 19 | c.Values.Row(idx), 20 | ) { 21 | return 22 | } 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /proto/col_map_go123_test.go: -------------------------------------------------------------------------------- 1 | //go:build go1.23 2 | 3 | package proto 4 | 5 | import ( 6 | "testing" 7 | 8 | "github.com/stretchr/testify/require" 9 | ) 10 | 11 | func TestColMapRange(t *testing.T) { 12 | var ( 13 | enc = &ColMap[string, string]{ 14 | Keys: &ColStr{}, 15 | Values: &ColStr{}, 16 | } 17 | expected = []map[string]string{ 18 | { 19 | "a": "b", 20 | "c": "d", 21 | }, 22 | { 23 | "e": "f", 24 | }, 25 | } 26 | ) 27 | enc.AppendArr(expected) 28 | 29 | var buf Buffer 30 | enc.EncodeColumn(&buf) 31 | 32 | var ( 33 | dec = &ColMap[string, string]{ 34 | Keys: &ColStr{}, 35 | Values: &ColStr{}, 36 | } 37 | got []map[string]string 38 | ) 39 | require.NoError(t, dec.DecodeColumn(buf.Reader(), enc.Rows())) 40 | for rowIdx := range dec.Rows() { 41 | row := map[string]string{} 42 | for k, v := range dec.RowRange(rowIdx) { 43 | row[k] = v 44 | } 45 | got = append(got, row) 46 | } 47 | require.Equal(t, expected, got) 48 | } 49 | -------------------------------------------------------------------------------- /proto/col_raw.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "github.com/go-faster/errors" 4 | 5 | // ColRaw is Column that performs zero decoding or encoding. 6 | // T, Size are required. 7 | // 8 | // TODO: support strings and T, Size inference. 9 | // 10 | // Useful for copying from one source to another. 11 | type ColRaw struct { 12 | T ColumnType // type of column 13 | Size int // size of single value 14 | 15 | Data []byte // raw value of column 16 | Count int // count of rows 17 | } 18 | 19 | func (c ColRaw) Type() ColumnType { return c.T } 20 | func (c ColRaw) Rows() int { return c.Count } 21 | func (c ColRaw) EncodeColumn(b *Buffer) { b.Buf = append(b.Buf, c.Data...) } 22 | 23 | func (c *ColRaw) DecodeColumn(r *Reader, rows int) error { 24 | c.Count = rows 25 | c.Data = append(c.Data[:0], make([]byte, c.Size*rows)...) 26 | if err := r.ReadFull(c.Data); err != nil { 27 | return errors.Wrap(err, "read full") 28 | } 29 | return nil 30 | } 31 | 32 | func (c *ColRaw) Reset() { 33 | c.Count = 0 34 | c.Data = c.Data[:0] 35 | } 36 | -------------------------------------------------------------------------------- /proto/col_uint128_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes UInt128 rows from *Reader. 16 | func (c *ColUInt128) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 128 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | binUInt128(data[i:i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes UInt128 rows to *Buffer. 40 | func (c ColUInt128) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 128 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binPutUInt128( 50 | b.Buf[offset:offset+size], 51 | vv, 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColUInt128) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_uint128_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes UInt128 rows from *Reader. 14 | func (c *ColUInt128) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]UInt128, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 128 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes UInt128 rows to *Buffer. 31 | func (c ColUInt128) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 128 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColUInt128) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 128 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_uint16_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes UInt16 rows from *Reader. 16 | func (c *ColUInt16) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 16 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | binary.LittleEndian.Uint16(data[i:i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes UInt16 rows to *Buffer. 40 | func (c ColUInt16) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 16 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint16( 50 | b.Buf[offset:offset+size], 51 | vv, 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColUInt16) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_uint16_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes UInt16 rows from *Reader. 14 | func (c *ColUInt16) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]uint16, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 16 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes UInt16 rows to *Buffer. 31 | func (c ColUInt16) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 16 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColUInt16) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 16 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_uint256_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes UInt256 rows from *Reader. 16 | func (c *ColUInt256) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 256 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | binUInt256(data[i:i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes UInt256 rows to *Buffer. 40 | func (c ColUInt256) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 256 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binPutUInt256( 50 | b.Buf[offset:offset+size], 51 | vv, 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColUInt256) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_uint256_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes UInt256 rows from *Reader. 14 | func (c *ColUInt256) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]UInt256, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 256 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes UInt256 rows to *Buffer. 31 | func (c ColUInt256) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 256 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColUInt256) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 256 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_uint32_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes UInt32 rows from *Reader. 16 | func (c *ColUInt32) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 32 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | binary.LittleEndian.Uint32(data[i:i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes UInt32 rows to *Buffer. 40 | func (c ColUInt32) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 32 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint32( 50 | b.Buf[offset:offset+size], 51 | vv, 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColUInt32) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_uint32_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes UInt32 rows from *Reader. 14 | func (c *ColUInt32) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]uint32, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 32 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes UInt32 rows to *Buffer. 31 | func (c ColUInt32) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 32 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColUInt32) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 32 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_uint64_safe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "encoding/binary" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 14 | 15 | // DecodeColumn decodes UInt64 rows from *Reader. 16 | func (c *ColUInt64) DecodeColumn(r *Reader, rows int) error { 17 | if rows == 0 { 18 | return nil 19 | } 20 | const size = 64 / 8 21 | data, err := r.ReadRaw(rows * size) 22 | if err != nil { 23 | return errors.Wrap(err, "read") 24 | } 25 | v := *c 26 | // Move bound check out of loop. 27 | // 28 | // See https://github.com/golang/go/issues/30945. 29 | _ = data[len(data)-size] 30 | for i := 0; i <= len(data)-size; i += size { 31 | v = append(v, 32 | binary.LittleEndian.Uint64(data[i:i+size]), 33 | ) 34 | } 35 | *c = v 36 | return nil 37 | } 38 | 39 | // EncodeColumn encodes UInt64 rows to *Buffer. 40 | func (c ColUInt64) EncodeColumn(b *Buffer) { 41 | v := c 42 | if len(v) == 0 { 43 | return 44 | } 45 | const size = 64 / 8 46 | offset := len(b.Buf) 47 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 48 | for _, vv := range v { 49 | binary.LittleEndian.PutUint64( 50 | b.Buf[offset:offset+size], 51 | vv, 52 | ) 53 | offset += size 54 | } 55 | } 56 | 57 | func (c ColUInt64) WriteColumn(w *Writer) { 58 | w.ChainBuffer(c.EncodeColumn) 59 | } 60 | -------------------------------------------------------------------------------- /proto/col_uint64_unsafe_gen.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 4 | 5 | package proto 6 | 7 | import ( 8 | "unsafe" 9 | 10 | "github.com/go-faster/errors" 11 | ) 12 | 13 | // DecodeColumn decodes UInt64 rows from *Reader. 14 | func (c *ColUInt64) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | *c = append(*c, make([]uint64, rows)...) 19 | s := *(*slice)(unsafe.Pointer(c)) 20 | const size = 64 / 8 21 | s.Len *= size 22 | s.Cap *= size 23 | dst := *(*[]byte)(unsafe.Pointer(&s)) 24 | if err := r.ReadFull(dst); err != nil { 25 | return errors.Wrap(err, "read full") 26 | } 27 | return nil 28 | } 29 | 30 | // EncodeColumn encodes UInt64 rows to *Buffer. 31 | func (c ColUInt64) EncodeColumn(b *Buffer) { 32 | v := c 33 | if len(v) == 0 { 34 | return 35 | } 36 | offset := len(b.Buf) 37 | const size = 64 / 8 38 | b.Buf = append(b.Buf, make([]byte, size*len(v))...) 39 | s := *(*slice)(unsafe.Pointer(&v)) 40 | s.Len *= size 41 | s.Cap *= size 42 | src := *(*[]byte)(unsafe.Pointer(&s)) 43 | dst := b.Buf[offset:] 44 | copy(dst, src) 45 | } 46 | 47 | func (c ColUInt64) WriteColumn(w *Writer) { 48 | v := c 49 | if len(v) == 0 { 50 | return 51 | } 52 | const size = 64 / 8 53 | 54 | s := *(*slice)(unsafe.Pointer(&v)) 55 | s.Len *= size 56 | s.Cap *= size 57 | 58 | src := *(*[]byte)(unsafe.Pointer(&s)) 59 | w.ChainWrite(src) 60 | } 61 | -------------------------------------------------------------------------------- /proto/col_uint8_safe_gen.go: -------------------------------------------------------------------------------- 1 | // Code generated by ./cmd/ch-gen-col, DO NOT EDIT. 2 | 3 | package proto 4 | 5 | import ( 6 | "encoding/binary" 7 | 8 | "github.com/go-faster/errors" 9 | ) 10 | 11 | var _ = binary.LittleEndian // clickHouse uses LittleEndian 12 | 13 | // DecodeColumn decodes UInt8 rows from *Reader. 14 | func (c *ColUInt8) DecodeColumn(r *Reader, rows int) error { 15 | if rows == 0 { 16 | return nil 17 | } 18 | data, err := r.ReadRaw(rows) 19 | if err != nil { 20 | return errors.Wrap(err, "read") 21 | } 22 | *c = append(*c, data...) 23 | return nil 24 | } 25 | 26 | // EncodeColumn encodes UInt8 rows to *Buffer. 27 | func (c ColUInt8) EncodeColumn(b *Buffer) { 28 | v := c 29 | if len(v) == 0 { 30 | return 31 | } 32 | b.Buf = append(b.Buf, v...) 33 | } 34 | 35 | func (c ColUInt8) WriteColumn(w *Writer) { 36 | w.ChainWrite([]byte(c)) 37 | } 38 | -------------------------------------------------------------------------------- /proto/col_uuid.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "github.com/google/uuid" 5 | ) 6 | 7 | // ColUUID is UUID column. 8 | type ColUUID []uuid.UUID 9 | 10 | // Compile-time assertions for ColUUID. 11 | var ( 12 | _ ColInput = ColUUID{} 13 | _ ColResult = (*ColUUID)(nil) 14 | _ Column = (*ColUUID)(nil) 15 | _ ColumnOf[uuid.UUID] = (*ColUUID)(nil) 16 | ) 17 | 18 | func (c ColUUID) Type() ColumnType { return ColumnTypeUUID } 19 | func (c ColUUID) Rows() int { return len(c) } 20 | func (c ColUUID) Row(i int) uuid.UUID { return c[i] } 21 | func (c *ColUUID) Reset() { *c = (*c)[:0] } 22 | func (c *ColUUID) Append(v uuid.UUID) { *c = append(*c, v) } 23 | func (c *ColUUID) AppendArr(v []uuid.UUID) { *c = append(*c, v...) } 24 | 25 | // Nullable is helper that creates Nullable(uuid.UUID). 26 | func (c *ColUUID) Nullable() *ColNullable[uuid.UUID] { 27 | return NewColNullable[uuid.UUID](c) 28 | } 29 | 30 | // Array is helper that creates Array of uuid.UUID. 31 | func (c *ColUUID) Array() *ColArr[uuid.UUID] { 32 | return NewArray[uuid.UUID](c) 33 | } 34 | -------------------------------------------------------------------------------- /proto/col_uuid_safe.go: -------------------------------------------------------------------------------- 1 | //go:build !(amd64 || arm64 || riscv64) || purego 2 | 3 | package proto 4 | 5 | import ( 6 | "github.com/go-faster/errors" 7 | "github.com/segmentio/asm/bswap" 8 | ) 9 | 10 | func (c *ColUUID) DecodeColumn(r *Reader, rows int) error { 11 | const size = 16 12 | data, err := r.ReadRaw(rows * size) 13 | if err != nil { 14 | return errors.Wrap(err, "read") 15 | } 16 | v := *c 17 | bswap.Swap64(data) // BE <-> LE 18 | for i := 0; i < len(data); i += size { 19 | // In-place conversion from slice to array. 20 | // https://go.dev/ref/spec#Conversions_from_slice_to_array_pointer 21 | v = append(v, *(*[size]byte)(data[i : i+size])) 22 | } 23 | *c = v 24 | return nil 25 | } 26 | 27 | func (c ColUUID) EncodeColumn(b *Buffer) { 28 | const size = 16 29 | offset := len(b.Buf) 30 | b.Buf = append(b.Buf, make([]byte, size*len(c))...) 31 | for _, v := range c { 32 | copy(b.Buf[offset:offset+size], v[:]) 33 | offset += size 34 | } 35 | bswap.Swap64(b.Buf) // BE <-> LE 36 | } 37 | 38 | // WriteColumn encodes ColUUID rows to *Writer. 39 | func (c ColUUID) WriteColumn(w *Writer) { 40 | if len(c) == 0 { 41 | return 42 | } 43 | // Can't write UUID as-is: bswap is required. 44 | w.ChainBuffer(c.EncodeColumn) 45 | } 46 | -------------------------------------------------------------------------------- /proto/compression.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | //go:generate go run github.com/dmarkham/enumer -type Compression -trimprefix Compression -output compression_enum.go 4 | 5 | // Compression status. 6 | type Compression byte 7 | 8 | // Compression statuses. 9 | const ( 10 | CompressionDisabled Compression = 0 11 | CompressionEnabled Compression = 1 12 | ) 13 | 14 | // Encode to buffer. 15 | func (c Compression) Encode(b *Buffer) { 16 | b.PutUVarInt(uint64(c)) 17 | } 18 | -------------------------------------------------------------------------------- /proto/date.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "time" 4 | 5 | // Date represents Date value. 6 | // 7 | // https://clickhouse.com/docs/en/sql-reference/data-types/date/ 8 | type Date uint16 9 | 10 | // DateLayout is default time format for Date. 11 | const DateLayout = "2006-01-02" 12 | 13 | // secInDay represents seconds in day. 14 | // 15 | // NB: works only on UTC, use time.Date, time.Time.AddDate. 16 | const secInDay = 24 * 60 * 60 17 | 18 | // Unix returns unix timestamp of Date. 19 | func (d Date) Unix() int64 { 20 | return secInDay * int64(d) 21 | } 22 | 23 | // Time returns UTC starting time.Time of Date. 24 | // 25 | // You can use time.Unix(d.Unix(), 0) to get Time in time.Local location. 26 | func (d Date) Time() time.Time { 27 | return time.Unix(d.Unix(), 0).UTC() 28 | } 29 | 30 | func (d Date) String() string { 31 | return d.Time().UTC().Format(DateLayout) 32 | } 33 | 34 | // ToDate returns Date of time.Time. 35 | func ToDate(t time.Time) Date { 36 | if t.IsZero() { 37 | return 0 38 | } 39 | _, offset := t.Zone() 40 | return Date((t.Unix() + int64(offset)) / secInDay) 41 | } 42 | 43 | // NewDate returns the Date corresponding to year, month and day in UTC. 44 | func NewDate(year int, month time.Month, day int) Date { 45 | return ToDate(time.Date(year, month, day, 0, 0, 0, 0, time.UTC)) 46 | } 47 | -------------------------------------------------------------------------------- /proto/date32.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "time" 4 | 5 | // Date32 represents Date32 value. 6 | // 7 | // https://clickhouse.com/docs/en/sql-reference/data-types/date32/ 8 | type Date32 int32 9 | 10 | // Unix returns unix timestamp of Date32. 11 | // 12 | // You can use time.Unix(d.Unix(), 0) to get Time in time.Local location. 13 | func (d Date32) Unix() int64 { 14 | return secInDay * int64(d) 15 | } 16 | 17 | // Time returns UTC starting time.Time of Date32. 18 | func (d Date32) Time() time.Time { 19 | return time.Unix(d.Unix(), 0).UTC() 20 | } 21 | 22 | func (d Date32) String() string { 23 | return d.Time().Format(DateLayout) 24 | } 25 | 26 | // ToDate32 returns Date32 of time.Time. 27 | func ToDate32(t time.Time) Date32 { 28 | if t.IsZero() { 29 | return 0 30 | } 31 | _, offset := t.Zone() 32 | return Date32((t.Unix() + int64(offset)) / secInDay) 33 | } 34 | 35 | // NewDate32 returns the Date32 corresponding to year, month and day in UTC. 36 | func NewDate32(year int, month time.Month, day int) Date32 { 37 | return ToDate32(time.Date(year, month, day, 0, 0, 0, 0, time.UTC)) 38 | } 39 | -------------------------------------------------------------------------------- /proto/datetime.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "time" 4 | 5 | // DateTime represents DateTime type. 6 | type DateTime uint32 7 | 8 | // ToDateTime converts time.Time to DateTime. 9 | func ToDateTime(t time.Time) DateTime { 10 | if t.IsZero() { 11 | return 0 12 | } 13 | return DateTime(t.Unix()) 14 | } 15 | 16 | // Time returns DateTime as time.Time. 17 | func (d DateTime) Time() time.Time { 18 | // https://clickhouse.com/docs/en/sql-reference/data-types/datetime/#usage-remarks 19 | // ClickHouse stores UTC timestamps that are timezone-agnostic. 20 | return time.Unix(int64(d), 0) 21 | } 22 | -------------------------------------------------------------------------------- /proto/datetime64_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "testing" 5 | "time" 6 | 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestDateTime64_Time(t *testing.T) { 11 | for _, p := range []Precision{ 12 | PrecisionSecond, 13 | 1, 14 | PrecisionMilli, 15 | PrecisionMicro, 16 | PrecisionNano, 17 | 8, 18 | } { 19 | t.Run(p.Duration().String(), func(t *testing.T) { 20 | for _, v := range []time.Time{ 21 | time.Unix(0, 0).UTC(), // zero time 22 | time.Unix(1546290000, 0).UTC(), 23 | } { 24 | d := ToDateTime64(v, p) 25 | vt := d.Time(p) 26 | assert.Equal(t, ToDateTime64(v, p), d) 27 | assert.Equal(t, v.Unix(), vt.Unix()) 28 | assert.True(t, p.Valid()) 29 | } 30 | }) 31 | 32 | t.Run("Zero_"+p.Duration().String(), func(t *testing.T) { 33 | t1 := time.Time{} 34 | t2 := time.Unix(0, 0).UTC() 35 | d1 := ToDateTime64(t1, p) 36 | d2 := ToDateTime64(t2, p) 37 | vt1 := d1.Time(p) 38 | vt2 := d2.Time(p) 39 | 40 | assert.True(t, t1.IsZero()) 41 | assert.False(t, t2.IsZero()) 42 | assert.Equal(t, d1, d2) 43 | assert.Equal(t, vt1.Unix(), int64(0)) 44 | assert.Equal(t, vt2.Unix(), int64(0)) 45 | }) 46 | } 47 | t.Run("Duration", func(t *testing.T) { 48 | assert.Equal(t, time.Second, PrecisionSecond.Duration(), "sec") 49 | assert.Equal(t, time.Nanosecond, PrecisionNano.Duration(), "ns") 50 | }) 51 | } 52 | -------------------------------------------------------------------------------- /proto/datetime_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "testing" 5 | "time" 6 | 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestDateTime_ToDateTime(t *testing.T) { 11 | t.Run("Ok", func(t *testing.T) { 12 | v := time.Unix(1546290000, 0).UTC() 13 | d := ToDateTime(v) 14 | assert.Equal(t, int32(1546290000), int32(d)) 15 | }) 16 | t.Run("Zero", func(t *testing.T) { 17 | v := time.Time{} 18 | d := ToDateTime(v) 19 | assert.Equal(t, int32(0), int32(d)) 20 | }) 21 | } 22 | 23 | func TestDateTime_Time(t *testing.T) { 24 | t.Run("OK", func(t *testing.T) { 25 | d := DateTime(1546290000) 26 | assert.Equal(t, d.Time().Unix(), int64(1546290000)) 27 | }) 28 | 29 | t.Run("Zero", func(t *testing.T) { 30 | d := DateTime(0) 31 | assert.Equal(t, d.Time().Unix(), int64(0)) 32 | }) 33 | 34 | t.Run("IsZero", func(t *testing.T) { 35 | d1 := DateTime(0) 36 | d2 := time.Time{} 37 | assert.Equal(t, d1.Time().IsZero(), false) 38 | assert.Equal(t, d2.IsZero(), true) 39 | }) 40 | } 41 | -------------------------------------------------------------------------------- /proto/decimal.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | // Decimal32 represents Decimal32 value. 4 | type Decimal32 int32 5 | 6 | // Decimal64 represents Decimal32 value. 7 | type Decimal64 int64 8 | 9 | // Decimal128 represents Decimal128 value. 10 | type Decimal128 Int128 11 | 12 | // Decimal256 represents Decimal256 value. 13 | type Decimal256 Int256 14 | -------------------------------------------------------------------------------- /proto/decimal_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | func Decimal128FromInt(v int) Decimal128 { 4 | return Decimal128(Int128FromInt(v)) 5 | } 6 | 7 | func Decimal256FromInt(v int) Decimal256 { 8 | return Decimal256(Int256FromInt(v)) 9 | } 10 | -------------------------------------------------------------------------------- /proto/dump_external_test.go: -------------------------------------------------------------------------------- 1 | package proto_test 2 | 3 | import ( 4 | "bytes" 5 | "fmt" 6 | 7 | "github.com/ClickHouse/ch-go/proto" 8 | ) 9 | 10 | func ExampleBlock_EncodeBlock() { 11 | // See ./internal/cmd/ch-native-dump for more sophisticated example. 12 | var ( 13 | colK proto.ColInt64 14 | colV proto.ColInt64 15 | ) 16 | // Generate some data. 17 | for i := 0; i < 100; i++ { 18 | colK.Append(int64(i)) 19 | colV.Append(int64(i) + 1000) 20 | } 21 | // Write data to buffer. 22 | var buf proto.Buffer 23 | input := proto.Input{ 24 | {"k", colK}, 25 | {"v", colV}, 26 | } 27 | b := proto.Block{ 28 | Rows: colK.Rows(), 29 | Columns: len(input), 30 | } 31 | // Note that we are using version 54451, proto.Version will fail. 32 | if err := b.EncodeRawBlock(&buf, 54451, input); err != nil { 33 | panic(err) 34 | } 35 | 36 | // You can write buf.Buf to io.Writer, e.g. os.Stdout or file. 37 | var out bytes.Buffer 38 | _, _ = out.Write(buf.Buf) 39 | 40 | // You can encode multiple buffers in sequence. 41 | // 42 | // To do this, reset buf and all columns, append new values 43 | // to columns and call EncodeRawBlock again. 44 | buf.Reset() 45 | colV.Reset() 46 | colV.Reset() 47 | 48 | fmt.Println(out.Len()) 49 | // Output: 1618 50 | } 51 | -------------------------------------------------------------------------------- /proto/dump_test.go: -------------------------------------------------------------------------------- 1 | package proto_test 2 | 3 | import ( 4 | "bytes" 5 | "os" 6 | "path/filepath" 7 | "testing" 8 | 9 | "github.com/stretchr/testify/require" 10 | 11 | "github.com/ClickHouse/ch-go/proto" 12 | ) 13 | 14 | func TestDump(t *testing.T) { 15 | // Testing decoding of Native format dump. 16 | // 17 | // CREATE TABLE test_dump (id Int8, v String) 18 | // ENGINE = MergeTree() 19 | // ORDER BY id; 20 | // 21 | // SELECT * FROM test_dump 22 | // ORDER BY id 23 | // INTO OUTFILE 'test_dump_native.raw' FORMAT Native; 24 | data, err := os.ReadFile(filepath.Join("_testdata", "test_dump_native.raw")) 25 | require.NoError(t, err) 26 | var ( 27 | dec proto.Block 28 | ids proto.ColInt8 29 | values proto.ColStr 30 | ) 31 | require.NoError(t, dec.DecodeRawBlock(proto.NewReader(bytes.NewReader(data)), 54451, proto.Results{ 32 | {Name: "id", Data: &ids}, 33 | {Name: "v", Data: &values}, 34 | }), 35 | ) 36 | } 37 | 38 | func TestDumpLowCardinality(t *testing.T) { 39 | data, err := os.ReadFile(filepath.Join("_testdata", "select_lc.raw")) 40 | require.NoError(t, err) 41 | col := new(proto.ColStr).LowCardinality().Array() 42 | var dec proto.Block 43 | require.NoError(t, dec.DecodeRawBlock(proto.NewReader(bytes.NewReader(data)), 54451, proto.Results{ 44 | {Name: "v", Data: col}, 45 | }), 46 | ) 47 | } 48 | -------------------------------------------------------------------------------- /proto/enum16.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | // Enum16 represents raw Enum16 value. 4 | // 5 | // Actual values should be taken from DDL. 6 | type Enum16 int16 7 | -------------------------------------------------------------------------------- /proto/enum8.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | // Enum8 represents raw Enum8 value. 4 | // 5 | // Actual values should be taken from DDL. 6 | type Enum8 int8 7 | -------------------------------------------------------------------------------- /proto/error.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "fmt" 4 | 5 | // Error on server side. 6 | type Error int 7 | 8 | func (e Error) Error() string { 9 | if e.IsAError() { 10 | return fmt.Sprintf("%s (%d)", e.String(), e) 11 | } 12 | return fmt.Sprintf("UNKNOWN (%d)", e) 13 | } 14 | 15 | //go:generate go run github.com/dmarkham/enumer -transform snake_upper -type Error -trimprefix Err -output error_enum.go 16 | -------------------------------------------------------------------------------- /proto/error_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/go-faster/errors" 7 | "github.com/stretchr/testify/require" 8 | ) 9 | 10 | func TestError_Error(t *testing.T) { 11 | err := errors.Wrap(ErrNoZookeeper, "failed") 12 | require.Equal(t, err.Error(), "failed: NO_ZOOKEEPER (225)") 13 | require.ErrorIs(t, err, ErrNoZookeeper) 14 | 15 | var codeErr Error 16 | require.ErrorAs(t, err, &codeErr) 17 | require.Equal(t, ErrNoZookeeper, codeErr) 18 | 19 | require.Equal(t, errors.Wrap(Error(-1), "failed").Error(), "failed: UNKNOWN (-1)") 20 | } 21 | -------------------------------------------------------------------------------- /proto/exception.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "github.com/go-faster/errors" 4 | 5 | // Exception is server-side error. 6 | type Exception struct { 7 | Code Error 8 | Name string 9 | Message string 10 | Stack string 11 | Nested bool 12 | } 13 | 14 | // DecodeAware decodes exception. 15 | func (e *Exception) DecodeAware(r *Reader, _ int) error { 16 | code, err := r.Int32() 17 | if err != nil { 18 | return errors.Wrap(err, "code") 19 | } 20 | e.Code = Error(code) 21 | 22 | { 23 | s, err := r.Str() 24 | if err != nil { 25 | return errors.Wrap(err, "name") 26 | } 27 | e.Name = s 28 | } 29 | { 30 | s, err := r.Str() 31 | if err != nil { 32 | return errors.Wrap(err, "message") 33 | } 34 | e.Message = s 35 | } 36 | { 37 | s, err := r.Str() 38 | if err != nil { 39 | return errors.Wrap(err, "stack trace") 40 | } 41 | e.Stack = s 42 | } 43 | nested, err := r.Bool() 44 | if err != nil { 45 | return errors.Wrap(err, "nested") 46 | } 47 | e.Nested = nested 48 | 49 | return nil 50 | } 51 | 52 | // EncodeAware encodes exception. 53 | func (e *Exception) EncodeAware(b *Buffer, _ int) { 54 | b.PutInt32(int32(e.Code)) 55 | b.PutString(e.Name) 56 | b.PutString(e.Message) 57 | b.PutString(e.Stack) 58 | b.PutBool(e.Nested) 59 | } 60 | -------------------------------------------------------------------------------- /proto/gen.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | //go:generate go run ./cmd/ch-gen-col 4 | -------------------------------------------------------------------------------- /proto/gold_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "reflect" 5 | "testing" 6 | 7 | "github.com/ClickHouse/ch-go/internal/gold" 8 | ) 9 | 10 | func typeName(v interface{}) string { 11 | t := reflect.TypeOf(v) 12 | if t.Kind() == reflect.Ptr { 13 | return t.Elem().Name() 14 | } 15 | return t.Name() 16 | } 17 | 18 | // Gold checks golden version of v encoding. 19 | func Gold(t testing.TB, v AwareEncoder, name ...string) { 20 | t.Helper() 21 | if len(name) == 0 { 22 | name = []string{"type", typeName(v)} 23 | } 24 | var b Buffer 25 | v.EncodeAware(&b, Version) 26 | gold.Bytes(t, b.Buf, name...) 27 | } 28 | -------------------------------------------------------------------------------- /proto/int256_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/require" 7 | 8 | "github.com/ClickHouse/ch-go/internal/gold" 9 | ) 10 | 11 | func Test_putUInt256(t *testing.T) { 12 | v := UInt256FromInt(100) 13 | buf := make([]byte, 32) 14 | binPutUInt256(buf, v) 15 | gold.Bytes(t, buf, "uint256_100") 16 | dec := binUInt256(buf) 17 | require.Equal(t, v, dec) 18 | } 19 | 20 | func Benchmark_PutUInt256(b *testing.B) { 21 | buf := make([]byte, 256/8) 22 | var v UInt256 23 | b.ReportAllocs() 24 | b.SetBytes(int64(len(buf))) 25 | 26 | for i := 0; i < b.N; i++ { 27 | binPutUInt256(buf, v) 28 | } 29 | } 30 | 31 | func Benchmark_UInt256(b *testing.B) { 32 | buf := make([]byte, 256/8) 33 | binPutUInt256(buf, UInt256{}) 34 | b.ReportAllocs() 35 | b.SetBytes(int64(len(buf))) 36 | 37 | var v UInt256 38 | for i := 0; i < b.N; i++ { 39 | v = binUInt256(buf) 40 | } 41 | _ = v 42 | } 43 | -------------------------------------------------------------------------------- /proto/ipv4.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "encoding/binary" 5 | "net/netip" 6 | ) 7 | 8 | // IPv4 represents IPv4 address as uint32 number. 9 | // 10 | // Not using netip.Addr because uint32 is 5 times faster, 11 | // consumes 6 times less memory and better represents IPv4. 12 | // 13 | // Use ToIP helper for convenience. 14 | type IPv4 uint32 15 | 16 | func (v IPv4) String() string { 17 | return v.ToIP().String() 18 | } 19 | 20 | // ToIP represents IPv4 as netaddr.IP. 21 | func (v IPv4) ToIP() netip.Addr { 22 | var buf [4]byte 23 | binary.BigEndian.PutUint32(buf[:], uint32(v)) 24 | return netip.AddrFrom4(buf) 25 | } 26 | 27 | // ToIPv4 represents ip as IPv4. Panics if ip is not ipv4. 28 | func ToIPv4(ip netip.Addr) IPv4 { 29 | b := ip.As4() 30 | return IPv4(binary.BigEndian.Uint32(b[:])) 31 | } 32 | -------------------------------------------------------------------------------- /proto/ipv4_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "bytes" 5 | "net/netip" 6 | "testing" 7 | 8 | "github.com/stretchr/testify/require" 9 | 10 | "github.com/ClickHouse/ch-go/internal/gold" 11 | ) 12 | 13 | func TestIPv4_String(t *testing.T) { 14 | for _, v := range []netip.Addr{ 15 | netip.MustParseAddr("127.0.0.1"), 16 | netip.MustParseAddr("1.1.1.1"), 17 | } { 18 | d := ToIPv4(v) 19 | require.Equal(t, v.String(), d.String()) 20 | } 21 | } 22 | 23 | func TestColIPv4_NetAddr(t *testing.T) { 24 | input := []netip.Addr{ 25 | netip.MustParseAddr("127.0.0.1"), 26 | netip.MustParseAddr("127.0.0.2"), 27 | netip.MustParseAddr("127.0.0.3"), 28 | } 29 | var d ColIPv4 30 | for _, v := range input { 31 | d = append(d, ToIPv4(v)) 32 | } 33 | var netBuf Buffer 34 | d.EncodeColumn(&netBuf) 35 | t.Run("Golden", func(t *testing.T) { 36 | gold.Bytes(t, netBuf.Buf, "col_ipv4_netaddr") 37 | }) 38 | t.Run("Decode", func(t *testing.T) { 39 | br := bytes.NewReader(netBuf.Buf) 40 | r := NewReader(br) 41 | 42 | var dec ColIPv4 43 | require.NoError(t, dec.DecodeColumn(r, len(input))) 44 | var output []netip.Addr 45 | for _, v := range dec { 46 | output = append(output, v.ToIP()) 47 | } 48 | require.Equal(t, input, output) 49 | }) 50 | } 51 | -------------------------------------------------------------------------------- /proto/ipv6.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "net/netip" 5 | ) 6 | 7 | // IPv6 represents IPv6 address. 8 | // 9 | // Same as FixedString(16) internally in ClickHouse. 10 | type IPv6 [16]byte 11 | 12 | func (v IPv6) String() string { 13 | return v.ToIP().String() 14 | } 15 | 16 | // ToIP represents IPv6 as netip.IP. 17 | func (v IPv6) ToIP() netip.Addr { 18 | return netip.AddrFrom16(v) 19 | } 20 | 21 | // ToIPv6 represents ip as IPv6. 22 | func ToIPv6(ip netip.Addr) IPv6 { return ip.As16() } 23 | 24 | func binIPv6(b []byte) IPv6 { return *(*[16]byte)(b) } 25 | func binPutIPv6(b []byte, v IPv6) { copy(b, v[:]) } 26 | -------------------------------------------------------------------------------- /proto/profile_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/require" 7 | ) 8 | 9 | func TestProfile_EncodeAware(t *testing.T) { 10 | p := Profile{ 11 | Rows: 1234, 12 | Blocks: 235123, 13 | Bytes: 424, 14 | AppliedLimit: true, 15 | RowsBeforeLimit: 2341, 16 | CalculatedRowsBeforeLimit: false, 17 | } 18 | var b Buffer 19 | p.EncodeAware(&b, Version) 20 | Gold(t, &p) 21 | 22 | t.Run("Decode", func(t *testing.T) { 23 | buf := skipCode(t, b.Buf, int(ServerCodeProfile)) 24 | var dec Profile 25 | requireDecode(t, buf, aware(&dec)) 26 | require.Equal(t, p, dec) 27 | requireNoShortRead(t, buf, aware(&dec)) 28 | }) 29 | } 30 | -------------------------------------------------------------------------------- /proto/progress_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/assert" 7 | 8 | "github.com/ClickHouse/ch-go/internal/gold" 9 | ) 10 | 11 | func TestProgress_EncodeAware(t *testing.T) { 12 | b := new(Buffer) 13 | v := Progress{ 14 | Rows: 100, 15 | Bytes: 608120, 16 | TotalRows: 1000, 17 | WroteRows: 441, 18 | WroteBytes: 91023, 19 | } 20 | v.EncodeAware(b, Version) 21 | gold.Bytes(t, b.Buf, "progress") 22 | 23 | t.Run("DecodeAware", func(t *testing.T) { 24 | var dec Progress 25 | requireDecode(t, b.Buf, aware(&dec)) 26 | assert.Equal(t, v, dec) 27 | requireNoShortRead(t, b.Buf, aware(&dec)) 28 | }) 29 | } 30 | -------------------------------------------------------------------------------- /proto/proto.go: -------------------------------------------------------------------------------- 1 | // Package proto implements ClickHouse wire protocol. 2 | package proto 3 | 4 | // Defaults for ClientHello. 5 | const ( 6 | Version = 54460 7 | Name = "clickhouse/ch-go" 8 | ) 9 | -------------------------------------------------------------------------------- /proto/query_fuzz_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "bytes" 5 | "encoding/hex" 6 | "testing" 7 | 8 | "github.com/stretchr/testify/require" 9 | ) 10 | 11 | func FuzzQuery_DecodeAware(f *testing.F) { 12 | data, err := hex.DecodeString(queryCreateDatabaseHex) 13 | require.NoError(f, err) 14 | 15 | f.Add(data) 16 | f.Fuzz(func(t *testing.T, data []byte) { 17 | var v Query 18 | r := NewReader(bytes.NewReader(data)) 19 | _, _ = r.UVarInt() // skip code 20 | 21 | if err := v.DecodeAware(r, queryProtoVersion); err != nil { 22 | t.Skip() 23 | } 24 | 25 | b := new(Buffer) 26 | v.EncodeAware(b, queryProtoVersion) 27 | 28 | br := NewReader(bytes.NewReader(b.Buf)) 29 | _, _ = br.UVarInt() // skip code 30 | 31 | var dec Query 32 | if err := dec.DecodeAware(br, queryProtoVersion); err != nil { 33 | t.Fatal(err) 34 | } 35 | }) 36 | } 37 | -------------------------------------------------------------------------------- /proto/reader_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/require" 7 | ) 8 | 9 | func TestReader_Int32(t *testing.T) { 10 | var b Buffer 11 | b.PutInt32(1056) 12 | 13 | v, err := b.Reader().Int32() 14 | require.NoError(t, err) 15 | require.Equal(t, int32(1056), v) 16 | } 17 | 18 | func TestReader_Int64(t *testing.T) { 19 | var b Buffer 20 | b.PutInt64(204789) 21 | 22 | v, err := b.Reader().Int64() 23 | require.NoError(t, err) 24 | require.Equal(t, int64(204789), v) 25 | } 26 | 27 | func TestReader_Int(t *testing.T) { 28 | var b Buffer 29 | b.PutInt(529) 30 | 31 | v, err := b.Reader().Int() 32 | require.NoError(t, err) 33 | require.Equal(t, 529, v) 34 | } 35 | -------------------------------------------------------------------------------- /proto/reset.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | type Resettable interface { 4 | Reset() 5 | } 6 | 7 | // Reset is helper to reset columns. 8 | func Reset(columns ...Resettable) { 9 | for _, column := range columns { 10 | column.Reset() 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /proto/slice_unsafe.go: -------------------------------------------------------------------------------- 1 | //go:build (amd64 || arm64 || riscv64) && !purego 2 | 3 | package proto 4 | 5 | import "unsafe" 6 | 7 | // slice represents slice header. 8 | // 9 | // Used in optimizations when we can interpret [N]T as [M]byte, where 10 | // M = sizeof(T) * N. 11 | // 12 | // NB: careful with endianness! 13 | type slice struct { 14 | Data unsafe.Pointer 15 | Len uintptr 16 | Cap uintptr 17 | } 18 | -------------------------------------------------------------------------------- /proto/stage.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | // Stage of query till SELECT should be executed. 4 | type Stage byte 5 | 6 | // Encode to buffer. 7 | func (s Stage) Encode(b *Buffer) { b.PutUVarInt(uint64(s)) } 8 | 9 | //go:generate go run github.com/dmarkham/enumer -type Stage -trimprefix Stage -output stage_enum.go 10 | 11 | // StageComplete is query complete. 12 | const ( 13 | StageFetchColumns Stage = 0 14 | StageWithMergeableState Stage = 1 15 | StageComplete Stage = 2 16 | ) 17 | -------------------------------------------------------------------------------- /proto/table_columns.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import "github.com/go-faster/errors" 4 | 5 | type TableColumns struct { 6 | First string 7 | Second string 8 | } 9 | 10 | func (c *TableColumns) DecodeAware(r *Reader, _ int) error { 11 | { 12 | v, err := r.Str() 13 | if err != nil { 14 | return errors.Wrap(err, "first") 15 | } 16 | c.First = v 17 | } 18 | { 19 | v, err := r.Str() 20 | if err != nil { 21 | return errors.Wrap(err, "second") 22 | } 23 | c.Second = v 24 | } 25 | return nil 26 | } 27 | 28 | func (c TableColumns) EncodeAware(b *Buffer, _ int) { 29 | ServerCodeTableColumns.Encode(b) 30 | b.PutString(c.First) 31 | b.PutString(c.Second) 32 | } 33 | -------------------------------------------------------------------------------- /proto/table_columns_test.go: -------------------------------------------------------------------------------- 1 | package proto 2 | 3 | import ( 4 | "encoding/hex" 5 | "testing" 6 | 7 | "github.com/stretchr/testify/require" 8 | ) 9 | 10 | func TestTableColumns_EncodeAware(t *testing.T) { 11 | v := TableColumns{ 12 | First: "", 13 | Second: "columns format version: 1\n1 columns:\n`id` UInt8\n", 14 | } 15 | var b Buffer 16 | v.EncodeAware(&b, Version) 17 | t.Log(hex.Dump(b.Buf)) 18 | t.Run("Golden", func(t *testing.T) { 19 | Gold(t, v) 20 | }) 21 | t.Run("Decode", func(t *testing.T) { 22 | var dec TableColumns 23 | buf := skipCode(t, b.Buf, int(ServerCodeTableColumns)) 24 | requireDecode(t, buf, aware(&dec)) 25 | require.Equal(t, dec, v) 26 | requireNoShortRead(t, buf, aware(&dec)) 27 | }) 28 | } 29 | -------------------------------------------------------------------------------- /query_metrics.go: -------------------------------------------------------------------------------- 1 | package ch 2 | 3 | import "context" 4 | 5 | type ( 6 | ctxQueryKey struct{} 7 | queryMetrics struct { 8 | ColumnsReceived int 9 | RowsReceived int 10 | BlocksReceived int 11 | BlocksSent int 12 | Rows int 13 | Bytes int 14 | } 15 | ) 16 | 17 | func (c *Client) metricsInc(ctx context.Context, delta queryMetrics) { 18 | if !c.otel { 19 | return 20 | } 21 | v, ok := ctx.Value(ctxQueryKey{}).(*queryMetrics) 22 | if !ok { 23 | return 24 | } 25 | 26 | v.Bytes += delta.Bytes 27 | v.Rows += delta.Rows 28 | v.RowsReceived += delta.RowsReceived 29 | v.BlocksReceived += delta.BlocksReceived 30 | v.BlocksSent += delta.BlocksSent 31 | 32 | if delta.ColumnsReceived > 0 { 33 | v.ColumnsReceived = delta.ColumnsReceived 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /query_params.go: -------------------------------------------------------------------------------- 1 | package ch 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | 7 | "github.com/ClickHouse/ch-go/proto" 8 | ) 9 | 10 | // Parameters is helper for building Query.Parameters. 11 | // 12 | // EXPERIMENTAL. 13 | func Parameters(m map[string]any) []proto.Parameter { 14 | var out []proto.Parameter 15 | for k, v := range m { 16 | out = append(out, proto.Parameter{ 17 | Key: k, 18 | Value: fmt.Sprintf("'%v'", v), 19 | }) 20 | } 21 | // Sorting to make output deterministic. 22 | sort.Slice(out, func(i, j int) bool { 23 | return out[i].Key < out[j].Key 24 | }) 25 | 26 | return out 27 | } 28 | -------------------------------------------------------------------------------- /query_params_test.go: -------------------------------------------------------------------------------- 1 | package ch 2 | 3 | import ( 4 | "context" 5 | "testing" 6 | 7 | "github.com/stretchr/testify/require" 8 | 9 | "github.com/ClickHouse/ch-go/proto" 10 | ) 11 | 12 | func TestQueryParameters(t *testing.T) { 13 | conn := Conn(t) 14 | SkipNoFeature(t, conn, proto.FeatureParameters) 15 | ctx := context.Background() 16 | require.NoError(t, conn.Do(ctx, Query{ 17 | Body: "select {num:UInt8} v, {str:String} s", 18 | Parameters: Parameters(map[string]any{ 19 | "num": 100, 20 | "str": "foo", 21 | }), 22 | Result: discardResult(), 23 | })) 24 | } 25 | -------------------------------------------------------------------------------- /tools.go: -------------------------------------------------------------------------------- 1 | //go:build tools 2 | 3 | package ch 4 | 5 | import ( 6 | _ "github.com/dmarkham/enumer" 7 | ) 8 | --------------------------------------------------------------------------------