activerecord 4.2.11.3 → 5.0.0

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

@@ -18,9 +18,9 @@ module ActiveRecord
       end
 
       # Returns the maximum allowed length for an index name. This
-      # limit is enforced by rails and Is less than or equal to
-      # <tt>index_name_length</tt>. The gap between
-      # <tt>index_name_length</tt> is to allow internal rails
+      # limit is enforced by \Rails and is less than or equal to
+      # #index_name_length. The gap between
+      # #index_name_length is to allow internal \Rails
       # operations to use prefixes in temporary operations.
       def allowed_index_name_length
         index_name_length

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

@@ -27,9 +27,19 @@ module ActiveRecord
       end
 
       # Returns an ActiveRecord::Result instance.
-      def select_all(arel, name = nil, binds = [])
+      def select_all(arel, name = nil, binds = [], preparable: nil)
         arel, binds = binds_from_relation arel, binds
-        select(to_sql(arel, binds), name, binds)
+        sql = to_sql(arel, binds)
+        if !prepared_statements || (arel.is_a?(String) && preparable.nil?)
+          preparable = false
+        else
+          preparable = visitor.preparable
+        end
+        if prepared_statements && preparable
+          select_prepared(sql, name, binds)
+        else
+          select(sql, name, binds)
+        end
       end
 
       # Returns a record hash with the column names as keys and column values
@@ -40,33 +50,39 @@ module ActiveRecord
 
       # Returns a single value from a record
       def select_value(arel, name = nil, binds = [])
-        if result = select_one(arel, name, binds)
-          result.values.first
+        arel, binds = binds_from_relation arel, binds
+        if result = select_rows(to_sql(arel, binds), name, binds).first
+          result.first
         end
       end
 
       # Returns an array of the values of the first column in a select:
       #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
-      def select_values(arel, name = nil)
-        arel, binds = binds_from_relation arel, []
+      def select_values(arel, name = nil, binds = [])
+        arel, binds = binds_from_relation arel, binds
         select_rows(to_sql(arel, binds), name, binds).map(&:first)
       end
 
       # Returns an array of arrays containing the field values.
       # Order is the same as that returned by +columns+.
       def select_rows(sql, name = nil, binds = [])
+        exec_query(sql, name, binds).rows
       end
-      undef_method :select_rows
 
-      # Executes the SQL statement in the context of this connection.
+      # Executes the SQL statement in the context of this connection and returns
+      # the raw result from the connection adapter.
+      # Note: depending on your database connector, the result returned by this
+      # method may be manually memory managed. Consider using the exec_query
+      # wrapper instead.
       def execute(sql, name = nil)
+        raise NotImplementedError
       end
-      undef_method :execute
 
       # Executes +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
-      def exec_query(sql, name = 'SQL', binds = [])
+      def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+        raise NotImplementedError
       end
 
       # Executes insert +sql+ statement in the context of this connection using
@@ -95,7 +111,7 @@ module ActiveRecord
         exec_query(sql, name, binds)
       end
 
-      # Returns the last auto-generated ID from the affected table.
+      # Executes an INSERT query and returns the new record's ID
       #
       # +id_value+ will be returned unless the value is nil, in
       # which case the database will attempt to calculate the last inserted
@@ -104,20 +120,27 @@ module ActiveRecord
       # If the next id was calculated in advance (as in Oracle), it should be
       # passed in as +id_value+.
       def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-        sql, binds = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds)
-        value      = exec_insert(sql, name, binds, pk, sequence_name)
+        sql, binds, pk, sequence_name = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds)
+        value = exec_insert(sql, name, binds, pk, sequence_name)
         id_value || last_inserted_id(value)
       end
+      alias create insert
+      alias insert_sql insert
+      deprecate insert_sql: :insert
 
       # Executes the update statement and returns the number of rows affected.
       def update(arel, name = nil, binds = [])
         exec_update(to_sql(arel, binds), name, binds)
       end
+      alias update_sql update
+      deprecate update_sql: :update
 
       # Executes the delete statement and returns the number of rows affected.
       def delete(arel, name = nil, binds = [])
         exec_delete(to_sql(arel, binds), name, binds)
       end
+      alias delete_sql delete
+      deprecate delete_sql: :delete
 
       # Returns +true+ when the connection adapter supports prepared statement
       # caching, otherwise returns +false+
@@ -136,7 +159,7 @@ module ActiveRecord
       #
       # In order to get around this problem, #transaction will emulate the effect
       # of nested transactions, by using savepoints:
