click_house 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67e6a326b4ad9972ca7713c935a6b4b1d03da9b3a1e4150119a6bd88cd63481e
-  data.tar.gz: 5face2f1ed1c776b822e023fe862525b94cd3349055ce1a7135a0d184d493196
+  metadata.gz: f271ed936f2d0f66ec2045ec72025e317523dc8d70123c2bcf145ede5b4f1871
+  data.tar.gz: d3e48437b08cbf5eb96315bd46ba88429302bcbebc882d787257c3636c586c8f
 SHA512:
-  metadata.gz: c3f9f7f4962e323684324fd863a487a46440aec742c06e8e406abe88c56f5457795e5b03d1367a206da45b3f912fb237428c1bc9251120e0f28272517d283a5a
-  data.tar.gz: 70795ae32a9e0c555de49034fa19f3863459ea267b3e29aa85ff185f675dfacd15633d8c345f31d90ae2e6e95721187afc700fb40e891a6b5129ecc92ef87f6f
+  metadata.gz: 3bae70c6d33a93ad298db0d14b91beb4bbfe31117cb51e9a58cdeeb95dc48e506363d3e660e6b9e3cd54398df2065210f3b0582e1891bb76e2bdd900520269b3
+  data.tar.gz: cb202cf091808068383a32bb3a2a078aaacc3e051e5c30ecfc47d0bdfab84bb188f0ace4dbc6dbd2950407e5743deeb5f2ffd82c3b31a27ef6fcea01a3fdab1d

data/CHANGELOG.md

@@ -1,3 +1,36 @@
+# 2.1.0
+* `ClickHouse.connection.insert` now returns `ClickHouse::Response::Execution` objects
+  with methods `headers`, `summary`, `written_rows`, `written_bytes`, etc... 
+* `ClickHouse.connection.insert(columns: ["id"], values: [1])` now uses `JSONCompactEachRow` by default
+  (to increase JSON serialization speed)
+* Methods `insert_rows` and `insert_compact` added to `connection`
+* Added ability to pass object directly to insert like:
+  `ClickHouse.connection.insert("table", {id: 1})` or
+  `ClickHouse.connection.insert("table", [{id: 1})]` (for ruby < 3.0 use `ClickHouse.connection.insert("table", [{id: 1}], {})`)
+* 🔥 Added config option `json_serializer` (one of `ClickHouse::Serializer::JsonSerializer`, `ClickHouse::Serializer::JsonOjSerializer`)
+* 🔥 Added config option `symbolize_keys`
+* 🔥 Added type serialization for INSERT statements, example below:
+
+```sql
+CREATE TABLE assets(visible Boolean, tags Array(Nullable(String))) ENGINE Memory
+```
+
+```ruby
+# cache table schema in a class variable
+@schema = ClickHouse.connection.table_schema('assets')
+
+# Json each row
+ClickHouse.connection.insert('assets', @schema.serialize({'visible' => true, 'tags' => ['ruby']}))
+
+# Json compact
+ClickHouse.connection.insert('assets', columns: %w[visible tags]) do |buffer|
+  buffer << [
+    @schema.serialize_column("visible", true),
+    @schema.serialize_column("tags", ['ruby']),
+  ]
+end
+```
+
 # 2.0.0
 * Fixed `Bigdecimal` casting with high precision
 * Added nested `type casting like Array(Array(Array(Nullable(T))))`
@@ -5,6 +38,7 @@
 * Added `Tuple(T1, T2)` support
 * Added support for `Faraday` v1 and v2
 * Added support for `Oj` parser
