sequel 4.31.0 → 4.32.0

data/lib/sequel/plugins/association_pks.rb

@@ -29,6 +29,12 @@ module Sequel
     # objects, and the setting will not be persisted until after the object has
     # been saved.
     #
+    # By default, if you pass a nil value to the setter, an exception will be raised.
+    # You can change this behavior by using the :association_pks_nil association option.
+    # If set to :ignore, the setter will take no action if nil is given.
+    # If set to :remove, the setter will treat the nil as an empty array, removing
+    # the association all currently associated values.
+    #
     # Usage:
     #
     #   # Make all model subclass *_to_many associations have association_pks
@@ -74,21 +80,25 @@ module Sequel
           end
 
           opts[:pks_setter] = lambda do |pks|
-            checked_transaction do
-              if clpk
-                lpkv = lpk.map{|k| get_column_value(k)}
-                cond = lk.zip(lpkv)
-              else
-                lpkv = get_column_value(lpk)
-                cond = {lk=>lpkv}
+            if pks.empty?
+              send(opts.remove_all_method)
+            else
+              checked_transaction do
+                if clpk
+                  lpkv = lpk.map{|k| get_column_value(k)}
+                  cond = lk.zip(lpkv)
+                else
+                  lpkv = get_column_value(lpk)
+                  cond = {lk=>lpkv}
+                end
+                ds = _join_table_dataset(opts).filter(cond)
+                ds.exclude(rk=>pks).delete
+                pks -= ds.select_map(rk)
+                lpkv = Array(lpkv)
+                key_array = crk ? pks.map{|pk| lpkv + pk} : pks.map{|pk| lpkv + [pk]}
+                key_columns = Array(lk) + Array(rk)
+                ds.import(key_columns, key_array)
               end
-              ds = _join_table_dataset(opts).filter(cond)
-              ds.exclude(rk=>pks).delete
-              pks -= ds.select_map(rk)
-              lpkv = Array(lpkv)
-              key_array = crk ? pks.map{|pk| lpkv + pk} : pks.map{|pk| lpkv + [pk]}
-              key_columns = Array(lk) + Array(rk)
-              ds.import(key_columns, key_array)
             end
           end
 
@@ -109,25 +119,29 @@ module Sequel
           end
 
           opts[:pks_setter] = lambda do |pks|
-            primary_key = opts.associated_class.primary_key
-            pkh = {primary_key=>pks}
-
-            if key.is_a?(Array)
-              h = {}
-              nh = {}
-              key.zip(pk).each do|k, v|
-                h[k] = v
-                nh[k] = nil
-              end
+            if pks.empty?
+              send(opts.remove_all_method)
             else
-              h = {key=>pk}
-              nh = {key=>nil}
-            end
+              primary_key = opts.associated_class.primary_key
+              pkh = {primary_key=>pks}
+
+              if key.is_a?(Array)
+                h = {}
+                nh = {}
+                key.zip(pk).each do|k, v|
+                  h[k] = v
+                  nh[k] = nil
+                end
+              else
+                h = {key=>pk}
+                nh = {key=>nil}
+              end
 
-            checked_transaction do
-              ds = send(opts.dataset_method)
-              ds.unfiltered.filter(pkh).update(h)
-              ds.exclude(pkh).update(nh)
+              checked_transaction do
+                ds = send(opts.dataset_method)
+                ds.unfiltered.filter(pkh).update(h)
+                ds.exclude(pkh).update(nh)
+              end
             end
           end
 
@@ -141,7 +155,7 @@ module Sequel
         def after_save
           if assoc_pks = @_association_pks
             assoc_pks.each do |name, pks|
-              instance_exec(pks, &model.association_reflection(name)[:pks_setter]) unless pks.empty?
+              instance_exec(pks, &model.association_reflection(name)[:pks_setter])
             end
             @_association_pks = nil
           end
@@ -174,7 +188,19 @@ module Sequel
         # If the receiver is a new object, save the pks
         # so the update can happen after the received has been saved.
         def _association_pks_setter(opts, pks)
+          if pks.nil?
+            case opts[:association_pks_nil]
+            when :remove
+              pks = []
+            when :ignore
+              return
+            else
+              raise Error, "nil value given to association_pks setter"
+            end
+          end
+
           pks = convert_pk_array(opts, pks)
+
           delay = opts[:delay_pks]
           if (new? && delay) || (delay == :always)
             modified!
@@ -190,7 +216,6 @@ module Sequel
           klass = opts.associated_class
           primary_key = klass.primary_key
           sch = klass.db_schema
