sequel 4.13.0 → 4.14.0

data/lib/sequel/plugins/xml_serializer.rb

@@ -12,50 +12,50 @@ module Sequel
     #   album = Album[1]
     #   puts album.to_xml
     #   # Output:
-    #   <?xml version="1.0"?>
-    #   <album>
-    #     <id>1</id>
-    #     <name>RF</name>
-    #     <artist_id>2</artist_id>
-    #   </album>
+    #   # <?xml version="1.0"?>
+    #   # <album>
+    #   #   <id>1</id>
+    #   #   <name>RF</name>
+    #   #   <artist_id>2</artist_id>
+    #   # </album>
     #
     # You can provide options to control the XML output:
     #
     #   puts album.to_xml(:only=>:name)
     #   puts album.to_xml(:except=>[:id, :artist_id])
     #   # Output:
-    #   <?xml version="1.0"?>
-    #   <album>
-    #     <name>RF</name>
-    #   </album>
+    #   # <?xml version="1.0"?>
+    #   # <album>
+    #   #   <name>RF</name>
+    #   # </album>
     #
     #   album.to_xml(:include=>:artist)
     #   # Output:
-    #   <?xml version="1.0"?>
-    #   <album>
-    #     <id>1</id>
-    #     <name>RF</name>
-    #     <artist_id>2</artist_id>
-    #     <artist>
-    #       <id>2</id>
-    #       <name>YJM</name>
-    #     </artist>
-    #   </album>
+    #   # <?xml version="1.0"?>
+    #   # <album>
+    #   #   <id>1</id>
+    #   #   <name>RF</name>
+    #   #   <artist_id>2</artist_id>
+    #   #   <artist>
+    #   #     <id>2</id>
+    #   #     <name>YJM</name>
+    #   #   </artist>
+    #   # </album>
     # 
     # You can use a hash value with <tt>:include</tt> to pass options
     # to associations:
     #
     #   album.to_xml(:include=>{:artist=>{:only=>:name}})
     #   # Output:
-    #   <?xml version="1.0"?>
-    #   <album>
-    #     <id>1</id>
-    #     <name>RF</name>
-    #     <artist_id>2</artist_id>
-    #     <artist>
-    #       <name>YJM</name>
-    #     </artist>
-    #   </album>
+    #   # <?xml version="1.0"?>
+    #   # <album>
+    #   #   <id>1</id>
+    #   #   <name>RF</name>
+    #   #   <artist_id>2</artist_id>
+    #   #   <artist>
+    #   #     <name>YJM</name>
+    #   #   </artist>
+    #   # </album>
     #
     # +to_xml+ also exists as a class and dataset method, both
     # of which return all objects in the dataset:

data/lib/sequel/sql.rb

@@ -909,7 +909,7 @@ module Sequel
       # Return a +StringExpression+ representing the concatenation of the receiver
       # with the given argument.
       #
-      #   :x.sql_string + :y => # "x" || "y"
+      #   :x.sql_string + :y # => "x" || "y"
       def +(ce)
         StringExpression.new(:'||', self, ce)
       end
@@ -984,14 +984,14 @@ module Sequel
       # and converts it to a +BooleanExpression+.  The operator and args
       # used depends on the case of the right (2nd) argument:
       #
-      # * 0..10 - left >= 0 AND left <= 10
-      # * [1,2] - left IN (1,2)
-      # * nil - left IS NULL
-      # * true - left IS TRUE 
-      # * false - left IS FALSE 
-      # * /as/ - left ~ 'as'
-      # * :blah - left = blah
-      # * 'blah' - left = 'blah'
+      # 0..10 :: left >= 0 AND left <= 10
+      # [1,2] :: left IN (1,2)
+      # nil :: left IS NULL
+      # true :: left IS TRUE 
+      # false :: left IS FALSE 
+      # /as/ :: left ~ 'as'
+      # :blah :: left = blah
+      # 'blah' :: left = 'blah'
       #
       # If multiple arguments are given, they are joined with the op given (AND
       # by default, OR possible).  If negate is set to true,
@@ -1022,7 +1022,7 @@ module Sequel
         when Regexp
           StringExpression.like(l, r)
         when DelayedEvaluation
