activerecord-jdbc-adapter-onsite 1.2.2

data/src/java/arjdbc/oracle/OracleRubyJdbcConnection.java

@@ -0,0 +1,85 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ***** END LICENSE BLOCK *****/
+package arjdbc.oracle;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author nicksieger
+ */
+public class OracleRubyJdbcConnection extends RubyJdbcConnection {
+    protected OracleRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public static RubyClass createOracleJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("OracleJdbcConnection",
+                jdbcConnection, ORACLE_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(OracleRubyJdbcConnection.class);
+
+        return clazz;
+    }
+
+    private static ObjectAllocator ORACLE_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new OracleRubyJdbcConnection(runtime, klass);
+        }
+    };
+
+    /**
+     * Oracle needs this override to reconstruct NUMBER which is different
+     * from NUMBER(x) or NUMBER(x,y).
+     */
+    @Override
+    protected String typeFromResultSet(ResultSet resultSet) throws SQLException {
+        int precision = intFromResultSet(resultSet, COLUMN_SIZE);
+        int scale = intFromResultSet(resultSet, DECIMAL_DIGITS);
+
+        // According to http://forums.oracle.com/forums/thread.jspa?threadID=658646
+        // Unadorned NUMBER reports scale == null, so we look for that here.
+        if (scale < 0 && resultSet.getInt(DATA_TYPE) == java.sql.Types.DECIMAL) {
+            precision = -1;
+        }
+
+        String type = resultSet.getString(TYPE_NAME);
+        if (precision > 0) {
+            type += "(" + precision;
+            if(scale > 0) type += "," + scale;
+            type += ")";
+        }
+
+        return type;
+    }
+}

data/src/java/arjdbc/postgresql/PostgresqlRubyJdbcConnection.java

@@ -0,0 +1,82 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ***** END LICENSE BLOCK *****/
+package arjdbc.postgresql;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author enebo
+ */
+public class PostgresqlRubyJdbcConnection extends RubyJdbcConnection {
+    protected PostgresqlRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public static RubyClass createPostgresqlJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("PostgresJdbcConnection",
+                jdbcConnection, POSTGRESQL_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(PostgresqlRubyJdbcConnection.class);
+
+        return clazz;
+    }
+
+    /**
+     * Override jdbcToRuby type conversions to handle infinite timestamps.
+     * Handing timestamp off to ruby as string so adapter can perform type
+     * conversion to timestamp
+     */
+    @Override
+    protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, 
+                                     ResultSet resultSet)
+        throws SQLException {
+        if(type == Types.TIMESTAMP) {
+            try {
+                return stringToRuby(runtime, resultSet, 
+                                    resultSet.getString(column));
+            } catch(java.io.IOException ioe) {
+                SQLException ex = new SQLException(ioe.getMessage());
+                throw (SQLException) ex.initCause(ioe);
+            }
+        }
+        return super.jdbcToRuby(runtime, column, type, resultSet);
+    }
+
+    private static ObjectAllocator POSTGRESQL_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new PostgresqlRubyJdbcConnection(runtime, klass);
+        }
+    };
+}

data/src/java/arjdbc/sqlite3/Sqlite3RubyJdbcConnection.java

@@ -0,0 +1,126 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ***** END LICENSE BLOCK *****/
+
+package arjdbc.sqlite3;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+import arjdbc.jdbc.SQLBlock;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author enebo
+ */
+public class Sqlite3RubyJdbcConnection extends RubyJdbcConnection {
+    protected Sqlite3RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public static RubyClass createSqlite3JdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("Sqlite3JdbcConnection",
+                jdbcConnection, SQLITE3_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(Sqlite3RubyJdbcConnection.class);
+
+        return clazz;
+    }
+
+    private static ObjectAllocator SQLITE3_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new Sqlite3RubyJdbcConnection(runtime, klass);
+        }
+    };
+
+    @JRubyMethod(name = "last_insert_row_id")
+    public IRubyObject getLastInsertRowId(final ThreadContext context) 
+        throws SQLException {
+        return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
+                public Object call(Connection c) throws SQLException {
+                    Statement stmt = null;
+                    try {
+                        stmt = c.createStatement();
+                        return unmarshal_id_result(context.getRuntime(),
+                                                   stmt.getGeneratedKeys());
+                    } catch (SQLException sqe) {
+                        if (context.getRuntime().isDebug()) {
+                            System.out.println("Error SQL:" + sqe.getMessage());
+                        }
+                        throw sqe;
+                    } finally {
+                        close(stmt);
+                    }
+                }
+            });
+    }
+
+    @Override
+    protected IRubyObject tables(ThreadContext context, String catalog, String schemaPattern, String tablePattern, String[] types) {
+        return (IRubyObject) withConnectionAndRetry(context, tableLookupBlock(context.getRuntime(), catalog, schemaPattern, tablePattern, types, true));
+    }
+
+    @Override
+    protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, ResultSet resultSet)
+            throws SQLException {
+        try {
+            // This is rather gross, and only needed because the resultset metadata for SQLite tries to be overly
+            // clever, and returns a type for the column of the "current" row, so an integer value stored in a 
+            // decimal column is returned as Types.INTEGER.  Therefore, if the first row of a resultset was an
+            // integer value, all rows of that result set would get truncated.
+            if( resultSet instanceof ResultSetMetaData ) {
+                type = ((ResultSetMetaData)resultSet).getColumnType(column);
+            }
+            switch (type) {
+            case Types.BINARY:
+            case Types.BLOB:
+            case Types.LONGVARBINARY:
+            case Types.VARBINARY:
+                return streamToRuby(runtime, resultSet, new ByteArrayInputStream(resultSet.getBytes(column)));
+            case Types.LONGVARCHAR:
+                return runtime.is1_9() ?
+                    readerToRuby(runtime, resultSet, resultSet.getCharacterStream(column)) :
+                    streamToRuby(runtime, resultSet, new ByteArrayInputStream(resultSet.getBytes(column)));
+            default:
+                return super.jdbcToRuby(runtime, column, type, resultSet);
+            }
+        } catch (IOException ioe) {
+            throw (SQLException) new SQLException(ioe.getMessage()).initCause(ioe);
+        }
+    }
+}

