activerecord 3.2.22.5 → 4.2.11.3

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

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/big_decimal/conversions'
+require "active_support/multibyte/chars"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -9,70 +10,29 @@ module ActiveRecord
         # records are quoted as their primary key
         return value.quoted_id if value.respond_to?(:quoted_id)
 
-        case value
-        when String, ActiveSupport::Multibyte::Chars
-          value = value.to_s
-          return "'#{quote_string(value)}'" unless column
-
-          case column.type
-          when :binary then "'#{quote_string(column.string_to_binary(value))}'"
-          when :integer then value.to_i.to_s
-          when :float then value.to_f.to_s
-          else
-            "'#{quote_string(value)}'"
-          end
-
-        when true, false
-          if column && column.type == :integer
-            value ? '1' : '0'
-          else
-            value ? quoted_true : quoted_false
-          end
-          # BigDecimals need to be put in a non-normalized form and quoted.
-        when nil        then "NULL"
-        when BigDecimal then value.to_s('F')
-        when Numeric    then value.to_s
-        when Date, Time then "'#{quoted_date(value)}'"
-        when Symbol     then "'#{quote_string(value.to_s)}'"
-        else
-          "'#{quote_string(YAML.dump(value))}'"
+        if column
+          value = column.cast_type.type_cast_for_database(value)
         end
+
+        _quote(value)
       end
 
       # 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)
-        return value.id if value.respond_to?(:quoted_id)
-
-        case value
-        when String, ActiveSupport::Multibyte::Chars
-          value = value.to_s
-          return value unless column
-
-          case column.type
-          when :binary then value
-          when :integer then value.to_i
-          when :float then value.to_f
-          else
-            value
-          end
+        if value.respond_to?(:quoted_id) && value.respond_to?(:id)
+          return value.id
+        end
 
-        when true, false
-          if column && column.type == :integer
-            value ? 1 : 0
-          else
-            value ? 't' : 'f'
-          end
-          # BigDecimals need to be put in a non-normalized form and quoted.
-        when nil        then nil
-        when BigDecimal then value.to_s('F')
-        when Numeric    then value
-        when Date, Time then quoted_date(value)
-        when Symbol     then value.to_s
-        else
-          YAML.dump(value)
+        if column
+          value = column.cast_type.type_cast_for_database(value)
         end
+
+        _type_cast(value)
+      rescue TypeError
+        to_type = column ? " to #{column.type}" : ""
+        raise TypeError, "can't cast #{value.class}#{to_type}"
       end
 
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
@@ -91,14 +51,34 @@ module ActiveRecord
         quote_column_name(table_name)
       end
 
+      # 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
+      # resolve ambiguity.
+      #
+      # We override this in the sqlite3 and postgresql adapters to use only
+      # the column name (as per syntax requirements).
+      def quote_table_name_for_assignment(table, attr)
+        quote_table_name("#{table}.#{attr}")
+      end
+
       def quoted_true
         "'t'"
       end
 
+      def unquoted_true
+        't'
+      end
+
       def quoted_false
         "'f'"
       end
 
+      def unquoted_false
+        'f'
+      end
+
       def quoted_date(value)
         if value.acts_like?(:time)
           zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
@@ -110,6 +90,45 @@ module ActiveRecord
 
         value.to_s(:db)
       end
+
+      private
+
+      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}'"
+        else
+          "'#{quote_string(YAML.dump(value))}'"
+        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
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Savepoints #:nodoc:
+      def supports_savepoints?
+        true
+      end
+
+      def create_savepoint(name = current_savepoint_name)
+        execute("SAVEPOINT #{name}")
+      end
+
+      def exec_rollback_to_savepoint(name = current_savepoint_name)
+        execute("ROLLBACK TO SAVEPOINT #{name}")
+      end
+
+      def release_savepoint(name = current_savepoint_name)
+        execute("RELEASE SAVEPOINT #{name}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+require 'active_support/core_ext/string/strip'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      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
+
+        def visit_AddColumn(o)
+          "ADD #{accept(o)}"
+        end
+
+        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(' ')
+          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?
+            column_sql
+          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
+          end
+
+          def visit_AddForeignKey(o)
+            sql = <<-SQL.strip_heredoc
+              ADD 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_DropForeignKey(name)
+            "DROP CONSTRAINT #{quote_column_name(name)}"
+          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
+          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)
+            # 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
+            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?)
+          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
+          end
+
+          def type_for_column(column)
+            @conn.lookup_cast_type(column.sql_type)
+          end
+      end
+    end
+  end
+end