sequel 4.49.0 → 5.3.0

data/spec/integration/prepared_statement_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Prepared Statements and Bound Arguments" do
   before do
@@ -332,27 +332,27 @@ describe "Bound Argument Types" do
     @db.drop_table?(:items)
   end
 
-  cspecify "should handle date type", [:do, :sqlite], [:tinytds], [:jdbc, :mssql], [:jdbc, :sqlite], :oracle do 
+  cspecify "should handle date type", [:tinytds], [:jdbc, :mssql], [:jdbc, :sqlite], :oracle do 
     @ds.filter(:d=>:$x).prepare(:first, :ps_date).call(:x=>@vs[:d])[:d].must_equal @vs[:d]
   end
 
-  cspecify "should handle datetime type", [:do], [:mysql2], [:jdbc, :sqlite], [:tinytds], [:oracle] do
+  cspecify "should handle datetime type", [:mysql2], [:jdbc, :sqlite], [:tinytds], [:oracle] do
     Sequel.datetime_class = DateTime
     @ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>@vs[:dt])[:dt].must_equal @vs[:dt]
   end
 
-  cspecify "should handle datetime type with fractional seconds", [:do, :postgres], [:jdbc, :sqlite], [:oracle] do
+  cspecify "should handle datetime type with fractional seconds", [:jdbc, :sqlite], [:jdbc, :mysql], [:oracle] do
     Sequel.datetime_class = DateTime
     fract_time = DateTime.parse('2010-10-12 13:14:15.500000')
     @ds.prepare(:update, :ps_datetime_up, :dt=>:$x).call(:x=>fract_time)
     @ds.literal(@ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>fract_time)[:dt]).must_equal @ds.literal(fract_time)
   end
 
-  cspecify "should handle time type", [:do], [:jdbc, :sqlite], [:swift], [:oracle] do
+  cspecify "should handle time type", [:jdbc, :sqlite] do
     @ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>@vs[:t])[:t].must_equal @vs[:t]
   end
 
-  cspecify "should handle time type with fractional seconds", [:do, :postgres], [:jdbc, :sqlite], [:oracle], [:swift, :postgres] do
+  cspecify "should handle time type with fractional seconds", [:jdbc, :sqlite], [:jdbc, :mysql] do
     fract_time = @vs[:t] + 0.5
     @ds.prepare(:update, :ps_time_up, :t=>:$x).call(:x=>fract_time)
     @ds.literal(@ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>fract_time)[:t]).must_equal @ds.literal(fract_time)
@@ -384,7 +384,7 @@ describe "Bound Argument Types" do
     @ds.get(:file).must_equal zero_blob
   end
 
-  cspecify "should handle float type", [:swift, :sqlite] do
+  it "should handle float type" do
     @ds.filter(:f=>:$x).prepare(:first, :ps_float).call(:x=>@vs[:f])[:f].must_equal @vs[:f]
   end
 
@@ -392,87 +392,7 @@ describe "Bound Argument Types" do
     @ds.filter(:s=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:s])[:s].must_equal @vs[:s]
   end
 
-  cspecify "should handle boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
+  cspecify "should handle boolean type", [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     @ds.filter(:b=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:b])[:b].must_equal @vs[:b]
   end
 end
