activerecord 6.1.6 → 7.1.2

data/lib/arel/visitors/to_sql.rb

@@ -103,7 +103,7 @@ module Arel # :nodoc: all
             row.each_with_index do |value, k|
               collector << ", " unless k == 0
               case value
-              when Nodes::SqlLiteral, Nodes::BindParam
+              when Nodes::SqlLiteral, Nodes::BindParam, ActiveModel::Attribute
                 collector = visit(value, collector)
               else
                 collector << quote(value).to_s
@@ -135,6 +135,8 @@ module Arel # :nodoc: all
           visit_Arel_Nodes_SelectOptions(o, collector)
         end
 
+        # The Oracle enhanced adapter uses this private method,
+        # see https://github.com/rsim/oracle-enhanced/issues/2186
         def visit_Arel_Nodes_SelectOptions(o, collector)
           collector = maybe_visit o.limit, collector
           collector = maybe_visit o.offset, collector
@@ -243,6 +245,13 @@ module Arel # :nodoc: all
           collector << ")"
         end
 
+        def visit_Arel_Nodes_Filter(o, collector)
+          visit o.left, collector
+          collector << " FILTER (WHERE "
+          visit o.right, collector
+          collector << ")"
+        end
+
         def visit_Arel_Nodes_Rows(o, collector)
           if o.expr
             collector << "ROWS "
@@ -324,7 +333,7 @@ module Arel # :nodoc: all
         def visit_Arel_Nodes_HomogeneousIn(o, collector)
           collector.preparable = false
 
-          collector << quote_table_name(o.table_name) << "." << quote_column_name(o.column_name)
+          visit o.left, collector
 
           if o.type == :in
             collector << " IN ("
@@ -341,7 +350,6 @@ module Arel # :nodoc: all
           end
 
           collector << ")"
-          collector
         end
 
         def visit_Arel_SelectManager(o, collector)
@@ -357,6 +365,17 @@ module Arel # :nodoc: all
           visit(o.expr, collector) << " DESC"
         end
 
+        # NullsFirst is available on all but MySQL, where it is redefined.
+        def visit_Arel_Nodes_NullsFirst(o, collector)
+          visit o.expr, collector
+          collector << " NULLS FIRST"
+        end
+
+        def visit_Arel_Nodes_NullsLast(o, collector)
+          visit o.expr, collector
+          collector << " NULLS LAST"
+        end
+
         def visit_Arel_Nodes_Group(o, collector)
           visit o.expr, collector
         end
@@ -412,24 +431,48 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Nodes_GreaterThanOrEqual(o, collector)
+          case unboundable?(o.right)
+          when 1
+            return collector << "1=0"
+          when -1
+            return collector << "1=1"
+          end
           collector = visit o.left, collector
           collector << " >= "
           visit o.right, collector
         end
 
         def visit_Arel_Nodes_GreaterThan(o, collector)
+          case unboundable?(o.right)
+          when 1
+            return collector << "1=0"
+          when -1
+            return collector << "1=1"
+          end
           collector = visit o.left, collector
           collector << " > "
           visit o.right, collector
         end
 
         def visit_Arel_Nodes_LessThanOrEqual(o, collector)
+          case unboundable?(o.right)
+          when 1
+            return collector << "1=1"
+          when -1
+            return collector << "1=0"
+          end
           collector = visit o.left, collector
           collector << " <= "
           visit o.right, collector
         end
 
         def visit_Arel_Nodes_LessThan(o, collector)
+          case unboundable?(o.right)
+          when 1
+            return collector << "1=1"
+          when -1
+            return collector << "1=0"
+          end
           collector = visit o.left, collector
           collector << " < "
           visit o.right, collector
@@ -525,11 +568,17 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Table(o, collector)
-          if o.table_alias
-            collector << quote_table_name(o.name) << " " << quote_table_name(o.table_alias)
+          if Arel::Nodes::Node === o.name
+            visit o.name, collector
           else
             collector << quote_table_name(o.name)
           end
+
+          if o.table_alias
+            collector << " " << quote_table_name(o.table_alias)
+          end
+
+          collector
         end
 
         def visit_Arel_Nodes_In(o, collector)
@@ -585,7 +634,7 @@ module Arel # :nodoc: all
 
         def visit_Arel_Nodes_Assignment(o, collector)
           case o.right
-          when Arel::Nodes::Node, Arel::Attributes::Attribute
+          when Arel::Nodes::Node, Arel::Attributes::Attribute, ActiveModel::Attribute
             collector = visit o.left, collector
             collector << " = "
             visit o.right, collector
