activerecord 4.2.11.3 → 5.0.0.1

data/lib/active_record/connection_adapters/column.rb

@@ -1,46 +1,35 @@
-require 'set'
-
 module ActiveRecord
   # :stopdoc:
   module ConnectionAdapters
     # An abstract definition of a column in a table.
     class Column
-      TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].to_set
-      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
-
-      module Format
-        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
-        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
-      end
+      attr_reader :name, :default, :sql_type_metadata, :null, :table_name, :default_function, :collation, :comment
 
-      attr_reader :name, :cast_type, :null, :sql_type, :default, :default_function
-
-      delegate :type, :precision, :scale, :limit, :klass, :accessor,
-        :text?, :number?, :binary?, :changed?,
-        :type_cast_from_user, :type_cast_from_database, :type_cast_for_database,
-        :type_cast_for_schema,
-        to: :cast_type
+      delegate :precision, :scale, :limit, :type, :sql_type, to: :sql_type_metadata, allow_nil: true
 
       # Instantiates a new column in the table.
       #
-      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int(11)</tt>.
+      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int</tt>.
       # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
-      # +cast_type+ is the object used for type casting and type information.
-      # +sql_type+ is used to extract the column's length, if necessary. For example +60+ in
-      # <tt>company_name varchar(60)</tt>.
-      # It will be mapped to one of the standard Rails SQL types in the <tt>type</tt> attribute.
+      # +sql_type_metadata+ is various information about the type of the column
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, cast_type, sql_type = nil, null = true)
-        @name             = name.freeze
-        @cast_type        = cast_type
-        @sql_type         = sql_type
-        @null             = null
-        @default          = default
-        @default_function = nil
+      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil)
+        @name = name.freeze
+        @table_name = table_name
+        @sql_type_metadata = sql_type_metadata
+        @null = null
+        @default = default
+        @default_function = default_function
+        @collation = collation
+        @comment = comment
       end
 
       def has_default?
-        !default.nil?
+        !default.nil? || default_function
+      end
+
+      def bigint?
+        /\Abigint\b/ === sql_type
       end
 
       # Returns the human name of the column name.
@@ -51,19 +40,9 @@ module ActiveRecord
         Base.human_attribute_name(@name)
       end
 
-      def with_type(type)
-        dup.tap do |clone|
-          clone.instance_variable_set('@cast_type', type)
-        end
-      end
-
       def ==(other)
-        other.name == name &&
-          other.default == default &&
-          other.cast_type == cast_type &&
-          other.sql_type == sql_type &&
-          other.null == null &&
-          other.default_function == default_function
+        other.is_a?(Column) &&
+          attributes_for_hash == other.attributes_for_hash
       end
       alias :eql? :==
 
@@ -71,10 +50,16 @@ module ActiveRecord
         attributes_for_hash.hash
       end
 
-      private
+      protected
 
       def attributes_for_hash
-        [self.class, name, default, cast_type, sql_type, null, default_function]
+        [self.class, name, default, sql_type_metadata, null, table_name, default_function, collation]
+      end
+    end
+
+    class NullColumn < Column
+      def initialize(name)
+        super(name, nil)
       end
     end
   end

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -1,13 +1,12 @@
 require 'uri'
-require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionSpecification #:nodoc:
-      attr_reader :config, :adapter_method
+      attr_reader :name, :config, :adapter_method
 
-      def initialize(config, adapter_method)
-        @config, @adapter_method = config, adapter_method
+      def initialize(name, config, adapter_method)
+        @name, @config, @adapter_method = name, config, adapter_method
       end
 
       def initialize_dup(original)
@@ -34,7 +33,7 @@ module ActiveRecord
         def initialize(url)
           raise "Database URL cannot be empty" if url.blank?
           @uri     = uri_parser.parse(url)
-          @adapter = @uri.scheme.tr('-', '_')
+          @adapter = @uri.scheme && @uri.scheme.tr('-', '_')
           @adapter = "postgresql" if @adapter == "postgres"
 
           if @uri.opaque
@@ -165,7 +164,7 @@ module ActiveRecord
         #   spec.config
         #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
         #
-        def spec(config)
+        def spec(config, name = nil)
           spec = resolve(config).symbolize_keys
 
           raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
