activerecord-jdbc-adapter 1.1.3 → 1.2.0

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -13,6 +13,7 @@ class ActiveRecord::Base
       config[:url] ||= "jdbc:sqlite:#{database}"
       config[:driver] ||= "org.sqlite.JDBC"
       config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter
+      config[:adapter_spec] = ::ArJdbc::SQLite3
       jdbc_connection(config)
     end
 

data/lib/arjdbc/version.rb

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

data/lib/generators/jdbc/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Creates stubs that ensure activerecord-jdbc is bootstrapped in
+    your Rails application. 
+
+Example:
+    ./script/generate jdbc
+
+    This will create:
+        config/initializers/jdbc.rb
+	lib/tasks/jdbc.rake

data/pom.xml

@@ -0,0 +1,57 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.jruby.activerecord-jdbc</groupId>
+  <artifactId>activerecord-jdbc</artifactId>
+  <packaging>jar</packaging>
+  <version>1.0.0</version>
+  <name>activerecord-jdbc</name>
+  <description>
+    This POM for activerecord-jdbc is just for bootstrapping IDEs. You
+    can't use it to build the project at the moment.
+  </description>
+  <url>http://activerecord-jdbc.kenai.com/</url>
+
+  <issueManagement>
+    <system>JIRA</system>
+    <url>http://kenai.com/jira/browse/ACTIVERECORD_JDBC</url>
+  </issueManagement>
+
+  <scm>
+    <connection>scm:git:git://github.com/nicksieger/activerecord-jdbc-adapter.git</connection>
+    <developerConnection>scm:git:git@github.com:nicksieger/activerecord-jdbc-adapter.git</developerConnection>
+    <url>http://github.com/nicksieger/activerecord-jdbc-adapter</url>
+  </scm>
+
+  <licenses>
+    <license>
+      <name>BSD</name>
+      <url>http://www.opensource.org/licenses/bsd-license.php</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.jruby</groupId>
+      <artifactId>jruby-complete</artifactId>
+      <version>1.5.3</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <outputDirectory>pkg/classes</outputDirectory>
+    <sourceDirectory>src/java</sourceDirectory>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <source>1.5</source>
+          <target>1.5</target>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+
+</project>

data/rakelib/rails.rake

@@ -33,7 +33,7 @@ namespace :rails do
     raise "need location of RAILS source code" unless activerecord
     activerecord = File.join(activerecord, 'activerecord') unless activerecord =~ /activerecord$/
     ar_jdbc = File.expand_path(File.dirname(__FILE__) + '/..')
-    rubylib = "#{ar_jdbc}/lib:#{ar_jdbc}/drivers/#{_driver(driver)}/lib:#{ar_jdbc}/adapters/#{_adapter(driver)}/lib"
+    rubylib = "#{ar_jdbc}/lib:#{ar_jdbc}/jdbc-#{_driver(driver)}/lib:#{ar_jdbc}/activerecord-jdbc#{_adapter(driver)}-adapter/lib"
     Dir.chdir(activerecord) do
       rake "RUBYLIB=#{rubylib}", "#{_target(driver)}"
     end

data/rakelib/test.rake

@@ -12,6 +12,13 @@ else
   task :test => [:test_mysql]
 end
 
+def set_compat_version(task)
+  task.ruby_opts << '-v'
+  if defined?(JRUBY_VERSION)
+    task.ruby_opts << "--#{RUBY_VERSION[/^(\d+\.\d+)/, 1]}"
+  end
+end
+
 def declare_test_task_for(adapter, options = {})
   driver = options[:driver] || adapter
   Rake::TestTask.new("test_#{adapter}") do |t|
@@ -21,10 +28,11 @@ def declare_test_task_for(adapter, options = {})
     end
     t.test_files = files
     t.libs = []
+    set_compat_version(t)
     if defined?(JRUBY_VERSION)
       t.ruby_opts << "-rjdbc/#{driver}"
-      t.libs << "lib" << "drivers/#{driver}/lib"
-      t.libs.push *FileList["adapters/#{adapter}*/lib"]
+      t.libs << "lib" << "jdbc-#{driver}/lib"
+      t.libs.push *FileList["activerecord-jdbc#{adapter}*/lib"]
     end
     t.libs << "test"
     t.verbose = true
@@ -41,12 +49,14 @@ 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' << 'drivers/mysql/lib'
+  t.libs << 'test' << 'jdbc-mysql/lib'
+  set_compat_version(t)
 end
 
 Rake::TestTask.new(:test_jndi) do |t|
   t.test_files = FileList['test/jndi*_test.rb']
-  t.libs << 'test' << 'drivers/derby/lib'
+  t.libs << 'test' << 'jdbc-derby/lib'
+  set_compat_version(t)
 end
 
 task :test_postgresql => [:test_postgres]
@@ -59,6 +69,7 @@ task :test_pgsql => [:test_postgres]
     t.libs = []
     t.libs << 'lib' if defined?(JRUBY_VERSION)
     t.libs << 'test'
