clickhouse-activerecord 0.5.15 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6534694860bbb41c21789239e0589406bcbef64bc1750645c68485e77acb7310
-  data.tar.gz: c6640ccc74004a93bfaa18d93dd1c135411d66f27273eb65848f9843f64fd6d0
+  metadata.gz: 823fdbf17f27c65446c01b1599a3c61d9fa9b310d7ce153e9c64a912719e552e
+  data.tar.gz: 5b6dd44cdc44b2d1350e0f1c5937cf08051a5ff7a4f73cf56a5dc7567b4be800
 SHA512:
-  metadata.gz: f848ad57f80f061aa85a593a90bff65707e8dbe281caf3f4a41914d93a4723351bf7e5ca12bfdc7c8ed2cbed5df3db39472b8d015645875476b68941d7de6111
-  data.tar.gz: 1592560741198e983d43599ff78b145262e0638951a2825dcaac993e0dcc0195bf85980b5eeff80d973e0573aeaa865d6d6c8acdd7ee2b2b1ba6bb6740e734cf
+  metadata.gz: 5a8d48c078f5bf79a50fddf9b29ade13694019e8666c8c071e5b1ee7ab5b16c7e92116b794a82ce3fa6f927f0bd1186e7e87a65ed5f4eda0f1e6ed113f590de4
+  data.tar.gz: 2be66ae7ac2cb71b20486685f00552890559f2944777d8557aabb60d2318baa868c3c4bc0cf4be82a97eeee920de0049851771253129022e8fbbb0758190f917

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.
+A Ruby database ActiveRecord driver for ClickHouse. Support Rails >= 7.1.
+Support ClickHouse version from 22.0 LTS.
 
 ## Installation
 
@@ -50,41 +50,31 @@ class ActionView < ActiveRecord::Base
 end
 ```
 
-## Usage in Rails 5
+## Usage in Rails
 
 Add your `database.yml` connection information with postfix `_clickhouse` for you environment:
 
 ```yml
-development_clickhouse:
+development:
   adapter: clickhouse
   database: database
 ```
 
-Add to your model:
+Your model example:
 
 ```ruby
 class Action < ActiveRecord::Base
-  establish_connection "#{Rails.env}_clickhouse".to_sym
 end
 ```
 
 For materialized view model add:
 ```ruby
 class ActionView < ActiveRecord::Base
-  establish_connection "#{Rails.env}_clickhouse".to_sym
   self.is_view = true
 end
 ```
 
-Or global connection:
-
-```yml
-development:
-  adapter: clickhouse
-  database: database
-```
-
-## Usage in Rails 6 with second database
+## Usage in Rails with second database
 
 Add your `database.yml` connection information for you environment:
 
@@ -102,31 +92,31 @@ Connection [Multiple Databases with Active Record](https://guides.rubyonrails.or
 
 ```ruby
 class Action < ActiveRecord::Base
-  connects_to database: { writing: :clickhouse, reading: :clickhouse }
+  establish_connection :clickhouse
 end
 ```
 
 ### Rake tasks
 
-**Note!** For Rails 6 you can use default rake tasks if you configure `migrations_paths` in your `database.yml`, for example: `rake db:migrate`
-
 Create / drop / purge / reset database:
  
-    $ rake clickhouse:create
-    $ rake clickhouse:drop
-    $ rake clickhouse:purge
-    $ rake clickhouse:reset
+    $ rake db:create
+    $ rake db:drop
+    $ rake db:purge
+    $ rake db:reset
 
-Prepare system tables for rails:
+Or with multiple databases:
 
-    $ rake clickhouse:prepare_schema_migration_table
-    $ rake clickhouse:prepare_internal_metadata_table
+    $ rake db:create:clickhouse
+    $ rake db:drop:clickhouse
+    $ rake db:purge:clickhouse
+    $ rake db:reset:clickhouse
     
 Migration:
 
     $ rails g clickhouse_migration MIGRATION_NAME COLUMNS
-    $ rake clickhouse:migrate
-    $ rake clickhouse:rollback
+    $ rake db:migrate
+    $ rake db:rollback
 
 ### Dump / Load for multiple using databases
 
@@ -165,7 +155,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 +165,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 *** >]>
 ```
 
 
