activerecord-jdbc-adapter 1.2.9.1 → 1.3.0.beta1

data/lib/arjdbc/jdbc/compatibility.rb

@@ -1,51 +0,0 @@
-# AR's 2.2 version of this method is sufficient, but we need it for
-# older versions
-if ActiveRecord::VERSION::MAJOR <= 2 && ActiveRecord::VERSION::MINOR < 2
-  module ActiveRecord
-    module ConnectionAdapters # :nodoc:
-      module SchemaStatements
-        # Convert the speficied column type to a SQL string.
-        def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-          if native = native_database_types[type]
-            column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup
-
-            if type == :decimal # ignore limit, use precision and scale
-              scale ||= native[:scale]
-
-              if precision ||= native[:precision]
-                if scale
-                  column_type_sql << "(#{precision},#{scale})"
-                else
-                  column_type_sql << "(#{precision})"
-                end
-              elsif scale
-                raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified"
-              end
-
-            elsif limit ||= native.is_a?(Hash) && native[:limit]
-              column_type_sql << "(#{limit})"
-            end
-
-            column_type_sql
-          else
-            type
-          end
-        end
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    module CompatibilityMethods
-      def self.needed?(base)
-        !base.instance_methods.include?("quote_table_name")
-      end
-
-      def quote_table_name(name)
-        quote_column_name(name)
-      end
-    end
-  end
-end

data/lib/arjdbc/jdbc/core_ext.rb

@@ -1,24 +0,0 @@
-module ActiveRecord # :nodoc:
-  # Represents exceptions that have propagated up through the JDBC API.
-  class JDBCError < ActiveRecordError
-    # The vendor code or error number that came from the database
-    attr_accessor :errno
-
-    # The full Java SQLException object that was raised
-    attr_accessor :sql_exception
-  end
-
-  module ConnectionAdapters # :nodoc:
-    # Allows properly re-wrapping/re-defining methods that may already
-    # be alias_method_chain'd.
-    module ShadowCoreMethods
-      def alias_chained_method(meth, feature, target)
-        if instance_methods.include?("#{meth}_without_#{feature}")
-          alias_method "#{meth}_without_#{feature}".to_sym, target
-        else
-          alias_method meth, target if meth != target
-        end
-      end
-    end
-  end
-end

data/lib/arjdbc/jdbc/discover.rb

@@ -1,18 +0,0 @@
-module ArJdbc
-  def self.discover_extensions
-    if defined?(::Gem) && ::Gem.respond_to?(:find_files)
-      files = ::Gem.find_files('arjdbc/discover')
-    else
-      files = $LOAD_PATH.map do |p|
-        discover = File.join(p, 'arjdbc', 'discover.rb')
-        File.exist?(discover) ? discover : nil
-      end.compact
-    end
-    files.each do |f|
-      puts "Loading #{f}" if $DEBUG
-      require f
-    end
-  end
-
-  discover_extensions
-end

data/test/derby_schema_dump_test.rb

@@ -1,9 +0,0 @@
-require 'db/derby'
-require 'schema_dump'
-
-class DerbySchemaDumpTest < Test::Unit::TestCase
-  include SchemaDumpTestMethods
-  
-  DbTypeMigration.big_decimal_precision = 31 # DECIMAL precision between 1 and 31
-  
-end

data/test/mssql_ignore_system_views_test.rb

@@ -1,30 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-class MSSQLIgnoreSystemViewsTest < Test::Unit::TestCase
-  include MigrationSetup
-
-  def test_system_views_ignored
-    if ActiveRecord::Base.connection.sqlserver_version == "2000"
-      assert_equal false, table_exists?("sys.views"), %{table_exists?("sys.views")}
-      assert_equal false, table_exists?("information_schema.views"), %{table_exists?("information_schema.views")}
-    else
-      assert_equal true, table_exists?("sys.views"), %{table_exists?("sys.views")}
-      assert_equal true, table_exists?("information_schema.views"), %{table_exists?("information_schema.views")}
-    end
-    assert_equal false, table_exists?("dbo.views"), %{table_exists?("dbo.views")}
-    assert_equal false, table_exists?(:views), %{table_exists?(:views)}
-    ActiveRecord::Schema.define { suppress_messages { create_table :views } }
-    assert_equal true, table_exists?(:views), %{table_exists?(:views)}
-    ActiveRecord::Schema.define { suppress_messages { drop_table :views } }
-    assert_equal false, table_exists?(:views), %{table_exists?(:views)}
-  end
-
-  private
-
-  def table_exists?(*args)
-    ActiveRecord::Base.connection.table_exists?(*args)
-  end
-    
-end
-

data/test/mssql_legacy_types_test.rb

