activerecord 6.1.6 → 7.1.2

data/lib/arel/attributes/attribute.rb

@@ -27,14 +27,6 @@ module Arel # :nodoc: all
         relation.able_to_type_cast?
       end
     end
-
-    class String    < Attribute; end
-    class Time      < Attribute; end
-    class Boolean   < Attribute; end
-    class Decimal   < Attribute; end
-    class Float     < Attribute; end
-    class Integer   < Attribute; end
-    class Undefined < Attribute; end
   end
 
   Attribute = Attributes::Attribute

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/errors.rb

@@ -6,4 +6,14 @@ module Arel # :nodoc: all
 
   class EmptyJoinError < ArelError
   end
+
+  class BindError < ArelError
+    def initialize(message, sql = nil)
+      if sql
+        super("#{message} in: #{sql.inspect}")
+      else
+        super(message)
+      end
+    end
+  end
 end

data/lib/arel/factory_methods.rb

@@ -45,5 +45,9 @@ module Arel # :nodoc: all
     def coalesce(*exprs)
       Nodes::NamedFunction.new "COALESCE", exprs
     end
+
+    def cast(name, type)
+      Nodes::NamedFunction.new "CAST", [name.as(type)]
+    end
   end
 end

data/lib/arel/filter_predications.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  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/and.rb

@@ -18,6 +18,10 @@ module Arel # :nodoc: all
         children[1]
       end
 
+      def fetch_attribute(&block)
+        children.any? && children.all? { |child| child.fetch_attribute(&block) }
+      end
+
       def hash
         children.hash
       end

data/lib/arel/nodes/binary.rb

@@ -39,6 +39,12 @@ module Arel # :nodoc: all
       end
     end
 
+    class As < Binary
+      def to_cte
+        Arel::Nodes::Cte.new(left.name, right)
+      end
+    end
+
     class Between < Binary; include FetchAttribute; end
 
     class GreaterThan < Binary
