clickhouse-activerecord 1.0.5 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2217c1539b22307398fbc9c01bb8b521300ca23a7d03c2d32a56a9abdd3c5546
-  data.tar.gz: 8aa60f1a78db38df4120b0b405ddaf9466da70e68bf382f58945b29d5e130b7b
+  metadata.gz: 01f256bfb493f9961b3c0268d7f71009468b7b28c00deba7901d064f74b91c5c
+  data.tar.gz: 13b366b2264636610baa3bde60b9c82930c80b13201ac41724d37d4430fa60dd
 SHA512:
-  metadata.gz: d1e48e302475eff9ca738b35fc56b58a7a73f7d6b6cf5ae6632a7ee95fbc9432734ba18c53f7756d833ebd3748368fd73f7c29e04a0972f3141d00b5acd262cd
-  data.tar.gz: acedbb7298cd044769a5a1deaaae44672bdbf1affca5d2218e8b7209731df505434ed4f69bb23881e0d4f231e9e6699ac621ab0b4ac19f86475dd6c6515b3e18
+  metadata.gz: 75bafd27ee374a30f8a519937591254f2f316e3bf477b6298da709652064853cc491f454950fefc1558e66b170c4773b167d1988aaa9dd38b583d79ba60b3c4d
+  data.tar.gz: 23709bae8fdf85dda4be2f70d41016be9e8cc10ba503ffc73dcc42e69ca0573f792f4635fa7d1b476b74e394ba1dd2f4fc6774c42d96821c13b55f798094666e

data/.docker/docker-compose.cluster.yml

@@ -15,6 +15,9 @@ services:
     volumes:
       - './clickhouse/cluster/server1_config.xml:/etc/clickhouse-server/config.xml'
       - './clickhouse/users.xml:/etc/clickhouse-server/users.xml'
+    healthcheck:
+      test: bash -c "exec 6<> /dev/tcp/localhost/8123"
+      interval: 5s
 
   clickhouse2:
     image: 'clickhouse/clickhouse-server:${CLICKHOUSE_VERSION-23.11-alpine}'
@@ -29,6 +32,9 @@ services:
     volumes:
       - './clickhouse/cluster/server2_config.xml:/etc/clickhouse-server/config.xml'
       - './clickhouse/users.xml:/etc/clickhouse-server/users.xml'
+    healthcheck:
+      test: bash -c "exec 6<> /dev/tcp/localhost/8123"
+      interval: 5s
 
   # Using Nginx as a cluster entrypoint and a round-robin load balancer for HTTP requests
   nginx:
@@ -39,3 +45,8 @@ services:
     volumes:
       - './nginx/local.conf:/etc/nginx/conf.d/local.conf'
     container_name: clickhouse-activerecord-nginx
+    depends_on:
+      clickhouse1:
+        condition: service_healthy
+      clickhouse2:
+        condition: service_healthy

data/.docker/docker-compose.yml

@@ -12,3 +12,6 @@ services:
     volumes:
       - './clickhouse/single/config.xml:/etc/clickhouse-server/config.xml'
       - './clickhouse/users.xml:/etc/clickhouse-server/users.xml'
+    healthcheck:
+      test: bash -c "exec 6<> /dev/tcp/localhost/8123"
+      interval: 5s

data/README.md

@@ -203,7 +203,7 @@ false`. The default integer is `UInt32`
 Example:
 
 ``` ruby
-class CreateDataItems < ActiveRecord::Migration
+class CreateDataItems < ActiveRecord::Migration[7.1]
   def change
     create_table "data_items", id: false, options: "VersionedCollapsingMergeTree(sign, version) PARTITION BY toYYYYMM(day) ORDER BY category", force: :cascade do |t|
       t.date "day", null: false
@@ -212,9 +212,32 @@ class CreateDataItems < ActiveRecord::Migration
       t.integer "sign", limit: 1, unsigned: false, default: -> { "CAST(1, 'Int8')" }, null: false
       t.integer "version", limit: 8, default: -> { "CAST(toUnixTimestamp(now()), 'UInt64')" }, null: false
     end
