clickhouse-ruby 0.1.0 → 0.2.0

data/lib/clickhouse_ruby/connection.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'uri'
-require 'openssl'
+require "net/http"
+require "uri"
+require "openssl"
+require "zlib"
 
 module ClickhouseRuby
   # Single HTTP connection wrapper for ClickHouse communication
@@ -31,6 +32,44 @@ module ClickhouseRuby
   #   )
   #
   class Connection
+    # Error mapping for network issues to ClickhouseRuby exceptions
+    # Each entry maps an exception class to a lambda that creates the appropriate error
+    NETWORK_ERROR_MAPPING = {
+      OpenSSL::SSL::SSLError => lambda { |e, _conn|
+        SSLError.new("SSL connection failed: #{e.message}", original_error: e)
+      },
+      Errno::ECONNREFUSED => lambda { |e, conn|
+        ConnectionNotEstablished.new("Connection refused to #{conn.host}:#{conn.port}: #{e.message}", original_error: e)
+      },
+      Errno::EHOSTUNREACH => lambda { |e, conn|
+        ConnectionNotEstablished.new("Host unreachable #{conn.host}:#{conn.port}: #{e.message}", original_error: e)
+      },
+      SocketError => lambda { |e, conn|
+        ConnectionNotEstablished.new("Socket error to #{conn.host}:#{conn.port}: #{e.message}", original_error: e)
+      },
+      Net::OpenTimeout => lambda { |e, conn|
+        ConnectionTimeout.new("Connection timeout to #{conn.host}:#{conn.port}", original_error: e)
+      },
+      Net::ReadTimeout => lambda { |e, _conn|
+        ConnectionTimeout.new("Read timeout: #{e.message}", original_error: e)
+      },
+      Net::WriteTimeout => lambda { |e, _conn|
+        ConnectionTimeout.new("Write timeout: #{e.message}", original_error: e)
+      },
+      Errno::ECONNRESET => lambda { |e, _conn|
+        ConnectionError.new("Connection reset: #{e.message}", original_error: e)
+      },
+      Errno::EPIPE => lambda { |e, _conn|
+        ConnectionError.new("Broken pipe: #{e.message}", original_error: e)
+      },
+      IOError => lambda { |e, _conn|
+        ConnectionError.new("IO error: #{e.message}", original_error: e)
+      },
+    }.freeze
+
+    # All exception classes that should be caught and mapped
+    NETWORK_ERRORS = NETWORK_ERROR_MAPPING.keys.freeze
+
     # @return [String] the ClickHouse host
     attr_reader :host
 
@@ -66,10 +105,12 @@ module ClickhouseRuby
     # @param connect_timeout [Integer] connection timeout in seconds
     # @param read_timeout [Integer] read timeout in seconds
     # @param write_timeout [Integer] write timeout in seconds
+    # @param compression [String, nil] compression algorithm ('gzip' or nil)
+    # @param compression_threshold [Integer] minimum body size to compress
     def initialize(
       host:,
       port: 8123,
-      database: 'default',
+      database: "default",
       username: nil,
       password: nil,
       use_ssl: false,
@@ -77,7 +118,9 @@ module ClickhouseRuby
       ssl_ca_path: nil,
       connect_timeout: 10,
       read_timeout: 60,
-      write_timeout: 60
+      write_timeout: 60,
+      compression: nil,
+      compression_threshold: 1024
     )
       @host = host
       @port = port
@@ -90,6 +133,8 @@ module ClickhouseRuby
       @connect_timeout = connect_timeout
       @read_timeout = read_timeout
       @write_timeout = write_timeout
+      @compression = compression
+      @compression_threshold = compression_threshold
 
       @http = nil
       @connected = false
@@ -106,29 +151,11 @@ module ClickhouseRuby
       @mutex.synchronize do
         return self if @connected && @http&.started?
 
-        begin
+        with_error_handling do
           @http = build_http
           @http.start
           @connected = true
           @last_used_at = Time.now
-        rescue OpenSSL::SSL::SSLError => e
-          @connected = false
-          raise SSLError.new(
-            "SSL connection failed: #{e.message}",
-            original_error: e
-          )
-        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError => e
-          @connected = false
-          raise ConnectionNotEstablished.new(
-            "Failed to connect to #{@host}:#{@port}: #{e.message}",
-            original_error: e
-          )
-        rescue Net::OpenTimeout => e
-          @connected = false
-          raise ConnectionTimeout.new(
-            "Connection timeout to #{@host}:#{@port}",
-            original_error: e
-          )
         end
       end
 
@@ -141,7 +168,11 @@ module ClickhouseRuby
     def disconnect
       @mutex.synchronize do
         if @http&.started?
