activerecord 5.2.8.1 → 6.1.6.1

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -9,10 +9,12 @@ module ActiveRecord
       # Quotes the column value to help prevent
       # {SQL injection attacks}[https://en.wikipedia.org/wiki/SQL_injection].
       def quote(value)
-        value = id_value_for_database(value) if value.is_a?(Base)
-
-        if value.respond_to?(:value_for_database)
-          value = value.value_for_database
+        if value.is_a?(Base)
+          ActiveSupport::Deprecation.warn(<<~MSG)
+            Passing an Active Record object to `quote` directly is deprecated
+            and will be no longer quoted as id value in Rails 7.0.
+          MSG
+          value = value.id_for_database
         end
 
         _quote(value)
@@ -22,16 +24,23 @@ module ActiveRecord
       # SQLite does not understand dates, so this method will convert a Date
       # to a String.
       def type_cast(value, column = nil)
-        value = id_value_for_database(value) if value.is_a?(Base)
+        if value.is_a?(Base)
+          ActiveSupport::Deprecation.warn(<<~MSG)
+            Passing an Active Record object to `type_cast` directly is deprecated
+            and will be no longer type casted as id value in Rails 7.0.
+          MSG
+          value = value.id_for_database
+        end
 
         if column
-          value = type_cast_from_column(column, value)
+          ActiveSupport::Deprecation.warn(<<~MSG)
+            Passing a column to `type_cast` is deprecated and will be removed in Rails 7.0.
+          MSG
+          type = lookup_cast_type_from_column(column)
+          value = type.serialize(value)
         end
 
         _type_cast(value)
-      rescue TypeError
-        to_type = column ? " to #{column.type}" : ""
-        raise TypeError, "can't cast #{value.class}#{to_type}"
       end
 
       # If you are having to call this function, you are likely doing something
@@ -43,16 +52,6 @@ module ActiveRecord
       # represent the type doesn't sufficiently reflect the differences
       # (varchar vs binary) for example. The type used to get this primitive
       # should have been provided before reaching the connection adapter.
-      def type_cast_from_column(column, value) # :nodoc:
-        if column
-          type = lookup_cast_type_from_column(column)
-          type.serialize(value)
-        else
-          value
-        end
-      end
-
-      # See docs for #type_cast_from_column
       def lookup_cast_type_from_column(column) # :nodoc:
         lookup_cast_type(column.sql_type)
       end
@@ -60,7 +59,7 @@ module ActiveRecord
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
       # characters.
       def quote_string(s)
-        s.gsub('\\'.freeze, '\&\&'.freeze).gsub("'".freeze, "''".freeze) # ' (for ruby-mode)
+        s.gsub('\\', '\&\&').gsub("'", "''") # ' (for ruby-mode)
       end
 
       # Quotes the column name. Defaults to no quoting.
@@ -95,7 +94,7 @@ module ActiveRecord
       end
 
       def quoted_true
-        "TRUE".freeze
+        "TRUE"
       end
 
       def unquoted_true
@@ -103,7 +102,7 @@ module ActiveRecord
       end
 
       def quoted_false
-        "FALSE".freeze
+        "FALSE"
       end
 
       def unquoted_false
@@ -114,16 +113,16 @@ module ActiveRecord
       # if the value is a Time responding to usec.
       def quoted_date(value)
         if value.acts_like?(:time)
-          zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
-
-          if value.respond_to?(zone_conversion_method)
-            value = value.send(zone_conversion_method)
+          if ActiveRecord::Base.default_timezone == :utc
+            value = value.getutc if value.respond_to?(:getutc) && !value.utc?
+          else
+            value = value.getlocal if value.respond_to?(:getlocal)
           end
         end
 
         result = value.to_s(:db)
         if value.respond_to?(:usec) && value.usec > 0
-          "#{result}.#{sprintf("%06d", value.usec)}"
+          result << "." << sprintf("%06d", value.usec)
         else
           result
         end
@@ -138,32 +137,86 @@ module ActiveRecord
         "'#{quote_string(value.to_s)}'"
       end
 
-      def type_casted_binds(binds) # :nodoc:
-        if binds.first.is_a?(Array)
-          binds.map { |column, value| type_cast(value, column) }
-        else
-          binds.map { |attr| type_cast(attr.value_for_database) }
-        end
+      def sanitize_as_sql_comment(value) # :nodoc:
+        value.to_s.gsub(%r{ (/ (?: | \g<1>) \*) \+? \s* | \s* (\* (?: | \g<2>) /) }x, "")
       end
 
-      private
-        def lookup_cast_type(sql_type)
-          type_map.lookup(sql_type)
-        end
+      def column_name_matcher # :nodoc:
+        COLUMN_NAME
+      end
+
+      def column_name_with_order_matcher # :nodoc:
+        COLUMN_NAME_WITH_ORDER
+      end
 
