activerecord 6.0.0 → 7.2.3

data/lib/arel/nodes/in.rb

@@ -2,7 +2,14 @@
 
 module Arel # :nodoc: all
   module Nodes
-    class In < Equality
+    class In < Arel::Nodes::Binary
+      include FetchAttribute
+
+      def equality?; true; end
+
+      def invert
+        Arel::Nodes::NotIn.new(left, right)
+      end
     end
   end
 end

data/lib/arel/nodes/infix_operation.rb

@@ -43,7 +43,19 @@ module Arel # :nodoc: all
 
     class Concat < InfixOperation
       def initialize(left, right)
-        super("||", left, right)
+        super(:"||", left, right)
+      end
+    end
+
+    class Contains < InfixOperation
+      def initialize(left, right)
+        super(:"@>", left, right)
+      end
+    end
+
+    class Overlaps < InfixOperation
+      def initialize(left, right)
+        super(:"&&", left, right)
       end
     end
 

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

@@ -5,7 +5,7 @@ module Arel # :nodoc: all
     ###
     # Class that represents a join source
     #
-    #   http://www.sqlite.org/syntaxdiagrams.html#join-source
+    #   https://www.sqlite.org/syntaxdiagrams.html#join-source
 
     class JoinSource < Arel::Nodes::Binary
       def initialize(single_source, joinop = [])

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/{and.rb → nary.rb}

@@ -2,7 +2,7 @@
 
 module Arel # :nodoc: all
   module Nodes
-    class And < Arel::Nodes::NodeExpression
+    class Nary < Arel::Nodes::NodeExpression
       attr_reader :children
 
       def initialize(children)
@@ -18,8 +18,12 @@ 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
+        [self.class, children].hash
       end
 
       def eql?(other)
@@ -28,5 +32,8 @@ module Arel # :nodoc: all
       end
       alias :== :eql?
     end
+
+    And = Class.new(Nary)
+    Or = Class.new(Nary)
   end
 end

data/lib/arel/nodes/node.rb

@@ -2,11 +2,119 @@
 
 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
-      include Enumerable
 
       ###
       # Factory method to create a Nodes::Not node that has the recipient of
@@ -19,7 +127,7 @@ module Arel # :nodoc: all
       # Factory method to create a Nodes::Grouping node that has an Nodes::Or
       # node as a child.
       def or(right)
-        Nodes::Grouping.new Nodes::Or.new(self, right)
+        Nodes::Grouping.new Nodes::Or.new([self, right])
       end
 
       ###
@@ -28,6 +136,10 @@ module Arel # :nodoc: all
         Nodes::And.new [self, right]
       end
 
+      def invert
+        Arel::Nodes::Not.new(self)
+      end
+
       # FIXME: this method should go away.  I don't like people calling
       # to_sql on non-head nodes.  This forces us to walk the AST until we
       # can find a node that has a "relation" member.
@@ -35,16 +147,15 @@ module Arel # :nodoc: all
       # Maybe we should just use `Table.engine`?  :'(
       def to_sql(engine = Table.engine)
         collector = Arel::Collectors::SQLString.new
-        collector = engine.connection.visitor.accept self, collector
-        collector.value
+        engine.with_connection do |connection|
+          connection.visitor.accept(self, collector).value
+        end
       end
 
-      # Iterate through AST, nodes will be yielded depth-first
-      def each(&block)
-        return enum_for(:each) unless block_given?
-
-        ::Arel::Visitors::DepthFirst.new(block).accept self
+      def fetch_attribute
       end
+
+      def equality?; false; end
     end
   end
 end

data/lib/arel/nodes/ordering.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Ordering < Unary
+      def nulls_first
+        NullsFirst.new(self)
+      end
+
+      def nulls_last
+        NullsLast.new(self)
+      end
+    end
+
+    class NullsFirst < Ordering
+      def reverse
+        NullsLast.new(expr.reverse)
+      end
+    end
+
+    class NullsLast < Ordering
+      def reverse
+        NullsFirst.new(expr.reverse)
+      end
+    end
+  end
+end

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

@@ -8,9 +8,25 @@ module Arel # :nodoc: all
       include Arel::AliasPredication
       include Arel::OrderPredications
 
