sequel 5.20.0 → 5.49.0

data/spec/extensions/dirty_spec.rb

@@ -1,189 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::Dirty" do
-  before do
-    @db = Sequel.mock(:fetch=>{:initial=>'i'.dup, :initial_changed=>'ic'.dup}, :numrows=>1)
-    @c = Class.new(Sequel::Model(@db[:c]))
-    @c.plugin :dirty
-    @c.columns :initial, :initial_changed, :missing, :missing_changed
-  end
-
-  dirty_plugin_specs = shared_description do
-    it "initial_value should be the current value if value has not changed" do
-      @o.initial_value(:initial).must_equal 'i'
-      @o.initial_value(:missing).must_be_nil
-    end
-
-    it "initial_value should be the intial value if value has changed" do
-      @o.initial_value(:initial_changed).must_equal 'ic'
-      @o.initial_value(:missing_changed).must_be_nil
-    end
-
-    it "initial_value should handle case where initial value is reassigned later" do
-      @o.initial_changed = 'ic'
-      @o.initial_value(:initial_changed).must_equal 'ic'
-      @o.missing_changed = nil
-      @o.initial_value(:missing_changed).must_be_nil
-    end
-
-    it "changed_columns should handle case where initial value is reassigned later" do
-      @o.changed_columns.must_equal [:initial_changed, :missing_changed]
-      @o.initial_changed = 'ic'
-      @o.changed_columns.must_equal [:missing_changed]
-      @o.missing_changed = nil
-      @o.changed_columns.must_equal [:missing_changed]
-    end
-
-    it "column_change should give initial and current values if there has been a change made" do
-      @o.column_change(:initial_changed).must_equal ['ic', 'ic2']
-      @o.column_change(:missing_changed).must_equal [nil, 'mc2']
-    end
-
-    it "column_change should be nil if no change has been made" do
-      @o.column_change(:initial).must_be_nil
-      @o.column_change(:missing).must_be_nil
-    end
-
-    it "column_changed? should return whether the column has changed" do
-      @o.column_changed?(:initial).must_equal false
-      @o.column_changed?(:initial_changed).must_equal true
-      @o.column_changed?(:missing).must_equal false
-      @o.column_changed?(:missing_changed).must_equal true
-    end
-
-    it "column_changed? should handle case where initial value is reassigned later" do
-      @o.initial_changed = 'ic'
-      @o.column_changed?(:initial_changed).must_equal false
-      @o.missing_changed = nil
-      @o.column_changed?(:missing_changed).must_equal false
-    end
-
-    it "changed_columns should handle case where initial value is reassigned later" do
-      @o.changed_columns.must_equal [:initial_changed, :missing_changed]
-      @o.initial_changed = 'ic'
-      @o.changed_columns.must_equal [:missing_changed]
-      @o.missing_changed = nil
-      @o.changed_columns.must_equal [:missing_changed]
-    end
-
-    it "column_changes should give initial and current values" do
-      @o.column_changes.must_equal(:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2'])
-    end
-
-    it "reset_column should reset the column to its initial value" do
-      @o.reset_column(:initial)
-      @o.initial.must_equal 'i'
-      @o.reset_column(:initial_changed)
-      @o.initial_changed.must_equal 'ic'
-      @o.reset_column(:missing)
-      @o.missing.must_be_nil
-      @o.reset_column(:missing_changed)
-      @o.missing_changed.must_be_nil
-    end
-
-    it "reset_column should remove missing values from the values" do
-      @o.reset_column(:missing)
-      @o.values.has_key?(:missing).must_equal false
-      @o.reset_column(:missing_changed)
-      @o.values.has_key?(:missing_changed).must_equal false
-    end
-    
-    it "refresh should clear the cached initial values" do
-      @o.refresh
-      @o.column_changes.must_equal({})
-    end
-    
-    it "will_change_column should be used to signal in-place modification to column" do
-      @o.will_change_column(:initial)
-      @o.initial << 'b'
-      @o.column_change(:initial).must_equal ['i', 'ib']
-      @o.will_change_column(:initial_changed)
-      @o.initial_changed << 'b'
-      @o.column_change(:initial_changed).must_equal ['ic', 'ic2b']
-      @o.will_change_column(:missing)
-      @o.values[:missing] = 'b'
-      @o.column_change(:missing).must_equal [nil, 'b']
-      @o.will_change_column(:missing_changed)
-      @o.missing_changed << 'b'
-      @o.column_change(:missing_changed).must_equal [nil, 'mc2b']
-    end
-
-    it "will_change_column should different types of existing objects" do
-      [nil, true, false, Class.new{undef_method :clone}.new, Class.new{def clone; raise TypeError; end}.new].each do |v|
-        o = @c.new(:initial=>v)
-        o.will_change_column(:initial)
-        o.initial = 'a'
-        o.column_change(:initial).must_equal [v, 'a']
-      end
-    end
-
-    it "should work when freezing objects" do
-      @o.freeze
-      @o.initial_value(:initial).must_equal 'i'
-      proc{@o.initial = 'b'}.must_raise
-    end
-
-    it "should have #dup duplicate structures" do
-      was_new = @o.new?
-      @o.update(:missing=>'m2')
-      @o.dup.initial_values.must_equal @o.initial_values
-      @o.dup.initial_values.wont_be_same_as(@o.initial_values)
-      @o.dup.instance_variable_get(:@missing_initial_values).must_equal @o.instance_variable_get(:@missing_initial_values)
-      @o.dup.instance_variable_get(:@missing_initial_values).wont_be_same_as(@o.instance_variable_get(:@missing_initial_values))
-      if was_new
-        @o.previous_changes.must_be_nil
-        @o.dup.previous_changes.must_be_nil
-      else
-        @o.dup.previous_changes.must_equal @o.previous_changes
-      end
-      @o.dup.previous_changes.wont_be_same_as(@o.previous_changes) if @o.previous_changes
-    end
-  end
-
-  describe "with new instance" do
-    before do
-      @o = @c.new(:initial=>'i'.dup, :initial_changed=>'ic'.dup)
-      @o.initial_changed = 'ic2'.dup
-      @o.missing_changed = 'mc2'.dup
-    end
-
-    include dirty_plugin_specs
-
-    it "save should clear the cached initial values" do
-      @o.save
-      @o.column_changes.must_equal({})
-    end
-
-    it "save_changes should clear the cached initial values" do
-      @c.dataset = @c.dataset.with_extend do
-        def supports_insert_select?; true end
-        def insert_select(*) {:id=>1} end
-      end
-      @o.save
-      @o.column_changes.must_equal({})
-    end
-  end
-
-  describe "with existing instance" do
-    before do
-      @o = @c[1]
-      @o.initial_changed = 'ic2'.dup
-      @o.missing_changed = 'mc2'.dup
-    end
-
-    include dirty_plugin_specs
-
-    it "previous_changes should be the previous changes after saving" do
-      @o.save
-      @o.previous_changes.must_equal(:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2'])
-    end
-
-    it "should work when freezing objects after saving" do
-      @o.initial = 'a'
-      @o.save
-      @o.freeze
-      @o.previous_changes[:initial].must_equal ['i', 'a']
-      proc{@o.initial = 'b'}.must_raise
-    end
-  end
-end

data/spec/extensions/duplicate_columns_handler_spec.rb

@@ -1,104 +0,0 @@
-require_relative "spec_helper"
-
-mod = shared_description do
-  it "should take action depending on :on_duplicate_columns if 2 or more columns have the same name" do
-    check(nil, @cols)
-    @warned.must_be_nil
-
-    check(:ignore, @cols)
-    @warned.must_be_nil
-
-    check(:warn, @cols)
-    @warned.must_include("One or more duplicate columns present in #{@cols.inspect}")
-
-    proc{check(:raise, @cols)}.must_raise(Sequel::DuplicateColumnError)
-
-    cols = nil
-    check(proc{|cs| cols = cs; nil}, @cols)
-    @warned.must_be_nil
-    cols.must_equal @cols
-
-    cols = nil
-    check(proc{|cs| cols = cs; :ignore}, @cols)
-    @warned.must_be_nil
-    cols.must_equal @cols
-
-    cols = nil
-    proc{check(proc{|cs| cols = cs; :raise}, @cols)}.must_raise(Sequel::DuplicateColumnError)
-    cols.must_equal @cols
-
-    cols = nil
-    check(proc{|cs| cols = cs; :warn}, @cols)
-    @warned.must_include("One or more duplicate columns present in #{@cols.inspect}")
-    cols.must_equal @cols
-
-    check(:raise, nil)
-    @warned.must_be_nil
-  end
-
-  it "should not raise error or warning if no columns have the same name" do
-    [nil, :ignore, :raise, :warn, proc{|cs| :raise}].each do |handler|
-      check(handler, @cols.uniq)
-      @warned.must_be_nil
-    end
-  end
-end
-
-describe "Sequel::DuplicateColumnsHandler Database configuration" do
-  before do
-    @db = Sequel.mock
-    @db.extension(:duplicate_columns_handler)
-    @cols = [:id, :name, :id]
-    @warned = nil
-    set_warned = @set_warned = proc{|m| @warned = m}
-    @ds = @db[:things].with_extend{define_method(:warn){|message| set_warned.call(message)}}
-  end
-
-  def check(handler, cols)
-    @db.opts[:on_duplicate_columns] = handler
-    @set_warned.call(nil)
-    @ds.send(:columns=, cols)
-  end
-
-  include mod
-end
-
-describe "Sequel::DuplicateColumnsHandler Dataset configuration" do
-  before do
-    @cols = [:id, :name, :id]
-    @warned = nil
-    set_warned = @set_warned = proc{|m| @warned = m}
-    @ds = Sequel.mock[:things].extension(:duplicate_columns_handler).with_extend{define_method(:warn){|message| set_warned.call(message)}}
-  end
-
-  def check(handler, cols)
-    @set_warned.call(nil)
-    @ds.on_duplicate_columns(handler).send(:columns=, cols)
-  end
-
-  include mod
-
-  it "should use handlers passed as blocks to on_duplicate_columns" do
-    proc{@ds.on_duplicate_columns{:raise}.send(:columns=, @cols)}.must_raise(Sequel::DuplicateColumnError)
-  end
-
-  it "should raise an error if not providing either an argument or block to on_duplicate_columns" do
-    proc{@ds.on_duplicate_columns}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if providing both an argument and block to on_duplicate_columns" do
-    proc{@ds.on_duplicate_columns(:raise){:raise}}.must_raise(Sequel::Error)
-  end
-
-  it "should warn by defaul if there is no database or dataset handler" do
-    @ds.send(:columns=, @cols)
-    @warned.must_include("One or more duplicate columns present in #{@cols.inspect}")
-  end
-
-  it "should fallback to database setting if there is no dataset-level handler" do
-    @ds.db.opts[:on_duplicate_columns] = :raise
-    proc{@ds.send(:columns=, @cols)}.must_raise(Sequel::DuplicateColumnError)
-    check(:ignore, @cols)
-    @warned.must_be_nil
-  end
-end

data/spec/extensions/eager_each_spec.rb

@@ -1,62 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::EagerEach" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.columns :id, :parent_id
-    @c.plugin :eager_each
-    @c.one_to_many :children, :class=>@c, :key=>:parent_id
-    @c.db.sqls
-  end
-
-  it "should make #each on an eager dataset do eager loading" do
-    a = []
-    ds = @c.eager(:children).with_fetch([{:id=>1, :parent_id=>nil}, {:id=>2, :parent_id=>nil}])
-    @c.dataset = @c.dataset.with_fetch([{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>2}, {:id=>6, :parent_id=>2}])
-    ds.each{|c| a << c}
-    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
-    a.map{|c| c.associations[:children]}.must_equal [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
-    sqls = @c.db.sqls
-    sqls.shift.must_equal 'SELECT * FROM items'
-    ['SELECT * FROM items WHERE (items.parent_id IN (1, 2))', 
-     'SELECT * FROM items WHERE (items.parent_id IN (2, 1))'].must_include(sqls.pop)
-  end
-
-  it "should make #each on an eager_graph dataset do eager loading" do
-    a = []
-    ds = @c.eager_graph(:children).with_fetch([{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}, {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}, {:id=>2, :parent_id=>nil, :children_id=>6, :children_parent_id=>2}])
-    ds.each{|c| a << c}
-    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
-    a.map{|c| c.associations[:children]}.must_equal [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
-    @c.db.sqls.must_equal ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
-  end
-
-  it "should make #first on an eager dataset do eager loading" do
-    ds = @c.eager(:children).with_fetch([{:id=>1, :parent_id=>nil}])
-    @c.dataset = @c.dataset.with_fetch([{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}])
-    a = ds.first
-    a.values.must_equal(:id=>1, :parent_id=>nil)
-    a.associations[:children].must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)]
-    @c.db.sqls.must_equal ['SELECT * FROM items LIMIT 1','SELECT * FROM items WHERE (items.parent_id IN (1))'] 
-  end
-
-  it "should make #first on an eager_graph dataset do eager loading" do
-    a = @c.eager_graph(:children).with_fetch([[{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}], [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}]]).first
-    a.values.must_equal(:id=>1, :parent_id=>nil)
-    a.associations[:children].must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)]
-    @c.db.sqls.must_equal ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) LIMIT 1',
-      'SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) WHERE (items.id = 1)']
-  end
-
-  it "should make #first on a non-eager dataset work correctly" do
-    @c.dataset.with_fetch([{:id=>1, :parent_id=>nil}]).first.must_equal @c.load(:id=>1, :parent_id=>nil)
-  end
-
-  it "should get columns normally columns" do
-    @c.dataset.columns!.must_equal [:id, :parent_id]
-  end
-
-  it "should not attempt to eager load when getting the columns" do
-    @c.eager(:children).with_extend{def all; raise; end}.columns!.must_equal [:id, :parent_id]
-  end
-end

