activerecord-jdbc-adapter 1.2.0 → 1.2.1

data/rakelib/db.rake

@@ -1,19 +1,27 @@
 namespace :db do
-  task :load_arjdbc do
-    $LOAD_PATH.unshift 'test'
-    $LOAD_PATH.unshift 'lib'
-    require 'abstract_db_create'
-  end
-
   desc "Creates the test database for MySQL."
-  task :mysql => :load_arjdbc do
+  task :mysql do
     load 'test/db/mysql.rb' rescue nil
-    def db_config
-      MYSQL_CONFIG
+    IO.popen("mysql -u root", "w") do |io|
+      io.puts <<-SQL
+DROP DATABASE IF EXISTS `#{MYSQL_CONFIG[:database]}`;
+CREATE DATABASE `#{MYSQL_CONFIG[:database]}` DEFAULT CHARACTER SET `utf8`;
+GRANT ALL PRIVILEGES ON `#{MYSQL_CONFIG[:database]}`.* TO #{MYSQL_CONFIG[:username]}@localhost;
+SET PASSWORD FOR #{MYSQL_CONFIG[:username]}@localhost = PASSWORD('#{MYSQL_CONFIG[:password]}');
+SQL
+    end
+  end
+
+  desc "Creates the test database for PostgreSQL."
+  task :postgres do
+    load 'test/db/postgres.rb' rescue nil
+    IO.popen("psql", "w") do |io|
+      io.puts <<-SQL
+DROP DATABASE IF EXISTS #{POSTGRES_CONFIG[:database]};
+DROP USER IF EXISTS #{POSTGRES_CONFIG[:username]};
+CREATE USER #{POSTGRES_CONFIG[:username]} CREATEDB SUPERUSER LOGIN PASSWORD '#{POSTGRES_CONFIG[:password]}';
+CREATE DATABASE #{POSTGRES_CONFIG[:database]} OWNER #{POSTGRES_CONFIG[:username]};
+SQL
     end
-    extend AbstractDbCreate
-    do_setup('arjdbc', nil)
-    Rake::Task['db:drop'].invoke rescue nil
-    Rake::Task['db:create'].invoke
   end
 end

data/rakelib/rails.rake

@@ -26,7 +26,7 @@ namespace :rails do
     end
   end
 
-  task :test => "java_compile" do
+  task :test => :jar do
     driver = ENV['DRIVER']
     raise "need a DRIVER" unless driver
     activerecord = ENV['RAILS']

data/src/java/arjdbc/derby/DerbyModule.java