@@ -685,6 +734,20 @@ module Arel # :nodoc: all
           collector << quote_column_name(o.name)
         end
 
+        def visit_Arel_Nodes_Cte(o, collector)
+          collector << quote_table_name(o.name)
+          collector << " AS "
+
+          case o.materialized
+          when true
+            collector << "MATERIALIZED "
+          when false
+            collector << "NOT MATERIALIZED "
+          end
+
+          visit o.relation, collector
+        end
+
         def visit_Arel_Attributes_Attribute(o, collector)
           join_name = o.relation.table_alias || o.relation.name
           collector << quote_table_name(join_name) << "." << quote_column_name(o.name)
@@ -695,6 +758,10 @@ module Arel # :nodoc: all
 
         def bind_block; BIND_BLOCK; end
 
+        def visit_ActiveModel_Attribute(o, collector)
+          collector.add_bind(o, &bind_block)
+        end
+
         def visit_Arel_Nodes_BindParam(o, collector)
           collector.add_bind(o.value, &bind_block)
         end
@@ -704,6 +771,59 @@ module Arel # :nodoc: all
           collector << o.to_s
         end
 
+        def visit_Arel_Nodes_BoundSqlLiteral(o, collector)
+          bind_index = 0
+
+          new_bind = lambda do |value|
+            if Arel.arel_node?(value)
+              visit value, collector
+            elsif value.is_a?(Array)
+              if value.empty?
+                collector << @connection.quote(nil)
+              else
+                if value.none? { |v| Arel.arel_node?(v) }
+                  collector.add_binds(value.map { |v| @connection.cast_bound_value(v) }, &bind_block)
+                else
+                  value.each_with_index do |v, i|
+                    collector << ", " unless i == 0
+                    if Arel.arel_node?(v)
+                      visit v, collector
+                    else
+                      collector.add_bind(@connection.cast_bound_value(v), &bind_block)
+                    end
+                  end
+                end
+              end
+            else
+              collector.add_bind(@connection.cast_bound_value(value), &bind_block)
+            end
+          end
+
+          if o.positional_binds
+            o.sql_with_placeholders.scan(/\?|([^?]+)/) do
+              if $1
+                collector << $1
+              else
+                value = o.positional_binds[bind_index]
+                bind_index += 1
+
+                new_bind.call(value)
+              end
+            end
+          else
+            o.sql_with_placeholders.scan(/:(?<!::)([a-zA-Z]\w*)|([^:]+|.)/) do
+              if $2
+                collector << $2
+              else
+                value = o.named_binds[$1.to_sym]
+                new_bind.call(value)
+              end
+            end
+          end
+
+          collector
+        end
+
         def visit_Integer(o, collector)
           collector << o.to_s
         end
@@ -743,6 +863,10 @@ module Arel # :nodoc: all
         end
         alias :visit_Set :visit_Array
 
+        def visit_Arel_Nodes_Fragments(o, collector)
+          inject_join o.values, collector, " "
+        end
+
         def quote(value)
           return value if Arel::Nodes::SqlLiteral === value
           @connection.quote value
@@ -793,6 +917,10 @@ module Arel # :nodoc: all
           o.limit || o.offset || !o.orders.empty?
         end
 
+        def has_group_by_and_having?(o)
+          !o.groups.empty? && !o.havings.empty?
+        end
+
         # The default strategy for an UPDATE with joins is to use a subquery. This doesn't work
         # on MySQL (even when aliasing the tables), but MySQL allows using JOIN directly in
         # an UPDATE statement, so in the MySQL visitor we redefine this to do that.
@@ -804,6 +932,8 @@ module Arel # :nodoc: all
             stmt.orders = []
             stmt.wheres = [Nodes::In.new(o.key, [build_subselect(o.key, o)])]
             stmt.relation = o.relation.left if has_join_sources?(o)
+            stmt.groups = o.groups unless o.groups.empty?
+            stmt.havings = o.havings unless o.havings.empty?
             stmt
           else
             o
@@ -818,6 +948,8 @@ module Arel # :nodoc: all
           core.froms       = o.relation
           core.wheres      = o.wheres
           core.projections = [key]
+          core.groups      = o.groups unless o.groups.empty?
+          core.havings     = o.havings unless o.havings.empty?
           stmt.limit       = o.limit
           stmt.offset      = o.offset
           stmt.orders      = o.orders
@@ -877,19 +1009,7 @@ module Arel # :nodoc: all
         def collect_ctes(children, collector)
           children.each_with_index do |child, i|
             collector << ", " unless i == 0
