clickhouse-ruby 0.1.0 → 0.2.0

data/lib/clickhouse_ruby/active_record/connection_adapter.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-require 'active_record/connection_adapters/abstract_adapter'
-require_relative 'arel_visitor'
-require_relative 'schema_statements'
+require "active_record/connection_adapters/abstract_adapter"
+require_relative "arel_visitor"
+require_relative "schema_statements"
+require_relative "relation_extensions"
 
 module ClickhouseRuby
   module ActiveRecord
@@ -39,28 +40,28 @@ module ClickhouseRuby
     #   Event.where(status: 'old').delete_all  # Raises on error!
     #
     class ConnectionAdapter < ::ActiveRecord::ConnectionAdapters::AbstractAdapter
-      ADAPTER_NAME = 'Clickhouse'
+      ADAPTER_NAME = "Clickhouse"
 
       include SchemaStatements
 
       # Native database types mapping for ClickHouse
       # Used by migrations and schema definitions
       NATIVE_DATABASE_TYPES = {
-        primary_key: 'UInt64',
-        string: { name: 'String' },
-        text: { name: 'String' },
-        integer: { name: 'Int32' },
-        bigint: { name: 'Int64' },
-        float: { name: 'Float32' },
-        decimal: { name: 'Decimal', precision: 10, scale: 0 },
-        datetime: { name: 'DateTime' },
-        timestamp: { name: 'DateTime64', precision: 3 },
-        time: { name: 'DateTime' },
-        date: { name: 'Date' },
-        binary: { name: 'String' },
-        boolean: { name: 'UInt8' },
-        uuid: { name: 'UUID' },
-        json: { name: 'String' }
+        primary_key: "UInt64",
+        string: { name: "String" },
+        text: { name: "String" },
+        integer: { name: "Int32" },
+        bigint: { name: "Int64" },
+        float: { name: "Float32" },
+        decimal: { name: "Decimal", precision: 10, scale: 0 },
+        datetime: { name: "DateTime" },
+        timestamp: { name: "DateTime64", precision: 3 },
+        time: { name: "DateTime" },
+        date: { name: "Date" },
+        binary: { name: "String" },
+        boolean: { name: "UInt8" },
+        uuid: { name: "UUID" },
+        json: { name: "String" },
       }.freeze
 
       class << self
@@ -73,9 +74,9 @@ module ClickhouseRuby
         # @param config [Hash] database configuration
         # @return [ConnectionAdapter] the adapter instance
         def new_client(config)
-          chruby_config = build_chruby_config(config)
-          chruby_config.validate!
-          ClickhouseRuby::Client.new(chruby_config)
+          clickhouse_config = build_clickhouse_config(config)
+          clickhouse_config.validate!
+          ClickhouseRuby::Client.new(clickhouse_config)
         end
 
         private
@@ -84,11 +85,11 @@ module ClickhouseRuby
         #
         # @param config [Hash] database configuration hash
         # @return [ClickhouseRuby::Configuration] configured client
-        def build_chruby_config(config)
+        def build_clickhouse_config(config)
           ClickhouseRuby::Configuration.new.tap do |c|
-            c.host = config[:host] || 'localhost'
+            c.host = config[:host] || "localhost"
             c.port = config[:port]&.to_i || 8123
-            c.database = config[:database] || 'default'
+            c.database = config[:database] || "default"
             c.username = config[:username]
             c.password = config[:password]
             c.ssl = config[:ssl]
@@ -110,12 +111,15 @@ module ClickhouseRuby
       # @param logger [Logger] Rails logger
       # @param connection_options [Array] connection options
       # @param config [Hash] database configuration
-      def initialize(connection, logger = nil, connection_options = nil, config = {})
+      def initialize(connection, logger = nil, _connection_options = nil, config = {})
         @config = config.symbolize_keys
-        @chruby_client = nil
+        @clickhouse_client = nil
         @connection_parameters = nil
 
         super(connection, logger, config)
+
+        # Extend ActiveRecord::Relation with our methods
+        ::ActiveRecord::Relation.include(RelationExtensions)
       end
 
       # Returns the adapter name
@@ -140,10 +144,10 @@ module ClickhouseRuby
       #
       # @return [Boolean] true if connected and responding
       def active?
-        return false unless @chruby_client
+        return false unless @clickhouse_client
 
         # Ping ClickHouse to verify connection
-        execute_internal('SELECT 1')
+        execute_internal("SELECT 1")
         true
       rescue ClickhouseRuby::Error
         false
@@ -153,7 +157,7 @@ module ClickhouseRuby
       #
       # @return [Boolean] true if we have a client instance
       def connected?
