activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/test/oracle_binary_test.rb

@@ -0,0 +1,6 @@
+require 'db/oracle'
+require 'binary'
+
+class OracleBinaryTest < Test::Unit::TestCase
+  include BinaryTestMethods
+end

data/test/oracle_limit_test.rb

@@ -19,5 +19,6 @@ class OracleLimitTest < Test::Unit::TestCase
     assert_nothing_thrown do 
       Entry.includes(:user).all
     end
-  end 
+  end if ar_version('3.1') # in_clause_limit not supported in AR <= 3.0
+  
 end 

data/test/oracle_serialize_test.rb

@@ -0,0 +1,6 @@
+require 'db/oracle'
+require 'serialize'
+
+class OracleSerializeTest < Test::Unit::TestCase
+  include SerializeTestMethods
+end

data/test/oracle_simple_test.rb

@@ -15,4 +15,65 @@ class OracleSimpleTest < Test::Unit::TestCase
       assert e1.id != e2.id
     end
   end
+  
+  def test_find_by_sql_WITH_statement
+    user = User.create! :login => 'ferko'
+    Entry.create! :title => 'aaa', :user_id => user.id
+    entries = Entry.find_by_sql '' + 
+      ' WITH EntryLogin (title, login) AS ' +
+      ' ( ' +
+      '  SELECT e.title, u.login ' + 
+      '  FROM entries e INNER JOIN users u ON e.user_id = u.id ' +
+      ' ) ' +
+      ' ' +
+      ' SELECT * FROM EntryLogin ORDER BY title ASC '
+    assert entries.first
+    assert entries.first.title
+    assert entries.first.login
+  end
+  
+  include ExplainSupportTestMethods if ar_version("3.1")
+  
+  protected
+
+  def assert_empty_string value
+    # An empty string is treated as a null value in Oracle :
+    # http://www.techonthenet.com/oracle/questions/empty_null.php
+    assert_equal nil, value
+  end
+
+  def assert_null_text value
+    # Oracle adapter initializes all CLOB fields with empty_clob() 
+    # fn, so they all have a initial value of an empty string ''
+    assert_equal '', value
+  end
+
+  def assert_date_equal expected, actual
+    # Oracle doesn't distinguish btw date/datetime
+    assert_equal expected, actual.to_date
+  end
+  
+  def assert_date_type(value)
+    # NOTE: no support for bare Date type in Oracle :
+    assert_instance_of Date, value.to_date
+  end
+  
+end
+
+class OracleMultibyteTest < Test::Unit::TestCase
+  include MultibyteTestMethods
+
+  def self.startup
+    super
+    MigrationSetup.setup!
+  end
+  
+  def self.shutdown
+    MigrationSetup.teardown!
+    super
+  end
+
+  def setup!; end # MigrationSetup#setup!
+  def teardown!; end # MigrationSetup#teardown!
+  
 end

data/test/oracle_specific_test.rb

@@ -1,40 +1,64 @@
+require 'test_helper'
 require 'jdbc_common'
 require 'db/oracle'
 
-class DefaultNumber < ActiveRecord::Base
-end
-
 class OracleSpecificTest < Test::Unit::TestCase
-  include MultibyteTestMethods  # so we can get @java_con
-
-  def setup
-    super
-    @java_con.createStatement.execute "
+  include MigrationSetup
+  
+  @@java_connection = nil
+  
+  def self.startup
+    config = ActiveRecord::Base.connection.config
+    jdbc_driver = ActiveRecord::ConnectionAdapters::JdbcDriver.new(config[:driver])
+    @@java_connection = jdbc_driver.connection(config[:url], config[:username], config[:password])
+    @@java_connection.setAutoCommit(true)
+    
+    java_connection = @@java_connection
+    java_connection.createStatement.execute "
       CREATE TABLE DEFAULT_NUMBERS (
-       ID INTEGER NOT NULL PRIMARY KEY, VALUE NUMBER, DATUM DATE, FPOINT NUMBER(10,2), VALUE2 NUMBER(15)
+        ID INTEGER NOT NULL PRIMARY KEY, VALUE NUMBER, DATUM DATE, FPOINT NUMBER(10,2), VALUE2 NUMBER(15)
       )"