@@ -183,20 +185,20 @@ ActionView.maximum(:date)
 Integer types are unsigned by default. Specify signed values with `:unsigned =>
 false`. The default integer is `UInt32`
 
-| Type (bit size)    | Range | :limit (byte size) |
-| :---        |    :----:   |          ---: |
-| Int8 | -128 to 127 | 1 | 
-| Int16 | -32768 to 32767 | 2 |
-| Int32 | -2147483648 to 2,147,483,647 | 3,4 |
-| Int64 | -9223372036854775808 to 9223372036854775807] |  5,6,7,8 |
-| Int128 | ... | 9 - 15 |
-| Int256 | ... | 16+ |
-| UInt8 | 0 to 255 | 1 |
-| UInt16 | 0 to 65,535 | 2 |
-| UInt32 | 0 to 4,294,967,295 | 3,4 |
-| UInt64 | 0 to 18446744073709551615 | 5,6,7,8 |
-| UInt256 | 0 to ... | 8+ |
-| Array | ... | ... |
+| Type (bit size) |                    Range                     | :limit (byte size) |
+|:----------------|:--------------------------------------------:|-------------------:|
+| Int8            |                 -128 to 127                  |                  1 | 
+| Int16           |               -32768 to 32767                |                  2 |
+| Int32           |         -2147483648 to 2,147,483,647         |                3,4 |
+| Int64           | -9223372036854775808 to 9223372036854775807] |            5,6,7,8 |
+| Int128          |                     ...                      |             9 - 15 |
+| Int256          |                     ...                      |                16+ |
+| UInt8           |                   0 to 255                   |                  1 |
+| UInt16          |                 0 to 65,535                  |                  2 |
+| UInt32          |              0 to 4,294,967,295              |                3,4 |
+| UInt64          |          0 to 18446744073709551615           |            5,6,7,8 |
+| UInt256         |                   0 to ...                   |                 8+ |
+| Array           |                     ...                      |                ... |
 
 Example:
 

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.1'
 
-  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/lib/active_record/connection_adapters/clickhouse/schema_creation.rb

@@ -125,7 +125,7 @@ module ActiveRecord
         end
 
         def current_database
-          if ActiveRecord::version >= Gem::Version.new('6')
+          if ActiveRecord::version >= Gem::Version.new('6.1')
             ActiveRecord::Base.connection_db_config.database
           else
             ActiveRecord::Base.connection_config[:database]

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

@@ -10,15 +10,15 @@ module ActiveRecord
           do_execute(sql, name, settings: settings)
         end
 
-        def exec_insert(sql, name, _binds, _pk = nil, _sequence_name = nil)
+        def exec_insert(sql, name, _binds, _pk = nil, _sequence_name = nil, returning: nil)
           new_sql = sql.dup.sub(/ (DEFAULT )?VALUES/, " VALUES")
           do_execute(new_sql, name, format: nil)
           true
         end
 