+    
+    create_table "with_index", id: false, options: 'MergeTree PARTITION BY toYYYYMM(date) ORDER BY (date)' do |t|
+      t.integer :int1, null: false
+      t.integer :int2, null: false
+      t.date :date, null: false
+
+      t.index '(int1 * int2, date)', name: 'idx', type: 'minmax', granularity: 3
+    end
+    
+    remove_index :some, 'idx'
+    
+    add_index :some, 'int1 * int2', name: 'idx2', type: 'set(10)', granularity: 4
+  end
+end
+```
+
+Create table with custom column structure:
+
+``` ruby
+class CreateDataItems < ActiveRecord::Migration
+  def change
+    create_table "data_items", id: false, options: "MergeTree PARTITION BY toYYYYMM(timestamp) ORDER BY timestamp", force: :cascade do |t|
+      t.column "timestamp", "DateTime('UTC') CODEC(DoubleDelta, LZ4)"
+    end
   end
 end
-      
 ```
 
 
@@ -246,6 +269,12 @@ After checking out the repo, run `bin/setup` to install dependencies. You can al
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+Testing github actions:
+
+```bash
+act
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at [https://github.com/pnixx/clickhouse-activerecord](https://github.com/pnixx/clickhouse-activerecord). This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

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

@@ -6,6 +6,7 @@ module ActiveRecord
       module OID # :nodoc:
         class Uuid < Type::Value # :nodoc:
           ACCEPTABLE_UUID = %r{\A(\{)?([a-fA-F0-9]{4}-?){8}(?(1)\}|)\z}
+          CANONICAL_UUID = %r{\A[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}\z}
 
           alias :serialize :deserialize
 
@@ -13,23 +14,32 @@ module ActiveRecord
             :uuid
           end
 
-          def changed?(old_value, new_value, _)
+          def changed?(old_value, new_value, _new_value_before_type_cast)
             old_value.class != new_value.class ||
-              new_value && old_value.casecmp(new_value) != 0
+              new_value != old_value
           end
 
           def changed_in_place?(raw_old_value, new_value)
             raw_old_value.class != new_value.class ||
-              new_value && raw_old_value.casecmp(new_value) != 0
+              new_value != raw_old_value
           end
 
           private
 
           def cast_value(value)
-            casted = value.to_s
-            casted if casted.match?(ACCEPTABLE_UUID)
+            value = value.to_s
+            format_uuid(value) if value.match?(ACCEPTABLE_UUID)
           end
-        end
+
+          def format_uuid(uuid)
+            if uuid.match?(CANONICAL_UUID)
+              uuid
+            else
+              uuid = uuid.delete("{}-").downcase
+              "#{uuid[..7]}-#{uuid[8..11]}-#{uuid[12..15]}-#{uuid[16..19]}-#{uuid[20..]}"
+            end
+          end
+        end        
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 begin
   require "active_record/connection_adapters/deduplicable"
 rescue LoadError => e
@@ -93,6 +92,14 @@ module ActiveRecord
 
           statements = o.columns.map { |c| accept c }
           statements << accept(o.primary_keys) if o.primary_keys
+
+          if supports_indexes_in_create?
+            indexes = o.indexes.map do |expression, options|
+              accept(@conn.add_index_options(o.name, expression, **options))
+            end
+            statements.concat(indexes)
+          end
+
           create_sql << "(#{statements.join(', ')})" if statements.present?
           # Attach options for only table or materialized view without TO section
           add_table_options!(create_sql, o) if !o.view || o.view && o.materialized && !o.to
@@ -108,7 +115,7 @@ module ActiveRecord
 
         def visit_ChangeColumnDefinition(o)
           column = o.column
-          column.sql_type = type_to_sql(column.type, column.options)
+          column.sql_type = type_to_sql(column.type, **column.options)
           options = column_options(column)
 
           quoted_column_name = quote_column_name(o.name)
@@ -124,6 +131,23 @@ module ActiveRecord
           change_column_sql
         end
 
+        def visit_IndexDefinition(o, create = false)
+          sql = create ? ["ALTER TABLE #{quote_table_name(o.table)} ADD"] : []
+          sql << "INDEX"
+          sql << "IF NOT EXISTS" if o.if_not_exists
+          sql << "IF EXISTS" if o.if_exists
+          sql << "#{quote_column_name(o.name)} (#{o.expression}) TYPE #{o.type}"
+          sql << "GRANULARITY #{o.granularity}" if o.granularity
+          sql << "FIRST #{quote_column_name(o.first)}" if o.first
+          sql << "AFTER #{quote_column_name(o.after)}" if o.after
+
+          sql.join(' ')
+        end
+
+        def visit_CreateIndexDefinition(o)
+          visit_IndexDefinition(o.index, true)
+        end
+
         def current_database
           ActiveRecord::Base.connection_db_config.database
         end

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

@@ -94,6 +94,23 @@ module ActiveRecord
           args.each { |name| column(name, kind, **options.except(:limit)) }
         end
       end
+
+      class IndexDefinition
+        attr_reader :table, :name, :expression, :type, :granularity, :first, :after, :if_exists, :if_not_exists
+
+        def initialize(table, name, expression, type, granularity, first:, after:, if_exists:, if_not_exists:)
+          @table = table
+          @name = name
+          @expression = expression
+          @type = type
+          @granularity = granularity
+          @first = first
+          @after = after
+          @if_exists = if_exists
+          @if_not_exists = if_not_exists
+        end
+
+      end
     end
   end
 end

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

@@ -57,6 +57,16 @@ module ActiveRecord
           result['data'].flatten
         end
 
+        def functions
+          result = do_system_execute("SELECT name FROM system.functions WHERE origin = 'SQLUserDefined'")
+          return [] if result.nil?
+          result['data'].flatten
+        end
+
+        def show_create_function(function)
+          do_execute("SELECT create_query FROM system.functions WHERE origin = 'SQLUserDefined' AND name = '#{function}'", format: nil)
+        end
+
         def table_options(table)
           sql = show_create_table(table)
           { options: sql.gsub(/^(?:.*?)(?:ENGINE = (.*?))?( AS SELECT .*?)?$/, '\\1').presence, as: sql.match(/^CREATE (?:.*?) AS (SELECT .*?)$/).try(:[], 1) }.compact
@@ -67,6 +77,14 @@ module ActiveRecord
           []
         end
 
+        def add_index_options(table_name, expression, **options)
+          options.assert_valid_keys(:name, :type, :granularity, :first, :after, :if_not_exists, :if_exists)
+
+          validate_index_length!(table_name, options[:name])
+
+          IndexDefinition.new(table_name, options[:name], expression, options[:type], options[:granularity], first: options[:first], after: options[:after], if_not_exists: options[:if_not_exists], if_exists: options[:if_exists])
+        end
+
         def data_sources
           tables
         end
@@ -74,14 +92,14 @@ module ActiveRecord
         def do_system_execute(sql, name = nil)
           log_with_debug(sql, "#{adapter_name} #{name}") do
             res = request(sql, DEFAULT_RESPONSE_FORMAT)
-            process_response(res, DEFAULT_RESPONSE_FORMAT)
+            process_response(res, DEFAULT_RESPONSE_FORMAT, sql)
           end
         end
 
         def do_execute(sql, name = nil, format: DEFAULT_RESPONSE_FORMAT, settings: {})
           log(sql, "#{adapter_name} #{name}") do
             res = request(sql, format, settings)
-            process_response(res, format)
+            process_response(res, format, sql)
           end
         end
 
@@ -132,11 +150,11 @@ module ActiveRecord
           format ? "#{sql} FORMAT #{format}" : sql
         end
 
-        def process_response(res, format)
+        def process_response(res, format, sql = nil)
           case res.code.to_i
           when 200
             if res.body.to_s.include?("DB::Exception")
-              raise ActiveRecord::ActiveRecordError, "Response code: #{res.code}:\n#{res.body}"
+              raise ActiveRecord::ActiveRecordError, "Response code: #{res.code}:\n#{res.body}#{sql ? "\nQuery: #{sql}" : ''}"
             else
               format_body_response(res.body, format)
             end
@@ -233,11 +251,11 @@ module ActiveRecord
         end
 
         def format_from_json_compact(body)
-          JSON.parse(body)
+          parse_json_payload(body)
         end
 
         def format_from_json_compact_each_row_with_names_and_types(body)
-          rows = body.split("\n").map { |row| JSON.parse(row) }
+          rows = body.split("\n").map { |row| parse_json_payload(row) }
           names, types, *data = rows
 
           meta = names.zip(types).map do |name, type|
@@ -252,6 +270,10 @@ module ActiveRecord
             'data' => data
           }
         end
