sequel 4.6.0 → 4.7.0

data/lib/sequel/plugins/update_or_create.rb

@@ -0,0 +1,60 @@
+module Sequel
+  module Plugins
+    # The update_or_create plugin adds a couple of methods that make it easier
+    # to deal with objects which may or may not yet exist in the database.
+    # The first method is update_or_create, which updates an object if it
+    # exists in the database, or creates the object if it does not.
+    #
+    # You can call create_or_update with a block:
+    #
+    #   Album.update_or_create(:name=>'Hello') do |album|
+    #     album.num_copies_sold = 1000
+    #   end
+    #
+    # or provide two hashes, with the second one being the attributes
+    # to set.
+    #
+    #   Album.update_or_create({:name=>'Hello'}, {:num_copies_sold=>1000})
+    #
+    # In both cases, this will check the database to find the album with
+    # the name "Hello". If such an album exists, it will be updated to set
+    # num_copies_sold to 1000.  If no such album exists, an album with the
+    # name "Hello" and num_copies_sold 1000 will be created.
+    #
+    # The second method is find_or_new, which returns the object from the
+    # database if it exists, or returns a new (unsaved) object if not. It
+    # has the same API as update_or_create, and operates identically to
+    # update_or_create except that it doesn't persist any changes.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass support update_or_create
+    #   Sequel::Model.plugin :update_or_create
+    #
+    #   # Make the Album class support update_or_create
+    #   Album.plugin :update_or_create
+    module UpdateOrCreate
+      module ClassMethods
+        # Attempt to find an record with the +attrs+, which should be a
+        # hash with column symbol keys.  If such an record exists, update it
+        # with the values given in +set_attrs+.  If no such record exists,
+        # create a new record with the columns specified by both +attrs+ and
+        # +set_attrs+, with the ones in +set_attrs+ taking priority.  If
+        # a block is given, the object is yielded to the block before the
+        # object is saved.
+        def update_or_create(attrs, set_attrs=nil, &block)
+          find_or_new(attrs, set_attrs, &block).save_changes
+        end
+
+        # Operates the same as +update_or_create+, but returns the objects
+        # without persisting changes (no UPDATE/INSERT queries).
+        def find_or_new(attrs, set_attrs=nil, &block)
+          obj = find(attrs) || new(attrs)
+          obj.set(set_attrs) if set_attrs
+          yield obj if block_given?
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_helpers.rb

@@ -202,6 +202,8 @@ module Sequel
         # since it can deal with a grouping of multiple attributes.
         #
         # Possible Options:
+        # :dataset :: The base dataset to use for the unique query, defaults to the
+        #             model's dataset.
         # :message :: The message to use (default: 'is already taken')
         # :only_if_modified :: Only check the uniqueness if the object is new or
         #                      one of the columns has been modified.
@@ -231,12 +233,13 @@ module Sequel
             arr = Array(a)
             next if arr.any?{|x| errors.on(x)}
             next if opts[:only_if_modified] && !new? && !arr.any?{|x| changed_columns.include?(x)}
+            ds = opts[:dataset] || model.dataset
             ds = if where
-              where.call(model.dataset, self, arr)
+              where.call(ds, self, arr)
             else
               vals = arr.map{|x| send(x)}
               next if vals.any?{|v| v.nil?}
-              model.where(arr.zip(vals))
+              ds.where(arr.zip(vals))
             end
             ds = yield(ds) if block_given?
             ds = ds.exclude(pk_hash) unless new?

data/lib/sequel/sql.rb

@@ -48,6 +48,17 @@ module Sequel
       t = now
       local(t.year, t.month, t.day, hour, minute, second, usec)
     end
+
+    # Return a string in HH:MM:SS format representing the time.
+    def to_s(*args)
+      if args.empty?
+        strftime('%H:%M:%S')
+      else
+        # Superclass may have defined a method that takes a format string,
+        # and we shouldn't override in that case.
+        super
+      end
+    end
   end
 
   # The SQL module holds classes whose instances represent SQL fragments.