-          pks = Array(pks)
 
           if primary_key.is_a?(Array)
             if (cols = sch.values_at(*klass.primary_key)).all? && (convs = cols.map{|c| c[:type] == :integer}).all?

data/lib/sequel/plugins/eager_each.rb

@@ -15,6 +15,11 @@ module Sequel
     # and setting a new flag in the cloned dataset, so that each can check with the flag to
     # determine whether it should call all.
     #
+    # This plugin also makes #first and related methods that load single records work with
+    # eager loading.  Note that when using eager_graph, calling #first or a similar method
+    # will result in two queries, one to load the main object, and one to eagerly load all associated
+    # objects to that main object.
+    #
     # Usage:
     #
     #   # Make all model subclass instances eagerly load for each (called before loading subclasses)
@@ -53,6 +58,23 @@ module Sequel
           end
         end
 
+        # Handle eager loading when calling first and related methods.  For eager_graph,
+        # this does an additional query after retrieving a single record, because otherwise
+        # the associated records won't get eager loaded correctly.
+        def single_record!
+          if use_eager_all?
+            obj = clone(:all_called=>true).all.first
+
+            if opts[:eager_graph]
+              obj = clone(:all_called=>true).where(obj.qualified_pk_hash).unlimited.all.first
+            end
+
+            obj
+          else
+            super
+          end
+        end
+
         private
 
         # Wether to use all when each is called, true when eager loading

data/lib/sequel/plugins/pg_typecast_on_load.rb

@@ -3,11 +3,12 @@
 module Sequel
   module Plugins
     # The PgTypecastOnLoad plugin exists because when you connect to PostgreSQL
-    # using the do, swift, or jdbc adapter, Sequel doesn't have complete
+    # using the do and swift adapters, Sequel doesn't have complete
     # control over typecasting, and may return columns as strings instead of how
     # the native postgres adapter would typecast them.  This is mostly needed for
     # the additional support that the pg_* extensions add for advanced PostgreSQL
-    # types such as arrays.
+    # types such as arrays. This plugin is not needed if using the postgres or
+    # jdbc/postgresql adapters.
     #
     # This plugin makes model loading to do the same conversion that the
     # native postgres adapter would do for all columns given.  You can either

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -19,7 +19,47 @@ module Sequel
     #   Album.filter{id<100}.all do |a|
     #     a.artists
     #   end
+    #   # SELECT * FROM albums WHERE (id < 100)
+    #   # SELECT * FROM artists WHERE id IN (...)
+    #
+    # Note that if you are passing a callback to the association method via
+    # a block or :callback option, or using the :reload option to reload
+    # the association, eager loading will not be done.
+    #
+    # You can use the :eager_reload option to reload the association for all
+    # objects that the current object was retrieved with:
+    #
+    #   # SELECT * FROM albums WHERE (id < 100)
+    #   albums = Album.filter{id<100}.all
+    #
+    #   # Eagerly load all artists for these albums
+    #   # SELECT * FROM artists WHERE id IN (...)
+    #   albums.first.artists
+    #
+    #   # Do something that may affect which artists are associated to the albums
+    #
+    #   # Eagerly reload all artists for these albums
+    #   # SELECT * FROM artists WHERE id IN (...)
+    #   albums.first.artists(:eager_reload=>true)
     # 
+    # You can also use the :eager option to specify dependent associations
+    # to eager load:
+    #
+    #  albums = Album.filter{id<100}.all
+    #
+    #   # Eager load all artists for these albums, and all albums for those artists
+    #   # SELECT * FROM artists WHERE id IN (...)
+    #   # SELECT * FROM albums WHERE artist_id IN (...)
+    #   albums.first.artists(:eager=>:albums)
+    #
+    # You can also use :eager to specify an eager callback. For example:
+    #
+    #   albums = Album.filter{id<100}.all
+    #
+    #   # Eagerly load all artists whose name starts with A-M for these albums
+    #   # SELECT * FROM artists WHERE name > 'N' AND id IN (...)
+    #   albums.first.artists(:eager=>proc{|ds| ds.where(:name > 'N')})
+    #
     # Usage:
     #
     #   # Make all model subclass instances use tactical eager loading (called before loading subclasses)
@@ -51,11 +91,12 @@ module Sequel
         # If there the association is not in the associations cache and the object
         # was reteived via Dataset#all, eagerly load the association for all model
         # objects retrieved with the current object.
