sequel 4.24.0 → 4.25.0

data/lib/sequel/extensions/query_literals.rb

@@ -45,7 +45,7 @@ module Sequel
   # Note that if you pass a block to these methods, it will use the default
   # implementation without the special literal handling.
   module QueryLiterals
-    %w'select select_append select_group select_more group group_and_count order order_append order_more'.each do |m|
+    %w'select select_append select_group select_more group group_and_count group_append order order_append order_more'.each do |m|
       class_eval(<<-END, __FILE__, __LINE__ + 1)
         def #{m}(*args)
           if !block_given? && (l = query_literal(args))

data/lib/sequel/model/base.rb

@@ -508,16 +508,12 @@ module Sequel
           end
           subclass.instance_variable_set(iv, sup_class_value)
         end
-        unless ivs.include?("@dataset")
-          if self == Model || !@dataset
-            n = subclass.name
-            unless n.nil? || n.empty?
-              db
-              subclass.set_dataset(subclass.implicit_table_name) rescue nil
-            end
-          elsif @dataset
-            subclass.set_dataset(@dataset.clone, :inherited=>true) rescue nil
-          end
+
+        if @dataset && self != Model
+          subclass.set_dataset(@dataset.clone, :inherited=>true) rescue nil
+        elsif (n = subclass.name) && !n.to_s.empty?
+          db
+          subclass.set_dataset(subclass.implicit_table_name) rescue nil
         end
       end
 
@@ -756,7 +752,7 @@ module Sequel
       # dataset methods that accept arguments, you should use define a
       # method directly inside a #dataset_module block.
       def subset(name, *args, &block)
-        dataset_module.subset(name, *args, &block)
+        def_dataset_method(name){filter(*args, &block)}
       end
       
       # Returns name of primary table for the dataset. If the table for the dataset

data/lib/sequel/model/dataset_module.rb

@@ -15,7 +15,7 @@ module Sequel
       # Define a named filter for this dataset, see
       # Model.subset for details.
       def subset(name, *args, &block)
-        define_method(name){filter(*args, &block)}
+        @model.subset(name, *args, &block)
       end
 
       private

data/lib/sequel/plugins/association_pks.rb

@@ -154,6 +154,12 @@ module Sequel
           super
         end
 
+        # Clear the associated pks if explicitly refreshing.
+        def refresh
+          @_association_pks = nil
+          super
+        end
+
         private
 
         # Return the primary keys of the associated objects.

data/lib/sequel/plugins/dirty.rb

@@ -38,7 +38,12 @@ module Sequel
     #   artist.update(:name=>'Bar')
     #   artist.column_changes        # => {}
     #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
-    # 
+    #
+    # There is one caveat; when used with a column that also uses the
+    # serialization plugin, setting the column back to its original value
+    # after changing it is not correctly detected and will leave an entry
+    # in changed_columns.
+    #
     # Usage:
     #
     #   # Make all model subclass instances record previous values (called before loading subclasses)

data/lib/sequel/plugins/inverted_subsets.rb

@@ -0,0 +1,48 @@
+module Sequel
+  module Plugins
+    # The inverted_subsets plugin adds another method for each defined
+    # subset, which inverts the condition supplied. By default, inverted
+    # subset method names are prefixed with not_.
+    #
+    # You can change the prefix, or indeed entirely customise the inverted names,
+    # by passing a block to the plugin configuration:
+    #
+    #   # Use an exclude_ prefix for inverted subsets instead of not_
+    #   Album.plugin(:inverted_subsets){|name| "exclude_#{name}"}
+    #
+    # Usage:
+    #
+    #   # Add inverted subsets in the Album class
+    #   Album.plugin :inverted_subsets
+    #
+    #   # This will now create two methods, published and not_published
+    #   Album.subset :published, :published => true
+    #
+    #   Album.published.sql
+    #   # SELECT * FROM albums WHERE (published IS TRUE)
+    #
+    #   Album.not_published.sql
+    #   # SELECT * FROM albums WHERE (published IS NOT TRUE)
+    #
+    module InvertedSubsets
+      # Default naming for inverted subsets
+      DEFAULT_NAME_BLOCK = lambda{|name| "not_#{name}"}
+
+      # Store the supplied block for calling later when subsets are defined, or
+      # create a default one if we need to.
+      def self.configure(model, &block)
+        model.instance_variable_set(:@inverted_subsets_name_block, block || DEFAULT_NAME_BLOCK)
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@inverted_subsets_name_block => nil)
+
+        # Define a not_ prefixed subset which inverts the subset condition.
+        def subset(name, *args, &block)
+          super
+          def_dataset_method(@inverted_subsets_name_block.call(name)){exclude(*args, &block)}
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/serialization.rb