@@ -112,7 +118,6 @@ module Arel # :nodoc: all
     end
 
     %w{
-      As
       Assignment
       Join
       Union

data/lib/arel/nodes/bound_sql_literal.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class BoundSqlLiteral < NodeExpression
+      attr_reader :sql_with_placeholders, :positional_binds, :named_binds
+
+      def initialize(sql_with_placeholders, positional_binds, named_binds)
+        if !positional_binds.empty? && !named_binds.empty?
+          raise BindError.new("cannot mix positional and named binds", sql_with_placeholders)
+        elsif !positional_binds.empty?
+          if positional_binds.size != (expected = sql_with_placeholders.count("?"))
+            raise BindError.new("wrong number of bind variables (#{positional_binds.size} for #{expected})", sql_with_placeholders)
+          end
+        elsif !named_binds.empty?
+          tokens_in_string = sql_with_placeholders.scan(/:(?<!::)([a-zA-Z]\w*)/).flatten.map(&:to_sym).uniq
+          tokens_in_hash = named_binds.keys.map(&:to_sym).uniq
+
+          if !(missing = (tokens_in_string - tokens_in_hash)).empty?
+            if missing.size == 1
+              raise BindError.new("missing value for #{missing.first.inspect}", sql_with_placeholders)
+            else
+              raise BindError.new("missing values for #{missing.inspect}", sql_with_placeholders)
+            end
+          end
+        end
+
+        @sql_with_placeholders = sql_with_placeholders
+        if !positional_binds.empty?
+          @positional_binds = positional_binds
+          @named_binds = nil
+        else
+          @positional_binds = nil
+          @named_binds = named_binds
+        end
+      end
+
+      def hash
+        [self.class, sql_with_placeholders, positional_binds, named_binds].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          sql_with_placeholders == other.sql_with_placeholders &&
+          positional_binds == other.positional_binds &&
+          named_binds == other.named_binds
+      end
+      alias :== :eql?
+
+      def +(other)
+        raise ArgumentError, "Expected Arel node" unless Arel.arel_node?(other)
+
+        Fragments.new([self, other])
+      end
+
+      def inspect
+        "#<#{self.class.name} #{sql_with_placeholders.inspect} #{(named_binds || positional_binds).inspect}>"
+      end
+    end
+  end
+end

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/cte.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Cte < Arel::Nodes::Binary
+      alias :name :left
+      alias :relation :right
+      attr_reader :materialized
+
+      def initialize(name, relation, materialized: nil)
+        super(name, relation)
+        @materialized = materialized
+      end
+
+      def hash
+        [name, relation, materialized].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.name == other.name &&
+          self.relation == other.relation &&
+          self.materialized == other.materialized
+      end
+      alias :== :eql?
+
+      def to_cte
+        self
+      end
+
+      def to_table
+        Arel::Table.new(name)
+      end
+    end
+  end
+end

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 # :nodoc: all
+  module Nodes
+    class Filter < Binary
+      include Arel::WindowPredications
+      include Arel::AliasPredication
+    end
+  end
+end

data/lib/arel/nodes/fragments.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Fragments < Arel::Nodes::Node
+      attr_reader :values
+
+      def initialize(values = [])
+        super()
+        @values = values
+      end
+
+      def initialize_copy(other)
+        super
+        @values = @values.clone
+      end
+
+      def hash
+        [@values].hash
+      end
+
+      def +(other)
+        raise ArgumentError, "Expected Arel node" unless Arel.arel_node?(other)
+
+        self.class.new([*@values, other])
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.values == other.values
+      end
+      alias :== :eql?
+    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/homogeneous_in.rb

@@ -36,14 +36,6 @@ module Arel # :nodoc: all
         attribute.quoted_array(values)
       end
 
-      def table_name
-        attribute.relation.table_alias || attribute.relation.name
-      end
-
-      def column_name
-        attribute.name
-      end
-
       def casted_values
         type = attribute.type_caster
 
@@ -56,7 +48,7 @@ module Arel # :nodoc: all
       end
 
       def proc_for_binds
-        -> value { ActiveModel::Attribute.with_cast_value(attribute.name, value, attribute.type_caster) }
+        -> value { ActiveModel::Attribute.with_cast_value(attribute.name, value, ActiveModel::Type.default_value) }
       end
 
       def fetch_attribute(&block)

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/leading_join.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class LeadingJoin < Arel::Nodes::InnerJoin
+    end
+  end
+end

data/lib/arel/nodes/node.rb

@@ -2,8 +2,117 @@
 
 module Arel # :nodoc: all
   module Nodes
-    ###
-    # Abstract base class for all AST nodes
+    # = Using +Arel::Nodes::Node+
+    #
+    # Active Record uses Arel to compose SQL statements. Instead of building SQL strings directly, it's building an
+    # abstract syntax tree (AST) of the statement using various types of Arel::Nodes::Node. Each node represents a
+    # fragment of a SQL statement.
+    #
+    # The intermediate representation allows Arel to compile the statement into the database's specific SQL dialect
+    # only before sending it without having to care about the nuances of each database when building the statement.
+    # It also allows easier composition of statements without having to resort to (brittle and unsafe) string manipulation.
+    #
+    # == Building constraints
+    #
+    # One of the most common use cases of Arel is generating constraints for +SELECT+ statements. To help with that,
+    # most nodes include a couple of useful factory methods to create subtree structures for common constraints. For
+    # a full list of those, please refer to Arel::Predications.
+    #
+    # The following example creates an equality constraint where the value of the name column on the users table
+    # matches the value DHH.
+    #
+    #   users = Arel::Table.new(:users)
+    #   constraint = users[:name].eq("DHH")
+    #
+    #   # => Arel::Nodes::Equality.new(
+    #   #      Arel::Attributes::Attribute.new(users, "name"),
+    #   #      Arel::Nodes::Casted.new(
+    #   #        "DHH",
+    #   #        Arel::Attributes::Attribute.new(users, "name")
+    #   #      )
+    #   #    )
+    #
+    # The resulting SQL fragment will look like this:
+    #
+    #   "users"."name" = 'DHH'
+    #
+    # The constraint fragments can be used with regular ActiveRecord::Relation objects instead of a Hash. The
+    # following two examples show two ways of creating the same query.
+    #
+    #   User.where(name: 'DHH')
+    #
+    #   # SELECT "users".* FROM "users" WHERE "users"."name" = 'DHH'
+    #
+    #   users = User.arel_table
+    #
+    #   User.where(users[:name].eq('DHH'))
+    #
+    #   # SELECT "users".* FROM "users" WHERE "users"."name" = 'DHH'
+    #
+    # == Functions
+    #
+    # Arel comes with built-in support for SQL functions like +COUNT+, +SUM+, +MIN+, +MAX+, and +AVG+. The
+    # Arel::Expressions module includes factory methods for the default functions.
+    #
+    #   employees = Employee.arel_table
+    #
+    #   Employee.select(employees[:department_id], employees[:salary].average).group(employees[:department_id])
+    #
+    #   # SELECT "employees"."department_id", AVG("employees"."salary")
+    #   #   FROM "employees" GROUP BY "employees"."department_id"
+    #
+    # It’s also possible to use custom functions by using the Arel::Nodes::NamedFunction node type. It accepts a
+    # function name and an array of parameters.
+    #
+    #   Arel::Nodes::NamedFunction.new('date_trunc', [Arel::Nodes.build_quoted('day'), User.arel_table[:created_at]])
+    #
+    #   # date_trunc('day', "users"."created_at")
+    #
+    # == Quoting & bind params
+    #
+    # Values that you pass to Arel nodes need to be quoted or wrapped in bind params. This ensures they are properly
+    # converted into the correct format without introducing a possible SQL injection vulnerability. Most factory
+    # methods (like +eq+, +gt+, +lteq+, …) quote passed values automatically. When not using a factory method, it’s
+    # possible to convert a value and wrap it in an Arel::Nodes::Quoted node (if necessary) by calling +Arel::Nodes.
+    # build_quoted+.
+    #
+    #   Arel::Nodes.build_quoted("foo") # 'foo'
+    #   Arel::Nodes.build_quoted(12.3)  # 12.3
+    #
+    # Instead of quoting values and embedding them directly in the SQL statement, it’s also possible to create bind
+    # params. This keeps the actual values outside of the statement and allows using the prepared statement feature
+    # of some databases.
+    #
+    #   attribute = ActiveRecord::Relation::QueryAttribute.new(:name, "DHH", ActiveRecord::Type::String.new)
+    #   Arel::Nodes::BindParam.new(attribute)
+    #
+    # When ActiveRecord runs the query, bind params are replaced by placeholders (like +$1+) and the values are passed
+    # separately.
+    #
+    # == SQL Literals
+    #
+    # For cases where there is no way to represent a particular SQL fragment using Arel nodes, you can use an SQL
+    # literal. SQL literals are strings that Arel will treat “as is”.
+    #
+    #   Arel.sql('LOWER("users"."name")').eq('dhh')
+    #
+    #   # LOWER("users"."name") = 'dhh'
+    #
+    # Please keep in mind that passing data as raw SQL literals might introduce a possible SQL injection. However,
+    # `Arel.sql` supports binding parameters which will ensure proper quoting. This can be useful when you need to
+    # control the exact SQL you run, but you still have potentially user-supplied values.
+    #
+    #   Arel.sql('LOWER("users"."name") = ?', 'dhh')
+    #
+    #   # LOWER("users"."name") = 'dhh'
+    #
+    # You can also combine SQL literals.
+    #
+    #   sql = Arel.sql('SELECT * FROM "users" WHERE ')
+    #   sql += Arel.sql('LOWER("users"."name") = :name', name: 'dhh')
+    #   sql += Arel.sql('AND "users"."age" > :age', age: 35)
+    #
+    #   # SELECT * FROM "users" WHERE LOWER("users"."name") = 'dhh' AND "users"."age" > '35'
     class Node
       include Arel::FactoryMethods
 

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/sql_literal.rb

@@ -14,6 +14,12 @@ module Arel # :nodoc: all
 
       def fetch_attribute
       end
+
+      def +(other)
+        raise ArgumentError, "Expected Arel node" unless Arel.arel_node?(other)
+
+        Fragments.new([self, other])
+      end
     end
   end
 end

data/lib/arel/nodes/table_alias.rb

@@ -26,6 +26,10 @@ module Arel # :nodoc: all
       def able_to_type_cast?
         relation.respond_to?(:able_to_type_cast?) && relation.able_to_type_cast?
       end
+
+      def to_cte
+        Arel::Nodes::Cte.new(name, relation)
+      end
     end
   end
 end

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 &&