+* Time types return `Time` class instead of `DateTime` for now
 
 # 1.6.3
 * [PR](https://github.com/shlima/click_house/pull/38) Add option format for insert

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    click_house (2.0.1)
+    click_house (2.1.0)
       activesupport
       faraday (>= 1.7, < 3)
 

data/Gemfile_faraday1

@@ -5,7 +5,7 @@ source 'https://rubygems.org'
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # lock faraday to v1
-gem 'faraday_middleware'
+gem 'faraday', '< 2'
 
 # Specify your gem's dependencies in click_house.gemspec
 gemspec

data/Gemfile_faraday1.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    click_house (1.7.0)
+    click_house (2.1.0)
       activesupport
       faraday (>= 1.7, < 3)
 
@@ -40,8 +40,6 @@ GEM
     faraday-patron (1.0.0)
     faraday-rack (1.0.0)
     faraday-retry (1.0.3)
-    faraday_middleware (1.2.0)
-      faraday (~> 1.0)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
     json (2.6.2)
@@ -94,12 +92,13 @@ GEM
     unicode-display_width (2.3.0)
 
 PLATFORMS
+  ruby
   x86_64-darwin-21
 
 DEPENDENCIES
   bundler
   click_house!
-  faraday_middleware
+  faraday (< 2)
   oj
   pry
   rake

data/Gemfile_faraday2.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    click_house (1.7.0)
+    click_house (2.1.0)
       activesupport
       faraday (>= 1.7, < 3)
 

data/README.md

@@ -52,6 +52,8 @@ ClickHouse.config do |config|
   config.timeout = 60
   config.open_timeout = 3
   config.ssl_verify = false
+  # set to true to symbolize keys for SELECT and INSERT statements (type casting)
+  config.symbolize_keys = false
   config.headers = {}
 
   # or provide connection options separately
@@ -66,10 +68,15 @@ ClickHouse.config do |config|
   # if you want to add settings to all queries
   config.global_params = { mutations_sync: 1 }
   
-  # choose a ruby JSON parser
+  # choose a ruby JSON parser (default one)
   config.json_parser = ClickHouse::Middleware::ParseJson
   # or Oj parser
   config.json_parser = ClickHouse::Middleware::ParseJsonOj
+
+  # JSON.dump (default one)
+  config.json_serializer = ClickHouse::Serializer::JsonSerializer
+  # or Oj.dump
+  config.json_serializer = ClickHouse::Serializer::JsonOjSerializer
 end
 ```
 
@@ -195,7 +202,8 @@ response.body #=> "\u0002\u0000\u0000\u0000\u0000\u0000\u0000\u0000"
 
 ## Insert
 
-When column names and values are transferred separately
+When column names and values are transferred separately, data sends to the server 
+using `JSONCompactEachRow` format by default.
 
 ```ruby
 ClickHouse.connection.insert('table', columns: %i[id name]) do |buffer|
@@ -203,23 +211,42 @@ ClickHouse.connection.insert('table', columns: %i[id name]) do |buffer|
   buffer << [2, 'Venus']
 end
 
+# or
 ClickHouse.connection.insert('table', columns: %i[id name], values: [[1, 'Mercury'], [2, 'Venus']])
-#=> true
 ```
 
-When rows are passed as a hash
-
+When rows are passed as an Array or a Hash, data sends to the server
+using `JSONEachRow` format by default.
 
 ```ruby
-ClickHouse.connection.insert('table', values: [{ name: 'Sun', id: 1 }, { name: 'Moon', id: 2 }])
+ClickHouse.connection.insert('table', [{ name: 'Sun', id: 1 }, { name: 'Moon', id: 2 }])
+
+# or
+ClickHouse.connection.insert('table', { name: 'Sun', id: 1 })
+
+# for ruby < 3.0 provide an extra argument
+ClickHouse.connection.insert('table', { name: 'Sun', id: 1 }, {})
 
+# or
 ClickHouse.connection.insert('table') do |buffer|
   buffer << { name: 'Sun', id: 1 }
   buffer << { name: 'Moon', id: 2 }
 end
-#=> true
 ```
 
+Sometimes it's needed to use other format than `JSONEachRow` For example if you want to send BigDecimal's 
+you could use `JSONStringsEachRow` format so string representation of `BigDecimal` will be parsed:
+
+```ruby
+ClickHouse.connection.insert('table', { name: 'Sun', id: '1' }, format: 'JSONStringsEachRow')
+# or
+ClickHouse.connection.insert_rows('table', { name: 'Sun', id: '1' }, format: 'JSONStringsEachRow')
+# or
+ClickHouse.connection.insert_compact('table', columns: %w[name id], values: %w[Sun 1], format: 'JSONCompactStringsEachRow')
+```
+
+See the [type casting](#type-casting) section to insert the data in a proper way.
+
 ## Create a table
 ### Create table using DSL
 
@@ -326,42 +353,35 @@ end
 ## Type casting
 
 By default gem provides all necessary type casting, but you may overwrite or define
-your own logic
+your own logic. if you need to redefine all built-in types with your implementation,
+just clear the default type system:
 
 ```ruby
-class DateType
-  def cast(value)
-    Date.parse(value)
-  end
-
-  def serialize(value)
-    value.strftime('%Y-%m-%d')
-  end
-end
-
-ClickHouse.add_type('Date', DateType.new)
+ClickHouse.types.clear
+ClickHouse.types # => {}
+ClickHouse.types.default #=> #<ClickHouse::Type::UndefinedType>
 ```
 
-If native type supports arguments, define *String* type with `%s`
-argument and *Numeric* type with `%d` argument:
+Type casting works automatically when fetching data, when inserting data, you must serialize the types yourself
 
-```ruby
-class DateTimeType
-  def cast(value, time_zone)
-    Time.parse("#{value} #{time_zone}")
-  end
-end
-
-ClickHouse.add_type('DateTime(%s)', DateTimeType.new)
+```sql
+CREATE TABLE assets(visible Boolean, tags Array(Nullable(String))) ENGINE Memory
 ```
 
-if you need to redefine all built-in types with your implementation,
-just clear the default type system:
-
 ```ruby
-ClickHouse.types.clear
-ClickHouse.types # => {}
-ClickHouse.types.default #=> #<ClickHouse::Type::UndefinedType:0x00007fc1cfabd630>
+# cache table schema in a class variable
+@schema = ClickHouse.connection.table_schema('assets')
+
+# Json each row
+ClickHouse.connection.insert('assets', @schema.serialize({'visible' => true, 'tags' => ['ruby']}))
+
+# Json compact
+ClickHouse.connection.insert('assets', columns: %w[visible tags]) do |buffer|
+  buffer << [
+    @schema.serialize_column("visible", true),
+    @schema.serialize_column("tags", ['ruby']),
+  ]
+end
 ```
 
 ## Using with a connection pool

data/lib/click_house/benchmark/map_join.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'stringio'
+
+INPUT = Array.new(5_000_000, 'foo bar')
+
+Benchmark.bm do |x|
+  x.report('map.join') do
+    INPUT.map(&:to_s).join("\n")
+  end
+
+  x.report('StringIO') do
+    out = StringIO.new
+    INPUT.each do |value|
+      out << "#{value}\n"
+    end
+    out.string
+  end
+end

data/lib/click_house/config.rb

@@ -18,18 +18,21 @@ module ClickHouse
       headers: {},
       global_params: {},
       json_parser: ClickHouse::Middleware::ParseJson,
+      json_serializer: ClickHouse::Serializer::JsonSerializer,
+      oj_dump_options: {
+        mode: :compat # to be able to dump improper JSON like {1 => 2}
+      },
       oj_load_options: {
         mode: :custom,
         allow_blank: true,
         bigdecimal_as_decimal: false, # dump BigDecimal as a String
         bigdecimal_load: :bigdecimal, # convert all decimal numbers to BigDecimal
-        empty_string: false,
-        second_precision: 6,
-        time_format: :ruby,
       },
       json_load_options: {
         decimal_class: BigDecimal,
       },
+      # should be after json load options
+      symbolize_keys: false,
     }.freeze
 
     attr_accessor :adapter
