activerecord 5.0.7 → 5.1.7

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -1,11 +1,12 @@
-require 'active_record/type'
-require 'active_record/connection_adapters/determine_if_preparable_visitor'
-require 'active_record/connection_adapters/schema_cache'
-require 'active_record/connection_adapters/sql_type_metadata'
-require 'active_record/connection_adapters/abstract/schema_dumper'
-require 'active_record/connection_adapters/abstract/schema_creation'
-require 'arel/collectors/bind'
-require 'arel/collectors/sql_string'
+require "active_record/type"
+require "active_record/connection_adapters/determine_if_preparable_visitor"
+require "active_record/connection_adapters/schema_cache"
+require "active_record/connection_adapters/sql_type_metadata"
+require "active_record/connection_adapters/abstract/schema_dumper"
+require "active_record/connection_adapters/abstract/schema_creation"
+require "active_support/concurrency/load_interlock_aware_monitor"
+require "arel/collectors/bind"
+require "arel/collectors/sql_string"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -14,7 +15,7 @@ module ActiveRecord
     autoload :Column
     autoload :ConnectionSpecification
 
-    autoload_at 'active_record/connection_adapters/abstract/schema_definitions' do
+    autoload_at "active_record/connection_adapters/abstract/schema_definitions" do
       autoload :IndexDefinition
       autoload :ColumnDefinition
       autoload :ChangeColumnDefinition
@@ -25,11 +26,11 @@ module ActiveRecord
       autoload :ReferenceDefinition
     end
 
-    autoload_at 'active_record/connection_adapters/abstract/connection_pool' do
+    autoload_at "active_record/connection_adapters/abstract/connection_pool" do
       autoload :ConnectionHandler
     end
 
-    autoload_under 'abstract' do
+    autoload_under "abstract" do
       autoload :SchemaStatements
       autoload :DatabaseStatements
       autoload :DatabaseLimits
@@ -39,7 +40,7 @@ module ActiveRecord
       autoload :Savepoints
     end
 
-    autoload_at 'active_record/connection_adapters/abstract/transaction' do
+    autoload_at "active_record/connection_adapters/abstract/transaction" do
       autoload :TransactionManager
       autoload :NullTransaction
       autoload :RealTransaction
@@ -74,7 +75,7 @@ module ActiveRecord
       SIMPLE_INT = /\A\d+\z/
 
       attr_accessor :visitor, :pool
-      attr_reader :schema_cache, :owner, :logger
+      attr_reader :schema_cache, :owner, :logger, :prepared_statements, :lock
       alias :in_use? :owner
 
       def self.type_cast_config_to_integer(config)
@@ -93,8 +94,6 @@ module ActiveRecord
         end
       end
 
-      attr_reader :prepared_statements
-
       def initialize(connection, logger = nil, config = {}) # :nodoc:
         super()
 
@@ -106,7 +105,8 @@ module ActiveRecord
         @pool                = nil
         @schema_cache        = SchemaCache.new self
         @quoted_column_names, @quoted_table_names = {}, {}
-        @visitor             = arel_visitor
+        @visitor = arel_visitor
+        @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
 
         if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
           @prepared_statements = true
@@ -120,17 +120,17 @@ module ActiveRecord
         include Comparable
 
         def initialize(version_string)
-          @version = version_string.split('.').map(&:to_i)
+          @version = version_string.split(".").map(&:to_i)
         end
 
         def <=>(version_string)
-          @version <=> version_string.split('.').map(&:to_i)
+          @version <=> version_string.split(".").map(&:to_i)
         end
       end
 
       class BindCollector < Arel::Collectors::Bind
         def compile(bvs, conn)
-          casted_binds = conn.prepare_binds_for_database(bvs)
+          casted_binds = bvs.map(&:value_for_database)
           super(casted_binds.map { |value| conn.quote(value) })
         end
       end