-    @java_con.createStatement.execute "
+    java_connection.createStatement.execute "
       INSERT INTO DEFAULT_NUMBERS (ID, VALUE, DATUM, FPOINT, VALUE2)
-                          VALUES (1, 0.076, TIMESTAMP'2009-11-05 00:00:00', 1000.01, 1234)"
-    @java_con.createStatement.execute "CREATE SYNONYM POSTS FOR ENTRIES"
+        VALUES (1, 0.076, TIMESTAMP'2009-11-05 00:00:00', 1000.01, 1234)"
+    java_connection.createStatement.execute "CREATE SYNONYM POSTS FOR ENTRIES"
+    
+    MigrationSetup.setup!
   end
 
-  def teardown
-    @java_con.createStatement.execute "DROP TABLE DEFAULT_NUMBERS"
-    @java_con.createStatement.execute "DROP SYNONYM POSTS"
+  def self.shutdown
+    MigrationSetup.teardown!
+    
+    java_connection = @@java_connection
+    java_connection.createStatement.execute "DROP TABLE DEFAULT_NUMBERS"
+    java_connection.createStatement.execute "DROP SYNONYM POSTS"
+    
+    @@java_connection.close
     super
   end
 
+  def setup! # MigrationSetup#setup!
+    # speedup by creating tables once only on startup !
+    # before: Finished in 174.545 seconds.
+    #  after: Finished in 22.504 seconds.
+  end
+
+  def teardown! # MigrationSetup#teardown!
+    # speedup by creating tables once only on startup !
+  end
+  
+  class DefaultNumber < ActiveRecord::Base; end
+  
   def test_default_number_precision
-    assert_equal 0.076, DefaultNumber.find(:first).value
+    assert_equal 0.076, DefaultNumber.first.value
   end
 
   def test_number_with_precision_and_scale
-    assert_equal 1000.01, DefaultNumber.find(:first).fpoint
+    assert_equal 1000.01, DefaultNumber.first.fpoint
   end
 
   def test_number_with_precision
-    assert_equal 1234, DefaultNumber.find(:first).value2
+    assert_equal 1234, DefaultNumber.first.value2
   end
 
   def test_number_type_with_precision_and_scale_is_reported_correctly
@@ -45,39 +69,66 @@ class OracleSpecificTest < Test::Unit::TestCase
 
   # JRUBY-3675, ACTIVERECORD_JDBC-22
   def test_load_date
-    obj = DefaultNumber.find(:first)
+    obj = DefaultNumber.first
     assert_not_nil obj.datum, "no date"
   end
 
   # ACTIVERECORD_JDBC-127
   def test_save_date
-    obj = DefaultNumber.find(:first)
+    obj = DefaultNumber.first
     obj.datum = '01Jan2010'
     obj.save!
   end
 
   def test_save_timestamp
-    obj = DefaultNumber.find(:first)
+    obj = DefaultNumber.first
     obj.datum = Time.now
     obj.save!
   end
 
   def test_load_null_date
-    @java_con.createStatement.execute "UPDATE DEFAULT_NUMBERS SET DATUM = NULL"
-    obj = DefaultNumber.find(:first)
+    java_connection.createStatement.execute "UPDATE DEFAULT_NUMBERS SET DATUM = NULL"
+    obj = DefaultNumber.first
     assert obj.datum.nil?
   end
 
   def test_model_access_by_synonym
     @klass = Class.new(ActiveRecord::Base)
-    @klass.table_name = "POSTS"
+    @klass.table_name = "POSTS" # alias
     entry_columns = Entry.columns_hash
     @klass.columns.each do |c|
-      ec = entry_columns[c.name]
-      assert ec
+      assert ec = entry_columns[c.name]
       assert_equal ec.sql_type, c.sql_type
       assert_equal ec.type, c.type
     end
   end
 