-        !@chruby_client.nil?
+        !@clickhouse_client.nil?
       end
 
       # Disconnect from the database
@@ -161,8 +165,8 @@ module ClickhouseRuby
       # @return [void]
       def disconnect!
         super
-        @chruby_client&.close if @chruby_client.respond_to?(:close)
-        @chruby_client = nil
+        @clickhouse_client&.close if @clickhouse_client.respond_to?(:close)
+        @clickhouse_client = nil
       end
 
       # Reconnect to the database
@@ -185,7 +189,7 @@ module ClickhouseRuby
       #
       # @return [void]
       def connect
-        @chruby_client = self.class.new_client(@config)
+        @clickhouse_client = self.class.new_client(@config)
       end
 
       # ========================================
@@ -322,7 +326,7 @@ module ClickhouseRuby
         raise ClickhouseRuby::QueryError.new(
           "Query execution failed: #{e.message}",
           sql: sql,
-          original_error: e
+          original_error: e,
         )
       end
 
@@ -337,7 +341,7 @@ module ClickhouseRuby
       # @param binds [Array] bind values
       # @return [Object] the id value
       # @raise [ClickhouseRuby::QueryError] on ClickHouse errors
-      def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+      def exec_insert(sql, name = nil, _binds = [], _pk = nil, _sequence_name = nil)
         execute(sql, name)
         # ClickHouse doesn't return inserted IDs
         # Return nil as we can't get the last insert ID
@@ -355,7 +359,7 @@ module ClickhouseRuby
       # @param binds [Array] bind values
       # @return [Integer] number of affected rows (estimated, ClickHouse doesn't return exact count)
       # @raise [ClickhouseRuby::QueryError] on ClickHouse errors - NEVER silently fails
-      def exec_delete(sql, name = nil, binds = [])
+      def exec_delete(sql, name = nil, _binds = [])
         ensure_connected!
 
         # The Arel visitor should have already converted this to
@@ -363,7 +367,7 @@ module ClickhouseRuby
         # But if it's standard DELETE, convert it here
         clickhouse_sql = convert_delete_to_alter(sql)
 
-        log(clickhouse_sql, name || 'DELETE') do
+        log(clickhouse_sql, name || "DELETE") do
           result = execute_internal(clickhouse_sql)
           # CRITICAL: Raise on any error
           raise_if_error!(result)
@@ -379,7 +383,7 @@ module ClickhouseRuby
         raise ClickhouseRuby::QueryError.new(
           "DELETE failed: #{e.message}",
           sql: sql,
-          original_error: e
+          original_error: e,
         )
       end
 
@@ -394,14 +398,14 @@ module ClickhouseRuby
       # @param binds [Array] bind values
       # @return [Integer] number of affected rows (estimated)
       # @raise [ClickhouseRuby::QueryError] on ClickHouse errors
-      def exec_update(sql, name = nil, binds = [])
+      def exec_update(sql, name = nil, _binds = [])
         ensure_connected!
 
         # The Arel visitor should have already converted this to
         # ALTER TABLE ... UPDATE ... WHERE syntax
         clickhouse_sql = convert_update_to_alter(sql)
 
-        log(clickhouse_sql, name || 'UPDATE') do
+        log(clickhouse_sql, name || "UPDATE") do
           result = execute_internal(clickhouse_sql)
           raise_if_error!(result)
 
@@ -414,7 +418,7 @@ module ClickhouseRuby
         raise ClickhouseRuby::QueryError.new(
           "UPDATE failed: #{e.message}",
           sql: sql,
-          original_error: e
+          original_error: e,
         )
       end
 
@@ -425,7 +429,7 @@ module ClickhouseRuby
       # @param binds [Array] bind values
       # @param prepare [Boolean] whether to prepare (ignored, ClickHouse doesn't support)
       # @return [ClickhouseRuby::Result] query result
-      def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+      def exec_query(sql, name = "SQL", _binds = [], prepare: false)
         execute(sql, name)
       end
 
@@ -456,7 +460,7 @@ module ClickhouseRuby
       def exec_rollback_db_transaction
         # No-op: ClickHouse doesn't support transactions
         # Log a warning since rollback was requested but cannot be performed
-        @logger&.warn('ClickHouse does not support transaction rollback')
+        @logger&.warn("ClickHouse does not support transaction rollback")
       end
 
       # ========================================
@@ -469,7 +473,7 @@ module ClickhouseRuby
       # @param name [String, Symbol] the column name
       # @return [String] the quoted column name
       def quote_column_name(name)