-          Sequel.delay{from_value_pair(l, r.callable.call)}
+          Sequel.delay{|ds| from_value_pair(l, r.call(ds))}
         when Dataset::PlaceholderLiteralizer::Argument
           r.transform{|v| from_value_pair(l, v)}
         else
@@ -1220,7 +1220,18 @@ module Sequel
         @callable = callable
       end
 
-      to_s_method :delayed_evaluation_sql, '@callable'
+      # Call the underlying callable and return the result.  If the
+      # underlying callable only accepts a single argument, call it
+      # with the given dataset.
+      def call(ds)
+        if @callable.respond_to?(:arity) && @callable.arity == 1
+          @callable.call(ds)
+        else
+          @callable.call
+        end
+      end
+
+      to_s_method :delayed_evaluation_sql
     end
 
     # Represents an SQL function call.

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 13
+  MINOR = 14
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -1533,6 +1533,16 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
     @d.send(:drop_trigger_sql, :test, :identity, :if_exists=>true, :cascade=>true).should == 'DROP TRIGGER IF EXISTS identity ON "test" CASCADE'
     # Make sure if exists works
     @d.drop_trigger(:test, :identity, :if_exists=>true, :cascade=>true)
+
+    if @d.supports_trigger_conditions?
+      @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true, :when=> {:new__name => 'b'}).should == %q{CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON "test" FOR EACH ROW WHEN ("new"."name" = 'b') EXECUTE PROCEDURE tf()}
+      @d.create_trigger(:test, :identity, :tf, :each_row=>true, :events => :update, :when=> {:new__name => 'b'})
+      proc{@d[:test].filter(:name=>'a').update(:value=>nil)}.should_not raise_error
+      @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>nil}]
+      proc{@d[:test].filter(:name=>'a').update(:name=>'b')}.should raise_error(Sequel::DatabaseError)
+      @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>nil}]
+      @d.drop_trigger(:test, :identity)
+    end
   end
 end
 

data/spec/core/database_spec.rb

@@ -720,16 +720,15 @@ shared_examples_for "Database#transaction" do
     @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'ROLLBACK']
   end
   
-  specify "should handle errors when sending ROLLBACK" do
+  specify "should raise original exception if there is an exception raised when rolling back" do
     ec = Class.new(StandardError)
     meta_def(@db, :database_error_classes){[ec]}
     meta_def(@db, :log_connection_execute){|c, sql| sql =~ /ROLLBACK/ ? raise(ec, 'bad') : super(c, sql)}
     begin
       @db.transaction{raise ArgumentError, 'asdf'}
-    rescue Sequel::DatabaseError => e
+    rescue => e
     end
-    e.should_not be_nil
-    e.wrapped_exception.should be_a_kind_of(ec)
+    e.should be_a_kind_of(ArgumentError)
     @db.sqls.should == ['BEGIN']
   end
   

data/spec/core/dataset_spec.rb

@@ -593,8 +593,18 @@ describe "Dataset#where" do
       "SELECT * FROM test WHERE (((name < 'b') AND (table.id = 1)) OR is_active(blah, xx, x.y_z))"
   end
 
-  specify "should raise an error if an invalid argument is used" do
+  specify "should handle arbitrary objects" do
+    o = Object.new
+    def o.sql_literal(ds)
+      "foo"
+    end
+    @dataset.filter(o).sql.should == 'SELECT * FROM test WHERE foo'
+  end
+
+  specify "should raise an error if an numeric is used" do
     proc{@dataset.filter(1)}.should raise_error(Sequel::Error)
+    proc{@dataset.filter(1.0)}.should raise_error(Sequel::Error)
+    proc{@dataset.filter(BigDecimal.new('1.0'))}.should raise_error(Sequel::Error)
   end
 
   specify "should raise an error if a NumericExpression or StringExpression is used" do
@@ -3707,6 +3717,11 @@ describe "Sequel::Dataset#qualify" do
     ds.sql.should == 'SELECT t.* FROM t WHERE t.b'
   end
 
