clickhouse-activerecord 1.1.3 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 419c50a4b99b183f729939034e8f6b671bf899fb0ef93fc97f105798fa437aa1
-  data.tar.gz: 7508a2ed443d64565ca6b1f5af48bf076cf40d2eae91fd3c3187cae05371a864
+  metadata.gz: b40a04fe93423fd3469b65a66429ecb41e4c5c25440777c69617e69081e578b4
+  data.tar.gz: 43586cb853dec4d3453a6b6938158e5f1197504678c2e1aa824b8521a6a1c628
 SHA512:
-  metadata.gz: 8e8607fa219f6e17e22a3029ba564e6d3d6d2bd39cf86f639d277a6e83fe2ffb1a47e93fceb8d20c4de6a7e9679f8a15b40ee744bfa445be14e6e0693dde4a0e
-  data.tar.gz: 5e58b79aab91a64387dc74821a75710c70738791227084a3a6ce29e72827a40e0458d48643a99c14b6d2dc6c94bbed8672d31051d7501084aa3a7e0bc27ef6a1
+  metadata.gz: 38073e81994dd027caf7fab5463a715eac7f15ec8373c1415d0064611118b0f2b0c391cae0db9b7670ebb8a3141c023879b3d1425c7059f4c00450579bcff64c
+  data.tar.gz: 0ce78412004ae3590bc97877141e66f74f9de1ad0aab2cdc1af5a3369157c01e0e29fe10b4921c96487cad66fa16e50163f9c34941381357f1960cc3c7f20fbc

data/.github/workflows/testing.yml

@@ -27,7 +27,7 @@ jobs:
           - ruby: 3.2
             rails: 7.1.3
           - ruby: 3.2
-            rails: 7.2.0
+            rails: 7.2.1
         clickhouse: [ '22.1', '24.6' ]
 
     steps:
@@ -49,7 +49,7 @@ jobs:
           ruby-version: ${{ matrix.version.ruby }}
           bundler-cache: true
 
-      - run: bundle exec rspec spec/single
+      - run: bundle exec rspec spec/single --format progress
 
   tests_cluster:
     name: Testing cluster server
@@ -94,4 +94,4 @@ jobs:
           ruby-version: ${{ matrix.version.ruby }}
           bundler-cache: true
 
-      - run: bundle exec rspec spec/cluster
+      - run: bundle exec rspec spec/cluster --format progress

data/README.md

@@ -237,12 +237,13 @@ class CreateDataItems < ActiveRecord::Migration[7.1]
 end
 ```
 
-Create table with custom column structure:
+Create table with custom column structure and codec compression:
 
 ```ruby
 class CreateDataItems < ActiveRecord::Migration[7.1]
   def change
     create_table "data_items", id: false, options: "MergeTree PARTITION BY toYYYYMM(timestamp) ORDER BY timestamp", force: :cascade do |t|
+      t.integer :user_id, limit: 8, codec: 'DoubleDelta, LZ4'
       t.column "timestamp", "DateTime('UTC') CODEC(DoubleDelta, LZ4)"
     end
   end

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

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Clickhouse
+      class Column < ActiveRecord::ConnectionAdapters::Column
+
+        attr_reader :codec
+
+        def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, codec: nil, **args)
+          super
+          @codec = codec
+        end
+
+        private
+
+        def deduplicated
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -7,15 +7,16 @@ module ActiveRecord
         class Map < Type::Value # :nodoc:
 
           def initialize(sql_type)
-            @subtype = case sql_type
-                       when /U?Int\d+/
-                         :integer
-                       when /DateTime/
-                         :datetime
-                       when /Date/
-                         :date
-                       else
-                         :string
+            case sql_type
+            when /U?Int(\d+)/
+              @subtype = :integer
+              @limit = bits_to_limit(Regexp.last_match(1)&.to_i)
+            when /DateTime/
+              @subtype = :datetime
+            when /Date/
+              @subtype = :date
+            else
+              @subtype = :string
             end
           end
 
@@ -26,6 +27,8 @@ module ActiveRecord
           def deserialize(value)
             if value.is_a?(::Hash)
               value.map { |k, item| [k.to_s, deserialize(item)] }.to_h
