activerecord 4.2.9 → 5.2.8

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module DatabaseStatements
+        # Returns an ActiveRecord::Result instance.
+        def select_all(*) # :nodoc:
+          result = if ExplainRegistry.collect? && prepared_statements
+            unprepared_statement { super }
+          else
+            super
+          end
+          discard_remaining_results
+          result
+        end
+
+        def query(sql, name = nil) # :nodoc:
+          execute(sql, name).to_a
+        end
+
+        # Executes the SQL statement in the context of this connection.
+        def execute(sql, name = nil)
+          # 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
+
+          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 = nil, 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
+
+        private
+          def default_insert_value(column)
+            Arel.sql("DEFAULT") unless column.auto_increment?
+          end
+
+          def last_inserted_id(result)
+            @connection.last_id
+          end
+
+          def discard_remaining_results
+            @connection.next_result while @connection.more_results?
+          end
+
+          def supports_set_server_option?
+            @connection.respond_to?(:set_server_option)
+          end
+
+          def multi_statements_enabled?(flags)
+            if flags.is_a?(Array)
+              flags.include?("MULTI_STATEMENTS")
+            else
+              (flags & Mysql2::Client::MULTI_STATEMENTS) != 0
+            end
+          end
+
+          def with_multi_statements
+            previous_flags = @config[:flags]
+
+            unless multi_statements_enabled?(previous_flags)
+              if supports_set_server_option?
+                @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
+              else
+                @config[:flags] = Mysql2::Client::MULTI_STATEMENTS
+                reconnect!
+              end
+            end
+
+            yield
+          ensure
+            unless multi_statements_enabled?(previous_flags)
+              if supports_set_server_option?
+                @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
+              else
+                @config[:flags] = previous_flags
+                reconnect!
+              end
+            end
+          end
+
+          def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
+            # 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
+
+            type_casted_binds = type_casted_binds(binds)
+
+            log(sql, name, binds, type_casted_binds) do
+              if cache_stmt
+                cache = @statements[sql] ||= {
+                  stmt: @connection.prepare(sql)
+                }
+                stmt = cache[:stmt]
+              else
+                stmt = @connection.prepare(sql)
+              end
+
+              begin
+                result = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                  stmt.execute(*type_casted_binds)
+                end
+              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,72 @@
+# frozen_string_literal: true
+
+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,44 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module Quoting # :nodoc:
+        def quote_column_name(name)
+          @quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`".freeze
+        end
+
+        def quote_table_name(name)
+          @quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
+        end
+
+        def unquoted_true
+          1
+        end
+
+        def unquoted_false
+          0
+        end
+
+        def quoted_date(value)
+          if supports_datetime_with_precision?
+            super
+          else
+            super.sub(/\.\d{6}\z/, "")
+          end
+        end
+
+        def quoted_binary(value)
+          "x'#{value.hex}'"
+        end
+
+        def _type_cast(value)
+          case value
+          when Date, Time then value
+          else super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
+        delegate :add_sql_comment!, :mariadb?, to: :@conn
+        private :add_sql_comment!, :mariadb?
+
+        private
+
+          def visit_DropForeignKey(name)
+            "DROP FOREIGN KEY #{name}"
+          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)}".dup
+            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 add_column_options!(sql, options)
+            # By default, TIMESTAMP columns are NOT NULL, cannot contain NULL values,
+            # and assigning NULL assigns the current timestamp. To permit a TIMESTAMP
+            # column to contain NULL, explicitly declare it with the NULL attribute.
+            # See https://dev.mysql.com/doc/refman/5.7/en/timestamp-initialization.html
+            if /\Atimestamp\b/.match?(options[:column].sql_type) && !options[:primary_key]
+              sql << " NULL" unless options[:null] == false || options_include_default?(options)
+            end
+
+            if charset = options[:charset]
+              sql << " CHARACTER SET #{charset}"
+            end
+
+            if collation = options[:collation]
+              sql << " COLLATE #{collation}"
+            end
+
+            if as = options[:as]
+              sql << " AS (#{as})"
+              if options[:stored]
+                sql << (mariadb? ? " PERSISTENT" : " STORED")
+              end
+            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})".dup, comment)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module ColumnMethods
+        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 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 TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        def new_column_definition(name, type, **options) # :nodoc:
+          case type
+          when :virtual
+            type = options[:type]
+          when :primary_key
+            type = :integer
+            options[:limit] ||= 8
+            options[:primary_key] = true
+          when /\Aunsigned_(?<type>.+)\z/
+            type = $~[:type].to_sym
+            options[:unsigned] = true
+          end
+
+          super
+        end
+
+        private
+          def aliased_types(name, fallback)
+            fallback
+          end
+
+          def integer_like_primary_key_type(type, options)
+            options[:auto_increment] = true
+            type
+          end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
+        private
+          def prepare_column_options(column)
+            spec = super
+            spec[:unsigned] = "true" if column.unsigned?
+            spec[:auto_increment] = "true" if column.auto_increment?
+
+            if @connection.supports_virtual_columns? && column.virtual?
+              spec[:as] = extract_expression_for_virtual_column(column)
+              spec[:stored] = "true" if /\b(?:STORED|PERSISTENT)\b/.match?(column.extra)
+              spec = { type: schema_type(column).inspect }.merge!(spec)
+            end
+
+            spec
+          end
+
+          def column_spec_for_primary_key(column)
+            spec = super
+            spec.delete(:auto_increment) if column.type == :integer && column.auto_increment?
+            spec
+          end
+
+          def default_primary_key?(column)
+            super && column.auto_increment? && !column.unsigned?
+          end
+
+          def explicit_primary_key_default?(column)
+            column.type == :integer && !column.auto_increment?
+          end
+
+          def schema_type(column)
+            case column.sql_type
+            when /\Atimestamp\b/
+              :timestamp
+            when "tinyblob"
+              :blob
+            else
+              super
+            end
+          end
+
+          def schema_precision(column)
+            super unless /\A(?:date)?time(?:stamp)?\b/.match?(column.sql_type) && column.precision == 0
+          end
+
+          def schema_collation(column)
+            if column.collation && table_name = column.table_name
+              @table_collation_cache ||= {}
+              @table_collation_cache[table_name] ||=
+                @connection.exec_query("SHOW TABLE STATUS LIKE #{@connection.quote(table_name)}", "SCHEMA").first["Collation"]
+              column.collation.inspect if column.collation != @table_collation_cache[table_name]
+            end
+          end
+
+          def extract_expression_for_virtual_column(column)
+            if @connection.mariadb? && @connection.version < "10.2.5"
+              create_table_info = @connection.send(:create_table_info, column.table_name)
+              column_name = @connection.quote_column_name(column.name)
+              if %r/#{column_name} #{Regexp.quote(column.sql_type)}(?: COLLATE \w+)? AS \((?<expression>.+?)\) #{column.extra}/ =~ create_table_info
+                $~[:expression].inspect
+              end
+            else
+              scope = @connection.send(:quoted_scope, column.table_name)
+              column_name = @connection.quote(column.name)
+              sql = "SELECT generation_expression FROM information_schema.columns" \
+                    " WHERE table_schema = #{scope[:schema]}" \
+                    "   AND table_name = #{scope[:name]}" \
+                    "   AND column_name = #{column_name}"
+              @connection.query_value(sql, "SCHEMA").inspect
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module SchemaStatements # :nodoc:
+        # Returns an array of indexes for the given table.
+        def indexes(table_name)
+          indexes = []
+          current_index = nil
+          execute_and_free("SHOW KEYS FROM #{quote_table_name(table_name)}", "SCHEMA") do |result|
+            each_hash(result) do |row|
+              if current_index != row[:Key_name]
+                next if row[:Key_name] == "PRIMARY" # skip the primary key
+                current_index = row[:Key_name]
+
+                mysql_index_type = row[:Index_type].downcase.to_sym
+                case mysql_index_type
+                when :fulltext, :spatial
+                  index_type = mysql_index_type
+                when :btree, :hash
+                  index_using = mysql_index_type
+                end
+
+                indexes << [
+                  row[:Table],
+                  row[:Key_name],
+                  row[:Non_unique].to_i == 0,
+                  [],
+                  lengths: {},
+                  orders: {},
+                  type: index_type,
+                  using: index_using,
+                  comment: row[:Index_comment].presence
+                ]
+              end
+
+              indexes.last[-2] << row[:Column_name]
+              indexes.last[-1][:lengths].merge!(row[:Column_name] => row[:Sub_part].to_i) if row[:Sub_part]
+              indexes.last[-1][:orders].merge!(row[:Column_name] => :desc) if row[:Collation] == "D"
+            end
+          end
+
+          indexes.map { |index| IndexDefinition.new(*index) }
+        end
+
+        def remove_column(table_name, column_name, type = nil, options = {})
+          if foreign_key_exists?(table_name, column: column_name)
+            remove_foreign_key(table_name, column: column_name)
+          end
+          super
+        end
+
+        def internal_string_options_for_primary_key
+          super.tap do |options|
+            if CHARSETS_OF_4BYTES_MAXLEN.include?(charset) && (mariadb? || version < "8.0.0")
+              options[:collation] = collation.sub(/\A[^_]+/, "utf8")
+            end
+          end
+        end
+
+        def update_table_definition(table_name, base)
+          MySQL::Table.new(table_name, base)
+        end
+
+        def create_schema_dumper(options)
+          MySQL::SchemaDumper.create(self, options)
+        end
+
+        private
+          CHARSETS_OF_4BYTES_MAXLEN = ["utf8mb4", "utf16", "utf16le", "utf32"]
+
+          def schema_creation
+            MySQL::SchemaCreation.new(self)
+          end
+
+          def create_table_definition(*args)
+            MySQL::TableDefinition.new(*args)
+          end
+
+          def new_column_from_field(table_name, field)
+            type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
+            if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(field[:Default])
+              default, default_function = nil, field[:Default]
+            else
+              default, default_function = field[:Default], nil
+            end
+
+            MySQL::Column.new(
+              field[:Field],
+              default,
+              type_metadata,
+              field[:Null] == "YES",
+              table_name,
+              default_function,
+              field[:Collation],
+              comment: field[:Comment].presence
+            )
+          end
+
+          def fetch_type_metadata(sql_type, extra = "")
+            MySQL::TypeMetadata.new(super(sql_type), extra: extra)
+          end
+
+          def extract_foreign_key_action(specifier)
+            super unless specifier == "RESTRICT"
+          end
+
+          def add_index_length(quoted_columns, **options)
+            lengths = options_for_index_columns(options[:length])
+            quoted_columns.each do |name, column|
+              column << "(#{lengths[name]})" if lengths[name].present?
+            end
+          end
+
+          def add_options_for_index_columns(quoted_columns, **options)
+            quoted_columns = add_index_length(quoted_columns, options)
+            super
+          end
+
+          def data_source_sql(name = nil, type: nil)
+            scope = quoted_scope(name, type: type)
+
+            sql = "SELECT table_name FROM information_schema.tables".dup
+            sql << " WHERE table_schema = #{scope[:schema]}"
+            sql << " AND table_name = #{scope[:name]}" if scope[:name]
+            sql << " AND table_type = #{scope[:type]}" if scope[:type]
+            sql
+          end
+
+          def quoted_scope(name = nil, type: nil)
+            schema, name = extract_schema_qualified_name(name)
+            scope = {}
+            scope[:schema] = schema ? quote(schema) : "database()"
+            scope[:name] = quote(name) if name
+            scope[:type] = quote(type) if type
+            scope
+          end
+
+          def extract_schema_qualified_name(string)
+            schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
+            schema, name = nil, schema unless name
+            [schema, name]
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class TypeMetadata < DelegateClass(SqlTypeMetadata) # :nodoc:
+        undef to_yaml if method_defined?(:to_yaml)
+
+        attr_reader :extra
+
+        def initialize(type_metadata, extra: "")
+          super(type_metadata)
+          @type_metadata = type_metadata
+          @extra = extra
+        end
+
+        def ==(other)
+          other.is_a?(MySQL::TypeMetadata) &&
+            attributes_for_hash == other.attributes_for_hash
+        end
+        alias eql? ==
+
+        def hash
+          attributes_for_hash.hash
+        end
+
+        protected
+
+          def attributes_for_hash
+            [self.class, @type_metadata, extra]
+          end
+      end
+    end
+  end
+end