+  specify "should handle SQL::DelayedEvaluations that take dataset arguments" do
+    ds = @ds.filter(Sequel.delay{|ds| ds.first_source}).qualify
+    ds.sql.should == 'SELECT t.* FROM t WHERE t.t'
+  end
+
   specify "should handle all other objects by returning them unchanged" do
     @ds.select("a").filter{a(3)}.filter('blah').order(Sequel.lit('true')).group(Sequel.lit('a > ?', 1)).having(false).qualify.sql.should == "SELECT 'a' FROM t WHERE (a(3) AND (blah)) GROUP BY a > 1 HAVING 'f' ORDER BY true"
   end

data/spec/core/expression_filters_spec.rb

@@ -1116,6 +1116,12 @@ describe "Sequel.delay" do
     @o._a.should == 2
   end
 
+  specify "should call the block with the current dataset if it accepts one argument" do
+    ds = Sequel.mock[:b].where(Sequel.delay{|ds| ds.first_source})
+    ds.sql.should == "SELECT * FROM b WHERE b"
+    ds.from(:c).sql.should == "SELECT * FROM c WHERE c"
+  end
+
   specify "should have the condition specifier handling respect delayed evaluations" do
     ds = Sequel.mock[:b].where(:a=>Sequel.delay{@o.b})
     ds.sql.should == "SELECT * FROM b WHERE (a IS NULL)"
@@ -1125,6 +1131,12 @@ describe "Sequel.delay" do
     ds.sql.should == "SELECT * FROM b WHERE (a IN (1, 2))"
   end
 
+  specify "should have the condition specifier handling call block with the current dataset if it accepts one argument" do
+    ds = Sequel.mock[:b].where(:a=>Sequel.delay{|ds| ds.first_source})
+    ds.sql.should == "SELECT * FROM b WHERE (a = b)"
+    ds.from(:c).sql.should == "SELECT * FROM c WHERE (a = c)"
+  end
+
   specify "should raise if called without a block" do
     proc{Sequel.delay}.should raise_error(Sequel::Error)
   end

data/spec/core/object_graph_spec.rb

@@ -171,6 +171,11 @@ describe Sequel::Dataset, "graphing" do
       ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points INNER JOIN lines ON (lines.x = points.id)'
     end
 
+    it "should accept a :join_only option" do
+      ds = @ds1.graph(:lines, {:x=>:id}, :join_only=>true)
+      ds.sql.should == 'SELECT * FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    end
+
     it "should not select any columns from the graphed table if :select option is false" do
       ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
       ds.sql.should == 'SELECT points.id, points.x, points.y, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN graphs ON (graphs.id = lines.graph_id)'

data/spec/core/placeholder_literalizer_spec.rb

@@ -41,6 +41,14 @@ describe "Dataset::PlaceholderLiteralizer" do
     @db.sqls.should == ["SELECT s FROM items WHERE ((a = 1) AND (b = (c + 1)) AND (id = 1)) HAVING h", "SELECT s2 FROM items WHERE ((a = 2) AND (b = (d + 1)) AND (id = 2)) HAVING h2"]
   end
   
+  specify "should handle calls with placeholders and delayed arguments that take dataset argument" do
+    d = @ds.select(Sequel.delay{|ds| ds.first_source})
+    loader = @c.loader(d){|pl, ds| ds.where(:a=>pl.arg).where(:b=>Sequel.+(pl.arg, 1)).where(pl.arg)}
+    loader.first(1, :c, :id=>1).should == @h
+    loader.first(2, :d, :id=>2).should == @h
+    @db.sqls.should == ["SELECT items FROM items WHERE ((a = 1) AND (b = (c + 1)) AND (id = 1))", "SELECT items FROM items WHERE ((a = 2) AND (b = (d + 1)) AND (id = 2))"]
+  end
+  
   specify "should handle calls with a placeholders used as filter arguments" do
     loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
     loader.first(:id=>1).should == @h

data/spec/extensions/caching_spec.rb

@@ -249,4 +249,22 @@ describe Sequel::Model, "caching" do
     @c.cache_delete_pk(1).should == nil
     @c.cache_get_pk(1).should == nil
   end
