activerecord 6.1.7.2 → 7.0.4.2

data/lib/arel/crud.rb

@@ -4,23 +4,6 @@ module Arel # :nodoc: all
   ###
   # FIXME hopefully we can remove this
   module Crud
-    def compile_update(values, pk)
-      um = UpdateManager.new
-
-      if Nodes::SqlLiteral === values
-        relation = @ctx.from
-      else
-        relation = values.first.first.relation
-      end
-      um.key = pk
-      um.table relation
-      um.set values
-      um.take @ast.limit.expr if @ast.limit
-      um.order(*@ast.orders)
-      um.wheres = @ctx.wheres
-      um
-    end
-
     def compile_insert(values)
       im = create_insert
       im.insert values
@@ -31,11 +14,34 @@ module Arel # :nodoc: all
       InsertManager.new
     end
 
-    def compile_delete
-      dm = DeleteManager.new
-      dm.take @ast.limit.expr if @ast.limit
-      dm.wheres = @ctx.wheres
-      dm.from @ctx.froms
+    def compile_update(
+      values,
+      key = nil,
+      having_clause = nil,
+      group_values_columns = []
+    )
+      um = UpdateManager.new(source)
+      um.set(values)
+      um.take(limit)
+      um.offset(offset)
+      um.order(*orders)
+      um.wheres = constraints
+      um.key = key
+
+      um.group(group_values_columns) unless group_values_columns.empty?
+      um.having(having_clause) unless having_clause.nil?
+      um
+    end
+
+    def compile_delete(key = nil, having_clause = nil, group_values_columns = [])
+      dm = DeleteManager.new(source)
+      dm.take(limit)
+      dm.offset(offset)
+      dm.order(*orders)
+      dm.wheres = constraints
+      dm.key = key
+      dm.group(group_values_columns) unless group_values_columns.empty?
+      dm.having(having_clause) unless having_clause.nil?
       dm
     end
   end

data/lib/arel/delete_manager.rb

@@ -4,15 +4,29 @@ module Arel # :nodoc: all
   class DeleteManager < Arel::TreeManager
     include TreeManager::StatementMethods
 
-    def initialize
-      super
-      @ast = Nodes::DeleteStatement.new
-      @ctx = @ast
+    def initialize(table = nil)
+      @ast = Nodes::DeleteStatement.new(table)
     end
 
     def from(relation)
       @ast.relation = relation
       self
     end
+
+    def group(columns)
+      columns.each do |column|
+        column = Nodes::SqlLiteral.new(column) if String === column
+        column = Nodes::SqlLiteral.new(column.to_s) if Symbol === column
+
+        @ast.groups.push Nodes::Group.new column
+      end
+
+      self
+    end
+
+    def having(expr)
+      @ast.havings << expr
+      self
+    end
   end
 end

data/lib/arel/filter_predications.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel
+  module FilterPredications
+    def filter(expr)
+      Nodes::Filter.new(self, expr)
+    end
+  end
+end

data/lib/arel/insert_manager.rb

@@ -2,9 +2,8 @@
 
 module Arel # :nodoc: all
   class InsertManager < Arel::TreeManager
-    def initialize
-      super
-      @ast = Nodes::InsertStatement.new
+    def initialize(table = nil)
+      @ast = Nodes::InsertStatement.new(table)
     end
 
     def into(table)

data/lib/arel/nodes/casted.rb

@@ -47,7 +47,7 @@ module Arel # :nodoc: all
 
     def self.build_quoted(other, attribute = nil)
       case other
-      when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::Nodes::BindParam, Arel::SelectManager, Arel::Nodes::Quoted, Arel::Nodes::SqlLiteral
+      when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::SelectManager, Arel::Nodes::SqlLiteral, ActiveModel::Attribute
         other
       else
         case attribute

data/lib/arel/nodes/delete_statement.rb

@@ -3,17 +3,14 @@
 module Arel # :nodoc: all
   module Nodes
     class DeleteStatement < Arel::Nodes::Node
-      attr_accessor :left, :right, :orders, :limit, :offset, :key
-
-      alias :relation :left
-      alias :relation= :left=
-      alias :wheres :right
-      alias :wheres= :right=
+      attr_accessor :relation, :wheres, :groups, :havings, :orders, :limit, :offset, :key
 
       def initialize(relation = nil, wheres = [])
         super()
-        @left = relation
-        @right = wheres
+        @relation = relation
+        @wheres = wheres
+        @groups = []
+        @havings = []
         @orders = []
         @limit = nil
         @offset = nil
