clickhouse-activerecord 0.5.7 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79b43575e5eef93daa11e1a2aca2984f696cbef59021f55d1470b2dc0a5d1e3d
-  data.tar.gz: b79cccb85d8a07fa4dc533d7b7e9042eeaa2afead26214c075b3131e1843394b
+  metadata.gz: 6533de4ab9b2415a4df22e72e7ef551d4fb58c5bdc6713ec355b85dbad1174fd
+  data.tar.gz: 1c0a898f494c6dc7511897617ea86c2f12aa42461cf693e28e78124bde3638c6
 SHA512:
-  metadata.gz: 840b01cc1d5b88eee5e031fada23cfd35f7a8d948a35a767b2f5baf1596af665f28c56778e699960511004367b16ee3130be1f5bd2ee713a9a0d5053a9b58a37
-  data.tar.gz: 4e613a19c51b362a05634da06d9528809ed09f01ebec4eac9984656156e9b877bdc4ce321e24bea63ae4e49d85609fa9dda781db60159e60b6d6ee06e8a99a3e
+  metadata.gz: f6c5c2eba18dce09211cc6b8e5448aaaf2c40ca3eb5cc411aa76874ad6efc00ae257880e5997256808d02771aec7947559edfca941187c219b6724f09b9488f0
+  data.tar.gz: 7b7e5f520c4189b4b5a1587789d0ea2ef8b74e86c077611ac18515c45105306c6e17cfd824623ab574420beeb45d205a9f301e2db9f3befd3c3b92c4d303b978

data/CHANGELOG.md