@@ -165,6 +165,8 @@ module Sequel
               define_method("#{column}=") do |v| 
                 if !changed_columns.include?(column) && (new? || get_column_value(column) != v)
                   changed_columns << column
+
+                  will_change_column(column) if respond_to?(:will_change_column)
                 end
 
                 deserialized_values[column] = v

data/lib/sequel/plugins/singular_table_names.rb

@@ -0,0 +1,31 @@
+module Sequel
+  module Plugins
+    # The singular_table_names plugin changes the default
+    # table names for subclasses to not assume a plural version.
+    # By default, Sequel assumes table names for models use
+    # the plural versions.
+    #
+    # Note that this plugin only affects subclasses of the
+    # class it is loaded into, it does not affect the
+    # current class.  So it only makes sense to load this
+    # into Sequel::Model itself, or a subclass of Sequel::Model
+    # that is created via Class.new.
+    #
+    # Usage:
+    #
+    #   # Don't assume pluralized table names
+    #   Sequel::Model.plugin :singular_table_names
+    module SingularTableNames
+      module ClassMethods
+        # Returns the implicit table name for the model class, which is the demodulized,
+        # underscored, name of the class.
+        #
+        #   Artist.implicit_table_name # => :artist
+        #   Foo::ArtistAlias.implicit_table_name # => :artist_alias
+        def implicit_table_name
+          underscore(demodulize(name)).to_sym
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/static_cache.rb

@@ -35,6 +35,23 @@ module Sequel
     #   # Cache the AlbumType class statically, but return unfrozen instances
     #   # that can be modified.
     #   AlbumType.plugin :static_cache, :frozen=>false
+    #
+    # If you would like the speed benefits of keeping :frozen=>true but still need
+    # to occasionally update objects, you can side-step the before_ hooks by
+    # overriding the class method +static_cache_allow_modifications?+ to return true:
+    #
+    #   class Model
+    #     plugin :static_cache
+    #
+    #     def self.static_cache_allow_modifications?
+    #       true
+    #     end
+    #   end
+    #
+    # Now if you +#dup+ a Model object (the resulting object is not frozen), you
+    # will be able to update and save the duplicate.
+    # Note the caveats around your responsibility to update the cache still applies.
+    #
     module StaticCache
       # Populate the static caches when loading the plugin. Options:
       # :frozen :: Whether retrieved model objects are frozen.  The default is true,

data/lib/sequel/sql.rb

@@ -1178,6 +1178,7 @@ module Sequel
       include AliasMethods
       include CastMethods
       include OrderMethods
+      include PatternMatchMethods
       include SubscriptMethods
 
       # Return a BooleanExpression with the same op and args.

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 = 24
+  MINOR = 25
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/db2_spec.rb

@@ -66,6 +66,7 @@ describe Sequel::Database do
   after do
     @db.drop_table(:items)
   end
+
   it "should parse primary keys from the schema properly" do
     @db.create_table!(:items){Integer :number}
     @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal []
@@ -74,6 +75,17 @@ describe Sequel::Database do
     @db.create_table!(:items){Integer :number1, :null => false; Integer :number2, :null => false; primary_key [:number1, :number2]}
     @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal [:number1, :number2]
   end
+
+  it "should not error on alter_table operations that need REORG" do
+    @db.create_table!(:items) do
+      varchar :a
+    end
+    @db.alter_table(:items) do
+      add_column :b, :varchar, :null => true
+      set_column_allow_null :a, false
+      add_index :a, :unique => true
+    end
+  end
 end
 
 describe "Sequel::IBMDB.convert_smallint_to_bool" do

data/spec/adapters/mysql_spec.rb

@@ -24,6 +24,7 @@ SQL_COMMIT = 'COMMIT'
 describe "MySQL", '#create_table' do
   before do
     @db = DB
+    @db.test_connection
     DB.sqls.clear
   end
   after do

data/spec/adapters/postgres_spec.rb

@@ -11,7 +11,11 @@ def logger.method_missing(m, msg)
 end
 DB.loggers << logger
 
-DB.extension :pg_array, :pg_hstore, :pg_range, :pg_interval, :pg_row, :pg_inet, :pg_json, :pg_enum
+DB.extension :pg_array, :pg_hstore, :pg_range, :pg_row, :pg_inet, :pg_json, :pg_enum
+begin
+  DB.extension :pg_interval
+rescue LoadError
+end
 
 describe "PostgreSQL", '#create_table' do
   before do
@@ -168,6 +172,42 @@ describe "PostgreSQL views" do
   end
 end 
     