+    set_compat_version(t)
   end
 end
 
@@ -66,16 +77,19 @@ end
 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' 
+  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' 
+  t.libs << 'test'
+  set_compat_version(t)
 end

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

@@ -817,8 +817,11 @@ public class RubyJdbcConnection extends RubyObject {
             case Types.BLOB:
             case Types.LONGVARBINARY:
             case Types.VARBINARY:
-            case Types.LONGVARCHAR:
                 return streamToRuby(runtime, resultSet, resultSet.getBinaryStream(column));
+            case Types.LONGVARCHAR:
+                return runtime.is1_9() ?
+                    readerToRuby(runtime, resultSet, resultSet.getCharacterStream(column)) :
+                    streamToRuby(runtime, resultSet, resultSet.getBinaryStream(column));
             case Types.CLOB:
                 return readerToRuby(runtime, resultSet, resultSet.getCharacterStream(column));
             case Types.TIMESTAMP:

data/src/java/arjdbc/jdbc/SQLBlock.java

@@ -36,7 +36,7 @@ import java.sql.Statement;
  * @author nicksieger
  */
 public abstract class SQLBlock {
-    abstract Object call(Connection c) throws SQLException;
+    protected abstract Object call(Connection c) throws SQLException;
 
     public void close(Statement statement) {
         RubyJdbcConnection.close(statement);

data/src/java/arjdbc/mysql/MySQLRubyJdbcConnection.java

@@ -26,13 +26,21 @@
 package arjdbc.mysql;
 
 import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.sql.ResultSet;
 import java.sql.Statement;
 import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
 
+import arjdbc.jdbc.SQLBlock;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyNil;
+import org.jruby.RubyString;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
@@ -84,4 +92,70 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
             return new MySQLRubyJdbcConnection(runtime, klass);
         }
     };
+
+  @Override
+  protected IRubyObject indexes(final ThreadContext context, final String tableNameArg, String name, final String schemaNameArg) {
+    return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
+      @Override
+      public Object call(Connection connection) throws SQLException {
+        Ruby runtime = context.getRuntime();
+        DatabaseMetaData metadata = connection.getMetaData();
+        String jdbcTableName = caseConvertIdentifierForJdbc(metadata, tableNameArg);
+        String jdbcSchemaName = caseConvertIdentifierForJdbc(metadata, schemaNameArg);
+
+        StringBuilder buffer = new StringBuilder("SHOW KEYS FROM ");
+        if (jdbcSchemaName != null) buffer.append(jdbcSchemaName).append(".");
+        buffer.append(jdbcTableName);
+        buffer.append(" WHERE key_name != 'PRIMARY'");
+        String query = buffer.toString();
+
+        List<IRubyObject> indexes = new ArrayList<IRubyObject>();
+        PreparedStatement stmt = null;
+        ResultSet rs = null;
+
+        try {
+          stmt = connection.prepareStatement(query);
+          rs = stmt.executeQuery();
+
+          IRubyObject rubyTableName = RubyString.newUnicodeString(runtime, caseConvertIdentifierForJdbc(metadata, tableNameArg));
+          RubyModule indexDefinitionClass = getConnectionAdapters(runtime).getClass("IndexDefinition");
+          String currentKeyName = null;
+
+          while (rs.next()) {
+            String keyName = caseConvertIdentifierForRails(metadata, rs.getString("key_name"));
+
+            if (!keyName.equals(currentKeyName)) {
+              currentKeyName = keyName;
+
+              boolean nonUnique = rs.getBoolean("non_unique");
+              IRubyObject indexDefinition = indexDefinitionClass.callMethod(context, "new", new IRubyObject[]{
+                rubyTableName,
+                RubyString.newUnicodeString(runtime, keyName),
+                runtime.newBoolean(!nonUnique),
+                runtime.newArray(),
+                runtime.newArray()
+              });
+
+              indexes.add(indexDefinition);
+            }
+
+            IRubyObject lastIndex = indexes.get(indexes.size() - 1);
+            if (lastIndex != null) {
+              String columnName = caseConvertIdentifierForRails(metadata, rs.getString("column_name"));
+              int length = rs.getInt("sub_part");
+              boolean lengthIsNull = rs.wasNull();
+
+              lastIndex.callMethod(context, "columns").callMethod(context, "<<", RubyString.newUnicodeString(runtime, columnName));
+              lastIndex.callMethod(context, "lengths").callMethod(context, "<<", lengthIsNull ? runtime.getNil() : runtime.newFixnum(length));
+            }
+          }
+
+          return runtime.newArray(indexes);
+        } finally {
+          close(rs);
+          close(stmt);
+        }
+      }
+    });
+  }
 }

data/test/abstract_db_create.rb

@@ -8,6 +8,9 @@ module Rails
     def self.config
       @config ||= Object.new
     end
+    def self.paths
+      @paths ||= Hash.new { [] }
+    end
   end
   def self.application
     Rails::Application