@@ -49,6 +52,9 @@ module ClickHouse
     attr_accessor :oj_load_options
     attr_accessor :json_load_options
     attr_accessor :json_parser # response middleware
+    attr_accessor :oj_dump_options
+    attr_accessor :json_serializer # [ClickHouse::Serializer::Base]
+    attr_accessor :symbolize_keys # [NilClass, Boolean]
 
     def initialize(params = {})
       assign(DEFAULTS.merge(params))
@@ -77,5 +83,25 @@ module ClickHouse
     def null_logger
       @null_logger ||= Logger.new(IO::NULL)
     end
+
+    # @param klass [ClickHouse::Serializer::Base]
+    def json_serializer=(klass)
+      @json_serializer = klass.new(self)
+    end
+
+    def symbolize_keys=(value)
+      bool = value ? true : false
+
+      # merge to be able to clone a config
+      # prevent overriding default values
+      self.oj_load_options = oj_load_options.merge(symbol_keys: bool)
+      self.json_load_options = json_load_options.merge(symbolize_names: bool)
+      @symbolize_keys = bool
+    end
+
+    # @param name [Symbol, String]
+    def key(name)
+      symbolize_keys ? name.to_sym : name.to_s
+    end
   end
 end

data/lib/click_house/connection.rb

@@ -47,13 +47,22 @@ module ClickHouse
     end
 
     # transport should work the same both with Faraday v1 and Faraday v2