+
+        def parse_json_payload(payload)
+          JSON.parse(payload, decimal_class: BigDecimal)
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/clickhouse_adapter.rb

@@ -149,6 +149,10 @@ module ActiveRecord
         !native_database_types[type].nil?
       end
 
+      def supports_indexes_in_create?
+        true
+      end
+
       class << self
         def extract_limit(sql_type) # :nodoc:
           case sql_type
@@ -308,6 +312,11 @@ module ActiveRecord
         end
       end
 
+      def create_function(name, body)
+        fd = "CREATE FUNCTION #{apply_cluster(quote_table_name(name))} AS #{body}"
+        do_execute(fd, format: nil)
+      end
+
       # Drops a ClickHouse database.
       def drop_database(name) #:nodoc:
         sql = apply_cluster "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
@@ -317,6 +326,12 @@ module ActiveRecord
         end
       end
 
+      def drop_functions
+        functions.each do |function|
+          drop_function(function)
+        end
+      end
+
       def rename_table(table_name, new_name)
         do_execute apply_cluster "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
       end
@@ -336,6 +351,16 @@ module ActiveRecord
         end
       end
 
+      def drop_function(name, options = {})
+        query = "DROP FUNCTION"
+        query = "#{query} IF EXISTS " if options[:if_exists]
+        query = "#{query} #{quote_table_name(name)}"
+        query = apply_cluster(query)
+        query = "#{query} SYNC" if options[:sync]
+
+        do_execute(query, format: nil)
+      end
+
       def add_column(table_name, column_name, type, **options)
         return if options[:if_not_exists] == true && column_exists?(table_name, column_name, type)
 
