activerecord 7.0.8.7 → 7.2.2.1

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/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/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/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)
@@ -23,7 +23,7 @@ module Arel # :nodoc: all
       end
 
       def hash
-        children.hash
+        [self.class, children].hash
       end
 
       def eql?(other)
@@ -32,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,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
 
@@ -18,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
 
       ###
@@ -38,8 +147,9 @@ 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
 
       def fetch_attribute

data/lib/arel/nodes/sql_literal.rb

@@ -8,12 +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

@@ -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.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
 
@@ -38,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.
@@ -63,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

@@ -53,6 +53,8 @@ module Arel # :nodoc: all
         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)
@@ -230,7 +232,7 @@ module Arel # :nodoc: all
       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
 

data/lib/arel/select_manager.rb

@@ -46,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"))

data/lib/arel/table.rb

@@ -8,13 +8,17 @@ module Arel # :nodoc: all
     @engine = nil
     class << self; attr_accessor :engine; end
 
-    attr_accessor :name, :table_alias
-
-    # TableAlias and Table both have a #table_name which is the name of the underlying table
-    alias :table_name :name
+    attr_accessor :name
+    attr_reader :table_alias
 
     def initialize(name, as: nil, klass: nil, type_caster: klass&.type_caster)
-      @name = name.to_s
+      @name =
+        case name
+        when Symbol then name.to_s
+        else
+          name
+        end
+
       @klass = klass
       @type_caster = type_caster
 

data/lib/arel/tree_manager.rb

@@ -21,7 +21,11 @@ module Arel # :nodoc: all
       end
 
       def key=(key)
-        @ast.key = Nodes.build_quoted(key)
+        @ast.key = if key.is_a?(Array)
+          key.map { |k| Nodes.build_quoted(k) }
+        else
+          Nodes.build_quoted(key)
+        end
       end
 
       def key
@@ -48,8 +52,9 @@ module Arel # :nodoc: all
 
     def to_sql(engine = Table.engine)
       collector = Arel::Collectors::SQLString.new
-      collector = engine.connection.visitor.accept @ast, collector
-      collector.value
+      engine.with_connection do |connection|
+        connection.visitor.accept(@ast, collector).value
+      end
     end
 
     def initialize_copy(other)

data/lib/arel/update_manager.rb

@@ -16,7 +16,8 @@ module Arel # :nodoc: all
     end
 
     def set(values)
-      if String === values
+      case values
+      when String, Nodes::BoundSqlLiteral
         @ast.values = [values]
       else
         @ast.values = values.map { |column, value|

data/lib/arel/visitors/dot.rb

@@ -191,6 +191,7 @@ module Arel # :nodoc: all
           end
         end
         alias :visit_Arel_Nodes_And :visit__children
+        alias :visit_Arel_Nodes_Or :visit__children
         alias :visit_Arel_Nodes_With :visit__children
 
         def visit_String(o)

data/lib/arel/visitors/mysql.rb

@@ -5,8 +5,9 @@ module Arel # :nodoc: all
     class MySQL < Arel::Visitors::ToSql
       private
         def visit_Arel_Nodes_Bin(o, collector)
-          collector << "BINARY "
+          collector << "CAST("
           visit o.expr, collector
+          collector << " AS BINARY)"
         end
 
         def visit_Arel_Nodes_UnqualifiedColumn(o, collector)
@@ -26,7 +27,7 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Nodes_SelectCore(o, collector)
-          o.froms ||= Arel.sql("DUAL")
+          o.froms ||= Arel.sql("DUAL", retryable: true)
           super
         end
 
@@ -58,9 +59,20 @@ module Arel # :nodoc: all
           infix_value o, collector, " NOT REGEXP "
         end
 
-        # no-op
         def visit_Arel_Nodes_NullsFirst(o, collector)
-          visit o.expr, collector
+          visit(o.expr.expr, collector) << " IS NOT NULL, "
+          visit(o.expr, collector)
+        end
+
+        def visit_Arel_Nodes_NullsLast(o, collector)
+          visit(o.expr.expr, collector) << " IS NULL, "
+          visit(o.expr, collector)
+        end
+
+        def visit_Arel_Nodes_Cte(o, collector)
+          collector << quote_table_name(o.name)
+          collector << " AS "
+          visit o.relation, collector
         end
 
         # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
@@ -91,7 +103,7 @@ module Arel # :nodoc: all
           Nodes::SelectStatement.new.tap do |stmt|
             core = stmt.cores.last
             core.froms = Nodes::Grouping.new(subselect).as("__active_record_temp")
-            core.projections = [Arel.sql(quote_column_name(key.name))]
+            core.projections = [Arel.sql(quote_column_name(key.name), retryable: true)]
           end
         end
     end

data/lib/arel/visitors/postgresql.rb

@@ -63,7 +63,7 @@ module Arel # :nodoc: all
 
         def visit_Arel_Nodes_Lateral(o, collector)
           collector << "LATERAL "
-          grouping_parentheses o, collector
+          grouping_parentheses o.expr, collector
         end
 
         def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
@@ -83,17 +83,6 @@ module Arel # :nodoc: all
 
         def bind_block; BIND_BLOCK; end
 
-        # Used by Lateral visitor to enclose select queries in parentheses
-        def grouping_parentheses(o, collector)
-          if o.expr.is_a? Nodes::SelectStatement
-            collector << "("
-            visit o.expr, collector
-            collector << ")"
-          else
-            visit o.expr, collector
-          end
-        end
-
         # Utilized by GroupingSet, Cube & RollUp visitors to
         # handle grouping aggregation semantics
         def grouping_array_or_grouping_element(o, collector)

data/lib/arel/visitors/sqlite.rb

@@ -33,6 +33,31 @@ module Arel # :nodoc: all
           collector << " IS NOT "
           visit o.right, collector
         end
+
+        # Queries used in UNION should not be wrapped by parentheses,
+        # because it is an invalid syntax in SQLite.
+        def infix_value_with_paren(o, collector, value, suppress_parens = false)
+          collector << "( " unless suppress_parens
+
+          left = o.left.is_a?(Nodes::Grouping) ? o.left.expr : o.left
+          collector = if left.class == o.class
+            infix_value_with_paren(left, collector, value, true)
+          else
+            grouping_parentheses left, collector, false
+          end
+
+          collector << value
+
+          right = o.right.is_a?(Nodes::Grouping) ? o.right.expr : o.right
+          collector = if right.class == o.class
+            infix_value_with_paren(right, collector, value, true)
+          else
+            grouping_parentheses right, collector, false
+          end
+
+          collector << " )" unless suppress_parens
+          collector
+        end
     end
   end
 end