+    # rubocop:disable Metrics/AbcSize
     def transport
       @transport ||= Faraday.new(config.url!) do |conn|
         conn.options.timeout = config.timeout
         conn.options.open_timeout = config.open_timeout
         conn.headers = config.headers
         conn.ssl.verify = config.ssl_verify
-        conn.request(:basic_auth, config.username, config.password) if config.auth?
+
+        if config.auth?
+          if faraday_v1?
+            conn.request :basic_auth, config.username, config.password
+          else
+            conn.request :authorization, :basic, config.username, config.password
+          end
+        end
+
         conn.response Middleware::RaiseError
         conn.response Middleware::Logging, logger: config.logger!
         conn.response config.json_parser, content_type: %r{application/json}, parser_options: { config: config }
@@ -61,10 +70,16 @@ module ClickHouse
         conn.adapter config.adapter
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     def compose(path, query = {})
       # without <query.compact> "DB::Exception: Empty query" error will occur
       "#{path}?#{URI.encode_www_form({ send_progress_in_http_headers: 1 }.merge(query).compact)}"
     end
+
+    # @return [Boolean]
+    def faraday_v1?
+      Faraday::VERSION.start_with?('1')
+    end
   end
 end

data/lib/click_house/errors.rb

@@ -5,4 +5,5 @@ module ClickHouse
   NetworkException = Class.new(Error)
   DbException = Class.new(Error)
   StatementException = Class.new(Error)
+  SerializeError = Class.new(Error)
 end

data/lib/click_house/extend/connection_inserting.rb

@@ -3,7 +3,8 @@
 module ClickHouse
   module Extend
     module ConnectionInserting
-      EMPTY_INSERT = true
+      DEFAULT_JSON_EACH_ROW_FORMAT = 'JSONEachRow'
+      DEFAULT_JSON_COMPACT_EACH_ROW_FORMAT = 'JSONCompactEachRow'
 
       # @return [Boolean]
       #
@@ -13,20 +14,71 @@ module ClickHouse
       #   buffer << ['Moon', 2]
       # end
       #
-      # == Example with a param
-      # subject.insert('rspec', values: [{ name: 'Sun', id: 1 }, { name: 'Moon', id: 2 }], format: 'JSONStringsEachRow')
-      def insert(table, columns: [], values: [], format: 'JSONEachRow')
-        yield(values) if block_given?
+      # @return [Response::Execution]
+      # @param body [Array, Hash]
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      def insert(table, body = [], **opts)
+        # In Ruby < 3.0, if the last argument is a hash, and the method being called
+        # accepts keyword arguments, then it is always converted to keyword arguments.
+        columns = opts.fetch(:columns, [])
+        values =  opts.fetch(:values, [])
+        format = opts.fetch(:format, nil)
+
+        yield(body) if block_given?
 
-        body = if columns.empty?
-          values.map(&:to_json)
+        # values: [{id: 1}]
+        if values.any? && columns.empty?
+          return insert_rows(table, values, format: format)
+        end
+
+        # body: [{id: 1}]
+        if body.any? && columns.empty?
+          return insert_rows(table, body, format: format)
+        end
+
+        # body: [1], columns: ["id"]
+        if body.any? && columns.any?
+          return insert_compact(table, columns: columns, values: body, format: format)
+        end
+
+        # columns: ["id"], values: [[1]]
+        if columns.any? && values.any?
+          return insert_compact(table, columns: columns, values: values, format: format)
+        end
+
+        Response::Factory.empty_exec
+      end
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+      # @param table [String]
+      # @param body [Array, Hash]
+      # @param format [String]
+      # @return [Response::Execution]
+      #
+      # Sometimes it's needed to use other format than JSONEachRow
+      # For example if you want to send BigDecimal's you could use
+      # JSONStringsEachRow format so string representation of BigDecimal will be parsed
+      def insert_rows(table, body, format: nil)
+        format ||= DEFAULT_JSON_EACH_ROW_FORMAT
+
+        case body
+        when Hash
+          Response::Factory.exec(execute("INSERT INTO #{table} FORMAT #{format}", config.json_serializer.dump(body)))
+        when Array
+          Response::Factory.exec(execute("INSERT INTO #{table} FORMAT #{format}", config.json_serializer.dump_each_row(body)))
         else