@@ -350,8 +375,8 @@ module ActiveRecord
         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)}", nil, settings: {wait_end_of_query: 1, send_progress_in_http_headers: 1})
+      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)}", 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
 
@@ -365,6 +390,39 @@ module ActiveRecord
         change_column table_name, column_name, nil, {default: default}.compact
       end
 
+      # Adds index description to tables metadata
+      # @link https://clickhouse.com/docs/en/sql-reference/statements/alter/skipping-index
+      def add_index(table_name, expression, **options)
+        index = add_index_options(apply_cluster(table_name), expression, **options)
+        execute schema_creation.accept(CreateIndexDefinition.new(index))
+      end
+
+      # Removes index description from tables metadata and deletes index files from disk
+      def remove_index(table_name, name)
+        query = apply_cluster("ALTER TABLE #{quote_table_name(table_name)}")
+        execute "#{query} DROP INDEX #{quote_column_name(name)}"
+      end
+
+      # Rebuilds the secondary index name for the specified partition_name
+      def rebuild_index(table_name, name, if_exists: false, partition: nil)
+        query = [apply_cluster("ALTER TABLE #{quote_table_name(table_name)}")]
+        query << 'MATERIALIZE INDEX'
+        query << 'IF EXISTS' if if_exists
+        query << quote_column_name(name)
+        query << "IN PARTITION #{quote_column_name(partition)}" if partition
+        execute query.join(' ')
+      end
+
+      # Deletes the secondary index files from disk without removing description
+      def clear_index(table_name, name, if_exists: false, partition: nil)
+        query = [apply_cluster("ALTER TABLE #{quote_table_name(table_name)}")]
+        query << 'CLEAR INDEX'
+        query << 'IF EXISTS' if if_exists
+        query << quote_column_name(name)
+        query << "IN PARTITION #{quote_column_name(partition)}" if partition
+        execute query.join(' ')
+      end
+
       def cluster
         @config[:cluster_name]
       end