+            elsif value.is_a?(::Array)
+              value.map { |item| deserialize(item) }
             else
               return value if value.nil?
               case @subtype
@@ -44,6 +47,8 @@ module ActiveRecord
           def serialize(value)
             if value.is_a?(::Hash)
               value.map { |k, item| [k.to_s, serialize(item)] }.to_h
+            elsif value.is_a?(::Array)
+              value.map { |item| serialize(item) }
             else
               return value if value.nil?
               case @subtype
@@ -61,6 +66,19 @@ module ActiveRecord
             end
           end
 
+          private
+
+          def bits_to_limit(bits)
+            case bits
+            when 8   then 1
+            when 16  then 2
+            when 32  then 4
+            when 64  then 8
+            when 128 then 16
+            when 256 then 32
+            end
+          end
+
         end
       end
     end

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

@@ -33,9 +33,15 @@ module ActiveRecord
           if options[:array]
             sql.gsub!(/\s+(.*)/, ' Array(\1)')
           end
-          if options[:map]
+          if options[:map] == :array
+            sql.gsub!(/\s+(.*)/, ' Map(String, Array(\1))')
+          end
+          if options[:map] == true
             sql.gsub!(/\s+(.*)/, ' Map(String, \1)')
           end
+          if options[:codec]
+            sql.gsub!(/\s+(.*)/, " \\1 CODEC(#{options[:codec]})")
+          end
           sql.gsub!(/(\sString)\(\d+\)/, '\1')
           sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
           sql

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

@@ -8,6 +8,8 @@ module ActiveRecord
       module SchemaStatements
         DEFAULT_RESPONSE_FORMAT = 'JSONCompactEachRowWithNamesAndTypes'.freeze
 
+        DB_EXCEPTION_REGEXP = /\ACode:\s+\d+\.\s+DB::Exception:/.freeze
+
         def execute(sql, name = nil, settings: {})
           do_execute(sql, name, settings: settings)
         end
@@ -70,8 +72,14 @@ module ActiveRecord
           result['data'].flatten
         end
 
+        def materialized_views(name = nil)
+          result = do_system_execute("SHOW TABLES WHERE engine = 'MaterializedView'", name)
+          return [] if result.nil?
+          result['data'].flatten
+        end
+
         def functions
-          result = do_system_execute("SELECT name FROM system.functions WHERE origin = 'SQLUserDefined'")
+          result = do_system_execute("SELECT name FROM system.functions WHERE origin = 'SQLUserDefined' ORDER BY name")
           return [] if result.nil?
           result['data'].flatten
         end
@@ -183,7 +191,9 @@ module ActiveRecord
         def process_response(res, format, sql = nil)
           case res.code.to_i
           when 200
-            if res.body.to_s.include?("DB::Exception")
+            body = res.body
+
+            if body.include?("DB::Exception") && body.match?(DB_EXCEPTION_REGEXP)
               raise ActiveRecord::ActiveRecordError, "Response code: #{res.code}:\n#{res.body}#{sql ? "\nQuery: #{sql}" : ''}"
             else
               format_body_response(res.body, format)
@@ -221,7 +231,7 @@ module ActiveRecord
           default_value = extract_value_from_default(field[3], field[2])
           default_function = extract_default_function(field[3])
           default_value = lookup_cast_type(sql_type).cast(default_value)
-          ClickhouseColumn.new(field[0], default_value, type_metadata, field[1].include?('Nullable'), default_function)
+          Clickhouse::Column.new(field[0], default_value, type_metadata, field[1].include?('Nullable'), default_function, codec: field[5].presence)
         end
 
         protected

data/lib/active_record/connection_adapters/clickhouse/{schema_definitions.rb → table_definition.rb}

@@ -94,10 +94,15 @@ module ActiveRecord
           args.each { |name| column(name, kind, **options.except(:limit)) }
         end
 
+        def column(name, type, index: nil, **options)
+          options[:null] = false if type.match?(/Nullable\([^)]+\)/)
+          super(name, type, index: index, **options)
+        end
+
         private
 
         def valid_column_definition_options