-          values.map { |value_row| columns.zip(value_row).to_h.to_json }
+          raise ArgumentError, "unknown body class <#{body.class}>"
         end
+      end
 
-        return EMPTY_INSERT if values.empty?
+      # @return [Response::Execution]
+      def insert_compact(table, columns: [], values: [], format: nil)
+        format ||= DEFAULT_JSON_COMPACT_EACH_ROW_FORMAT
+
+        yield(values) if block_given?
 
-        execute("INSERT INTO #{table} FORMAT #{format}", body.join("\n")).success?
+        response = execute("INSERT INTO #{table} (#{columns.join(',')}) FORMAT #{format}", config.json_serializer.dump_each_row(values))
+        Response::Factory.exec(response)
       end
     end
   end

data/lib/click_house/extend/connection_selective.rb

@@ -6,17 +6,17 @@ module ClickHouse
       # @return [ResultSet]
       def select_all(sql)
         response = get(body: sql, query: { default_format: 'JSON' })
-        Response::Factory[response]
+        Response::Factory.response(response, config)
       end
 
       def select_value(sql)
         response = get(body: sql, query: { default_format: 'JSON' })
-        Array(Response::Factory[response].first).dig(0, -1)
+        Array(Response::Factory.response(response, config).first).dig(0, -1)
       end
 
       def select_one(sql)
         response = get(body: sql, query: { default_format: 'JSON' })
-        Response::Factory[response].first
+        Response::Factory.response(response, config).first
       end
     end
   end

data/lib/click_house/extend/connection_table.rb

@@ -10,7 +10,12 @@ module ClickHouse
 
       # @return [ResultSet]
       def describe_table(name)
-        Response::Factory[execute("DESCRIBE TABLE #{name} FORMAT JSON")]
+        Response::Factory.response(execute("DESCRIBE TABLE #{name} FORMAT JSON"), config)
+      end
+
+      # @return [ResultSet]
+      def table_schema(name)
+        Response::Factory.response(execute("SELECT * FROM #{name} WHERE 1=0 FORMAT JSON"), config)
       end
 
       # @return [Boolean]

data/lib/click_house/response/execution.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module Response
+    class Execution
+      SUMMARY_HEADER = 'x-clickhouse-summary'
+
+      attr_reader :headers, :summary
+
+      # @param headers [Faraday::Utils::Headers]
+      def initialize(headers: Faraday::Utils::Headers.new)
+        @headers = headers
+        @summary = parse_summary(headers[SUMMARY_HEADER])
+      end
+
+      # @return [Integer]
+      def read_rows
+        summary['read_rows'].to_i
+      end
+
+      # @return [Integer]
+      def read_bytes
+        summary['read_bytes'].to_i
+      end
+
+      # @return [Integer]
+      def written_rows
+        summary['written_rows'].to_i
+      end
+
+      # @return [Integer]
+      def written_bytes
+        summary['written_bytes'].to_i
+      end
+
+      # @return [Integer]
+      def total_rows_to_read
+        summary['total_rows_to_read'].to_i
+      end
+
+      # @return [Integer]
+      def result_rows
+        summary['result_rows'].to_i
+      end
+
+      # @return [Integer]
+      def result_bytes
+        summary['result_bytes'].to_i
+      end
+
+      private
+
+      # @return [Hash]
+      # {
+      #   "read_rows" => "1",
+      #   "read_bytes" => "23",
+      #   "written_rows" => "1",
+      #   "written_bytes" => "23",
+      #   "total_rows_to_read" => "0",
+      #   "result_rows" => "1",
+      #   "result_bytes" => "23",
+      # }
+      def parse_summary(value)
+        return {} if value.nil? || value.empty?
+
+        JSON.parse(value)
+      end
+    end
+  end
+end

data/lib/click_house/response/factory.rb

@@ -3,21 +3,41 @@
 module ClickHouse
   module Response
     class Factory
