sequel 4.9.0 → 4.10.0

data/lib/sequel/plugins/prepared_statements.rb

@@ -130,7 +130,8 @@ module Sequel
           h = @prepared_statements[type]
           Sequel.synchronize do
             if v = h[subtype]
-              return v end
+              return v
+            end
           end
           ps = yield
           Sequel.synchronize{h[subtype] = ps}

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -22,17 +22,6 @@ module Sequel
       # lambda returns the next integer to use.
       NEXT = lambda{MUTEX.synchronize{i += 1}}
 
-      module ClassMethods
-        # Disable prepared statement use if a block is given, or the :dataset or :conditions
-        # options are used, or you are cloning an association.
-        def associate(type, name, opts = OPTS, &block)
-          if block || opts[:dataset] || (opts[:clone] && association_reflection(opts[:clone])[:prepared_statement] == false)
-            opts = opts.merge(:prepared_statement=>false)
-          end
-          super(type, name, opts, &block)
-        end
-      end
-
       module InstanceMethods
         private
 
@@ -50,9 +39,9 @@ module Sequel
             association_bound_variable_hash(opts.associated_class.table_name, opts.primary_keys, opts[:keys])
           when :one_to_many, :one_to_one
             association_bound_variable_hash(opts.associated_class.table_name, opts[:keys], opts[:primary_keys])
-          when :many_to_many
+          when :many_to_many, :one_through_one
             association_bound_variable_hash(opts.join_table_alias, opts[:left_keys], opts[:left_primary_keys])
-          when :many_through_many
+          when :many_through_many, :one_through_many
             association_bound_variable_hash(opts.final_reverse_edge[:alias], Array(opts[:left_key]), opts[:left_primary_keys])
           end
         end
@@ -62,26 +51,46 @@ module Sequel
         # instance.  Return false if such a prepared statement cannot be created.
         def association_prepared_statement(opts, assoc_bv)
           opts.send(:cached_fetch, :prepared_statement) do
-            ds, bv = _associated_dataset(opts, {}).unbind
-            if bv.length != assoc_bv.length
-              h = {}
-              bv.each do |k,v|
-                h[k] = v unless assoc_bv.has_key?(k)
+            unless opts[:instance_specific]
+              ds, bv = _associated_dataset(opts, {}).unbind
+              if bv.length != assoc_bv.length
+                h = {}
+                bv.each do |k,v|
+                  h[k] = v unless assoc_bv.has_key?(k)
+                end
+                ds = ds.bind(h)
               end
-              ds = ds.bind(h)
+              ps = ds.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
+              ps.log_sql = true
+              ps
             end
-            ps = ds.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
-            ps.log_sql = true
-            ps
           end
         end
 
-        # If a prepared statement can be used to load the associated objects, execute it to retrieve them.  Otherwise,
-        # fall back to the default implementation.
-        def _load_associated_objects(opts, dynamic_opts=OPTS)
-          if !opts.can_have_associated_objects?(self) || dynamic_opts[:callback] || (load_with_primary_key_lookup?(opts, dynamic_opts) && opts.associated_class.respond_to?(:cache_get_pk))
+        # Use a prepared statement if possible to load the associated object,
+        # unless a dynamic callback is given.
+        def _load_associated_object(opts, dynamic_opts)
+          if !dynamic_opts[:callback] && (bv = association_bound_variables(opts)) && (ps ||= association_prepared_statement(opts, bv))
+            ps.call(bv)
+          else
             super
-          elsif (bv = association_bound_variables(opts)) && (ps ||= association_prepared_statement(opts, bv))
+          end
+        end
+
+        # Use a prepared statement if possible to load the associated object,
+        # unless the associated model uses caching.
+        def _load_associated_object_via_primary_key(opts)
+          if !opts.associated_class.respond_to?(:cache_get_pk) && (bv = association_bound_variables(opts)) && (ps ||= association_prepared_statement(opts, bv))
+            ps.call(bv)
+          else
+            super
+          end
+        end
+
+        # Use a prepared statement if possible to load the associated objects,
+        # unless a dynamic callback is given.
+        def _load_associated_object_array(opts, dynamic_opts)
+          if !dynamic_opts[:callback] && (bv = association_bound_variables(opts)) && (ps ||= association_prepared_statement(opts, bv))
             ps.call(bv)
           else
             super

