sequel 2.10.0 → 2.11.0

data/spec/sequel_core/dataset_spec.rb

@@ -81,6 +81,13 @@ context "Dataset" do
     @dataset.literal(:a).should == 'a'
   end
 
+  specify "should have upcase_identifiers? method which returns whether identifiers are currently upcased" do
+    @dataset.upcase_identifiers = true
+    @dataset.upcase_identifiers?.should == true
+    @dataset.upcase_identifiers = false
+    @dataset.upcase_identifiers?.should == false
+  end
+
   specify "should have identifier_input_method= method which changes literalization of identifiers" do
     @dataset.identifier_input_method = :upcase
     @dataset.literal(:a).should == 'A'
@@ -696,6 +703,10 @@ context "Dataset#literal" do
     @dataset.literal("a\\'bc").should == "'a\\\\''bc'"
   end
   
+  specify "should escape blobs as strings by default" do
+    @dataset.literal('abc'.to_sequel_blob).should == "'abc'"
+  end
+
   specify "should literalize numbers properly" do
     @dataset.literal(1).should == "1"
     @dataset.literal(1.5).should == "1.5"
@@ -727,13 +738,19 @@ context "Dataset#literal" do
   
   specify "should literalize Time properly" do
     t = Time.now
-    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+    s = t.strftime("'%Y-%m-%dT%H:%M:%S%z'").gsub(/(\d\d')\z/, ':\1')
+    @dataset.literal(t).should == s
+  end
+  
+  specify "should literalize DateTime properly" do
+    t = DateTime.now
+    s = t.strftime("'%Y-%m-%dT%H:%M:%S%z'").gsub(/(\d\d')\z/, ':\1')
     @dataset.literal(t).should == s
   end
   
   specify "should literalize Date properly" do
     d = Date.today
-    s = d.strftime("DATE '%Y-%m-%d'")
+    s = d.strftime("'%Y-%m-%d'")
     @dataset.literal(d).should == s
   end
   
@@ -867,6 +884,20 @@ context "Dataset#select" do
 
     @d.select(nil, 1, :x => :y).sql.should == "SELECT NULL, 1, x AS y FROM test"
   end
+
+  specify "should accept a block that yields a virtual row" do
+    @d.select{|o| o.a}.sql.should == 'SELECT a FROM test'
+    @d.select{|o| o.a(1)}.sql.should == 'SELECT a(1) FROM test'
+    @d.select{|o| o.a(1, 2)}.sql.should == 'SELECT a(1, 2) FROM test'
+    @d.select{|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT a, a(1, 2) FROM test'
+  end
+
+  specify "should merge regular arguments with argument returned from block" do
+    @d.select(:b){|o| o.a}.sql.should == 'SELECT b, a FROM test'
+    @d.select(:b, :c){|o| o.a(1)}.sql.should == 'SELECT b, c, a(1) FROM test'
+    @d.select(:b){|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT b, a, a(1, 2) FROM test'
+    @d.select(:b, :c){|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT b, c, a, a(1, 2) FROM test'
+  end
 end
 
 context "Dataset#select_all" do
@@ -898,6 +929,11 @@ context "Dataset#select_more" do
     @d.select(:a).select_more(:b).sql.should == 'SELECT a, b FROM test'
     @d.select(:a.*).select_more(:b.*).sql.should == 'SELECT a.*, b.* FROM test'
   end
+
+  specify "should accept a block that yields a virtual row" do
+    @d.select(:a).select_more{|o| o.b}.sql.should == 'SELECT a, b FROM test'
+    @d.select(:a.*).select_more(:b.*){|o| o.b(1)}.sql.should == 'SELECT a.*, b.*, b(1) FROM test'
+  end
 end
 
 context "Dataset#order" do
@@ -934,6 +970,20 @@ context "Dataset#order" do
     @dataset.order(:bah).order(nil).sql.should == 
       'SELECT * FROM test'
   end
+
+  specify "should accept a block that yields a virtual row" do
+    @dataset.order{|o| o.a}.sql.should == 'SELECT * FROM test ORDER BY a'
+    @dataset.order{|o| o.a(1)}.sql.should == 'SELECT * FROM test ORDER BY a(1)'
+    @dataset.order{|o| o.a(1, 2)}.sql.should == 'SELECT * FROM test ORDER BY a(1, 2)'
+    @dataset.order{|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY a, a(1, 2)'
+  end
+
+  specify "should merge regular arguments with argument returned from block" do
+    @dataset.order(:b){|o| o.a}.sql.should == 'SELECT * FROM test ORDER BY b, a'
+    @dataset.order(:b, :c){|o| o.a(1)}.sql.should == 'SELECT * FROM test ORDER BY b, c, a(1)'
+    @dataset.order(:b){|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY b, a, a(1, 2)'
+    @dataset.order(:b, :c){|o| [o.a, o.a(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY b, c, a, a(1, 2)'
+  end
 end
 
 context "Dataset#unfiltered" do
@@ -958,6 +1008,21 @@ context "Dataset#unordered" do
   end
 end
 
+context "Dataset#with_sql" do
+  setup do
+    @dataset = Sequel::Dataset.new(nil).from(:test)
+  end
+  
+  specify "should remove use static sql" do
+    @dataset.with_sql('SELECT 1 FROM test').sql.should == 'SELECT 1 FROM test'
+  end
+  
+  specify "should keep row_proc and transform" do
+    @dataset.with_sql('SELECT 1 FROM test').row_proc.should == @dataset.row_proc
+    @dataset.with_sql('SELECT 1 FROM test').instance_variable_get(:@transform).should == @dataset.instance_variable_get(:@transform)
+  end
+end
+
 context "Dataset#order_by" do
   setup do
     @dataset = Sequel::Dataset.new(nil).from(:test)
@@ -1003,6 +1068,11 @@ context "Dataset#order_more" do
     @dataset.order(:name).order_more(:stamp.desc).sql.should ==
       'SELECT * FROM test ORDER BY name, stamp DESC'
   end
+
+  specify "should accept a block that yields a virtual row" do
+    @dataset.order(:a).order_more{|o| o.b}.sql.should == 'SELECT * FROM test ORDER BY a, b'
+    @dataset.order(:a, :b).order_more(:c, :d){|o| [o.e, o.f(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY a, b, c, d, e, f(1, 2)'
+  end
 end
 
 context "Dataset#reverse_order" do
@@ -1186,7 +1256,7 @@ context "Dataset#uniq" do
   specify "should accept an expression list" do
     @dataset.uniq(:a, :b).sql.should == 'SELECT DISTINCT ON (a, b) name FROM test'
 
-    @dataset.uniq(:stamp.cast_as(:integer), :node_id=>nil).sql.should == 'SELECT DISTINCT ON (cast(stamp AS integer), (node_id IS NULL)) name FROM test'
+    @dataset.uniq(:stamp.cast_as(:integer), :node_id=>nil).sql.should == 'SELECT DISTINCT ON (CAST(stamp AS integer), (node_id IS NULL)) name FROM test'
   end
 
   specify "should do a subselect for count" do
@@ -1961,6 +2031,15 @@ context "Dataset#get" do
   specify "should work with aliased fields" do
     @d.get(:x__b.as(:name)).should == "SELECT x.b AS name FROM test LIMIT 1"
   end
+  
+  specify "should accept a block that yields a virtual row" do
+    @d.get{|o| o.x__b.as(:name)}.should == "SELECT x.b AS name FROM test LIMIT 1"
+    @d.get{|o| o.x(1).as(:name)}.should == "SELECT x(1) AS name FROM test LIMIT 1"
+  end
+  
+  specify "should raise an error if both a regular argument and block argument are used" do
+    proc{@d.get(:name){|o| o.x__b.as(:name)}}.should raise_error(Sequel::Error)
+  end
 end
 
 context "Dataset#set_row_proc" do
@@ -3396,32 +3475,3 @@ context "Sequel::Dataset#each" do
     end
   end
 end
-
-context Sequel::Dataset::UnsupportedIntersectExcept do
-  before do
-    @ds = Sequel::Dataset.new(nil).from(:items)
-    @ds2 = Sequel::Dataset.new(nil).from(:i)
-    @ds.extend(Sequel::Dataset::UnsupportedIntersectExcept)
-  end
-
-  specify "should raise an error if INTERSECT or EXCEPT is USED" do
-    @ds.union(@ds2).sql.should == 'SELECT * FROM items UNION SELECT * FROM i'
-    proc{@ds.intersect(@ds2)}.should raise_error(Sequel::Error)
-    proc{@ds.except(@ds2)}.should raise_error(Sequel::Error)
-  end
-end
-
-context Sequel::Dataset::UnsupportedIntersectExceptAll do
-  before do
-    @ds = Sequel::Dataset.new(nil).from(:items)
-    @ds2 = Sequel::Dataset.new(nil).from(:i)
-    @ds.extend(Sequel::Dataset::UnsupportedIntersectExceptAll)
-  end
-
-  specify "should raise an error if INTERSECT or EXCEPT is USED" do
-    @ds.intersect(@ds2).sql.should == 'SELECT * FROM items INTERSECT SELECT * FROM i'
-    @ds.except(@ds2).sql.should == 'SELECT * FROM items EXCEPT SELECT * FROM i'
-    proc{@ds.intersect(@ds2, true)}.should raise_error(Sequel::Error)
-    proc{@ds.except(@ds2, true)}.should raise_error(Sequel::Error)
-  end
-end

data/spec/sequel_core/schema_spec.rb

@@ -327,6 +327,22 @@ context "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)", "CREATE INDEX cats_name_index ON cats (name)"]
   end
   
+  specify "should accept functional indexes" do
+    @db.create_table(:cats) do
+      integer :id
+      index :lower.sql_function(:name)
+    end
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_lower_name__index ON cats (lower(name))"]
+  end
+  
+  specify "should accept indexes with identifiers" do
+    @db.create_table(:cats) do
+      integer :id
+      index :lower__name.identifier
+    end
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_lower__name_index ON cats (lower__name)"]
+  end
+  
   specify "should accept custom index names" do
     @db.create_table(:cats) do
       integer :id

data/spec/sequel_model/associations_spec.rb

@@ -15,6 +15,34 @@ describe Sequel::Model, "associate" do
     klass.association_reflection(:"par_parent1s").associated_class.should == ParParent
     klass.association_reflection(:"par_parent2s").associated_class.should == ParParent
   end
+
+  it "should add a model_object and association_reflection accessors to the dataset, and return it with the current model object" do
+    MODEL_DB.reset
+    klass = Class.new(Sequel::Model(:nodes)) do
+      columns :id, :a_id
+    end
+    mod = Module.new do
+      def blah
+       filter{|o| o.__send__(association_reflection[:key]) > model_object.id*2}
+      end
+    end
+
+    klass.associate :many_to_one, :a, :class=>klass
+    klass.associate :one_to_many, :bs, :key=>:b_id, :class=>klass, :extend=>mod
+    klass.associate :many_to_many, :cs, :class=>klass
+    
+    node = klass.load(:id=>1)
+    node.a_dataset.model_object.should == node
+    node.bs_dataset.model_object.should == node
+    node.cs_dataset.model_object.should == node
+
+    node.a_dataset.association_reflection.should == klass.association_reflection(:a)
+    node.bs_dataset.association_reflection.should == klass.association_reflection(:bs)
+    node.cs_dataset.association_reflection.should == klass.association_reflection(:cs)
+
+    node.bs_dataset.blah.sql.should == 'SELECT * FROM nodes WHERE ((nodes.b_id = 1) AND (b_id > 2))'
+  end
+
   it "should allow extending the dataset with :extend option" do
     MODEL_DB.reset
     klass = Class.new(Sequel::Model(:nodes)) do
@@ -41,6 +69,34 @@ describe Sequel::Model, "associate" do
     node.cs_dataset.blah.should == 1
     node.cs_dataset.blar.should == 2
   end
+
+  it "should clone an existing association with the :clone option" do
+    MODEL_DB.reset
+    klass = Class.new(Sequel::Model(:nodes))
+    
+    klass.many_to_one(:par_parent, :order=>:a){1}
+    klass.one_to_many(:par_parent1s, :class=>'ParParent', :limit=>12){4}
+    klass.many_to_many(:par_parent2s, :class=>:ParParent, :uniq=>true){2}
+
+    klass.many_to_one :par, :clone=>:par_parent, :select=>:b
+    klass.one_to_many :par1s, :clone=>:par_parent1s, :order=>:b, :limit=>10, :block=>nil
+    klass.many_to_many(:par2s, :clone=>:par_parent2s, :order=>:c){3}
+    
+    klass.association_reflection(:par).associated_class.should == ParParent
+    klass.association_reflection(:par1s).associated_class.should == ParParent
+    klass.association_reflection(:par2s).associated_class.should == ParParent
+    
+    klass.association_reflection(:par)[:order].should == :a
+    klass.association_reflection(:par).select.should == :b
+    klass.association_reflection(:par)[:block].call.should == 1
+    klass.association_reflection(:par1s)[:limit].should == 10
+    klass.association_reflection(:par1s)[:order].should == :b
+    klass.association_reflection(:par1s)[:block].should == nil
+    klass.association_reflection(:par2s)[:after_load].length.should == 1
+    klass.association_reflection(:par2s)[:order].should == :c
+    klass.association_reflection(:par2s)[:block].call.should == 3
+  end
+
 end
 
 describe Sequel::Model, "many_to_one" do
@@ -117,6 +173,17 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT id, name FROM nodes WHERE (nodes.id = 567) LIMIT 1"]
   end
 
+  it "should use :conditions option if given" do
+    @c2.many_to_one :parent, :class => @c2, :key => :blah, :conditions=>{:a=>32}
+    @c2.new(:id => 1, :blah => 567).parent
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 567) AND (a = 32)) LIMIT 1"]
+
+    @c2.many_to_one :parent, :class => @c2, :key => :blah, :conditions=>:a
+    MODEL_DB.sqls.clear
+    @c2.new(:id => 1, :blah => 567).parent
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 567) AND a) LIMIT 1"]
+  end
+
   it "should support :order, :limit (only for offset), and :dataset options, as well as a block" do
     c2 = @c2
     @c2.many_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{c2.filter(:parent_id=>pk)}, :limit=>[10,20], :order=>:name do |ds|
@@ -594,6 +661,15 @@ describe Sequel::Model, "one_to_many" do
     n.attributes_dataset.sql.should == "SELECT id, name FROM attributes WHERE (attributes.node_id = 1234)"
   end
   
+  it "should support a conditions option" do
+    @c2.one_to_many :attributes, :class => @c1, :conditions => {:a=>32}
+    n = @c2.new(:id => 1234)
+    n.attributes_dataset.sql.should == "SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (a = 32))"
+    @c2.one_to_many :attributes, :class => @c1, :conditions => ~:a
+    n = @c2.new(:id => 1234)
+    n.attributes_dataset.sql.should == "SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND NOT a)"
+  end
+  
   it "should support an order option" do
     @c2.one_to_many :attributes, :class => @c1, :order => :kind
 
@@ -1152,6 +1228,19 @@ describe Sequel::Model, "many_to_many" do
     a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attribute2node ON ((attribute2node.attributeid = attributes.id) AND (attribute2node.nodeid = 1234))'
   end
   
+  it "should support a conditions option" do
+    @c2.many_to_many :attributes, :class => @c1, :conditions => {:a=>32}
+    n = @c2.new(:id => 1234)
+    a = n.attributes_dataset
+    a.should be_a_kind_of(Sequel::Dataset)
+    a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (a = 32)'
+    @c2.many_to_many :attributes, :class => @c1, :conditions => ['a = ?', 32]
+    n = @c2.new(:id => 1234)
+    a = n.attributes_dataset
+    a.should be_a_kind_of(Sequel::Dataset)
+    a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (a = 32)'
+  end
+  
   it "should support an order option" do
     @c2.many_to_many :attributes, :class => @c1, :order => :blah
 

data/spec/sequel_model/base_spec.rb

@@ -417,3 +417,69 @@ describe Sequel::Model, ".strict_param_setting" do
     proc{@c.new(:z=>1)}.should_not raise_error
   end
 end
+
+describe Sequel::Model, ".[] optimization" do
+  setup do
+    @c = Class.new(Sequel::Model(:a))
+    @c.instance_eval do
+      def simple_table
+        @simple_table
+      end
+    end
+  end
+
+  it "should set simple_pk to the literalized primary key column name if a single primary key" do
+    @c.simple_pk.should == 'id'
+    @c.set_primary_key :b
+    @c.simple_pk.should == 'b'
+    @c.set_primary_key :b__a.identifier
+    @c.simple_pk.should == 'b__a'
+  end
+
+  it "should have simple_pk be blank if compound or no primary key" do
+    @c.no_primary_key
+    @c.simple_pk.should == nil
+    @c.set_primary_key :b, :a
+    @c.simple_pk.should == nil
+  end
+
+  it "should have simple table set if passed a Symbol to set_dataset" do
+    @c.set_dataset :a
+    @c.simple_table.should == 'a'
+    @c.set_dataset :b
+    @c.simple_table.should == 'b'
+    @c.set_dataset :b__a
+    @c.simple_table.should == 'b.a'
+  end
+
+  it "should have simple_table = nil if passed a dataset to set_dataset" do
+    @c.set_dataset @c.db[:a]
+    @c.simple_table.should == nil
+  end
+
+  it "should have simple_table superclasses setting if inheriting" do
+    @c.set_dataset :a
+    Class.new(@c).simple_table.should == 'a'
+    @c.instance_variable_set(:@simple_table, nil)
+    Class.new(@c).simple_table.should == nil
+    @c.instance_variable_set(:@simple_table, "'b'")
+    Class.new(@c).simple_table.should == "'b'"
+  end
+
+  it "should have simple_table = nil if inheriting and sti_key is set" do
+    @c.set_sti_key :x
+    Class.new(@c).simple_table.should == nil
+  end
+
+  it "should use Dataset#with_sql if simple_table and simple_pk are true" do
+    @c.set_dataset :a
+    @c.dataset.should_receive(:with_sql).and_return(@c.dataset)
+    @c[1]
+  end
+
+  it "should not use Dataset#with_sql if either simple_table or simple_pk is nil" do
+    @c.set_dataset @c.dataset
+    @c.dataset.should_not_receive(:with_sql)
+    @c[1]
+  end
+end

data/spec/sequel_model/eager_loading_spec.rb

@@ -328,6 +328,27 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.length.should == 2
   end
   
+  it "should respect :conditions when eagerly loading" do
+    EagerBandMember.many_to_many :good_bands, :clone=>:bands, :conditions=>{:a=>32}
+    a = EagerBandMember.eager(:good_bands).all
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(EagerBandMember)
+    a.first.values.should == {:id => 5}
+    MODEL_DB.sqls.should == ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON ((bm.band_id = bands.id) AND (bm.member_id IN (5))) WHERE (a = 32) ORDER BY id']
+    a = a.first
+    a.good_bands.should be_a_kind_of(Array)
+    a.good_bands.size.should == 1
+    a.good_bands.first.should be_a_kind_of(EagerBand)
+    a.good_bands.first.values.should == {:id => 2}
+    MODEL_DB.sqls.length.should == 2
+
+    MODEL_DB.sqls.clear
+    EagerBandMember.many_to_many :good_bands, :clone=>:bands, :conditions=>"x = 1"
+    a = EagerBandMember.eager(:good_bands).all
+    MODEL_DB.sqls.should == ['SELECT * FROM members', 'SELECT bands.*, bm.member_id AS x_foreign_key_x FROM bands INNER JOIN bm ON ((bm.band_id = bands.id) AND (bm.member_id IN (5))) WHERE (x = 1) ORDER BY id']
+  end
+  
   it "should respect :order when eagerly loading" do
     a = EagerBandMember.eager(:bands).all
     a.should be_a_kind_of(Array)
@@ -1019,6 +1040,17 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.eager_graph(:inner_genres).sql.should == 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums INNER JOIN ag ON (ag.album_id = albums.id) RIGHT OUTER JOIN genres AS inner_genres ON (inner_genres.id = ag.genre_id)'
   end
 
+  it "should respect the association's :conditions option" do 
+    GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :conditions=>{:active=>true}
+    GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON ((active_band.id = albums.band_id) AND (active_band.active = 't'))"
+
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :conditions=>{:id=>(0..100)}
+    GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON ((right_tracks.album_id = albums.id) AND ((right_tracks.id >= 0) AND (right_tracks.id <= 100)))'
+
+    GraphAlbum.many_to_many :active_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :conditions=>{true=>:active}
+    GraphAlbum.eager_graph(:active_genres).sql.should == "SELECT albums.id, albums.band_id, active_genres.id AS active_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS active_genres ON ((active_genres.id = ag.genre_id) AND ('t' = ag.active))"
+  end
+
   it "should respect the association's :graph_conditions option" do 
     GraphAlbum.many_to_one :active_band, :class=>'GraphBand', :key=>:band_id, :graph_conditions=>{:active=>true}
     GraphAlbum.eager_graph(:active_band).sql.should == "SELECT albums.id, albums.band_id, active_band.id AS active_band_id, active_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS active_band ON ((active_band.id = albums.band_id) AND (active_band.active = 't'))"