-      # @return [String, ResultSet]
-      # @params env [Faraday::Response]
-      def self.[](faraday)
+      KEY_META = 'meta'
+      KEY_DATA = 'data'
+      KEY_TOTALS = 'totals'
+      KEY_STATISTICS = 'statistics'
+      KEY_ROWS_BEFORE_LIMIT_AT_LEAST = 'rows_before_limit_at_least'
+
+      # @return [Nil], ResultSet]
+      # @params faraday [Faraday::Response]
+      # @params config [Config]
+      def self.response(faraday, config)
         body = faraday.body
 
-        return body if !body.is_a?(Hash) || !(body.key?('meta') && body.key?('data'))
+        return body unless body.is_a?(Hash)
+        return body unless body.key?(config.key(KEY_META)) && body.key?(config.key(KEY_DATA))
 
         ResultSet.new(
-          meta: body.fetch('meta'),
-          data: body.fetch('data'),
-          totals: body['totals'],
-          statistics: body['statistics'],
-          rows_before_limit_at_least: body['rows_before_limit_at_least']
+          config: config,
+          meta: body.fetch(config.key(KEY_META)),
+          data: body.fetch(config.key(KEY_DATA)),
+          totals: body[config.key(KEY_TOTALS)],
+          statistics: body[config.key(KEY_STATISTICS)],
+          rows_before_limit_at_least: body[config.key(KEY_ROWS_BEFORE_LIMIT_AT_LEAST)]
         )
       end
+
+      # @return [Response::Execution]
+      # @params faraday [Faraday::Response]
+      def self.exec(faraday)
+        Execution.new(headers: faraday.headers)
+      end
+
+      # @return [Response::Execution]
+      def self.empty_exec
+        Execution.new
+      end
     end
   end
 end

data/lib/click_house/response/result_set.rb

@@ -6,27 +6,63 @@ module ClickHouse
       extend Forwardable
       include Enumerable
 
-      PLACEHOLDER_D = '%d'
-      PLACEHOLDER_S = '%s'
+      KEY_META_NAME = 'name'
+      KEY_META_TYPE = 'type'
 
       def_delegators :to_a,
                      :inspect, :each, :fetch, :length, :count, :size,
                      :first, :last, :[], :to_h
 
-      attr_reader :meta, :data, :totals, :statistics, :rows_before_limit_at_least
+      attr_reader :config, :meta, :data, :totals, :statistics, :rows_before_limit_at_least
 
+      # @param config [Config]
       # @param meta [Array]
       # @param data [Array]
       # @param totals [Array|Hash|NilClass] Support for 'GROUP BY WITH TOTALS' modifier
       #   https://clickhouse.tech/docs/en/sql-reference/statements/select/group-by/#with-totals-modifier
       #   Hash in JSON format and Array in JSONCompact
-      def initialize(meta:, data:, totals: nil, statistics: nil, rows_before_limit_at_least: nil)
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(config:, meta:, data:, totals: nil, statistics: nil, rows_before_limit_at_least: nil)
+        @config = config
         @meta = meta
         @data = data
         @totals = totals
         @rows_before_limit_at_least = rows_before_limit_at_least
         @statistics = Hash(statistics)
       end
+      # rubocop:enable Metrics/ParameterLists
+
+      # @return [Array, Hash]
+      # @param data [Array, Hash]
+      def serialize(data)
+        case data
+        when Hash
+          serialize_one(data)
+        when Array
+          data.map(&method(:serialize_one))
+        else
+          raise ArgumentError, "expect Hash or Array, got: #{data.class}"
+        end
+      end
+
+      # @return [Hash]
+      # @param row [Hash]
+      def serialize_one(row)
+        row.each_with_object({}) do |(key, value), object|
+          object[key] = serialize_column(key, value)
+        end
+      end
+
+      # @param name [String] column name
+      # @param value [Any]
+      def serialize_column(name, value)
+        stmt = types.fetch(name)
+        serialize_type(stmt, value)
+      rescue KeyError => e
+        raise SerializeError, "field <#{name}> does not exists in table schema: #{types}", e.backtrace
+      rescue StandardError => e
+        raise SerializeError, "failed to serialize <#{name}> with #{stmt}, #{e.class}, #{e.message}", e.backtrace
+      end
 
       def to_a
         @to_a ||= data.each do |row|
@@ -39,8 +75,11 @@ module ClickHouse
       # @return [Hash<String, Ast::Statement>]
       def types
         @types ||= meta.each_with_object({}) do |row, object|