-        def id_value_for_database(value)
-          if primary_key = value.class.primary_key
-            value.instance_variable_get(:@attributes)[primary_key].value_for_database
+      # Regexp for column names (with or without a table name prefix).
+      # Matches the following:
+      #
+      #   "#{table_name}.#{column_name}"
+      #   "#{column_name}"
+      COLUMN_NAME = /
+        \A
+        (
+          (?:
+            # table_name.column_name | function(one or no argument)
+            ((?:\w+\.)?\w+) | \w+\((?:|\g<2>)\)
+          )
+          (?:(?:\s+AS)?\s+\w+)?
+        )
+        (?:\s*,\s*\g<1>)*
+        \z
+      /ix
+
+      # Regexp for column names with order (with or without a table name prefix,
+      # with or without various order modifiers). Matches the following:
+      #
+      #   "#{table_name}.#{column_name}"
+      #   "#{table_name}.#{column_name} #{direction}"
+      #   "#{table_name}.#{column_name} #{direction} NULLS FIRST"
+      #   "#{table_name}.#{column_name} NULLS LAST"
+      #   "#{column_name}"
+      #   "#{column_name} #{direction}"
+      #   "#{column_name} #{direction} NULLS FIRST"
+      #   "#{column_name} NULLS LAST"
+      COLUMN_NAME_WITH_ORDER = /
+        \A
+        (
+          (?:
+            # table_name.column_name | function(one or no argument)
+            ((?:\w+\.)?\w+) | \w+\((?:|\g<2>)\)
+          )
+          (?:\s+ASC|\s+DESC)?
+          (?:\s+NULLS\s+(?:FIRST|LAST))?
+        )
+        (?:\s*,\s*\g<1>)*
+        \z
+      /ix
+
+      private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
+      private
+        def type_casted_binds(binds)
+          case binds.first
+          when Array
+            binds.map { |column, value| type_cast(value, column) }
+          else
+            binds.map do |value|
+              if ActiveModel::Attribute === value
+                type_cast(value.value_for_database)
+              else
+                type_cast(value)
+              end
+            end
           end
         end
 
-        def types_which_need_no_typecasting
-          [nil, Numeric, String]
+        def lookup_cast_type(sql_type)
+          type_map.lookup(sql_type)
         end
 
         def _quote(value)
           case value
-          when String, ActiveSupport::Multibyte::Chars
+          when String, Symbol, ActiveSupport::Multibyte::Chars
             "'#{quote_string(value.to_s)}'"
           when true       then quoted_true
           when false      then quoted_false
@@ -174,7 +227,6 @@ module ActiveRecord
           when Type::Binary::Data then quoted_binary(value)
           when Type::Time::Value then "'#{quoted_time(value)}'"
           when Date, Time then "'#{quoted_date(value)}'"
-          when Symbol     then "'#{quote_string(value.to_s)}'"
           when Class      then "'#{value}'"
           else raise TypeError, "can't quote #{value.class.name}"
           end
@@ -188,11 +240,10 @@ module ActiveRecord
           when false      then unquoted_false
           # BigDecimals need to be put in a non-normalized form and quoted.
           when BigDecimal then value.to_s("F")
+          when nil, Numeric, String then value
           when Type::Time::Value then quoted_time(value)
           when Date, Time then quoted_date(value)
-          when *types_which_need_no_typecasting
-            value
-          else raise TypeError
+          else raise TypeError, "can't cast #{value.class.name}"
           end
         end
     end

data/lib/active_record/connection_adapters/abstract/savepoints.rb

@@ -8,15 +8,15 @@ module ActiveRecord
       end
 
       def create_savepoint(name = current_savepoint_name)
-        execute("SAVEPOINT #{name}")
+        execute("SAVEPOINT #{name}", "TRANSACTION")
       end
 
       def exec_rollback_to_savepoint(name = current_savepoint_name)
-        execute("ROLLBACK TO SAVEPOINT #{name}")
+        execute("ROLLBACK TO SAVEPOINT #{name}", "TRANSACTION")
       end
 
       def release_savepoint(name = current_savepoint_name)
-        execute("RELEASE SAVEPOINT #{name}")
+        execute("RELEASE SAVEPOINT #{name}", "TRANSACTION")
       end
     end
   end

data/lib/active_record/connection_adapters/abstract/schema_creation.rb

@@ -1,146 +1,189 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string/strip"
-
 module ActiveRecord
   module ConnectionAdapters