-        def exec_query(sql, name = nil, binds = [], prepare: false)
+        def internal_exec_query(sql, name = nil, binds = [], prepare: false, async: 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
@@ -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
@@ -127,7 +137,7 @@ module ActiveRecord
           Clickhouse::TableDefinition.new(self, table_name, **options)
         end
 
-        def new_column_from_field(table_name, field)
+        def new_column_from_field(table_name, field, _definitions)
           sql_type = field[1]
           type_metadata = fetch_type_metadata(sql_type)
           default = field[3]

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'
@@ -62,6 +63,8 @@ module ActiveRecord
 
   module ModelSchema
     module ClassMethods
+      delegate :final, :settings, to: :all
+
       def is_view
         @is_view || false
       end
@@ -69,10 +72,10 @@ 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
 
@@ -92,7 +95,7 @@ module ActiveRecord
         datetime: { name: 'DateTime' },
         datetime64: { name: 'DateTime64' },
         date: { name: 'Date' },
-        boolean: { name: 'UInt8' },
+        boolean: { name: 'Bool' },
         uuid: { name: 'UUID' },
 
         enum8: { name: 'Enum8' },
@@ -133,7 +136,11 @@ module ActiveRecord
 
       # Support SchemaMigration from v5.2.2 to v6+
       def schema_migration # :nodoc:
-        ClickhouseActiverecord::SchemaMigration
+        ClickhouseActiverecord::SchemaMigration.new(self)
+      end
+
+      def internal_metadata # :nodoc:
+        ClickhouseActiverecord::InternalMetadata.new(self)
       end
 
       def migrations_paths
@@ -141,11 +148,11 @@ module ActiveRecord
       end
 
       def migration_context # :nodoc:
-        ClickhouseActiverecord::MigrationContext.new(migrations_paths, schema_migration)
+        ClickhouseActiverecord::MigrationContext.new(migrations_paths, schema_migration, internal_metadata)
       end
 
       def arel_visitor # :nodoc:
-        ClickhouseActiverecord::Arel::Visitors::ToSql.new(self)
+        Arel::Visitors::Clickhouse.new(self)
       end
 
       def native_database_types #:nodoc:
@@ -156,66 +163,73 @@ 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
-      end
 
-      # `extract_scale` and `extract_precision` are the same as in the Rails abstract base class,
-      # except this permits a space after the comma
+        # `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
+        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
-      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)
+        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
 
-      def _quote(value)
+      # 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 quote(value)
         case value
         when Array
-          '[' + value.map { |v| _quote(v) }.join(', ') + ']'
+          '[' + value.map { |v| quote(v) }.join(', ') + ']'
         else
           super
         end
@@ -331,7 +345,13 @@ 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)

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

@@ -3,124 +3,101 @@ require 'active_record/migration'
 module ClickhouseActiverecord
 
   class SchemaMigration < ::ActiveRecord::SchemaMigration
-    class << self
+    def create_table
+      return if table_exists?
 
-      def create_table
-        return if table_exists?
+      version_options = connection.internal_string_options_for_primary_key
+      table_options = {
+        id: false, options: 'ReplacingMergeTree(ver) ORDER BY (version)', if_not_exists: true
+      }
+      full_config = connection.instance_variable_get(:@full_config) || {}
 
-        version_options = connection.internal_string_options_for_primary_key
-        table_options = {
-          id: false, options: 'ReplacingMergeTree(ver) ORDER BY (version)', if_not_exists: true
-        }
-        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)')
 
-        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.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()' }
-        end
+        distributed_suffix = "_#{full_config[:distributed_service_tables_suffix] || 'distributed'}"
       end
 
-      def all_versions
-        from("#{table_name} FINAL").where(active: 1).order(:version).pluck(:version)
+      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()' }
       end
     end
-  end
 
-  class InternalMetadata < ::ActiveRecord::InternalMetadata
-    class << self
-      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)' : '',
-          if_not_exists: true
-        }
-        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.create_table(table_name + distributed_suffix.to_s, **table_options) do |t|
-          t.string :key, **key_options
-          t.string :value
-          t.timestamps
-        end
-      end
+    def versions
+      table = arel_table.dup
+      table.final = true
+      sm = Arel::SelectManager.new(table)
+      sm.project(arel_table[primary_key])
+      sm.order(arel_table[primary_key].asc)
+      sm.where([arel_table['active'].eq(1)])
+
+      connection.select_values(sm, "#{self.class} Load")
+    end
+
+    def delete_version(version)
+      im = Arel::InsertManager.new(arel_table)
+      im.insert(arel_table[primary_key] => version.to_s, arel_table['active'] => 0)
+      connection.insert(im, "#{self.class} Create Rollback Version", primary_key, version)
     end
   end
 
-  class MigrationContext < ::ActiveRecord::MigrationContext #:nodoc:
-    attr_reader :migrations_paths, :schema_migration
+  class InternalMetadata < ::ActiveRecord::InternalMetadata
 
