activerecord-jdbc-adapter 0.9.7-java → 1.0.0.beta1-java

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/oracle.rb

@@ -0,0 +1,3 @@
+require 'arjdbc/jdbc'
+require 'arjdbc/oracle/connection_methods'
+require 'arjdbc/oracle/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/postgresql.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/postgres'
+require 'arjdbc/postgresql/connection_methods'
+require 'arjdbc/postgresql/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/sqlite3.rb

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

data/lib/{jdbc_adapter/jdbc_sqlite3.rb → arjdbc/sqlite3/adapter.rb}

@@ -1,47 +1,13 @@
-module ::JdbcSpec
-  # Don't need to load native postgres adapter
-  $LOADED_FEATURES << "active_record/connection_adapters/sqlite3_adapter.rb"
+require 'arjdbc/jdbc/missing_functionality_helper'
 
-  module ActiveRecordExtensions
-    add_method_to_remove_from_ar_base(:sqlite3_connection)
-
-    def sqlite3_connection(config)
-      require File.dirname(__FILE__) + "/../active_record/connection_adapters/sqlite3_adapter"
-
-      parse_sqlite3_config!(config)
-
-      config[:url] ||= "jdbc:sqlite:#{config[:database]}"
-      config[:driver] ||= "org.sqlite.JDBC"
-      jdbc_connection(config)
-    end
-
-    def parse_sqlite3_config!(config)
-      config[:database] ||= config[:dbfile]
-
-      # Allow database path relative to RAILS_ROOT, but only if
-      # the database path is not the special path that tells
-      # Sqlite to build a database only in memory.
-      rails_root_defined = defined?(Rails.root) || Object.const_defined?(:RAILS_ROOT)
-      if rails_root_defined && ':memory:' != config[:database]
-        rails_root = defined?(Rails.root) ? Rails.root : RAILS_ROOT
-        config[:database] = File.expand_path(config[:database], rails_root)
-      end
-    end
-  end
+module ActiveRecord::ConnectionAdapters
+  Sqlite3Adapter = Class.new(AbstractAdapter) unless const_defined?(:Sqlite3Adapter)
+end
 
+module ::ArJdbc
   module SQLite3
-    def self.extended(base)
-      base.class.class_eval do
-        alias_chained_method :insert, :query_dirty, :insert
-      end
-    end
-
-    def self.adapter_matcher(name, *)
-      name =~ /sqlite/i ? self : false
-    end
-
     def self.column_selector
-      [/sqlite/i, lambda {|cfg,col| col.extend(::JdbcSpec::SQLite3::Column)}]
+      [/sqlite/i, lambda {|cfg,col| col.extend(::ArJdbc::SQLite3::Column)}]
     end
 
     def self.jdbc_connection_class
@@ -57,12 +23,12 @@ module ::JdbcSpec
         return nil if value.nil?
         case type
         when :string   then value
-        when :integer  then JdbcSpec::SQLite3::Column.cast_to_integer(value)
+        when :integer  then ArJdbc::SQLite3::Column.cast_to_integer(value)
         when :primary_key then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
         when :float    then value.to_f
-        when :datetime then JdbcSpec::SQLite3::Column.cast_to_date_or_time(value)
-        when :date then JdbcSpec::SQLite3::Column.cast_to_date_or_time(value)
-        when :time     then JdbcSpec::SQLite3::Column.cast_to_time(value)
+        when :datetime then ArJdbc::SQLite3::Column.cast_to_date_or_time(value)
+        when :date then ArJdbc::SQLite3::Column.cast_to_date_or_time(value)
+        when :time     then ArJdbc::SQLite3::Column.cast_to_time(value)
         when :decimal  then self.class.value_to_decimal(value)
         when :boolean  then self.class.value_to_boolean(value)
         else value
@@ -71,10 +37,10 @@ module ::JdbcSpec
 
       def type_cast_code(var_name)
         case type
-          when :integer  then "JdbcSpec::SQLite3::Column.cast_to_integer(#{var_name})"
-          when :datetime then "JdbcSpec::SQLite3::Column.cast_to_date_or_time(#{var_name})"
-          when :date     then "JdbcSpec::SQLite3::Column.cast_to_date_or_time(#{var_name})"
-          when :time     then "JdbcSpec::SQLite3::Column.cast_to_time(#{var_name})"
+          when :integer  then "ArJdbc::SQLite3::Column.cast_to_integer(#{var_name})"
+          when :datetime then "ArJdbc::SQLite3::Column.cast_to_date_or_time(#{var_name})"
+          when :date     then "ArJdbc::SQLite3::Column.cast_to_date_or_time(#{var_name})"
+          when :time     then "ArJdbc::SQLite3::Column.cast_to_time(#{var_name})"
         else
           super
         end
@@ -98,11 +64,11 @@ module ::JdbcSpec
 
       def extract_precision(sql_type)
         case sql_type
-          when /^(real)\((\d+)(,\d+)?\)/i then $2.to_i 
+          when /^(real)\((\d+)(,\d+)?\)/i then $2.to_i
           else super
-        end 
+        end
       end
-      
+
       def extract_scale(sql_type)
         case sql_type
           when /^(real)\((\d+)\)/i then 0
@@ -190,14 +156,7 @@ module ::JdbcSpec
     end
 
     def quote_column_name(name) #:nodoc:
-      name = name.to_s
-      # Did not find reference on values needing quoting, but these
-      # happen in AR unit tests
-      if name == "references" || name =~ /-/
-        %Q("#{name}") 
-      else
-        name
-      end
+      %Q("#{name}")
     end
 
     def quote_string(str)
