clickhouse-native 0.1.1-x86_64-linux-gnu

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa18bb35a5161587c5743d27cb4d17fd8c25f7ad5865938deeaa51179c0518b8
+  data.tar.gz: 2efe20b98476212884665ad681872e3af5558f8d8b6e2a366f4e846b39b0ea17
+SHA512:
+  metadata.gz: b8e8f67bcfd88a96dff2896ec16540069c3a2bc560a65e62db30319b5706834ee98a39ff946856280fcc6fb37c3316408f0bcce1c7ecab39dab1e58c3026d649
+  data.tar.gz: 598d753e3ef3d70496c0f105525d8f8b7ae3e7ad57b2a17aad0dc5d4eec8fecb7b2bdf6dbeb8af7ae1168d10f038fd88554cee68c056d8036a47b4d597822e4d

data/lib/clickhouse_native/client.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ClickhouseNative
+  class Client
+    attr_reader :host, :port, :database
+
+    def describe_table(table, db_name: nil)
+      fq = db_name ? "#{db_name}.#{table}" : table
+      query("DESCRIBE TABLE #{fq}")
+    end
+
+    # insert(table, rows, columns: nil, db_name: nil, types: nil)
+    #
+    # rows may be Array<Hash{Symbol|String => Object}> or Array<Array>.
+    # columns defaults to the first hash's keys (for Array<Hash>) or all table
+    # columns in DDL order (for Array<Array>).
+    # types may be supplied to skip the DESCRIBE lookup.
+    #
+    # Hash keys not present in the schema raise ArgumentError — if you need
+    # to insert a subset, pass `columns:` explicitly.
+    def insert(table, rows, columns: nil, db_name: nil, types: nil)
+      return 0 if rows.empty?
+
+      fq = db_name ? "#{db_name}.#{table}" : table
+      col_pairs =
+        if types && columns
+          zip_columns_and_types(columns, types)
+        else
+          columns_from_schema(table, rows, columns, db_name, fq)
+        end
+      row_arrays = rows.first.is_a?(Hash) ? hash_rows_to_arrays(rows, col_pairs) : rows
+
+      insert_block(fq, col_pairs, row_arrays)
+    end
+
+    def inspect
+      "#<#{self.class} #{host}:#{port}/#{database}>"
+    end
+
+    private
+
+    def zip_columns_and_types(columns, types)
+      if columns.size != types.size
+        raise ArgumentError, "types and columns must have the same length"
+      end
+      columns.zip(types).map { |n, t| [n.to_s, t] }
+    end
+
+    def columns_from_schema(table, rows, columns, db_name, fqn)
+      schema = describe_table(table, db_name: db_name)
+      type_by_name = schema.to_h { |c| [c[:name], c[:type]] }
+      columns ||= rows.first.is_a?(Hash) ? rows.first.keys.map(&:to_s) : schema.map { |c| c[:name] }
+      columns.map do |name|
+        name_s = name.to_s
+        t = type_by_name[name_s] or
+          raise ArgumentError, "unknown column #{name_s.inspect} in #{fqn}"
+        [name_s, t]
+      end
+    end
+
+    def hash_rows_to_arrays(rows, col_pairs)
+      lookup = col_pairs.map { |n, _| [n.to_sym, n] }
+      rows.map { |h| lookup.map { |sym, str| h.fetch(sym) { h[str] } } }
+    end
+  end
+end

data/lib/clickhouse_native/errors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ClickhouseNative
+  class Error < StandardError; end
+
+  class ConnectionError < Error; end
+  class TimeoutError < ConnectionError; end
+
+  class ProtocolError < Error; end
+
+  class ServerError < Error
+    attr_reader :server_code, :server_name, :server_stacktrace
+
+    def initialize(message, code: nil, name: nil, stacktrace: nil)
+      super(message)
+      @server_code = code
+      @server_name = name
+      @server_stacktrace = stacktrace
+    end
+  end
+
+  class EncoderError < Error; end
+  class DecoderError < Error; end
+  class UnsupportedTypeError < DecoderError; end
+end