@@ -420,9 +478,9 @@ module ActiveRecord
         result
       end
 
-      def change_column_for_alter(table_name, column_name, type, options = {})
+      def change_column_for_alter(table_name, column_name, type, **options)
         td = create_table_definition(table_name)
-        cd = td.new_column_definition(column_name, type, options)
+        cd = td.new_column_definition(column_name, type, **options)
         schema_creation.accept(ChangeColumnDefinition.new(cd, column_name))
       end
 

data/lib/clickhouse-activerecord/schema_dumper.rb

@@ -34,8 +34,12 @@ HEADER
     end
 
     def tables(stream)
-      sorted_tables = @connection.tables.sort {|a,b| @connection.show_create_table(a).match(/^CREATE\s+(MATERIALIZED\s+)?VIEW/) ? 1 : a <=> b }
+      functions = @connection.functions
+      functions.each do |function|
+        function(function, stream)
+      end
 
+      sorted_tables = @connection.tables.sort {|a,b| @connection.show_create_table(a).match(/^CREATE\s+(MATERIALIZED\s+)?VIEW/) ? 1 : a <=> b }
       sorted_tables.each do |table_name|
         table(table_name, stream) unless ignored?(table_name)
       end
@@ -104,7 +108,13 @@ HEADER
             end
           end
 
-          indexes_in_create(table, tbl)
+          indexes = sql.scan(/INDEX \S+ \S+ TYPE .*? GRANULARITY \d+/)
+          if indexes.any?
+            tbl.puts ''
+            indexes.flatten.map!(&:strip).each do |index|
+              tbl.puts "    t.index #{index_parts(index).join(', ')}"
+            end
+          end
 
           tbl.puts "  end"
           tbl.puts
@@ -119,6 +129,13 @@ HEADER
       end
     end
 
+    def function(function, stream)
+      stream.puts "  # FUNCTION: #{function}"
+      sql = @connection.show_create_function(function)
+      stream.puts "  # SQL: #{sql}" if sql
+      stream.puts "  create_function \"#{function}\", \"#{sql.gsub(/^CREATE FUNCTION (.*?) AS/, '').strip}\"" if sql
+    end
+
     def format_options(options)
       if options && options[:options]
         options[:options] = options[:options].gsub(/^Replicated(.*?)\('[^']+',\s*'[^']+',?\s?([^\)]*)?\)/, "\\1(\\2)")
@@ -154,5 +171,16 @@ HEADER
       spec[:array] = schema_array(column)
       spec.merge(super).compact
     end
+
+    def index_parts(index)
+      idx = index.match(/^INDEX (?<name>\S+) (?<expr>.*?) TYPE (?<type>.*?) GRANULARITY (?<granularity>\d+)$/)
+      index_parts = [
+        format_index_parts(idx['expr']),
+        "name: #{format_index_parts(idx['name'])}",
+        "type: #{format_index_parts(idx['type'])}",
+      ]
+      index_parts << "granularity: #{idx['granularity']}" if idx['granularity']
+      index_parts
+    end
   end
 end

data/lib/clickhouse-activerecord/tasks.rb

@@ -5,12 +5,12 @@ module ClickhouseActiverecord
     delegate :connection, :establish_connection, to: ActiveRecord::Base
 
     def initialize(configuration)