-
-describe "Dataset#unbind" do
-  before do
-    deprecated do
-      @ds = ds = DB[:items]
-      @ct = proc do |t, v|
-        DB.create_table!(:items) do
-          column :c, t
-        end
-        ds.insert(:c=>v)
-      end
-      @u = proc{|ds1| ds2, bv = ds1.unbind; ds2.call(:first, bv)}
-    end
-  end
-  after do
-    DB.drop_table?(:items)
-  end
-  
-  deprecated "should unbind values assigned to equality and inequality statements" do
-    @ct[Integer, 10]
-    @u[@ds.filter(:c=>10)].must_equal(:c=>10)
-    @u[@ds.exclude(:c=>10)].must_be_nil
-    @u[@ds.filter{c < 10}].must_be_nil
-    @u[@ds.filter{c <= 10}].must_equal(:c=>10)
-    @u[@ds.filter{c > 10}].must_be_nil
-    @u[@ds.filter{c >= 10}].must_equal(:c=>10)
-  end
-
-  cspecify "should handle numerics and strings", [:odbc], [:swift, :sqlite] do
-    deprecated do
-      @ct[Integer, 10]
-      @u[@ds.filter(:c=>10)].must_equal(:c=>10)
-      @ct[Float, 0.0]
-      @u[@ds.filter{c < 1}].must_equal(:c=>0.0)
-      @ct[String, 'foo']
-      @u[@ds.filter(:c=>'foo')].must_equal(:c=>'foo')
-
-      DB.create_table!(:items) do
-        BigDecimal :c, :size=>[15,2]
-      end
-      @ds.insert(:c=>BigDecimal.new('1.1'))
-      @u[@ds.filter{c > 0}].must_equal(:c=>BigDecimal.new('1.1'))
-    end
-  end
-
-  cspecify "should handle dates and times", [:do], [:jdbc, :mssql], [:jdbc, :sqlite], [:swift], [:tinytds], :oracle do
-    deprecated do
-      @ct[Date, Date.today]
-      @u[@ds.filter(:c=>Date.today)].must_equal(:c=>Date.today)
-      t = Time.now
-      @ct[Time, t]
-      @u[@ds.filter{c < t + 1}][:c].to_i.must_equal t.to_i
-    end
-  end
-
-  deprecated "should handle QualifiedIdentifiers" do
-    @ct[Integer, 10]
-    @u[@ds.filter{items[:c] > 1}].must_equal(:c=>10)
-  end
-
-  cspecify "should handle deep nesting", :h2 do
-    deprecated do
-      DB.create_table!(:items) do
-        Integer :a
-        Integer :b
-        Integer :c
-        Integer :d
-      end
-      @ds.insert(:a=>2, :b=>0, :c=>3, :d=>5)
-      @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>4)=>1}, 0) => 1)].must_equal(:a=>2, :b=>0, :c=>3, :d=>5)
-      @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>5)=>1}, 0) => 1)].must_be_nil
-    end
-  end
-
-  deprecated "should handle case where the same variable has the same value in multiple places " do
-    @ct[Integer, 1]
-    @u[@ds.filter{c > 1}.or{c < 1}.invert].must_equal(:c=>1)
-    @u[@ds.filter{c > 1}.or{c < 1}].must_be_nil
-  end
-end    

data/spec/integration/schema_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Database schema parser" do
   after do
@@ -129,7 +129,7 @@ describe "Database schema parser" do
     DB.schema(:items).first.last[:ruby_default].must_equal Sequel::CURRENT_TIMESTAMP
   end
 
-  cspecify "should parse current date defaults from the schema properly", :mysql, :oracle do
+  cspecify "should parse current date defaults from the schema properly", [proc{|db| !db.mariadb? || db.server_version <= 100200}, :mysql], :oracle do
     DB.create_table!(:items){Date :a, :default=>Sequel::CURRENT_DATE}
     DB.schema(:items).first.last[:ruby_default].must_equal Sequel::CURRENT_DATE
   end
@@ -215,7 +215,7 @@ describe "Database index parsing" do
     DB.indexes(:items).must_equal({})
   end
 
-  it "should not include partial indexes" do
+  cspecify "should not include partial indexes", [proc{|db| db.sqlite_version < 30808}, :sqlite] do
     DB.create_table!(:items){Integer :n; Integer :a; index :n, :where=>proc{n > 10}}
     DB.indexes(:items).must_equal({})
   end if DB.supports_partial_indexes?
@@ -610,7 +610,7 @@ describe "Database schema modifiers" do
     @ds.all.must_equal [{:id2=>10}]
   end
 
-  cspecify "should set column NULL/NOT NULL correctly", [:jdbc, :db2], [:db2] do
+  cspecify "should set column NULL/NOT NULL correctly", [:jdbc, :db2] do
     @db.create_table!(:items, :engine=>:InnoDB){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_allow_null :id, false}
@@ -632,7 +632,7 @@ describe "Database schema modifiers" do
     @ds.all.must_equal [{:id=>10}, {:id=>20}]
   end
 
-  cspecify "should set column types correctly", [:jdbc, :db2], [:db2], :oracle do
+  cspecify "should set column types correctly", [:jdbc, :db2], :oracle do
     @db.create_table!(:items){Integer :id}
     @ds.insert(:id=>10)
     @db.alter_table(:items){set_column_type :id, String}
