activerecord 5.0.0.beta3 → 5.0.0.beta4

data/lib/active_record/connection_adapters/column.rb

@@ -1,11 +1,9 @@
-require 'set'
-
 module ActiveRecord
   # :stopdoc:
   module ConnectionAdapters
     # An abstract definition of a column in a table.
     class Column
-      attr_reader :name, :null, :sql_type_metadata, :default, :default_function, :collation
+      attr_reader :name, :default, :sql_type_metadata, :null, :table_name, :default_function, :collation, :comment
 
       delegate :precision, :scale, :limit, :type, :sql_type, to: :sql_type_metadata, allow_nil: true
 
@@ -15,14 +13,15 @@ module ActiveRecord
       # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
       # +sql_type_metadata+ is various information about the type of the column
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation = 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
-        @table_name = nil
+        @comment = comment
       end
 
       def has_default?
@@ -54,7 +53,7 @@ module ActiveRecord
       protected
 
       def attributes_for_hash
-        [self.class, name, default, sql_type_metadata, null, default_function, collation]
+        [self.class, name, default, sql_type_metadata, null, table_name, default_function, collation]
       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/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

@@ -2,6 +2,9 @@ module ActiveRecord
   module ConnectionAdapters
     module MySQL
       class SchemaCreation < AbstractAdapter::SchemaCreation
+        delegate :quote, to: :@conn
+        private :quote
+
         private
 
         def visit_DropForeignKey(name)
@@ -22,6 +25,14 @@ module ActiveRecord
           add_column_position!(change_column_sql, column_options(o.column))
         end
 
+        def add_table_options!(create_sql, options)
+          super
+
+          if comment = options[:comment]
+            create_sql << " COMMENT #{quote(comment)}"
+          end
+        end
+
         def column_options(o)
           column_options = super
           column_options[:charset] = o.charset
@@ -29,13 +40,21 @@ module ActiveRecord
         end
 
         def add_column_options!(sql, options)
-          if options[:charset]
-            sql << " CHARACTER SET #{options[:charset]}"
+          if charset = options[:charset]
+            sql << " CHARACTER SET #{charset}"
           end
-          if options[:collation]
-            sql << " COLLATE #{options[:collation]}"
+
+          if collation = options[:collation]
+            sql << " COLLATE #{collation}"
           end
+
           super
+
+          if comment = options[:comment]
+            sql << " COMMENT #{quote(comment)}"
+          end
+
+          sql
         end
 
         def add_column_position!(sql, options)
@@ -44,12 +63,14 @@ module ActiveRecord
           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 = @conn.add_index_options(table_name, column_name, options)
-          "#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns}) "
+          index_name, index_type, index_columns, _, _, index_using, comment = @conn.add_index_options(table_name, column_name, options)
+          index_option = " COMMENT #{quote(comment)}" if comment
+          "#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_option} "
         end
       end
     end

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

@@ -3,18 +3,13 @@ module ActiveRecord
     module MySQL
       module ColumnDumper
         def column_spec_for_primary_key(column)
-          spec = {}
           if column.bigint?
-            spec[:id] = ':bigint'
+            spec = { id: :bigint.inspect }
             spec[:default] = schema_default(column) || 'nil' unless column.auto_increment?
-            spec[:unsigned] = 'true' if column.unsigned?
-          elsif column.auto_increment?
-            spec[:unsigned] = 'true' if column.unsigned?
-            return if spec.empty?
           else
-            spec[:id] = schema_type(column).inspect
-            spec.merge!(prepare_column_options(column).delete_if { |key, _| [:name, :type, :null].include?(key) })
+            spec = super
           end
+          spec[:unsigned] = 'true' if column.unsigned?
           spec
         end
 
@@ -30,6 +25,10 @@ module ActiveRecord
 
         private
 
+        def default_primary_key?(column)
+          super && column.auto_increment?
+        end
+
         def schema_type(column)
           if column.sql_type == 'tinyblob'
             :blob
@@ -38,16 +37,12 @@ module ActiveRecord
           end
         end
 
-        def schema_limit(column)
-          super unless column.type == :boolean
-        end
-
         def schema_precision(column)
           super unless /time/ === column.sql_type && column.precision == 0
         end
 
         def schema_collation(column)
-          if column.collation && table_name = column.instance_variable_get(:@table_name)
+          if column.collation && table_name = column.table_name
             @table_collation_cache ||= {}
             @table_collation_cache[table_name] ||= select_one("SHOW TABLE STATUS LIKE '#{table_name}'")["Collation"]
             column.collation.inspect if column.collation != @table_collation_cache[table_name]

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,7 +1,9 @@
 require 'active_record/connection_adapters/abstract_mysql_adapter'
+require 'active_record/connection_adapters/mysql/database_statements'
 
 gem 'mysql2', '>= 0.3.18', '< 0.5'
 require 'mysql2'
+raise 'mysql2 0.4.3 is not supported. Please upgrade to 0.4.4+' if Mysql2::VERSION == '0.4.3'
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
@@ -16,7 +18,7 @@ module ActiveRecord
         if config[:flags].kind_of? Array
           config[:flags].push "FOUND_ROWS".freeze
         else
-          config[:flags] |= Mysql2::Client::FOUND_ROWS          
+          config[:flags] |= Mysql2::Client::FOUND_ROWS
         end
       end
 
@@ -35,9 +37,11 @@ module ActiveRecord
     class Mysql2Adapter < AbstractMysqlAdapter
       ADAPTER_NAME = 'Mysql2'.freeze
 
+      include MySQL::DatabaseStatements
+
       def initialize(connection, logger, connection_options, config)
         super
-        @prepared_statements = false
+        @prepared_statements = false unless config.key?(:prepared_statements)
         configure_connection
       end
 
@@ -45,6 +49,18 @@ module ActiveRecord
         !mariadb? && version >= '5.7.8'
       end
 
+      def supports_comments?
+        true
+      end
+
+      def supports_comments_in_create?
+        true
+      end
+
+      def supports_savepoints?
+        true
+      end
+
       # HELPER METHODS ===========================================
 
       def each_hash(result) # :nodoc:
@@ -95,59 +111,6 @@ module ActiveRecord
         end
       end
 
-      #--
-      # DATABASE STATEMENTS ======================================
-      #++
-
-      # 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)
-        execute(to_sql(arel, binds), name).each(as: :hash) do |row|
-          @connection.next_result while @connection.more_results?
-          return row
-        end
-      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 = [])
-        result = execute(sql, name)
-        @connection.next_result while @connection.more_results?
-        result.to_a
-      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)
-        result = execute(sql, name)
-        @connection.next_result while @connection.more_results?
-        ActiveRecord::Result.new(result.fields, result.to_a)
-      end
-
-      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-        execute to_sql(sql, binds), name
-      end
-
-      def exec_delete(sql, name, binds)
-        execute to_sql(sql, binds), name
-        @connection.affected_rows
-      end
-      alias :exec_update :exec_delete
-
-      def last_inserted_id(result)
-        @connection.last_id
-      end
-
       private
 
       def connect

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

@@ -8,7 +8,6 @@ module ActiveRecord
       def serial?
         return unless default_function
 
-        table_name = @table_name || '(?<table_name>.+)'
         %r{\Anextval\('"?#{table_name}_#{name}_seq"?'::regclass\)\z} === default_function
       end
     end