@@ -1,10 +1,16 @@
+### Version 0.5.10 (Jun 22, 2022)
+
+ * Fixes to create_table method (#70)
+ * Added support for rails 7 (#65)
+ * Use ClickHouse default KeepAlive timeout of 10 seconds (#67)
+
 ### Version 0.5.6 (Oct 25, 2021)
- 
+
  * Added auto creating service distributed tables and additional options for creating view [@ygreeek](https://github.com/ygreeek)
  * Added default user agent
 
 ### Version 0.5.3 (Sep 22, 2021)
- 
+
  * Fix replica cluster for a new syntax MergeTree
  * Fix support rails 5.2 on alter table
  * Support array type of column

data/README.md

@@ -1,7 +1,7 @@
 # Clickhouse::Activerecord
 
 A Ruby database ActiveRecord driver for ClickHouse. Support Rails >= 5.2.
-Support ClickHouse version from 20.9 LTS.
+Support ClickHouse version from 22.0 LTS.
 
 ## Installation
 
@@ -165,7 +165,7 @@ Structure load from `db/clickhouse_structure.sql` file:
 
 ```ruby
 Action.where(url: 'http://example.com', date: Date.current).where.not(name: nil).order(created_at: :desc).limit(10)
-# Clickhouse Action Load (10.3ms)  SELECT  actions.* FROM actions WHERE actions.date = '2017-11-29' AND actions.url = 'http://example.com' AND (actions.name IS NOT NULL)  ORDER BY actions.created_at DESC LIMIT 10
+# Clickhouse Action Load (10.3ms)  SELECT actions.* FROM actions WHERE actions.date = '2017-11-29' AND actions.url = 'http://example.com' AND (actions.name IS NOT NULL)  ORDER BY actions.created_at DESC LIMIT 10
 #=> #<ActiveRecord::Relation [#<Action *** >]>
 
 Action.create(url: 'http://example.com', date: Date.yesterday)
@@ -175,6 +175,18 @@ Action.create(url: 'http://example.com', date: Date.yesterday)
 ActionView.maximum(:date)
 # Clickhouse (10.3ms)  SELECT maxMerge(actions.date) FROM actions
 #=> 'Wed, 29 Nov 2017'
+
+Action.where(date: Date.current).final.limit(10)
+# Clickhouse Action Load (10.3ms)  SELECT actions.* FROM actions FINAL WHERE actions.date = '2017-11-29' LIMIT 10
+#=> #<ActiveRecord::Relation [#<Action *** >]>
+
+Action.settings(optimize_read_in_order: 1).where(date: Date.current).limit(10)
+# Clickhouse Action Load (10.3ms)  SELECT actions.* FROM actions FINAL WHERE actions.date = '2017-11-29' LIMIT 10 SETTINGS optimize_read_in_order = 1
+#=> #<ActiveRecord::Relation [#<Action *** >]>
+
+User.joins(:actions).using(:group_id)
+# Clickhouse User Load (10.3ms)  SELECT users.* FROM users INNER JOIN actions USING group_id
+#=> #<ActiveRecord::Relation [#<Action *** >]>
 ```
 
 

data/clickhouse-activerecord.gemspec

@@ -24,9 +24,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'bundler', '>= 1.13.4'
-  spec.add_runtime_dependency 'activerecord', '>= 5.2'
+  spec.add_runtime_dependency 'activerecord', '~> 7.0.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.15'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.4'
   spec.add_development_dependency 'pry', '~> 0.12'

data/core_extensions/active_record/migration/command_recorder.rb

@@ -2,21 +2,12 @@ module CoreExtensions
   module ActiveRecord
     module Migration
       module CommandRecorder
-        def create_table_with_distributed(*args, &block)
-          record(:create_table_with_distributed, args, &block)
-        end
-
         def create_view(*args, &block)
           record(:create_view, args, &block)
         end
 
         private
 
-        def invert_create_table_with_distributed(args)
-          table_name, options = args
-          [:drop_table_with_distributed, table_name, options]
-        end
-
         def invert_create_view(args)
           view_name, options = args
           [:drop_table, view_name, options]

data/lib/active_record/connection_adapters/clickhouse/oid/array.rb

@@ -23,6 +23,42 @@ module ActiveRecord
             @subtype
           end
 
+          def deserialize(value)
+            if value.is_a?(::Array)
+              value.map { |item| deserialize(item) }
+            else
+              return value if value.nil?
+              case @subtype
+                when :integer
+                  value.to_i
+                when :datetime
+                  ::DateTime.parse(value)
+                when :date
+                  ::Date.parse(value)
+              else
+                super
+              end
+            end
+          end
+
+          def serialize(value)
+            if value.is_a?(::Array)
+              value.map { |item| serialize(item) }
+            else
+              return value if value.nil?
+              case @subtype
+                when :integer
+                  value.to_i
+                when :datetime
+                  DateTime.new.serialize(value)
+                when :date
+                  Date.new.serialize(value)
+              else
+                super
+              end
+            end
+          end
+
         end
       end
     end

data/lib/active_record/connection_adapters/clickhouse/oid/date_time.rb

@@ -9,9 +9,8 @@ module ActiveRecord
           def serialize(value)
             value = super
             return unless value
-            return value.strftime('%Y-%m-%d %H:%M:%S') unless value.acts_like?(:time)
 
-            value.to_time.strftime('%Y-%m-%d %H:%M:%S')
+            value.strftime('%Y-%m-%d %H:%M:%S' + (@precision.present? && @precision > 0 ? ".%#{@precision}N" : ''))
           end
 
           def type_cast_from_database(value)

data/lib/active_record/connection_adapters/clickhouse/schema_creation.rb

@@ -19,9 +19,18 @@ module ActiveRecord
         end
 
         def add_column_options!(sql, options)
+          if options[:value]
+            sql.gsub!(/\s+(.*)/, " \\1(#{options[:value]})")
+          end
+          if options[:fixed_string]
+            sql.gsub!(/\s+(.*)/, " FixedString(#{options[:fixed_string]})")
+          end
           if options[:null] || options[:null].nil?
             sql.gsub!(/\s+(.*)/, ' Nullable(\1)')
           end
+          if options[:low_cardinality]
+            sql.gsub!(/\s+(.*)/, ' LowCardinality(\1)')
+          end
           if options[:array]
             sql.gsub!(/\s+(.*)/, ' Array(\1)')
           end
@@ -73,7 +82,7 @@ module ActiveRecord
           return unless match
           return if match[:database]
 
-          create_sql << "TO #{current_database}.#{options.to.sub('.', '')} "
+          create_sql << "TO #{current_database}.#{match[:table_name].sub('.', '')}"
         end
 
         def visit_TableDefinition(o)
@@ -116,7 +125,11 @@ module ActiveRecord
         end
 
         def current_database
-          ActiveRecord::Base.connection_db_config.database
+          if ActiveRecord::version >= Gem::Version.new('6.1')
+            ActiveRecord::Base.connection_db_config.database
+          else
+            ActiveRecord::Base.connection_config[:database]
+          end
         end
       end
     end

data/lib/active_record/connection_adapters/clickhouse/schema_definitions.rb

@@ -62,6 +62,38 @@ module ActiveRecord
           end
           args.each { |name| column(name, kind, **options.except(:limit, :unsigned)) }
         end
+
+        def datetime(*args, **options)
+          kind = :datetime
+
+          if options[:precision]
+            kind = :datetime64
+            options[:value] = options[:precision]
+          end
+
+          args.each { |name| column(name, kind, **options.except(:precision)) }
+        end
+
+        def uuid(*args, **options)
+          args.each { |name| column(name, :uuid, **options) }
+        end
+
+        def enum(*args, **options)
+          kind = :enum8
+
+          unless options[:value].is_a? Hash
+            raise ArgumentError, "Column #{args.first}: option 'value' must be Hash, got: #{options[:value].class}"
+          end
+
+          options[:value] = options[:value].each_with_object([]) { |(k, v), arr| arr.push("'#{k}' = #{v}") }.join(', ')
+
+          if options[:limit]
+            kind = :enum8  if options[:limit] == 1
+            kind = :enum16 if options[:limit] == 2
+          end
+
+          args.each { |name| column(name, kind, **options.except(:limit)) }
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/clickhouse/schema_statements.rb

@@ -6,8 +6,8 @@ module ActiveRecord
   module ConnectionAdapters
     module Clickhouse
       module SchemaStatements
-        def execute(sql, name = nil)
-          do_execute(sql, name)
+        def execute(sql, name = nil, settings: {})
+          do_execute(sql, name, settings: settings)
         end
 
         def exec_insert(sql, name, _binds, _pk = nil, _sequence_name = nil)
@@ -18,7 +18,7 @@ module ActiveRecord
 
         def exec_query(sql, name = nil, binds = [], prepare: false)
           result = do_execute(sql, name)
-          ActiveRecord::Result.new(result['meta'].map { |m| m['name'] }, result['data'])
+          ActiveRecord::Result.new(result['meta'].map { |m| m['name'] }, result['data'], result['meta'].map { |m| [m['name'], type_map.lookup(m['type'])] }.to_h)
         rescue ActiveRecord::ActiveRecordError => e
           raise e
         rescue StandardError => e
@@ -39,7 +39,7 @@ module ActiveRecord
         end
 
         def tables(name = nil)
-          result = do_system_execute('SHOW TABLES', name)
+          result = do_system_execute("SHOW TABLES WHERE name NOT LIKE '.inner_id.%'", name)
           return [] if result.nil?
           result['data'].flatten
         end
@@ -92,7 +92,7 @@ module ActiveRecord
             if (duplicate = inserting.detect { |v| inserting.count(v) > 1 })
               raise "Duplicate migration #{duplicate}. Please renumber your migrations to resolve the conflict."
             end
-            execute insert_versions_sql(inserting)
+            do_execute(insert_versions_sql(inserting), nil, settings: {max_partitions_per_insert_block: [100, inserting.size].max})
           end
         end
 
@@ -105,10 +105,20 @@ module ActiveRecord
         def process_response(res)
           case res.code.to_i
           when 200
-            res.body.presence && JSON.parse(res.body)
+            if res.body.to_s.include?("DB::Exception")
+              raise ActiveRecord::ActiveRecordError, "Response code: #{res.code}:\n#{res.body}"
+            else
+              res.body.presence && JSON.parse(res.body)
+            end
           else
-            raise ActiveRecord::ActiveRecordError,
-              "Response code: #{res.code}:\n#{res.body}"
+            case res.body
+              when /DB::Exception:.*\(UNKNOWN_DATABASE\)/
+                raise ActiveRecord::NoDatabaseError
+              when /DB::Exception:.*\(DATABASE_ALREADY_EXISTS\)/
+                raise ActiveRecord::DatabaseAlreadyExists
+              else
+                raise ActiveRecord::ActiveRecordError, "Response code: #{res.code}:\n#{res.body}"
+            end
           end
         rescue JSON::ParserError
           res.body

data/lib/active_record/connection_adapters/clickhouse_adapter.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'clickhouse-activerecord/arel/visitors/to_sql'
-require 'clickhouse-activerecord/arel/table'
+require 'arel/visitors/clickhouse'
+require 'arel/nodes/settings'
+require 'arel/nodes/using'
 require 'clickhouse-activerecord/migration'
 require 'active_record/connection_adapters/clickhouse/oid/array'
 require 'active_record/connection_adapters/clickhouse/oid/date'
@@ -11,6 +12,7 @@ require 'active_record/connection_adapters/clickhouse/schema_definitions'
 require 'active_record/connection_adapters/clickhouse/schema_creation'
 require 'active_record/connection_adapters/clickhouse/schema_statements'
 require 'net/http'
+require 'openssl'
 
 module ActiveRecord
   class Base
@@ -32,6 +34,7 @@ module ActiveRecord
             sslca: config[:sslca],
             read_timeout: config[:read_timeout],
             write_timeout: config[:write_timeout],
+            keep_alive_timeout: config[:keep_alive_timeout]
           }
         end
 
@@ -46,21 +49,6 @@ module ActiveRecord
     end
   end
 
-  class Relation
-
-    # Replace for only ClickhouseAdapter
-    def reverse_order!
-      orders = order_values.uniq
-      orders.reject!(&:blank?)
-      if self.connection.is_a?(ConnectionAdapters::ClickhouseAdapter) && orders.empty? && !primary_key
-        self.order_values = %w(date created_at).select {|c| column_names.include?(c) }.map{|c| arel_attribute(c).desc }
-      else
-        self.order_values = reverse_sql_order(orders)
-      end
-      self
-    end
-  end
-
   module TypeCaster
     class Map
       def is_view
@@ -74,7 +62,9 @@ module ActiveRecord
   end
 
   module ModelSchema
-     module ClassMethods
+    module ClassMethods
+      delegate :final, :settings, to: :all
+
       def is_view
         @is_view || false
       end
@@ -82,13 +72,12 @@ module ActiveRecord
       def is_view=(value)
         @is_view = value
       end
-
-      def arel_table # :nodoc:
-        @arel_table ||= ClickhouseActiverecord::Arel::Table.new(table_name, type_caster: type_caster)
-      end
-
+      #
+      # def arel_table # :nodoc:
+      #   @arel_table ||= Arel::Table.new(table_name, type_caster: type_caster)
+      # end
     end
-   end
+  end
 
   module ConnectionAdapters
     class ClickhouseColumn < Column
@@ -104,8 +93,13 @@ module ActiveRecord
         float: { name: 'Float32' },
         decimal: { name: 'Decimal' },
         datetime: { name: 'DateTime' },
+        datetime64: { name: 'DateTime64' },
         date: { name: 'Date' },
-        boolean: { name: 'UInt8' },
+        boolean: { name: 'Bool' },
+        uuid: { name: 'UUID' },
+
+        enum8: { name: 'Enum8' },
+        enum16: { name: 'Enum16' },
 
         int8:  { name: 'Int8' },
         int16: { name: 'Int16' },
@@ -154,7 +148,7 @@ module ActiveRecord
       end
 
       def arel_visitor # :nodoc:
-        ClickhouseActiverecord::Arel::Visitors::ToSql.new(self)
+        Arel::Visitors::Clickhouse.new(self)
       end
 
       def native_database_types #:nodoc:
@@ -165,59 +159,97 @@ module ActiveRecord
         !native_database_types[type].nil?
       end
 
-      def extract_limit(sql_type) # :nodoc:
-        case sql_type
-          when /(Nullable)?\(?String\)?/
-            super('String')
-          when /(Nullable)?\(?U?Int8\)?/
-            1
-          when /(Nullable)?\(?U?Int16\)?/
-            2
-          when /(Nullable)?\(?U?Int32\)?/
-            nil
-          when /(Nullable)?\(?U?Int64\)?/
-            8
-          else
-            super
+      class << self
+        def extract_limit(sql_type) # :nodoc:
+          case sql_type
+            when /(Nullable)?\(?String\)?/
+              super('String')
+            when /(Nullable)?\(?U?Int8\)?/
+              1
+            when /(Nullable)?\(?U?Int16\)?/
+              2
+            when /(Nullable)?\(?U?Int32\)?/
+              nil
+            when /(Nullable)?\(?U?Int64\)?/
+              8
+            else
+              super
+          end
+        end
+
+        # `extract_scale` and `extract_precision` are the same as in the Rails abstract base class,
+        # except this permits a space after the comma
+
+        def extract_scale(sql_type)
+          case sql_type
+          when /\((\d+)\)/ then 0
+          when /\((\d+)(,\s?(\d+))\)/ then $3.to_i
+          end
         end
+
+        def extract_precision(sql_type)
+          $1.to_i if sql_type =~ /\((\d+)(,\s?\d+)?\)/
+        end
+
+        def initialize_type_map(m) # :nodoc:
+          super
+          register_class_with_limit m, %r(String), Type::String
+          register_class_with_limit m, 'Date',  Clickhouse::OID::Date
+          register_class_with_precision m, %r(datetime)i,  Clickhouse::OID::DateTime
+
+          register_class_with_limit m, %r(Int8), Type::Integer
+          register_class_with_limit m, %r(Int16), Type::Integer
+          register_class_with_limit m, %r(Int32), Type::Integer
+          register_class_with_limit m, %r(Int64), Type::Integer
+          register_class_with_limit m, %r(Int128), Type::Integer
+          register_class_with_limit m, %r(Int256), Type::Integer
+
+          register_class_with_limit m, %r(UInt8), Type::UnsignedInteger
+          register_class_with_limit m, %r(UInt16), Type::UnsignedInteger
+          register_class_with_limit m, %r(UInt32), Type::UnsignedInteger
+          register_class_with_limit m, %r(UInt64), Type::UnsignedInteger
+          #register_class_with_limit m, %r(UInt128), Type::UnsignedInteger #not implemnted in clickhouse
+          register_class_with_limit m, %r(UInt256), Type::UnsignedInteger
+          # register_class_with_limit m, %r(Array), Clickhouse::OID::Array
+          m.register_type(%r(Array)) do |sql_type|
+            Clickhouse::OID::Array.new(sql_type)
+          end
+        end
+      end
+
+      # In Rails 7 used constant TYPE_MAP, we need redefine method
+      def type_map
+        @type_map ||= Type::TypeMap.new.tap { |m| ClickhouseAdapter.initialize_type_map(m) }
       end
 
-      def initialize_type_map(m) # :nodoc:
-        super
-        register_class_with_limit m, %r(String), Type::String
-        register_class_with_limit m, 'Date',  Clickhouse::OID::Date
-        register_class_with_limit m, 'DateTime',  Clickhouse::OID::DateTime
-
-        register_class_with_limit m, %r(Int8), Type::Integer
-        register_class_with_limit m, %r(Int16), Type::Integer
-        register_class_with_limit m, %r(Int32), Type::Integer
-        register_class_with_limit m, %r(Int64), Type::Integer
-        register_class_with_limit m, %r(Int128), Type::Integer
-        register_class_with_limit m, %r(Int256), Type::Integer
-
-        register_class_with_limit m, %r(UInt8), Type::UnsignedInteger
-        register_class_with_limit m, %r(UInt16), Type::UnsignedInteger
-        register_class_with_limit m, %r(UInt32), Type::UnsignedInteger
-        register_class_with_limit m, %r(UInt64), Type::UnsignedInteger
-        #register_class_with_limit m, %r(UInt128), Type::UnsignedInteger #not implemnted in clickhouse
-        register_class_with_limit m, %r(UInt256), Type::UnsignedInteger
-        # register_class_with_limit m, %r(Array), Clickhouse::OID::Array
-        m.register_type(%r(Array)) do |sql_type|
-          Clickhouse::OID::Array.new(sql_type)
+      def quote(value)
+        case value
+        when Array
+          '[' + value.map { |v| quote(v) }.join(', ') + ']'
+        else
+          super
         end
       end
 
       # Quoting time without microseconds
       def quoted_date(value)
         if value.acts_like?(:time)
-          zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+          if ActiveRecord::version >= Gem::Version.new('7')
+            zone_conversion_method = ActiveRecord.default_timezone == :utc ? :getutc : :getlocal
+          else
+            zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+          end
 
           if value.respond_to?(zone_conversion_method)
             value = value.send(zone_conversion_method)
           end
         end
 
-        value.to_s(:db)
+        if ActiveRecord::version >= Gem::Version.new('7')
+          value.to_fs(:db)
+        else
+          value.to_s(:db)
+        end
       end
 
       def column_name_for_operation(operation, node) # :nodoc:
@@ -269,32 +301,30 @@ module ActiveRecord
           drop_table(table_name, options.merge(if_exists: true))
         end
 
-        execute schema_creation.accept td
+        do_execute(schema_creation.accept(td), format: nil)
       end
 
       def create_table(table_name, **options, &block)
         options = apply_replica(table_name, options)
         td = create_table_definition(apply_cluster(table_name), **options)
         block.call td if block_given?
+        td.column(:id, options[:id], null: false) if options[:id].present? && td[:id].blank?
 
         if options[:force]
           drop_table(table_name, options.merge(if_exists: true))
         end
 
-        execute schema_creation.accept td
-      end
-
-      def create_table_with_distributed(table_name, **options, &block)
-        sharding_key = options.delete(:sharding_key) || 'rand()'
-        create_table("#{table_name}_distributed", **options, &block)
-        raise 'Set a cluster' unless cluster
+        do_execute(schema_creation.accept(td), format: nil)
 
-        distributed_options = "Distributed(#{cluster},#{@config[:database]},#{table_name}_distributed,#{sharding_key})"
-        create_table(table_name, **options.merge(options: distributed_options), &block)
-      end
+        if options[:with_distributed]
+          distributed_table_name = options.delete(:with_distributed)
+          sharding_key = options.delete(:sharding_key) || 'rand()'
+          raise 'Set a cluster' unless cluster
 
-      def drop_table_with_distributed(table_name, **options)
-        ["#{table_name}_distributed", table_name].each { |name| drop_table(name, **options) }
+          distributed_options =
+            "Distributed(#{cluster}, #{@config[:database]}, #{table_name}, #{sharding_key})"
+          create_table(distributed_table_name, **options.merge(options: distributed_options), &block)
+        end
       end
 
       # Drops a ClickHouse database.
@@ -311,11 +341,36 @@ module ActiveRecord
       end
 
       def drop_table(table_name, options = {}) # :nodoc:
-        do_execute apply_cluster "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}"
+        query = "DROP TABLE"
+        query = "#{query} IF EXISTS " if options[:if_exists]
+        query = "#{query} #{quote_table_name(table_name)}"
+        query = apply_cluster(query)
+        query = "#{query} SYNC" if options[:sync]
+
+        do_execute(query)
+
+        if options[:with_distributed]
+          distributed_table_name = options.delete(:with_distributed)
+          drop_table(distributed_table_name, **options)
+        end
+      end
+
+      def add_column(table_name, column_name, type, **options)
+        return if options[:if_not_exists] == true && column_exists?(table_name, column_name, type)
+
+        at = create_alter_table table_name
+        at.add_column(column_name, type, **options)
+        execute(schema_creation.accept(at), nil, settings: {wait_end_of_query: 1, send_progress_in_http_headers: 1})
+      end
+
+      def remove_column(table_name, column_name, type = nil, **options)
+        return if options[:if_exists] == true && !column_exists?(table_name, column_name)
+
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{remove_column_for_alter(table_name, column_name, type, **options)}", nil, settings: {wait_end_of_query: 1, send_progress_in_http_headers: 1})
       end
 
       def change_column(table_name, column_name, type, options = {})
-        result = do_execute "ALTER TABLE #{quote_table_name(table_name)} #{change_column_for_alter(table_name, column_name, type, options)}"
+        result = do_execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_for_alter(table_name, column_name, type, options)}", nil, settings: {wait_end_of_query: 1, send_progress_in_http_headers: 1})
         raise "Error parse json response: #{result}" if result.presence && !result.is_a?(Hash)
       end
 
@@ -351,12 +406,18 @@ module ActiveRecord
 
       def database_engine_atomic?
         current_database_engine = "select engine from system.databases where name = '#{@config[:database]}'"
-        res = ActiveRecord::Base.connection.select_one(current_database_engine)
+        res = select_one(current_database_engine)
         res['engine'] == 'Atomic' if res
       end
 
       def apply_cluster(sql)
-        cluster ? "#{sql} ON CLUSTER #{cluster}" : sql
+        if cluster
+          normalized_cluster_name = cluster.start_with?('{') ? "'#{cluster}'" : cluster
+
+          "#{sql} ON CLUSTER #{normalized_cluster_name}"
+        else
+          sql
+        end
       end
 
       def supports_insert_on_duplicate_skip?
@@ -393,6 +454,9 @@ module ActiveRecord
         @connection.read_timeout = @connection_parameters[:read_timeout] if @connection_parameters[:read_timeout]
         @connection.write_timeout = @connection_parameters[:write_timeout] if @connection_parameters[:write_timeout]
 
+        # Use clickhouse default keep_alive_timeout value of 10, rather than Net::HTTP's default of 2
+        @connection.keep_alive_timeout = @connection_parameters[:keep_alive_timeout] || 10
+
         @connection
       end
 

data/lib/arel/nodes/settings.rb

@@ -0,0 +1,11 @@
+module Arel # :nodoc: all
+  module Nodes
+    class Settings < Arel::Nodes::Unary
+      def initialize(expr)
+        raise ArgumentError, 'Settings must be a Hash' unless expr.is_a?(Hash)
+
+        super
+      end
+    end
+  end
+end

data/lib/arel/nodes/using.rb

@@ -0,0 +1,6 @@
+module Arel # :nodoc: all
+  module Nodes
+    class Using < Arel::Nodes::Unary
+    end
+  end
+end

data/lib/arel/visitors/clickhouse.rb

@@ -0,0 +1,60 @@
+require 'arel/visitors/to_sql'
+
+module Arel
+  module Visitors
+    class Clickhouse < ::Arel::Visitors::ToSql
+
+      def aggregate(name, o, collector)
+        # replacing function name for materialized view
+        if o.expressions.first && o.expressions.first != '*' && !o.expressions.first.is_a?(String) && o.expressions.first.relation&.is_view
+          super("#{name.downcase}Merge", o, collector)
+        else
+          super
+        end
+      end
+
+      def visit_Arel_Table o, collector
+        collector = super
+        collector << ' FINAL ' if o.final
+        collector
+      end
+
+      def visit_Arel_Nodes_SelectOptions(o, collector)
+        maybe_visit o.settings, super
+      end
+
+      def visit_Arel_Nodes_Settings(o, collector)
+        return collector if o.expr.empty?
+
+        collector << "SETTINGS "
+        o.expr.each_with_index do |(key, value), i|
+          collector << ", " if i > 0
+          collector << key.to_s.gsub(/\W+/, "")
+          collector << " = "
+          collector << sanitize_as_setting_value(value)
+        end
+        collector
+      end
+
+      def visit_Arel_Nodes_Using o, collector
+        collector << "USING "
+        visit o.expr, collector
+        collector
+      end
+
+      def sanitize_as_setting_value(value)
+        if value == :default
+          'DEFAULT'
+        else
+          quote(value)
+        end
+      end
+
+      def sanitize_as_setting_name(value)
+        return value if Arel::Nodes::SqlLiteral === value
+        @connection.sanitize_as_setting_name(value)
+      end
+
+    end
+  end
+end

data/lib/clickhouse-activerecord/migration.rb

@@ -10,16 +10,17 @@ module ClickhouseActiverecord
 
         version_options = connection.internal_string_options_for_primary_key
         table_options = {
-          id: false, options: 'ReplacingMergeTree(ver) PARTITION BY version ORDER BY (version)', if_not_exists: true
+          id: false, options: 'ReplacingMergeTree(ver) ORDER BY (version)', if_not_exists: true
         }
-        if connection.instance_variable_get(:@full_config)[:distributed_service_tables]
-          table_options.merge!(sharding_key: 'cityHash64(version)')
-          table_creation_method = 'create_table_with_distributed'
-        else
-          table_creation_method = 'create_table'
+        full_config = connection.instance_variable_get(:@full_config) || {}
+
+        if full_config[:distributed_service_tables]
+          table_options.merge!(with_distributed: table_name, sharding_key: 'cityHash64(version)')
+
+          distributed_suffix = "_#{full_config[:distributed_service_tables_suffix] || 'distributed'}"
         end
 
-        connection.public_send(table_creation_method, table_name, **table_options) do |t|
+        connection.create_table(table_name + distributed_suffix.to_s, **table_options) do |t|
           t.string :version, **version_options
           t.column :active, 'Int8', null: false, default: '1'
           t.datetime :ver, null: false, default: -> { 'now()' }
@@ -27,30 +28,43 @@ module ClickhouseActiverecord
       end
 
       def all_versions
-        from("#{table_name} FINAL").where(active: 1).order(:version).pluck(:version)
+        final.where(active: 1).order(:version).pluck(:version)
       end
     end
   end
 
   class InternalMetadata < ::ActiveRecord::InternalMetadata
     class << self
+
+      def []=(key, value)
+        row = final.find_by(key: key)
+        if row.nil? || row.value != value
+          create!(key: key, value: value)
+        end
+      end
+
+      def [](key)
+        final.where(key: key).pluck(:value).first
+      end
+
       def create_table
         return if table_exists?
 
         key_options = connection.internal_string_options_for_primary_key
         table_options = {
           id: false,
-          options: connection.adapter_name.downcase == 'clickhouse' ? 'MergeTree() PARTITION BY toDate(created_at) ORDER BY (created_at)' : '',
+          options: connection.adapter_name.downcase == 'clickhouse' ? 'ReplacingMergeTree(created_at) PARTITION BY key ORDER BY key' : '',
           if_not_exists: true
         }
-        if connection.instance_variable_get(:@full_config).try(:[], :distributed_service_tables)
-          table_options.merge!(sharding_key: 'cityHash64(created_at)')
-          table_creation_method = 'create_table_with_distributed'
-        else
-          table_creation_method = 'create_table'
+        full_config = connection.instance_variable_get(:@full_config) || {}
+
+        if full_config[:distributed_service_tables]
+          table_options.merge!(with_distributed: table_name, sharding_key: 'cityHash64(created_at)')
+
+          distributed_suffix = "_#{full_config[:distributed_service_tables_suffix] || 'distributed'}"
         end
 
-        connection.public_send(table_creation_method, table_name, **table_options) do |t|
+        connection.create_table(table_name + distributed_suffix.to_s, **table_options) do |t|
           t.string :key, **key_options
           t.string :value
           t.timestamps
@@ -120,5 +134,13 @@ module ClickhouseActiverecord
         super
       end
     end
+
+    private
+
+    def record_environment
+      return if down?
+      ClickhouseActiverecord::InternalMetadata[:environment] = ActiveRecord::Base.connection.migration_context.current_environment
+    end
+
   end
 end

data/lib/clickhouse-activerecord/railtie.rb

@@ -4,6 +4,12 @@ module ClickhouseActiverecord
   require 'rails'
 
   class Railtie < Rails::Railtie
+    initializer "clickhouse.load" do
+      ActiveSupport.on_load :active_record do
+        ClickhouseActiverecord.load
+      end
+    end
+
     rake_tasks { load 'tasks/clickhouse.rake' }
   end
 end

data/lib/clickhouse-activerecord/tasks.rb

@@ -2,7 +2,6 @@
 
 module ClickhouseActiverecord
   class Tasks
-
     delegate :connection, :establish_connection, :clear_active_connections!, to: ActiveRecord::Base
 
     def initialize(configuration)
@@ -11,10 +10,10 @@ module ClickhouseActiverecord
 
     def create
       establish_master_connection
-      connection.create_database @configuration["database"]
+      connection.create_database @configuration['database']
     rescue ActiveRecord::StatementInvalid => e
       if e.cause.to_s.include?('already exists')
-        raise ActiveRecord::Tasks::DatabaseAlreadyExists
+        raise ActiveRecord::DatabaseAlreadyExists
       else
         raise
       end
@@ -22,7 +21,7 @@ module ClickhouseActiverecord
 
     def drop
       establish_master_connection
-      connection.drop_database @configuration["database"]
+      connection.drop_database @configuration['database']
     end
 
     def purge

data/lib/clickhouse-activerecord/version.rb

@@ -1,3 +1,3 @@
 module ClickhouseActiverecord
-  VERSION = '0.5.7'
+  VERSION = '0.6.2'
 end

data/lib/clickhouse-activerecord.rb

@@ -2,6 +2,12 @@
 
 require 'active_record/connection_adapters/clickhouse_adapter'
 
+require 'core_extensions/active_record/relation'
+
+require 'core_extensions/arel/nodes/select_statement'
+require 'core_extensions/arel/select_manager'
+require 'core_extensions/arel/table'
+
 require_relative '../core_extensions/active_record/migration/command_recorder'
 ActiveRecord::Migration::CommandRecorder.include CoreExtensions::ActiveRecord::Migration::CommandRecorder
 
@@ -14,5 +20,11 @@ if defined?(Rails::Railtie)
 end
 
 module ClickhouseActiverecord
+  def self.load
+    ActiveRecord::Relation.prepend(CoreExtensions::ActiveRecord::Relation)
 
+    Arel::Nodes::SelectStatement.prepend(CoreExtensions::Arel::Nodes::SelectStatement)
+    Arel::SelectManager.prepend(CoreExtensions::Arel::SelectManager)
+    Arel::Table.prepend(CoreExtensions::Arel::Table)
+  end
 end

data/lib/core_extensions/active_record/relation.rb

@@ -0,0 +1,44 @@
+module CoreExtensions
+  module ActiveRecord
+    module Relation
+      def reverse_order!
+        return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+
+        orders = order_values.uniq.reject(&:blank?)
+        return super unless orders.empty? && !primary_key
+
+        self.order_values = (column_names & %w[date created_at]).map { |c| arel_table[c].desc }
+        self
+      end
+
+      # @param [Hash] opts
+      def settings(**opts)
+        check_command('SETTINGS')
+        @values[:settings] = (@values[:settings] || {}).merge opts
+        self
+      end
+
+      # @param [Boolean] final
+      def final(final = true)
+        check_command('FINAL')
+        @table = @table.dup
+        @table.final = final
+        self
+      end
+
+      private
+
+      def check_command(cmd)
+        raise ::ActiveRecord::ActiveRecordError, cmd + ' is a ClickHouse specific query clause' unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+      end
+
+      def build_arel(aliases = nil)
+        arel = super
+
+        arel.settings(@values[:settings]) if @values[:settings].present?
+
+        arel
+      end
+    end
+  end
+end

data/lib/core_extensions/arel/nodes/select_statement.rb

@@ -0,0 +1,18 @@
+module CoreExtensions
+  module Arel # :nodoc: all
+    module Nodes
+      module SelectStatement
+        attr_accessor :settings
+
+        def initialize(relation = nil)
+          super
+          @settings = nil
+        end
+
+        def eql?(other)
+          super && settings == other.settings
+        end
+      end
+    end
+  end
+end

data/lib/core_extensions/arel/select_manager.rb

@@ -0,0 +1,17 @@
+module CoreExtensions
+  module Arel
+    module SelectManager
+
+      # @param [Hash] values
+      def settings(values)
+        @ast.settings = ::Arel::Nodes::Settings.new(values)
+        self
+      end
+
+      def using(*exprs)
+        @ctx.source.right.last.right = ::Arel::Nodes::Using.new(::Arel.sql(exprs.join(',')))
+        self
+      end
+    end
+  end
+end

data/lib/{clickhouse-activerecord → core_extensions}/arel/table.rb

@@ -1,6 +1,8 @@
-module ClickhouseActiverecord
+module CoreExtensions
   module Arel
-    class Table < ::Arel::Table
+    module Table
+      attr_accessor :final
+
       def is_view
         type_caster.is_view
       end

data/lib/tasks/clickhouse.rake

@@ -1,68 +1,70 @@
 # frozen_string_literal: true
 
 namespace :clickhouse do
-
   task prepare_schema_migration_table: :environment do
-    ClickhouseActiverecord::SchemaMigration.create_table unless ENV['simple'] || ARGV.map{|a| a.include?('--simple') ? true : nil}.compact.any?
+    ClickhouseActiverecord::SchemaMigration.create_table unless ENV['simple'] || ARGV.any? { |a| a.include?('--simple') }
   end
 
   task prepare_internal_metadata_table: :environment do
-    ClickhouseActiverecord::InternalMetadata.create_table unless ENV['simple'] || ARGV.map{|a| a.include?('--simple') ? true : nil}.compact.any?
+    ClickhouseActiverecord::InternalMetadata.create_table unless ENV['simple'] || ARGV.any? { |a| a.include?('--simple') }
   end
 
   task load_config: :environment do
-    ENV['SCHEMA'] = "db/clickhouse_schema.rb"
-    ActiveRecord::Migrator.migrations_paths = ["db/migrate_clickhouse"]
-    ActiveRecord::Base.establish_connection(:"#{Rails.env}_clickhouse")
+    ENV['SCHEMA'] = 'db/clickhouse_schema.rb'
+    ActiveRecord::Migrator.migrations_paths = %w[db/migrate_clickhouse]
+    ActiveRecord::Base.establish_connection(:clickhouse)
   end
 
   namespace :schema do
-
-    # todo not testing
+    # TODO: not testing
     desc 'Load database schema'
-    task load: [:load_config, :prepare_internal_metadata_table] do |t, args|
-      simple = ENV['simple'] || ARGV.map{|a| a.include?('--simple') ? true : nil}.compact.any? ? '_simple' : nil
+    task load: %i[load_config prepare_internal_metadata_table] do
+      simple = ENV['simple'] || ARGV.any? { |a| a.include?('--simple') } ? '_simple' : nil
       ClickhouseActiverecord::SchemaMigration.drop_table
-      load("#{Rails.root}/db/clickhouse_schema#{simple}.rb")
+      load(Rails.root.join("db/clickhouse_schema#{simple}.rb"))
     end
 
     desc 'Dump database schema'
-    task dump: :environment do |t, args|
-      simple = ENV['simple'] || args[:simple] || ARGV.map{|a| a.include?('--simple') ? true : nil}.compact.any? ? '_simple' : nil
-      filename = "#{Rails.root}/db/clickhouse_schema#{simple}.rb"
+    task dump: :environment do |_, args|
+      simple = ENV['simple'] || args[:simple] || ARGV.any? { |a| a.include?('--simple') } ? '_simple' : nil
+      filename = Rails.root.join("db/clickhouse_schema#{simple}.rb")
       File.open(filename, 'w:utf-8') do |file|
-        ActiveRecord::Base.establish_connection(:"#{Rails.env}_clickhouse")
-        ClickhouseActiverecord::SchemaDumper.dump(ActiveRecord::Base.connection, file, ActiveRecord::Base, !!simple)
+        ActiveRecord::Base.establish_connection(:clickhouse)
+        ClickhouseActiverecord::SchemaDumper.dump(ActiveRecord::Base.connection, file, ActiveRecord::Base, simple.present?)
       end
     end
-
   end
 
   namespace :structure do
     desc 'Load database structure'
     task load: [:load_config, 'db:check_protected_environments'] do
-      ClickhouseActiverecord::Tasks.new(ActiveRecord::Base.configurations["#{Rails.env}_clickhouse"]).structure_load("#{Rails.root}/db/clickhouse_structure.sql")
+      config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'clickhouse')
+      ClickhouseActiverecord::Tasks.new(config).structure_load(Rails.root.join('db/clickhouse_structure.sql'))
     end
 
     desc 'Dump database structure'
     task dump: [:load_config, 'db:check_protected_environments'] do
-      ClickhouseActiverecord::Tasks.new(ActiveRecord::Base.configurations["#{Rails.env}_clickhouse"]).structure_dump("#{Rails.root}/db/clickhouse_structure.sql")
+      config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'clickhouse')
+      ClickhouseActiverecord::Tasks.new(config).structure_dump(Rails.root.join('db/clickhouse_structure.sql'))
     end
   end
 
   desc 'Creates the database from DATABASE_URL or config/database.yml'
   task create: [:load_config] do