data/spec/extensions/eager_graph_eager_spec.rb

@@ -1,100 +0,0 @@
-require_relative "spec_helper"
-
-describe "eager_graph_eager plugin" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.columns :id, :parent_id
-    @c.plugin :eager_graph_eager
-    @c.one_to_many :children, :class=>@c, :key=>:parent_id
-    @c.many_to_one :parent, :class=>@c
-    @c.db.sqls
-  end
-
-  it "should support Dataset#eager_graph_eager for eager loading dependencies of eager_graph associations for one_to_many associations" do
-    a = @c.eager_graph(:children).
-      with_fetch([{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>2, :parent_id=>nil}]).
-      eager_graph_eager([:children], :children=>proc{|ds| ds.with_fetch(:id=>4, :parent_id=>3)}).
-      all
-    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)",
-      "SELECT * FROM items WHERE (items.parent_id IN (3))"]
-
-    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
-    a.map(&:children).must_equal [[@c.load(:id=>3, :parent_id=>1)], []]
-    a.first.children.first.children.must_equal [@c.load(:id=>4, :parent_id=>3)]
-    @c.db.sqls.must_equal []
-  end
-
-  it "should support Dataset#eager_graph_eager for eager loading dependencies of eager_graph associations for many_to_one associations" do
-    a = @c.eager_graph(:parent).
-      with_fetch([{:id=>4, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1}, {:id=>2, :parent_id=>nil}]).
-      eager_graph_eager([:parent], :parent=>proc{|ds| ds.with_fetch(:id=>1, :parent_id=>nil)}).
-      all
-    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id FROM items LEFT OUTER JOIN items AS parent ON (parent.id = items.parent_id)",
-      "SELECT * FROM items WHERE (items.id IN (1))"]
-
-    a.must_equal [@c.load(:id=>4, :parent_id=>3), @c.load(:id=>2, :parent_id=>nil)]
-    a.map(&:parent).must_equal [@c.load(:id=>3, :parent_id=>1), nil]
-    a.first.parent.parent.must_equal @c.load(:id=>1, :parent_id=>nil)
-    @c.db.sqls.must_equal []
-  end
-
-  it "should support multiple entries in dependency chain" do
-    a = @c.eager_graph(:children=>:children).
-      with_fetch([{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1, :children_0_id=>4, :children_0_parent_id=>3}, {:id=>2, :parent_id=>nil}]).
-      eager_graph_eager([:children, :children], :children=>proc{|ds| ds.with_fetch(:id=>5, :parent_id=>4)}).
-      all
-    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id, children_0.id AS children_0_id, children_0.parent_id AS children_0_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) LEFT OUTER JOIN items AS children_0 ON (children_0.parent_id = children.id)",
-      "SELECT * FROM items WHERE (items.parent_id IN (4))"]
-
-    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
-    a.map(&:children).must_equal [[@c.load(:id=>3, :parent_id=>1)], []]
-    a.first.children.first.children.must_equal [@c.load(:id=>4, :parent_id=>3)]
-    a.first.children.first.children.first.children.must_equal [@c.load(:id=>5, :parent_id=>4)]
-    @c.db.sqls.must_equal []
-  end
-
-  it "should support multiple dependency chains" do
-    a = @c.eager_graph(:children, :parent).
-      with_fetch([{:id=>4, :parent_id=>3, :children_id=>5, :children_parent_id=>4, :parent_id_0=>3, :parent_parent_id=>1}, {:id=>2, :parent_id=>nil}]).
-      eager_graph_eager([:children], :children=>proc{|ds| ds.with_fetch(:id=>6, :parent_id=>5)}).
-      eager_graph_eager([:parent], :parent=>proc{|ds| ds.with_fetch(:id=>1, :parent_id=>nil)}).
-      all
-    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) LEFT OUTER JOIN items AS parent ON (parent.id = items.parent_id)",
-      "SELECT * FROM items WHERE (items.parent_id IN (5))",
-      "SELECT * FROM items WHERE (items.id IN (1))"]
-
-    a.must_equal [@c.load(:id=>4, :parent_id=>3), @c.load(:id=>2, :parent_id=>nil)]
-    a.map(&:children).must_equal [[@c.load(:id=>5, :parent_id=>4)], []]
-    a.map(&:parent).must_equal [@c.load(:id=>3, :parent_id=>1), nil]
-    a.first.children.first.children.must_equal [@c.load(:id=>6, :parent_id=>5)]
-    a.first.parent.parent.must_equal @c.load(:id=>1, :parent_id=>nil)
-    @c.db.sqls.must_equal []
-  end
-
-  it "should raise for invalid dependency chains" do
-    proc{@c.dataset.eager_graph_eager([], :children)}.must_raise Sequel::Error
-    proc{@c.dataset.eager_graph_eager(:children, :children)}.must_raise Sequel::Error
-    proc{@c.dataset.eager_graph_eager(['foo'], :children)}.must_raise Sequel::Error
-    proc{@c.dataset.eager_graph_eager([:foo], :children)}.must_raise Sequel::Error
-  end
-
-  it "should handle cases where not all associated objects are unique" do
-    a = @c.eager_graph(:parent=>:children).
-      with_fetch([
-        {:id=>4, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1, :children_id=>4, :children_parent_id=>3},
-        {:id=>5, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1, :children_id=>4, :children_parent_id=>3},
-        {:id=>4, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1, :children_id=>5, :children_parent_id=>3},
-        {:id=>5, :parent_id=>3, :parent_id_0=>3, :parent_parent_id=>1, :children_id=>5, :children_parent_id=>3}
-      ]).
-      eager_graph_eager([:parent], :parent=>proc{|ds| ds.with_fetch(:id=>1, :parent_id=>nil)}).
-      all
-    @c.db.sqls.must_equal ["SELECT items.id, items.parent_id, parent.id AS parent_id_0, parent.parent_id AS parent_parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS parent ON (parent.id = items.parent_id) LEFT OUTER JOIN items AS children ON (children.parent_id = parent.id)",
-      "SELECT * FROM items WHERE (items.id IN (1))"]
-
-    a.must_equal [@c.load(:id=>4, :parent_id=>3), @c.load(:id=>5, :parent_id=>3)]
-    a.map(&:parent).must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>3, :parent_id=>1)]
-    a.map(&:parent).map(&:children).must_equal [a, a]
-    a.map(&:parent).map(&:parent).must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>1, :parent_id=>nil)]
-    @c.db.sqls.must_equal []
-  end
-end