data/lib/sequel/plugins/rcte_tree.rb

@@ -204,15 +204,12 @@ module Sequel
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
-          elds = model.eager_loading_dataset(r,
-           model.from(SQL::AliasedExpression.new(t, table_alias)).
-            with_recursive(t, base_case,
-             recursive_case,
-             :args=>((key_aliases + col_aliases) if col_aliases)),
-           r.select,
-           eo[:associations], eo)
-          elds = elds.select_append(ka) unless elds.opts[:select] == nil
-          elds.all do |obj|
+          ds = model.from(SQL::AliasedExpression.new(t, table_alias)).
+            with_recursive(t, base_case, recursive_case,
+             :args=>((key_aliases + col_aliases) if col_aliases))
+          ds = r.apply_eager_dataset_changes(ds)
+          ds = ds.select_append(ka) unless ds.opts[:select] == nil
+          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
             opk = prkey_conv[obj]
             if parent_map.has_key?(opk)
               if idm_obj = parent_map[opk]
@@ -308,13 +305,12 @@ module Sequel
             recursive_case = recursive_case.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).filter(SQL::QualifiedIdentifier.new(t, la) < level - 1)
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
-          elds = model.eager_loading_dataset(r,
-           model.from(SQL::AliasedExpression.new(t, table_alias)).with_recursive(t, base_case, recursive_case,
-            :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases)),
-           r.select,
-           associations, eo)
-          elds = elds.select_append(ka) unless elds.opts[:select] == nil
-          elds.all do |obj|
+          ds = model.from(SQL::AliasedExpression.new(t, table_alias)).
+            with_recursive(t, base_case, recursive_case,
+              :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases))
+          ds = r.apply_eager_dataset_changes(ds)
+          ds = ds.select_append(ka) unless ds.opts[:select] == nil
+          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>{})) do |obj|
             if level
               no_cache = no_cache_level == obj.values.delete(la)
             end

data/lib/sequel/plugins/sharding.rb

@@ -24,9 +24,22 @@ module Sequel
           new_using_server(s, values, &block).save
         end
 
-        # When eagerly loading, if the current dataset has a defined shard and the
-        # dataset that you will be using to get the associated records does not,
-        # use the current dataset's shard for the associated dataset.
+        # Eager load the association with the given eager loader options.
+        def eager_load_results(opts, eo, &block)
+          if (s = eo[:self]) && (server = s.opts[:server])
+            eb = eo[:eager_block]
+            set_server = proc do |ds|
+              ds = eb.call(ds) if eb
+              ds = ds.server(server) unless ds.opts[:server]
+              ds
+            end
+            eo = eo.merge(:eager_block=>set_server)
+          end
+
+          super
+        end
+
+        # REMOVE410
         def eager_loading_dataset(opts, ds, select, associations, eager_options=OPTS)
           ds = super(opts, ds, select, associations, eager_options)
           if !ds.opts[:server] and s = eager_options[:self] and server = s.opts[:server]
@@ -70,6 +83,11 @@ module Sequel
           use_server(super)
         end
 
+        # Don't use an associated object loader, as it won't respect the shard used.
+        def _associated_object_loader(opts, dynamic_opts)
+          nil
+        end
+
         # Ensure that the join table for many_to_many associations uses the correct shard.
         def _join_table_dataset(opts)
           use_server(super)

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -182,7 +182,8 @@ module Sequel
         # keys for all of their descendant classes.
         def sti_subclass_added(key)
           if sti_key_array