-      @configuration = configuration.with_indifferent_access
+      @configuration = configuration
     end
 
     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
@@ -21,7 +21,7 @@ module ClickhouseActiverecord
 
     def drop
       establish_master_connection
-      connection.drop_database @configuration['database']
+      connection.drop_database @configuration.database
     end
 
     def purge
@@ -31,12 +31,28 @@ module ClickhouseActiverecord
     end
 
     def structure_dump(*args)
-      tables = connection.execute("SHOW TABLES FROM #{@configuration['database']}")['data'].flatten
+      establish_master_connection
+
+      # get all tables
+      tables = connection.execute("SHOW TABLES FROM #{@configuration.database} WHERE name NOT LIKE '.inner_id.%'")['data'].flatten.map do |table|
+        next if %w[schema_migrations ar_internal_metadata].include?(table)
+        connection.show_create_table(table).gsub("#{@configuration.database}.", '')
+      end.compact
+
+      # sort view to last
+      tables.sort_by! {|table| table.match(/^CREATE\s+(MATERIALIZED\s+)?VIEW/) ? 1 : 0}
 
+      # get all functions
+      functions = connection.execute("SELECT create_query FROM system.functions WHERE origin = 'SQLUserDefined'")['data'].flatten
+
+      # put to file
       File.open(args.first, 'w:utf-8') do |file|
+        functions.each do |function|
+          file.puts function + ";\n\n"
+        end
+        
         tables.each do |table|
-          next if table.match(/\.inner/)
-          file.puts connection.execute("SHOW CREATE TABLE #{table}")['data'].try(:first).try(:first).gsub("#{@configuration['database']}.", '') + ";\n\n"
+          file.puts table + ";\n\n"
         end
       end
     end

data/lib/clickhouse-activerecord/version.rb

@@ -1,3 +1,3 @@
 module ClickhouseActiverecord
-  VERSION = '1.0.5'
+  VERSION = '1.0.6'
 end

data/lib/clickhouse-activerecord.rb

@@ -5,15 +5,12 @@ require 'active_record/connection_adapters/clickhouse_adapter'
 require 'core_extensions/active_record/internal_metadata'
 require 'core_extensions/active_record/relation'
 require 'core_extensions/active_record/schema_migration'
-
+require 'core_extensions/active_record/migration/command_recorder'
 require 'core_extensions/arel/nodes/select_core'
 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
-
 if defined?(Rails::Railtie)
   require 'clickhouse-activerecord/railtie'
   require 'clickhouse-activerecord/schema'
@@ -24,9 +21,10 @@ end
 
 module ClickhouseActiverecord
   def self.load
-    ActiveRecord::InternalMetadata.prepend(CoreExtensions::ActiveRecord::InternalMetadata::ClassMethods)
+    ActiveRecord::InternalMetadata.prepend(CoreExtensions::ActiveRecord::InternalMetadata)
+    ActiveRecord::Migration::CommandRecorder.include(CoreExtensions::ActiveRecord::Migration::CommandRecorder)
     ActiveRecord::Relation.prepend(CoreExtensions::ActiveRecord::Relation)
-    ActiveRecord::SchemaMigration.prepend(CoreExtensions::ActiveRecord::SchemaMigration::ClassMethods)
+    ActiveRecord::SchemaMigration.prepend(CoreExtensions::ActiveRecord::SchemaMigration)
 
     Arel::Nodes::SelectCore.prepend(CoreExtensions::Arel::Nodes::SelectCore)
     Arel::Nodes::SelectStatement.prepend(CoreExtensions::Arel::Nodes::SelectStatement)

data/lib/core_extensions/active_record/internal_metadata.rb

@@ -1,55 +1,53 @@
 module CoreExtensions
   module ActiveRecord
     module InternalMetadata