-          super + [:array, :low_cardinality, :fixed_string, :value, :type, :map]
+          super + [:array, :low_cardinality, :fixed_string, :value, :type, :map, :codec, :unsigned]
         end
       end
 

data/lib/active_record/connection_adapters/clickhouse_adapter.rb

@@ -2,18 +2,21 @@
 
 require 'arel/visitors/clickhouse'
 require 'arel/nodes/final'
+require 'arel/nodes/grouping_sets'
 require 'arel/nodes/settings'
 require 'arel/nodes/using'
+require 'arel/nodes/limit_by'
 require 'active_record/connection_adapters/clickhouse/oid/array'
 require 'active_record/connection_adapters/clickhouse/oid/date'
 require 'active_record/connection_adapters/clickhouse/oid/date_time'
 require 'active_record/connection_adapters/clickhouse/oid/big_integer'
 require 'active_record/connection_adapters/clickhouse/oid/map'
 require 'active_record/connection_adapters/clickhouse/oid/uuid'
+require 'active_record/connection_adapters/clickhouse/column'
 require 'active_record/connection_adapters/clickhouse/quoting'
-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 'active_record/connection_adapters/clickhouse/table_definition'
 require 'net/http'
 require 'openssl'
 
@@ -47,7 +50,12 @@ module ActiveRecord
 
   module ModelSchema
     module ClassMethods
-      delegate :final, :final!, :settings, :settings!, :window, :window!, to: :all
+      delegate :final, :final!,
+               :group_by_grouping_sets, :group_by_grouping_sets!,
+               :settings, :settings!,
+               :window, :window!,
+               :limit_by, :limit_by!,
+               to: :all
 
       def is_view
         @is_view || false
@@ -70,13 +78,6 @@ module ActiveRecord
       register "clickhouse", "ActiveRecord::ConnectionAdapters::ClickhouseAdapter", "active_record/connection_adapters/clickhouse_adapter"
     end
 
-    class ClickhouseColumn < Column
-      private
-      def deduplicated
-        self
-      end
-    end
-
     class ClickhouseAdapter < AbstractAdapter
       include Clickhouse::Quoting
 
@@ -190,6 +191,8 @@ module ActiveRecord
               nil
             when /(Nullable)?\(?U?Int64\)?/
               8
+            when /(Nullable)?\(?U?Int128\)?/
+              16
             else
               super
           end
@@ -311,7 +314,7 @@ module ActiveRecord
         end
       end
 
-      def create_view(table_name, **options)
+      def create_view(table_name, request_settings: {}, **options)
         options.merge!(view: true)
         options = apply_replica(table_name, options)
         td = create_table_definition(apply_cluster(table_name), **options)
@@ -321,10 +324,10 @@ module ActiveRecord
           drop_table(table_name, options.merge(if_exists: true))
         end
 
-        do_execute(schema_creation.accept(td), format: nil)
+        do_execute(schema_creation.accept(td), format: nil, settings: request_settings)
       end
 
-      def create_table(table_name, **options, &block)
+      def create_table(table_name, request_settings: {}, **options, &block)
         options = apply_replica(table_name, options)
         td = create_table_definition(apply_cluster(table_name), **options)
         block.call td if block_given?
@@ -338,7 +341,7 @@ module ActiveRecord
           drop_table(table_name, options.merge(if_exists: true))
         end
 
-        do_execute(schema_creation.accept(td), format: nil)
+        do_execute(schema_creation.accept(td), format: nil, settings: request_settings)
 
         if options[:with_distributed]
           distributed_table_name = options.delete(:with_distributed)
@@ -351,8 +354,8 @@ module ActiveRecord
         end
       end
 
-      def create_function(name, body)
-        fd = "CREATE FUNCTION #{apply_cluster(quote_table_name(name))} AS #{body}"
+      def create_function(name, body, **options)
+        fd = "CREATE#{' OR REPLACE' if options[:force]} FUNCTION #{apply_cluster(quote_table_name(name))} AS #{body}"
         do_execute(fd, format: nil)
       end
 