+
+  it "should support overriding the cache key prefix" do
+    c2 = Class.new(@c)
+    def c2.cache_key_prefix; "ceetwo" end
+    c3 = Class.new(c2)
+    @c.cache_key(:id).should_not == c2.cache_key(:id)
+    c2.cache_key(:id).should == c3.cache_key(:id)
+    
+    @c[1]
+    c2.cache_get_pk(1).should == nil
+    m = c2[1]
+    c2.cache_get_pk(1).values.should == @c[1].values
+    c3.cache_get_pk(1).values.should == m.values
+
+    m.name << m.name
+    m.save
+    c2[1].values.should == c3[1].values
+  end
 end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -78,6 +78,17 @@ describe "class_table_inheritance plugin" do
     Manager.all.collect{|x| x.class}.should == [Manager, Executive]
   end
   
+  it "should have refresh return all columns in subclass after loading from superclass" do
+    Employee.dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Executive'}]
+    Executive.instance_dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Executive', :num_staff=>3, :num_managers=>2}]
+    a = Employee.first
+    a.class.should == Executive
+    a.values.should == {:id=>1, :name=>'A', :kind=>'Executive'}
+    a.refresh.values.should == {:id=>1, :name=>'A', :kind=>'Executive', :num_staff=>3, :num_managers=>2}
+    @db.sqls.should == ["SELECT employees.id, employees.name, employees.kind FROM employees LIMIT 1",
+      "SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id = 1) LIMIT 1"]
+  end
+  
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance)
     Employee.dataset._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
@@ -171,6 +182,29 @@ describe "class_table_inheritance plugin" do
     m.values.should == {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2, :num_managers=>3}
   end
 
+  it "should lazily load columns in middle classes correctly when loaded from parent class" do
+    Employee.dataset._fetch = {:id=>1, :kind=>'Executive'}
+    Manager.dataset._fetch = {:num_staff=>2}
+    e = Employee[1]
+    e.should be_a_kind_of(Executive)
+    @db.sqls.should == ["SELECT employees.id, employees.name, employees.kind FROM employees WHERE (id = 1) LIMIT 1"]
+    e.num_staff.should == 2
+    @db.sqls.should == ["SELECT managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1"]
+  end
+
+  it "should eagerly load lazily columns in subclasses when loaded from parent class" do
+    Employee.dataset._fetch = {:id=>1, :kind=>'Executive'}
+    Manager.dataset._fetch = {:id=>1, :num_staff=>2}
+    Executive.dataset._fetch = {:id=>1, :num_managers=>3}
+    e = Employee.all.first
+    e.should be_a_kind_of(Executive)
+    @db.sqls.should == ["SELECT employees.id, employees.name, employees.kind FROM employees"]
+    e.num_staff#.should == 2
+    @db.sqls.should == ["SELECT managers.id, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id IN (1))"]
+    e.num_managers#.should == 3
+    @db.sqls.should == ['SELECT executives.id, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id IN (1))']
+  end
+  
   it "should include schema for columns for tables for ancestor classes" do
     Employee.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}}
     Manager.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer}}

data/spec/extensions/many_through_many_spec.rb

@@ -872,6 +872,10 @@ describe "many_through_many eager loading methods" do
     @c1.association_join(:tags).sql.should == "SELECT * FROM artists INNER JOIN albums_artists ON (albums_artists.artist_id = artists.id) INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id)"
   end
 
+  it "should support custom selects when using association_join" do
+    @c1.select{a(b)}.association_join(:tags).sql.should == "SELECT a(b) FROM artists INNER JOIN albums_artists ON (albums_artists.artist_id = artists.id) INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id)"
+  end
+
   it "should eagerly graph a single many_through_many association" do
     a = @c1.eager_graph(:tags).all
     a.should == [@c1.load(:id=>1)]

data/spec/extensions/nested_attributes_spec.rb

@@ -36,12 +36,16 @@ describe "NestedAttributes plugin" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
     @Artist.one_to_many :concerts, :class=>@Concert, :key=>:artist_id
     @Artist.one_to_one :first_album, :class=>@Album, :key=>:artist_id