-      module ClassMethods
-
-        def create_table
-          return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
-          return if table_exists? || !enabled?
-
-          key_options = connection.internal_string_options_for_primary_key
-          table_options = {
-            id: false,
-            options: 'ReplacingMergeTree(created_at) PARTITION BY key ORDER BY key',
-            if_not_exists: true
-          }
-          full_config = connection.instance_variable_get(:@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'}"
-          else
-            distributed_suffix = ''
-          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
 
-        private
+      def create_table
+        return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+        return if table_exists? || !enabled?
+
+        key_options = connection.internal_string_options_for_primary_key
+        table_options = {
+          id: false,
+          options: 'ReplacingMergeTree(created_at) PARTITION BY key ORDER BY key',
+          if_not_exists: true
+        }
+        full_config = connection.instance_variable_get(:@config) || {}
 
-        def update_entry(key, new_value)
-          return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+        if full_config[:distributed_service_tables]
+          table_options.merge!(with_distributed: table_name, sharding_key: 'cityHash64(created_at)')
 
-          create_entry(key, new_value)
+          distributed_suffix = "_#{full_config[:distributed_service_tables_suffix] || 'distributed'}"
+        else
+          distributed_suffix = ''
         end
 
-        def select_entry(key)
-          return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+        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
 
-          sm = ::Arel::SelectManager.new(arel_table)
-          sm.final! if connection.table_options(table_name)[:options] =~ /^ReplacingMergeTree/
-          sm.project(::Arel.star)
-          sm.where(arel_table[primary_key].eq(::Arel::Nodes::BindParam.new(key)))
-          sm.order(arel_table[primary_key].asc)
-          sm.limit = 1
+      private
 
-          connection.select_one(sm, "#{self.class} Load")
-        end
+      def update_entry(key, new_value)
+        return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+
+        create_entry(key, new_value)
+      end
+
+      def select_entry(key)
+        return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+
+        sm = ::Arel::SelectManager.new(arel_table)
+        sm.final! if connection.table_options(table_name)[:options] =~ /^ReplacingMergeTree/
+        sm.project(::Arel.star)
+        sm.where(arel_table[primary_key].eq(::Arel::Nodes::BindParam.new(key)))
+        sm.order(arel_table[primary_key].asc)
+        sm.limit = 1
+
+        connection.select_one(sm, "#{self.class} Load")
       end
     end
   end

data/lib/core_extensions/active_record/schema_migration.rb

@@ -1,47 +1,45 @@
 module CoreExtensions
   module ActiveRecord
     module SchemaMigration
-      module ClassMethods
 
-        def create_table
-          return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+      def create_table
+        return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
 
-          return if table_exists?
+        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(:@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(:@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'}"
-          else
-            distributed_suffix = ''
-          end
+          distributed_suffix = "_#{full_config[:distributed_service_tables_suffix] || 'distributed'}"
+        else
+          distributed_suffix = ''
+        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
+        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
 
-        def delete_version(version)
-          return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+      def delete_version(version)
+        return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
 
-          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
+        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
 
-        def all_versions
-          return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
+      def all_versions
+        return super unless connection.is_a?(::ActiveRecord::ConnectionAdapters::ClickhouseAdapter)
 
-          final.where(active: 1).order(:version).pluck(:version)
-        end
+        final.where(active: 1).order(:version).pluck(:version)
       end
     end
   end

data/lib/tasks/clickhouse.rake

@@ -15,15 +15,18 @@ namespace :clickhouse do
     # TODO: deprecated
     desc 'Load database schema'
     task load: %i[prepare_internal_metadata_table] do
+      puts 'Warning: `rake clickhouse:schema:load` is deprecated! Use `rake db:schema:load:clickhouse` instead'
       simple = ENV['simple'] || ARGV.any? { |a| a.include?('--simple') } ? '_simple' : nil
       ActiveRecord::Base.establish_connection(:clickhouse)
-      ActiveRecord::SchemaMigration.drop_table
+      connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection
+      connection.schema_migration.drop_table
       load(Rails.root.join("db/clickhouse_schema#{simple}.rb"))
     end
 
     # TODO: deprecated
     desc 'Dump database schema'
     task dump: :environment do |_, args|
+      puts 'Warning: `rake clickhouse:schema:dump` is deprecated! Use `rake db:schema:dump:clickhouse` instead'
       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|
@@ -36,43 +39,38 @@ namespace :clickhouse do
   namespace :structure do
     desc 'Load database structure'
     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: ['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: [] do
-    config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'clickhouse')
-    ActiveRecord::Tasks::DatabaseTasks.create(config)
+    puts 'Warning: `rake clickhouse:create` is deprecated! Use `rake db:create:clickhouse` instead'
   end
 
   desc 'Drops the database from DATABASE_URL or config/database.yml'
   task drop: ['db:check_protected_environments'] do
-    config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'clickhouse')
-    ActiveRecord::Tasks::DatabaseTasks.drop(config)
+    puts 'Warning: `rake clickhouse:drop` is deprecated! Use `rake db:drop:clickhouse` instead'
   end
 
   desc 'Empty the database from DATABASE_URL or config/database.yml'
   task purge: ['db:check_protected_environments'] do
-    config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'clickhouse')
-    ActiveRecord::Tasks::DatabaseTasks.purge(config)
+    puts 'Warning: `rake clickhouse:purge` is deprecated! Use `rake db:reset:clickhouse` instead'
   end
 
   # desc 'Resets your database using your migrations for the current environment'
   task :reset  do
-    Rake::Task['clickhouse:purge'].execute
-    Rake::Task['clickhouse:migrate'].execute
+    puts 'Warning: `rake clickhouse:reset` is deprecated! Use `rake db:reset:clickhouse` instead'
   end
 
   desc 'Migrate the clickhouse database'
   task migrate: %i[prepare_schema_migration_table prepare_internal_metadata_table] do
+    puts 'Warning: `rake clickhouse:migrate` is deprecated! Use `rake db:migrate:clickhouse` instead'
     Rake::Task['db:migrate:clickhouse'].execute
     if File.exist? "#{Rails.root}/db/clickhouse_schema_simple.rb"
       Rake::Task['clickhouse:schema:dump'].execute(simple: true)
@@ -81,9 +79,14 @@ namespace :clickhouse do
 
   desc 'Rollback the clickhouse database'
   task rollback: %i[prepare_schema_migration_table prepare_internal_metadata_table] do
+    puts 'Warning: `rake clickhouse:rollback` is deprecated! Use `rake db:rollback:clickhouse` instead'
     Rake::Task['db:rollback:clickhouse'].execute
     if File.exist? "#{Rails.root}/db/clickhouse_schema_simple.rb"
       Rake::Task['clickhouse:schema:dump'].execute(simple: true)
     end
   end
+
+  def config
+    ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: 'clickhouse')
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-activerecord
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
 platform: ruby
 authors:
 - Sergey Odintsov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-14 00:00:00.000000000 Z
+date: 2024-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -106,7 +106,6 @@ files:
 - bin/console
 - bin/setup
 - clickhouse-activerecord.gemspec
-- core_extensions/active_record/migration/command_recorder.rb
 - lib/active_record/connection_adapters/clickhouse/oid/array.rb
 - lib/active_record/connection_adapters/clickhouse/oid/big_integer.rb
 - lib/active_record/connection_adapters/clickhouse/oid/date.rb
@@ -127,6 +126,7 @@ files:
 - lib/clickhouse-activerecord/tasks.rb
 - lib/clickhouse-activerecord/version.rb
 - lib/core_extensions/active_record/internal_metadata.rb
+- lib/core_extensions/active_record/migration/command_recorder.rb
 - lib/core_extensions/active_record/relation.rb
 - lib/core_extensions/active_record/schema_migration.rb
 - lib/core_extensions/arel/nodes/select_core.rb
@@ -154,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: ClickHouse ActiveRecord