-
-            case child
-            when Arel::Nodes::As
-              name = child.left.name
-              relation = child.right
-            when Arel::Nodes::TableAlias
-              name = child.name
-              relation = child.relation
-            end
-
-            collector << quote_table_name(name)
-            collector << " AS "
-            visit relation, collector
+            visit child.to_cte, collector
           end
 
           collector

data/lib/arel/visitors/visitor.rb

@@ -16,8 +16,8 @@ module Arel # :nodoc: all
 
         def self.dispatch_cache
           @dispatch_cache ||= Hash.new do |hash, klass|
-            hash[klass] = "visit_#{(klass.name || '').gsub('::', '_')}"
-          end
+            hash[klass] = :"visit_#{(klass.name || "").gsub("::", "_")}"
+          end.compare_by_identity
         end
 
         def get_dispatch_cache

data/lib/arel.rb

@@ -7,6 +7,7 @@ require "arel/factory_methods"
 
 require "arel/expressions"
 require "arel/predications"
+require "arel/filter_predications"
 require "arel/window_predications"
 require "arel/math"
 require "arel/alias_predication"
@@ -29,13 +30,27 @@ module Arel
 
   # Wrap a known-safe SQL string for passing to query methods, e.g.
   #
-  #   Post.order(Arel.sql("length(title)")).last
+  #   Post.order(Arel.sql("REPLACE(title, 'misc', 'zzzz') asc")).pluck(:id)
   #
   # Great caution should be taken to avoid SQL injection vulnerabilities.
   # This method should not be used with unsafe values such as request
   # parameters or model attributes.
-  def self.sql(raw_sql)
-    Arel::Nodes::SqlLiteral.new raw_sql
+  #
+  # Take a look at the {security guide}[https://guides.rubyonrails.org/security.html#sql-injection]
+  # for more information.
+  #
+  # To construct a more complex query fragment, including the possible
+  # use of user-provided values, the +sql_string+ may contain <tt>?</tt> and
+  # +:key+ placeholders, corresponding to the additional arguments. Note
+  # that this behavior only applies when bind value parameters are
+  # supplied in the call; without them, the placeholder tokens have no
+  # special meaning, and will be passed through to the query as-is.
+  def self.sql(sql_string, *positional_binds, **named_binds)
+    if positional_binds.empty? && named_binds.empty?
+      Arel::Nodes::SqlLiteral.new sql_string
+    else
+      Arel::Nodes::BoundSqlLiteral.new sql_string, positional_binds, named_binds
+    end
   end
 
   def self.star # :nodoc:

data/lib/rails/generators/active_record/application_record/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates an `ApplicationRecord` base class for other models to inherit from.
+
+Example:
+    `bin/rails generate application_record`
+
+    This generates the base class. A test is not generated because no
+    behaviour is included in `ApplicationRecord` by default.

data/lib/rails/generators/active_record/application_record/templates/application_record.rb.tt

@@ -1,5 +1,5 @@
 <% module_namespacing do -%>
 class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
+  primary_abstract_class
 end
 <% end -%>

data/lib/rails/generators/active_record/migration.rb

@@ -41,11 +41,13 @@ module ActiveRecord
 
         def configured_migrate_path
           return unless database = options[:database]
+
           config = ActiveRecord::Base.configurations.configs_for(
             env_name: Rails.env,
             name: database
           )
-          config&.migrations_paths
+
+          Array(config&.migrations_paths).first
         end
     end
   end

data/lib/rails/generators/active_record/model/USAGE