-          @http.finish rescue nil
+          begin
+            @http.finish
+          rescue StandardError
+            nil
+          end
         end
         @http = nil
         @connected = false
@@ -170,22 +201,26 @@ module ClickhouseRuby
       ensure_connected
 
       request = Net::HTTP::Post.new(path)
-      request.body = body
 
       # Set default headers
-      request['Content-Type'] = 'application/x-www-form-urlencoded'
-      request['Accept'] = 'application/json'
-      request['User-Agent'] = "ClickhouseRuby/#{ClickhouseRuby::VERSION} Ruby/#{RUBY_VERSION}"
+      request["Content-Type"] = "application/x-www-form-urlencoded"
+      request["Accept"] = "application/json"
+      request["User-Agent"] = "ClickhouseRuby/#{ClickhouseRuby::VERSION} Ruby/#{RUBY_VERSION}"
+
+      # Add compression headers if enabled
+      request["Accept-Encoding"] = "gzip" if @compression == "gzip"
 
       # Add authentication
-      if @username
-        request.basic_auth(@username, @password || '')
-      end
+      request.basic_auth(@username, @password || "") if @username
 
       # Merge custom headers
       headers.each { |k, v| request[k] = v }
 
-      execute_request(request)
+      # Handle request body compression
+      setup_body(request, body)
+
+      response = execute_request(request)
+      decompress_response(response)
     end
 
     # Executes an HTTP GET request
@@ -197,12 +232,10 @@ module ClickhouseRuby
       ensure_connected
 
       request = Net::HTTP::Get.new(path)
-      request['Accept'] = 'application/json'
-      request['User-Agent'] = "ClickhouseRuby/#{ClickhouseRuby::VERSION} Ruby/#{RUBY_VERSION}"
+      request["Accept"] = "application/json"
+      request["User-Agent"] = "ClickhouseRuby/#{ClickhouseRuby::VERSION} Ruby/#{RUBY_VERSION}"
 
-      if @username
-        request.basic_auth(@username, @password || '')
-      end
+      request.basic_auth(@username, @password || "") if @username
 
       headers.each { |k, v| request[k] = v }
 
@@ -215,8 +248,8 @@ module ClickhouseRuby
     def ping
       connect unless connected?
 
-      response = get('/ping')
-      response.code == '200' && response.body&.strip == 'Ok.'
+      response = get("/ping")
+      response.code == "200" && response.body&.strip == "Ok."
     rescue StandardError
       false
     end
@@ -242,8 +275,8 @@ module ClickhouseRuby
     #
     # @return [String]
     def inspect
-      scheme = @use_ssl ? 'https' : 'http'
-      status = @connected ? 'connected' : 'disconnected'
+      scheme = @use_ssl ? "https" : "http"
+      status = @connected ? "connected" : "disconnected"
       "#<#{self.class.name} #{scheme}://#{@host}:#{@port} #{status}>"
     end
 
@@ -272,6 +305,7 @@ module ClickhouseRuby
         else
           # Only disable if explicitly requested (development only!)
           http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          warn "[ClickhouseRuby] WARNING: SSL verification disabled. Insecure for production."
         end
 
         # Use modern TLS versions
@@ -288,9 +322,9 @@ module ClickhouseRuby
     #
     # @raise [ConnectionNotEstablished] if not connected
     def ensure_connected
-      unless @connected && @http&.started?
-        connect
-      end
+      return if @connected && @http&.started?
+
+      connect
     end
 
     # Executes an HTTP request with error handling
@@ -299,28 +333,110 @@ module ClickhouseRuby
     # @return [Net::HTTPResponse]
     def execute_request(request)
       @mutex.synchronize do
-        begin
+        with_error_handling do
           response = @http.request(request)
           @last_used_at = Time.now
           response