-            Sequel.synchronize{sti_key_array.push(*Array(key))}
+            key_array = Array(key)
+            Sequel.synchronize{sti_key_array.push(*key_array)}
             superclass.sti_subclass_added(key)
           end
         end

data/lib/sequel/plugins/subclasses.rb

@@ -42,7 +42,7 @@ module Sequel
 
         # All descendent classes of this model.
         def descendents
-          Sequel.synchronize{_descendents}
+          Sequel.synchronize{subclasses.dup}.map{|x| [x] + x.send(:descendents)}.flatten
         end
 
         Plugins.inherited_instance_variables(self, :@subclasses=>lambda{|v| []}, :@on_subclass=>nil)
@@ -55,14 +55,6 @@ module Sequel
           Sequel.synchronize{subclasses << subclass}
           on_subclass.call(subclass) if on_subclass
         end
-
-        private
-
-        # Recursive, non-thread safe version of descendents, since
-        # the mutex Sequel uses isn't reentrant.
-        def _descendents
-          subclasses.map{|x| [x] + x.send(:_descendents)}.flatten
-        end
       end
     end
   end

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -35,6 +35,15 @@ module Sequel
         # reteived via Dataset#all.
         attr_accessor :retrieved_with
 
+        # Remove retrieved_by and retrieved_with when marshalling.  retrieved_by
+        # contains unmarshallable objects, and retrieved_with can be very large
+        # and is not helpful without retrieved_by.
+        def marshallable!
+          @retrieved_by = nil
+          @retrieved_with = nil
+          super
+        end
+
         private
 
         # If there the association is not in the associations cache and the object

data/lib/sequel/plugins/tree.rb

@@ -88,9 +88,9 @@ module Sequel
           nodes
         end
 
-        # Returns list of ancestors, starting from parent until root.
+        # Returns list of descendants
         #
-        #   subchild1.ancestors # => [child1, root]
+        #   node.descendants # => [child1, child2, subchild1_1, subchild1_2, subchild2_1, subchild2_2]
         def descendants
           nodes = children.dup
           children.each{|child| nodes.concat(child.descendants)}

data/lib/sequel/plugins/validation_class_methods.rb

@@ -67,7 +67,7 @@ module Sequel
         # Instructs the model to skip validations defined in superclasses
         def skip_superclass_validations
           superclass.validations.each do |att, procs|
-            if ps = @validations[att]
+            if @validations[att]
               @validations[att] -= procs
             end
           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 = 9
+  MINOR = 10
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mssql_spec.rb

@@ -656,25 +656,67 @@ describe "MSSQL Stored Procedure support" do
     @db.execute('DROP PROCEDURE dbo.SequelTest')
   end
 
-  it "should return a hash of output variables" do
-    r = @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})
-    r.should be_a_kind_of(Hash)
-    r.values_at(:var2, :var3).should == [@now, '1']
-  end
+  describe "with unnamed parameters" do
+    it "should return a hash of output variables" do
+      r = @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})
+      r.should be_a_kind_of(Hash)
+      r.values_at(:var2, :var3).should == [@now, '1']
+    end
 
-  it "should support typed output variables" do
-    @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, [:output, 'int']]})[:var3].should == 1
-  end
+    it "should support typed output variables" do
+      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, [:output, 'int']]})[:var3].should == 1
+    end
 
-  it "should support named output variables" do
-    @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, [:output, nil, 'output'], :output]})[:output].should == @now
-  end
+    it "should support named output variables" do
+      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, [:output, nil, 'output'], :output]})[:output].should == @now
+    end
+
+    it "should return the number of Affected Rows" do
+      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})[:numrows].should == 1
+    end
 
-  it "should return the number of Affected Rows" do
-    @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})[:numrows].should == 1
+    it "should return the Result Code" do
+      @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})[:result].should == 1
+    end
   end
 