@@ -1200,6 +1211,10 @@ module Sequel
 
     # Represents an SQL function call.
     class Function < GenericExpression
+      WILDCARD = LiteralString.new('*').freeze
+      DISTINCT = ["DISTINCT ".freeze].freeze
+      COMMA_ARRAY = [LiteralString.new(', ').freeze].freeze
+
       # The SQL function to call
       attr_reader :f
       
@@ -1211,6 +1226,28 @@ module Sequel
         @f, @args = f, args
       end
 
+      # If no arguments are given, return a new function with the wildcard prepended to the arguments.
+      #
+      #   Sequel.function(:count).*  # count(*)
+      #   Sequel.function(:count, 1).*  # count(*, 1)
+      def *(ce=(arg=false;nil))
+        if arg == false
+          Function.new(f, WILDCARD, *args)
+        else
+          super(ce)
+        end
+      end
+
+      # Return a new function with DISTINCT before the method arguments.
+      def distinct
+        Function.new(f, PlaceholderLiteralString.new(DISTINCT + COMMA_ARRAY * (args.length-1), args))
+      end
+
+      # Create a WindowFunction using the receiver and the appropriate options for the window.
+      def over(opts=OPTS)
+        WindowFunction.new(self, Window.new(opts))
+      end
+
       to_s_method :function_sql
     end
 
@@ -1245,6 +1282,12 @@ module Sequel
       def initialize(value)
         @value = value
       end
+
+      # Create a Function using this identifier as the functions name, with
+      # the given args.
+      def function(*args)
+        Function.new(self, *args)
+      end
       
       to_s_method :quote_identifier, '@value'
     end
@@ -1399,6 +1442,12 @@ module Sequel
         @table, @column = table, column
       end
       
+      # Create a Function using this identifier as the functions name, with
+      # the given args.
+      def function(*args)
+        Function.new(self, *args)
+      end
+      
       to_s_method :qualified_identifier_sql, "@table, @column"
     end
     
@@ -1584,12 +1633,8 @@ module Sequel
     #
     # For a more detailed explanation, see the {Virtual Rows guide}[rdoc-ref:doc/virtual_rows.rdoc].
     class VirtualRow < BasicObject
-      WILDCARD = LiteralString.new('*').freeze
       QUESTION_MARK = LiteralString.new('?').freeze
-      COMMA_SEPARATOR = LiteralString.new(', ').freeze
       DOUBLE_UNDERSCORE = '__'.freeze
-      DISTINCT = ["DISTINCT ".freeze].freeze
-      COMMA_ARRAY = [COMMA_SEPARATOR].freeze
 
       include OperatorBuilders
 
@@ -1616,13 +1661,14 @@ module Sequel
           else
             case args.shift
             when :*
-              Function.new(m, WILDCARD)
+              Function.new(m, *args).*
             when :distinct
-              Function.new(m, PlaceholderLiteralString.new(DISTINCT + COMMA_ARRAY * (args.length-1), args))
+              Function.new(m, *args).distinct
             when :over
-              opts = args.shift || {}
-              fun_args = ::Kernel.Array(opts[:*] ? WILDCARD : opts[:args])
-              WindowFunction.new(Function.new(m, *fun_args), Window.new(opts))
+              opts = args.shift || OPTS
+              f = Function.new(m, *::Kernel.Array(opts[:args]))
+              f = f.* if opts[:*]
+              f.over(opts)
             else
               Kernel.raise(Error, 'unsupported VirtualRow method argument used with block')
             end

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 = 6
+  MINOR = 7
   # 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

@@ -170,6 +170,16 @@ describe "A PostgreSQL database" do
     @db.server_version.should > 70000
   end
 
+  specify "should support functions with and without quoting" do
+    ds = @db[:public__testfk]
+    ds.insert
+    ds.get{sum(1)}.should == 1
+    ds.get{Sequel.function('pg_catalog.sum', 1)}.should == 1
+    ds.get{sum.function(1)}.should == 1
+    ds.get{pg_catalog__sum.function(1)}.should == 1
+    ds.delete
+  end
+
   specify "should support a :qualify option to tables and views" do
     @db.tables(:qualify=>true).should include(Sequel.qualify(:public, :testfk))
     begin