-        "`#{name.to_s.gsub('`', '``')}`"
+        "`#{name.to_s.gsub("`", "``")}`"
       end
 
       # Quote a table name for ClickHouse
@@ -477,7 +481,7 @@ module ClickhouseRuby
       # @param name [String, Symbol] the table name
       # @return [String] the quoted table name
       def quote_table_name(name)
-        "`#{name.to_s.gsub('`', '``')}`"
+        "`#{name.to_s.gsub("`", "``")}`"
       end
 
       # Quote a string value for ClickHouse
@@ -509,58 +513,58 @@ module ClickhouseRuby
       # @return [void]
       def initialize_type_map(m = type_map)
         # Register standard types
-        register_class_with_limit m, %r{^String}i, ::ActiveRecord::Type::String
-        register_class_with_limit m, %r{^FixedString}i, ::ActiveRecord::Type::String
+        register_class_with_limit m, /^String/i, ::ActiveRecord::Type::String
+        register_class_with_limit m, /^FixedString/i, ::ActiveRecord::Type::String
 
         # Integer types
-        m.register_type %r{^Int8}i, ::ActiveRecord::Type::Integer.new(limit: 1)
-        m.register_type %r{^Int16}i, ::ActiveRecord::Type::Integer.new(limit: 2)
-        m.register_type %r{^Int32}i, ::ActiveRecord::Type::Integer.new(limit: 4)
-        m.register_type %r{^Int64}i, ::ActiveRecord::Type::Integer.new(limit: 8)
-        m.register_type %r{^UInt8}i, ::ActiveRecord::Type::Integer.new(limit: 1)
-        m.register_type %r{^UInt16}i, ::ActiveRecord::Type::Integer.new(limit: 2)
-        m.register_type %r{^UInt32}i, ::ActiveRecord::Type::Integer.new(limit: 4)
-        m.register_type %r{^UInt64}i, ::ActiveRecord::Type::Integer.new(limit: 8)
+        m.register_type(/^Int8/i, ::ActiveRecord::Type::Integer.new(limit: 1))
+        m.register_type(/^Int16/i, ::ActiveRecord::Type::Integer.new(limit: 2))
+        m.register_type(/^Int32/i, ::ActiveRecord::Type::Integer.new(limit: 4))
+        m.register_type(/^Int64/i, ::ActiveRecord::Type::Integer.new(limit: 8))
+        m.register_type(/^UInt8/i, ::ActiveRecord::Type::Integer.new(limit: 1))
+        m.register_type(/^UInt16/i, ::ActiveRecord::Type::Integer.new(limit: 2))
+        m.register_type(/^UInt32/i, ::ActiveRecord::Type::Integer.new(limit: 4))
+        m.register_type(/^UInt64/i, ::ActiveRecord::Type::Integer.new(limit: 8))
 
         # Float types
-        m.register_type %r{^Float32}i, ::ActiveRecord::Type::Float.new
-        m.register_type %r{^Float64}i, ::ActiveRecord::Type::Float.new
+        m.register_type(/^Float32/i, ::ActiveRecord::Type::Float.new)
+        m.register_type(/^Float64/i, ::ActiveRecord::Type::Float.new)
 
         # Decimal types
-        m.register_type %r{^Decimal}i, ::ActiveRecord::Type::Decimal.new
+        m.register_type(/^Decimal/i, ::ActiveRecord::Type::Decimal.new)
 
         # Date/Time types
-        m.register_type %r{^Date$}i, ::ActiveRecord::Type::Date.new
-        m.register_type %r{^DateTime}i, ::ActiveRecord::Type::DateTime.new
-        m.register_type %r{^DateTime64}i, ::ActiveRecord::Type::DateTime.new
+        m.register_type(/^Date$/i, ::ActiveRecord::Type::Date.new)
+        m.register_type(/^DateTime/i, ::ActiveRecord::Type::DateTime.new)
+        m.register_type(/^DateTime64/i, ::ActiveRecord::Type::DateTime.new)
 
         # Boolean (UInt8 with 0/1)
-        m.register_type %r{^Bool}i, ::ActiveRecord::Type::Boolean.new
+        m.register_type(/^Bool/i, ::ActiveRecord::Type::Boolean.new)
 
         # UUID
-        m.register_type %r{^UUID}i, ::ActiveRecord::Type::String.new
+        m.register_type(/^UUID/i, ::ActiveRecord::Type::String.new)
 
         # Nullable wrapper - extract inner type
