activerecord 5.0.7.2 → 6.0.3.4

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

@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module QueryCache
       class << self
         def included(base) #:nodoc:
-          dirties_query_cache base, :insert, :update, :delete, :rollback_to_savepoint, :rollback_db_transaction
+          dirties_query_cache base, :insert, :update, :delete, :truncate, :truncate_tables,
+            :rollback_to_savepoint, :rollback_db_transaction, :exec_insert_all
 
           base.set_callback :checkout, :after, :configure_query_cache!
           base.set_callback :checkin, :after, :disable_query_cache!
@@ -13,7 +18,7 @@ module ActiveRecord
           method_names.each do |method_name|
             base.class_eval <<-end_code, __FILE__, __LINE__ + 1
               def #{method_name}(*)
-                clear_query_cache if @query_cache_enabled
+                ActiveRecord::Base.clear_query_caches_for_current_thread if @query_cache_enabled
                 super
               end
             end_code
@@ -28,17 +33,17 @@ module ActiveRecord
         end
 
         def enable_query_cache!
-          @query_cache_enabled[connection_cache_key(Thread.current)] = true
+          @query_cache_enabled[connection_cache_key(current_thread)] = true
           connection.enable_query_cache! if active_connection?
         end
 
         def disable_query_cache!
-          @query_cache_enabled.delete connection_cache_key(Thread.current)
+          @query_cache_enabled.delete connection_cache_key(current_thread)
           connection.disable_query_cache! if active_connection?
         end
 
         def query_cache_enabled
-          @query_cache_enabled[connection_cache_key(Thread.current)]
+          @query_cache_enabled[connection_cache_key(current_thread)]
         end
       end
 
@@ -46,7 +51,7 @@ module ActiveRecord
 
       def initialize(*)
         super
-        @query_cache         = Hash.new { |h,sql| h[sql] = {} }
+        @query_cache         = Hash.new { |h, sql| h[sql] = {} }
         @query_cache_enabled = false
       end
 
@@ -83,48 +88,67 @@ module ActiveRecord
       # the same SQL query and repeatedly return the same result each time, silently
       # undermining the randomness you were expecting.
       def clear_query_cache
-        @query_cache.clear
+        @lock.synchronize do
+          @query_cache.clear
+        end
       end
 
       def select_all(arel, name = nil, binds = [], preparable: nil)
         if @query_cache_enabled && !locked?(arel)
-          arel, binds = binds_from_relation arel, binds
-          sql = to_sql(arel, binds)
-          cache_sql(sql, binds) { super(sql, name, binds, preparable: preparable) }
+          arel = arel_from_relation(arel)
+          sql, binds = to_sql_and_binds(arel, binds)
+
+          if preparable.nil?
+            preparable = prepared_statements ? visitor.preparable : false
+          end
+
+          cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable) }
         else
           super
         end
       end
 
       private
-
-      def cache_sql(sql, binds)
-        result =
-          if @query_cache[sql].key?(binds)
-            ActiveSupport::Notifications.instrument(
-              "sql.active_record",
-              sql: sql,
-              binds: binds,
-              type_casted_binds: -> { type_casted_binds(binds) },
-              name: "CACHE",
-              connection_id: object_id,
-            )
-            @query_cache[sql][binds]
-          else
-            @query_cache[sql][binds] = yield
+        def cache_sql(sql, name, binds)
+          @lock.synchronize do
+            result =
+              if @query_cache[sql].key?(binds)
+                ActiveSupport::Notifications.instrument(
+                  "sql.active_record",
+                  cache_notification_info(sql, name, binds)
+                )
+                @query_cache[sql][binds]
+              else
+                @query_cache[sql][binds] = yield
+              end
+            result.dup
           end
-        result.dup
-      end
+        end
 
-      # If arel is locked this is a SELECT ... FOR UPDATE or somesuch. Such
-      # queries should not be cached.
-      def locked?(arel)
-        arel.respond_to?(:locked) && arel.locked
-      end
+        # Database adapters can override this method to
+        # provide custom cache information.
+        def cache_notification_info(sql, name, binds)
+          {
+            sql: sql,
+            binds: binds,
+            type_casted_binds: -> { type_casted_binds(binds) },
+            name: name,
+            connection_id: object_id,
+            connection: self,
+            cached: true
+          }
+        end
 