-    ActiveRecord::Tasks::DatabaseTasks.create(ActiveRecord::Base.configurations["#{Rails.env}_clickhouse"])
+    config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'clickhouse')
+    ActiveRecord::Tasks::DatabaseTasks.create(config)
   end
 
   desc 'Drops the database from DATABASE_URL or config/database.yml'
   task drop: [:load_config, 'db:check_protected_environments'] do
-    ActiveRecord::Tasks::DatabaseTasks.drop(ActiveRecord::Base.configurations["#{Rails.env}_clickhouse"])
+    config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'clickhouse')
+    ActiveRecord::Tasks::DatabaseTasks.drop(config)
   end
 
   desc 'Empty the database from DATABASE_URL or config/database.yml'
   task purge: [:load_config, 'db:check_protected_environments'] do
-    ActiveRecord::Tasks::DatabaseTasks.purge(ActiveRecord::Base.configurations["#{Rails.env}_clickhouse"])
+    config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'clickhouse')
+    ActiveRecord::Tasks::DatabaseTasks.purge(config)
   end
 
   # desc 'Resets your database using your migrations for the current environment'
@@ -72,7 +74,7 @@ namespace :clickhouse do
   end
 
   desc 'Migrate the clickhouse database'
-  task migrate: [:load_config, :prepare_schema_migration_table, :prepare_internal_metadata_table] do
+  task migrate: %i[load_config prepare_schema_migration_table prepare_internal_metadata_table] do
     Rake::Task['db:migrate'].execute
     if File.exists? "#{Rails.root}/db/clickhouse_schema_simple.rb"
       Rake::Task['clickhouse:schema:dump'].execute(simple: true)