-  it "should return the Result Code" do
-    @db.call_mssql_sproc(:SequelTest, {:args => [@now, 1, :output, :output]})[:result].should == 1
+  describe "with named parameters" do
+    it "should return a hash of output variables" do
+      r = @db.call_mssql_sproc(:SequelTest, :args => {
+        'Input' => @now,
+        'IntegerInput' => 1,
+        'Output' => [:output, nil, 'output'],
+        'IntegerOutput' => [:output, nil, 'integer_output']
+      })
+      r.should be_a_kind_of(Hash)
+      r.values_at(:output, :integer_output).should == [@now, '1']
+    end
+
+    it "should support typed output variables" do
+      @db.call_mssql_sproc(:SequelTest, :args => {
+        'Input' => @now,
+        'IntegerInput' => 1,
+        'Output' => [:output, nil, 'output'],
+        'IntegerOutput' => [:output, 'int', 'integer_output']
+      })[:integer_output].should == 1
+    end
+
+    it "should return the number of Affected Rows" do
+      @db.call_mssql_sproc(:SequelTest, :args => {
+        'Input' => @now,
+        'IntegerInput' => 1,
+        'Output' => [:output, nil, 'output'],
+        'IntegerOutput' => [:output, nil, 'integer_output']
+      })[:numrows].should == 1
+    end
+
+    it "should return the Result Code" do
+      @db.call_mssql_sproc(:SequelTest, :args => {
+        'Input' => @now,
+        'IntegerInput' => 1,
+        'Output' => [:output, nil, 'output'],
+        'IntegerOutput' => [:output, nil, 'integer_output']
+      })[:result].should == 1
+    end
   end
 end unless DB.adapter_scheme == :odbc

data/spec/adapters/mysql_spec.rb

@@ -520,6 +520,17 @@ describe "A MySQL database" do
     end
   end
 
+  specify "should correctly format ALTER TABLE statements with named foreign keys" do
+    @db.create_table(:items){Integer :id}
+    @db.create_table(:users){primary_key :id}
+    @db.alter_table(:items){add_foreign_key :p_id, :users, :key => :id, :null => false, :on_delete => :cascade, :foreign_key_constraint_name => :pk_items__users }
+    check_sqls do
+      @db.sqls.should == ["CREATE TABLE `items` (`id` integer)",
+        "CREATE TABLE `users` (`id` integer PRIMARY KEY AUTO_INCREMENT)",
+        "ALTER TABLE `items` ADD COLUMN `p_id` integer NOT NULL, ADD CONSTRAINT `pk_items__users` FOREIGN KEY (`p_id`) REFERENCES `users`(`id`) ON DELETE CASCADE"]
+    end
+  end
+
   specify "should have rename_column support keep existing options" do
     @db.create_table(:items){String :id, :null=>false, :default=>'blah'}
     @db.alter_table(:items){rename_column :id, :nid}

data/spec/bin_spec.rb

@@ -140,7 +140,7 @@ END
   end
 
   it "-E should echo SQL statements to stdout" do