+      attr_reader :retryable
+
+      def initialize(string, retryable: false)
+        @retryable = retryable
+        super(string)
+      end
+
       def encode_with(coder)
         coder.scalar = self.to_s
       end
+
+      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

@@ -8,20 +8,28 @@ module Arel # :nodoc: all
       alias :table_alias :name
 
       def [](name)
-        Attribute.new(self, name)
+        relation.is_a?(Table) ? relation[name, self] : Attribute.new(self, name)
       end
 
       def table_name
         relation.respond_to?(:name) ? relation.name : name
       end
 
-      def type_cast_for_database(*args)
-        relation.type_cast_for_database(*args)
+      def type_cast_for_database(attr_name, value)
+        relation.type_cast_for_database(attr_name, value)
+      end
+
+      def type_for_attribute(name)
+        relation.type_for_attribute(name)
       end
 
       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/unary.rb

@@ -36,7 +36,6 @@ module Arel # :nodoc: all
       Offset
       On
       OptimizerHints
-      Ordering
       RollUp
     }.each do |name|
       const_set(name, Class.new(Unary))

data/lib/arel/nodes/update_statement.rb

@@ -3,15 +3,19 @@
 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, :comment, :key
 
-      def initialize
-        @relation = nil
+      def initialize(relation = nil)
+        super()
+        @relation = relation
         @wheres   = []
         @values   = []
+        @groups   = []
+        @havings  = []
         @orders   = []
         @limit    = nil
         @offset   = nil
+        @comment  = nil
         @key      = nil
       end
 
@@ -22,7 +26,7 @@ module Arel # :nodoc: all
       end
 
       def hash
-        [@relation, @wheres, @values, @orders, @limit, @offset, @key].hash
+        [@relation, @wheres, @values, @orders, @limit, @offset, @comment, @key].hash
       end
 
       def eql?(other)
@@ -30,9 +34,12 @@ 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 &&
+          self.comment == other.comment &&
           self.key == other.key
       end
       alias :== :eql?

data/lib/arel/nodes.rb

@@ -8,6 +8,7 @@ require "arel/nodes/select_core"
 require "arel/nodes/insert_statement"
 require "arel/nodes/update_statement"
 require "arel/nodes/bind_param"
+require "arel/nodes/fragments"
 
 # terminal
 
@@ -18,6 +19,8 @@ require "arel/nodes/false"
 # unary
 require "arel/nodes/unary"
 require "arel/nodes/grouping"
+require "arel/nodes/homogeneous_in"
+require "arel/nodes/ordering"
 require "arel/nodes/ascending"
 require "arel/nodes/descending"
 require "arel/nodes/unqualified_column"
@@ -26,7 +29,8 @@ require "arel/nodes/with"
 # binary
 require "arel/nodes/binary"
 require "arel/nodes/equality"
-require "arel/nodes/in" # Why is this subclassed from equality?
+require "arel/nodes/filter"
+require "arel/nodes/in"
 require "arel/nodes/join_source"
 require "arel/nodes/delete_statement"
 require "arel/nodes/table_alias"
@@ -35,9 +39,10 @@ require "arel/nodes/unary_operation"
 require "arel/nodes/over"
 require "arel/nodes/matches"
 require "arel/nodes/regexp"
+require "arel/nodes/cte"
 
-# nary
-require "arel/nodes/and"
+# nary (And and Or)
+require "arel/nodes/nary"
 
 # function
 # FIXME: Function + Alias can be rewritten as a Function and Alias node.
@@ -60,9 +65,11 @@ require "arel/nodes/inner_join"
 require "arel/nodes/outer_join"
 require "arel/nodes/right_outer_join"
 require "arel/nodes/string_join"
+require "arel/nodes/leading_join"
 
 require "arel/nodes/comment"
 
 require "arel/nodes/sql_literal"
+require "arel/nodes/bound_sql_literal"
 
 require "arel/nodes/casted"

data/lib/arel/predications.rb

@@ -38,21 +38,27 @@ module Arel # :nodoc: all
       if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1
         self.in([])
       elsif open_ended?(other.begin)
-        if other.end.nil? || open_ended?(other.end)
-          not_in([])
+        if open_ended?(other.end)
+          if infinity?(other.begin) == 1 || infinity?(other.end) == -1
+            self.in([])
+          else
+            not_in([])
+          end
         elsif other.exclude_end?
           lt(other.end)
         else
           lteq(other.end)
         end