@@ -0,0 +1,113 @@
+Description:
+    Generates a new model. Pass the model name, either CamelCased or
+    under_scored, and an optional list of attribute pairs as arguments.
+
+    Attribute pairs are field:type arguments specifying the
+    model's attributes. Timestamps are added by default, so you don't have to
+    specify them by hand as 'created_at:datetime updated_at:datetime'.
+
+    As a special case, specifying 'password:digest' will generate a
+    password_digest field of string type, and configure your generated model and
+    tests for use with Active Model has_secure_password (assuming the default ORM
+    and test framework are being used).
+
+    You don't have to think up every attribute up front, but it helps to
+    sketch out a few so you can start working with the model immediately.
+
+    This generator invokes your configured ORM and test framework, which
+    defaults to Active Record and TestUnit.
+
+    Finally, if --parent option is given, it's used as superclass of the
+    created model. This allows you create Single Table Inheritance models.
+
+    If you pass a namespaced model name (e.g. admin/account or Admin::Account)
+    then the generator will create a module with a table_name_prefix method
+    to prefix the model's table name with the module name (e.g. admin_accounts)
+
+Available field types:
+
+    Just after the field name you can specify a type like text or boolean.
+    It will generate the column with the associated SQL type. For instance:
+
+        `bin/rails generate model post title:string body:text`
+
+    will generate a title column with a varchar type and a body column with a text
+    type. If no type is specified the string type will be used by default.
+    You can use the following types:
+
+        integer
+        primary_key
+        decimal
+        float
+        boolean
+        binary
+        string
+        text
+        date
+        time
+        datetime
+
+    You can also consider `references` as a kind of type. For instance, if you run:
+
+        `bin/rails generate model photo title:string album:references`
+
+    It will generate an `album_id` column. You should generate these kinds of fields when
+    you will use a `belongs_to` association, for instance. `references` also supports
+    polymorphism, you can enable polymorphism like this:
+
+        `bin/rails generate model product supplier:references{polymorphic}`
+
+    For integer, string, text and binary fields, an integer in curly braces will
+    be set as the limit:
+
+        `bin/rails generate model user pseudo:string{30}`
+
+    For decimal, two integers separated by a comma in curly braces will be used
+    for precision and scale:
+
+        `bin/rails generate model product 'price:decimal{10,2}'`
+
+    You can add a `:uniq` or `:index` suffix for unique or standard indexes
+    respectively:
+
+        `bin/rails generate model user pseudo:string:uniq`
+        `bin/rails generate model user pseudo:string:index`
+
+    You can combine any single curly brace option with the index options:
+
+        `bin/rails generate model user username:string{30}:uniq`
+        `bin/rails generate model product supplier:references{polymorphic}:index`
+
+    If you require a `password_digest` string column for use with
+    has_secure_password, you can specify `password:digest`:
+
+        `bin/rails generate model user password:digest`
+
+    If you require a `token` string column for use with
+    has_secure_token, you can specify `auth_token:token`:
+
+        `bin/rails generate model user auth_token:token`
+
+Examples:
+    `bin/rails generate model account`
+
+        For Active Record and TestUnit it creates:
+
+            Model:      app/models/account.rb
+            Test:       test/models/account_test.rb
+            Fixtures:   test/fixtures/accounts.yml
+            Migration:  db/migrate/XXX_create_accounts.rb
+
+    `bin/rails generate model post title:string body:text published:boolean`
+
+        Creates a Post model with a string title, text body, and published flag.
+
+    `bin/rails generate model admin/account`
+
+        For Active Record and TestUnit it creates:
+
+            Module:     app/models/admin.rb
+            Model:      app/models/admin/account.rb
+            Test:       test/models/admin/account_test.rb
+            Fixtures:   test/fixtures/admin/accounts.yml
+            Migration:  db/migrate/XXX_create_admin_accounts.rb

data/lib/rails/generators/active_record/model/model_generator.rb

@@ -11,20 +11,25 @@ module ActiveRecord
 
       class_option :migration, type: :boolean
       class_option :timestamps, type: :boolean
-      class_option :parent, type: :string, desc: "The parent class for the generated model"
+      class_option :parent, type: :string, default: "ApplicationRecord", desc: "The parent class for the generated model"
       class_option :indexes, type: :boolean, default: true, desc: "Add indexes for references and belongs_to columns"
       class_option :primary_key_type, type: :string, desc: "The type for primary key"
       class_option :database, type: :string, aliases: %i(--db), desc: "The database for your model's migration. By default, the current environment's primary database is used."
 
+      Rails::Generators.templates_path.each do |path|
+        source_paths << File.join(path, base_name, "migration")
+      end
+      source_paths << File.expand_path(File.join(base_name, "migration", "templates"), base_root)
+
       # creates the migration file for the model.
       def create_migration_file
         return if skip_migration_creation?
         attributes.each { |a| a.attr_options.delete(:index) if a.reference? && !a.has_index? } if options[:indexes] == false
-        migration_template "../../migration/templates/create_table_migration.rb", File.join(db_migrate_path, "create_#{table_name}.rb")
+        migration_template "create_table_migration.rb", File.join(db_migrate_path, "create_#{table_name}.rb")
       end
 
       def create_model_file
-        generate_abstract_class if database && !parent
+        generate_abstract_class if database && !custom_parent?
         template "model.rb", File.join("app/models", class_path, "#{file_name}.rb")
       end
 
