kb-activerecord-jdbc-adapter 0.9.7.1-java → 1.0.0.beta1-java

data/lib/arjdbc/mysql/adapter.rb

@@ -0,0 +1,388 @@
+require 'active_record/connection_adapters/abstract/schema_definitions'
+
+module ::ArJdbc
+  module MySQL
+    def self.column_selector
+      [/mysql/i, lambda {|cfg,col| col.extend(::ArJdbc::MySQL::Column)}]
+    end
+
+    def self.extended(adapter)
+      adapter.configure_connection
+    end
+
+    def configure_connection
+      execute("SET SQL_AUTO_IS_NULL=0")
+    end
+
+    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
+
+      def has_default?
+        return false if sql_type =~ /blob/i || type == :text #mysql forbids defaults on blob and text columns
+        super
+      end
+
+      def simplified_type(field_type)
+        return :boolean if field_type =~ /tinyint\(1\)|bit/i
+        return :string  if field_type =~ /enum/i
+        super
+      end
+
+      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
+        else
+          super
+        end
+      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 == ''
+      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 case_sensitive_equality_operator
+      "= BINARY"
+    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
+      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}")
+      end
+    end
+
+    # SCHEMA STATEMENTS ========================================
+
+    def structure_dump #:nodoc:
+      if supports_views?
+        sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
+      else
+        sql = "SHOW TABLES"
+      end
+
+      select_all(sql).inject("") do |structure, table|
+        table.delete('Table_type')
+
+        hash = show_create_table(table.to_a.first.last)
+
+        if(table = hash["Create Table"])
+          structure += table + ";\n\n"
+        elsif(view = hash["Create View"])
+          structure += view + ";\n\n"
+        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")
+      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
+      end
+
+      unless options.has_key?(:null)
+        options[:null] = column.null
+      end
+
+      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
+
+    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}"
+      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}"
+      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
+
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      return super unless type.to_s == 'integer'
+
+      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
+
+    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)
+
+      case exception.errno
+      when 1062
+        ::ActiveRecord::RecordNotUnique.new(message, exception)
+      when 1452
+        ::ActiveRecord::InvalidForeignKey.new(message, exception)
+      else
+        super
+      end
+    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}"
+      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
+  class MysqlColumn < JdbcColumn
+    include ArJdbc::MySQL::Column
+
+    def initialize(name, *args)
+      if Hash === name
+        super
+      else
+        super(nil, name, *args)
+      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

data/lib/arjdbc/mysql/connection_methods.rb

@@ -0,0 +1,26 @@
+# Don't need to load native mysql adapter
+$LOADED_FEATURES << "active_record/connection_adapters/mysql_adapter.rb"
+
+class ActiveRecord::Base
+  class << self
+    def mysql_connection(config)
+      require "arjdbc/mysql"
+      config[:port] ||= 3306
+      url_options = "zeroDateTimeBehavior=convertToNull&jdbcCompliantTruncation=false&useUnicode=true&characterEncoding="
+      url_options << (config[:encoding] || 'utf8')
+      if config[:url]
+        config[:url] = config[:url]['?'] ? "#{config[:url]}&#{url_options}" : "#{config[:url]}?#{url_options}"
+      else
+        config[:url] = "jdbc:mysql://#{config[:host]}:#{config[:port]}/#{config[:database]}?#{url_options}"
+      end
+      config[:driver] ||= "com.mysql.jdbc.Driver"
+      config[:adapter_class] = ActiveRecord::ConnectionAdapters::MysqlAdapter
+      connection = jdbc_connection(config)
+      ::ArJdbc::MySQL.kill_cancel_timer(connection.raw_connection)
+      connection
+    end
+    alias_method :jdbcmysql_connection, :mysql_connection
+  end
+end
+
+

data/lib/arjdbc/mysql.rb

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

data/lib/{jdbc_adapter/jdbc_oracle.rb → arjdbc/oracle/adapter.rb}

@@ -1,13 +1,8 @@
-module ::JdbcSpec
-  module ActiveRecordExtensions
-    def oracle_connection(config)
-      config[:port] ||= 1521
-      config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database]}"
-      config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
-      jdbc_connection(config)
-    end
-  end
+module ActiveRecord::ConnectionAdapters
+  OracleAdapter = Class.new(AbstractAdapter) unless const_defined?(:OracleAdapter)
+end
 
+module ::ArJdbc
   module Oracle
     def self.extended(mod)
       unless @lob_callback_added
@@ -26,19 +21,16 @@ module ::JdbcSpec
         ActiveRecord::Base.after_save :after_save_with_oracle_lob
         @lob_callback_added = true
       end
-      ActiveRecord::Base.extend JdbcSpec::QuotedPrimaryKeyExtension
+      require 'arjdbc/jdbc/quoted_primary_key'
+      ActiveRecord::Base.extend ArJdbc::QuotedPrimaryKeyExtension
       mod.class.class_eval do
         alias_chained_method :insert, :query_dirty, :insert
         alias_chained_method :columns, :query_cache, :columns
       end
     end
 
-    def self.adapter_matcher(name, *)
-      name =~ /oracle/i ? self : false
-    end
-
     def self.column_selector