@@ -1,58 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-ActiveRecord::Schema.verbose = false
-
-class CreateArticles < ActiveRecord::Migration
-
-  def self.up
-    execute <<-SQL
-      CREATE TABLE articles (
-        [id] int NOT NULL IDENTITY(1, 1) PRIMARY KEY, 
-        [title] VARCHAR(100), 
-        [author] VARCHAR(60) DEFAULT 'anonymous', 
-        [body] TEXT
-      )
-    SQL
-  end
-
-  def self.down
-    drop_table "articles"
-  end
-
-end
-
-class Article < ActiveRecord::Base
-end
-
-class MsSQLLegacyTypesTest < Test::Unit::TestCase
-
-  def setup
-    CreateArticles.up
-    ActiveRecord::Base.connection
-  end
-
-  def teardown
-    CreateArticles.down
-    ActiveRecord::Base.clear_active_connections!
-  end
-
-  def test_varchar_column
-    Article.create!(:title => "Blah blah")
-    article = Article.first
-    assert_equal("Blah blah", article.title)
-  end
-  
-  SAMPLE_TEXT = "Lorem ipsum dolor sit amet ..."
-  
-  def test_text_column
-    Article.create!(:body => SAMPLE_TEXT)
-    article = Article.first
-    assert_equal(SAMPLE_TEXT, article.body)
-  end
-  
-  def test_varchar_default_value
-    assert_equal("anonymous", Article.new.author)
-  end
-  
-end

data/test/mssql_null_test.rb

@@ -1,14 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-class MsSQLNullTest < Test::Unit::TestCase
-  include MigrationSetup
-
-  [nil, "NULL", "null", "(null)", "(NULL)"].each_with_index do |v, i|
-    define_method "test_null_#{i}" do
-      entry = Entry.create!(:title => v, :content => v)
-      entry = Entry.find(entry.id)
-      assert_equal [v, v], [entry.title, entry.content], "writing #{v.inspect} should read back as #{v.inspect} for both string and text columns"
-    end
-  end
-end

data/test/mssql_simple_test.rb