@@ -40,7 +45,7 @@ module ActiveRecord
         #   - options parent is present and database option is not present
         #   - migrations option is nil or false
         def skip_migration_creation?
-          parent && !database || !migration
+          custom_parent? && !database || !migration
         end
 
         def attributes_with_index
@@ -49,12 +54,12 @@ module ActiveRecord
 
         # Used by the migration template to determine the parent name of the model
         def parent_class_name
-          if parent
+          if custom_parent?
             parent
           elsif database
             abstract_class_name
           else
-            "ApplicationRecord"
+            parent
           end
         end
 
@@ -77,6 +82,10 @@ module ActiveRecord
           options[:parent]
         end
 
+        def custom_parent?
+          parent != self.class.class_options[:parent].default
+        end
+
         def migration
           options[:migration]
         end

data/lib/rails/generators/active_record/model/templates/abstract_base_class.rb.tt

@@ -2,6 +2,6 @@
 class <%= abstract_class_name %> < ApplicationRecord
   self.abstract_class = true
 
-  connects_to database: { <%= ActiveRecord::Base.writing_role %>: :<%= database -%> }
+  connects_to database: { <%= ActiveRecord.writing_role %>: :<%= database -%> }
 end
 <% end -%>

data/lib/rails/generators/active_record/model/templates/model.rb.tt

@@ -1,7 +1,7 @@
 <% module_namespacing do -%>
 class <%= class_name %> < <%= parent_class_name.classify %>
 <% attributes.select(&:reference?).each do |attribute| -%>
-  belongs_to :<%= attribute.name %><%= ', polymorphic: true' if attribute.polymorphic? %>
+  belongs_to :<%= attribute.name %><%= ", polymorphic: true" if attribute.polymorphic? %>
 <% end -%>
 <% attributes.select(&:rich_text?).each do |attribute| -%>
   has_rich_text :<%= attribute.name %>

data/lib/rails/generators/active_record/model/templates/module.rb.tt

@@ -1,7 +1,7 @@
 <% module_namespacing do -%>
-module <%= class_path.map(&:camelize).join('::') %>
+module <%= class_path.map(&:camelize).join("::") %>
   def self.table_name_prefix
-    '<%= namespaced? ? namespaced_class_path.join('_') : class_path.join('_') %>_'
+    "<%= namespaced? ? namespaced_class_path.join("_") : class_path.join("_") %>_"
   end
 end
 <% end -%>

data/lib/rails/generators/active_record/multi_db/multi_db_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module ActiveRecord
+  module Generators # :nodoc:
+    class MultiDbGenerator < ::Rails::Generators::Base # :nodoc:
+      source_root File.expand_path("templates", __dir__)
+
+      def create_multi_db
+        filename = "multi_db.rb"
+        template filename, "config/initializers/#{filename}"
+      end
+    end
+  end
+end

data/lib/rails/generators/active_record/multi_db/templates/multi_db.rb.tt

@@ -0,0 +1,44 @@
+# Multi-db Configuration
+#
+# This file is used for configuration settings related to multiple databases.
+#
+# Enable Database Selector
+#
+# Inserts middleware to perform automatic connection switching.
+# The `database_selector` hash is used to pass options to the DatabaseSelector
+# middleware. The `delay` is used to determine how long to wait after a write
+# to send a subsequent read to the primary.
+#
+# The `database_resolver` class is used by the middleware to determine which
+# database is appropriate to use based on the time delay.
+#
+# The `database_resolver_context` class is used by the middleware to set
+# timestamps for the last write to the primary. The resolver uses the context
+# class timestamps to determine how long to wait before reading from the
+# replica.
+#
+# By default Rails will store a last write timestamp in the session. The
+# DatabaseSelector middleware is designed as such you can define your own
+# strategy for connection switching and pass that into the middleware through
+# these configuration options.
+#
+# Rails.application.configure do
+#   config.active_record.database_selector = { delay: 2.seconds }
+#   config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
+#   config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+# end
+#
+# Enable Shard Selector
+#
+# Inserts middleware to perform automatic shard swapping. The `shard_selector` hash
+# can be used to pass options to the `ShardSelector` middleware. The `lock` option is
+# used to determine whether shard swapping should be prohibited for the request.
+#
+# The `shard_resolver` option is used by the middleware to determine which shard
+# to switch to. The application must provide a mechanism for finding the shard name
+# in a proc. See guides for an example.
+#
+# Rails.application.configure do
+#   config.active_record.shard_selector = { lock: true }
+#   config.active_record.shard_resolver = ->(request) { Tenant.find_by!(host: request.host).shard }
+# end