@@ -22,19 +19,21 @@ module Arel # :nodoc: all
 
       def initialize_copy(other)
         super
-        @left  = @left.clone if @left
-        @right = @right.clone if @right
+        @relation = @relation.clone if @relation
+        @wheres = @wheres.clone if @wheres
       end
 
       def hash
-        [self.class, @left, @right, @orders, @limit, @offset, @key].hash
+        [self.class, @relation, @wheres, @orders, @limit, @offset, @key].hash
       end
 
       def eql?(other)
         self.class == other.class &&
-          self.left == other.left &&
-          self.right == other.right &&
+          self.relation == other.relation &&
+          self.wheres == other.wheres &&
           self.orders == other.orders &&
+          self.groups == other.groups &&
+          self.havings == other.havings &&
           self.limit == other.limit &&
           self.offset == other.offset &&
           self.key == other.key

data/lib/arel/nodes/filter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Arel
+  module Nodes
+    class Filter < Binary
+      include Arel::WindowPredications
+      include Arel::AliasPredication
+    end
+  end
+end

data/lib/arel/nodes/function.rb

@@ -4,6 +4,7 @@ module Arel # :nodoc: all
   module Nodes
     class Function < Arel::Nodes::NodeExpression
       include Arel::WindowPredications
+      include Arel::FilterPredications
       attr_accessor :expressions, :alias, :distinct
 
       def initialize(expr, aliaz = nil)

data/lib/arel/nodes/insert_statement.rb

@@ -5,9 +5,9 @@ module Arel # :nodoc: all
     class InsertStatement < Arel::Nodes::Node
       attr_accessor :relation, :columns, :values, :select
 
-      def initialize
+      def initialize(relation = nil)
         super()
-        @relation = nil
+        @relation = relation
         @columns  = []
         @values   = nil
         @select   = nil

data/lib/arel/nodes/select_core.rb

@@ -6,9 +6,9 @@ module Arel # :nodoc: all
       attr_accessor :projections, :wheres, :groups, :windows, :comment
       attr_accessor :havings, :source, :set_quantifier, :optimizer_hints
 
-      def initialize
+      def initialize(relation = nil)
         super()
-        @source = JoinSource.new nil
+        @source = JoinSource.new(relation)
 
         # https://ronsavage.github.io/SQL/sql-92.bnf.html#set%20quantifier
         @set_quantifier  = nil

data/lib/arel/nodes/select_statement.rb

@@ -6,9 +6,9 @@ module Arel # :nodoc: all
       attr_reader :cores
       attr_accessor :limit, :orders, :lock, :offset, :with
 
-      def initialize(cores = [SelectCore.new])
+      def initialize(relation = nil)
         super()
-        @cores          = cores
+        @cores          = [SelectCore.new(relation)]
         @orders         = []
         @limit          = nil
         @lock           = nil

data/lib/arel/nodes/update_statement.rb

@@ -3,12 +3,15 @@
 module Arel # :nodoc: all
   module Nodes
     class UpdateStatement < Arel::Nodes::Node
-      attr_accessor :relation, :wheres, :values, :orders, :limit, :offset, :key
+      attr_accessor :relation, :wheres, :values, :groups, :havings, :orders, :limit, :offset, :key
 
-      def initialize
-        @relation = nil
+      def initialize(relation = nil)
+        super()
+        @relation = relation
         @wheres   = []
         @values   = []
+        @groups   = []
+        @havings  = []
         @orders   = []
         @limit    = nil
         @offset   = nil
@@ -30,6 +33,8 @@ module Arel # :nodoc: all
           self.relation == other.relation &&
           self.wheres == other.wheres &&
           self.values == other.values &&
+          self.groups == other.groups &&
+          self.havings == other.havings &&
           self.orders == other.orders &&
           self.limit == other.limit &&
           self.offset == other.offset &&

data/lib/arel/nodes.rb

@@ -28,6 +28,7 @@ require "arel/nodes/with"
 # binary
 require "arel/nodes/binary"
 require "arel/nodes/equality"
+require "arel/nodes/filter"
 require "arel/nodes/in"
 require "arel/nodes/join_source"
 require "arel/nodes/delete_statement"

data/lib/arel/predications.rb

@@ -39,7 +39,11 @@ module Arel # :nodoc: all
         self.in([])
       elsif open_ended?(other.begin)
         if open_ended?(other.end)
-          not_in([])
+          if infinity?(other.begin) == 1 || infinity?(other.end) == -1
+            self.in([])
+          else
+            not_in([])
+          end
         elsif other.exclude_end?
           lt(other.end)
         else