-      [/oracle/i, lambda {|cfg,col| col.extend(::JdbcSpec::Oracle::Column)}]
+      [/oracle/i, lambda {|cfg,col| col.extend(::ArJdbc::Oracle::Column)}]
     end
 
     module Column
@@ -52,7 +44,7 @@ module ::JdbcSpec
       def type_cast(value)
         return nil if value.nil?
         case type
-        when :datetime then JdbcSpec::Oracle::Column.string_to_time(value, self.class)
+        when :datetime then ArJdbc::Oracle::Column.string_to_time(value, self.class)
         else
           super
         end
@@ -60,7 +52,7 @@ module ::JdbcSpec
 
       def type_cast_code(var_name)
         case type
-        when :datetime  then "JdbcSpec::Oracle::Column.string_to_time(#{var_name}, self.class)"
+        when :datetime  then "ArJdbc::Oracle::Column.string_to_time(#{var_name}, self.class)"
         else
           super
         end

data/lib/arjdbc/oracle/connection_methods.rb

@@ -0,0 +1,11 @@
+class ActiveRecord::Base
+  class << self
+    def oracle_connection(config)
+      config[:port] ||= 1521
+      config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database]}"
+      config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
+      jdbc_connection(config)
+    end
+  end
+end
+

data/lib/arjdbc/oracle.rb

@@ -0,0 +1,3 @@
+require 'arjdbc/jdbc'
+require 'arjdbc/oracle/connection_methods'
+require 'arjdbc/oracle/adapter'

data/lib/{jdbc_adapter/jdbc_postgre.rb → arjdbc/postgresql/adapter.rb}

@@ -1,24 +1,8 @@
+module ActiveRecord::ConnectionAdapters
+  PostgreSQLAdapter = Class.new(AbstractAdapter) unless const_defined?(:PostgreSQLAdapter)
+end
 
-module ::JdbcSpec
-  # Don't need to load native postgres adapter
-  $LOADED_FEATURES << "active_record/connection_adapters/postgresql_adapter.rb"
-
-  module ActiveRecordExtensions
-    add_method_to_remove_from_ar_base(:postgresql_connection)
-
-    def postgresql_connection(config)
-      require File.dirname(__FILE__) + "/../active_record/connection_adapters/postgresql_adapter"
-      config[:host] ||= "localhost"
-      config[:port] ||= 5432
-      config[:url] ||= "jdbc:postgresql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
-      config[:url] << config[:pg_params] if config[:pg_params]
-      config[:driver] ||= "org.postgresql.Driver"
-      conn = jdbc_connection(config)
-      conn.execute("SET SEARCH_PATH TO #{config[:schema_search_path]}") if config[:schema_search_path]
-      conn
-    end
-  end
-
+module ::ArJdbc
   module PostgreSQL
     def self.extended(mod)
       mod.class.class_eval do
@@ -26,12 +10,8 @@ module ::JdbcSpec
       end
     end
 
-    def self.adapter_matcher(name, *)
-      name =~ /postgre/i ? self : false
-    end
-
     def self.column_selector
-      [/postgre/i, lambda {|cfg,col| col.extend(::JdbcSpec::PostgreSQL::Column)}]
+      [/postgre/i, lambda {|cfg,col| col.extend(::ArJdbc::PostgreSQL::Column)}]
     end
 
     def self.jdbc_connection_class
@@ -188,9 +168,9 @@ module ::JdbcSpec
     end
 
     def quote_regclass(table_name)
-      table_name.to_s.split('.').map do |part| 
+      table_name.to_s.split('.').map do |part|
         part =~ /".*"/i ? part : quote_table_name(part)
-      end.join('.')  
+      end.join('.')
     end
 
     # Find a table's primary key and sequence.
@@ -381,15 +361,6 @@ module ::JdbcSpec
       end
     end
 
-    def _execute(sql, name = nil)
-        case sql.strip
-        when /\A\(?\s*(select|show)/i then
-          @connection.execute_query(sql)
-        else
-          @connection.execute_update(sql)
-        end
-    end
-
     # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
     #
     # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -0,0 +1,21 @@
+# Don't need to load native postgres adapter
+$LOADED_FEATURES << "active_record/connection_adapters/postgresql_adapter.rb"
+
+class ActiveRecord::Base
+  class << self
+    def postgresql_connection(config)
+      require "arjdbc/postgresql"
+      config[:host] ||= "localhost"
+      config[:port] ||= 5432
+      config[:url] ||= "jdbc:postgresql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      config[:url] << config[:pg_params] if config[:pg_params]
+      config[:driver] ||= "org.postgresql.Driver"
+      conn = jdbc_connection(config)
+      conn.execute("SET SEARCH_PATH TO #{config[:schema_search_path]}") if config[:schema_search_path]
+      conn
+    end
+    alias_method :jdbcpostgresql_connection, :postgresql_connection
+  end
+end
+
+

data/lib/arjdbc/postgresql.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/postgres'
+require 'arjdbc/postgresql/connection_methods'
+require 'arjdbc/postgresql/adapter'