sequel 5.20.0 → 5.49.0

data/spec/extensions/hook_class_methods_spec.rb

@@ -1,402 +0,0 @@
-require_relative "spec_helper"
-
-model_class = proc do |klass, &block|
-  c = Class.new(klass)
-  c.plugin :hook_class_methods
-  c.class_eval(&block) if block
-  c
-end
-
-describe Sequel::Model, "hook_class_methods plugin" do
-  before do
-    DB.reset
-  end
-  
-  it "should freeze hooks when freezing model class" do
-    c = model_class.call Sequel::Model do
-      before_save{adds << 'hi'}
-    end
-    c.freeze
-    hooks = c.instance_variable_get(:@hooks)
-    hooks.frozen?.must_equal true
-    hooks.values.all?(&:frozen?).must_equal true
-  end
-
-  deprecated ".hook_blocks method should yield each hook block" do
-    c = model_class.call Sequel::Model
-    a = []
-    c.hook_blocks(:before_save){|b| a << b}
-    a.must_equal []
-
-    pr = proc{adds << 'hi'}
-    c.before_save(&pr)
-    a = []
-    c.hook_blocks(:before_save){|b| a << b}
-    a.must_equal [pr]
-
-    c.before_save(&pr)
-    a = []
-    c.hook_blocks(:before_save){|b| a << b}
-    a.must_equal [pr, pr]
-
-    a = []
-    c.hook_blocks(:after_save){|b| a << b}
-    a.must_equal []
-  end
-
-  it "should be definable using a block" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      before_save{adds << 'hi'}
-    end
-    
-    c.new.before_save
-    adds.must_equal ['hi']
-  end
-  
-  it "should be definable using a method name" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save :bye
-    end
-    
-    c.new.before_save
-    adds.must_equal ['bye']
-  end
-
-  it "should be additive" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      after_save{adds << 'hyiyie'}
-      after_save{adds << 'byiyie'}
-    end
-
-    c.new.after_save
-    adds.must_equal ['hyiyie', 'byiyie']
-  end
-  
-  it "before hooks should run in reverse order" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      before_save{adds << 'hyiyie'}
-      before_save{adds << 'byiyie'}
-    end
-    
-    c.new.before_save
-    adds.must_equal ['byiyie', 'hyiyie']
-  end
-
-  it "should not be additive if the method or tag already exists" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save :bye
-      before_save :bye
-    end
-    
-    c.new.before_save
-    adds.must_equal ['bye']
-
-    adds = []
-    d = model_class.call Sequel::Model do
-      before_save(:bye){adds << 'hyiyie'}
-      before_save(:bye){adds << 'byiyie'}
-    end
-    
-    d.new.before_save
-    adds.must_equal ['byiyie']
-
-    adds = []
-    e = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save :bye
-      before_save(:bye){adds << 'byiyie'}
-    end
-    
-    e.new.before_save
-    adds.must_equal ['byiyie']
-
-    adds = []
-    e = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save(:bye){adds << 'byiyie'}
-      before_save :bye
-    end
-    
-    e.new.before_save
-    adds.must_equal ['bye']
-  end
-  
-  it "should be inheritable" do
-    adds = []
-    a = model_class.call Sequel::Model do
-      after_save{adds << '123'}
-    end
-    
-    b = Class.new(a)
-    b.class_eval do
-      after_save{adds << '456'}
-      after_save{adds << '789'}
-    end
-    
-    b.new.after_save
-    adds.must_equal ['123', '456', '789']
-  end
-  
-  it "should be overridable in descendant classes" do
-    adds = []
-    a = model_class.call Sequel::Model do
-      before_save{adds << '123'}
-    end
-    
-    b = Class.new(a)
-    b.class_eval do
-      define_method(:before_save){adds << '456'}
-    end
-    
-    a.new.before_save
-    adds.must_equal ['123']
-    adds = []
-    b.new.before_save
-    adds.must_equal ['456']
-  end
-  
-  it "should stop processing if a before hook calls cancel_action" do
-    flag = true
-    adds = []
-    
-    a = model_class.call Sequel::Model(:items) do
-      before_save{adds << 'cruel'; cancel_action if flag == false}
-      before_save{adds << 'blah'; cancel_action if flag == false}
-    end
-    
-    a.raise_on_save_failure = false
-    a.new.save
-    adds.must_equal ['blah', 'cruel']
-
-    # chain should not break on nil
-    adds = []
-    flag = nil
-    a.new.save
-    adds.must_equal ['blah', 'cruel']
-    
-    adds = []
-    flag = false
-    a.new.save
-    adds.must_equal ['blah']
-    
-    b = Class.new(a)
-    b.class_eval do
-      before_save{adds << 'mau'}
-    end
-    
-    adds = []
-    b.new.save
-    adds.must_equal ['mau', 'blah']
-  end
-end
-
-describe "Model#before_create && Model#after_create" do
-  before do
-    DB.reset
-
-    @c = model_class.call Sequel::Model(:items)  do
-      columns :x
-      no_primary_key
-      
-      after_create {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around new record creation" do
-    @c.before_create {DB << "BLAH before"}
-    @c.create(:x => 2)
-    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
-  end
-
-  it ".create should cancel the save and raise an error if before_create calls cancel_action and raise_on_save_failure is true" do
-    @c.before_create{cancel_action}
-    proc{@c.create(:x => 2)}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it ".create should cancel the save and return nil if before_create calls cancel_action and raise_on_save_failure is false" do
-    @c.before_create{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.create(:x => 2).must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_update && Model#after_update" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      after_update {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around record update" do
-    @c.before_update {DB << "BLAH before"}
-    m = @c.load(:id => 2233, :x=>123)
-    m.save
-    DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
-  end
-
-  it "#save should cancel the save and raise an error if before_update calls cancel_action and raise_on_save_failure is true" do
-    @c.before_update{cancel_action}
-    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it "#save should cancel the save and return nil if before_update calls cancel_action and raise_on_save_failure is false" do
-    @c.before_update{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_save && Model#after_save" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      columns :x
-      after_save {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around record update" do
-    @c.before_save {DB << "BLAH before"}
-    m = @c.load(:id => 2233, :x=>123)
-    m.save
-    DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
-  end
-  
-  it "should be called around record creation" do
-    @c.before_save {DB << "BLAH before"}
-    @c.no_primary_key
-    @c.create(:x => 2)
-    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
-  end
-
-  it "#save should cancel the save and raise an error if before_save calls cancel_action and raise_on_save_failure is true" do
-    @c.before_save{cancel_action}
-    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it "#save should cancel the save and return nil if before_save calls cancel_action and raise_on_save_failure is false" do
-    @c.before_save{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_destroy && Model#after_destroy" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      after_destroy {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around record destruction" do
-    @c.before_destroy {DB << "BLAH before"}
-    m = @c.load(:id => 2233)
-    m.destroy
-    DB.sqls.must_equal ['BLAH before', "DELETE FROM items WHERE id = 2233", 'BLAH after']
-  end
-
-  it "#destroy should cancel the destroy and raise an error if before_destroy calls cancel_action and raise_on_save_failure is true" do
-    @c.before_destroy{cancel_action}
-    proc{@c.load(:id => 2233).destroy}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it "#destroy should cancel the destroy and return nil if before_destroy calls cancel_action and raise_on_save_failure is false" do
-    @c.before_destroy{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).destroy.must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_validation && Model#after_validation" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      plugin :validation_class_methods
-      after_validation{DB << "BLAH after"}
-
-      def self.validate(o)
-        o.errors.add(:id, 'not valid') unless o[:id] == 2233
-      end
-      columns :id
-    end
-  end
-  
-  it "should be called around validation" do
-    @c.before_validation{DB << "BLAH before"}
-    m = @c.load(:id => 2233)
-    m.must_be :valid?
-    DB.sqls.must_equal ['BLAH before', 'BLAH after']
-
-    DB.sqls.clear
-    m = @c.load(:id => 22)
-    m.wont_be :valid?
-    DB.sqls.must_equal ['BLAH before', 'BLAH after']
-  end
-
-  it "should be called when calling save" do
-    @c.before_validation{DB << "BLAH before"}
-    m = @c.load(:id => 2233, :x=>123)
-    m.save.must_equal m
-    DB.sqls.must_equal ['BLAH before', 'BLAH after', 'UPDATE items SET x = 123 WHERE (id = 2233)']
-
-    DB.sqls.clear
-    m = @c.load(:id => 22)
-    m.raise_on_save_failure = false
-    m.save.must_be_nil
-    DB.sqls.must_equal ['BLAH before', 'BLAH after']
-  end
-
-  it "#save should cancel the save and raise an error if before_validation calls cancel_action and raise_on_save_failure is true" do
-    @c.before_validation{cancel_action}
-    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it "#save should cancel the save and return nil if before_validation calls cancel_action and raise_on_save_failure is false" do
-    @c.before_validation{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.must_be_nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model.has_hooks?" do
-  before do
-    @c = model_class.call(Sequel::Model(:items))
-  end
-  
-  it "should return false if no hooks are defined" do
-    @c.has_hooks?(:before_save).must_equal false
-  end
-  
-  it "should return true if hooks are defined" do
-    @c.before_save {'blah'}
-    @c.has_hooks?(:before_save).must_equal true
-  end
-  
-  it "should return true if hooks are inherited" do
-    @d = Class.new(@c)
-    @d.has_hooks?(:before_save).must_equal false
-  end
-end

data/spec/extensions/identifier_mangling_spec.rb

@@ -1,201 +0,0 @@
-require_relative "spec_helper"
-
-describe "identifier_mangling extension" do
-  it "should respect the :quote_identifiers option" do
-    db = Sequel::Database.new(:quote_identifiers=>false).extension(:identifier_mangling)
-    db.quote_identifiers?.must_equal false
-    db = Sequel::Database.new(:quote_identifiers=>true).extension(:identifier_mangling)
-    db.quote_identifiers?.must_equal true
-  end
-
-  it "should respect the :quote_identifiers setting" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.quote_identifiers?.must_equal true
-    db.quote_identifiers = false
-    db.quote_identifiers?.must_equal false
-  end
-
-  it "should upcase on input and downcase on output by default" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.send(:identifier_input_method_default).must_equal :upcase
-    db.send(:identifier_output_method_default).must_equal :downcase
-  end
-
-  it "should respect the :identifier_input_method option" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.identifier_input_method.must_equal :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.must_be_nil
-    db = Sequel::Database.new(:identifier_input_method=>nil).extension(:identifier_mangling)
-    db.identifier_input_method.must_be_nil
-    db.identifier_input_method = :downcase
-    db.identifier_input_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_input_method=>:upcase).extension(:identifier_mangling)
-    db.identifier_input_method.must_equal :upcase
-    db.identifier_input_method = nil
-    db.identifier_input_method.must_be_nil
-  end
-  
-  it "should respect the :identifier_output_method option" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.identifier_output_method.must_equal :downcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.must_be_nil
-    db = Sequel::Database.new(:identifier_output_method=>nil).extension(:identifier_mangling)
-    db.identifier_output_method.must_be_nil
-    db.identifier_output_method = :downcase
-    db.identifier_output_method.must_equal :downcase
-    db = Sequel::Database.new(:identifier_output_method=>:upcase).extension(:identifier_mangling)
-    db.identifier_output_method.must_equal :upcase
-    db.identifier_output_method = nil
-    db.identifier_output_method.must_be_nil
-  end
-
-  it "should respect the identifier_input_method_default method if Sequel.identifier_input_method is not called" do
-    class Sequel::Database
-      @identifier_input_method = nil
-    end
-    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_input_method_default; :downcase end}
-    x.new.extension(:identifier_mangling).identifier_input_method.must_equal :downcase
-    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_input_method_default; :camelize end}
-    y.new.extension(:identifier_mangling).identifier_input_method.must_equal :camelize
-  end
-  
-  it "should respect the identifier_output_method_default method if Sequel.identifier_output_method is not called" do
-    class Sequel::Database
-      @identifier_output_method = nil
-    end
-    x = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_output_method_default; :upcase end}
-    x.new.extension(:identifier_mangling).identifier_output_method.must_equal :upcase
-    y = Class.new(Sequel::Database){def dataset_class_default; Sequel::Dataset end; def identifier_output_method_default; :underscore end}
-    y.new.extension(:identifier_mangling).identifier_output_method.must_equal :underscore
-  end
-end
-
-describe "Database#input_identifier_meth" do
-  it "should be the input_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.identifier_input_method = nil
-    db.send(:input_identifier_meth).call(:a).must_equal 'a'
-    db.identifier_input_method = :upcase
-    db.send(:input_identifier_meth).call(:a).must_equal 'A'
-  end
-end
-
-describe "Database#output_identifier_meth" do
-  it "should be the output_identifer method of a default dataset for this database" do
-    db = Sequel::Database.new.extension(:identifier_mangling)
-    db.identifier_output_method = nil
-    db.send(:output_identifier_meth).call('A').must_equal :A
-    db.identifier_output_method = :downcase
-    db.send(:output_identifier_meth).call('A').must_equal :a
-  end
-end
-
-describe "Database#metadata_dataset" do
-  it "should be a dataset with the default settings for identifier_mangling" do
-    ds = Sequel::Database.new.extension(:identifier_mangling).send(:metadata_dataset)
-    ds.literal(:a).must_equal "\"A\""
-    ds.send(:output_identifier, 'A').must_equal :a
-  end
-end
-
-describe "Dataset" do
-  before do
-    @dataset = Sequel.mock.extension(:identifier_mangling).dataset
-  end
-  
-  it "should get quote_identifiers default from database" do
-    db = Sequel::Database.new(:quote_identifiers=>true).extension(:identifier_mangling)
-    db[:a].quote_identifiers?.must_equal true
-    db = Sequel::Database.new(:quote_identifiers=>false).extension(:identifier_mangling)
-    db[:a].quote_identifiers?.must_equal false
-  end
-
-  it "should get identifier_input_method default from database" do
-    db = Sequel::Database.new(:identifier_input_method=>:upcase).extension(:identifier_mangling)
-    db[:a].identifier_input_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_input_method=>:downcase).extension(:identifier_mangling)
-    db[:a].identifier_input_method.must_equal :downcase
-  end
-
-  it "should get identifier_output_method default from database" do
-    db = Sequel::Database.new(:identifier_output_method=>:upcase).extension(:identifier_mangling)
-    db[:a].identifier_output_method.must_equal :upcase
-    db = Sequel::Database.new(:identifier_output_method=>:downcase).extension(:identifier_mangling)
-    db[:a].identifier_output_method.must_equal :downcase
-  end
-  
-  it "should have with_quote_identifiers method which returns cloned dataset with changed literalization of identifiers" do
-    @dataset.with_quote_identifiers(true).literal(:a).must_equal '"a"'
-    @dataset.with_quote_identifiers(false).literal(:a).must_equal 'a'
-    ds = @dataset.freeze.with_quote_identifiers(false)
-    ds.literal(:a).must_equal 'a'
-    ds.frozen?.must_equal true
-  end
-  
-  it "should have with_identifier_input_method method which returns cloned dataset with changed literalization of identifiers" do
-    @dataset.with_identifier_input_method(:upcase).literal(:a).must_equal 'A'
-    @dataset.with_identifier_input_method(:downcase).literal(:A).must_equal 'a'
-    @dataset.with_identifier_input_method(:reverse).literal(:at_b).must_equal 'b_ta'
-    ds = @dataset.freeze.with_identifier_input_method(:reverse)
-    ds.frozen?.must_equal true
-    ds.literal(:at_b).must_equal 'b_ta'
-  end
-  
-  it "should have with_identifier_output_method method which returns cloned dataset with changed identifiers returned from the database" do
-    @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
-    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "at_b_C").must_equal :AT_B_C
-    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "at_b_C").must_equal :at_b_c
-    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "at_b_C").must_equal :C_b_ta
-    ds = @dataset.freeze.with_identifier_output_method(:reverse)
-    ds.send(:output_identifier, "at_b_C").must_equal :C_b_ta
-    ds.frozen?.must_equal true
-  end
-  
-  it "should have output_identifier handle empty identifiers" do
-    @dataset.send(:output_identifier, "").must_equal :untitled
-    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "").must_equal :UNTITLED
-    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "").must_equal :untitled
-    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "").must_equal :deltitnu
-  end
-end
-
-describe "identifier_mangling extension" do
-  it "should be able to load dialects based on the database name" do
-    Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.must_equal 'SELECT #2011-12-13#'
-    Sequel.mock(:host=>'db2').select(1).sql.must_equal 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
-    Sequel.mock(:host=>'mssql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
-    Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
-    Sequel.mock(:host=>'oracle')[:a].limit(1).sql.must_equal 'SELECT * FROM (SELECT * FROM "A") "T1" WHERE (ROWNUM <= 1)'
-    Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM \"a\" WHERE (to_tsvector(CAST('simple' AS regconfig), (COALESCE(\"b\", ''))) @@ to_tsquery(CAST('simple' AS regconfig), 'c'))"
-    Sequel.mock(:host=>'sqlanywhere').from(:a).offset(1).sql.must_equal 'SELECT TOP 2147483647 START AT (1 + 1) * FROM "A"'
-    Sequel.mock(:host=>'sqlite')[Sequel[:a].as(:b)].sql.must_equal "SELECT * FROM `a` AS 'b'"
-  end
-end
-
-describe Sequel::Model, ".[] optimization" do
-  before do
-    @db = Sequel.mock(:quote_identifiers=>true).extension(:identifier_mangling)
-    def @db.schema(*) [[:id, {:primary_key=>true}]] end
-    def @db.supports_schema_parsing?() true end
-    @c = Class.new(Sequel::Model(@db))
-    @ds = @db.dataset.with_quote_identifiers(true)
-  end
-
-  it "should have simple_pk and simple_table respect dataset's identifier input methods" do
-    ds = @db.from(:ab).with_identifier_input_method(:reverse)
-    @c.set_dataset ds
-    @c.simple_table.must_equal '"ba"'
-    @c.set_primary_key :cd
-    @c.simple_pk.must_equal '"dc"'
-    @c.set_dataset ds.from(Sequel[:ef][:gh])
-    @c.simple_table.must_equal '"fe"."hg"'
-  end
-
-  with_symbol_splitting "should have simple_pk and simple_table respect dataset's identifier input methods when using splittable symbols" do
-    ds = @db.from(:ab).with_identifier_input_method(:reverse)
-    @c.set_dataset ds.from(:ef__gh)
-    @c.simple_table.must_equal '"fe"."hg"'
-  end
-end

data/spec/extensions/implicit_subquery_spec.rb

@@ -1,58 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Dataset::ImplicitSubquery" do
-  it "should implicitly use a subquery for most dataset query methods" do
-    db = Sequel.mock
-    db.extend_datasets{def supports_cte?; true end}
-    ds = db["SELECT * FROM table"].extension(:implicit_subquery)
-    ds.columns(:id, :a)
-    ods = db[:c]
-    ods.columns(:id, :b)
-
-    ds.cross_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 CROSS JOIN c"
-    ds.distinct.sql.must_equal "SELECT DISTINCT * FROM (SELECT * FROM table) AS t1"
-    ds.except(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 EXCEPT SELECT * FROM c) AS t1"
-    ds.exclude(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
-    ds.exclude_having(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 HAVING NOT c"
-    ds.filter(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
-    ds.for_update.sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FOR UPDATE"
-    ds.full_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FULL JOIN c"
-    ds.full_outer_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FULL OUTER JOIN c"
-    ds.graph(ods).sql.must_equal "SELECT t1.id, t1.a, c.id AS c_id, c.b FROM (SELECT * FROM table) AS t1 LEFT OUTER JOIN c"
-    ds.grep(:c, 'a').sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE ((c LIKE 'a' ESCAPE '\\'))"
-    ds.group(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.group_append(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.group_and_count(:c).sql.must_equal "SELECT c, count(*) AS count FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.group_by(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.having(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 HAVING c"
-    ds.inner_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 INNER JOIN c USING (d)"
-    ds.intersect(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 INTERSECT SELECT * FROM c) AS t1"
-    ds.invert.sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE 'f'"
-    ds.join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 INNER JOIN c USING (d)"
-    ds.join_table(:inner, :c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 INNER JOIN c USING (d)"
-    ds.left_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 LEFT JOIN c USING (d)"
-    ds.left_outer_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 LEFT OUTER JOIN c USING (d)"
-    ds.limit(1).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 LIMIT 1"
-    ds.lock_style('FOR UPDATE').sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FOR UPDATE"
-    ds.natural_full_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL FULL JOIN c"
-    ds.natural_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL JOIN c"
-    ds.natural_left_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL LEFT JOIN c"
-    ds.natural_right_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL RIGHT JOIN c"
-    ds.offset(1).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 OFFSET 1"
-    ds.order(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.order_append(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.order_by(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.order_more(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.order_prepend(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
-    ds.right_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 RIGHT JOIN c USING (d)"
-    ds.right_outer_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 RIGHT OUTER JOIN c USING (d)"
-    ds.select(:c).sql.must_equal "SELECT c FROM (SELECT * FROM table) AS t1"
-    ds.select_append(:c).sql.must_equal "SELECT *, c FROM (SELECT * FROM table) AS t1"
-    ds.select_group(:c).sql.must_equal "SELECT c FROM (SELECT * FROM table) AS t1 GROUP BY c"
-    ds.select_more(:c).sql.must_equal "SELECT *, c FROM (SELECT * FROM table) AS t1"
-    ds.union(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 UNION SELECT * FROM c) AS t1"
-    ds.where(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
-    ds.with(:d, ods).sql.must_equal "WITH d AS (SELECT * FROM c) SELECT * FROM (SELECT * FROM table) AS t1"
-    ds.with_recursive(:d, ods, ods).sql.must_equal "WITH d AS (SELECT * FROM c UNION ALL SELECT * FROM c) SELECT * FROM (SELECT * FROM table) AS t1"
-  end
-end