@@ -52,7 +56,7 @@ module Arel # :nodoc: all
       else
         left = quoted_node(other.begin)
         right = quoted_node(other.end)
-        Nodes::Between.new(self, left.and(right))
+        Nodes::Between.new(self, Nodes::And.new([left, right]))
       end
     end
 
@@ -80,7 +84,11 @@ module Arel # :nodoc: all
         not_in([])
       elsif open_ended?(other.begin)
         if open_ended?(other.end)
-          self.in([])
+          if infinity?(other.begin) == 1 || infinity?(other.end) == -1
+            not_in([])
+          else
+            self.in([])
+          end
         elsif other.exclude_end?
           gteq(other.end)
         else

data/lib/arel/select_manager.rb

@@ -7,10 +7,8 @@ module Arel # :nodoc: all
     STRING_OR_SYMBOL_CLASS = [Symbol, String]
 
     def initialize(table = nil)
-      super()
-      @ast = Nodes::SelectStatement.new
+      @ast = Nodes::SelectStatement.new(table)
       @ctx = @ast.cores.last
-      from table
     end
 
     def initialize_copy(other)
@@ -98,7 +96,7 @@ module Arel # :nodoc: all
     end
 
     def froms
-      @ast.cores.map { |x| x.from }.compact
+      @ast.cores.filter_map { |x| x.from }
     end
 
     def join(relation, klass = Nodes::InnerJoin)
@@ -183,6 +181,14 @@ module Arel # :nodoc: all
       @ast.orders
     end
 
+    def where(expr)
+      if Arel::TreeManager === expr
+        expr = expr.ast
+      end
+      @ctx.wheres << expr
+      self
+    end
+
     def where_sql(engine = Table.engine)
       return if @ctx.wheres.empty?
 

data/lib/arel/table.rb

@@ -2,7 +2,6 @@
 
 module Arel # :nodoc: all
   class Table
-    include Arel::Crud
     include Arel::FactoryMethods
     include Arel::AliasPredication
 

data/lib/arel/tree_manager.rb

@@ -40,10 +40,6 @@ module Arel # :nodoc: all
 
     attr_reader :ast
 
-    def initialize
-      @ctx = nil
-    end
-
     def to_dot
       collector = Arel::Collectors::PlainString.new
       collector = Visitors::Dot.new.accept @ast, collector
@@ -60,13 +56,5 @@ module Arel # :nodoc: all
       super
       @ast = @ast.clone
     end
-
-    def where(expr)
-      if Arel::TreeManager === expr
-        expr = expr.ast
-      end
-      @ctx.wheres << expr
-      self
-    end
   end
 end

data/lib/arel/update_manager.rb

@@ -4,10 +4,8 @@ module Arel # :nodoc: all
   class UpdateManager < Arel::TreeManager
     include TreeManager::StatementMethods
 
-    def initialize
-      super
-      @ast = Nodes::UpdateStatement.new
-      @ctx = @ast
+    def initialize(table = nil)
+      @ast = Nodes::UpdateStatement.new(table)
     end
 
     ###
@@ -30,5 +28,21 @@ module Arel # :nodoc: all
       end
       self
     end
+
+    def group(columns)
+      columns.each do |column|
+        column = Nodes::SqlLiteral.new(column) if String === column
+        column = Nodes::SqlLiteral.new(column.to_s) if Symbol === column
+
+        @ast.groups.push Nodes::Group.new column
+      end
+
+      self
+    end
+
+    def having(expr)
+      @ast.havings << expr
+      self
+    end
   end
 end

data/lib/arel/visitors/dot.rb

@@ -31,6 +31,40 @@ module Arel # :nodoc: all
       end
 
       private
+        def visit_Arel_Nodes_Function(o)
+          visit_edge o, "expressions"
+          visit_edge o, "distinct"
+          visit_edge o, "alias"
+        end
+
+        def visit_Arel_Nodes_Unary(o)
+          visit_edge o, "expr"
+        end
+
+        def visit_Arel_Nodes_Binary(o)
+          visit_edge o, "left"
+          visit_edge o, "right"
+        end
+
+        def visit_Arel_Nodes_UnaryOperation(o)
+          visit_edge o, "operator"
+          visit_edge o, "expr"
+        end
+
+        def visit_Arel_Nodes_InfixOperation(o)
+          visit_edge o, "operator"
+          visit_edge o, "left"
+          visit_edge o, "right"
+        end
+
+        def visit__regexp(o)
+          visit_edge o, "left"
+          visit_edge o, "right"
+          visit_edge o, "case_sensitive"
+        end
+        alias :visit_Arel_Nodes_Regexp :visit__regexp
+        alias :visit_Arel_Nodes_NotRegexp :visit__regexp
+
         def visit_Arel_Nodes_Ordering(o)
           visit_edge o, "expr"
         end