data/lib/arel/nodes/grouping_sets.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class GroupingSets < Arel::Nodes::Unary
+
+      def initialize(expr)
+        super
+        @expr = wrap_grouping_sets(expr)
+      end
+
+      private
+
+      def wrap_grouping_sets(sets)
+        sets.map do |element|
+          # See Arel::SelectManager#group
+          case element
+          when Array
+            wrap_grouping_sets(element)
+          when String
+            ::Arel::Nodes::SqlLiteral.new(element)
+          when Symbol
+            ::Arel::Nodes::SqlLiteral.new(element.to_s)
+          else
+            element
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/arel/nodes/limit_by.rb

@@ -0,0 +1,17 @@
+module Arel # :nodoc: all
+  module Nodes
+    class LimitBy < Arel::Nodes::Unary
+      attr_reader :column
+
+      def initialize(limit, column)
+        raise ArgumentError, 'Limit should be an integer' unless limit.is_a?(Integer)
+        raise ArgumentError, 'Limit should be a positive integer' unless limit >= 0
+        raise ArgumentError, 'Column should be a Symbol or String' unless column.is_a?(String) || column.is_a?(Symbol)
+        
+        @column = column
+
+        super(limit)
+      end
+    end
+  end
+end

data/lib/arel/visitors/clickhouse.rb

@@ -25,6 +25,7 @@ module Arel
       end
 
       def visit_Arel_Nodes_SelectOptions(o, collector)
+        maybe_visit o.limit_by, collector
         maybe_visit o.settings, super
       end
 
@@ -45,6 +46,11 @@ module Arel
         collector
       end
 
+      def visit_Arel_Nodes_GroupingSets(o, collector)
+        collector << 'GROUPING SETS '
+        grouping_array_or_grouping_element(o.expr, collector)
+      end
+
       def visit_Arel_Nodes_Settings(o, collector)
         return collector if o.expr.empty?
 
@@ -64,6 +70,11 @@ module Arel
         collector
       end
 
+      def visit_Arel_Nodes_LimitBy(o, collector)
+        collector << "LIMIT #{o.expr} BY #{o.column}"
+        collector
+      end
+
       def visit_Arel_Nodes_Matches(o, collector)
         op = o.case_sensitive ? " LIKE " : " ILIKE "
         infix_value o, collector, op
@@ -95,6 +106,25 @@ module Arel
         @connection.sanitize_as_setting_name(value)
       end
 
+      private
+
+      # Utilized by GroupingSet, Cube & RollUp visitors to
+      # handle grouping aggregation semantics
+      def grouping_array_or_grouping_element(o, collector)
+        if o.is_a? Array
+          collector << '( '
+          o.each_with_index do |el, i|
+            collector << ', ' if i > 0
+            grouping_array_or_grouping_element el, collector
+          end
+          collector << ' )'
+        elsif o.respond_to? :expr
+          visit o.expr, collector
+        else
+          visit o, collector
+        end
+      end
+
     end
   end
 end

data/lib/clickhouse-activerecord/schema_dumper.rb

@@ -15,13 +15,16 @@ module ClickhouseActiverecord
     private
 
     def tables(stream)
-      functions = @connection.functions
+      functions = @connection.functions.sort
       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|
+      view_tables = @connection.views.sort
+      materialized_view_tables = @connection.materialized_views.sort
+      sorted_tables = @connection.tables.sort - view_tables - materialized_view_tables
+
+      (sorted_tables + view_tables + materialized_view_tables).each do |table_name|
         table(table_name, stream) unless ignored?(table_name)
       end
     end
@@ -35,7 +38,7 @@ module ClickhouseActiverecord
           # super(table.gsub(/^\.inner\./, ''), stream)
 
           # detect view table
-          match = sql.match(/^CREATE\s+(MATERIALIZED\s+)?VIEW/)
+          view_match = sql.match(/^CREATE\s+(MATERIALIZED\s+)?VIEW\s+\S+\s+(?:TO (\S+))?/)
         end
 
         # Copy from original dumper
@@ -50,8 +53,9 @@ module ClickhouseActiverecord
 
           unless simple
             # Add materialize flag
-            tbl.print ', view: true' if match
-            tbl.print ', materialized: true' if match && match[1].presence
+            tbl.print ', view: true' if view_match
+            tbl.print ', materialized: true' if view_match && view_match[1].presence
+            tbl.print ", to: \"#{view_match[2]}\"" if view_match && view_match[2].presence
           end
 
           if (id = columns.detect { |c| c.name == 'id' })