@@ -1,51 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-class MSSQLSimpleTest < Test::Unit::TestCase
-  include SimpleTestMethods
-  include ActiveRecord3TestMethods
-  include DirtyAttributeTests
-
-  # MS SQL 2005 doesn't have a DATE class, only TIMESTAMP
-
-  # String comparisons are insensitive by default
-  undef_method :test_validates_uniqueness_of_strings_case_sensitive
-
-  def test_does_not_munge_quoted_strings
-    example_quoted_values = [%{'quoted'}, %{D\'oh!}]
-    example_quoted_values.each do |value|
-      entry = Entry.create!(:title => value)
-      entry.reload
-      assert_equal(value, entry.title)
-    end
-  end
-
-  def test_change_column_default
-    Entry.connection.change_column "entries", "title", :string, :default => "new default"
-    Entry.reset_column_information
-    assert_equal("new default", Entry.new.title)
-
-    Entry.connection.change_column "entries", "title", :string, :default => nil
-    Entry.reset_column_information
-    assert_equal(nil, Entry.new.title)
-  end
-
-  def test_change_column_nullability
-    Entry.connection.change_column "entries", "title", :string, :null => true
-    Entry.reset_column_information
-    title_column = Entry.columns.find { |c| c.name == "title" }
-    assert(title_column.null)
-
-    Entry.connection.change_column "entries", "title", :string, :null => false
-    Entry.reset_column_information
-    title_column = Entry.columns.find { |c| c.name == "title" }
-    assert(!title_column.null)
-  end
-
-  # ACTIVERECORD_JDBC-124
-  def test_model_does_not_have_row_num_column
-    entry = Entry.first
-    assert_false entry.attributes.keys.include?("_row_num")
-    assert_false entry.respond_to?(:_row_num)
-  end
-end

data/test/postgres_information_schema_leak_test.rb

@@ -1,28 +0,0 @@
-require 'jdbc_common'
-
-class CreateISLSchema < ActiveRecord::Migration
-  def self.up
-    execute "CREATE TABLE domains (id int, name varchar(16))"
-  end
-
-  def self.down
-    execute "DROP TABLE domains"
-  end
-end
-
-class Domain < ActiveRecord::Base
-end
-
-class PostgresInformationSchemaLeakTest < Test::Unit::TestCase
-  def setup
-    CreateISLSchema.up
-  end
-
-  def teardown
-    CreateISLSchema.down
-  end
-
-  def test_columns
-    assert_equal(%w{id name}, Domain.column_names)
-  end
-end  

data/test/postgres_native_type_mapping_test.rb

@@ -1,93 +0,0 @@
-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"
-    ]
-    columns << "uuid_should_be_string uuid" if PG_VERSION >= 80300
-    table_sql = %Q{
-      CREATE TABLE customers (
-        #{columns.join(",\n")}
-      )}
-    execute table_sql
-  end
-
-  def self.down
-    execute "DROP TABLE customers"
-    execute "DROP SEQUENCE IF EXISTS seq_pk_customers"
-  end
-end
-
-class Customer < ActiveRecord::Base
-end
-
-class PostgresNativeTypeMappingTest < Test::Unit::TestCase
-  def setup
-    CreateNativeTypeMappingTestSchema.up
-  end
-
-  def teardown
-    CreateNativeTypeMappingTestSchema.down
-  end
-
-  def column_type(column_name)
-    Customer.columns.detect { |c| c.name == column_name }.type
-  end
-
-  def test_uuid_column_should_map_to_string
-    assert_equal :string, column_type("uuid_should_be_string") if PG_VERSION >= 80300
-  end
-  
-  def test_bigint_serial_should_be_mapped_to_integer
-    assert_equal :integer, column_type("bigint_serial_should_be_integer")
-  end
-
-  def test_integer_serial_should_be_mapped_to_integer
-    assert_equal :integer, column_type("integer_serial_should_be_integer")
-  end
-
-  def test_varchar_should_be_mapped_to_string
-    assert_equal :string, column_type("varchar_should_be_string")
-  end
-
-  def test_timestamp_should_be_mapped_to_datetime
-    assert_equal :datetime, column_type("timestamp_should_be_datetime")
-  end
-
-  def test_bytea_should_be_mapped_to_binary
-    assert_equal :binary, column_type("bytea_should_be_binary")
-  end
-
-  def test_double_precision_should_be_mapped_to_float
-    assert_equal :float, column_type("double_precision_should_be_float")
-  end
-
-  def test_real_should_be_mapped_to_float
-    assert_equal :float, column_type("real_should_be_float")
-  end
-
-  def test_bool_should_be_mapped_to_boolean
-    assert_equal :boolean, column_type("bool_should_be_boolean")
-  end
-
-  def test_interval_should_be_mapped_to_string
-    assert_equal :string, column_type("interval_should_be_string")
-  end
-
-  def test_bigint_should_be_mapped_to_integer
-    assert_equal :integer, column_type("bigint_should_be_integer")
-  end
-end

data/test/postgres_nonseq_pkey_test.rb

@@ -1,38 +0,0 @@
-require 'jdbc_common'
-require 'db/postgres'
-
-class CreateUrls < ActiveRecord::Migration
-  def self.up
-    create_table 'urls', :id => false do |t|
-      t.text :uhash, :null => false
-      t.text :url,  :null => false
-    end
-    execute "ALTER TABLE urls ADD PRIMARY KEY (uhash)"
-  end
-  def self.down
-    drop_table 'urls'
-  end
-end
-
-class Url < ActiveRecord::Base
-  self.primary_key = :uhash
-  #Shouldn't be needed: set_sequence_name nil
-end
-
-class PostgresNonSeqPKey < Test::Unit::TestCase
-  def setup
-    CreateUrls.up
-  end
-
-  def teardown
-    CreateUrls.down
-  end
-
-  def test_create
-    url = Url.create! do |u|
-      u.uhash = 'uhash'
-      u.url = 'http://url'
-    end
-    assert_equal( 'uhash', url.uhash )
-  end
-end

data/test/postgres_schema_search_path_test.rb

@@ -1,48 +0,0 @@
-require 'jdbc_common'
-require 'db/postgres'
-
-class CreateSchema < ActiveRecord::Migration
-  def self.up
-    execute "CREATE SCHEMA test"
-    execute "CREATE TABLE test.people (id serial, name text)"
-    execute "INSERT INTO test.people (name) VALUES ('Alex')"
-    execute "CREATE TABLE public.people (id serial, wrongname text)"
-  end
-
-  def self.down
-    execute "DROP SCHEMA test CASCADE"
-    execute "DROP TABLE people"
-  end
-end
-
-class Person < ActiveRecord::Base
-  establish_connection POSTGRES_CONFIG.merge(:schema_search_path => 'test,public')
-end
-
-class PostgresSchemaSearchPathTest < Test::Unit::TestCase
-  def setup
-    CreateSchema.up
-  end
-
-  def teardown
-    CreateSchema.down
-  end
-
-  def test_columns
-    assert_equal(%w{id name}, Person.column_names)
-  end
-
-  def test_find_right
-    assert_not_nil Person.find_by_name("Alex")
-  end
-
-  def test_find_wrong
-    assert_raise NoMethodError do
-      Person.find_by_wrongname("Alex")
-    end
-  end
-  def test_column_information
-    assert Person.columns.map{|col| col.name}.include?("name")
-    assert !Person.columns.map{|col| col.name}.include?("wrongname")
-  end
-end