-        m.register_type %r{^Nullable\((.+)\)}i do |sql_type|
-          inner_type = sql_type.match(%r{^Nullable\((.+)\)}i)[1]
+        m.register_type(/^Nullable\((.+)\)/i) do |sql_type|
+          inner_type = sql_type.match(/^Nullable\((.+)\)/i)[1]
           lookup_cast_type(inner_type)
         end
 
         # Array types
-        m.register_type %r{^Array\(}i, ::ActiveRecord::Type::String.new
+        m.register_type(/^Array\(/i, ::ActiveRecord::Type::String.new)
 
         # Map types
-        m.register_type %r{^Map\(}i, ::ActiveRecord::Type::String.new
+        m.register_type(/^Map\(/i, ::ActiveRecord::Type::String.new)
 
         # Tuple types
-        m.register_type %r{^Tuple\(}i, ::ActiveRecord::Type::String.new
+        m.register_type(/^Tuple\(/i, ::ActiveRecord::Type::String.new)
 
         # Enum types (treated as strings)
-        m.register_type %r{^Enum}i, ::ActiveRecord::Type::String.new
+        m.register_type(/^Enum/i, ::ActiveRecord::Type::String.new)
 
         # LowCardinality wrapper
-        m.register_type %r{^LowCardinality\((.+)\)}i do |sql_type|
-          inner_type = sql_type.match(%r{^LowCardinality\((.+)\)}i)[1]
+        m.register_type(/^LowCardinality\((.+)\)/i) do |sql_type|
+          inner_type = sql_type.match(/^LowCardinality\((.+)\)/i)[1]
           lookup_cast_type(inner_type)
         end
       end
@@ -573,10 +577,10 @@ module ClickhouseRuby
       def ensure_connected!
         connect unless connected?
 
-        unless @chruby_client
-          raise ClickhouseRuby::ConnectionNotEstablished,
-                'No connection to ClickHouse. Call connect first.'
-        end
+        return if @clickhouse_client
+
+        raise ClickhouseRuby::ConnectionNotEstablished,
+              "No connection to ClickHouse. Call connect first."
       end
 
       # Execute SQL through the ClickhouseRuby client
@@ -584,7 +588,7 @@ module ClickhouseRuby
       # @param sql [String] the SQL to execute
       # @return [ClickhouseRuby::Result] the result
       def execute_internal(sql)
-        @chruby_client.execute(sql)
+        @clickhouse_client.execute(sql)
       end
 
       # Check if result contains an error and raise it
@@ -598,7 +602,7 @@ module ClickhouseRuby
         raise ClickhouseRuby::QueryError.new(
           result.error_message,
           code: result.error_code,
-          http_status: result.http_status
+          http_status: result.http_status,
         )
       end
 
@@ -610,22 +614,21 @@ module ClickhouseRuby
       def raise_query_error(error, sql)
         if error.is_a?(ClickhouseRuby::QueryError)
           # Re-raise with SQL if not already set
-          if error.sql.nil?
-            raise ClickhouseRuby::QueryError.new(
-              error.message,
-              code: error.code,
-              http_status: error.http_status,
-              sql: sql,
-              original_error: error.original_error
-            )
-          else
-            raise error
-          end
+          raise error unless error.sql.nil?
+
+          raise ClickhouseRuby::QueryError.new(
+            error.message,
+            code: error.code,
+            http_status: error.http_status,
+            sql: sql,
+            original_error: error.original_error,
+          )
+
         else
           raise ClickhouseRuby::QueryError.new(
             error.message,
             sql: sql,
-            original_error: error
+            original_error: error,
           )
         end
       end
@@ -705,19 +708,21 @@ module ClickhouseRuby
       # @param sql_type [String] the SQL type
       # @return [Integer, nil] the limit or nil
       def extract_limit(sql_type)
-        if (match = sql_type.match(/\((\d+)\)/))
-          match[1].to_i
-        end
+        return unless (match = sql_type.match(/\((\d+)\)/))
+
+        match[1].to_i
       end
     end
   end
 end
 
 # Register the adapter with ActiveRecord
-if defined?(::ActiveRecord::ConnectionAdapters)
-  ::ActiveRecord::ConnectionAdapters.register(
-    'clickhouse',
-    'ClickhouseRuby::ActiveRecord::ConnectionAdapter',
-    'chruby/active_record/connection_adapter'
-  )
+if defined?(ActiveRecord::ConnectionAdapters)
+  if ActiveRecord::ConnectionAdapters.respond_to?(:register)
+    ActiveRecord::ConnectionAdapters.register(
+      "clickhouse",
+      "ClickhouseRuby::ActiveRecord::ConnectionAdapter",
+      "clickhouse_ruby/active_record/connection_adapter",
+    )
+  end
 end

data/lib/clickhouse_ruby/active_record/railtie.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rails/railtie'
+require "rails/railtie"
 
 module ClickhouseRuby
   module ActiveRecord
@@ -28,24 +28,25 @@ module ClickhouseRuby
     #
     class Railtie < ::Rails::Railtie
       # Initialize the adapter when ActiveRecord loads
-      initializer 'chruby.initialize_active_record' do
+      initializer "clickhouse_ruby.initialize_active_record" do
         # Register the adapter
         ::ActiveSupport.on_load(:active_record) do
-          require_relative 'connection_adapter'
+          require_relative "connection_adapter"
 
           # Log that the adapter is being registered
           if defined?(Rails.logger) && Rails.logger
-            Rails.logger.info '[ClickhouseRuby] ClickHouse adapter registered with ActiveRecord'
+            Rails.logger.info "[ClickhouseRuby] ClickHouse adapter registered with ActiveRecord"
           end
         end
       end
 
       # Configure database tasks (db:create, db:drop, etc.)
-      initializer 'chruby.configure_database_tasks' do
+      initializer "clickhouse_ruby.configure_database_tasks" do
         ::ActiveSupport.on_load(:active_record) do
           # Register ClickHouse-specific database tasks
           if defined?(::ActiveRecord::Tasks::DatabaseTasks)
-            ::ActiveRecord::Tasks::DatabaseTasks.register_task(/clickhouse/, 'ClickhouseRuby::ActiveRecord::DatabaseTasks')
+            ::ActiveRecord::Tasks::DatabaseTasks.register_task(/clickhouse/,
+                                                               "ClickhouseRuby::ActiveRecord::DatabaseTasks",)
           end
         end
       end
@@ -55,21 +56,25 @@ module ClickhouseRuby
         # Set up connection pool based on Rails configuration
         if defined?(ActiveRecord::Base)
           # Ensure connections are properly managed
-          ActiveRecord::Base.connection_pool.disconnect! rescue nil
+          begin
+            ActiveRecord::Base.connection_pool.disconnect!
+          rescue StandardError
+            nil
+          end
         end
       end
 
       # Add generators namespace for Rails generators
       generators do
-        require_relative 'generators/migration_generator' if defined?(::Rails::Generators)
+        require_relative "generators/migration_generator" if defined?(::Rails::Generators)
       end
 
       # Log deprecation warnings for known issues
-      initializer 'chruby.log_deprecation_warnings' do
+      initializer "clickhouse_ruby.log_deprecation_warnings" do
         ::ActiveSupport.on_load(:active_record) do
           # Warn about features that don't work with ClickHouse
           if defined?(Rails.logger) && Rails.logger
-            Rails.logger.debug '[ClickhouseRuby] Note: ClickHouse does not support transactions, savepoints, or foreign keys'
+            Rails.logger.debug "[ClickhouseRuby] Note: ClickHouse does not support transactions, savepoints, or foreign keys"
           end
         end
       end
@@ -94,7 +99,7 @@ module ClickhouseRuby
 
         # Connect without database to create it
         temp_config = config.dup
-        temp_config[:database] = 'default'
+        temp_config[:database] = "default"
 
         adapter = ConnectionAdapter.new(nil, nil, nil, temp_config)
         adapter.connect
@@ -117,7 +122,7 @@ module ClickhouseRuby
 
         # Connect without database to drop it
         temp_config = config.dup
-        temp_config[:database] = 'default'
+        temp_config[:database] = "default"
 
         adapter = ConnectionAdapter.new(nil, nil, nil, temp_config)
         adapter.connect
@@ -145,11 +150,11 @@ module ClickhouseRuby
         adapter = ConnectionAdapter.new(nil, nil, nil, config)
         adapter.connect
 
-        File.open(filename, 'w') do |file|
+        File.open(filename, "w") do |file|
           # Dump each table's CREATE statement
           adapter.tables.each do |table_name|
             result = adapter.execute("SHOW CREATE TABLE #{adapter.quote_table_name(table_name)}")
-            create_statement = result.first['statement'] || result.first['Create Table']
+            create_statement = result.first["statement"] || result.first["Create Table"]
             file.puts "#{create_statement};\n\n"
           end
         end
@@ -180,7 +185,7 @@ module ClickhouseRuby
 
       # Charset (not applicable to ClickHouse)
       def charset(_master_configuration_hash = configuration_hash)
-        'UTF-8'
+        "UTF-8"
       end
 
       # Collation (not applicable to ClickHouse)