activerecord 4.2.0 → 5.2.8.1

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

@@ -1,9 +1,16 @@
+# 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
+          dirties_query_cache base, :insert, :update, :delete, :rollback_to_savepoint, :rollback_db_transaction
+
+          base.set_callback :checkout, :after, :configure_query_cache!
+          base.set_callback :checkin, :after, :disable_query_cache!
         end
 
         def dirties_query_cache(base, *method_names)
@@ -18,11 +25,32 @@ module ActiveRecord
         end
       end
 
+      module ConnectionPoolConfiguration
+        def initialize(*)
+          super
+          @query_cache_enabled = Concurrent::Map.new { false }
+        end
+
+        def enable_query_cache!
+          @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(current_thread)
+          connection.disable_query_cache! if active_connection?
+        end
+
+        def query_cache_enabled
+          @query_cache_enabled[connection_cache_key(current_thread)]
+        end
+      end
+
       attr_reader :query_cache, :query_cache_enabled
 
       def initialize(*)
         super
-        @query_cache         = Hash.new { |h,sql| h[sql] = {} }
+        @query_cache         = Hash.new { |h, sql| h[sql] = {} }
         @query_cache_enabled = false
       end
 
@@ -41,6 +69,7 @@ module ActiveRecord
 
       def disable_query_cache!
         @query_cache_enabled = false
+        clear_query_cache
       end
 
       # Disable the query cache within the block.
@@ -58,14 +87,21 @@ 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 = [])
+      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) }
+          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
@@ -73,23 +109,37 @@ module ActiveRecord
 
       private
 
-      def cache_sql(sql, binds)
-        result =
-          if @query_cache[sql].key?(binds)
-            ActiveSupport::Notifications.instrument("sql.active_record",
-              :sql => sql, :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",
+                  sql: sql,
+                  binds: binds,
+                  type_casted_binds: -> { type_casted_binds(binds) },
+                  name: name,
+                  connection_id: object_id,
+                  cached: true,
+                )
+                @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
+        # 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,16 +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
-          value = column.cast_type.type_cast_for_database(value)
+        if value.respond_to?(:value_for_database)
+          value = value.value_for_database
         end
 
         _quote(value)
@@ -19,13 +21,11 @@ module ActiveRecord
       # Cast a +value+ to a type that the database understands. For example,
       # SQLite does not understand dates, so this method will convert a Date
       # to a String.
-      def type_cast(value, column)
-        if value.respond_to?(:quoted_id) && value.respond_to?(:id)
-          return value.id
-        end
+      def type_cast(value, column = nil)
+        value = id_value_for_database(value) if value.is_a?(Base)
 
         if column
-          value = column.cast_type.type_cast_for_database(value)
+          value = type_cast_from_column(column, value)
         end
 
         _type_cast(value)
@@ -34,15 +34,38 @@ module ActiveRecord
         raise TypeError, "can't cast #{value.class}#{to_type}"
       end
 
+      # If you are having to call this function, you are likely doing something
+      # wrong. The column does not have sufficient type information if the user
+      # provided a custom type on the class level either explicitly (via
+      # Attributes::ClassMethods#attribute) or implicitly (via
+      # AttributeMethods::Serialization::ClassMethods#serialize, +time_zone_aware_attributes+).
+      # In almost all cases, the sql type should only be used to change quoting behavior, when the primitive to
+      # 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
+
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
       # characters.
       def quote_string(s)
-        s.gsub(/\\/, '\&\&').gsub(/'/, "''") # ' (for ruby-mode)
+        s.gsub('\\'.freeze, '\&\&'.freeze).gsub("'".freeze, "''".freeze) # ' (for ruby-mode)
       end
 
       # Quotes the column name. Defaults to no quoting.
       def quote_column_name(column_name)
-        column_name
+        column_name.to_s
       end
 
       # Quotes the table name. Defaults to column name quoting.
@@ -53,7 +76,7 @@ module ActiveRecord
       # Override to return the quoted table name for assignment. Defaults to
       # table quoting.
       #
-      # This works for mysql and mysql2 where table.column can be used to
+      # This works for mysql2 where table.column can be used to
       # resolve ambiguity.
       #
       # We override this in the sqlite3 and postgresql adapters to use only
@@ -62,22 +85,33 @@ module ActiveRecord
         quote_table_name("#{table}.#{attr}")
       end
 
+      def quote_default_expression(value, column) # :nodoc:
+        if value.is_a?(Proc)
+          value.call
+        else
+          value = lookup_cast_type(column.sql_type).serialize(value)
+          quote(value)
+        end
+      end
+
       def quoted_true
-        "'t'"
+        "TRUE".freeze
       end
 
       def unquoted_true
-        't'
+        true
       end
 
       def quoted_false
-        "'f'"
+        "FALSE".freeze
       end
 
       def unquoted_false
-        'f'
+        false
       end
 
+      # Quote date/time values for use in SQL input. Includes microseconds
+      # 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
@@ -87,47 +121,80 @@ module ActiveRecord
           end
         end
 
-        value.to_s(:db)
+        result = value.to_s(:db)
+        if value.respond_to?(:usec) && value.usec > 0
+          "#{result}.#{sprintf("%06d", value.usec)}"
+        else
+          result
+        end
       end
 
-      private
+      def quoted_time(value) # :nodoc:
+        value = value.change(year: 2000, month: 1, day: 1)
+        quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "")
+      end
+
+      def quoted_binary(value) # :nodoc:
+        "'#{quote_string(value.to_s)}'"
+      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 Date, Time then "'#{quoted_date(value)}'"
-        when Symbol     then "'#{quote_string(value.to_s)}'"
-        when Class      then "'#{value}'"
+      def type_casted_binds(binds) # :nodoc:
+        if binds.first.is_a?(Array)
+          binds.map { |column, value| type_cast(value, column) }
         else