-      elsif other.end.nil? || open_ended?(other.end)
+      elsif open_ended?(other.end)
         gteq(other.begin)
       elsif other.exclude_end?
         gteq(other.begin).and(lt(other.end))
+      elsif other.begin == other.end
+        eq(other.begin)
       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
 
@@ -60,13 +66,6 @@ module Arel # :nodoc: all
       case other
       when Arel::SelectManager
         Arel::Nodes::In.new(self, other.ast)
-      when Range
-        if $VERBOSE
-          warn <<-eowarn
-Passing a range to `#in` is deprecated. Call `#between`, instead.
-          eowarn
-        end
-        between(other)
       when Enumerable
         Nodes::In.new self, quoted_array(other)
       else
@@ -86,14 +85,18 @@ Passing a range to `#in` is deprecated. Call `#between`, instead.
       if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1
         not_in([])
       elsif open_ended?(other.begin)
-        if other.end.nil? || open_ended?(other.end)
-          self.in([])
+        if open_ended?(other.end)
+          if infinity?(other.begin) == 1 || infinity?(other.end) == -1
+            not_in([])
+          else
+            self.in([])
+          end
         elsif other.exclude_end?
           gteq(other.end)
         else
           gt(other.end)
         end
-      elsif other.end.nil? || open_ended?(other.end)
+      elsif open_ended?(other.end)
         lt(other.begin)
       else
         left = lt(other.begin)
@@ -110,13 +113,6 @@ Passing a range to `#in` is deprecated. Call `#between`, instead.
       case other
       when Arel::SelectManager
         Arel::Nodes::NotIn.new(self, other.ast)
-      when Range
-        if $VERBOSE
-          warn <<-eowarn
-Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
-          eowarn
-        end
-        not_between(other)
       when Enumerable
         Nodes::NotIn.new self, quoted_array(other)
       else
@@ -220,12 +216,23 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
       Nodes::Concat.new self, other
     end
 
-    private
+    def contains(other)
+      Arel::Nodes::Contains.new self, quoted_node(other)
+    end
+
+    def overlaps(other)
+      Arel::Nodes::Overlaps.new self, quoted_node(other)
+    end
 
+    def quoted_array(others)
+      others.map { |v| quoted_node(v) }
+    end
+
+    private
       def grouping_any(method_id, others, *extras)
         nodes = others.map { |expr| send(method_id, expr, *extras) }
         Nodes::Grouping.new nodes.inject { |memo, node|
-          Nodes::Or.new(memo, node)
+          Nodes::Or.new([memo, node])
         }
       end
 
@@ -238,10 +245,6 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
         Nodes.build_quoted(other, self)
       end
 
-      def quoted_array(others)
-        others.map { |v| quoted_node(v) }
-      end
-
       def infinity?(value)
         value.respond_to?(:infinite?) && value.infinite?
       end
@@ -251,7 +254,7 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
       end
 
       def open_ended?(value)
-        infinity?(value) || unboundable?(value)
+        value.nil? || infinity?(value) || unboundable?(value)
       end
   end
 end

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)
@@ -48,7 +46,7 @@ module Arel # :nodoc: all
     end
 
     def as(other)
-      create_table_alias grouping(@ast), Nodes::SqlLiteral.new(other)
+      create_table_alias grouping(@ast), Nodes::SqlLiteral.new(other, retryable: true)
     end
 
     def lock(locking = Arel.sql("FOR UPDATE"))
@@ -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,11 +181,18 @@ 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?
 
-      viz = Visitors::WhereSql.new(engine.connection.visitor, engine.connection)
-      Nodes::SqlLiteral.new viz.accept(@ctx, Collectors::SQLString.new).value
+      Nodes::SqlLiteral.new("WHERE #{Nodes::And.new(@ctx.wheres).to_sql(engine)}")
     end
 
     def union(operation, other = nil)
@@ -245,8 +250,12 @@ module Arel # :nodoc: all
     end
 
     def comment(*values)
-      @ctx.comment = Nodes::Comment.new(values)
-      self
+      if values.any?
+        @ctx.comment = Nodes::Comment.new(values)
+        self
+      else
+        @ctx.comment
+      end
     end
 
     private