-    class AbstractAdapter
-      class SchemaCreation # :nodoc:
-        def initialize(conn)
-          @conn = conn
-          @cache = {}
+    class SchemaCreation # :nodoc:
+      def initialize(conn)
+        @conn = conn
+        @cache = {}
+      end
+
+      def accept(o)
+        m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
+        send m, o
+      end
+
+      delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
+        :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys?, :foreign_key_options,
+        :quoted_columns_for_index, :supports_partial_index?, :supports_check_constraints?, :check_constraint_options,
+        to: :@conn, private: true
+
+      private
+        def visit_AlterTable(o)
+          sql = +"ALTER TABLE #{quote_table_name(o.name)} "
+          sql << o.adds.map { |col| accept col }.join(" ")
+          sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(" ")
+          sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
+          sql << o.check_constraint_adds.map { |con| visit_AddCheckConstraint con }.join(" ")
+          sql << o.check_constraint_drops.map { |con| visit_DropCheckConstraint con }.join(" ")
         end
 
-        def accept(o)
-          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
-          send m, o
+        def visit_ColumnDefinition(o)
+          o.sql_type = type_to_sql(o.type, **o.options)
+          column_sql = +"#{quote_column_name(o.name)} #{o.sql_type}"
+          add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
+          column_sql
         end
 
-        delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
-          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys_in_create?, :foreign_key_options, to: :@conn
-        private :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
-          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys_in_create?, :foreign_key_options
+        def visit_AddColumnDefinition(o)
+          +"ADD #{accept(o.column)}"
+        end
 
-        private
+        def visit_TableDefinition(o)
+          create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
+          create_sql << "IF NOT EXISTS " if o.if_not_exists
+          create_sql << "#{quote_table_name(o.name)} "
 
-          def visit_AlterTable(o)
-            sql = "ALTER TABLE #{quote_table_name(o.name)} ".dup
-            sql << o.adds.map { |col| accept col }.join(" ")
-            sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(" ")
-            sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
+          statements = o.columns.map { |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
+
+          if supports_indexes_in_create?
+            statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
           end
 
-          def visit_ColumnDefinition(o)
-            o.sql_type = type_to_sql(o.type, o.options)
-            column_sql = "#{quote_column_name(o.name)} #{o.sql_type}".dup
-            add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
-            column_sql
+          if supports_foreign_keys?
+            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
           end
 
-          def visit_AddColumnDefinition(o)
-            "ADD #{accept(o.column)}".dup
+          if supports_check_constraints?
+            statements.concat(o.check_constraints.map { |expression, options| check_constraint_in_create(o.name, expression, options) })
           end
 
-          def visit_TableDefinition(o)
-            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} ".dup
+          create_sql << "(#{statements.join(', ')})" if statements.present?
+          add_table_options!(create_sql, o)
+          create_sql << " AS #{to_sql(o.as)}" if o.as
+          create_sql
+        end
 
-            statements = o.columns.map { |c| accept c }
-            statements << accept(o.primary_keys) if o.primary_keys
+        def visit_PrimaryKeyDefinition(o)
+          "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
+        end
 
