activerecord-jdbc-adapter 1.0.3-java → 50.1-java

data/lib/arjdbc/mysql.rb

@@ -1,4 +1,3 @@
-require 'arjdbc/jdbc'
-jdbc_require_driver 'jdbc/mysql'
-require 'arjdbc/mysql/connection_methods'
+require 'arjdbc'
 require 'arjdbc/mysql/adapter'
+require 'arjdbc/mysql/connection_methods'

data/lib/arjdbc/mysql/adapter.rb

@@ -1,402 +1,132 @@
+ArJdbc.load_java_part :MySQL
+
+require 'bigdecimal'
+require 'active_record/connection_adapters/abstract_mysql_adapter'
 require 'active_record/connection_adapters/abstract/schema_definitions'
+require 'arjdbc/abstract/core'
+require 'arjdbc/abstract/connection_management'
+require 'arjdbc/abstract/database_statements'
+require 'arjdbc/abstract/statement_cache'
+require 'arjdbc/abstract/transaction_support'
 
-module ::ArJdbc
-  module MySQL
-    def self.column_selector
-      [/mysql/i, lambda {|cfg,col| col.extend(::ArJdbc::MySQL::Column)}]
+module ActiveRecord
+  module ConnectionAdapters
+    AbstractMysqlAdapter.class_eval do
+      include ArJdbc::Abstract::Core # to have correct initialize() super
     end
 
-    def self.extended(adapter)
-      adapter.configure_connection
-    end
+    # Remove any vestiges of core/Ruby MySQL adapter
+    remove_const(:Mysql2Adapter) if const_defined?(:Mysql2Adapter)
 
-    def configure_connection
-      execute("SET SQL_AUTO_IS_NULL=0")
-    end
+    class Mysql2Adapter < AbstractMysqlAdapter
+      ADAPTER_NAME = 'Mysql2'.freeze
 
-    module Column
-      def extract_default(default)
-        if sql_type =~ /blob/i || type == :text
-          if default.blank?
-            return null ? nil : ''
-          else
-            raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
-          end
-        elsif missing_default_forged_as_empty_string?(default)
-          nil
-        else
-          super
-        end
-      end
+      include Jdbc::ConnectionPoolCallbacks
 
-      def has_default?
-        return false if sql_type =~ /blob/i || type == :text #mysql forbids defaults on blob and text columns
-        super
-      end
+      include ArJdbc::Abstract::ConnectionManagement
+      include ArJdbc::Abstract::DatabaseStatements
+      # NOTE: do not include MySQL::DatabaseStatements
+      include ArJdbc::Abstract::StatementCache
+      include ArJdbc::Abstract::TransactionSupport
 
-      def simplified_type(field_type)
-        return :boolean if field_type =~ /tinyint\(1\)|bit/i
-        return :string  if field_type =~ /enum/i
-        super
-      end
+      include ArJdbc::MySQL
 
-      def extract_limit(sql_type)
-        case sql_type
-        when /blob|text/i
-          case sql_type
-          when /tiny/i
-            255
-          when /medium/i
-            16777215
-          when /long/i
-            2147483647 # mysql only allows 2^31-1, not 2^32-1, somewhat inconsistently with the tiny/medium/normal cases
-          else
-            nil # we could return 65535 here, but we leave it undecorated by default
-          end
-        when /^bigint/i;    8
-        when /^int/i;       4
-        when /^mediumint/i; 3
-        when /^smallint/i;  2
-        when /^tinyint/i;   1
-        when /^(datetime|date|timestamp)/
-          nil
-        else
-          super
-        end
+      def initialize(connection, logger, config)
+        super(connection, logger, nil, config)
+        @prepared_statements = false unless config.key?(:prepared_statements)
+        # configure_connection taken care of at ArJdbc::Abstract::Core
       end
 
-      # MySQL misreports NOT NULL column default when none is given.
-      # We can't detect this for columns which may have a legitimate ''
-      # default (string) but we can for others (integer, datetime, boolean,
-      # and the rest).
-      #
-      # Test whether the column has default '', is not null, and is not
-      # a type allowing default ''.
-      def missing_default_forged_as_empty_string?(default)
-        type != :string && !null && default == ''
+      def supports_json?
+        !mariadb? && version >= '5.7.8'
       end
-    end
-
-    def modify_types(tp)
-      tp[:primary_key] = "int(11) DEFAULT NULL auto_increment PRIMARY KEY"
-      tp[:integer] = { :name => 'int', :limit => 4 }
-      tp[:decimal] = { :name => "decimal" }
-      tp[:timestamp] = { :name => "datetime" }
-      tp[:datetime][:limit] = nil
-      tp
-    end
-
-    def adapter_name #:nodoc:
-      'MySQL'
-    end
-
-    def arel2_visitors
-      {'jdbcmysql' => ::Arel::Visitors::MySQL}
-    end
 