data/spec/extensions/empty_array_consider_nulls_spec.rb

@@ -1,24 +0,0 @@
-require_relative "spec_helper"
-
-describe "filter_having extension" do
-  before do
-    @dataset = Sequel.mock[:test].extension(:empty_array_consider_nulls)
-  end
-
-  it "should handle all types of IN/NOT IN queries with empty arrays" do
-    @dataset.filter(:id => []).sql.must_equal "SELECT * FROM test WHERE (id != id)"
-    @dataset.filter([:id1, :id2] => []).sql.must_equal "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
-    @dataset.exclude(:id => []).sql.must_equal "SELECT * FROM test WHERE (id = id)"
-    @dataset.exclude([:id1, :id2] => []).sql.must_equal "SELECT * FROM test WHERE ((id1 = id1) AND (id2 = id2))"
-  end
-
-  it "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it" do
-    db = Sequel.mock
-    d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
-    @dataset = @dataset.with_extend{def supports_multiple_column_in?; false end}
-    @dataset.filter([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
-    db.sqls.must_equal ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
-    @dataset.exclude([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE ((id1 = id1) AND (id2 = id2))"
-    db.sqls.must_equal ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
-  end
-end

data/spec/extensions/error_splitter_spec.rb

@@ -1,18 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::ErrorSplitter" do
-  before do
-    @c = Class.new(Sequel::Model)
-    @c.plugin :error_splitter
-    @m = @c.new
-    def @m.validate
-      errors.add([:a, :b], 'is bad')
-    end
-  end
-
-  it "should split errors for multiple columns and assign them to each column" do
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:a=>['is bad'], :b=>['is bad'])
-  end
-end
-

data/spec/extensions/error_sql_spec.rb

@@ -1,20 +0,0 @@
-require_relative "spec_helper"
-
-describe "error_sql extension" do
-  before do
-    @db = Sequel.mock(:fetch=>proc{|sql| @db.log_connection_yield(sql, nil){raise StandardError}}).extension(:error_sql)
-  end
-
-  it "should have Sequel::DatabaseError#sql give the SQL causing the error" do
-    @db["SELECT"].all rescue (e = $!)
-    e.sql.must_equal "SELECT"
-  end
-
-  it "should have Sequel::DatabaseError#sql give the SQL causing the error when using a logger" do
-    l = Object.new
-    def l.method_missing(*) end
-    @db.loggers = [l]
-    @db["SELECT"].all rescue (e = $!)
-    e.sql.must_equal "SELECT"
-  end
-end

data/spec/extensions/escaped_like_spec.rb

@@ -1,40 +0,0 @@
-require_relative "spec_helper"
-
-describe "escaped_like extension" do
-  before do
-    Sequel.extension(:escaped_like)
-    @ds = Sequel.mock[:t]
-    @c = Sequel[:c]
-  end
-
-  it "escaped_like should support creating case sensitive pattern matches" do
-    @ds.where(@c.escaped_like('?', 'a')).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a' ESCAPE '\\')"
-    @ds.where(@c.escaped_like('?%', 'a')).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a%' ESCAPE '\\')"
-    @ds.where(@c.escaped_like('?', 'a%')).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a\\%' ESCAPE '\\')"
-    @ds.where(@c.escaped_like('?', ['a%'])).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a\\%' ESCAPE '\\')"
-    @ds.where(@c.escaped_like('??', ['a', '%'])).sql.must_equal "SELECT * FROM t WHERE (c LIKE 'a\\%' ESCAPE '\\')"
-  end
-
-  it "escaped_ilike should support creating case insensitive pattern matches" do
-    @ds.where(@c.escaped_ilike('?', 'a')).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a') ESCAPE '\\')"
-    @ds.where(@c.escaped_ilike('?%', 'a')).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a%') ESCAPE '\\')"
-    @ds.where(@c.escaped_ilike('?', 'a%')).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a\\%') ESCAPE '\\')"
-    @ds.where(@c.escaped_ilike('?', ['a%'])).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a\\%') ESCAPE '\\')"
-    @ds.where(@c.escaped_ilike('??', ['a', '%'])).sql.must_equal "SELECT * FROM t WHERE (UPPER(c) LIKE UPPER('a\\%') ESCAPE '\\')"
-  end
-
-  it "should raise an Error for a mismatched number of placeholders" do
-    proc{@ds.where(@c.escaped_like('?', [])).sql}.must_raise Sequel::Error
-    proc{@ds.where(@c.escaped_like('??', ['a'])).sql}.must_raise Sequel::Error
-    proc{@ds.where(@c.escaped_ilike('', ['a'])).sql}.must_raise Sequel::Error
-    proc{@ds.where(@c.escaped_ilike('?', ['a', 'a'])).sql}.must_raise Sequel::Error
-  end
-
-  it "escaped_like and escaped_ilike should return expressions" do
-    @ds.select(@c.escaped_like('?', 'a').as(:b)).sql.must_equal "SELECT (c LIKE 'a' ESCAPE '\\') AS b FROM t"
-    @ds.select(@c.escaped_like('?', 'a').cast(String)).sql.must_equal "SELECT CAST((c LIKE 'a' ESCAPE '\\') AS varchar(255)) FROM t"
-    @ds.order(@c.escaped_like('?', 'a').desc).sql.must_equal "SELECT * FROM t ORDER BY (c LIKE 'a' ESCAPE '\\') DESC"
-    @ds.where(@c.escaped_like('?', 'a') | @c.escaped_like('?', 'b')).sql.must_equal "SELECT * FROM t WHERE ((c LIKE 'a' ESCAPE '\\') OR (c LIKE 'b' ESCAPE '\\'))"
-  end
-end
-

data/spec/extensions/eval_inspect_spec.rb

@@ -1,81 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :eval_inspect
-
-describe "eval_inspect extension" do
-  before do
-    @ds = Sequel.mock.dataset.with_extend do
-      def supports_window_functions?; true end
-      def literal_blob_append(sql, s) sql << "X'#{s}'" end
-    end
-  end
-
-  it "should make eval(obj.inspect) == obj for all Sequel::SQL::Expression subclasses" do
-    [
-      # Objects with components where eval(inspect) == self
-      Sequel::SQL::AliasedExpression.new(:b, :a),
-      Sequel::SQL::AliasedExpression.new(:b, :a, [:c, :d]),
-      Sequel::SQL::CaseExpression.new({:b=>:a}, :c),
-      Sequel::SQL::CaseExpression.new({:b=>:a}, :c, :d),
-      Sequel::SQL::Cast.new(:a, :b),
-      Sequel::SQL::ColumnAll.new(:a),
-      Sequel::SQL::ComplexExpression.new(:'=', :b, :a),
-      Sequel::SQL::Constant.new(:a),
-      Sequel::CURRENT_DATE,
-      Sequel::CURRENT_TIMESTAMP,
-      Sequel::CURRENT_TIME,
-      Sequel::SQLTRUE,
-      Sequel::SQLFALSE,
-      Sequel::NULL,
-      Sequel::NOTNULL,
-      Sequel::SQL::Function.new(:a, :b, :c),
-      Sequel::SQL::Identifier.new(:a),
-      Sequel::SQL::JoinClause.new(:inner, :b),
-      Sequel::SQL::JoinOnClause.new({:d=>:a}, :inner, :b),
-      Sequel::SQL::JoinUsingClause.new([:a], :inner, :b),
-      Sequel::SQL::JoinClause.new(:inner, Sequel.as(:b, :c, [:d, :e])),
-      Sequel::SQL::JoinOnClause.new({:d=>:a}, :inner, Sequel.as(:b, :c, [:d, :e])),
-      Sequel::SQL::JoinUsingClause.new([:a], :inner, Sequel.as(:b, :c, [:d, :e])),
-      Sequel::SQL::PlaceholderLiteralString.new('? = ?', [:a, :b]),
-      Sequel::SQL::PlaceholderLiteralString.new(':a = :b', [{:a=>:b, :b=>42}]),
-      Sequel::SQL::OrderedExpression.new(:a),
-      Sequel::SQL::OrderedExpression.new(:a, false),
-      Sequel::SQL::OrderedExpression.new(:a, false, :nulls=>:first),
-      Sequel::SQL::OrderedExpression.new(:a, false, :nulls=>:last),
-      Sequel::SQL::QualifiedIdentifier.new(:b, :a),
-      Sequel::SQL::Subscript.new(:a, [1, 2]),
-      Sequel::SQL::Window.new(:order=>:a, :partition=>:b),
-      Sequel::SQL::Function.new(:a, :b, :c).over(:order=>:a, :partition=>:b),
-      Sequel::SQL::Wrapper.new(:a),
-      
-      # Objects with components where eval(inspect) != self
-      Sequel::SQL::AliasedExpression.new(Sequel::SQL::Blob.new('s'), :a),
-      Sequel::SQL::AliasedExpression.new(Sequel::LiteralString.new('s'), :a),
-      Sequel::SQL::PlaceholderLiteralString.new('(a, b) IN ?', [Sequel::SQL::ValueList.new([[1, 2]])]),
-      Sequel::SQL::CaseExpression.new({{:d=>Sequel::LiteralString.new('e')}=>:a}, :c, :d),
-      Sequel::SQL::AliasedExpression.new(Date.new(2011, 10, 11), :a),
-      Sequel::SQL::AliasedExpression.new(Sequel::SQLTime.create(10, 20, 30, 500000.125), :a),
-      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30), :a),
-      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30, 0.25), :a),
-      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30, -0.25), :a),
-      Sequel::SQL::AliasedExpression.new(Time.local(2011, 9, 11, 10, 20, 30), :a),
-      Sequel::SQL::AliasedExpression.new(Time.local(2011, 9, 11, 10, 20, 30, 500000.125), :a),
-      Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30), :a),
-      Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30, 500000.125), :a),
-      Sequel::SQL::AliasedExpression.new(BigDecimal('1.000000000000000000000000000000000000000000000001'), :a),
-      Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_DATE, :a),
-      Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_TIMESTAMP, :a),
-    ].each do |o|
-      v = eval(o.inspect)
-      v.must_equal o
-      @ds.literal(v).must_equal @ds.literal(o)
-
-      ds = @ds
-      @ds.db.create_table(:test) do
-        v = eval(o.inspect)
-        v.must_equal o
-        ds.literal(v).must_equal ds.literal(o)
-      end
-    end
-  end
-end