-        rescue Net::ReadTimeout => e
-          @connected = false
-          raise ConnectionTimeout.new(
-            "Read timeout: #{e.message}",
-            original_error: e
-          )
-        rescue Net::WriteTimeout => e
-          @connected = false
-          raise ConnectionTimeout.new(
-            "Write timeout: #{e.message}",
-            original_error: e
-          )
-        rescue Errno::ECONNRESET, Errno::EPIPE, IOError => e
-          @connected = false
-          raise ConnectionError.new(
-            "Connection lost: #{e.message}",
-            original_error: e
-          )
+        end
+      end
+    end
+
+    # Executes a block with network error handling
+    #
+    # Maps network exceptions to ClickhouseRuby exceptions and marks
+    # connection as disconnected on error.
+    #
+    # @yield the block to execute
+    # @return the block's return value
+    # @raise [ConnectionError, ConnectionTimeout, ConnectionNotEstablished, SSLError]
+    def with_error_handling
+      yield
+    rescue *NETWORK_ERRORS => e
+      @connected = false
+      handler = NETWORK_ERROR_MAPPING[e.class] || find_handler_for(e)
+      raise handler.call(e, self) if handler
+      raise e  # Re-raise if no handler found (shouldn't happen, but be safe)
+    end
+
+    # Finds error handler by checking exception class and its ancestors
+    #
+    # @param exception [Exception] the exception to find a handler for
+    # @return [Proc, nil] the handler lambda or nil if not found
+    private def find_handler_for(exception)
+      exception.class.ancestors.each do |ancestor_class|
+        return NETWORK_ERROR_MAPPING[ancestor_class] if NETWORK_ERROR_MAPPING.key?(ancestor_class)
+      end
+      nil
+    end
+
+    # Sets up request body with optional compression
+    #
+    # @param request [Net::HTTPRequest] the request object
+    # @param body [String, nil] the request body
+    # @return [void]
+    def setup_body(request, body)
+      return unless body
+
+      if should_compress?(body)
+        request["Content-Encoding"] = "gzip"
+        request["Content-Type"] = "application/octet-stream"
+        request.body = Zlib.gzip(body, level: Zlib::DEFAULT_COMPRESSION)
+      else
+        request.body = body
+      end
+    end
+
+    # Determines if body should be compressed
+    #
+    # @param body [String] the request body
+    # @return [Boolean] true if compression is enabled and body exceeds threshold
+    def should_compress?(body)
+      @compression == "gzip" && body.bytesize > @compression_threshold
+    end
+
+    # Decompresses response if needed
+    #
+    # @param response [Net::HTTPResponse] the HTTP response
+    # @return [Net::HTTPResponse] the response (possibly wrapped with decompression)
+    def decompress_response(response)
+      return response unless response["Content-Encoding"] == "gzip"
+
+      DecompressedResponse.new(response)
+    end
+
+    # Wrapper for automatically decompressing gzip responses
+    class DecompressedResponse
+      # @param response [Net::HTTPResponse] the original HTTP response
+      def initialize(response)
+        @response = response
+        @decompressed_body = nil
+      end
+
+      # Returns the HTTP status code
+      #
+      # @return [String] status code
+      def code
+        @response.code
+      end
+
+      # Returns a header value
+      #
+      # @param header [String] header name
+      # @return [String, nil] header value
+      def [](header)
+        @response[header]
+      end
+
+      # Returns the decompressed response body
+      #
+      # @return [String] decompressed body
+      def body
+        @decompressed_body ||= begin
+          return @response.body if @response.body.nil? || @response.body.empty?
+
+          Zlib.gunzip(@response.body)
+        rescue Zlib::Error
+          @response.body
         end
       end
     end

data/lib/clickhouse_ruby/connection_pool.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'thread'
-require 'timeout'
+require "timeout"
 
 module ClickhouseRuby
   # Thread-safe connection pool for managing multiple ClickHouse connections
@@ -46,7 +45,7 @@ module ClickhouseRuby
       @connection_options = config.to_connection_options
 
       # Pool state
-      @available = []           # Connections available for checkout
+      @available = [] # Connections available for checkout
       @in_use = []             # Connections currently checked out
       @all_connections = []    # All connections ever created
 
@@ -110,10 +109,8 @@ module ClickhouseRuby
           remaining = deadline - Time.now
           if remaining <= 0
             @total_timeouts += 1
-            raise PoolTimeout.new(
-              "Could not obtain a connection from the pool within #{@timeout} seconds " \
-              "(pool size: #{@size}, in use: #{@in_use.size})"
-            )
+            raise PoolTimeout, "Could not obtain a connection from the pool within #{@timeout} seconds " \
+                               "(pool size: #{@size}, in use: #{@in_use.size})"
           end
 
           @condition.wait(@mutex, remaining)
@@ -136,7 +133,7 @@ module ClickhouseRuby
           @available << connection
         else
           # Disconnect unhealthy connections
-          connection.disconnect rescue nil
+          safe_disconnect(connection)
           @all_connections.delete(connection)
         end
 
@@ -182,7 +179,7 @@ module ClickhouseRuby
     def shutdown
       @mutex.synchronize do
         (@available + @in_use).each do |conn|
-          conn.disconnect rescue nil
+          safe_disconnect(conn)
         end
 
         @available.clear
@@ -201,7 +198,7 @@ module ClickhouseRuby
       @mutex.synchronize do
         @available.reject! do |conn|
           if conn.stale?(max_idle_seconds) || !conn.healthy?
-            conn.disconnect rescue nil
+            safe_disconnect(conn)
             @all_connections.delete(conn)
             removed += 1
             true