data/lib/clickhouse_native/logging.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ClickhouseNative
+  # Sequel-style logging wrapper. Prepended onto Client so it fires for the
+  # raw C-level execute/query/query_value/query_each/insert_block calls.
+  #
+  #   client = Client.new(..., logger: Rails.logger)
+  #   client.query("SELECT 1")
+  #   # => DEBUG  -- : (0.421ms) SELECT 1
+  #
+  # Errors are logged at ERROR with the elapsed time and exception class.
+  module Logging
+    LEVEL = :debug
+
+    def execute(sql)
+      log_sql(sql) { super }
+    end
+
+    def query(sql)
+      log_sql(sql) { super }
+    end
+
+    def query_value(sql)
+      log_sql(sql) { super }
+    end
+
+    def query_each(sql, &)
+      log_sql(sql) { super }
+    end
+
+    def insert_block(table, columns, rows)
+      col_list = columns.map(&:first).join(", ")
+      log_sql("INSERT INTO #{table} (#{col_list}) VALUES (#{rows.size} rows)") { super }
+    end
+
+    private
+
+    def log_sql(sql)
+      return yield unless @logger
+
+      t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      begin
+        result = yield
+        elapsed_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000
+        @logger.public_send(LEVEL, format("(%<ms>.3fms) %<sql>s", ms: elapsed_ms, sql: sql))
+        result
+      rescue => error
+        elapsed_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000
+        first_line = error.message.to_s.lines.first.to_s.strip
+        @logger.error(format(
+                        "(%<ms>.3fms) %<class>s: %<msg>s -- %<sql>s",
+                        ms: elapsed_ms, class: error.class, msg: first_line, sql: sql,
+                      ))
+        raise
+      end
+    end
+  end
+
+  class Client
+    attr_accessor :logger
+
+    prepend Logging
+  end
+end

data/lib/clickhouse_native/pool.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "connection_pool"
+
+module ClickhouseNative
+  class Pool
+    def initialize(host:, port:, database: "default", user: "default", password: "",
+                   compression: :none, logger: nil, pool_size: 5, pool_timeout: 5)
+      client_kwargs = { host:, port:, database:, user:, password:, compression:, logger: }
+      @pool = ConnectionPool.new(size: pool_size, timeout: pool_timeout) do
+        Client.new(**client_kwargs)
+      end
+    end
+
+    def with(&)
+      @pool.with(&)
+    end
+
+    def execute(sql)
+      @pool.with { |c| c.execute(sql) }
+    end
+
+    def query(sql)
+      @pool.with { |c| c.query(sql) }
+    end
+
+    def query_each(sql, &block)
+      @pool.with { |c| c.query_each(sql, &block) }
+    end
+
+    def query_value(sql)
+      @pool.with { |c| c.query_value(sql) }
+    end
+
+    def insert(table, rows, **opts)
+      @pool.with { |c| c.insert(table, rows, **opts) }
+    end
+
+    def ping
+      @pool.with(&:ping)
+    end
+
+    def server_version
+      @pool.with(&:server_version)
+    end
+
+    def describe_table(table, db_name: nil)
+      @pool.with { |c| c.describe_table(table, db_name:) }
+    end
+  end
+end

data/lib/clickhouse_native/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ClickhouseNative
+  VERSION = "0.1.1"
+end

data/lib/clickhouse_native.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "time"
+require "bigdecimal"
+require "clickhouse_native/version"
+require "clickhouse_native/errors"
+require "clickhouse_native/clickhouse_native"
+require "clickhouse_native/client"
+require "clickhouse_native/logging"
+require "clickhouse_native/pool"
+
+module ClickhouseNative
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: clickhouse-native
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: x86_64-linux-gnu
+authors:
+- Yuri Smirnov
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: A high-performance Ruby client for ClickHouse using the native binary
+  protocol via a C++ extension wrapping clickhouse-cpp.
+email:
+- tycoooon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/clickhouse_native.rb
+- lib/clickhouse_native/3.3/clickhouse_native.so
+- lib/clickhouse_native/3.4/clickhouse_native.so
+- lib/clickhouse_native/4.0/clickhouse_native.so
+- lib/clickhouse_native/client.rb
+- lib/clickhouse_native/errors.rb
+- lib/clickhouse_native/logging.rb
+- lib/clickhouse_native/pool.rb
+- lib/clickhouse_native/version.rb
+licenses:
+- Apache-2.0
+metadata:
+  precompiled: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: ClickHouse Ruby driver over the native TCP protocol
+test_files: []