-        def load_associated_objects(opts, reload=false)
+        def load_associated_objects(opts, dynamic_opts=nil, &block)
+          dynamic_opts = load_association_objects_options(dynamic_opts, &block)
           name = opts[:name]
-          if !associations.include?(name) && retrieved_by && !frozen?
+          if (!associations.include?(name) || dynamic_opts[:eager_reload]) && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
             begin
-              retrieved_by.send(:eager_load, retrieved_with.reject(&:frozen?), name=>{})
+              retrieved_by.send(:eager_load, retrieved_with.reject(&:frozen?), name=>dynamic_opts[:eager] || {})
             rescue Sequel::UndefinedAssociation
               # This can happen if class table inheritance is used and the association
               # is only defined in a subclass.  This particular instance can use the

data/lib/sequel/version.rb

@@ -5,13 +5,13 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 31
+  MINOR = 32
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
-  VERSION = [MAJOR, MINOR, TINY].join('.')
+  VERSION = [MAJOR, MINOR, TINY].join('.').freeze
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   def self.version

data/spec/adapters/mysql_spec.rb

@@ -325,12 +325,6 @@ describe "Joined MySQL dataset" do
     @ds.join(:attributes, :node_id => :id).sql.must_equal "SELECT * FROM `nodes` INNER JOIN `attributes` ON (`attributes`.`node_id` = `nodes`.`id`)"
   end
 
-  it "should allow a having clause on ungrouped datasets" do
-    @ds.having('blah')
-
-    @ds.having('blah').sql.must_equal "SELECT * FROM `nodes` HAVING (blah)"
-  end
-
   it "should put a having clause before an order by clause" do
     @ds.order(:aaa).having(:bbb => :ccc).sql.must_equal "SELECT * FROM `nodes` HAVING (`bbb` = `ccc`) ORDER BY `aaa`"
   end
@@ -1289,3 +1283,37 @@ if DB.adapter_scheme == :mysql2
     end
   end
 end
+
+describe "MySQL joined datasets" do
+  before do
+    @db = DB
+    @db.create_table!(:a) do
+      Integer :id
+    end
+    @db.create_table!(:b) do
+      Integer :id
+      Integer :a_id
+    end
+    @db[:a].insert(1)
+    @db[:a].insert(2)
+    @db[:b].insert(3, 1)
+    @db[:b].insert(4, 1)
+    @db[:b].insert(5, 2)
+    @ds = @db[:a].join(:b, :a_id=>:id)
+  end
+  after do
+    @db.drop_table?(:a, :b)
+  end
+
+  it "should support deletions from a single table" do
+    @ds.where(:a__id=>1).delete
+    @db[:a].select_order_map(:id).must_equal [2]
+    @db[:b].select_order_map(:id).must_equal [3, 4, 5]
+  end
+
+  it "should support deletions from multiple tables" do
+    @ds.delete_from(:a, :b).where(:a__id=>1).delete
+    @db[:a].select_order_map(:id).must_equal [2]
+    @db[:b].select_order_map(:id).must_equal [5]
+  end
+end

data/spec/adapters/oracle_spec.rb

@@ -222,7 +222,7 @@ describe "An Oracle database" do
   it "should translate values correctly" do
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
-    @d.filter('value > 500').update(:date_created => Sequel.lit("to_timestamp('2009-09-09', 'YYYY-MM-DD')"))
+    @d.filter{value > 500}.update(:date_created => Sequel.lit("to_timestamp('2009-09-09', 'YYYY-MM-DD')"))
     
     @d[:name => 'def'][:date_created].strftime('%F').must_equal '2009-09-09'
   end

data/spec/bin_spec.rb

@@ -139,7 +139,7 @@ END
   end
 
   it "-E should echo SQL statements to stdout" do