@@ -236,7 +233,7 @@ module ClickhouseRuby
           total: @all_connections.size,
           capacity: @size,
           healthy: healthy,
-          unhealthy: unhealthy
+          unhealthy: unhealthy,
         }
       end
     end
@@ -253,7 +250,7 @@ module ClickhouseRuby
           total_connections: @all_connections.size,
           total_checkouts: @total_checkouts,
           total_timeouts: @total_timeouts,
-          uptime_seconds: Time.now - @created_at
+          uptime_seconds: Time.now - @created_at,
         }
       end
     end
@@ -275,18 +272,27 @@ module ClickhouseRuby
     def get_available_connection
       while (conn = @available.pop)
         # Verify the connection is still healthy
-        if conn.healthy? && !conn.stale?
-          return conn
-        else
-          # Remove unhealthy connections
-          conn.disconnect rescue nil
-          @all_connections.delete(conn)
-        end
+        return conn if conn.healthy? && !conn.stale?
+
+        # Remove unhealthy connections
+        safe_disconnect(conn)
+        @all_connections.delete(conn)
+
       end
 
       nil
     end
 
+    # Safely disconnects a connection, logging any errors
+    #
+    # @param connection [Connection] the connection to disconnect
+    # @return [void]
+    def safe_disconnect(connection)
+      connection.disconnect
+    rescue StandardError => e
+      @config.logger&.warn("[ClickhouseRuby] Disconnect error: #{e.class} - #{e.message}")
+    end
+
     # Creates a new connection
     #
     # @return [Connection] the new connection

data/lib/clickhouse_ruby/errors.rb

@@ -62,7 +62,7 @@ module ClickhouseRuby
       parts << "Code: #{code}" if code
       parts << "HTTP Status: #{http_status}" if http_status
       parts << "SQL: #{sql}" if sql
-      parts.join(' | ')
+      parts.join(" | ")
     end
   end
 
@@ -140,5 +140,17 @@ module ClickhouseRuby
     def error_class_for_code(code)
       ERROR_CODE_MAPPING.fetch(code, QueryError)
     end
+
+    # Sanitizes a message to prevent credential leakage
+    #
+    # @param message [String] the message to sanitize
+    # @param config [Configuration, nil] the configuration containing credentials
+    # @return [String] the sanitized message
+    def sanitize_message(message, config)
+      return message unless config.respond_to?(:password) && config&.password
+      return message if config.password.to_s.empty?
+
+      message.gsub(config.password.to_s, "[REDACTED]")
+    end
   end
 end

data/lib/clickhouse_ruby/result.rb

@@ -57,16 +57,12 @@ module ClickhouseRuby
     def initialize(columns:, types:, data:, statistics: {}, deserialize: true)
       @columns = columns.freeze
       @types = types.freeze
-      @elapsed_time = statistics['elapsed']
-      @rows_read = statistics['rows_read']
-      @bytes_read = statistics['bytes_read']
+      @elapsed_time = statistics["elapsed"]
+      @rows_read = statistics["rows_read"]
+      @bytes_read = statistics["bytes_read"]
 
       # Build type instances for deserialization
-      @type_instances = if deserialize
-                          types.map { |t| Types.lookup(t) }
-                        else
-                          nil
-                        end
+      @type_instances = (types.map { |t| Types.lookup(t) } if deserialize)
 
       # Convert raw data to row hashes
       @rows = build_rows(data).freeze
@@ -88,6 +84,7 @@ module ClickhouseRuby
     end
     alias size count
     alias length count
+    alias data rows
 
     # Returns whether there are no rows
     #
@@ -149,11 +146,11 @@ module ClickhouseRuby
     # @param response_data [Hash] parsed JSON response
     # @return [Result] the result
     def self.from_json_compact(response_data)
-      meta = response_data['meta'] || []
-      columns = meta.map { |m| m['name'] }
-      types = meta.map { |m| m['type'] }
-      data = response_data['data'] || []
-      statistics = response_data['statistics'] || {}
+      meta = response_data["meta"] || []
+      columns = meta.map { |m| m["name"] }
+      types = meta.map { |m| m["type"] }
+      data = response_data["data"] || []
+      statistics = response_data["statistics"] || {}
 
       new(columns: columns, types: types, data: data, statistics: statistics)
     end
@@ -177,9 +174,7 @@ module ClickhouseRuby
         @columns.each_with_index do |col, i|
           value = row_values[i]
           # Deserialize if we have type instances
-          if @type_instances
-            value = @type_instances[i].deserialize(value)
-          end
+          value = @type_instances[i].deserialize(value) if @type_instances
           row[col] = value
         end
         row