-    def case_sensitive_equality_operator
-      "= BINARY"
-    end
-
-    def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
-      where_sql
-    end
-
-    # QUOTING ==================================================
-
-    def quote(value, column = nil)
-      return value.quoted_id if value.respond_to?(:quoted_id)
-
-      if column && column.type == :primary_key
-        value.to_s
-      elsif column && String === value && column.type == :binary && column.class.respond_to?(:string_to_binary)
-        s = column.class.string_to_binary(value).unpack("H*")[0]
-        "x'#{s}'"
-      elsif BigDecimal === value
-        "'#{value.to_s("F")}'"
-      else
-        super
+      def supports_comments?
+        true
       end
-    end
 
-    def quoted_true
-        "1"
-    end
-
-    def quoted_false
-        "0"
-    end
-
-    def begin_db_transaction #:nodoc:
-      @connection.begin
-    rescue Exception
-      # Transactions aren't supported
-    end
-
-    def commit_db_transaction #:nodoc:
-      @connection.commit
-    rescue Exception
-      # Transactions aren't supported
-    end
-
-    def rollback_db_transaction #:nodoc:
-      @connection.rollback
-    rescue Exception
-      # Transactions aren't supported
-    end
-
-    def supports_savepoints? #:nodoc:
-      true
-    end
-
-    def create_savepoint
-      execute("SAVEPOINT #{current_savepoint_name}")
-    end
-
-    def rollback_to_savepoint
-      execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
-    end
-
-    def release_savepoint
-      execute("RELEASE SAVEPOINT #{current_savepoint_name}")
-    end
-
-    def disable_referential_integrity(&block) #:nodoc:
-      old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
-      begin
-        update("SET FOREIGN_KEY_CHECKS = 0")
-        yield
-      ensure
-        update("SET FOREIGN_KEY_CHECKS = #{old}")
+      def supports_comments_in_create?
+        true
       end
-    end
-
-    # SCHEMA STATEMENTS ========================================
 
-    def structure_dump #:nodoc:
-      if supports_views?
-        sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
-      else
-        sql = "SHOW TABLES"
+      def supports_savepoints?
+        true
       end
 
-      select_all(sql).inject("") do |structure, table|
-        table.delete('Table_type')
+      # HELPER METHODS ===========================================
 
-        hash = show_create_table(table.to_a.first.last)
+      # Reloading the type map in abstract/statement_cache.rb blows up postgres
+      def clear_cache!
+        reload_type_map
+        super
+      end
 
-        if(table = hash["Create Table"])
-          structure += table + ";\n\n"
-        elsif(view = hash["Create View"])
-          structure += view + ";\n\n"
+      def each_hash(result) # :nodoc:
+        if block_given?
+          # FIXME: This is C in mysql2 gem and I just made simplest Ruby
+          result.each do |row|
+            new_hash = {}
+            row.each { |k, v| new_hash[k.to_sym] = v }
+            yield new_hash
+          end
+        else
+          to_enum(:each_hash, result)
         end
       end
-    end
-
-    def recreate_database(name, options = {}) #:nodoc:
-      drop_database(name)
-      create_database(name, options)
-    end
-
-    def character_set(options) #:nodoc:
-      str = "CHARACTER SET `#{options[:charset] || 'utf8'}`"
-      str += " COLLATE `#{options[:collation]}`" if options[:collation]
-      str
-    end
-    private :character_set
-
-    def create_database(name, options = {}) #:nodoc:
-      execute "CREATE DATABASE `#{name}` DEFAULT #{character_set(options)}"
-    end
 
-    def drop_database(name) #:nodoc:
-      execute "DROP DATABASE IF EXISTS `#{name}`"
-    end
-
-    def current_database
-      select_one("SELECT DATABASE() as db")["db"]
-    end
-
-    def create_table(name, options = {}) #:nodoc:
-      super(name, {:options => "ENGINE=InnoDB #{character_set(options)}"}.merge(options))
-    end
-
-    def rename_table(name, new_name)
-      execute "RENAME TABLE #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
-    end
-
-    def add_column(table_name, column_name, type, options = {})
-      add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-      add_column_options!(add_column_sql, options)
-      add_column_position!(add_column_sql, options)
-      execute(add_column_sql)
-    end
-
-    def change_column_default(table_name, column_name, default) #:nodoc:
-      column = column_for(table_name, column_name)
-      change_column table_name, column_name, column.sql_type, :default => default
-    end
-
-    def change_column_null(table_name, column_name, null, default = nil)
-      column = column_for(table_name, column_name)
-
-      unless null || default.nil?
-        execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+      def error_number(exception)
+        exception.error_code if exception.is_a?(JDBCError)
       end
 
-      change_column table_name, column_name, column.sql_type, :null => null
-    end
-
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
-      column = column_for(table_name, column_name)
-
-      unless options_include_default?(options)
-        options[:default] = column.default
+      def create_table(table_name, **options) #:nodoc:
+        super(table_name, options: "ENGINE=InnoDB", **options)
       end
 