@@ -642,7 +642,7 @@ describe "Database schema modifiers" do
     @ds.order(:id).all.must_equal [{:id=>"10"}, {:id=>"20"}]
   end
 
-  cspecify "should set column types without modifying NULL/NOT NULL", [:jdbc, :db2], [:db2], :oracle, :derby do
+  cspecify "should set column types without modifying NULL/NOT NULL", [:jdbc, :db2], :derby do
     @db.create_table!(:items){Integer :id, :null=>false, :default=>2}
     proc{@ds.insert(:id=>nil)}.must_raise(Sequel::NotNullConstraintViolation, Sequel::ConstraintViolation, Sequel::DatabaseError)
     @db.alter_table(:items){set_column_type :id, String}
@@ -655,7 +655,7 @@ describe "Database schema modifiers" do
     @ds.map(:id).must_equal [nil, nil]
   end
 
-  cspecify "should set column types without modifying defaults", [:jdbc, :db2], [:db2], :oracle, :derby do
+  cspecify "should set column types without modifying defaults", [:jdbc, :db2], :oracle, :derby do
     @db.create_table!(:items){Integer :id, :default=>0}
     @ds.insert
     @ds.map(:id).must_equal [0]
@@ -760,19 +760,19 @@ describe "Database schema modifiers" do
     @db.schema(:items, :reload=>true).map{|x| x.first}.must_equal [:id]
   end
 
-  cspecify "should work correctly with many operations in a single alter_table call", [:jdbc, :db2], [:db2] do
+  cspecify "should work correctly with many operations in a single alter_table call", [:jdbc, :db2] do
     @db.create_table!(:items) do
       primary_key :id
       String :name2
       String :number2
-      constraint :bar, Sequel.~(:id=>nil)
+      constraint :bar, Sequel.~(:number2=>nil, :name2=>nil)
     end
     @ds.insert(:name2=>'A12')
     @db.alter_table(:items) do
       add_column :number, Integer
+      drop_constraint :bar
       drop_column :number2
       rename_column :name2, :name
-      drop_constraint :bar
       set_column_not_null :name
       set_column_default :name, 'A13'
       add_constraint :foo, Sequel.like(:name, 'A%')

data/spec/integration/spec_helper.rb

@@ -1,39 +1,33 @@
-require 'rubygems'
 require 'logger'
-require "#{File.dirname(File.dirname(__FILE__))}/sequel_warning.rb"
+require_relative "../sequel_warning"
 
 if ENV['COVERAGE']
-  require File.join(File.dirname(File.expand_path(__FILE__)), "../sequel_coverage")
+  require_relative "../sequel_coverage"
   SimpleCov.sequel_coverage(:group=>%r{lib/sequel/adapters})
 end
 
-unless Object.const_defined?('Sequel')
-  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel'
-end
+$:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
+require_relative "../../lib/sequel"
+
 begin
-  require File.join(File.dirname(File.dirname(__FILE__)), 'spec_config.rb') unless defined?(DB)
+  require_relative "../spec_config" unless defined?(DB)
 rescue LoadError
 end
 Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_(spec|test)\.rb/}
 
-Sequel.split_symbols = false if ENV['SEQUEL_NO_SPLIT_SYMBOLS']
+Sequel.split_symbols = true if ENV['SEQUEL_SPLIT_SYMBOLS']
 Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
 Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
 Sequel::Model.plugin :prepared_statements if ENV['SEQUEL_MODEL_PREPARED_STATEMENTS']
 Sequel::Model.use_transactions = false
 Sequel::Model.cache_anonymous_models = false
 
-require './spec/guards_helper'
+require_relative '../guards_helper'
 
-IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
+DB = Sequel.connect(ENV['SEQUEL_INTEGRATION_URL']) unless defined?(DB)
 
-unless defined?(DB)
-  # SEQUEL5: Remove :identifier_mangling=>false
-  DB = Sequel.connect(ENV['SEQUEL_INTEGRATION_URL'], :identifier_mangling=>false)
-  DB.extension(:freeze_datasets) if ENV['SEQUEL_FREEZE_DATASETS']
-  DB.extension(:identifier_mangling) if IDENTIFIER_MANGLING
-end
+IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
+DB.extension(:identifier_mangling) if IDENTIFIER_MANGLING
 
 if DB.adapter_scheme == :ibmdb || (DB.adapter_scheme == :ado && DB.database_type == :access)
   def DB.drop_table(*tables)