@@ -1345,13 +1355,13 @@ if DB.dataset.supports_window_functions?
     end
 
     specify "should give correct results for window functions" do
-      @ds.window(:win, :partition=>:group_id, :order=>:id).select(:id){sum(:over, :args=>amount, :window=>win){}}.all.should ==
+      @ds.window(:win, :partition=>:group_id, :order=>:id).select(:id){sum(:amount).over(:window=>win)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.window(:win, :partition=>:group_id).select(:id){sum(:over, :args=>amount, :window=>win, :order=>id){}}.all.should ==
+      @ds.window(:win, :partition=>:group_id).select(:id){sum(:amount).over(:window=>win, :order=>id)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.window(:win, {}).select(:id){sum(:over, :args=>amount, :window=>:win, :order=>id){}}.all.should ==
+      @ds.window(:win, {}).select(:id){sum(:amount).over(:window=>:win, :order=>id)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
-      @ds.window(:win, :partition=>:group_id).select(:id){sum(:over, :args=>amount, :window=>:win, :order=>id, :frame=>:all){}}.all.should ==
+      @ds.window(:win, :partition=>:group_id).select(:id){sum(:amount).over(:window=>:win, :order=>id, :frame=>:all)}.all.should ==
         [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
     end
   end
@@ -1456,6 +1466,17 @@ if DB.adapter_scheme == :postgres
       @ds.all.should == @ds.use_cursor.all
     end
 
+    specify "should not swallow errors if closing cursor raises an error" do
+      proc do
+        @db.synchronize do |c|
+          @ds.use_cursor.each do |r|
+            @db.run "CLOSE sequel_cursor"
+            raise ArgumentError
+          end
+        end
+      end.should raise_error(ArgumentError)
+    end
+
     specify "should respect the :rows_per_fetch option" do
       @db.sqls.clear
       @ds.use_cursor.all

data/spec/core/database_spec.rb

@@ -825,7 +825,7 @@ shared_examples_for "Database#transaction" do
     @db.sqls.should == ['BEGIN', 'BEGIN -- test', 'DROP TABLE test;', 'COMMIT -- test', 'COMMIT']
   end
   
-  if (!defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or RUBY_ENGINE == 'rbx') and RUBY_VERSION < '1.9'
+  if (!defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or RUBY_ENGINE == 'rbx') and !RUBY_VERSION.start_with?('1.9')
     specify "should handle Thread#kill for transactions inside threads" do
       q = Queue.new
       q1 = Queue.new

data/spec/core/dataset_spec.rb

@@ -3582,7 +3582,7 @@ describe "Sequel::Dataset#qualify" do
 
   specify "should handle SQL::WindowFunctions" do
     meta_def(@ds, :supports_window_functions?){true}
-    @ds.select{sum(:over, :args=>:a, :partition=>:b, :order=>:c){}}.qualify.sql.should == 'SELECT sum(t.a) OVER (PARTITION BY t.b ORDER BY t.c) FROM t'
+    @ds.select{sum(:a).over(:partition=>:b, :order=>:c)}.qualify.sql.should == 'SELECT sum(t.a) OVER (PARTITION BY t.b ORDER BY t.c) FROM t'
   end
 
   specify "should handle SQL::DelayedEvaluation" do

data/spec/core/expression_filters_spec.rb

@@ -419,8 +419,15 @@ describe Sequel::SQL::VirtualRow do
     @d.l{version{}}.should == 'version()'
   end
 
-  it "should treat methods with a block and a leading argument :* as a function call with the SQL wildcard" do
+  it "should treat methods with a block and a leading argument :* as a function call starting with the SQL wildcard" do
     @d.l{count(:*){}}.should == 'count(*)'
+    @d.l{count(:*, 1){}}.should == 'count(*, 1)'
+  end
+
+  it "should support * method on functions to add * as the first argument" do
+    @d.l{count{}.*}.should == 'count(*)'
+    @d.l{count(1).*}.should == 'count(*, 1)'
+    @d.literal(Sequel.expr{count(1) * 2}).should == '(count(1) * 2)'
   end
 
   it "should treat methods with a block and a leading argument :distinct as a function call with DISTINCT and the additional method arguments" do
@@ -428,6 +435,11 @@ describe Sequel::SQL::VirtualRow do
     @d.l{count(:distinct, column1, column2){}}.should == 'count(DISTINCT "column1", "column2")'
   end
 
+  it "should support distinct methods on functions to use DISTINCT before the arguments" do
+    @d.l{count(column1).distinct}.should == 'count(DISTINCT "column1")'
+    @d.l{count(column1, column2).distinct}.should == 'count(DISTINCT "column1", "column2")'
+  end
+
   it "should raise an error if an unsupported argument is used with a block" do
     proc{@d.where{count(:blah){}}}.should raise_error(Sequel::Error)
   end
@@ -479,6 +491,11 @@ describe Sequel::SQL::VirtualRow do
     @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.should == 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
   end
 
+  it "should support over method on functions to create window functions" do
+    @d.l{rank{}.over}.should == 'rank() OVER ()'
+    @d.l{sum(c).over(:partition=>a, :order=>b, :window=>:win, :frame=>:rows)}.should == 'sum("c") OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
+  end
+
   it "should raise an error if window functions are not supported" do
     class << @d; remove_method :supports_window_functions? end
     meta_def(@d, :supports_window_functions?){false}
@@ -486,6 +503,25 @@ describe Sequel::SQL::VirtualRow do
     proc{Sequel.mock.dataset.filter{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.sql}.should raise_error(Sequel::Error)
   end
   
+  it "should support function method on identifiers to create functions" do
+    @d.l{rank.function}.should == 'rank()' 
+    @d.l{sum.function(c)}.should == 'sum("c")'
+    @d.l{sum.function(c, 1)}.should == 'sum("c", 1)'
+  end
+
+  it "should support function method on qualified identifiers to create functions" do
+    @d.l{sch__rank.function}.should == 'sch.rank()' 
+    @d.l{sch__sum.function(c)}.should == 'sch.sum("c")'
+    @d.l{sch__sum.function(c, 1)}.should == 'sch.sum("c", 1)'
+    @d.l{Sequel.qualify(sch__sum, :x__y).function(c, 1)}.should == 'sch.sum.x.y("c", 1)'
+  end
+
+  it "should handle quoted function names" do
+    def @d.supports_quoted_function_names?; true; end
+    @d.l{rank.function}.should == '"rank"()' 
+    @d.l{sch__rank.function}.should == '"sch"."rank"()' 
+  end
+
   it "should deal with classes without requiring :: prefix" do
     @d.l{date < Date.today}.should == "(\"date\" < '#{Date.today}')"
     @d.l{date < Sequel::CURRENT_DATE}.should == "(\"date\" < CURRENT_DATE)"
@@ -903,6 +939,22 @@ describe "Sequel::SQLTime" do
     @db.literal(Sequel::SQLTime.create(1, 2, 3)).should == "'01:02:03.000000'"
     @db.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).should == "'01:02:03.500000'"
   end
+
+  specify "#to_s should include hour, minute, and second by default" do
+    Sequel::SQLTime.create(1, 2, 3).to_s.should == "01:02:03"
+    Sequel::SQLTime.create(1, 2, 3, 500000).to_s.should == "01:02:03"
+  end
+
+  specify "#to_s should handle arguments with super" do
+    t = Sequel::SQLTime.create(1, 2, 3)
+    begin
+      Time.now.to_s('%F')
+    rescue
+      proc{t.to_s('%F')}.should raise_error
+    else
+      proc{t.to_s('%F')}.should_not raise_error
+    end
+  end
 end
 
 describe "Sequel::SQL::Wrapper" do

data/spec/extensions/auto_validations_spec.rb

@@ -106,6 +106,24 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.errors.should == {[:name, :num]=>["is already taken"]}
   end
 
+  it "should work correctly in STI subclasses" do
+    @c.plugin(:single_table_inheritance, :num, :model_map=>{1=>@c}, :key_map=>proc{[1, 2]})
+    sc = Class.new(@c)
+    @m = sc.new
+    @m.valid?.should == false
+    @m.errors.should == {:d=>["is not present"], :name=>["is not present"]}
+
+    @m.set(:d=>'/', :num=>'a', :name=>'1')
+    @m.valid?.should == false
+    @m.errors.should == {:d=>["is not a valid date"], :num=>["is not a valid integer"]}
+
+    @m.db.sqls
+    @m.set(:d=>Date.today, :num=>1)
+    @m.valid?.should == false
+    @m.errors.should == {[:name, :num]=>["is already taken"]}
+    @m.db.sqls.should == ["SELECT count(*) AS count FROM test WHERE ((name = '1') AND (num = 1)) LIMIT 1"]
+  end
+
   it "should work correctly when changing the dataset" do
     @c.set_dataset(@c.db[:foo])
     @c.new.valid?.should == true

data/spec/extensions/instance_hooks_spec.rb

@@ -177,6 +177,20 @@ describe "InstanceHooks plugin" do
     @r.should == [2, 1, 4, 3]
   end
 
+  it "should not clear validations hooks on successful save" do
+    @x.after_validation_hook{@x.errors.add(:id, 'a') if @x.id == 1; r 1}
+    @x.before_validation_hook{r 2}
+    @x.save.should == nil
+    @r.should == [2, 1]
+    @x.save.should == nil
+    @r.should == [2, 1, 2, 1]
+    @x.id = 2
+    @x.save.should == @x
+    @r.should == [2, 1, 2, 1, 2, 1]
+    @x.save.should == @x
+    @r.should == [2, 1, 2, 1, 2, 1]
+  end
+
   it "should not allow addition of instance hooks to frozen instances" do
     @x.after_destroy_hook{r 1}
     @x.before_destroy_hook{r 2}

data/spec/extensions/pg_array_associations_spec.rb

@@ -644,4 +644,44 @@ describe Sequel::Model, "pg_array_associations" do
     @o2.add_artist(@c1.load(:id=>1))
     DB.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[2]::int8[] WHERE (id = 1)"]
   end
+
+  it "should not validate the current/associated object in add_ and remove_ if the :validate=>false option is used" do
+    @c1.pg_array_to_many :tags, :clone=>:tags, :validate=>false, :save_after_modify=>true
+    @c2.many_to_pg_array :artists, :clone=>:artists, :validate=>false
+    a = @c1.load(:id=>1)
+    t = @c2.load(:id=>2)
+    def a.validate() errors.add(:id, 'foo') end
+    a.associations[:tags] = []
+    a.add_tag(t).should == t
+    a.tags.should == [t]
+    a.remove_tag(t).should == t
+    a.tags.should == []
+
+    t.associations[:artists] = []
+    t.add_artist(a).should == a
+    t.artists.should == [a]
+    t.remove_artist(a).should == a
+    t.artists.should == []
+  end
+
+  it "should not raise exception in add_ and remove_ if the :raise_on_save_failure=>false option is used" do
+    @c1.pg_array_to_many :tags, :clone=>:tags, :raise_on_save_failure=>false, :save_after_modify=>true
+    @c2.many_to_pg_array :artists, :clone=>:artists, :raise_on_save_failure=>false
+    a = @c1.load(:id=>1)
+    t = @c2.load(:id=>2)
+    def a.validate() errors.add(:id, 'foo') end
+    a.associations[:tags] = []
+    a.add_tag(t).should == nil
+    a.tags.should == []
+    a.associations[:tags] = [t]
+    a.remove_tag(t).should == nil
+    a.tags.should == [t]
+
+    t.associations[:artists] = []
+    t.add_artist(a).should == nil
+    t.artists.should == []
+    t.associations[:artists] = [a]
+    t.remove_artist(a).should == nil
+    t.artists.should == [a]
+  end
 end