@@ -1,5 +1,5 @@
 /***** BEGIN LICENSE BLOCK *****
- * Copyright (c) 2006-2007, 2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2011 Nick Sieger <nick@nicksieger.com>
  * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining
@@ -29,13 +29,8 @@ import java.sql.SQLException;
 import arjdbc.jdbc.RubyJdbcConnection;
 
 import org.jruby.Ruby;
-import org.jruby.RubyBigDecimal;
-import org.jruby.RubyBignum;
 import org.jruby.RubyBoolean;
-import org.jruby.RubyFixnum;
-import org.jruby.RubyFloat;
 import org.jruby.RubyModule;
-import org.jruby.RubyNumeric;
 import org.jruby.RubyObjectAdapter;
 import org.jruby.RubyRange;
 import org.jruby.RubyString;
@@ -66,39 +61,39 @@ public class DerbyModule {
             String type = rubyApi.getInstanceVariable(recv, "@type").toString();
 
             switch (type.charAt(0)) {
-                case 's': //string
+            case 's': //string
+                return value;
+            case 't': //text, timestamp, time
+                if (type.equals("text")) {
                     return value;
-                case 't': //text, timestamp, time
-                    if (type.equals("text")) {
-                        return value;
-                    } else if (type.equals("timestamp")) {
-                        return rubyApi.callMethod(recv.getMetaClass(), "string_to_time", value);
-                    } else { //time
-                        return rubyApi.callMethod(recv.getMetaClass(), "string_to_dummy_time", value);
-                    }
-                case 'i': //integer
-                case 'p': //primary key
-                    if (value.respondsTo("to_i")) {
-                        return rubyApi.callMethod(value, "to_i");
-                    } else {
-                        return runtime.newFixnum(value.isTrue() ? 1 : 0);
-                    }
-                case 'd': //decimal, datetime, date
-                    if (type.equals("datetime")) {
-                        return rubyApi.callMethod(recv.getMetaClass(), "string_to_time", value);
-                    } else if (type.equals("date")) {
-                        return rubyApi.callMethod(recv.getMetaClass(), "string_to_date", value);
-                    } else {
-                        return rubyApi.callMethod(recv.getMetaClass(), "value_to_decimal", value);
-                    }
-                case 'f': //float
-                    return rubyApi.callMethod(value, "to_f");
-                case 'b': //binary, boolean
-                    if (type.equals("binary")) {
-                        return rubyApi.callMethod(recv.getMetaClass(), "binary_to_string", value);
-                    } else {
-                        return rubyApi.callMethod(recv.getMetaClass(), "value_to_boolean", value);
-                    }
+                } else if (type.equals("timestamp")) {
+                    return rubyApi.callMethod(recv.getMetaClass(), "string_to_time", value);
+                } else { //time
+                    return rubyApi.callMethod(recv.getMetaClass(), "string_to_dummy_time", value);
+                }
+            case 'i': //integer
+            case 'p': //primary key
+                if (value.respondsTo("to_i")) {
+                    return rubyApi.callMethod(value, "to_i");
+                } else {
+                    return runtime.newFixnum(value.isTrue() ? 1 : 0);
+                }
+            case 'd': //decimal, datetime, date
+                if (type.equals("datetime")) {
+                    return rubyApi.callMethod(recv.getMetaClass(), "string_to_time", value);
+                } else if (type.equals("date")) {
+                    return rubyApi.callMethod(recv.getMetaClass(), "string_to_date", value);
+                } else {
+                    return rubyApi.callMethod(recv.getMetaClass(), "value_to_decimal", value);
+                }
+            case 'f': //float
+                return rubyApi.callMethod(value, "to_f");
+            case 'b': //binary, boolean
+                if (type.equals("binary")) {
+                    return rubyApi.callMethod(recv.getMetaClass(), "binary_to_string", value);
+                } else {
+                    return rubyApi.callMethod(recv.getMetaClass(), "value_to_boolean", value);
+                }
             }
             return value;
         }
@@ -115,6 +110,8 @@ public class DerbyModule {
             if (type.equals("text") || type.equals("string")) {
             	value = make_ruby_string_for_text_column(context, recv, runtime, value);
             }
+            String metaClass = value.getMetaClass().getName();
+
             if (value instanceof RubyString) {
                 if (type.equals("string")) {
                     return quote_string_with_surround(runtime, "'", (RubyString)value, "'");
@@ -130,7 +127,7 @@ public class DerbyModule {
                         return super_quote(context, recv, runtime, value, col);
                     }
                 }
-            } else if ((value instanceof RubyFloat) || (value instanceof RubyFixnum) || (value instanceof RubyBignum)) {
+            } else if (metaClass.equals("Float") || metaClass.equals("Fixnum") || metaClass.equals("Bignum")) {
                 if (type.equals("string")) {
                     return quote_string_with_surround(runtime, "'", RubyString.objAsString(context, value), "'");
                 }
@@ -139,49 +136,54 @@ public class DerbyModule {
         return super_quote(context, recv, runtime, value, runtime.getNil());
     }
 
-    /* 
+    /*
      * Derby is not permissive like MySql. Try and send an Integer to a CLOB or VARCHAR column and Derby will vomit.
      * This method turns non stringy things into strings.
      */
     private static IRubyObject make_ruby_string_for_text_column(ThreadContext context, IRubyObject recv, Ruby runtime, IRubyObject value) {
-    	RubyModule multibyteChars = (RubyModule) 
-        ((RubyModule) ((RubyModule) runtime.getModule("ActiveSupport")).getConstant("Multibyte")).getConstantAt("Chars");
-		if (value instanceof RubyString || rubyApi.isKindOf(value, multibyteChars) || value.isNil()) {
-			return value;
-		}
-		if (value instanceof RubyBoolean) {
+    	RubyModule multibyteChars = (RubyModule)
+            ((RubyModule) ((RubyModule) runtime.getModule("ActiveSupport")).getConstant("Multibyte")).getConstantAt("Chars");
+        if (value instanceof RubyString || rubyApi.isKindOf(value, multibyteChars) || value.isNil()) {
+            return value;
+        }
+
+        String metaClass = value.getMetaClass().getName();
+
+        if (value instanceof RubyBoolean) {
             return value.isTrue() ? runtime.newString("1") : runtime.newString("0");
-		} else if (value instanceof RubyFloat || value instanceof RubyFixnum || value instanceof RubyBignum) {
-			return RubyString.objAsString(context, value);
-		} else if ( value instanceof RubyBigDecimal) {
-			return rubyApi.callMethod(value, "to_s", runtime.newString("F"));
-		} else {
-			if (rubyApi.callMethod(value, "acts_like?", runtime.newString("date")).isTrue() || rubyApi.callMethod(value, "acts_like?", runtime.newString("time")).isTrue()) {
-	            return (RubyString)rubyApi.callMethod(recv, "quoted_date", value); 
-	        } else {
-	            return (RubyString)rubyApi.callMethod(value, "to_yaml");
-	        }
-		}
-	}
-
-	private final static ByteList NULL = new ByteList("NULL".getBytes());
+        } else if (metaClass.equals("Float") || metaClass.equals("Fixnum") || metaClass.equals("Bignum")) {
+            return RubyString.objAsString(context, value);
+        } else if (metaClass.equals("BigDecimal")) {
+            return rubyApi.callMethod(value, "to_s", runtime.newString("F"));
+        } else {
+            if (rubyApi.callMethod(value, "acts_like?", runtime.newString("date")).isTrue() || rubyApi.callMethod(value, "acts_like?", runtime.newString("time")).isTrue()) {
+                return (RubyString)rubyApi.callMethod(recv, "quoted_date", value);
+            } else {
+                return (RubyString)rubyApi.callMethod(value, "to_yaml");
+            }
+        }
+    }
+
+    private final static ByteList NULL = new ByteList("NULL".getBytes());
 
     private static IRubyObject super_quote(ThreadContext context, IRubyObject recv, Ruby runtime, IRubyObject value, IRubyObject col) {
         if (value.respondsTo("quoted_id")) {
             return rubyApi.callMethod(value, "quoted_id");
         }
 
+        String metaClass = value.getMetaClass().getName();
+
         IRubyObject type = (col.isNil()) ? col : rubyApi.callMethod(col, "type");
         RubyModule multibyteChars = (RubyModule)
-                ((RubyModule) ((RubyModule) runtime.getModule("ActiveSupport")).getConstant("Multibyte")).getConstantAt("Chars");
+            ((RubyModule) ((RubyModule) runtime.getModule("ActiveSupport")).getConstant("Multibyte")).getConstantAt("Chars");
         if (value instanceof RubyString || rubyApi.isKindOf(value, multibyteChars)) {
             RubyString svalue = RubyString.objAsString(context, value);
             if (type == runtime.newSymbol("binary") && col.getType().respondsTo("string_to_binary")) {
                 return quote_string_with_surround(runtime, "'", (RubyString)(rubyApi.callMethod(col.getType(), "string_to_binary", svalue)), "'");
             } else if (type == runtime.newSymbol("integer") || type == runtime.newSymbol("float")) {
                 return RubyString.objAsString(context, ((type == runtime.newSymbol("integer")) ?
-                                               rubyApi.callMethod(svalue, "to_i") :
-                                               rubyApi.callMethod(svalue, "to_f")));
+                                                        rubyApi.callMethod(svalue, "to_i") :
+                                                        rubyApi.callMethod(svalue, "to_f")));
             } else {
                 return quote_string_with_surround(runtime, "'", svalue, "'");
             }