@@ -75,10 +79,10 @@ module ClickhouseActiverecord
           tbl.puts ", force: :cascade do |t|"
 
           # then dump all non-primary key columns
-          if simple || !match
+          if simple || !view_match
             columns.each do |column|
               raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
-              next if column.name == pk
+              next if column.name == pk && column.name == "id"
               type, colspec = column_spec(column)
               name = column.name =~ (/\./) ? "\"`#{column.name}`\"" : column.name.inspect
               tbl.print "    t.#{type} #{name}"
@@ -108,11 +112,23 @@ module ClickhouseActiverecord
       end
     end
 
+    def column_spec_for_primary_key(column)
+      spec = super
+
+      id = ActiveRecord::ConnectionAdapters::ClickhouseAdapter::NATIVE_DATABASE_TYPES.invert[{name: column.sql_type.gsub(/\(\d+\)/, "")}]
+      spec[:id] = id.inspect if id.present?
+
+      spec.except!(:limit, :unsigned) # This can be removed at some date, it is only here to clean up existing schemas which have dumped these values already
+    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
+      if sql
+        stream.puts "  # SQL: #{sql}"
+        stream.puts "  create_function \"#{function}\", \"#{sql.gsub(/^CREATE FUNCTION (.*?) AS/, '').strip}\", force: true"
+        stream.puts
+      end
     end
 
     def format_options(options)
@@ -141,23 +157,32 @@ module ClickhouseActiverecord
     end
 
     def schema_array(column)
