activerecord-jdbc-adapter 1.2.2.1 → 1.2.5

data/lib/arjdbc/sqlite3.rb

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

data/lib/arjdbc/sqlite3/adapter.rb

@@ -119,8 +119,17 @@ module ::ArJdbc
       tp
     end
 
+    def quote(value, column = nil)
+      if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+        s = column.class.string_to_binary(value).unpack("H*")[0]
+        "x'#{s}'"
+      else
+        super
+      end
+    end
+
     def quote_column_name(name) #:nodoc:
-      %Q("#{name.to_s.gsub('"', '""')}")
+      %Q("#{name.to_s.gsub('"', '""')}") # "' kludge for emacs font-lock
     end
 
     def quote_string(str)
@@ -181,12 +190,7 @@ module ::ArJdbc
       end
     end
 
-    def primary_key(table_name) #:nodoc:
-      column = table_structure(table_name).find {|field| field['pk'].to_i == 1}
-      column ? column['name'] : nil
-    end
-
-    def recreate_database(name)
+    def recreate_database(name, options = {})
       tables.each{ |table| drop_table(table) }
     end
 
@@ -341,19 +345,14 @@ module ActiveRecord::ConnectionAdapters
     end
 
     def self.string_to_binary(value)
-      "\000b64" + [value].pack('m*').split("\n").join('')
+      value
     end
 
     def self.binary_to_string(value)
       if value.respond_to?(:force_encoding) && value.encoding != Encoding::ASCII_8BIT
         value = value.force_encoding(Encoding::ASCII_8BIT)
       end
-
-      if value[0..3] == "\000b64"
-        value[4..-1].unpack('m*').first
-      else
-        value
-      end
+      value
     end
   end
 

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -5,17 +5,18 @@ $LOADED_FEATURES << "active_record/connection_adapters/sqlite3_adapter.rb"
 class ActiveRecord::Base
   class << self
     def sqlite3_connection(config)
-      require "arjdbc/sqlite3"
+      require 'active_record/connection_adapters/jdbcsqlite3_adapter'
 
       parse_sqlite3_config!(config)
       database = config[:database]
       database = '' if database == ':memory:'
       config[:url] ||= "jdbc:sqlite:#{database}"
-      config[:driver] ||= "org.sqlite.JDBC"
+      config[:driver] ||= defined?(::Jdbc::SQLite3.driver_name) ? ::Jdbc::SQLite3.driver_name : 'org.sqlite.JDBC'
       config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter
       config[:adapter_spec] = ::ArJdbc::SQLite3
       jdbc_connection(config)
     end
+    alias_method :jdbcsqlite3_connection, :sqlite3_connection
 
     def parse_sqlite3_config!(config)
       config[:database] ||= config[:dbfile]
@@ -29,7 +30,5 @@ class ActiveRecord::Base
         config[:database] = File.expand_path(config[:database], rails_root)
       end
     end
-
-    alias_method :jdbcsqlite3_connection, :sqlite3_connection
   end
 end

data/lib/arjdbc/version.rb

@@ -1,6 +1,6 @@
 module ArJdbc
   module Version
-    VERSION = "1.2.2.1"
+    VERSION = "1.2.5"
   end
 end
 # Compatibility with older versions of ar-jdbc for other extensions out there

data/rakelib/01-tomcat.rake

@@ -0,0 +1,52 @@
+
+namespace :'tomcat-jndi' do # contains a FS JNDI impl (for tests)
+  
+  TOMCAT_MAVEN_REPO = 'http://repo2.maven.org/maven2/org/apache/tomcat'
+  TOMCAT_VERSION = '7.0.34'
+
+  DOWNLOAD_DIR = File.expand_path('../test/jars', File.dirname(__FILE__))
+
+  #tomcat_jar = "tomcat-embed-core.jar"
+  #tomcat_uri = "#{TOMCAT_MAVEN_REPO}/embed/tomcat-embed-core/#{TOMCAT_VERSION}/tomcat-embed-core-#{TOMCAT_VERSION}.jar"
+
+  catalina_jar = "tomcat-catalina.jar"
+  catalina_uri = "#{TOMCAT_MAVEN_REPO}/tomcat-catalina/#{TOMCAT_VERSION}/tomcat-catalina-#{TOMCAT_VERSION}.jar"
+
+  juli_jar = "tomcat-juli.jar"
+  juli_uri = "#{TOMCAT_MAVEN_REPO}/tomcat-juli/#{TOMCAT_VERSION}/tomcat-juli-#{TOMCAT_VERSION}.jar"
+
+  task :download do
+    require 'open-uri'; require 'tmpdir'
+
+    temp_dir = File.join(Dir.tmpdir, (Time.now.to_f * 1000).to_i.to_s)
+    FileUtils.mkdir temp_dir
+
+    downloads = Hash.new
+    downloads[juli_jar] = juli_uri
+    downloads[catalina_jar] = catalina_uri
+
+    Dir.chdir(temp_dir) do
+      FileUtils.mkdir DOWNLOAD_DIR unless File.exist?(DOWNLOAD_DIR)
+      downloads.each do |jar, uri|
+        puts "downloading #{uri}"
+        file = open(uri)
+        FileUtils.cp file.path, File.join(DOWNLOAD_DIR, jar)
+      end
+    end
+
+    FileUtils.rm_r temp_dir
+  end
+  
+  task :check do
+    jar_path = File.join(DOWNLOAD_DIR, catalina_jar)
+    unless File.exist?(jar_path)
+      Rake::Task['tomcat-jndi:download'].invoke
+    end
+  end
+
+  task :clear do
+    jar_path = File.join(DOWNLOAD_DIR, catalina_jar)
+    rm jar_path if File.exist?(jar_path)
+  end
+
+end

data/rakelib/02-test.rake

@@ -0,0 +1,111 @@
+require File.expand_path '../../test/helper', __FILE__
+if defined?(JRUBY_VERSION)
+  databases = [ :test_mysql, :test_sqlite3, :test_derby, :test_hsqldb, :test_h2 ]
+  databases << :test_postgres if PostgresHelper.have_postgres?(false)
+  databases << :test_jdbc ; databases << :test_jndi
+  task :test do
+    unless PostgresHelper.have_postgres?
+      warn "... won't run test_postgres tests"
+    end
+    databases.each { |task| Rake::Task[task.to_s].invoke }
+  end
+else
+  task :test => [ :test_mysql ]
+end
+
+def set_compat_version(task)
+  task.ruby_opts << '-v' if RUBY_VERSION =~ /1\.8/
+  if defined?(JRUBY_VERSION)
+    task.ruby_opts << "--#{RUBY_VERSION[/^(\d+\.\d+)/, 1]}"
+  end
+end
+
+def all_appraisal_names
+  @appraisal_names ||= begin names = []; Appraisal::File.each { |file| names << file.name }; names end
+end
+
+def declare_test_task_for(adapter, options = {})
+  driver = options[:driver] || adapter
+  prereqs = options[:prereqs] || []
+  prereqs = [ prereqs ].flatten
+  task "test_#{adapter}_pre" do
+    puts "Specify AR version with 'rake appraisal:{version} test_#{adapter}' where version=(#{all_appraisal_names.join('|')})"
+  end
+  prereqs << "test_#{adapter}_pre"
+  test_task = lambda do |t|
+    task_name = t.name.keys.first
+    files = FileList["test/#{adapter}*test.rb"]
+    files.unshift "test/db/#{task_name.sub('test_','')}.rb"
+    if adapter == "derby"
+      files << 'test/activerecord/connection_adapters/type_conversion_test.rb'
+    end
+    t.test_files = files
+    t.libs = []
+    set_compat_version(t)
+    if defined?(JRUBY_VERSION)
+      t.ruby_opts << "-rjdbc/#{driver}"
+      t.libs << "lib" << "jdbc-#{driver}/lib"
+      t.libs.push *FileList["activerecord-jdbc#{adapter}*/lib"]
+    end
+    t.libs << "test"
+    t.verbose = true
+  end
+  Rake::TestTask.new("test_#{adapter}" => prereqs) { |t| test_task.call t }
+  Rake::TestTask.new("test_jdbc_#{adapter}" => prereqs) { |t| test_task.call t }
+end
+
+declare_test_task_for :derby
+declare_test_task_for :h2
+declare_test_task_for :hsqldb
+declare_test_task_for :mssql, :driver => :jtds
+declare_test_task_for :mysql, :prereqs => "db:mysql"
+declare_test_task_for :postgres, :prereqs => "db:postgres"
+declare_test_task_for :sqlite3
+
+Rake::TestTask.new(:test_jdbc) do |t|
+  t.test_files = FileList['test/generic_jdbc_connection_test.rb']
+  t.libs << 'test' << 'jdbc-mysql/lib'
+  set_compat_version(t)
+end
+
+Rake::TestTask.new(:test_jndi) do |t|
+  Rake::Task['tomcat-jndi:check'].invoke
+  t.test_files = FileList['test/jndi_test.rb']
+  t.libs << 'test' << 'jdbc-derby/lib'
+  set_compat_version(t)
+end
+
+task :test_postgresql => [:test_postgres]
+task :test_pgsql => [:test_postgres]
+
+# Ensure driver for these DBs is on your classpath
+%w(oracle db2 cachedb informix).each do |d|
+  Rake::TestTask.new("test_#{d}") do |t|
+    t.test_files = FileList["test/#{d}*_test.rb"]
+    t.libs = []
+    t.libs << 'lib' if defined?(JRUBY_VERSION)
+    t.libs << 'test'
+    set_compat_version(t)
+  end
+end
+
+# Tests for JDBC adapters that don't require a database.
+Rake::TestTask.new(:test_jdbc_adapters) do | t |
+  t.test_files = FileList[ 'test/jdbc_adapter/jdbc_sybase_test.rb' ]
+  t.libs << 'test'
+  set_compat_version(t)
+end
+
+# Ensure that the jTDS driver is in your classpath before launching rake
+Rake::TestTask.new(:test_sybase_jtds) do |t|
+  t.test_files = FileList['test/sybase_jtds_simple_test.rb']
+  t.libs << 'test'
+  set_compat_version(t)
+end
+
+# Ensure that the jConnect driver is in your classpath before launching rake
+Rake::TestTask.new(:test_sybase_jconnect) do |t|
+  t.test_files = FileList['test/sybase_jconnect_simple_test.rb']
+  t.libs << 'test'
+  set_compat_version(t)
+end

data/rakelib/db.rake

@@ -1,7 +1,8 @@
+require File.expand_path '../../test/helper', __FILE__
 namespace :db do
   desc "Creates the test database for MySQL."
   task :mysql do
-    load 'test/db/mysql.rb' rescue nil
+    load 'test/db/mysql_config.rb' rescue nil
     t = Tempfile.new("mysql")
     t.puts <<-SQL
 DROP DATABASE IF EXISTS `#{MYSQL_CONFIG[:database]}`;
@@ -23,8 +24,8 @@ SQL
 
   desc "Creates the test database for PostgreSQL."
   task :postgres do
-    fail unless have_postgres?
-    load 'test/db/postgres.rb' rescue nil
+    fail unless PostgresHelper.have_postgres?
+    load 'test/db/postgres_config.rb' rescue nil
     t = Tempfile.new("psql")
     t.puts <<-SQL
 DROP DATABASE IF EXISTS #{POSTGRES_CONFIG[:database]};

data/src/java/arjdbc/db2/DB2RubyJdbcConnection.java

@@ -37,10 +37,17 @@ import arjdbc.jdbc.RubyJdbcConnection;
  * @author mikestone
  */
 public class DB2RubyJdbcConnection extends RubyJdbcConnection {
+    private static final String[] TABLE_TYPES = new String[]{"TABLE", "VIEW", "SYNONYM", "MATERIALIZED QUERY TABLE", "ALIAS"};
+
     protected DB2RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
     }
 
+    @Override
+    protected String[] getTableTypes() {
+        return TABLE_TYPES;
+    }
+
     @Override
     protected boolean databaseSupportsSchemas() {
         return true;

data/src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -77,6 +77,7 @@ import org.jruby.util.ByteList;
  */
 public class RubyJdbcConnection extends RubyObject {
     private static final String[] TABLE_TYPE = new String[]{"TABLE"};
+    private static final String[] TABLE_TYPES = new String[]{"TABLE", "VIEW", "SYNONYM"};
 
     private static RubyObjectAdapter rubyApi;
 
@@ -104,6 +105,10 @@ public class RubyJdbcConnection extends RubyObject {
         return (RubyModule) runtime.getModule("ActiveRecord").getConstant("ConnectionAdapters");
     }
 
+    protected String[] getTableTypes() {
+        return TABLE_TYPES;
+    }
+
     @JRubyMethod(name = "begin")
     public IRubyObject begin(ThreadContext context) throws SQLException {
         final Ruby runtime = context.getRuntime();
@@ -126,9 +131,8 @@ public class RubyJdbcConnection extends RubyObject {
                     String tableName = rubyApi.convertToRubyString(args[0]).getUnicodeValue();
                     TableNameComponents components = extractTableNameComponents(c, defaultSchema, tableName);
 
-                    String[] tableTypes = new String[]{"TABLE","VIEW","SYNONYM"};
                     RubyArray matchingTables = (RubyArray) tableLookupBlock(context.getRuntime(),
-                            components.catalog, components.schema, components.table, tableTypes, false).call(c);
+                            components.catalog, components.schema, components.table, getTableTypes(), false).call(c);
                     if (matchingTables.isEmpty()) {
                         throw new SQLException("Table " + tableName + " does not exist");
                     }
@@ -507,7 +511,7 @@ public class RubyJdbcConnection extends RubyObject {
     public static IRubyObject select_p(ThreadContext context, IRubyObject recv, IRubyObject _sql) {
         ByteList sql = rubyApi.convertToRubyString(_sql).getByteList();
 
-        return context.getRuntime().newBoolean(startsWithNoCaseCmp(sql, SELECT) ||
+        return context.getRuntime().newBoolean(startsWithNoCaseCmp(sql, SELECT) || startsWithNoCaseCmp(sql, WITH) ||
                 startsWithNoCaseCmp(sql, SHOW) || startsWithNoCaseCmp(sql, CALL));
     }
 
@@ -1246,6 +1250,7 @@ public class RubyJdbcConnection extends RubyObject {
     private static byte[] CALL = new byte[]{'c', 'a', 'l', 'l'};
     private static byte[] INSERT = new byte[] {'i', 'n', 's', 'e', 'r', 't'};
     private static byte[] SELECT = new byte[] {'s', 'e', 'l', 'e', 'c', 't'};
+    private static byte[] WITH = new byte[] {'w', 'i', 't', 'h'};
     private static byte[] SHOW = new byte[] {'s', 'h', 'o', 'w'};
 
     private static boolean startsWithNoCaseCmp(ByteList bytelist, byte[] compare) {

data/test/abstract_db_create.rb

@@ -82,8 +82,12 @@ module AbstractDbCreate
     end
     ar_version = $LOADED_FEATURES.grep(%r{active_record/version}).first
     ar_lib_path = $LOAD_PATH.detect {|p| p if File.exist?File.join(p, ar_version)}
+    # if the old style finder didn't work, assume we have the absolute path already
+    if ar_lib_path.nil? && File.exist?(ar_version)
+      ar_lib_path = ar_version.sub(%r{/active_record/version.*}, '')
+    end
     ar_lib_path = ar_lib_path.sub(%r{activerecord/lib}, 'railties/lib') # edge rails
-    rails_lib_path = ar_lib_path.sub(/activerecord/, 'rails') # gem rails
+    rails_lib_path = ar_lib_path.sub(/activerecord-([\d\.]+)/, 'rails-\1') # gem rails
     load "#{rails_lib_path}/tasks/databases.rake"
   end
 

data/test/activerecord/connection_adapters/type_conversion_test.rb

@@ -1,7 +1,6 @@
 require 'java'
 require 'models/data_types'
 require 'arjdbc'
-require 'db/derby'
 require 'test/unit'
 
 JInteger = java.lang.Integer

data/test/db/db2.rb

@@ -1,3 +1,5 @@
+require 'jdbc_common'
+
 config = {
 # DB2 uses $USER if running locally, just add
 # yourself to your db2 groups in /etc/group

data/test/db/derby.rb

@@ -1,3 +1,5 @@
+require 'jdbc_common'
+
 config = {
   :adapter => 'derby',
   :database => "derby-testdb"
@@ -5,8 +7,4 @@ config = {
 
 ActiveRecord::Base.establish_connection(config)
 
-at_exit {
-  # Clean up derby files
-  require 'fileutils'
-  FileUtils.rm_rf('derby-testdb')
-}
+at_exit { FileUtils.rm_rf('derby-testdb') }

data/test/db/h2.rb

@@ -1,3 +1,5 @@
+require 'jdbc_common'
+
 config = {
   :adapter => 'h2',
   :database => 'test.db'
@@ -7,5 +9,5 @@ ActiveRecord::Base.establish_connection(config)
 
 at_exit {
   # Clean up hsqldb when done
-  Dir['test.db*'].each {|f| File.delete(f)}
+  Dir['test.db*'].each {|f| FileUtils.rm_rf(f) }
 }

data/test/db/hsqldb.rb

@@ -1,3 +1,5 @@
+require 'jdbc_common'
+
 config = {
   :adapter => 'hsqldb',
   :database => 'test.db'

data/test/db/informix.rb

@@ -1,3 +1,5 @@
+require 'jdbc_common'
+
 config = {
   :username   => 'blog',
   :password   => 'blog',

data/test/db/jdbc.rb

@@ -1,12 +1,13 @@
-require 'jdbc/mysql'
+require 'jdbc_common'
+require 'db/mysql_config'
 
-config = {
-  # see db/mysql.rb
-  :username => 'arjdbc',
-  :password => 'arjdbc',
-  :adapter  => 'jdbc',
-  :driver   => 'com.mysql.jdbc.Driver',
-  :url      => 'jdbc:mysql://localhost:3306/arjdbc_test'
-}
+require 'jdbc/mysql' # driver not loaded for plain JDBC
+Jdbc::MySQL.load_driver
 
-ActiveRecord::Base.establish_connection(config)
+ActiveRecord::Base.establish_connection({
+  :adapter => 'jdbc',
+  :driver => 'com.mysql.jdbc.Driver',
+  :url => "jdbc:mysql://#{MYSQL_CONFIG[:host]}/#{MYSQL_CONFIG[:database]}",
+  :username => MYSQL_CONFIG[:username],
+  :password => MYSQL_CONFIG[:password],
+})