activerecord 4.2.8 → 6.0.0

data/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module DetermineIfPreparableVisitor
+      attr_accessor :preparable
+
+      def accept(object, collector)
+        @preparable = true
+        super
+      end
+
+      def visit_Arel_Nodes_In(o, collector)
+        @preparable = false
+        super
+      end
+
+      def visit_Arel_Nodes_NotIn(o, collector)
+        @preparable = false
+        super
+      end
+
+      def visit_Arel_Nodes_SqlLiteral(o, collector)
+        @preparable = false
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class Column < ConnectionAdapters::Column # :nodoc:
+        delegate :extra, to: :sql_type_metadata, allow_nil: true
+
+        def unsigned?
+          /\bunsigned(?: zerofill)?\z/.match?(sql_type)
+        end
+
+        def case_sensitive?
+          collation && !/_ci\z/.match?(collation)
+        end
+
+        def auto_increment?
+          extra == "auto_increment"
+        end
+
+        def virtual?
+          /\b(?:VIRTUAL|STORED|PERSISTENT)\b/.match?(extra)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+# 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
+          @connection.abandon_results!
+          result
+        end
+
+        def query(sql, name = nil) # :nodoc:
+          execute(sql, name).to_a
+        end
+
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        end
+
+        # Executes the SQL statement in the context of this connection.
+        def execute(sql, name = nil)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
+          # 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|
+              if result
+                ActiveRecord::Result.new(result.fields, result.to_a)
+              else
+                ActiveRecord::Result.new([], [])
+              end
+            end
+          else
+            exec_stmt_and_free(sql, name, binds, cache_stmt: prepare) do |_, result|
+              if result
+                ActiveRecord::Result.new(result.fields, result.to_a)
+              else
+                ActiveRecord::Result.new([], [])
+              end
+            end
+          end
+        end
+
+        def exec_delete(sql, name = nil, binds = [])
+          if without_prepared_statement?(binds)
+            @lock.synchronize do
+              execute_and_free(sql, name) { @connection.affected_rows }
+            end
+          else
+            exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
+          end
+        end
+        alias :exec_update :exec_delete
+
+        private
+          def execute_batch(sql, name = nil)
+            super
+            @connection.abandon_results!
+          end
+
+          def default_insert_value(column)
+            super unless column.auto_increment?
+          end
+
+          def last_inserted_id(result)
+            @connection.last_id
+          end
+
+          def supports_set_server_option?
+            @connection.respond_to?(:set_server_option)
+          end
+
+          def build_truncate_statements(*table_names)
+            if table_names.size == 1
+              super.first
+            else
+              super
+            end
+          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 combine_multi_statements(total_sql)
+            total_sql.each_with_object([]) do |sql, total_sql_chunks|
+              previous_packet = total_sql_chunks.last
+              if max_allowed_packet_reached?(sql, previous_packet)
+                total_sql_chunks << +sql
+              else
+                previous_packet << ";\n"
+                previous_packet << sql
+              end
+            end
+          end
+
+          def max_allowed_packet_reached?(current_packet, previous_packet)
+            if current_packet.bytesize > max_allowed_packet
+              raise ActiveRecordError,
+                "Fixtures set is too large #{current_packet.bytesize}. Consider increasing the max_allowed_packet variable."
+            elsif previous_packet.nil?
+              true
+            else
+              (current_packet.bytesize + previous_packet.bytesize + 2) > max_allowed_packet
+            end
+          end
+
+          def max_allowed_packet
+            @max_allowed_packet ||= show_variable("max_allowed_packet")
+          end
+
+          def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
+            if preventing_writes? && write_query?(sql)
+              raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+            end
+
+            materialize_transactions
+
+            # 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
+                stmt = @statements[sql] ||= @connection.prepare(sql)
+              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,81 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module Quoting # :nodoc:
+        def quote_column_name(name)
+          self.class.quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
+        end
+
+        def quote_table_name(name)
+          self.class.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 column_name_matcher
+          COLUMN_NAME
+        end
+
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
+        end
+
+        COLUMN_NAME = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`)) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+AS\s+(?:\w+|`\w+`))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        COLUMN_NAME_WITH_ORDER = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`)) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+ASC|\s+DESC)?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
+        private
+          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,72 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
+        delegate :add_sql_comment!, :mariadb?, to: :@conn, private: true
+
+        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)}"
+            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})"), comment)
+          end
+      end
+    end
+  end
+end