@@ -176,11 +175,18 @@ module ActiveRecord
           rescue Gem::LoadError => e
             raise Gem::LoadError, "Specified '#{spec[:adapter]}' for database adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by ActiveRecord)."
           rescue LoadError => e
-            raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/database.yml is valid. If you use an adapter other than 'mysql', 'mysql2', 'postgresql' or 'sqlite3' add the necessary adapter gem to the Gemfile.", e.backtrace
+            raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/database.yml is valid. If you use an adapter other than 'mysql2', 'postgresql' or 'sqlite3' add the necessary adapter gem to the Gemfile.", e.backtrace
           end
 
           adapter_method = "#{spec[:adapter]}_connection"
-          ConnectionSpecification.new(spec, adapter_method)
+
+          name ||=
+            if config.is_a?(Symbol)
+              config.to_s
+            else
+              "primary"
+            end
+          ConnectionSpecification.new(name, spec, adapter_method)
         end
 
         private
@@ -210,30 +216,12 @@ module ActiveRecord
           when Symbol
             resolve_symbol_connection spec
           when String
-            resolve_string_connection spec
+            resolve_url_connection spec
           when Hash
             resolve_hash_connection spec
           end
         end
 
-        def resolve_string_connection(spec)
-          # Rails has historically accepted a string to mean either
-          # an environment key or a URL spec, so we have deprecated
-          # this ambiguous behaviour and in the future this function
-          # can be removed in favor of resolve_url_connection.
-          if configurations.key?(spec) || spec !~ /:/
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing a string to ActiveRecord::Base.establish_connection for a
-              configuration lookup is deprecated, please pass a symbol
-              (#{spec.to_sym.inspect}) instead.
-            MSG
-
-            resolve_symbol_connection(spec)
-          else
-            resolve_url_connection(spec)
-          end
-        end
-
         # Takes the environment such as +:production+ or +:development+.
         # This requires that the @configurations was initialized with a key that
         # matches.

data/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module DetermineIfPreparableVisitor
+      attr_reader :preparable
+
+      def accept(*)
+        @preparable = true
+        super
+      end
+
+      def visit_Arel_Nodes_In(*)
+        @preparable = false
+        super
+      end
+
+      def visit_Arel_Nodes_SqlLiteral(*)
+        @preparable = false
+        super
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/mysql/column.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class Column < ConnectionAdapters::Column # :nodoc:
+        delegate :strict, :extra, to: :sql_type_metadata, allow_nil: true
+
+        def initialize(*)
+          super
+          assert_valid_default
+          extract_default
+        end
+
+        def has_default?
+          return false if blob_or_text_column? # MySQL forbids defaults on blob and text columns
+          super
+        end
+
+        def blob_or_text_column?
+          /\A(?:tiny|medium|long)?blob\b/ === sql_type || type == :text
+        end
+
+        def unsigned?
+          /\bunsigned\z/ === sql_type
+        end
+
+        def case_sensitive?
+          collation && collation !~ /_ci\z/
+        end
+
+        def auto_increment?
+          extra == 'auto_increment'
+        end
+
+        private
+
+        def extract_default
+          if blob_or_text_column?
+            @default = null || strict ? nil : ''
+          end
+        end
+
+        def assert_valid_default
+          if blob_or_text_column? && default.present?
+            raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module DatabaseStatements
+        # Returns an ActiveRecord::Result instance.
+        def select_all(arel, name = nil, binds = [], preparable: nil)
+          result = if ExplainRegistry.collect? && prepared_statements
+            unprepared_statement { super }
+          else
+            super
+          end
+          @connection.next_result while @connection.more_results?
+          result
+        end
+
+        # Returns a record hash with the column names as keys and column values
+        # as values.
+        def select_one(arel, name = nil, binds = [])
+          arel, binds = binds_from_relation(arel, binds)
+          @connection.query_options.merge!(as: :hash)
+          select_result(to_sql(arel, binds), name, binds) do |result|
+            @connection.next_result while @connection.more_results?
+            result.first
+          end
+        ensure
+          @connection.query_options.merge!(as: :array)
+        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 = [])
+          select_result(sql, name, binds) do |result|
+            @connection.next_result while @connection.more_results?
+            result.to_a
+          end
+        end
+
+        # Executes the SQL statement in the context of this connection.
+        def execute(sql, name = nil)
+          if @connection
+            # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+            # made since we established the connection
+            @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+          end
+
+          super
+        end
+
+        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+          if without_prepared_statement?(binds)
+            execute_and_free(sql, name) do |result|
+              ActiveRecord::Result.new(result.fields, result.to_a) if result
+            end
+          else
+            exec_stmt_and_free(sql, name, binds, cache_stmt: prepare) do |_, result|
+              ActiveRecord::Result.new(result.fields, result.to_a) if result
+            end
+          end
+        end
+
+        def exec_delete(sql, name, binds)
+          if without_prepared_statement?(binds)
+            execute_and_free(sql, name) { @connection.affected_rows }
+          else
+            exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
+          end
+        end
+        alias :exec_update :exec_delete
+
+        protected
+
+        def last_inserted_id(result)
+          @connection.last_id
+        end
+
+        private
+
+        def select_result(sql, name = nil, binds = [])
+          if without_prepared_statement?(binds)
+            execute_and_free(sql, name) { |result| yield result }
+          else
+            exec_stmt_and_free(sql, name, binds, cache_stmt: true) { |_, result| yield result }
+          end
+        end
+
+        def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
+          if @connection
+            # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+            # made since we established the connection
+            @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+          end
+
+          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+
+          log(sql, name, binds) do
+            if cache_stmt
+              cache = @statements[sql] ||= {
+                stmt: @connection.prepare(sql)
+              }
+              stmt = cache[:stmt]
+            else
+              stmt = @connection.prepare(sql)
+            end
+
+            begin
+              result = stmt.execute(*type_casted_binds)
+            rescue Mysql2::Error => e
+              if cache_stmt
+                @statements.delete(sql)
+              else
+                stmt.close
+              end
+              raise e
+            end
+
+            ret = yield stmt, result
+            result.free if result
+            stmt.close unless cache_stmt
+            ret
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb

@@ -0,0 +1,70 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of an EXPLAIN in a way that resembles the output of the
+        # MySQL shell:
+        #
+        #   +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
+        #   | id | select_type | table | type  | possible_keys | key     | key_len | ref   | rows | Extra       |
+        #   +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
+        #   |  1 | SIMPLE      | users | const | PRIMARY       | PRIMARY | 4       | const |    1 |             |
+        #   |  1 | SIMPLE      | posts | ALL   | NULL          | NULL    | NULL    | NULL  |    1 | Using where |
+        #   +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
+        #   2 rows in set (0.00 sec)
+        #
+        # This is an exercise in Ruby hyperrealism :).
+        def pp(result, elapsed)
+          widths    = compute_column_widths(result)
+          separator = build_separator(widths)
+
+          pp = []
+
+          pp << separator
+          pp << build_cells(result.columns, widths)
+          pp << separator
+
+          result.rows.each do |row|
+            pp << build_cells(row, widths)
+          end
+
+          pp << separator
+          pp << build_footer(result.rows.length, elapsed)
+
+          pp.join("\n") + "\n"
+        end
+
+        private
+
+        def compute_column_widths(result)
+          [].tap do |widths|
+            result.columns.each_with_index do |column, i|
+              cells_in_column = [column] + result.rows.map {|r| r[i].nil? ? 'NULL' : r[i].to_s}
+              widths << cells_in_column.map(&:length).max
+            end
+          end
+        end
+
+        def build_separator(widths)
+          padding = 1
+          '+' + widths.map {|w| '-' * (w + (padding*2))}.join('+') + '+'
+        end
+
+        def build_cells(items, widths)
+          cells = []
+          items.each_with_index do |item, i|
+            item = 'NULL' if item.nil?
+            justifier = item.is_a?(Numeric) ? 'rjust' : 'ljust'
+            cells << item.to_s.send(justifier, widths[i])
+          end
+          '| ' + cells.join(' | ') + ' |'
+        end
+
+        def build_footer(nrows, elapsed)
+          rows_label = nrows == 1 ? 'row' : 'rows'
+          "#{nrows} #{rows_label} in set (%.2f sec)" % elapsed
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module Quoting # :nodoc:
+        QUOTED_TRUE, QUOTED_FALSE = '1', '0'
+
+        def quote_column_name(name)
+          @quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
+        end
+
+        def quote_table_name(name)
+          @quoted_table_names[name] ||= super.gsub('.', '`.`')
+        end
+
+        def quoted_true
+          QUOTED_TRUE
+        end
+
+        def unquoted_true
+          1
+        end
+
+        def quoted_false
+          QUOTED_FALSE
+        end
+
+        def unquoted_false
+          0
+        end
+
+        def quoted_date(value)
+          if supports_datetime_with_precision?
+            super
+          else
+            super.sub(/\.\d{6}\z/, '')
+          end
+        end
+
+        private
+
+        def _quote(value)
+          if value.is_a?(Type::Binary::Data)
+            "x'#{value.hex}'"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class SchemaCreation < AbstractAdapter::SchemaCreation
+        delegate :add_sql_comment!, to: :@conn
+        private :add_sql_comment!
+
+        private
+
+        def visit_DropForeignKey(name)
+          "DROP FOREIGN KEY #{name}"
+        end
+
+        def visit_ColumnDefinition(o)
+          o.sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale, o.unsigned)
+          super
+        end
+
+        def visit_AddColumnDefinition(o)
+          add_column_position!(super, column_options(o.column))
+        end
+
+        def visit_ChangeColumnDefinition(o)
+          change_column_sql = "CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
+          add_column_position!(change_column_sql, column_options(o.column))
+        end
+
+        def add_table_options!(create_sql, options)
+          add_sql_comment!(super, options[:comment])
+        end
+
+        def column_options(o)
+          column_options = super
+          column_options[:charset] = o.charset
+          column_options
+        end
+
+        def add_column_options!(sql, options)
+          if charset = options[:charset]
+            sql << " CHARACTER SET #{charset}"
+          end
+
+          if collation = options[:collation]
+            sql << " COLLATE #{collation}"
+          end
+
+          add_sql_comment!(super, options[:comment])
+        end
+
+        def add_column_position!(sql, options)
+          if options[:first]
+            sql << " FIRST"
+          elsif options[:after]
+            sql << " AFTER #{quote_column_name(options[:after])}"
+          end
+
+          sql
+        end
+
+        def index_in_create(table_name, column_name, options)
+          index_name, index_type, index_columns, _, _, index_using, comment = @conn.add_index_options(table_name, column_name, options)
+          add_sql_comment!("#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})", comment)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/mysql/schema_definitions.rb