-      def configure_query_cache!
-        enable_query_cache! if pool.query_cache_enabled
-      end
+        # If arel is locked this is a SELECT ... FOR UPDATE or somesuch. Such
+        # queries should not be cached.
+        def locked?(arel)
+          arel = arel.arel if arel.is_a?(Relation)
+          arel.respond_to?(:locked) && arel.locked
+        end
+
+        def configure_query_cache!
+          enable_query_cache! if pool.query_cache_enabled
+        end
     end
   end
 end

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

@@ -1,23 +1,18 @@
-require 'active_support/core_ext/big_decimal/conversions'
+# frozen_string_literal: true
+
+require "active_support/core_ext/big_decimal/conversions"
 require "active_support/multibyte/chars"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module Quoting
       # Quotes the column value to help prevent
-      # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
-      def quote(value, column = nil)
-        # records are quoted as their primary key
-        return value.quoted_id if value.respond_to?(:quoted_id)
+      # {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 column
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing a column to `quote` has been deprecated. It is only used
-            for type casting, which should be handled elsewhere. See
-            https://github.com/rails/arel/commit/6160bfbda1d1781c3b08a33ec4955f170e95be11
-            for more information.
-          MSG
-          value = type_cast_from_column(column, value)
+        if value.respond_to?(:value_for_database)
+          value = value.value_for_database
         end
 
         _quote(value)
@@ -27,9 +22,7 @@ module ActiveRecord
       # SQLite does not understand dates, so this method will convert a Date
       # to a String.
       def type_cast(value, column = nil)
-        if value.respond_to?(:quoted_id) && value.respond_to?(:id)
-          return value.id
-        end
+        value = id_value_for_database(value) if value.is_a?(Base)
 
         if column
           value = type_cast_from_column(column, value)
@@ -64,21 +57,10 @@ module ActiveRecord
         lookup_cast_type(column.sql_type)
       end
 
-      def fetch_type_metadata(sql_type)
-        cast_type = lookup_cast_type(sql_type)
-        SqlTypeMetadata.new(
-          sql_type: sql_type,
-          type: cast_type.type,
-          limit: cast_type.limit,
-          precision: cast_type.precision,
-          scale: cast_type.scale,
-        )
-      end
-
       # 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.
@@ -113,19 +95,19 @@ module ActiveRecord
       end
 
       def quoted_true
-        "'t'".freeze
+        "TRUE"
       end
 
       def unquoted_true
-        't'.freeze
+        true
       end
 
       def quoted_false
-        "'f'".freeze
+        "FALSE"
       end
 
       def unquoted_false
-        'f'.freeze
+        false
       end
 
       # Quote date/time values for use in SQL input. Includes microseconds
@@ -148,60 +130,122 @@ module ActiveRecord
       end
 
       def quoted_time(value) # :nodoc:
-        quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, '')
+        value = value.change(year: 2000, month: 1, day: 1)
+        quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "")
       end
 
-      def prepare_binds_for_database(binds) # :nodoc:
-        binds.map(&:value_for_database)
+      def quoted_binary(value) # :nodoc:
+        "'#{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
+
+      def column_name_matcher # :nodoc:
+        COLUMN_NAME
+      end
+
+      def column_name_with_order_matcher # :nodoc:
+        COLUMN_NAME_WITH_ORDER
       end
 
+      # 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)
+          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
+        end
 
-      def types_which_need_no_typecasting
-        [nil, Numeric, String]
-      end
-
-      def _quote(value)
-        case value
-        when String, ActiveSupport::Multibyte::Chars, Type::Binary::Data
-          "'#{quote_string(value.to_s)}'"
-        when true       then quoted_true
-        when false      then quoted_false
-        when nil        then "NULL"
-        # BigDecimals need to be put in a non-normalized form and quoted.
-        when BigDecimal then value.to_s('F')
-        when Numeric, ActiveSupport::Duration then value.to_s
-        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}"
+        def lookup_cast_type(sql_type)
+          type_map.lookup(sql_type)
         end
-      end
 