-          object[row.fetch('name')] = begin
-            current = Ast::Parser.new(row.fetch('type')).parse
+          column = row.fetch(config.key(KEY_META_NAME))
+          # make symbol keys, if config.symbolize_keys is true,
+          # to be able to cast and serialize properly
+          object[config.key(column)] = begin
+            current = Ast::Parser.new(row.fetch(config.key(KEY_META_TYPE))).parse
             assign_type(current)
             current
           end
@@ -96,6 +135,42 @@ module ClickHouse
           cast_type(stmt.arguments.fetch(ix), item)
         end
       end
+
+      # @param stmt [Ast::Statement]
+      def serialize_type(stmt, value)
+        return serialize_container(stmt, value) if stmt.caster.container?
+        return serialize_map(stmt, value) if stmt.caster.map?
+        return serialize_tuple(stmt, Array(value)) if stmt.caster.tuple?
+
+        stmt.caster.serialize(value, *stmt.arguments.map(&:value))
+      end
+
+      # @param stmt [Ast::Statement]
+      def serialize_container(stmt, value)
+        stmt.caster.cast_each(value) do |item|
+          # TODO: raise an error if multiple arguments
+          serialize_type(stmt.arguments.first, item)
+        end
+      end
+
+      # @return [Hash]
+      # @param stmt [Ast::Statement]
+      # @param hash [Hash]
+      def serialize_map(stmt, hash)
+        raise ArgumentError, "expect hash got #{hash.class}" unless hash.is_a?(Hash)
+
+        key_type, value_type = stmt.arguments
+        hash.each_with_object({}) do |(key, value), object|
+          object[serialize_type(key_type, key)] = serialize_type(value_type, value)
+        end
+      end
+
+      # @param stmt [Ast::Statement]
+      def serialize_tuple(stmt, value)
+        value.map.with_index do |item, ix|
+          serialize_type(stmt.arguments.fetch(ix), item)
+        end
+      end
     end
   end
 end

data/lib/click_house/response.rb

@@ -4,6 +4,6 @@ module ClickHouse
   module Response
     autoload :Factory, 'click_house/response/factory'
     autoload :ResultSet, 'click_house/response/result_set'
-    autoload :Tokenize, 'click_house/response/tokenize'
+    autoload :Execution, 'click_house/response/execution'
   end
 end

data/lib/click_house/serializer/base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module Serializer
+    class Base
+      attr_reader :config
+
+      # @param config [Config]
+      def initialize(config)
+        @config = config
+        on_setup
+      end
+
+      def dump(data)
+        raise NotImplementedError, __method__
+      end
+
+      # @return [String]
+      # @param data [Array]
+      def dump_each_row(data, sep = "\n")
+        data.map(&method(:dump)).join(sep)
+      end
+
+      private
+
+      # require external dependencies here
+      def on_setup
+        nil
+      end
+    end
+  end
+end

data/lib/click_house/serializer/json_oj_serializer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module Serializer
+    class JsonOjSerializer < Base
+      def dump(data)
+        Oj.dump(data, config.oj_dump_options)
+      end
+
+      private
+
+      def on_setup
+        require 'oj' unless defined?(Oj)
+      end
+    end
+  end
+end

data/lib/click_house/serializer/json_serializer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module Serializer
+    class JsonSerializer < Base
+      def dump(data)
+        JSON.dump(data)
+      end
+    end
+  end
+end

data/lib/click_house/serializer.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ClickHouse
+  module Serializer
+    autoload :Base, 'click_house/serializer/base'
+    autoload :JsonSerializer, 'click_house/serializer/json_serializer'
+    autoload :JsonOjSerializer, 'click_house/serializer/json_oj_serializer'
+  end
+end

data/lib/click_house/type/array_type.rb

@@ -7,6 +7,10 @@ module ClickHouse
         value.map(&block)
       end
 
+      def serialize_each(value, *_argv, &block)
+        value.map(&block)
+      end
+
       def container?
         true
       end

data/lib/click_house/type/base_type.rb

@@ -11,6 +11,10 @@ module ClickHouse
         raise NotImplementedError, __method__
       end
 
+      def serialize_each(_value, *)
+        raise NotImplementedError, __method__
+      end
+
       # @return [Boolean]
       # true if type contains another type like Nullable(T) or Array(T)
       def container?