-      # http://dev.mysql.com/doc/refman/5.0/en/savepoint.html
+      # http://dev.mysql.com/doc/refman/5.7/en/savepoint.html
       # Savepoints are supported by MySQL and PostgreSQL. SQLite3 version >= '3.6.8'
       # supports savepoints.
       #
@@ -188,29 +211,25 @@ module ActiveRecord
       # You should consult the documentation for your database to understand the
       # semantics of these different levels:
       #
-      # * http://www.postgresql.org/docs/9.1/static/transaction-iso.html
-      # * https://dev.mysql.com/doc/refman/5.0/en/set-transaction.html
+      # * http://www.postgresql.org/docs/current/static/transaction-iso.html
+      # * https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html
       #
-      # An <tt>ActiveRecord::TransactionIsolationError</tt> will be raised if:
+      # An ActiveRecord::TransactionIsolationError will be raised if:
       #
       # * The adapter does not support setting the isolation level
       # * You are joining an existing open transaction
       # * You are creating a nested (savepoint) transaction
       #
-      # The mysql, mysql2 and postgresql adapters support setting the transaction
-      # isolation level. However, support is disabled for MySQL versions below 5,
-      # because they are affected by a bug[http://bugs.mysql.com/bug.php?id=39170]
-      # which means the isolation level gets persisted outside the transaction.
-      def transaction(options = {})
-        options.assert_valid_keys :requires_new, :joinable, :isolation
-
-        if !options[:requires_new] && current_transaction.joinable?
-          if options[:isolation]
+      # The mysql2 and postgresql adapters support setting the transaction
+      # isolation level.
+      def transaction(requires_new: nil, isolation: nil, joinable: true)
+        if !requires_new && current_transaction.joinable?
+          if isolation
             raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
           end
           yield
         else
-          transaction_manager.within_new_transaction(options) { yield }
+          transaction_manager.within_new_transaction(isolation: isolation, joinable: joinable) { yield }
         end
       rescue ActiveRecord::Rollback
         # rollbacks are silently swallowed
@@ -272,9 +291,6 @@ module ActiveRecord
         exec_rollback_to_savepoint(name)
       end
 
-      def exec_rollback_to_savepoint(name = nil) #:nodoc:
-      end
-
       def default_sequence_name(table, column)
         nil
       end
@@ -288,17 +304,24 @@ module ActiveRecord
       # something beyond a simple insert (eg. Oracle).
       def insert_fixture(fixture, table_name)
         fixture = fixture.stringify_keys
-        columns = schema_cache.columns_hash(table_name)
 
-        key_list   = []
-        value_list = fixture.map do |name, value|
+        columns = schema_cache.columns_hash(table_name)
+        binds = fixture.map do |name, value|
           if column = columns[name]
-            key_list << quote_column_name(name)
-            quote(value, column)
+            type = lookup_cast_type_from_column(column)
+            Relation::QueryAttribute.new(name, value, type)
           else
             raise Fixture::FixtureError, %(table "#{table_name}" has no column named #{name.inspect}.)
           end
         end
+        key_list = fixture.keys.map { |name| quote_column_name(name) }
+        value_list = prepare_binds_for_database(binds).map do |value|
+          begin
+            quote(value)
+          rescue TypeError
+            quote(YAML.dump(value))
+          end
+        end
 
         execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", 'Fixture Insert'
       end
@@ -329,18 +352,12 @@ module ActiveRecord
       # 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 adapters we redefine this to do that.
-      def join_to_update(update, select) #:nodoc:
-        key = update.key
+      def join_to_update(update, select, key) # :nodoc:
         subselect = subquery_for(key, select)
 
         update.where key.in(subselect)
       end
-
-      def join_to_delete(delete, select, key) #:nodoc:
-        subselect = subquery_for(key, select)
-
-        delete.where key.in(subselect)
-      end
+      alias join_to_delete join_to_update
 
       protected
 
@@ -353,28 +370,15 @@ module ActiveRecord
 
         # Returns an ActiveRecord::Result instance.
         def select(sql, name = nil, binds = [])
-          exec_query(sql, name, binds)
-        end
-
-
-        # Returns the last auto-generated ID from the affected table.
-        def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-          execute(sql, name)
-          id_value
-        end
-
-        # Executes the update statement and returns the number of rows affected.
-        def update_sql(sql, name = nil)
-          execute(sql, name)
+          exec_query(sql, name, binds, prepare: false)
         end
 
-        # Executes the delete statement and returns the number of rows affected.
-        def delete_sql(sql, name = nil)
-          update_sql(sql, name)
+        def select_prepared(sql, name = nil, binds = [])
+          exec_query(sql, name, binds, prepare: true)
         end
 
         def sql_for_insert(sql, pk, id_value, sequence_name, binds)
-          [sql, binds]
+          [sql, binds, pk, sequence_name]
         end
 
         def last_inserted_id(result)
@@ -384,7 +388,7 @@ module ActiveRecord
 
         def binds_from_relation(relation, binds)
           if relation.is_a?(Relation) && binds.empty?
-            relation, binds = relation.arel, relation.bind_values
+            relation, binds = relation.arel, relation.bound_attributes
           end
           [relation, binds]
         end

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

@@ -61,11 +61,11 @@ module ActiveRecord
         @query_cache.clear
       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) }