-      def _type_cast(value)
-        case value
-        when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
-          value.to_s
-        when true       then unquoted_true
-        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 Type::Time::Value then quoted_time(value)
-        when Date, Time then quoted_date(value)
-        when *types_which_need_no_typecasting
-          value
-        else raise TypeError
+        def id_value_for_database(value)
+          if primary_key = value.class.primary_key
+            value.instance_variable_get(:@attributes)[primary_key].value_for_database
+          end
+        end
+
+        def _quote(value)
+          case value
+          when String, Symbol, ActiveSupport::Multibyte::Chars
+            "'#{quote_string(value.to_s)}'"
+          when true       then quoted_true
+          when false      then quoted_false
+          when nil        then "NULL"
+          # BigDecimals need to be put in a non-normalized form and quoted.
+          when BigDecimal then value.to_s("F")
+          when Numeric, ActiveSupport::Duration then value.to_s
+          when Type::Binary::Data then quoted_binary(value)
+          when Type::Time::Value then "'#{quoted_time(value)}'"
+          when Date, Time then "'#{quoted_date(value)}'"
+          when Class      then "'#{value}'"
+          else raise TypeError, "can't quote #{value.class.name}"
+          end
+        end
+
+        def _type_cast(value)
+          case value
+          when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+            value.to_s
+          when true       then unquoted_true
+          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)
+          else raise TypeError
+          end
         end
-      end
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module Savepoints

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

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/string/strip'
+# frozen_string_literal: true
 
 module ActiveRecord
   module ConnectionAdapters
@@ -15,32 +15,32 @@ module ActiveRecord
         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, 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?, :foreign_key_options
+          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys?, :foreign_key_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 = +"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(" ")
           end
 
           def visit_ColumnDefinition(o)
-            o.sql_type ||= type_to_sql(o.type, o.limit, o.precision, o.scale)
-            column_sql = "#{quote_column_name(o.name)} #{o.sql_type}"
+            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
 
           def visit_AddColumnDefinition(o)
-            "ADD #{accept(o.column)}"
+            +"ADD #{accept(o.column)}"
           end
 
           def visit_TableDefinition(o)
-            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+            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)} "
 
             statements = o.columns.map { |c| accept c }
             statements << accept(o.primary_keys) if o.primary_keys
@@ -55,16 +55,16 @@ module ActiveRecord
 
             create_sql << "(#{statements.join(', ')})" if statements.present?
             add_table_options!(create_sql, table_options(o))
-            create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+            create_sql << " AS #{to_sql(o.as)}" if o.as
             create_sql
           end
 
           def visit_PrimaryKeyDefinition(o)
-            "PRIMARY KEY (#{o.name.join(', ')})"
+            "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
           end
 
           def visit_ForeignKeyDefinition(o)
-            sql = <<-SQL.strip_heredoc
+            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)})
@@ -93,20 +93,11 @@ module ActiveRecord
             if options_sql = options[:options]
               create_sql << " #{options_sql}"
             end
+            create_sql
           end
 
           def column_options(o)
-            column_options = {}
-            column_options[:null] = o.null unless o.null.nil?
-            column_options[:default] = o.default unless o.default.nil?
-            column_options[:column] = o
-            column_options[:first] = o.first
-            column_options[:after] = o.after
-            column_options[:auto_increment] = o.auto_increment
-            column_options[:primary_key] = o.primary_key
-            column_options[:collation] = o.collation
-            column_options[:comment] = o.comment
-            column_options
+            o.options.merge(column: o)
           end
 
           def add_column_options!(sql, options)
@@ -124,7 +115,20 @@ module ActiveRecord
             sql
           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
@@ -135,7 +139,7 @@ module ActiveRecord
             when :cascade  then "ON #{action} CASCADE"
             when :restrict then "ON #{action} RESTRICT"
             else
-              raise ArgumentError, <<-MSG.strip_heredoc
+              raise ArgumentError, <<~MSG
                 '#{dependency}' is not supported for :on_update or :on_delete.
                 Supported values are: :nullify, :cascade, :restrict
               MSG
@@ -143,5 +147,6 @@ module ActiveRecord
           end
       end
     end
+    SchemaCreation = AbstractAdapter::SchemaCreation # :nodoc:
   end
 end