@@ -191,9 +193,9 @@ public class DerbyModule {
             return (value.isTrue() ?
                     (type == runtime.newSymbol(":integer")) ? runtime.newString("1") : rubyApi.callMethod(recv, "quoted_true") :
                     (type == runtime.newSymbol(":integer")) ? runtime.newString("0") : rubyApi.callMethod(recv, "quoted_false"));
-        } else if((value instanceof RubyFloat) || (value instanceof RubyFixnum) || (value instanceof RubyBignum)) {
+        } else if (metaClass.equals("Float") || metaClass.equals("Fixnum") || metaClass.equals("Bignum")) {
             return RubyString.objAsString(context, value);
-        } else if(value instanceof RubyBigDecimal) {
+        } else if (metaClass.equals("BigDecimal")) {
             return rubyApi.callMethod(value, "to_s", runtime.newString("F"));
         } else if (rubyApi.callMethod(value, "acts_like?", runtime.newString("date")).isTrue() || rubyApi.callMethod(value, "acts_like?", runtime.newString("time")).isTrue()) {
             return quote_string_with_surround(runtime, "'", (RubyString)(rubyApi.callMethod(recv, "quoted_date", value)), "'");
@@ -237,8 +239,8 @@ public class DerbyModule {
             output.append(lower);
             written += 2;
             if(written >= 16334) { // max hex length = 16334
-              output.append("'||X'".getBytes());
-              written = 0;
+                output.append("'||X'".getBytes());
+                written = 0;
             }
         }
 

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

@@ -26,10 +26,21 @@
 
 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;
@@ -57,8 +68,59 @@ public class Sqlite3RubyJdbcConnection extends RubyJdbcConnection {
         }
     };
 
+    @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/db/mysql.rb

@@ -1,8 +1,8 @@
 MYSQL_CONFIG = {
-  :username => 'blog',
-  :password => '',
+  :username => 'arjdbc',
+  :password => 'arjdbc',
   :adapter  => 'mysql',
-  :database => 'weblog_development',
+  :database => 'arjdbc_test',
   :host     => 'localhost'
 }
 