+          cache_sql(sql, binds) { super(sql, name, binds, preparable: preparable) }
         else
           super
         end

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

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/big_decimal/conversions'
-require "active_support/multibyte/chars"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -11,7 +10,13 @@ module ActiveRecord
         return value.quoted_id if value.respond_to?(:quoted_id)
 
         if column
-          value = column.cast_type.type_cast_for_database(value)
+          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)
         end
 
         _quote(value)
@@ -20,13 +25,13 @@ 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)
+      def type_cast(value, column = nil)
         if value.respond_to?(:quoted_id) && value.respond_to?(:id)
           return value.id
         end
 
         if column
-          value = column.cast_type.type_cast_for_database(value)
+          value = type_cast_from_column(column, value)
         end
 
         _type_cast(value)
@@ -35,15 +40,49 @@ 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
+
+      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(/\\/, '\&\&').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.
@@ -54,7 +93,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
@@ -63,6 +102,15 @@ 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'"
       end
@@ -79,6 +127,8 @@ module ActiveRecord
         'f'
       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
@@ -88,7 +138,20 @@ 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
+
+      def quoted_time(value) # :nodoc:
+        quoted_date(value).sub(/\A2000-01-01 /, '')
+      end
+
+      def prepare_binds_for_database(binds) # :nodoc:
+        binds.map(&:value_for_database)
       end
 
       private
@@ -107,11 +170,11 @@ module ActiveRecord
         # 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
-          "'#{quote_string(YAML.dump(value))}'"
+        else raise TypeError, "can't quote #{value.class.name}"
         end
       end
 
@@ -123,6 +186,7 @@ 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 Type::Time::Value then quoted_time(value)
         when Date, Time then quoted_date(value)
         when *types_which_need_no_typecasting
           value

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

@@ -1,8 +1,8 @@
 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)

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

@@ -14,38 +14,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?, :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
 
         private
 
           def visit_AlterTable(o)
             sql = "ALTER TABLE #{quote_table_name(o.name)} "
-            sql << o.adds.map { |col| visit_AddColumn col }.join(' ')
+            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.limit, o.precision, o.scale)
+            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)}"
+          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 = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+
+            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?
+              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 #{@conn.to_sql(o.as)}" if o.as
             create_sql
           end
 
-          def visit_AddForeignKey(o)
+          def visit_PrimaryKeyDefinition(o)
+            "PRIMARY KEY (#{o.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,10 +74,27 @@ module ActiveRecord
             sql
           end
 
+          def visit_AddForeignKey(o)
+            "ADD #{accept(o)}"
+          end
+
           def visit_DropForeignKey(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 add_table_options!(create_sql, options)
+            if options_sql = options[:options]
+              create_sql << " #{options_sql}"
+            end
+          end
+
           def column_options(o)
             column_options = {}
             column_options[:null] = o.null unless o.null.nil?
@@ -65,23 +102,15 @@ module ActiveRecord
             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
           end
 
-          def quote_column_name(name)
-            @conn.quote_column_name name
-          end
-
-          def quote_table_name(name)
-            @conn.quote_table_name name
-          end
-
-          def type_to_sql(type, limit, precision, scale)
-            @conn.type_to_sql type.to_sym, limit, precision, scale
-          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 +118,15 @@ 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)
-          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,10 +141,6 @@ module ActiveRecord
               MSG
             end
           end
-
-          def type_for_column(column)
-            @conn.lookup_cast_type(column.sql_type)
-          end
       end
     end
   end