-      (column.sql_type =~ /Array?\(/).nil? ? nil : true
+      (column.sql_type =~ /Array\(/).nil? ? nil : true
     end
 
     def schema_map(column)
-      (column.sql_type =~ /Map?\(/).nil? ? nil : true
+      if column.sql_type =~ /Map\(([^,]+),\s*(Array)\)/
+        return :array
+      end
+
+      (column.sql_type =~ /Map\(/).nil? ? nil : true
     end
 
     def schema_low_cardinality(column)
-      (column.sql_type =~ /LowCardinality?\(/).nil? ? nil : true
+      (column.sql_type =~ /LowCardinality\(/).nil? ? nil : true
     end
 
+    # @param [ActiveRecord::ConnectionAdapters::Clickhouse::Column] column
     def prepare_column_options(column)
       spec = {}
       spec[:unsigned] = schema_unsigned(column)
       spec[:array] = schema_array(column)
       spec[:map] = schema_map(column)
+      if spec[:map] == :array
+        spec[:array] = nil
+      end
       spec[:low_cardinality] = schema_low_cardinality(column)
+      spec[:codec] = column.codec.inspect if column.codec
       spec.merge(super).compact
     end
 

data/lib/clickhouse-activerecord/tasks.rb

@@ -47,12 +47,12 @@ module ClickhouseActiverecord
       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
+      functions = connection.execute("SELECT create_query FROM system.functions WHERE origin = 'SQLUserDefined' ORDER BY name")['data'].flatten
 
       # put to file
       File.open(args.first, 'w:utf-8') do |file|
         functions.each do |function|
-          file.puts function + ";\n\n"
+          file.puts function.gsub('\\n', "\n") + ";\n\n"
         end
 
         tables.each do |table|
@@ -67,6 +67,8 @@ module ClickhouseActiverecord
           next
         elsif sql =~ /^INSERT INTO/
           connection.do_execute(sql, nil, format: nil)
+        elsif sql =~ /^CREATE .*?FUNCTION/
+          connection.do_execute(sql, nil, format: nil)
         else
           connection.execute(sql)
         end

data/lib/clickhouse-activerecord/version.rb

@@ -1,3 +1,3 @@
 module ClickhouseActiverecord
-  VERSION = '1.1.3'
+  VERSION = '1.2.1'
 end

data/lib/core_extensions/active_record/relation.rb

@@ -47,6 +47,33 @@ module CoreExtensions
         self
       end
 
+      # GROUPING SETS allows you to specify multiple groupings in the GROUP BY clause.
+      # Whereas GROUP BY CUBE generates all possible groupings, GROUP BY GROUPING SETS generates only the specified groupings.
+      # For example:
+      #
+      #   users = User.group_by_grouping_sets([], [:name], [:name, :age]).select(:name, :age, 'count(*)')
+      #   # SELECT name, age, count(*) FROM users GROUP BY GROUPING SETS ( (), (name), (name, age) )
+      #
+      # which is generally equivalent to:
+      #   # SELECT NULL, NULL, count(*) FROM users
+      #   # UNION ALL
+      #   # SELECT name, NULL, count(*) FROM users GROUP BY name
+      #   # UNION ALL
+      #   # SELECT name, age, count(*) FROM users GROUP BY name, age
+      #
+      # Raises <tt>ArgumentError</tt> if no grouping sets are specified are provided.
+      def group_by_grouping_sets(*grouping_sets)
+        raise ArgumentError, 'The method .group_by_grouping_sets() must contain arguments.' if grouping_sets.blank?
+
+        spawn.group_by_grouping_sets!(*grouping_sets)
+      end
+
+      def group_by_grouping_sets!(*grouping_sets) # :nodoc:
+        grouping_sets = grouping_sets.map { |set| arel_columns(set) }
+        self.group_values += [::Arel::Nodes::GroupingSets.new(grouping_sets)]
+        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)
@@ -81,6 +108,24 @@ module CoreExtensions
         self
       end
 
+      # The LIMIT BY clause permit to improve deduplication based on a unique key, it has better performances than
+      # the GROUP BY clause
+      #
+      #   users = User.limit_by(1, id)
+      #   # SELECT users.* FROM users LIMIT 1 BY id
+      #
+      # An <tt>ActiveRecord::ActiveRecordError</tt> will be reaised if database is not Clickhouse.
+      # @param [Array] opts
+      def limit_by(*opts)
+        spawn.limit_by!(*opts)
+      end
+
+      # @param [Array] opts
+      def limit_by!(*opts)
+        @values[:limit_by] = *opts
+        self
+      end
+
       private
 
       def check_command(cmd)
@@ -95,6 +140,7 @@ module CoreExtensions
         end
 
         arel.final! if @values[:final].present?
+        arel.limit_by(*@values[:limit_by]) if @values[:limit_by].present?
         arel.settings(@values[:settings]) if @values[:settings].present?
         arel.using(@values[:using]) if @values[:using].present?
         arel.windows(@values[:windows]) if @values[:windows].present?

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

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

data/lib/core_extensions/arel/select_manager.rb

@@ -29,6 +29,11 @@ module CoreExtensions
         @ctx.source.right.last.right = ::Arel::Nodes::Using.new(::Arel.sql(exprs.join(',')))
         self
       end
+
+      def limit_by(*exprs)
+        @ast.limit_by = ::Arel::Nodes::LimitBy.new(*exprs)
+        self
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clickhouse-activerecord
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.2.1
 platform: ruby
 authors:
 - Sergey Odintsov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-27 00:00:00.000000000 Z
+date: 2024-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -106,6 +106,7 @@ files:
 - bin/console
 - bin/setup
 - clickhouse-activerecord.gemspec
+- lib/active_record/connection_adapters/clickhouse/column.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
@@ -114,10 +115,12 @@ files:
 - lib/active_record/connection_adapters/clickhouse/oid/uuid.rb
 - lib/active_record/connection_adapters/clickhouse/quoting.rb
 - lib/active_record/connection_adapters/clickhouse/schema_creation.rb
-- lib/active_record/connection_adapters/clickhouse/schema_definitions.rb
 - lib/active_record/connection_adapters/clickhouse/schema_statements.rb
+- lib/active_record/connection_adapters/clickhouse/table_definition.rb
 - lib/active_record/connection_adapters/clickhouse_adapter.rb
 - lib/arel/nodes/final.rb
+- lib/arel/nodes/grouping_sets.rb
+- lib/arel/nodes/limit_by.rb
 - lib/arel/nodes/settings.rb
 - lib/arel/nodes/using.rb
 - lib/arel/visitors/clickhouse.rb