@@ -53,71 +87,29 @@ module Arel # :nodoc: all
           visit_edge o, "left"
         end
 
-        def visit_Arel_Nodes_InnerJoin(o)
-          visit_edge o, "left"
-          visit_edge o, "right"
-        end
-        alias :visit_Arel_Nodes_FullOuterJoin  :visit_Arel_Nodes_InnerJoin
-        alias :visit_Arel_Nodes_OuterJoin      :visit_Arel_Nodes_InnerJoin
-        alias :visit_Arel_Nodes_RightOuterJoin :visit_Arel_Nodes_InnerJoin
-
-        def visit_Arel_Nodes_DeleteStatement(o)
-          visit_edge o, "relation"
-          visit_edge o, "wheres"
-        end
-
-        def unary(o)
-          visit_edge o, "expr"
-        end
-        alias :visit_Arel_Nodes_Group             :unary
-        alias :visit_Arel_Nodes_Cube              :unary
-        alias :visit_Arel_Nodes_RollUp            :unary
-        alias :visit_Arel_Nodes_GroupingSet       :unary
-        alias :visit_Arel_Nodes_GroupingElement   :unary
-        alias :visit_Arel_Nodes_Grouping          :unary
-        alias :visit_Arel_Nodes_Having            :unary
-        alias :visit_Arel_Nodes_Limit             :unary
-        alias :visit_Arel_Nodes_Not               :unary
-        alias :visit_Arel_Nodes_Offset            :unary
-        alias :visit_Arel_Nodes_On                :unary
-        alias :visit_Arel_Nodes_UnqualifiedColumn :unary
-        alias :visit_Arel_Nodes_OptimizerHints    :unary
-        alias :visit_Arel_Nodes_Preceding         :unary
-        alias :visit_Arel_Nodes_Following         :unary
-        alias :visit_Arel_Nodes_Rows              :unary
-        alias :visit_Arel_Nodes_Range             :unary
-
-        def window(o)
+        def visit_Arel_Nodes_Window(o)
           visit_edge o, "partitions"
           visit_edge o, "orders"
           visit_edge o, "framing"
         end
-        alias :visit_Arel_Nodes_Window            :window
 
-        def named_window(o)
+        def visit_Arel_Nodes_NamedWindow(o)
           visit_edge o, "partitions"
           visit_edge o, "orders"
           visit_edge o, "framing"
           visit_edge o, "name"
         end
-        alias :visit_Arel_Nodes_NamedWindow       :named_window
 
-        def function(o)
-          visit_edge o, "expressions"
-          visit_edge o, "distinct"
-          visit_edge o, "alias"
+        def visit__no_edges(o)
+          # intentionally left blank
         end
-        alias :visit_Arel_Nodes_Exists :function
-        alias :visit_Arel_Nodes_Min    :function
-        alias :visit_Arel_Nodes_Max    :function
-        alias :visit_Arel_Nodes_Avg    :function
-        alias :visit_Arel_Nodes_Sum    :function
+        alias :visit_Arel_Nodes_CurrentRow :visit__no_edges
+        alias :visit_Arel_Nodes_Distinct :visit__no_edges
 
-        def extract(o)
+        def visit_Arel_Nodes_Extract(o)
           visit_edge o, "expressions"
           visit_edge o, "alias"
         end
-        alias :visit_Arel_Nodes_Extract :extract
 
         def visit_Arel_Nodes_NamedFunction(o)
           visit_edge o, "name"
@@ -130,13 +122,19 @@ module Arel # :nodoc: all
           visit_edge o, "relation"
           visit_edge o, "columns"
           visit_edge o, "values"
+          visit_edge o, "select"
         end
 
         def visit_Arel_Nodes_SelectCore(o)
           visit_edge o, "source"
           visit_edge o, "projections"
           visit_edge o, "wheres"
-          visit_edge o,  "windows"
+          visit_edge o, "windows"
+          visit_edge o, "groups"
+          visit_edge o, "comment"
+          visit_edge o, "havings"
+          visit_edge o, "set_quantifier"
+          visit_edge o, "optimizer_hints"
         end
 
         def visit_Arel_Nodes_SelectStatement(o)