data/lib/click_house/type/boolean_type.rb

@@ -7,7 +7,12 @@ module ClickHouse
       FALSE_VALUE = 0
 
       def cast(value)
-        value.to_i == TRUE_VALUE
+        case value
+        when TrueClass, FalseClass
+          value
+        else
+          value.to_i == TRUE_VALUE
+        end
       end
 
       def serialize(value)

data/lib/click_house/type/date_time64_type.rb

@@ -11,7 +11,7 @@ module ClickHouse
         end
       end
 
-      def serialize(value, precision = 3)
+      def serialize(value, precision = 3, _tz = nil)
         value.strftime("%Y-%m-%d %H:%M:%S.%#{precision}N")
       end
     end

data/lib/click_house/type/date_time_type.rb

@@ -11,7 +11,7 @@ module ClickHouse
         end
       end
 
-      def serialize(value)
+      def serialize(value, *)
         value.strftime('%Y-%m-%d %H:%M:%S')
       end
     end

data/lib/click_house/type/decimal_type.rb

@@ -3,14 +3,14 @@
 module ClickHouse
   module Type
     class DecimalType < BaseType
-      MAXIMUM = Float::DIG
+      MAXIMUM = Float::DIG.next
 
       # clickhouse:
       # P - precision. Valid range: [ 1 : 76 ]. Determines how many decimal digits number can have (including fraction).
       # S - scale. Valid range: [ 0 : P ]. Determines how many decimal digits fraction can have.
       #
       # when Oj parser @refs https://stackoverflow.com/questions/47885304/deserialise-json-numbers-as-bigdecimal
-      def cast(value, precision = Float::DIG, _scale = nil)
+      def cast(value, precision = MAXIMUM, _scale = nil)
         case value
         when BigDecimal
           value
@@ -21,8 +21,9 @@ module ClickHouse
         end
       end
 
-      def serialize(value, precision = Float::DIG, _scale = nil)
-        BigDecimal(value, precision.to_i).to_f unless value.nil?
+      # @return [BigDecimal]
+      def serialize(value, precision = MAXIMUM, _scale = nil)
+        cast(value, precision)
       end
     end
   end

data/lib/click_house/type/string_type.rb

@@ -7,7 +7,7 @@ module ClickHouse
         value.to_s unless value.nil?
       end
 
-      def serialize(value)
+      def serialize(value, *)
         value.to_s unless value.nil?
       end
     end

data/lib/click_house/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClickHouse
-  VERSION = '2.0.1'
+  VERSION = '2.1.0'
 end

data/lib/click_house.rb

@@ -12,6 +12,7 @@ require 'active_support/core_ext/time/calculations'
 require 'click_house/version'
 require 'click_house/errors'
 require 'click_house/response'
+require 'click_house/serializer'
 require 'click_house/type'
 require 'click_house/middleware'
 require 'click_house/extend'
@@ -33,6 +34,10 @@ module ClickHouse
   add_type 'LowCardinality', Type::LowCardinalityType.new
   add_type 'Tuple', Type::TupleType.new
 
+  %w[Bool].each do |column|
+    add_type column, Type::BooleanType.new
+  end
+
   %w[Date].each do |column|
     add_type column, Type::DateType.new
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: click_house
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Aliaksandr Shylau
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-19 00:00:00.000000000 Z
+date: 2022-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -175,6 +175,7 @@ files:
 - lib/click_house/ast/parser.rb
 - lib/click_house/ast/statement.rb
 - lib/click_house/ast/ticker.rb
+- lib/click_house/benchmark/map_join.rb
 - lib/click_house/config.rb
 - lib/click_house/connection.rb
 - lib/click_house/definition.rb
@@ -200,8 +201,13 @@ files:
 - lib/click_house/middleware/raise_error.rb
 - lib/click_house/middleware/response_base.rb
 - lib/click_house/response.rb
+- lib/click_house/response/execution.rb
 - lib/click_house/response/factory.rb
 - lib/click_house/response/result_set.rb
+- lib/click_house/serializer.rb
+- lib/click_house/serializer/base.rb
+- lib/click_house/serializer/json_oj_serializer.rb
+- lib/click_house/serializer/json_serializer.rb
 - lib/click_house/type.rb
 - lib/click_house/type/array_type.rb
 - lib/click_house/type/base_type.rb