+  #
+
+  def test_oracle_identifier_lengths
+    assert_equal 30, connection.table_alias_length
+    assert_equal 30, connection.table_name_length
+    assert_equal 30, connection.index_name_length
+    assert_equal 30, connection.column_name_length
+  end
+
+  def test_current_user
+    puts "ORA current_user: #{connection.current_user}"
+    assert_instance_of String, connection.current_user
+  end
+
+  def test_current_database
+    puts "ORA current_database: #{connection.current_database}"
+    assert_instance_of String, connection.current_database
+  end
+
+  def test_current_schema
+    puts "ORA current_schema: #{connection.current_schema}"
+    assert_instance_of String, connection.current_schema
+  end
+  
+  private
+  
+  def java_connection; @@java_connection; end
+  
 end if defined?(JRUBY_VERSION)

data/test/postgres_binary_test.rb

@@ -0,0 +1,6 @@
+require 'db/postgres'
+require 'binary'
+
+class PostgresBinaryTest < Test::Unit::TestCase
+  include BinaryTestMethods
+end

data/test/postgres_native_type_mapping_test.rb

@@ -1,21 +1,22 @@
 require 'jdbc_common'
+require 'db/postgres'
 
 class CreateNativeTypeMappingTestSchema < ActiveRecord::Migration
   def self.up
     execute "DROP SEQUENCE IF EXISTS seq_pk_customers"
     execute "CREATE SEQUENCE seq_pk_customers"
     columns = [
-               "bigint_serial_should_be_integer bigint default nextval('seq_pk_customers')",
-               "integer_serial_should_be_integer integer default nextval('seq_pk_customers')",
-               "varchar_should_be_string varchar(2)",
-               "timestamp_should_be_datetime timestamp",
-               "bytea_should_be_binary bytea",
-               "double_precision_should_be_float double precision",
-               "real_should_be_float real",
-               "bool_should_be_boolean bool",
-               "interval_should_be_string interval",
-               "bigint_should_be_integer bigint"
-              ]
+      "bigint_serial_should_be_integer bigint default nextval('seq_pk_customers')",
+      "integer_serial_should_be_integer integer default nextval('seq_pk_customers')",
+      "varchar_should_be_string varchar(2)",
+      "timestamp_should_be_datetime timestamp",
+      "bytea_should_be_binary bytea",
+      "double_precision_should_be_float double precision",
+      "real_should_be_float real",
+      "bool_should_be_boolean bool",
+      "interval_should_be_string interval",
+      "bigint_should_be_integer bigint"
+    ]
     columns << "uuid_should_be_string uuid" if PG_VERSION >= 80300
     table_sql = %Q{
       CREATE TABLE customers (

data/test/postgres_nonseq_pkey_test.rb

@@ -1,4 +1,5 @@
 require 'jdbc_common'
+require 'db/postgres'
 
 class CreateUrls < ActiveRecord::Migration
   def self.up

data/test/postgres_reserved_test.rb

@@ -1,4 +1,5 @@
 require 'jdbc_common'
+require 'db/postgres'
 require 'models/reserved_word'
 
 class PostgresReservedWordsTest < Test::Unit::TestCase

data/test/postgres_reset_column_information_test.rb

@@ -1,4 +1,5 @@
 require 'jdbc_common'
+require 'db/postgres'
 
 class PostgresResetColumnInformationTest < Test::Unit::TestCase
   include ResetColumnInformationTestMethods

data/test/postgres_row_locking_test.rb

@@ -0,0 +1,21 @@
+require 'jdbc_common'
+require 'db/postgres'
+require 'row_locking'
+
+class PostgresRowLockingTest < Test::Unit::TestCase
+  include MigrationSetup
+  include RowLockingTestMethods
+  
+  def self.startup
+    MigrationSetup.setup!
+  end
+  
+  def setup!; nil; end
+
+  def self.shutdown
+    MigrationSetup.teardown!
+  end
+  
+  def teardown!; nil; end
+  
+end

data/test/postgres_schema_dump_test.rb

@@ -0,0 +1,88 @@
+require 'db/postgres'
+require 'schema_dump'
+
+class PostgresSchemaDumpTest < Test::Unit::TestCase
+  include SchemaDumpTestMethods
+  
+  def self.startup
+    super
+    MigrationSetup.setup!
+  end
+  
+  def self.shutdown
+    MigrationSetup.teardown!
+    super
+  end
+
+  def setup!; end # MigrationSetup#setup!
+  def teardown!; end # MigrationSetup#teardown!
+  
+  def test_schema_dump_includes_xml_shorthand_definition
+    output = standard_dump
+    if %r{create_table "postgresql_xml_data_type"} =~ output
+      assert_match %r{t.xml "data"}, output
+    end
+  end
+
+  def test_schema_dump_includes_tsvector_shorthand_definition
+    output = standard_dump
+    if %r{create_table "postgresql_tsvectors"} =~ output
+      assert_match %r{t.tsvector "text_vector"}, output
+    end
+  end
+  
+  #
+
+  # http://kenai.com/jira/browse/ACTIVERECORD_JDBC-135
+  def test_schema_dump_should_not_have_limits_on_boolean
+    dump = dump_with_data_types
+    lines = dump.lines.grep(/boolean/)
+    assert ! lines.empty?, "no boolean type definition found in: #{dump}"
+    lines.each {|line| assert line !~ /limit/ }
+  end
+
+  def test_schema_dump_should_not_have_limits_on_binaries
+    dump = dump_with_data_types
+    lines = dump.lines.grep(/binary/)
+    assert ! lines.empty?, "no binary type definitions found in: #{dump}"
+    lines.each {|line| assert line !~ /limit/, 'binary definition contains limit' }
+  end
+
+  # http://kenai.com/jira/browse/ACTIVERECORD_JDBC-139
+  def test_schema_dump_should_not_have_limits_on_text_or_date
+    dump = dump_with_data_types
+    lines = dump.lines.grep(/date|text/)
+    assert ! lines.empty?
+    lines.each {|line| assert line !~ /limit/ }
+  end
+
+  def test_schema_dump_integer_with_no_limit_should_have_no_limit
+    dump = dump_with_data_types
+    lines = dump.lines.grep(/sample_integer_no_limit/)
+    assert ! lines.empty?
+    lines.each {|line| assert line !~ /:limit/ }
+  end
+
+  def test_schema_dump_integer_with_limit_2_should_have_limit_2
+    dump = dump_with_data_types
+    lines = dump.lines.grep(/sample_integer_with_limit_2/)
+    assert ! lines.empty?
+    lines.each {|line| assert line =~ /limit => 2/ }
+  end
+
+  def test_schema_dump_integer_with_limit_8_should_have_limit_8
+    dump = dump_with_data_types
+    lines = dump.lines.grep(/sample_integer_with_limit_8/)
+    assert ! lines.empty?
+    lines.each {|line| assert line =~ /limit => 8/ }
+  end
+  
+  private
+  
+  def dump_with_data_types(io = StringIO.new)
+    ActiveRecord::SchemaDumper.ignore_tables = [/^[^d]/] # keep data_types
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, io)
+    io.string
+  end
+  
+end

data/test/postgres_schema_search_path_test.rb

@@ -1,4 +1,5 @@
 require 'jdbc_common'
+require 'db/postgres'
 
 class CreateSchema < ActiveRecord::Migration
   def self.up

data/test/postgres_simple_test.rb

@@ -5,69 +5,77 @@
 #
 
 require 'jdbc_common'
+require 'db/postgres'
 
 class PostgresSimpleTest < Test::Unit::TestCase
   include SimpleTestMethods
   include ActiveRecord3TestMethods
   include ColumnNameQuotingTests
+  include XmlColumnTests
 
   def test_adapter_class_name_equals_native_adapter_class_name
-    classname = @connection.class.name[/[^:]*$/]
+    classname = connection.class.name[/[^:]*$/]
     assert_equal 'PostgreSQLAdapter', classname
   end
 
   def test_schema_search_path
-    assert_equal @connection.schema_search_path, "\"$user\",public"
+    assert_equal connection.schema_search_path, "\"$user\",public"
   end
 
   def test_current_schema
-    assert_equal @connection.current_schema, "public"
+    assert_equal connection.current_schema, "public"
   end
 
   def test_encoding
-    assert_not_nil @connection.encoding
+    assert_not_nil connection.encoding
   end
 
   def test_multi_statement_support
-    results = @connection.execute "SELECT title from entries; SELECT login from users"
+    results = connection.execute "SELECT title from entries; SELECT login from users"
     assert_equal 2, results.length
     assert_equal ["title"], results[0].first.keys
     assert_equal ["login"], results[1].first.keys
   end
 
+  def test_find_by_sql_WITH_statement
+    user = User.create! :login => 'ferko'
+    Entry.create! :title => 'aaa', :user_id => user.id
+    entries = Entry.find_by_sql '' + 
+      '( ' + 
+      'WITH EntryAndUser (title, login, updated_on) AS ' +
+      ' ( ' +
+      ' SELECT e.title, u.login, e.updated_on ' + 
+      ' FROM entries e INNER JOIN users u ON e.user_id = u.id ' +
+      ' ) ' +
+      'SELECT * FROM EntryAndUser ORDER BY title ASC ' +
+      ') '
+    assert entries.first
+    assert entries.first.title
+    assert entries.first.login
+  end
+  
   def test_create_xml_column
     return unless PG_VERSION >= 80300
-    assert_nothing_raised do
-      @connection.create_table :xml_testings do |t|
-        t.column :xml_test, :xml
-      end
-    end
-
-    xml_test = @connection.columns(:xml_testings).detect do
-      |c| c.name == "xml_test"
-    end
-
-    assert_equal "xml", xml_test.sql_type
-  ensure
-    @connection.drop_table :xml_testings rescue nil
-  end
-
+    super
+  end if ar_version('3.1')
+  def xml_sql_type; 'xml'; end
+  
   def test_create_table_with_limits
     assert_nothing_raised do
-      @connection.create_table :testings do |t|
+      connection.create_table :testings do |t|
         t.column :eleven_int, :integer, :limit => 11
       end
     end
 
-    columns = @connection.columns(:testings)
+    columns = connection.columns(:testings)
     eleven = columns.detect { |c| c.name == "eleven_int" }
     assert_equal "integer", eleven.sql_type
   ensure
-    @connection.drop_table :testings rescue nil
+    connection.drop_table :testings rescue nil
   end
 
   def test_supports_standard_conforming_string
-    assert([true, false].include?(@connection.supports_standard_conforming_strings?))
+    assert([true, false].include?(connection.supports_standard_conforming_strings?))
   end
 
   def test_standard_conforming_string_default_set_on_new_connections
@@ -76,34 +84,38 @@ class PostgresSimpleTest < Test::Unit::TestCase
   end
 
   def test_default_standard_conforming_string
-    if @connection.supports_standard_conforming_strings?
-      assert_equal true, @connection.standard_conforming_strings?
+    if connection.supports_standard_conforming_strings?
+      assert_equal true, connection.standard_conforming_strings?
     else
-      assert_equal false, @connection.standard_conforming_strings?
+      assert_equal false, connection.standard_conforming_strings?
     end
   end
 
   def test_string_quoting_with_standard_conforming_strings
-    if @connection.supports_standard_conforming_strings?
+    if connection.supports_standard_conforming_strings?
       s = "\\m it's \\M"
-      assert_equal "'\\m it''s \\M'", @connection.quote(s)
+      assert_equal "'\\m it''s \\M'", connection.quote(s)
     end
   end
 
   def test_string_quoting_without_standard_conforming_strings
-    @connection.standard_conforming_strings = false
+    connection.standard_conforming_strings = false
     s = "\\m it's \\M"
-    assert_equal "'\\\\m it''s \\\\M'", @connection.quote(s)
-    @connection.standard_conforming_strings = true
+    assert_equal "'\\\\m it''s \\\\M'", connection.quote(s)
+    connection.standard_conforming_strings = true
   end
+  
+  include ExplainSupportTestMethods if ar_version("3.1")
+  
 end
 
 class PostgresTimestampTest < Test::Unit::TestCase
-  def setup
+  
+  def self.startup
     DbTypeMigration.up
   end
 
-  def teardown
+  def self.shutdown
     DbTypeMigration.down
   end
 
@@ -128,19 +140,29 @@ class PostgresTimestampTest < Test::Unit::TestCase
 
   def test_save_infinity_and_beyond
     d = DbType.create!(:sample_timestamp => 1.0 / 0.0)
-    assert_equal(1.0 / 0.0, d.sample_timestamp)
+    if ar_version('3.0')
+      assert_equal(1.0 / 0.0, d.sample_timestamp)
+    else # 2.3
+      assert_equal(nil, d.sample_timestamp)
+    end
 
     e = DbType.create!(:sample_timestamp => -1.0 / 0.0)
-    assert_equal(-1.0 / 0.0, e.sample_timestamp)
+    if ar_version('3.0')
+      assert_equal(-1.0 / 0.0, e.sample_timestamp)
+    else # 2.3
+      assert_equal(nil, e.sample_timestamp)
+    end
   end
+  
 end
 
 class PostgresDeserializationTest < Test::Unit::TestCase
-  def setup
+
+  def self.startup
     DbTypeMigration.up
   end
 
-  def teardown
+  def self.shutdown
     DbTypeMigration.down
   end
 
@@ -152,55 +174,6 @@ class PostgresDeserializationTest < Test::Unit::TestCase
   end
 end
 
-class PostgresSchemaDumperTest < Test::Unit::TestCase
-  def setup
-    DbTypeMigration.up
-    @connection = ActiveRecord::Base.connection
-    strio = StringIO.new
-    ActiveRecord::SchemaDumper::dump(ActiveRecord::Base.connection, strio)
-    @dump = strio.string
-  end
-
-  def teardown
-    DbTypeMigration.down
-  end
-
-  # http://kenai.com/jira/browse/ACTIVERECORD_JDBC-135
-  def test_schema_dump_should_not_have_limits_on_boolean
-    lines = @dump.lines.grep(/boolean/)
-    assert !lines.empty?
-    lines.each {|line| assert line !~ /limit/ }
-  end
-
-
-  def test_schema_dump_should_not_have_limits_on_binaries
-    lines = @dump.lines.grep(/binary/)
-    assert !lines.empty?, 'no binary type definitions found'
-    lines.each {|line| assert line !~ /limit/, 'binary definition contains limit' }
-  end
-
-  # http://kenai.com/jira/browse/ACTIVERECORD_JDBC-139
-  def test_schema_dump_should_not_have_limits_on_text_or_date
-    lines = @dump.lines.grep(/date|text/)
-    assert !lines.empty?
-    lines.each {|line| assert line !~ /limit/ }
-  end
-
-  def test_schema_dump_integer_with_no_limit_should_have_no_limit
-    lines = @dump.lines.grep(/sample_integer_no_limit/)
-    assert !lines.empty?
-    lines.each {|line| assert line !~ /:limit/ }
-  end
-
-  def test_schema_dump_integer_with_limit_2_should_have_limit_2
-    lines = @dump.lines.grep(/sample_integer_with_limit_2/)
-    assert !lines.empty?
-    lines.each {|line| assert line =~ /limit => 2/ }
-  end
-
-  def test_schema_dump_integer_with_limit_8_should_have_limit_8
-    lines = @dump.lines.grep(/sample_integer_with_limit_8/)
-    assert !lines.empty?
-    lines.each {|line| assert line =~ /limit => 8/ }
-  end
+class PostgresHasManyThroughTest < Test::Unit::TestCase
+  include HasManyThroughMethods
 end