+describe "PostgreSQL", 'INSERT ON CONFLICT' do
+  before(:all) do
+    @db = DB
+    @db.create_table!(:ic_test){Integer :a; Integer :b; unique :a, :name=>:ic_test_a_uidx}
+    @ds = @db[:ic_test]
+  end
+  before do
+    @ds.delete
+  end
+  after(:all) do
+    @db.drop_table?(:ic_test)
+  end
+
+  it "Dataset#insert_ignore and insert_constraint should ignore uniqueness violations" do
+    @ds.insert(1, 2)
+    proc{@ds.insert(1, 3)}.must_raise Sequel::UniqueConstraintViolation
+    @ds.insert_ignore.insert(1, 3).must_equal nil
+    @ds.insert_conflict.insert(1, 3).must_equal nil
+    @ds.insert_conflict(:target=>:a).insert(1, 3).must_equal nil
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx).insert(1, 3).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>2}]
+  end
+
+  it "Dataset#insert_constraint should handle upserts" do
+    @ds.insert(1, 2)
+    @ds.insert_conflict(:target=>:a, :update=>{:b=>3}).insert(1, 3).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>3}]
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>4}).insert(1, 3).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>4}]
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>5}, :update_where=>{:ic_test__b=>4}).insert(1, 3).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>5}]
+    @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>6}, :update_where=>{:ic_test__b=>4}).insert(1, 3).must_equal nil
+    @ds.all.must_equal [{:a=>1, :b=>5}]
+  end
+end if DB.server_version >= 90500
+
 describe "A PostgreSQL database" do
   before(:all) do
     @db = DB

data/spec/core/database_spec.rb

@@ -1683,6 +1683,7 @@ end
 
 describe "Database#each_server with do/jdbc adapter connection string without :adapter option" do
   it "should yield a separate database object for each server" do
+    require 'sequel/adapters/mock'
     klass = Class.new(Sequel::Database)
     def klass.adapter_class(v)
       raise unless v == :jdbc

data/spec/core/dataset_spec.rb

@@ -475,10 +475,10 @@ describe "Dataset#where" do
   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))"
+    @dataset.filter(:id => []).sql.must_equal "SELECT * FROM test WHERE (1 = 0)"
+    @dataset.filter([:id1, :id2] => []).sql.must_equal "SELECT * FROM test WHERE (1 = 0)"
+    @dataset.exclude(:id => []).sql.must_equal "SELECT * FROM test WHERE (1 = 1)"
+    @dataset.exclude([:id1, :id2] => []).sql.must_equal "SELECT * FROM test WHERE (1 = 1)"
   end
 
   it "should handle all types of IN/NOT IN queries" do
@@ -517,9 +517,9 @@ describe "Dataset#where" do
     meta_def(@dataset, :supports_multiple_column_in?){false}
     db = Sequel.mock
     d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