@@ -89,8 +92,12 @@ module AbstractDbCreate
     (class << Rails::Application.config; self ; end).instance_eval do
       define_method(:database_configuration) { configs }
     end
+    require 'pathname'
     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)}
+    ar_lib_path = $LOAD_PATH.detect do |p|
+      Pathname.new(p).absolute? && ar_version.start_with?(p) ||
+        File.exist?(File.join(p, ar_version))
+    end
     load "#{ar_lib_path}/active_record/railties/databases.rake"
   end
 

data/test/activerecord/jall.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+for test in *_test.rb; do
+    ./jtest.sh $test
+done
+
+#jruby.sh -I connections/native_jdbc_mysql -e 'Dir.foreach(".") { |file| require file if file =~ /_test.rb$/ }' | tee all.log

data/test/activerecord/jtest.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+jruby.sh -I connections/native_jdbc_mysql $1 | tee $1.log

data/test/jdbc_common.rb

@@ -3,23 +3,25 @@ def jruby?
   defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
 end
 
-require 'rubygems'
-require 'pick_rails_version'
 require 'arjdbc' if jruby?
 puts "Using activerecord version #{ActiveRecord::VERSION::STRING}"
-puts "Specify version with AR_VERSION=={version} or RUBYLIB={path}"
+puts "Specify version with AR_VERSION={version} or RUBYLIB={path}"
 require 'models/auto_id'
 require 'models/entry'
 require 'models/data_types'
 require 'models/add_not_null_column_to_table'
 require 'models/validates_uniqueness_of_string'
 require 'models/string_id'
+require 'models/thing'
 require 'simple'
 require 'has_many_through'
 require 'helper'
 require 'test/unit'
 
 # Comment/uncomment to enable logging to be loaded for any of the database adapters
-require 'db/logger' if $DEBUG || ENV['DEBUG']
+if $DEBUG || ENV['DEBUG']
+  require 'db/logger'
+  require 'ruby-debug'
+end
 
 

data/test/models/data_types.rb

@@ -16,7 +16,7 @@ class DbTypeMigration < ActiveRecord::Migration
       t.column :sample_integer_with_limit_2, :integer, :limit => 2
       t.column :sample_integer_with_limit_8, :integer, :limit => 8
       t.column :sample_integer_no_limit, :integer
-      t.column :sample_integer_negative_default, :integer, :default => -1
+      t.column :sample_integer_neg_default, :integer, :default => -1
       t.column :sample_text, :text
     end
   end

data/test/models/string_id.rb

@@ -12,4 +12,6 @@ end
 
 class StringId < ActiveRecord::Base
   def self.table_name () "string_ids" end
+  # Fake out a table without a primary key
+  self.primary_key = "id"
 end

data/test/models/thing.rb

@@ -0,0 +1,16 @@
+class CreateThings < ActiveRecord::Migration
+  def self.up
+    create_table :things, :id => false do |t|
+      t.string :name
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :things
+  end
+end
+
+class Thing < ActiveRecord::Base
+end

data/test/mysql_index_length_test.rb

@@ -0,0 +1,58 @@
+require 'jdbc_common'
+require 'db/mysql'
+
+class MySQLIndexLengthDBSetup < ActiveRecord::Migration
+  def self.up
+    execute <<-SQL
+      CREATE TABLE index_length_test (
+        int_column INT,
+        text_column TEXT,
+        second_text_column TEXT,
+        INDEX ix_int (int_column),
+        INDEX ix_length_text (text_column(255))
+      )
+    SQL
+  end
+
+  def self.down
+    drop_table 'index_length_test'
+  end
+end
+
+class MySQLIndexLengthTest < Test::Unit::TestCase
+  def setup
+    MySQLIndexLengthDBSetup.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    MySQLIndexLengthDBSetup.down
+  end
+
+  def test_index_length
+    index = @connection.indexes('index_length_test').find { |idx| idx.name == 'ix_length_text' }
+    assert_not_nil index
+    assert_equal "index_length_test", index.table
+    assert_equal "ix_length_text", index.name
+    assert !index.unique
+    assert_equal ["text_column"], index.columns
+    assert_equal [255], index.lengths
+  end
+
+  def test_add_index
+    @connection.add_index 'index_length_test', ['text_column', 'second_text_column'],
+      :name => 'added_index', :length => {'text_column' => 32, 'second_text_column' => 64}
+
+    index = @connection.indexes('index_length_test').find { |idx| idx.name == 'added_index' }
+    assert_not_nil index
+    assert_equal ['text_column', 'second_text_column'], index.columns
+    assert_equal [32, 64], index.lengths
+  end
+
+  def test_index_without_length
+    index = @connection.indexes('index_length_test').find { |idx| idx.name == 'ix_int' }
+    assert_not_nil index
+    assert_equal ['int_column'], index.columns
+    assert_equal [nil], index.lengths
+  end
+end