+    @Artist.one_to_one :first_concert, :class=>@Concert, :key=>:artist_id
+    @Concert.one_to_many :albums, :class=>@Album, :key=>:artist_id, :primary_key=>:artist_id
     @Album.many_to_one :artist, :class=>@Artist, :reciprocal=>:albums
     @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
     @Tag.many_to_many :albums, :class=>@Album, :left_key=>:tag_id, :right_key=>:album_id, :join_table=>:at
     @Artist.nested_attributes :albums, :first_album, :destroy=>true, :remove=>true
     @Artist.nested_attributes :concerts, :destroy=>true, :remove=>true
     @Album.nested_attributes :artist, :tags, :destroy=>true, :remove=>true
+    @Artist.nested_attributes :first_concert
+    @Concert.nested_attributes :albums
     @db.sqls
   end
   
@@ -76,7 +80,7 @@ describe "NestedAttributes plugin" do
     @Album.class_eval do
       plugin :validation_helpers
       def validate
-        validates_presence :artist_id
+        validates_integer :artist_id
         super
       end
     end
@@ -96,6 +100,55 @@ describe "NestedAttributes plugin" do
       ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
   end
 
+  it "should support creating new one_to_many and one_to_one objects with composite keys with presence validations on the foreign key" do
+    insert = nil
+    @Album.class_eval do
+      plugin :validation_helpers
+      def validate
+        validates_integer :artist_id
+        super
+      end
+    end
+    @Concert.class_eval do
+      define_method :_insert do
+        insert = values.dup
+      end
+      def before_create # Have to define the CPK somehow.
+        self.tour = 'To'
+        self.date = '2004-04-05'
+        super
+      end
+      def after_create
+        super
+        self.artist_id = 3
+      end
+    end
+
+    c = @Concert.new(:playlist=>'Pl')
+    @db.sqls.should == []
+    c.albums_attributes = [{:name=>'Al'}]
+    c.save
+    insert.should == {:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl'}
+    check_sql_array(["INSERT INTO albums (name, artist_id) VALUES ('Al', 3)", "INSERT INTO albums (artist_id, name) VALUES (3, 'Al')"])
+
+    @Concert.class_eval do
+      plugin :validation_helpers
+      def validate
+        validates_integer :artist_id
+        super
+      end
+    end
+
+    a = @Artist.new(:name=>'Ar')
+    a.id = 1
+    a.first_concert_attributes = {:playlist=>'Pl'}
+    @db.sqls.should == []
+    a.save
+    check_sql_array(["INSERT INTO artists (name, id) VALUES ('Ar', 1)", "INSERT INTO artists (id, name) VALUES (1, 'Ar')"],
+                   "UPDATE concerts SET artist_id = NULL WHERE (artist_id = 1)")
+    insert.should == {:tour=>'To', :date=>'2004-04-05', :artist_id=>1, :playlist=>'Pl'}
+  end
+
   it "should should not remove existing values from object when validating" do
     @Artist.one_to_one :first_album, :class=>@Album, :key=>:id
     @Artist.nested_attributes :first_album
@@ -130,7 +183,7 @@ describe "NestedAttributes plugin" do
     insert = nil
     @Concert.class_eval do
       define_method :_insert do
-        insert = values
+        insert = values.dup
       end
       def before_create # Have to define the CPK somehow.
         self.tour = 'To'
@@ -151,7 +204,7 @@ describe "NestedAttributes plugin" do
     @Album.class_eval do
       unrestrict_primary_key
       define_method :_insert do
-        insert = values
+        insert = values.dup
       end
     end
     a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:id=>7, :name=>'Al'}]})
@@ -166,7 +219,7 @@ describe "NestedAttributes plugin" do
     @Artist.nested_attributes :concerts, :unmatched_pk=>:create
     @Concert.class_eval do
       define_method :_insert do
-        insert = values
+        insert = values.dup
       end
     end
     a = @Artist.new({:name=>'Ar', :concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl'}]})
@@ -271,6 +324,7 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>10, :_remove=>'t'}])
+    ar.associations[:albums].should == []
     @db.sqls.should == []
     @Album.dataset._fetch = {:id=>1}
     ar.save
@@ -284,6 +338,7 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set(:tags_attributes=>[{:id=>20, :_remove=>true}])
+    a.associations[:tags].should == []
     @db.sqls.should == []
     a.save
     @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)"]