@@ -44,14 +38,14 @@ if DB.adapter_scheme == :ibmdb || (DB.adapter_scheme == :ado && DB.database_type
   end
 end
 
-if ENV['SEQUEL_NO_AUTO_LITERAL_STRINGS']
-  DB.extension :no_auto_literal_strings
-end
-
 if ENV['SEQUEL_ERROR_SQL']
   DB.extension :error_sql
 end
 
+if ENV['SEQUEL_SYNCHRONIZE_SQL']
+  DB.extension :synchronize_sql
+end
+
 if ENV['SEQUEL_CONNECTION_VALIDATOR']
   ENV['SEQUEL_NO_CHECK_SQLS'] = '1'
   DB.extension(:connection_validator)
@@ -68,3 +62,5 @@ if ENV['SEQUEL_FREEZE_DATABASE']
   DB.extension(:pg_array) if DB.database_type == :postgres
   DB.freeze
 end
+
+puts "running #{defined?(SEQUEL_ADAPTER_TEST) ? SEQUEL_ADAPTER_TEST : "integration (database type: #{DB.database_type})"} specs on #{RUBY_ENGINE} #{defined?(JRUBY_VERSION) ? JRUBY_VERSION : RUBY_VERSION} with #{DB.adapter_scheme} adapter"

data/spec/integration/timezone_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Sequel timezone support" do
   def _test_timezone(timezone=Sequel.application_timezone)
@@ -39,7 +39,7 @@ describe "Sequel timezone support" do
     @db.drop_table(:t)
   end
 
-  cspecify "should support using UTC for database storage and local time for the application", [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using UTC for database storage and local time for the application", [:tinytds], [:oracle] do
     Sequel.database_timezone = :utc
     Sequel.application_timezone = :local
     _test_timezone
@@ -48,7 +48,7 @@ describe "Sequel timezone support" do
     _test_timezone
   end
 
-  cspecify "should support using local time for database storage and UTC for the application", [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using local time for database storage and UTC for the application", [:tinytds], [:oracle] do
     Sequel.database_timezone = :local
     Sequel.application_timezone = :utc
     _test_timezone
@@ -57,7 +57,7 @@ describe "Sequel timezone support" do
     _test_timezone
   end
 
-  cspecify "should support using UTC for both database storage and for application", [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using UTC for both database storage and for application", [:oracle] do
     Sequel.default_timezone = :utc
     _test_timezone
     Sequel.database_timezone = :local
@@ -65,7 +65,7 @@ describe "Sequel timezone support" do
     _test_timezone
   end
 
-  cspecify "should support using local time for both database storage and for application", [:do, :postgres], [:oracle] do
+  cspecify "should support using local time for both database storage and for application", [:oracle] do
     Sequel.default_timezone = :local
     _test_timezone
     Sequel.database_timezone = :utc

data/spec/integration/transaction_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Database transactions" do
   before(:all) do
@@ -192,7 +192,6 @@ describe "Database transactions" do
       c = Class.new(Sequel::Model(@d))
       c.set_primary_key :name
       c.unrestrict_primary_key
-      c.use_after_commit_rollback = false
       @db.transaction(:prepare=>'XYZ'){c.create(:name => '1'); c.create(:name => '2').destroy}
       @db.commit_prepared_transaction('XYZ')
       @d.select_order_map(:name).must_equal ['1']
@@ -315,57 +314,6 @@ describe "Database transactions" do
   end
 end
 
-if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby') and RUBY_VERSION < '1.9'
-  describe "Database transactions and Thread#kill" do
-    before do
-      @db = DB
-      @db.create_table!(:items, :engine=>'InnoDB'){String :name; Integer :value}
-      @d = @db[:items]
-    end
-    after do
-      @db.drop_table?(:items)
-    end
-
-    it "should handle transactions inside threads" do
-      q = Queue.new
-      q1 = Queue.new
-      t = Thread.new do
-        @db.transaction do
-          @d.insert(:name => 'abc', :value => 1)
-          q1.push nil
-          q.pop
-          @d.insert(:name => 'def', :value => 2)
-        end
-      end
-      q1.pop
-      t.kill
-      @d.count.must_equal 0
-    end
-
-    if DB.supports_savepoints?
-      it "should handle transactions with savepoints inside threads" do
-        q = Queue.new
-        q1 = Queue.new
-        t = Thread.new do
-          @db.transaction do
-            @d.insert(:name => 'abc', :value => 1)
-            @db.transaction(:savepoint=>true) do
-              @d.insert(:name => 'def', :value => 2)
-              q1.push nil
-              q.pop
-              @d.insert(:name => 'ghi', :value => 3)
-            end
-            @d.insert(:name => 'jkl', :value => 4)
-          end
-        end
-        q1.pop
-        t.kill
-        @d.count.must_equal 0
-      end
-    end
-  end
-end
-
 describe "Database transaction retrying" do
   before(:all) do
     @db = DB
@@ -379,7 +327,7 @@ describe "Database transaction retrying" do
     @db.drop_table?(:items)
   end
 
-  cspecify "should be supported using the :retry_on option", [:db2] do
+  it "should be supported using the :retry_on option" do
     @d.insert('b')
     @d.insert('c')
     s = 'a'
@@ -390,7 +338,7 @@ describe "Database transaction retrying" do
     @d.select_order_map(:a).must_equal %w'b c d'
   end
 
-  cspecify "should limit number of retries via the :num_retries option", [:db2] do
+  it "should limit number of retries via the :num_retries option" do
     @d.insert('b')
     @d.insert('c')
     s = 'a'

data/spec/integration/type_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Supported types" do
   def create_items_table_with_column(name, type, opts={})
@@ -37,13 +37,13 @@ describe "Supported types" do
     ds.all.must_equal [{:number=>2**34}]
   end
   
-  cspecify "should support generic float type", [:swift, :sqlite] do
+  it "should support generic float type" do
     ds = create_items_table_with_column(:number, Float)
     ds.insert(:number => 2.1)
     ds.all.must_equal [{:number=>2.1}]
   end
   
-  cspecify "should support generic numeric type", [:odbc, :mssql], [:swift, :sqlite] do
+  cspecify "should support generic numeric type", [:odbc, :mssql] do
     ds = create_items_table_with_column(:number, Numeric, :size=>[15, 10])
     ds.insert(:number => BigDecimal.new('2.123456789'))
     ds.all.must_equal [{:number=>BigDecimal.new('2.123456789')}]
@@ -67,7 +67,7 @@ describe "Supported types" do
     ds.all.must_equal [{:name=>'Test User'*100}]
   end
   
-  cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], [:tinytds], [:jdbc, :mssql], :oracle do
+  cspecify "should support generic date type", [:jdbc, :sqlite], [:tinytds], [:jdbc, :mssql], :oracle do
     ds = create_items_table_with_column(:dat, Date)
     d = Date.today
     ds.insert(:dat => d)
@@ -75,7 +75,7 @@ describe "Supported types" do
     ds.first[:dat].to_s.must_equal d.to_s
   end
   
-  cspecify "should support generic time type", [:do], [:swift], [:odbc], [:jdbc, :mssql], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle, [:ado] do
+  cspecify "should support generic time type", [:odbc], [:jdbc, :mssql], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle, [:ado] do
     ds = create_items_table_with_column(:tim, Time, :only_time=>true)
     t = Sequel::SQLTime.now
     ds.insert(:tim => t)
@@ -89,7 +89,7 @@ describe "Supported types" do
     v2.must_be_kind_of(Sequel::SQLTime)
   end
   
-  cspecify "should support generic datetime type", [:do, :sqlite], [:jdbc, :sqlite] do
+  cspecify "should support generic datetime type", [:jdbc, :sqlite] do
     ds = create_items_table_with_column(:tim, DateTime)
     t = DateTime.now
     ds.insert(:tim => t)
@@ -100,14 +100,14 @@ describe "Supported types" do
     ds.first[:tim].strftime('%Y%m%d%H%M%S').must_equal t.strftime('%Y%m%d%H%M%S')
   end
   
-  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:tinytds] do
+  cspecify "should support generic file type", [:odbc, :mssql], [:mysql2], [:tinytds] do
     ds = create_items_table_with_column(:name, File)
     ds.insert(:name =>Sequel.blob("a\0"*300))
     ds.all.must_equal [{:name=>Sequel.blob("a\0"*300)}]
     ds.first[:name].must_be_kind_of(::Sequel::SQL::Blob)
   end
   
-  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
+  cspecify "should support generic boolean type", [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     ds = create_items_table_with_column(:number, TrueClass)
     ds.insert(:number => true)
     ds.all.must_equal [{:number=>true}]
@@ -116,7 +116,7 @@ describe "Supported types" do
     ds.all.must_equal [{:number=>true}]
   end
   
-  cspecify "should support generic boolean type with defaults", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
+  cspecify "should support generic boolean type with defaults", [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     ds = create_items_table_with_column(:number, TrueClass, :default=>true)
     ds.insert
     ds.all.must_equal [{:number=>true}]

data/spec/model/association_reflection_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe Sequel::Model::Associations::AssociationReflection, "#associated_class" do
   before do
@@ -15,14 +15,34 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_class"
     @c.association_reflection(:c).associated_class.must_equal ParParent
   end
 
+  it "should use the :class value if present" do
+    @c.many_to_one :c, :class=>@c
+    @c.one_to_many :cs, :class=>@c
+    c = @c.association_reflection(:c)
+    cs = @c.association_reflection(:cs)
+
+    c.association_method.must_equal :c
+    c.dataset_method.must_equal :c_dataset
+    c.setter_method.must_equal :c=
+    c._setter_method.must_equal :_c=
+
+    cs.association_method.must_equal :cs
+    cs.dataset_method.must_equal :cs_dataset
+    cs.add_method.must_equal :add_c
+    cs._add_method.must_equal :_add_c
+    cs.remove_method.must_equal :remove_c
+    cs._remove_method.must_equal :_remove_c
+    cs.remove_all_method.must_equal :remove_all_cs
+    cs._remove_all_method.must_equal :_remove_all_cs
+  end
+
   it "should have inspect include association class and representation of association definition " do
     ParParent.many_to_one :c
     ParParent.association_reflection(:c).inspect.must_equal "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c>"
     ParParent.many_to_one :c, :class=>ParParent
     ParParent.association_reflection(:c).inspect.must_equal "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :class=>ParParent>"
     ParParent.many_to_one :c, :class=>ParParent, :key=>:c_id
-    ["#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :key=>:c_id, :class=>ParParent>",
-     "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :class=>ParParent, :key=>:c_id>"].must_include ParParent.association_reflection(:c).inspect
+    ParParent.association_reflection(:c).inspect.must_equal "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :key=>:c_id, :class=>ParParent>"
 
     @c.one_to_many :foos do |ds| ds end
     @c.association_reflection(:foos).inspect.must_equal "#<Sequel::Model::Associations::OneToManyAssociationReflection #{@c.to_s}.one_to_many :foos, :block=>#{@c.association_reflection(:foos)[:block].inspect}>"
@@ -286,11 +306,6 @@ describe Sequel::Model::Associations::AssociationReflection do
     def @c.name() "C" end
   end
 
-  deprecated "#eager_loading_predicate_key should be an alias of predicate_key for backwards compatibility" do
-    @c.one_to_many :cs, :class=>@c
-    @c.dataset.literal(@c.association_reflection(:cs).eager_loading_predicate_key).must_equal 'foo.c_id'
-  end
-
   it "one_to_many #qualified_primary_key should be a qualified version of the primary key" do
     @c.one_to_many :cs, :class=>@c
     @c.dataset.literal(@c.association_reflection(:cs).qualified_primary_key).must_equal 'foo.id'
@@ -516,7 +531,7 @@ describe Sequel::Model, " association reflection methods" do
     c.associate :many_to_one, :parent2, :class => @c1
     @c1.associations.must_equal [:parent]
     c.associations.sort_by{|x| x.to_s}.must_equal [:parent, :parent2]
-    c.instance_methods.map{|x| x.to_s}.must_include('parent')
+    c.instance_methods.must_include(:parent)
   end
 end