-            if supports_indexes_in_create?
-              statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
-            end
+        def visit_ForeignKeyDefinition(o)
+          sql = +<<~SQL
+            CONSTRAINT #{quote_column_name(o.name)}
+            FOREIGN KEY (#{quote_column_name(o.column)})
+              REFERENCES #{quote_table_name(o.to_table)} (#{quote_column_name(o.primary_key)})
+          SQL
+          sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
+          sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
+          sql
+        end
 
-            if supports_foreign_keys_in_create?
-              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
-            end
+        def visit_AddForeignKey(o)
+          "ADD #{accept(o)}"
+        end
 
-            create_sql << "(#{statements.join(', ')})" if statements.present?
-            add_table_options!(create_sql, table_options(o))
-            create_sql << " AS #{to_sql(o.as)}" if o.as
-            create_sql
-          end
+        def visit_DropForeignKey(name)
+          "DROP CONSTRAINT #{quote_column_name(name)}"
+        end
 
-          def visit_PrimaryKeyDefinition(o)
-            "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
-          end
+        def visit_CreateIndexDefinition(o)
+          index = o.index
+
+          sql = ["CREATE"]
+          sql << "UNIQUE" if index.unique
+          sql << "INDEX"
+          sql << o.algorithm if o.algorithm
+          sql << "IF NOT EXISTS" if o.if_not_exists
+          sql << index.type if index.type
+          sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
+          sql << "USING #{index.using}" if supports_index_using? && index.using
+          sql << "(#{quoted_columns(index)})"
+          sql << "WHERE #{index.where}" if supports_partial_index? && index.where
+
+          sql.join(" ")
+        end
 
-          def visit_ForeignKeyDefinition(o)
-            sql = <<-SQL.strip_heredoc
-              CONSTRAINT #{quote_column_name(o.name)}
-              FOREIGN KEY (#{quote_column_name(o.column)})
-                REFERENCES #{quote_table_name(o.to_table)} (#{quote_column_name(o.primary_key)})
-            SQL
-            sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
-            sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
-            sql
-          end
+        def visit_CheckConstraintDefinition(o)
+          "CONSTRAINT #{o.name} CHECK (#{o.expression})"
+        end
 
-          def visit_AddForeignKey(o)
-            "ADD #{accept(o)}"
-          end
+        def visit_AddCheckConstraint(o)
+          "ADD #{accept(o)}"
+        end
 
-          def visit_DropForeignKey(name)
-            "DROP CONSTRAINT #{quote_column_name(name)}"
-          end
+        def visit_DropCheckConstraint(name)
+          "DROP CONSTRAINT #{quote_column_name(name)}"
+        end
 
-          def table_options(o)
-            table_options = {}
-            table_options[:comment] = o.comment
-            table_options[:options] = o.options
-            table_options
-          end
+        def quoted_columns(o)
+          String === o.columns ? o.columns : quoted_columns_for_index(o.columns, o.column_options)
+        end
 
-          def add_table_options!(create_sql, options)
-            if options_sql = options[:options]
-              create_sql << " #{options_sql}"
-            end
-            create_sql
-          end
+        def supports_index_using?
+          true
+        end
 
-          def column_options(o)
-            o.options.merge(column: o)
-          end
+        def add_table_options!(create_sql, o)
+          create_sql << " #{o.options}" if o.options
+          create_sql
+        end
 
-          def add_column_options!(sql, options)
-            sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
-            # must explicitly check for :null to allow change_column to work on migrations
-            if options[:null] == false
-              sql << " NOT NULL"
-            end
-            if options[:auto_increment] == true
-              sql << " AUTO_INCREMENT"
-            end
-            if options[:primary_key] == true
-              sql << " PRIMARY KEY"
-            end
-            sql
-          end
+        def column_options(o)
+          o.options.merge(column: o)
+        end
 
-          def to_sql(sql)
-            sql = sql.to_sql if sql.respond_to?(:to_sql)
-            sql
+        def add_column_options!(sql, options)
+          sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
+          # must explicitly check for :null to allow change_column to work on migrations
+          if options[:null] == false
+            sql << " NOT NULL"
           end
-
-          def foreign_key_in_create(from_table, to_table, options)
-            options = foreign_key_options(from_table, to_table, options)
-            accept ForeignKeyDefinition.new(from_table, to_table, options)
+          if options[:auto_increment] == true
+            sql << " AUTO_INCREMENT"
           end
+          if options[:primary_key] == true
+            sql << " PRIMARY KEY"
+          end
+          sql
+        end
 
-          def action_sql(action, dependency)
-            case dependency
-            when :nullify then "ON #{action} SET NULL"
-            when :cascade  then "ON #{action} CASCADE"
-            when :restrict then "ON #{action} RESTRICT"
-            else
-              raise ArgumentError, <<-MSG.strip_heredoc
-                '#{dependency}' is not supported for :on_update or :on_delete.
-                Supported values are: :nullify, :cascade, :restrict
-              MSG
-            end
+        def to_sql(sql)
+          sql = sql.to_sql if sql.respond_to?(:to_sql)
+          sql
+        end
+
+        # Returns any SQL string to go between CREATE and TABLE. May be nil.
+        def table_modifier_in_create(o)
+          " TEMPORARY" if o.temporary
+        end
+
+        def foreign_key_in_create(from_table, to_table, options)
+          prefix = ActiveRecord::Base.table_name_prefix
+          suffix = ActiveRecord::Base.table_name_suffix
+          to_table = "#{prefix}#{to_table}#{suffix}"
+          options = foreign_key_options(from_table, to_table, options)
+          accept ForeignKeyDefinition.new(from_table, to_table, options)
+        end
+
+        def check_constraint_in_create(table_name, expression, options)
+          options = check_constraint_options(table_name, expression, options)
+          accept CheckConstraintDefinition.new(table_name, expression, options)
+        end
+
+        def action_sql(action, dependency)
+          case dependency
+          when :nullify then "ON #{action} SET NULL"
+          when :cascade  then "ON #{action} CASCADE"
+          when :restrict then "ON #{action} RESTRICT"
+          else
+            raise ArgumentError, <<~MSG
+              '#{dependency}' is not supported for :on_update or :on_delete.
+              Supported values are: :nullify, :cascade, :restrict
+            MSG
           end
-      end
+        end
     end
-    SchemaCreation = AbstractAdapter::SchemaCreation # :nodoc:
   end
 end