-    bin(:args=>'-E -c DB.tables').must_match %r{SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
+    bin(:args=>'-E -c DB.tables').must_include "SELECT * FROM `sqlite_master` WHERE ((`name` != 'sqlite_sequence') AND (`type` = 'table'))"
   end
 
   it "-I should include directory in load path" do
@@ -148,7 +148,7 @@ END
 
   it "-l should log SQL statements to file" do
     bin(:args=>"-l #{TMP_FILE} -c DB.tables").must_equal ''
-    File.read(TMP_FILE).must_match %r{SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
+    File.read(TMP_FILE).must_include "SELECT * FROM `sqlite_master` WHERE ((`name` != 'sqlite_sequence') AND (`type` = 'table'))"
   end
 
   it "-L should load all *.rb files in given directory" do

data/spec/core/dataset_spec.rb

@@ -3642,6 +3642,13 @@ describe "Dataset prepared statements and bound variables " do
     proc{ps.prepare(:select, :select_n2)}.must_raise Sequel::Error
   end
 
+  it "PreparedStatement#prepare should not raise an error if preparing prepared statements is allowed" do
+    ps = @ds.prepare(:select, :select_n)
+    def ps.allow_preparing_prepared_statements?; true end
+    ps.prepare(:select, :select_n2).call
+    @db.sqls.must_equal ["SELECT * FROM items"]
+  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/extensions/association_pks_spec.rb

@@ -336,6 +336,14 @@ describe "Sequel::Plugins::AssociationPks" do
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (2, 4)))"
     ]
 
+    ar.album_pks = []
+    @db.sqls.must_equal []
+
+    ar.save_changes
+    @db.sqls.must_equal [
+      "UPDATE albums SET artist_id = NULL WHERE (artist_id = 1)"
+    ]
+
     al = @Album.load(:id=>1)
     al.tag_pks.must_equal [1,2]
     @db.sqls
@@ -351,6 +359,14 @@ describe "Sequel::Plugins::AssociationPks" do
       "INSERT INTO albums_tags (album_id, tag_id) VALUES (1, 3)",
       "COMMIT",
     ]
+
+    al.tag_pks = []
+    @db.sqls.must_equal []
+
+    al.save_changes
+    @db.sqls.must_equal [
+      "DELETE FROM albums_tags WHERE (album_id = 1)",
+    ]
   end
 
   it "should clear delayed associated pks if refreshing, if :delay plugin option is used" do
@@ -364,4 +380,26 @@ describe "Sequel::Plugins::AssociationPks" do
     ar.refresh
     ar.album_pks.must_equal [1,2,3]
   end
+
+  it "should remove all values if nil given to setter and :association_pks_nil=>:remove" do
+    @Artist.one_to_many :albums, :clone=>:albums, :association_pks_nil=>:remove
+
+    ar = @Artist.load(:id=>1)
+    ar.album_pks = nil
+    @db.sqls.must_equal ["UPDATE albums SET artist_id = NULL WHERE (artist_id = 1)"]
+  end
+
+  it "should take no action if nil given to setter and :association_pks_nil=>:ignore" do
+    @Artist.one_to_many :albums, :clone=>:albums, :association_pks_nil=>:ignore
+
+    ar = @Artist.load(:id=>1)
+    ar = @Artist.new
+    ar.album_pks = nil
+    @db.sqls.must_equal []
+  end
+
+  it "should raise error if nil given to setter by default" do
+    ar = @Artist.load(:id=>1)
+    proc{ar.album_pks = nil}.must_raise Sequel::Error
+  end
 end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -51,6 +51,14 @@ describe "class_table_inheritance plugin" do
     Object.send(:remove_const, :Employee)
   end
 
+  it "#cti_base_model should be the model that loaded the plugin" do
+    Executive.cti_base_model.must_equal Employee
+  end
+
+  it "#cti_columns should be a mapping of table names to columns" do
+    Executive.cti_columns.must_equal(:employees=>[:id, :name, :kind], :managers=>[:id, :num_staff], :executives=>[:id, :num_managers])
+  end
+
   it "should have simple_table = nil for all subclasses" do
     Manager.simple_table.must_equal nil
     Executive.simple_table.must_equal nil
@@ -246,7 +254,23 @@ describe "class_table_inheritance plugin" do
     sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Ceo)', '(E|Ceo)'\)/)
     sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/)
     sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/)
+  end
+    
+  it "should insert the correct rows into all tables when inserting when insert select is important" do
+    [Ceo, Manager, Employee].each do |klass|
+      def (klass.cti_instance_dataset).supports_insert_select?; true; end
+      def (klass.cti_instance_dataset).insert_select(v)
+        db.run(insert_sql(v) + " RETURNING *")
+        v.merge(:id=>1)
+      end
     end
+    Ceo.create(:num_managers=>3, :num_staff=>2, :name=>'E')
+    sqls = @db.sqls
+    sqls.length.must_equal 3
+    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Ceo)', '(E|Ceo)'\) RETURNING \*/)
+    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\) RETURNING \*/)
+    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\) RETURNING \*/)
+  end
     
   it "should insert the correct rows into all tables with a given primary key" do
     e = Ceo.new(:num_managers=>3, :num_staff=>2, :name=>'E')