-    bin(:args=>'-E -c DB.tables').should =~ %r{I, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) PRAGMA foreign_keys = 1\nI, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) PRAGMA case_sensitive_like = 1\nI, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
+    bin(:args=>'-E -c DB.tables').should =~ %r{SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
   end
 
   it "-I should include directory in load path" do
@@ -149,7 +149,7 @@ END
 
   it "-l should log SQL statements to file" do
     bin(:args=>"-l #{TMP_FILE} -c DB.tables").should == ''
-    File.read(TMP_FILE).should =~ %r{I, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) PRAGMA foreign_keys = 1\nI, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) PRAGMA case_sensitive_like = 1\nI, \[\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d+ #\d+\]  INFO -- : \(\d\.\d+s\) SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
+    File.read(TMP_FILE).should =~ %r{SELECT \* FROM `sqlite_master` WHERE \(type = 'table' AND NOT name = 'sqlite_sequence'\)\n}
   end
 
   it "-L should load all *.rb files in given directory" do

data/spec/core/database_spec.rb

@@ -927,7 +927,6 @@ describe "Database#transaction with savepoint support" do
   it_should_behave_like "Database#transaction"
 
   specify "should support after_commit inside savepoints" do
-    meta_def(@db, :supports_savepoints?){true}
     @db.transaction do
       @db.after_commit{@db.execute('foo')}
       @db.transaction(:savepoint=>true){@db.after_commit{@db.execute('bar')}}
@@ -937,7 +936,6 @@ describe "Database#transaction with savepoint support" do
   end
 
   specify "should support after_rollback inside savepoints" do
-    meta_def(@db, :supports_savepoints?){true}
     @db.transaction do
       @db.after_rollback{@db.execute('foo')}
       @db.transaction(:savepoint=>true){@db.after_rollback{@db.execute('bar')}}
@@ -948,14 +946,12 @@ describe "Database#transaction with savepoint support" do
   end
 
   specify "should raise an error if you attempt to use after_commit inside a savepoint in a prepared transaction" do
-    meta_def(@db, :supports_savepoints?){true}
     meta_def(@db, :supports_prepared_transactions?){true}
     proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{@db.execute('foo')}}}}.should raise_error(Sequel::Error)
     @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
   end
 
   specify "should raise an error if you attempt to use after_rollback inside a savepoint in a prepared transaction" do
-    meta_def(@db, :supports_savepoints?){true}
     meta_def(@db, :supports_prepared_transactions?){true}
     proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{@db.execute('foo')}}}}.should raise_error(Sequel::Error)
     @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1','ROLLBACK TO SAVEPOINT autopoint_1', 'ROLLBACK']
@@ -1023,6 +1019,25 @@ describe "Database#transaction with savepoints" do
     @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
   end
   
+  specify "should use savepoints if surrounding transaction uses :auto_savepoint option" do
+    @db.transaction(:auto_savepoint=>true){@db.transaction{@db.execute 'DROP TABLE test;'}}
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+
+    @db.transaction(:auto_savepoint=>true){@db.transaction{@db.transaction{@db.execute 'DROP TABLE test;'}}}
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+
+    @db.transaction(:auto_savepoint=>true){@db.transaction(:auto_savepoint=>true){@db.transaction{@db.execute 'DROP TABLE test;'}}}
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+
+    @db.transaction{@db.transaction(:auto_savepoint=>true, :savepoint=>true){@db.transaction{@db.execute 'DROP TABLE test;'}}}
+    @db.sqls.should == ['BEGIN', 'SAVEPOINT autopoint_1', 'SAVEPOINT autopoint_2', 'DROP TABLE test;', 'RELEASE SAVEPOINT autopoint_2', 'RELEASE SAVEPOINT autopoint_1', 'COMMIT']
+  end
+
+  specify "should not use savepoints if surrounding transaction uses :auto_savepoint and current transaction uses :savepoint=>false option" do
+    @db.transaction(:auto_savepoint=>true){@db.transaction(:savepoint=>false){@db.execute 'DROP TABLE test;'}}
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
+  end
+  
   specify "should not use a savepoint if no transaction is in progress" do
     @db.transaction(:savepoint=>true){@db.execute 'DROP TABLE test;'}
     @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'COMMIT']
@@ -2434,3 +2449,22 @@ describe "Database#schema_type_class" do
     end
   end
 end
+
+describe "Database#execute_{dui,ddl,insert}" do
+  before do
+    @db = Sequel::Database.new
+    def @db.execute(sql, opts={})
+      (@sqls ||= []) << sql
+    end
+    def @db.sqls
+      @sqls
+    end
+  end
+
+  specify "should execute the SQL" do
+    @db.execute_dui "DELETE FROM table"
+    @db.execute_ddl "SET foo"
+    @db.execute_insert "INSERT INTO table DEFAULT VALUES"
+    @db.sqls.should == ["DELETE FROM table", "SET foo", "INSERT INTO table DEFAULT VALUES"]
+  end
+end