@@ -262,23 +221,13 @@ module ::JdbcSpec
       execute "ALTER TABLE #{name} RENAME TO #{new_name}"
     end
 
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-      log(sql,name) do
-        @connection.execute_update(sql)
-      end
-      table = sql.split(" ", 4)[2]
-      id_value || last_insert_id(table, nil)
-    end
-
-    def last_insert_id(table, sequence_name)
-      Integer(select_value("SELECT SEQ FROM SQLITE_SEQUENCE WHERE NAME = '#{table}'"))
+    def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+      @connection.execute_update(sql)
+      id_value || last_insert_id
     end
 
-    def add_limit_offset!(sql, options) #:nodoc:
-      if options[:limit]
-        sql << " LIMIT #{options[:limit]}"
-        sql << " OFFSET #{options[:offset]}" if options[:offset]
-      end
+    def last_insert_id
+      Integer(select_value("SELECT last_insert_rowid()"))
     end
 
     def tables(name = nil) #:nodoc:
@@ -304,11 +253,13 @@ module ::JdbcSpec
         name = row[0]
         index_sql = row[1]
         unique = (index_sql =~ /unique/i)
-        cols = index_sql.match(/\((.*)\)/)[1].gsub(/,/,' ').split
+        cols = index_sql.match(/\((.*)\)/)[1].gsub(/,/,' ').split.map do |c|
+          match = /^"(.+)"$/.match(c); match ? match[1] : c
+        end
         ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, name, unique, cols)
       end
     end
-    
+
     def primary_key(table_name) #:nodoc:
       column = table_structure(table_name).find {|field| field['pk'].to_i == 1}
       column ? column['name'] : nil
@@ -319,14 +270,10 @@ module ::JdbcSpec
     end
 
     def _execute(sql, name = nil)
-      if ActiveRecord::ConnectionAdapters::JdbcConnection::select?(sql)
-        @connection.execute_query(sql)
-      else
-        affected_rows = @connection.execute_update(sql)
-        ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id(sql.split(" ", 4)[2], nil) : affected_rows
-      end
+      result = super
+      ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id : result
     end
-    
+
     def select(sql, name=nil)
       execute(sql, name).map do |row|
         record = {}
@@ -338,49 +285,104 @@ module ::JdbcSpec
         record
       end
     end
-    
+
     def table_structure(table_name)
       structure = @connection.execute_query("PRAGMA table_info(#{quote_table_name(table_name)})")
       raise ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'" if structure.empty?
       structure
     end
-    
-    def columns(table_name, name = nil) #:nodoc:        
+
+    def columns(table_name, name = nil) #:nodoc:
       table_structure(table_name).map do |field|
         ::ActiveRecord::ConnectionAdapters::JdbcColumn.new(@config, field['name'], field['dflt_value'], field['type'], field['notnull'] == 0)
       end
     end
-    
+
      # SELECT ... FOR UPDATE is redundant since the table is locked.
     def add_lock!(sql, options) #:nodoc:
       sql
     end
-    
+
     protected
-      include JdbcSpec::MissingFunctionalityHelper
+    include ArJdbc::MissingFunctionalityHelper
+
+    def translate_exception(exception, message)
+      case exception.message
+      when /column(s)? .* (is|are) not unique/
+        ActiveRecord::RecordNotUnique.new(message, exception)
+      else
+        super
+      end
+    end
   end
 end
 
-module ActiveRecord
-  module ConnectionAdapters
-    class JdbcColumn < Column
-      def self.string_to_binary(value)
-        value.gsub(/\0|%/n) do |b|
-          case b
-            when "\0" then "%00"
-            when "\%"  then "%25"
-          end
+module ActiveRecord::ConnectionAdapters
+  class SQLiteColumn < JdbcColumn
+    include ArJdbc::SQLite3::Column
+
+    def initialize(name, *args)
+      if Hash === name
+        super
+      else
+        super(nil, name, *args)
+      end
+    end
+
+    def call_discovered_column_callbacks(*)
+    end
+
+    def self.string_to_binary(value)
+      value.gsub(/\0|%/n) do |b|
+        case b
+        when "\0" then "%00"
+        when "\%"  then "%25"
         end
       end
+    end
 
-      def self.binary_to_string(value)
-        value.gsub(/%00|%25/n) do |b|
-          case b
-            when "%00" then "\0"
-            when "%25" then "%"
-          end
+    def self.binary_to_string(value)
+      value.gsub(/%00|%25/n) do |b|
+        case b
+        when "%00" then "\0"
+        when "%25" then "%"
         end
       end
     end
+
+    def self.cast_to_integer(value)
+      return nil if value =~ /NULL/ or value.to_s.empty? or value.nil?
+      return (value.to_i) ? value.to_i : (value ? 1 : 0)
+    end
+
+    def self.cast_to_date_or_time(value)
+      return value if value.is_a? Date
+      return nil if value.blank?
+      guess_date_or_time((value.is_a? Time) ? value : cast_to_time(value))
+    end
+
+    def self.cast_to_time(value)
+      return value if value.is_a? Time
+      time_array = ParseDate.parsedate value
+      time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
+      Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
+    end
+
+    def self.guess_date_or_time(value)
+      (value.hour == 0 and value.min == 0 and value.sec == 0) ?
+      Date.new(value.year, value.month, value.day) : value
+    end
+  end
+
+  class SQLite3Adapter < JdbcAdapter
+    include ArJdbc::SQLite3
+
+    def adapter_spec(config)
+      # return nil to avoid extending ArJdbc::SQLite3, which we've already done
+    end
+
+    def jdbc_column_class
+      ActiveRecord::ConnectionAdapters::SQLiteColumn
+    end
   end
 end