@@ -80,7 +82,7 @@ namespace :clickhouse do
   end
 
   desc 'Rollback the clickhouse database'
-  task rollback: [:load_config, :prepare_schema_migration_table, :prepare_internal_metadata_table] do
+  task rollback: %i[load_config prepare_schema_migration_table prepare_internal_metadata_table] do
     Rake::Task['db:rollback'].execute
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.6.2
 platform: ruby
 authors:
 - Sergey Odintsov
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-25 00:00:00.000000000 Z
+date: 2023-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -26,32 +26,18 @@ dependencies:
         version: 1.13.4
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.2'
-- !ruby/object:Gem::Dependency
-  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
-  type: :development
+        version: 7.0.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -121,22 +107,27 @@ files:
 - lib/active_record/connection_adapters/clickhouse/schema_definitions.rb
 - lib/active_record/connection_adapters/clickhouse/schema_statements.rb
 - lib/active_record/connection_adapters/clickhouse_adapter.rb
+- lib/arel/nodes/settings.rb
+- lib/arel/nodes/using.rb
+- lib/arel/visitors/clickhouse.rb
 - lib/clickhouse-activerecord.rb
-- lib/clickhouse-activerecord/arel/table.rb
-- lib/clickhouse-activerecord/arel/visitors/to_sql.rb
 - lib/clickhouse-activerecord/migration.rb
 - lib/clickhouse-activerecord/railtie.rb
 - lib/clickhouse-activerecord/schema.rb
 - lib/clickhouse-activerecord/schema_dumper.rb
 - lib/clickhouse-activerecord/tasks.rb
 - lib/clickhouse-activerecord/version.rb
+- lib/core_extensions/active_record/relation.rb
+- lib/core_extensions/arel/nodes/select_statement.rb
+- lib/core_extensions/arel/select_manager.rb
+- lib/core_extensions/arel/table.rb
 - lib/generators/clickhouse_migration_generator.rb
 - lib/tasks/clickhouse.rake
 homepage: https://github.com/pnixx/clickhouse-activerecord
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -151,8 +142,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: ClickHouse ActiveRecord
 test_files: []

data/lib/clickhouse-activerecord/arel/visitors/to_sql.rb

@@ -1,20 +0,0 @@
-require 'arel/visitors/to_sql'
-
-module ClickhouseActiverecord
-  module Arel
-    module Visitors
-      class ToSql < ::Arel::Visitors::ToSql
-
-        def aggregate(name, o, collector)
-          # replacing function name for materialized view
-          if o.expressions.first && o.expressions.first != '*' && !o.expressions.first.is_a?(String) && o.expressions.first.relation&.is_view
-            super("#{name.downcase}Merge", o, collector)
-          else
-            super
-          end
-        end
-
-      end
-    end
-  end
-end