-    @dataset.filter([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
+    @dataset.filter([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE (1 = 0)"
     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))"
+    @dataset.exclude([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE (1 = 1)"
     db.sqls.must_equal ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
   end
   
@@ -875,6 +875,25 @@ describe "Dataset#group_by" do
   end
 end
 
+describe "Dataset#group_append" do
+  before do
+    @d = Sequel.mock.dataset.from(:test)
+  end
+
+  it "should group by the given columns if no existing columns are present" do
+    @d.group_append(:a).sql.must_equal 'SELECT * FROM test GROUP BY a'
+  end
+
+  it "should add to the currently grouped columns" do
+    @d.group(:a).group_append(:b).sql.must_equal 'SELECT * FROM test GROUP BY a, b'
+  end
+
+  it "should accept a block that yields a virtual row" do
+    @d.group(:a).group_append{:b}.sql.must_equal 'SELECT * FROM test GROUP BY a, b'
+    @d.group(:a).group_append(:c){b}.sql.must_equal 'SELECT * FROM test GROUP BY a, c, b'
+  end
+end
+
 describe "Dataset#as" do
   it "should set up an alias" do
     dataset = Sequel.mock.dataset.from(:test)
@@ -3405,10 +3424,15 @@ describe "Dataset default #fetch_rows, #insert, #update, #delete, #truncate, #ex
     proc{@ds.having(:a=>1).truncate}.must_raise(Sequel::InvalidOperation)
   end
   
-  it "#execute should execute the SQL on the database" do
+  it "#execute should execute the SQL on the read_only database" do
     @ds.send(:execute, 'SELECT 1')
     @db.sqls.must_equal ["SELECT 1 -- read_only"]
   end
+  
+  it "#execute should execute the SQL on the default database if locking is used" do
+    @ds.for_update.send(:execute, 'SELECT 1')
+    @db.sqls.must_equal ["SELECT 1"]
+  end
 end
 
 describe "Dataset#with_sql_*" do
@@ -3542,6 +3566,30 @@ describe "Dataset prepared statements and bound variables " do
       'INSERT INTO items (num) VALUES (1) RETURNING *']
   end
     
+  it "#call and #prepare should handle returning" do
+    meta_def(@ds, :supports_returning?){|_| true}
+    meta_def(@ds, :insert_sql){|*v| "#{super(*v)} RETURNING *" }
+    meta_def(@ds, :update_sql){|*v| "#{super(*v)} RETURNING *" }
+    meta_def(@ds, :delete_sql){"#{super()} RETURNING *" }
+    @ds = @ds.returning
+    @ds.call(:insert, {:n=>1}, :num=>:$n)
+    @ds.filter(:num=>:$n).call(:update, {:n=>1, :n2=>2}, :num=>:$n2)
+    @ds.filter(:num=>:$n).call(:delete, :n=>1)
+    @ds.prepare(:insert, :insert_rn, :num=>:$n).call(:n=>1)
+    @ds.filter(:num=>:$n).prepare(:update, :update_rn, :num=>:$n2).call(:n=>1, :n2=>2)
+    @ds.filter(:num=>:$n).prepare(:delete, :delete_rn).call(:n=>1)
+    @db.sqls.must_equal([
+      'INSERT INTO items (num) VALUES (1) RETURNING *',
+      'UPDATE items SET num = 2 WHERE (num = 1) RETURNING *',
+      'DELETE FROM items WHERE (num = 1) RETURNING *',
+    ]*2)
+  end
+
+  it "PreparedStatement#prepare should raise an error" do
+    ps = @ds.prepare(:select, :select_n)
+    proc{ps.prepare(:select, :select_n2)}.must_raise Sequel::Error
+  end
+
   it "#call should default to using :all if an invalid type is given" do
     @ds.filter(:num=>:$n).call(:select_all, :n=>1)
     @db.sqls.must_equal ['SELECT * FROM items WHERE (num = 1)']

data/spec/core/expression_filters_spec.rb

@@ -68,8 +68,17 @@ describe "Blockless Ruby Filters" do
     @d.l{x =~ (1...5)}.must_equal '((x >= 1) AND (x < 5))'
     @d.l{x =~ [1,2,3]}.must_equal '(x IN (1, 2, 3))'
 
+    @d.l{(x + y) =~ 100}.must_equal '((x + y) = 100)'
+    @d.l{(x + y) =~ 'a'}.must_equal '((x + y) = \'a\')'
+    @d.l{(x + y) =~ true}.must_equal '((x + y) IS TRUE)'
+    @d.l{(x + y) =~ false}.must_equal '((x + y) IS FALSE)'
+    @d.l{(x + y) =~ nil}.must_equal '((x + y) IS NULL)'
+    @d.l{(x + y) =~ (1...5)}.must_equal '(((x + y) >= 1) AND ((x + y) < 5))'
+    @d.l{(x + y) =~ [1,2,3]}.must_equal '((x + y) IN (1, 2, 3))'
+
     def @d.supports_regexp?; true end
     @d.l{x =~ /blah/}.must_equal '(x ~ \'blah\')'
+    @d.l{(x + y) =~ /blah/}.must_equal '((x + y) ~ \'blah\')'
   end
 
   if RUBY_VERSION >= '1.9'
@@ -82,8 +91,17 @@ describe "Blockless Ruby Filters" do
       @d.l{x !~ (1...5)}.must_equal '((x < 1) OR (x >= 5))'
       @d.l{x !~ [1,2,3]}.must_equal '(x NOT IN (1, 2, 3))'
 
+      @d.l{(x + y) !~ 100}.must_equal '((x + y) != 100)'
+      @d.l{(x + y) !~ 'a'}.must_equal '((x + y) != \'a\')'
+      @d.l{(x + y) !~ true}.must_equal '((x + y) IS NOT TRUE)'
+      @d.l{(x + y) !~ false}.must_equal '((x + y) IS NOT FALSE)'
+      @d.l{(x + y) !~ nil}.must_equal '((x + y) IS NOT NULL)'
+      @d.l{(x + y) !~ (1...5)}.must_equal '(((x + y) < 1) OR ((x + y) >= 5))'
+      @d.l{(x + y) !~ [1,2,3]}.must_equal '((x + y) NOT IN (1, 2, 3))'
+
       def @d.supports_regexp?; true end
       @d.l{x !~ /blah/}.must_equal '(x !~ \'blah\')'
+      @d.l{(x + y) !~ /blah/}.must_equal '((x + y) !~ \'blah\')'
     end
   end