-    def initialize(migrations_paths, schema_migration)
-      @migrations_paths = migrations_paths
-      @schema_migration = schema_migration
-    end
+    def create_table
+      return if table_exists? || !enabled?
 
-    def up(target_version = nil)
-      selected_migrations = if block_given?
-        migrations.select { |m| yield m }
-      else
-        migrations
-      end
+      key_options = connection.internal_string_options_for_primary_key
+      table_options = {
+        id: false,
+        options: connection.adapter_name.downcase == 'clickhouse' ? 'ReplacingMergeTree(created_at) PARTITION BY key ORDER BY key' : '',
+        if_not_exists: true
+      }
+      full_config = connection.instance_variable_get(:@full_config) || {}
 
-      ClickhouseActiverecord::Migrator.new(:up, selected_migrations, schema_migration, target_version).migrate
-    end
+      if full_config[:distributed_service_tables]
+        table_options.merge!(with_distributed: table_name, sharding_key: 'cityHash64(created_at)')
 
-    def down(target_version = nil)
-      selected_migrations = if block_given?
-        migrations.select { |m| yield m }
-      else
-        migrations
+        distributed_suffix = "_#{full_config[:distributed_service_tables_suffix] || 'distributed'}"
       end
 
-      ClickhouseActiverecord::Migrator.new(:down, selected_migrations, schema_migration, target_version).migrate
-    end
-
-    def get_all_versions
-      if schema_migration.table_exists?
-        schema_migration.all_versions.map(&:to_i)
-      else
-        []
+      connection.create_table(table_name + distributed_suffix.to_s, **table_options) do |t|
+        t.string :key, **key_options
+        t.string :value
+        t.timestamps
       end
     end
 
-  end
-
-  class Migrator < ::ActiveRecord::Migrator
+    private
 
-    def initialize(direction, migrations, schema_migration, target_version = nil)
-      @direction         = direction
-      @target_version    = target_version
-      @migrated_versions = nil
-      @migrations        = migrations
-      @schema_migration  = schema_migration
+    def update_entry(key, new_value)
+      create_entry(key, new_value)
+    end
 
-      validate(@migrations)
+    def select_entry(key)
+      table = arel_table.dup
+      table.final = true
+      sm = Arel::SelectManager.new(table)
+      sm.project(Arel::Nodes::SqlLiteral.new("*"))
+      sm.where(table[primary_key].eq(Arel::Nodes::BindParam.new(key)))
+      sm.order(table[primary_key].asc)
+      sm.limit = 1
 
-      @schema_migration.create_table
-      ClickhouseActiverecord::InternalMetadata.create_table
+      connection.select_all(sm, "#{self.class} Load").first
     end
+  end
+
+  class MigrationContext < ::ActiveRecord::MigrationContext #:nodoc:
 
-    def record_version_state_after_migrating(version)
-      if down?
-        migrated.delete(version)
-        @schema_migration.create!(version: version.to_s, active: 0)
+    def get_all_versions
+      if schema_migration.table_exists?
+        schema_migration.versions.map(&:to_i)
       else
-        super
+        []
       end
     end
+
   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,7 +10,7 @@ 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::DatabaseAlreadyExists
@@ -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.15'
+  VERSION = '1.0.0'
 end

data/lib/clickhouse-activerecord.rb

@@ -4,6 +4,10 @@ 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
 
@@ -18,5 +22,9 @@ 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

@@ -10,6 +10,80 @@ module CoreExtensions
         self.order_values = (column_names & %w[date created_at]).map { |c| arel_table[c].desc }
         self
       end