@@ -153,22 +153,30 @@ module ActiveRecord
         Arel::Visitors::ToSql.new(self)
       end
 
-      def valid_type?(type)
-        false
+      def valid_type?(type) # :nodoc:
+        !native_database_types[type].nil?
       end
 
       def schema_creation
         SchemaCreation.new self
       end
 
+      # Returns an array of +Column+ objects for the table specified by +table_name+.
+      def columns(table_name) # :nodoc:
+        table_name = table_name.to_s
+        column_definitions(table_name).map do |field|
+          new_column_from_field(table_name, field)
+        end
+      end
+
       # this method must only be called while holding connection pool's mutex
       def lease
         if in_use?
-          msg = 'Cannot lease connection, '
+          msg = "Cannot lease connection, "
           if @owner == Thread.current
-            msg << 'it is already leased by the current thread.'
+            msg << "it is already leased by the current thread."
           else
-            msg << "it is already in use by a different thread: #{@owner}. " <<
+            msg << "it is already in use by a different thread: #{@owner}. " \
                    "Current thread: #{Thread.current}."
           end
           raise ActiveRecordError, msg
@@ -186,14 +194,14 @@ module ActiveRecord
       def expire
         if in_use?
           if @owner != Thread.current
-            raise ActiveRecordError, "Cannot expire connection, " <<
-              "it is owned by a different thread: #{@owner}. " <<
+            raise ActiveRecordError, "Cannot expire connection, " \
+              "it is owned by a different thread: #{@owner}. " \
               "Current thread: #{Thread.current}."
           end
 
           @owner = nil
         else
-          raise ActiveRecordError, 'Cannot expire connection, it is not currently leased.'
+          raise ActiveRecordError, "Cannot expire connection, it is not currently leased."
         end
       end
 
@@ -206,7 +214,7 @@ module ActiveRecord
             @owner = Thread.current
           end
         else
-          raise ActiveRecordError, 'Cannot steal connection, it is not currently leased.'
+          raise ActiveRecordError, "Cannot steal connection, it is not currently leased."
         end
       end
 
@@ -223,16 +231,15 @@ module ActiveRecord
         self.class::ADAPTER_NAME
       end
 
-      # Does this adapter support migrations?
-      def supports_migrations?
-        false
+      def supports_migrations? # :nodoc:
+        true
       end
+      deprecate :supports_migrations?
 
-      # Can this adapter determine the primary key for tables not attached
-      # to an Active Record class, such as join tables?
-      def supports_primary_key?
-        false
+      def supports_primary_key? # :nodoc:
+        true
       end
+      deprecate :supports_primary_key?
 
       # Does this adapter support DDL rollbacks in transactions? That is, would
       # CREATE TABLE or ALTER TABLE get rolled back by a transaction?
@@ -302,6 +309,12 @@ module ActiveRecord
         false
       end
 
+      # Does this adapter support creating foreign key constraints
+      # in the same statement as creating the table?
+      def supports_foreign_keys_in_create?
+        supports_foreign_keys?
+      end
+
       # Does this adapter support views?
       def supports_views?
         false
@@ -332,6 +345,11 @@ module ActiveRecord
         true
       end
 
+      # Does this adapter support virtual columns?
+      def supports_virtual_columns?
+        false
+      end
+
       # This is meant to be implemented by the adapters that support extensions
       def disable_extension(name)
       end
@@ -420,6 +438,9 @@ module ActiveRecord
       # This is done under the hood by calling #active?. If the connection
       # is no longer active, then this method will reconnect to the database.
       def verify!(*ignored)
+        if ignored.size > 0
+          ActiveSupport::Deprecation.warn("Passing arguments to #verify method of the connection has no effect and has been deprecated. Please remove all arguments from the #verify method call.")
+        end
         reconnect! unless active?
       end
 
@@ -433,19 +454,15 @@ module ActiveRecord
         @connection
       end
 