data/test/db/postgres.rb

@@ -1,9 +1,9 @@
 POSTGRES_CONFIG = {
   :adapter => 'postgresql',
-  :database => 'weblog_development',
+  :database => 'arjdbc_test',
   :host => 'localhost',
-  :username => 'blog',
-  :password => ''
+  :username => 'arjdbc',
+  :password => 'arjdbc'
 }
 
 ActiveRecord::Base.establish_connection(POSTGRES_CONFIG)

data/test/h2_change_column_test.rb

@@ -0,0 +1,68 @@
+require 'jdbc_common'
+require 'db/h2'
+
+class H2ChangeColumnTest < Test::Unit::TestCase
+
+  class Person < ActiveRecord::Base; end
+
+  class CreatePeopleTable < ActiveRecord::Migration
+    def self.up
+      create_table :people do |t|
+        t.integer :phone
+      end
+    end
+
+    def self.down
+      drop_table :people
+    end
+  end
+
+  def setup
+    CreatePeopleTable.up
+  end
+
+  def teardown
+    CreatePeopleTable.down
+  end
+
+  def test_should_change_column_type
+    ActiveRecord::Migration.change_column :people, :phone, :string
+    Person.reset_column_information
+
+    p = Person.create!(:phone => 'ABC')
+    assert_equal 'ABC', p.phone
+  end
+
+  def test_sets_defaults_on_column
+    ActiveRecord::Migration.change_column :people, :phone, :string, :default => '123456'
+    Person.reset_column_information
+
+    p = Person.create!
+    assert_equal '123456', p.phone
+  end
+
+  def test_should_change_column_default_value
+    ActiveRecord::Migration.add_column    :people, :email, :string, :default => 'foo@example.com'
+    ActiveRecord::Migration.change_column :people, :email, :string, :default => 'bar@example.com'
+    Person.reset_column_information
+
+    p = Person.create!
+    assert_equal 'bar@example.com', p.email
+  end
+
+  def test_should_set_non_null_restriction
+    ActiveRecord::Migration.change_column :people, :phone, :string, :null => false
+    Person.reset_column_information
+    assert_raises(ActiveRecord::StatementInvalid) { Person.create! }
+  end
+
+  def test_should_set_null_restriction_with_default
+    p = Person.create!
+    ActiveRecord::Migration.change_column :people, :phone, :string, :null => true, :default => '123456'
+    Person.reset_column_information
+
+    assert_nil p.reload.phone
+    assert_equal '123456', Person.create!.phone
+  end
+end
+

data/test/helper.rb

@@ -3,3 +3,72 @@ module Kernel
     ENV['PATH'].split(File::PATH_SEPARATOR).detect {|p| File.executable?(File.join(p, name))}
   end
 end
+
+# assert_queries and SQLCounter taken from rails active_record tests
+require 'test/unit'
+class Test::Unit::TestCase
+  def assert_queries(num = 1)
+    ActiveRecord::SQLCounter.log = []
+    yield
+  ensure
+    assert_equal num, ActiveRecord::SQLCounter.log.size, "#{ActiveRecord::SQLCounter.log.size} instead of #{num} queries were executed.#{ActiveRecord::SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{ActiveRecord::SQLCounter.log.join("\n")}"}"
+  end
+end
+
+require 'active_support/notifications'
+module ActiveRecord
+  class SQLCounter
+    def self.ignored_sql
+      @@ignored_sql
+    end
+
+    def self.ignored_sql=(value)
+      @@ignored_sql = value
+    end
+
+    self.ignored_sql = [
+      /^PRAGMA (?!(table_info))/,
+      /^SELECT currval/,
+      /^SELECT CAST/,
+      /^SELECT @@IDENTITY/,
+      /^SELECT @@ROWCOUNT/,
+      /^SAVEPOINT/,
+      /^ROLLBACK TO SAVEPOINT/,
+      /^RELEASE SAVEPOINT/,
+      /^SHOW max_identifier_length/,
+      /^BEGIN/,
+      /^COMMIT/
+    ]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL.  This ignored SQL is for Oracle.
+    ignored_sql.concat [/^select .*nextval/i,
+      /^SAVEPOINT/,
+      /^ROLLBACK TO/,
+      /^\s*select .* from all_triggers/im
+    ]
+
+    def self.log=(v)
+      @@log = v
+    end
+
+    def self.log
+      @@log
+    end
+
+    self.log = []
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      unless 'CACHE' == values[:name]
+        self.class.log << sql unless self.class.ignored_sql.
+          any? { |r| sql =~ r }
+      end
+    end
+  end
+
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+end