-          "'#{quote_string(YAML.dump(value))}'"
+          binds.map { |attr| type_cast(attr.value_for_database) }
         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 Date, Time then quoted_date(value)
-        when *types_which_need_no_typecasting
-          value
-        else raise TypeError
+      private
+        def lookup_cast_type(sql_type)
+          type_map.lookup(sql_type)
+        end
+
+        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 types_which_need_no_typecasting
+          [nil, Numeric, String]
+        end
+
+        def _quote(value)
+          case value
+          when String, 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 Symbol     then "'#{quote_string(value.to_s)}'"
+          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 Type::Time::Value then quoted_time(value)
+          when Date, Time then quoted_date(value)
+          when *types_which_need_no_typecasting
+            value
+          else raise TypeError
+          end
         end
-      end
     end
   end
 end

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

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
-    module Savepoints #:nodoc:
-      def supports_savepoints?
-        true
+    module Savepoints
+      def current_savepoint_name
+        current_transaction.savepoint_name
       end
 
       def create_savepoint(name = current_savepoint_name)
         execute("SAVEPOINT #{name}")
       end
 
-      def rollback_to_savepoint(name = current_savepoint_name)
+      def exec_rollback_to_savepoint(name = current_savepoint_name)
         execute("ROLLBACK TO SAVEPOINT #{name}")
       end
 

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

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/string/strip'
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/strip"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -14,38 +16,58 @@ module ActiveRecord
           send m, o
         end
 
-        def visit_AddColumn(o)
-          "ADD #{accept(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_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
 
         private
 
           def visit_AlterTable(o)
-            sql = "ALTER TABLE #{quote_table_name(o.name)} "
-            sql << o.adds.map { |col| visit_AddColumn 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)} ".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(" ")
           end
 
           def visit_ColumnDefinition(o)
-            sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale)
-            column_sql = "#{quote_column_name(o.name)} #{sql_type}"
-            add_column_options!(column_sql, column_options(o)) unless o.primary_key?
+            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
           end
 
+          def visit_AddColumnDefinition(o)
+            "ADD #{accept(o.column)}".dup
+          end
+
           def visit_TableDefinition(o)
-            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE "
-            create_sql << "#{quote_table_name(o.name)} "
-            create_sql << "(#{o.columns.map { |c| accept c }.join(', ')}) " unless o.as
-            create_sql << "#{o.options}"
-            create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} ".dup
+
+            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
+
+            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
+
+            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_AddForeignKey(o)
+          def visit_PrimaryKeyDefinition(o)
+            "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
+          end
+
+          def visit_ForeignKeyDefinition(o)
             sql = <<-SQL.strip_heredoc
-              ADD CONSTRAINT #{quote_column_name(o.name)}
+              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
@@ -54,34 +76,34 @@ module ActiveRecord
             sql
           end
 
-          def visit_DropForeignKey(name)
-            "DROP CONSTRAINT #{quote_column_name(name)}"
+          def visit_AddForeignKey(o)
+            "ADD #{accept(o)}"
           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
+          def visit_DropForeignKey(name)
+            "DROP CONSTRAINT #{quote_column_name(name)}"
           end
 
-          def quote_column_name(name)
-            @conn.quote_column_name name
+          def table_options(o)
+            table_options = {}
+            table_options[:comment] = o.comment
+            table_options[:options] = o.options
+            table_options
           end
 
-          def quote_table_name(name)
-            @conn.quote_table_name name
+          def add_table_options!(create_sql, options)
+            if options_sql = options[:options]
+              create_sql << " #{options_sql}"
+            end
+            create_sql
           end
 
-          def type_to_sql(type, limit, precision, scale)
-            @conn.type_to_sql type.to_sym, limit, precision, scale
+          def column_options(o)
+            o.options.merge(column: o)
           end
 
           def add_column_options!(sql, options)
-            sql << " DEFAULT #{quote_value(options[:default], options[:column])}" if options_include_default?(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"
@@ -89,18 +111,20 @@ module ActiveRecord
             if options[:auto_increment] == true
               sql << " AUTO_INCREMENT"
             end
+            if options[:primary_key] == true
+              sql << " PRIMARY KEY"
+            end
             sql
           end
 
-          def quote_value(value, column)
-            column.sql_type ||= type_to_sql(column.type, column.limit, column.precision, column.scale)
-            column.cast_type ||= type_for_column(column)
-
-            @conn.quote(value, column)
+          def to_sql(sql)
+            sql = sql.to_sql if sql.respond_to?(:to_sql)
+            sql
           end
 
-          def options_include_default?(options)
-            options.include?(:default) && !(options[:null] == false && options[:default].nil?)
+          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)
           end
 
           def action_sql(action, dependency)
@@ -115,11 +139,8 @@ module ActiveRecord
               MSG
             end
           end
-
-          def type_for_column(column)
-            @conn.lookup_cast_type(column.sql_type)
-          end
       end
     end
+    SchemaCreation = AbstractAdapter::SchemaCreation # :nodoc:
   end
 end