@@ -0,0 +1,93 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module ColumnMethods
+        def primary_key(name, type = :primary_key, **options)
+          options[:auto_increment] = true if type == :bigint && !options.key?(:default)
+          super
+        end
+
+        def blob(*args, **options)
+          args.each { |name| column(name, :blob, options) }
+        end
+
+        def tinyblob(*args, **options)
+          args.each { |name| column(name, :tinyblob, options) }
+        end
+
+        def mediumblob(*args, **options)
+          args.each { |name| column(name, :mediumblob, options) }
+        end
+
+        def longblob(*args, **options)
+          args.each { |name| column(name, :longblob, options) }
+        end
+
+        def tinytext(*args, **options)
+          args.each { |name| column(name, :tinytext, options) }
+        end
+
+        def mediumtext(*args, **options)
+          args.each { |name| column(name, :mediumtext, options) }
+        end
+
+        def longtext(*args, **options)
+          args.each { |name| column(name, :longtext, options) }
+        end
+
+        def json(*args, **options)
+          args.each { |name| column(name, :json, options) }
+        end
+
+        def unsigned_integer(*args, **options)
+          args.each { |name| column(name, :unsigned_integer, options) }
+        end
+
+        def unsigned_bigint(*args, **options)
+          args.each { |name| column(name, :unsigned_bigint, options) }
+        end
+
+        def unsigned_float(*args, **options)
+          args.each { |name| column(name, :unsigned_float, options) }
+        end
+
+        def unsigned_decimal(*args, **options)
+          args.each { |name| column(name, :unsigned_decimal, options) }
+        end
+      end
+
+      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
+        attr_accessor :charset, :unsigned
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        def new_column_definition(name, type, options) # :nodoc:
+          column = super
+          case column.type
+          when :primary_key
+            column.type = :integer
+            column.auto_increment = true
+          when /\Aunsigned_(?<type>.+)\z/
+            column.type = $~[:type].to_sym
+            column.unsigned = true
+          end
+          column.unsigned ||= options[:unsigned]
+          column.charset = options[:charset]
+          column
+        end
+
+        private
+
+        def create_column_definition(name, type)
+          MySQL::ColumnDefinition.new(name, type)
+        end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
+    end
+  end
+end