-      def case_sensitive_comparison(table, attribute, column, value)
-        if value.nil?
-          table[attribute].eq(value)
-        else
-          table[attribute].eq(Arel::Nodes::BindParam.new)
-        end
+      def case_sensitive_comparison(table, attribute, column, value) # :nodoc:
+        table[attribute].eq(value)
       end
 
-      def case_insensitive_comparison(table, attribute, column, value)
+      def case_insensitive_comparison(table, attribute, column, value) # :nodoc:
         if can_perform_case_insensitive_comparison_for?(column)
-          table[attribute].lower.eq(table.lower(Arel::Nodes::BindParam.new))
+          table[attribute].lower.eq(table.lower(value))
         else
-          table[attribute].eq(Arel::Nodes::BindParam.new)
+          table[attribute].eq(value)
         end
       end
 
@@ -495,117 +512,130 @@ module ActiveRecord
         result
       end
 
-      protected
-
-      def initialize_type_map(m) # :nodoc:
-        register_class_with_limit m, %r(boolean)i,       Type::Boolean
-        register_class_with_limit m, %r(char)i,          Type::String
-        register_class_with_limit m, %r(binary)i,        Type::Binary
-        register_class_with_limit m, %r(text)i,          Type::Text
-        register_class_with_precision m, %r(date)i,      Type::Date
-        register_class_with_precision m, %r(time)i,      Type::Time
-        register_class_with_precision m, %r(datetime)i,  Type::DateTime
-        register_class_with_limit m, %r(float)i,         Type::Float
-        register_class_with_limit m, %r(int)i,           Type::Integer
-
-        m.alias_type %r(blob)i,      'binary'
-        m.alias_type %r(clob)i,      'text'
-        m.alias_type %r(timestamp)i, 'datetime'
-        m.alias_type %r(numeric)i,   'decimal'
-        m.alias_type %r(number)i,    'decimal'
-        m.alias_type %r(double)i,    'float'
-
-        m.register_type(%r(decimal)i) do |sql_type|
-          scale = extract_scale(sql_type)
-          precision = extract_precision(sql_type)
-
-          if scale == 0
-            # FIXME: Remove this class as well
-            Type::DecimalWithoutScale.new(precision: precision)
-          else
-            Type::Decimal.new(precision: precision, scale: scale)
+      def default_index_type?(index) # :nodoc:
+        index.using.nil?
+      end
+
+      private
+
+        def initialize_type_map(m)
+          register_class_with_limit m, %r(boolean)i,       Type::Boolean
+          register_class_with_limit m, %r(char)i,          Type::String
+          register_class_with_limit m, %r(binary)i,        Type::Binary
+          register_class_with_limit m, %r(text)i,          Type::Text
+          register_class_with_precision m, %r(date)i,      Type::Date
+          register_class_with_precision m, %r(time)i,      Type::Time
+          register_class_with_precision m, %r(datetime)i,  Type::DateTime
+          register_class_with_limit m, %r(float)i,         Type::Float
+          register_class_with_limit m, %r(int)i,           Type::Integer
+
+          m.alias_type %r(blob)i,      "binary"
+          m.alias_type %r(clob)i,      "text"
+          m.alias_type %r(timestamp)i, "datetime"
+          m.alias_type %r(numeric)i,   "decimal"
+          m.alias_type %r(number)i,    "decimal"
+          m.alias_type %r(double)i,    "float"
+
+          m.register_type(%r(decimal)i) do |sql_type|
+            scale = extract_scale(sql_type)
+            precision = extract_precision(sql_type)
+
+            if scale == 0
+              # FIXME: Remove this class as well
+              Type::DecimalWithoutScale.new(precision: precision)
+            else
+              Type::Decimal.new(precision: precision, scale: scale)
+            end
           end
         end
-      end
 
-      def reload_type_map # :nodoc:
-        type_map.clear
-        initialize_type_map(type_map)
-      end
+        def reload_type_map
+          type_map.clear
+          initialize_type_map(type_map)
+        end
 