-      unless options.has_key?(:null)
-        options[:null] = column.null
-      end
+      #--
+      # QUOTING ==================================================
+      #++
 
-      change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-      add_column_options!(change_column_sql, options)
-      add_column_position!(change_column_sql, options)
-      execute(change_column_sql)
-    end
+      # NOTE: quote_string(string) provided by ArJdbc::MySQL (native code),
+      # this piece is also native (mysql2) under MRI: `@connection.escape(string)`
 
-    def rename_column(table_name, column_name, new_column_name) #:nodoc:
-      options = {}
-      if column = columns(table_name).find { |c| c.name == column_name.to_s }
-        options[:default] = column.default
-        options[:null] = column.null
-      else
-        raise ActiveRecord::ActiveRecordError, "No such column: #{table_name}.#{column_name}"
+      def quoted_date(value)
+        if supports_datetime_with_precision?
+          super
+        else
+          super.sub(/\.\d{6}\z/, '')
+        end
       end
-      current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
-      rename_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
-      add_column_options!(rename_column_sql, options)
-      execute(rename_column_sql)
-    end
 
-    def add_limit_offset!(sql, options) #:nodoc:
-      limit, offset = options[:limit], options[:offset]
-      if limit && offset
-        sql << " LIMIT #{offset.to_i}, #{sanitize_limit(limit)}"
-      elsif limit
-        sql << " LIMIT #{sanitize_limit(limit)}"
-      elsif offset
-        sql << " OFFSET #{offset.to_i}"
+      def _quote(value)
+        if value.is_a?(Type::Binary::Data)
+          "x'#{value.hex}'"
+        else
+          super
+        end
       end
-      sql
-    end
-
-    def show_variable(var)
-      res = execute("show variables like '#{var}'")
-      row = res.detect {|row| row["Variable_name"] == var }
-      row && row["Value"]
-    end
-
-    def charset
-      show_variable("character_set_database")
-    end
-
-    def collation
-      show_variable("collation_database")
-    end
+      private :_quote
 
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-      return super unless type.to_s == 'integer'
+      #--
+      # CONNECTION MANAGEMENT ====================================
+      #++
 
-      case limit
-      when 1; 'tinyint'
-      when 2; 'smallint'
-      when 3; 'mediumint'
-      when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
-      when 5..8; 'bigint'
-      else raise(ActiveRecordError, "No integer type has byte size #{limit}")
-      end
-    end
+      alias :reset! :reconnect!
 
-    def add_column_position!(sql, options)
-      if options[:first]
-        sql << " FIRST"
-      elsif options[:after]
-        sql << " AFTER #{quote_column_name(options[:after])}"
-      end
-    end
+      #
 
-    protected
-    def translate_exception(exception, message)
-      return super unless exception.respond_to?(:errno)
+      private
 
-      case exception.errno
-      when 1062
-        ::ActiveRecord::RecordNotUnique.new(message, exception)
-      when 1452
-        ::ActiveRecord::InvalidForeignKey.new(message, exception)
-      else
-        super
-      end
-    end
+      # e.g. "5.7.20-0ubuntu0.16.04.1"
+      def full_version; @full_version ||= @connection.full_version end
 
-    private
-    def column_for(table_name, column_name)
-      unless column = columns(table_name).find { |c| c.name == column_name.to_s }
-        raise "No such column: #{table_name}.#{column_name}"
+      def jdbc_connection_class(spec)
+        ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
       end
-      column
-    end
-
-    def show_create_table(table)
-      select_one("SHOW CREATE TABLE #{quote_table_name(table)}")
-    end
-
-    def supports_views?
-      false
-    end
-  end
-end
 
-module ActiveRecord::ConnectionAdapters
-  # Remove any vestiges of core/Ruby MySQL adapter
-  remove_const(:MysqlColumn) if const_defined?(:MysqlColumn)
-  remove_const(:MysqlAdapter) if const_defined?(:MysqlAdapter)
-
-  class MysqlColumn < JdbcColumn
-    include ArJdbc::MySQL::Column
-
-    def initialize(name, *args)
-      if Hash === name
-        super
-      else
-        super(nil, name, *args)
+      def jdbc_column_class
+        ::ActiveRecord::ConnectionAdapters::MySQL::Column
       end
-    end
-
-    def call_discovered_column_callbacks(*)
-    end
-  end
-
-  class MysqlAdapter < JdbcAdapter
-    include ArJdbc::MySQL
 
-    def initialize(*args)
-      super
-      configure_connection
     end
-
-    def adapter_spec(config)
-      # return nil to avoid extending ArJdbc::MySQL, which we've already done
-    end
-
-    def jdbc_column_class
-      ActiveRecord::ConnectionAdapters::MysqlColumn
-    end
-  end
-end
-
-module Mysql                    # :nodoc:
-  def self.client_version
-    50400                       # faked out for AR tests
   end
 end