+
+      # Define settings in the SETTINGS clause of the SELECT query. The setting value is applied only to that query and is reset to the default or previous value after the query is executed.
+      # For example:
+      #
+      #   users = User.settings(optimize_read_in_order: 1, cast_keep_nullable: 1).where(name: 'John')
+      #   # SELECT users.* FROM users WHERE users.name = 'John' SETTINGS optimize_read_in_order = 1, cast_keep_nullable = 1
+      #
+      # An <tt>ActiveRecord::ActiveRecordError</tt> will be raised if database not ClickHouse.
+      # @param [Hash] opts
+      def settings(**opts)
+        spawn.settings!(**opts)
+      end
+
+      # @param [Hash] opts
+      def settings!(**opts)
+        assert_mutability!
+        check_command('SETTINGS')
+        @values[:settings] = (@values[:settings] || {}).merge opts
+        self
+      end
+
+      # When FINAL is specified, ClickHouse fully merges the data before returning the result and thus performs all data transformations that happen during merges for the given table engine.
+      # For example:
+      #
+      #   users = User.final.all
+      #   # SELECT users.* FROM users FINAL
+      #
+      # An <tt>ActiveRecord::ActiveRecordError</tt> will be raised if database not ClickHouse.
+      # @param [Boolean] final
+      def final(final = true)
+        spawn.final!(final)
+      end
+
+      # @param [Boolean] final
+      def final!(final = true)
+        assert_mutability!
+        check_command('FINAL')
+        @table = @table.dup
+        @table.final = final
+        self
+      end
+
+      # The USING clause specifies one or more columns to join, which establishes the equality of these columns. For example:
+      #
+      #   users = User.joins(:joins).using(:event_name, :date)
+      #   # SELECT users.* FROM users INNER JOIN joins USING event_name,date
+      #
+      # An <tt>ActiveRecord::ActiveRecordError</tt> will be raised if database not ClickHouse.
+      # @param [Array] opts
+      def using(*opts)
+        spawn.using!(*opts)
+      end
+
+      # @param [Array] opts
+      def using!(*opts)
+        assert_mutability!
+        @values[:using] = opts
+        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.using(@values[:using]) if @values[:using].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,86 +1,87 @@
 # 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?
+    connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection
+    connection.schema_migration.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?
-  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")
+    connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection
+    connection.internal_metadata.create_table unless ENV['simple'] || ARGV.any? { |a| a.include?('--simple') }
   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")
+    task load: ['db:check_protected_environments'] do
+      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")
+    task dump: ['db:check_protected_environments'] do
+      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"])
+  task create: [] do
+    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"])
+  task drop: ['db:check_protected_environments'] do
+    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"])
+  task purge: ['db:check_protected_environments'] do
+    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'
-  task reset: :load_config do
+  task :reset  do
     Rake::Task['clickhouse:purge'].execute
     Rake::Task['clickhouse:migrate'].execute
   end
 
   desc 'Migrate the clickhouse database'
-  task migrate: [:load_config, :prepare_schema_migration_table, :prepare_internal_metadata_table] do
-    Rake::Task['db:migrate'].execute
+  task migrate: %i[prepare_schema_migration_table prepare_internal_metadata_table] do
+    Rake::Task['db:migrate:clickhouse'].execute
     if File.exists? "#{Rails.root}/db/clickhouse_schema_simple.rb"
       Rake::Task['clickhouse:schema:dump'].execute(simple: true)
     end
   end
 
   desc 'Rollback the clickhouse database'
-  task rollback: [:load_config, :prepare_schema_migration_table, :prepare_internal_metadata_table] do
-    Rake::Task['db:rollback'].execute
+  task rollback: %i[prepare_schema_migration_table prepare_internal_metadata_table] do
+    Rake::Task['db:rollback:clickhouse'].execute
+    if File.exists? "#{Rails.root}/db/clickhouse_schema_simple.rb"
+      Rake::Task['clickhouse:schema:dump'].execute(simple: true)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.5.15
+  version: 1.0.0
 platform: ruby
 authors:
 - Sergey Odintsov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-21 00:00:00.000000000 Z
+date: 2023-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,28 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '7.1'
   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
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -121,9 +107,10 @@ 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
@@ -131,6 +118,9 @@ files:
 - 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
@@ -152,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: ClickHouse ActiveRecord

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