-      def register_class_with_limit(mapping, key, klass) # :nodoc:
-        mapping.register_type(key) do |*args|
-          limit = extract_limit(args.last)
-          klass.new(limit: limit)
+        def register_class_with_limit(mapping, key, klass)
+          mapping.register_type(key) do |*args|
+            limit = extract_limit(args.last)
+            klass.new(limit: limit)
+          end
         end
-      end
 
-      def register_class_with_precision(mapping, key, klass) # :nodoc:
-        mapping.register_type(key) do |*args|
-          precision = extract_precision(args.last)
-          klass.new(precision: precision)
+        def register_class_with_precision(mapping, key, klass)
+          mapping.register_type(key) do |*args|
+            precision = extract_precision(args.last)
+            klass.new(precision: precision)
+          end
         end
-      end
 
-      def extract_scale(sql_type) # :nodoc:
-        case sql_type
+        def extract_scale(sql_type)
+          case sql_type
           when /\((\d+)\)/ then 0
           when /\((\d+)(,(\d+))\)/ then $3.to_i
+          end
         end
-      end
-
-      def extract_precision(sql_type) # :nodoc:
-        $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
-      end
 
-      def extract_limit(sql_type) # :nodoc:
-        case sql_type
-        when /^bigint/i
-          8
-        when /\((.*)\)/
-          $1.to_i
+        def extract_precision(sql_type)
+          $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
         end
-      end
 
-      def translate_exception_class(e, sql)
-        begin
-          message = "#{e.class.name}: #{e.message}: #{sql}"
-        rescue Encoding::CompatibilityError
-          message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
+        def extract_limit(sql_type)
+          case sql_type
+          when /^bigint/i
+            8
+          when /\((.*)\)/
+            $1.to_i
+          end
         end
 
-        exception = translate_exception(e, message)
-        exception.set_backtrace e.backtrace
-        exception
-      end
+        def translate_exception_class(e, sql)
+          begin
+            message = "#{e.class.name}: #{e.message}: #{sql}"
+          rescue Encoding::CompatibilityError
+            message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
+          end
 
-      def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
-        @instrumenter.instrument(
-          "sql.active_record",
-          sql:               sql,
-          name:              name,
-          binds:             binds,
-          type_casted_binds: type_casted_binds,
-          statement_name:    statement_name,
-          connection_id:     object_id) { yield }
-      rescue => e
-        raise translate_exception_class(e, sql)
-      end
+          exception = translate_exception(e, message)
+          exception.set_backtrace e.backtrace
+          exception
+        end
 
-      def translate_exception(exception, message)
-        # override in derived class
-        ActiveRecord::StatementInvalid.new(message)
-      end
+        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
+          @instrumenter.instrument(
+            "sql.active_record",
+            sql:               sql,
+            name:              name,
+            binds:             binds,
+            type_casted_binds: type_casted_binds,
+            statement_name:    statement_name,
+            connection_id:     object_id) do
+              @lock.synchronize do
+                yield
+              end
+            end
+        rescue => e
+          raise translate_exception_class(e, sql)
+        end
 
-      def without_prepared_statement?(binds)
-        !prepared_statements || binds.empty?
-      end
+        def translate_exception(exception, message)
+          # override in derived class
+          case exception
+          when RuntimeError
+            exception
+          else
+            ActiveRecord::StatementInvalid.new(message)
+          end
+        end
 
-      def column_for(table_name, column_name) # :nodoc:
-        column_name = column_name.to_s
-        columns(table_name).detect { |c| c.name == column_name } ||
-          raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}")
-      end
+        def without_prepared_statement?(binds)
+          !prepared_statements || binds.empty?
+        end
+
+        def column_for(table_name, column_name)
+          column_name = column_name.to_s
+          columns(table_name).detect { |c| c.name == column_name } ||
+            raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}")
+        end
     end
   end
 end