@@ -144,12 +142,27 @@ module Arel # :nodoc: all
           visit_edge o, "limit"
           visit_edge o, "orders"
           visit_edge o, "offset"
+          visit_edge o, "lock"
+          visit_edge o, "with"
         end
 
         def visit_Arel_Nodes_UpdateStatement(o)
           visit_edge o, "relation"
           visit_edge o, "wheres"
           visit_edge o, "values"
+          visit_edge o, "orders"
+          visit_edge o, "limit"
+          visit_edge o, "offset"
+          visit_edge o, "key"
+        end
+
+        def visit_Arel_Nodes_DeleteStatement(o)
+          visit_edge o, "relation"
+          visit_edge o, "wheres"
+          visit_edge o, "orders"
+          visit_edge o, "limit"
+          visit_edge o, "offset"
+          visit_edge o, "key"
         end
 
         def visit_Arel_Table(o)
@@ -167,47 +180,18 @@ module Arel # :nodoc: all
           visit_edge o, "attribute"
         end
 
-        def visit_Arel_Attribute(o)
+        def visit_Arel_Attributes_Attribute(o)
           visit_edge o, "relation"
           visit_edge o, "name"
         end
-        alias :visit_Arel_Attributes_Integer :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_Float :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_String :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_Time :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_Boolean :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_Attribute :visit_Arel_Attribute
 
-        def nary(o)
-          o.children.each_with_index do |x, i|
-            edge(i) { visit x }
+        def visit__children(o)
+          o.children.each_with_index do |child, i|
+            edge(i) { visit child }
           end
         end
-        alias :visit_Arel_Nodes_And :nary
-
-        def binary(o)
-          visit_edge o, "left"
-          visit_edge o, "right"
-        end
-        alias :visit_Arel_Nodes_As                 :binary
-        alias :visit_Arel_Nodes_Assignment         :binary
-        alias :visit_Arel_Nodes_Between            :binary
-        alias :visit_Arel_Nodes_Concat             :binary
-        alias :visit_Arel_Nodes_DoesNotMatch       :binary
-        alias :visit_Arel_Nodes_Equality           :binary
-        alias :visit_Arel_Nodes_GreaterThan        :binary
-        alias :visit_Arel_Nodes_GreaterThanOrEqual :binary
-        alias :visit_Arel_Nodes_In                 :binary
-        alias :visit_Arel_Nodes_JoinSource         :binary
-        alias :visit_Arel_Nodes_LessThan           :binary
-        alias :visit_Arel_Nodes_LessThanOrEqual    :binary
-        alias :visit_Arel_Nodes_IsNotDistinctFrom  :binary
-        alias :visit_Arel_Nodes_IsDistinctFrom     :binary
-        alias :visit_Arel_Nodes_Matches            :binary
-        alias :visit_Arel_Nodes_NotEqual           :binary
-        alias :visit_Arel_Nodes_NotIn              :binary
-        alias :visit_Arel_Nodes_Or                 :binary
-        alias :visit_Arel_Nodes_Over               :binary
+        alias :visit_Arel_Nodes_And :visit__children
+        alias :visit_Arel_Nodes_With :visit__children
 
         def visit_String(o)
           @node_stack.last.fields << o
@@ -225,22 +209,22 @@ module Arel # :nodoc: all
         alias :visit_Arel_Nodes_SqlLiteral :visit_String
 
         def visit_Arel_Nodes_BindParam(o)
-          edge("value") { visit o.value }
+          visit_edge(o, "value")
         end
 
         def visit_ActiveModel_Attribute(o)
-          edge("value_before_type_cast") { visit o.value_before_type_cast }
+          visit_edge(o, "value_before_type_cast")
         end
 
         def visit_Hash(o)
           o.each_with_index do |pair, i|
-            edge("pair_#{i}")   { visit pair }
+            edge("pair_#{i}") { visit pair }
           end
         end
 
         def visit_Array(o)
-          o.each_with_index do |x, i|
-            edge(i) { visit x }
+          o.each_with_index do |member, i|
+            edge(i) { visit member }
           end
         end
         alias :visit_Set :visit_Array
@@ -249,6 +233,12 @@ module Arel # :nodoc: all
           visit_edge(o, "values")
         end
 
+        def visit_Arel_Nodes_Case(o)
+          visit_edge(o, "case")
+          visit_edge(o, "conditions")
+          visit_edge(o, "default")
+        end
+
         def visit_edge(o, method)
           edge(method) { visit o.send(method) }
         end