data/test/abstract_db_create.rb

@@ -0,0 +1,135 @@
+require 'jdbc_common'
+require 'rake'
+
+module Rails
+  class Configuration
+  end
+  class Application
+    def self.config
+      @config ||= Object.new
+    end
+    def self.paths
+      @paths ||= Hash.new { [] }
+    end
+  end
+  def self.application
+    Rails::Application
+  end
+end
+
+module AbstractDbCreate
+  def self.included(base)
+    base.module_eval { include Rake::DSL } if defined?(Rake::DSL)
+  end
+
+  def setup
+    @prevapp = Rake.application
+    Rake.application = Rake::Application.new
+    verbose(true)
+    do_setup
+  end
+
+  def do_setup(env = 'unittest', db = 'test_rake_db_create')
+    @env = env
+    @prevconfigs = ActiveRecord::Base.configurations
+    ActiveRecord::Base.connection.disconnect!
+    @db_name = db
+    setup_rails
+    set_rails_constant("env", @env)
+    set_rails_constant("root", ".")
+    load File.dirname(__FILE__) + '/../lib/arjdbc/jdbc/jdbc.rake' if jruby?
+    task :environment do
+      ActiveRecord::Base.configurations = configurations
+      @full_env_loaded = true
+    end
+    task :rails_env do
+      @rails_env_set = true
+    end
+  end
+
+  def teardown
+    Rake::Task["db:drop"].invoke
+    Rake.application = @prevapp
+    restore_rails
+    ActiveRecord::Base.configurations = @prevconfigs
+    ActiveRecord::Base.establish_connection(db_config)
+    @rails_env_set = nil
+    @full_env_loaded = nil
+  end
+
+  def setup_rails
+    if ActiveRecord::VERSION::MAJOR == 3
+      setup_rails3
+    else
+      setup_rails2
+    end
+  end
+
+  def configurations
+    the_db_name = @db_name
+    the_db_config = db_config
+    the_db_config = the_db_config.merge({:database => the_db_name}) if the_db_name
+    the_db_config.stringify_keys!
+    @configs = { @env => the_db_config }
+    @configs["test"] = @configs[@env].dup
+    @configs
+  end
+
+  def setup_rails2
+    configs = configurations
+    Rails::Configuration.class_eval do
+      define_method(:database_configuration) { configs }
+    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)}
+    ar_lib_path = ar_lib_path.sub(%r{activerecord/lib}, 'railties/lib') # edge rails
+    rails_lib_path = ar_lib_path.sub(/activerecord-([\d\.]+)/, 'rails-\1') # gem rails
+    load "#{rails_lib_path}/tasks/databases.rake"
+  end
+
+  def setup_rails3
+    configs = configurations
+    (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 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
+
+  def set_rails_constant(name, value)
+    cname ="RAILS_#{name.upcase}"
+    @constants ||= {}
+    @constants[name] = Object.const_get(cname) rescue nil
+    silence_warnings { Object.const_set(cname, value) }
+    Rails.instance_eval do
+      if instance_methods(false).include?(name)
+        alias_method "orig_#{name}", name
+        define_method(name) { value }
+      end
+    end
+  end
+
+  def restore_rails
+    @constants.each do |key,value|
+      silence_warnings { Object.const_set("RAILS_#{key.upcase}", value) }
+      Rails.instance_eval do
+        if instance_methods(false).include?(name)
+          remove_method name
+          alias_method name, "orig_#{name}"
+        end
+      end
+    end
+  end
+
+  def silence_warnings
+    prev, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = prev
+  end
+end

data/test/activerecord/connection_adapters/type_conversion_test.rb

@@ -0,0 +1,31 @@
+require 'java'
+require 'models/data_types'
+require 'arjdbc'
+require 'db/derby'
+require 'test/unit'
+
+JInteger = java.lang.Integer
+
+class TypeConversionTest < Test::Unit::TestCase
+  TEST_TIME = Time.at(1169964202).gmtime
+  def setup
+    DbTypeMigration.up  
+    DbType.create(
+      :sample_timestamp => TEST_TIME,
+      :sample_decimal => JInteger::MAX_VALUE + 1)
+  end
+  
+  def teardown
+    DbTypeMigration.down
+  end
+  
+  def test_timestamp
+    types = DbType.find(:first)
+    assert_equal TEST_TIME, types.sample_timestamp.getutc
+  end
+  
+  def test_decimal
+    types = DbType.find(:first)
+    assert_equal((JInteger::MAX_VALUE + 1), types.sample_decimal)
+  end
+end