sequel 3.43.0 → 3.44.0

data/lib/sequel/model/base.rb

@@ -1934,6 +1934,35 @@ module Sequel
         end
       end
 
+      # If there is no order already defined on this dataset, order it by
+      # the primary key and call last.
+      #
+      #   Album.last
+      #   # SELECT * FROM albums ORDER BY id DESC LIMIT 1
+      def last(*a, &block)
+        if opts[:order].nil? && model && (pk = model.primary_key)
+          order(*pk).last(*a, &block)
+        else
+          super
+        end
+      end
+
+      # If there is no order already defined on this dataset, order it by
+      # the primary key and call paged_each.
+      #
+      #   Album.paged_each{|row| ...}
+      #   # SELECT * FROM albums ORDER BY id LIMIT 1000 OFFSET 0
+      #   # SELECT * FROM albums ORDER BY id LIMIT 1000 OFFSET 1000
+      #   # SELECT * FROM albums ORDER BY id LIMIT 1000 OFFSET 2000
+      #   # ...
+      def paged_each(*a, &block)
+        if opts[:order].nil? && model && (pk = model.primary_key)
+          order(*pk).paged_each(*a, &block)
+        else
+          super
+        end
+      end
+
       # This allows you to call +to_hash+ without any arguments, which will
       # result in a hash with the primary key value being the key and the
       # model object being the value.
@@ -1946,7 +1975,7 @@ module Sequel
         if key_column
           super
         else
-          raise(Sequel::Error, "No primary key for model") unless model and pk = model.primary_key
+          raise(Sequel::Error, "No primary key for model") unless model && (pk = model.primary_key)
           super(pk, value_column) 
         end
       end

data/lib/sequel/plugins/eager_each.rb

@@ -12,7 +12,7 @@ module Sequel
     # #each, this is a bit of issue, but this plugin resolves the issue by cloning the dataset
     # and setting a new flag in the cloned dataset, so that each can check with the flag to
     # determine whether it should call all.
-    # 
+    #
     # Usage:
     #
     #   # Make all model subclass instances eagerly load for each (called before loading subclasses)
@@ -21,37 +21,33 @@ module Sequel
     #   # Make the Album class eagerly load for each
     #   Album.plugin :eager_each
     module EagerEach 
-      # Methods added to eagerly loaded datasets when the eager_each plugin is in use.
-      module EagerDatasetMethods
-        # Call #all instead of #each unless #each is being called by #all.
+      module DatasetMethods
+        # Call #all instead of #each if eager loading,
+        # uless #each is being called by #all.
         def each(&block)
-          if opts[:all_called]
-            super
-          else
+          if use_eager_all?
             all(&block)
+          else
+            super
           end
         end
 
-        # Clone the dataset and set a flag to let #each know not to call #all,
+        # If eager loading, clone the dataset and set a flag to let #each know not to call #all,
         # to avoid the infinite loop.
         def all(&block)
-          if opts[:all_called]
-            super
-          else
+          if use_eager_all?
             clone(:all_called=>true).all(&block)
+          else
+            super
           end
         end
-      end
 
-      module DatasetMethods
-        # Make sure calling each on this dataset will eagerly load the dataset.
-        def eager(*)
-          super.extend(EagerDatasetMethods)
-        end
-        
-        # Make sure calling each on this dataset will eagerly load the dataset.
-        def eager_graph(*)
-          super.extend(EagerDatasetMethods)
+        private
+
+        # Wether to use all when each is called, true when eager loading
+        # unless the flag has already been set.
+        def use_eager_all?
+          (opts[:eager] || opts[:eager_graph]) && !opts[:all_called]
         end
       end
     end

data/lib/sequel/plugins/identity_map.rb

@@ -36,7 +36,7 @@ module Sequel
       module ClassMethods
         # Override the default :eager_loader option for many_*_many associations to work
         # with an identity_map.  If the :eager_graph association option is used, you'll probably have to use
-        # :uniq=>true on the current association amd :cartesian_product_number=>2 on the association
+        # :uniq=>true on the current association and :cartesian_product_number=>2 on the association
         # mentioned by :eager_graph, otherwise you'll end up with duplicates because the row proc will be
         # getting called multiple times for the same object.  If you do have duplicates and you use :eager_graph,
         # they'll probably be lost.  Making that work correctly would require changing a lot of the core
@@ -52,6 +52,7 @@ module Sequel
             uses_lcks = opts[:uses_left_composite_keys]
             uses_rcks = opts[:uses_right_composite_keys]
             right = opts[:right_key]
+            rcks = opts[:right_keys]
             join_table = opts[:join_table]
             left = opts[:left_key]
             lcks = opts[:left_keys]

data/lib/sequel/plugins/many_through_many.rb

@@ -192,7 +192,7 @@ module Sequel
           lpkc = opts[:left_primary_key_column] ||= left_pk
           lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
           opts[:dataset] ||= lambda do
-            ds = opts.associated_class
+            ds = opts.associated_dataset
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
             ft = opts.final_reverse_edge
             ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])) + opts.predicate_keys.zip(left_pks.map{|k| send(k)}), :table_alias=>ft[:alias], :qualify=>:deep)

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -59,8 +59,8 @@ module Sequel
     #   # which are different but do not require different code.
     #   Employee.plugin :single_table_inheritance, :type,
     #     :model_map=>{'staff' => "Staff",
-    #                  'manager => "Manager",
-    #                  'overpayed staff => "Staff",
+    #                  'manager' => "Manager",
+    #                  'overpayed staff' => "Staff",
     #                  'underpayed staff' => "Staff"}
     #
     # One minor issue to note is that if you specify the <tt>:key_map</tt>

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -60,7 +60,7 @@ module Sequel
       module DatasetMethods
         private
 
-        # Set the reteived_with and retrieved_by attributes for the object
+        # Set the retrieved_with and retrieved_by attributes for the object
         # with the current dataset and array of all objects.
         def post_load(objects)
           super

data/lib/sequel/sql.rb

@@ -1497,8 +1497,8 @@ module Sequel
     #
     # An instance of this class is yielded to the block supplied to <tt>Dataset#filter</tt>, <tt>Dataset#order</tt>, and <tt>Dataset#select</tt>
     # (and the other methods that accept a block and pass it to one of those methods).
-    # If the block doesn't take an argument, the block is instance_evaled in the context of
-    # a new instance of this class.
+    # If the block doesn't take an argument, the block is instance_execed in the context of
+    # an instance of this class.
     #
     # +VirtualRow+ uses +method_missing+ to return either an +Identifier+, +QualifiedIdentifier+, +Function+, or +WindowFunction+, 
     # depending on how it is called.
@@ -1621,6 +1621,8 @@ module Sequel
           Function.new(m, *args)
         end
       end
+
+      Sequel::VIRTUAL_ROW = new
     end
 
     # A +Window+ is part of a window function specifying the window over which the function operates.

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 43
+  MINOR = 44
   # 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

@@ -48,6 +48,28 @@ describe "PostgreSQL", '#create_table' do
   end
 end
 
+describe "PostgreSQL temporary views" do
+  before do
+    @db = POSTGRES_DB
+    @db.drop_view(:items_view) rescue nil
+    @db.create_table!(:items){Integer :number}
+    @db[:items].insert(10)
+    @db[:items].insert(20)
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+
+  specify "should be supported" do
+    @db.create_view(:items_view, @db[:items].where(:number=>10), :temp=>true)
+    @db[:items_view].map(:number).should == [10]
+    @db.create_or_replace_view(:items_view, @db[:items].where(:number=>20),  :temp=>true)
+    @db[:items_view].map(:number).should == [20]
+    @db.disconnect
+    lambda{@db[:items_view].map(:number)}.should raise_error(Sequel::DatabaseError)
+  end
+end unless POSTGRES_DB.adapter_scheme == :do # Causes freezing later
+    
 describe "A PostgreSQL database" do
   before(:all) do
     @db = POSTGRES_DB
@@ -61,6 +83,14 @@ describe "A PostgreSQL database" do
     @db.server_version.should > 70000
   end
 
+  specify "should not typecast the int2vector type incorrectly" do
+    @db.get(Sequel.cast('10 20', :int2vector)).should_not == 10
+  end
+
+  cspecify "should not typecast the money type incorrectly", :do do
+    @db.get(Sequel.cast('10.01', :money)).should_not == 0
+  end
+
   specify "should correctly parse the schema" do
     @db.schema(:public__testfk, :reload=>true).should == [
       [:id, {:type=>:integer, :ruby_default=>nil, :db_type=>"integer", :default=>"nextval('testfk_id_seq'::regclass)", :oid=>23, :primary_key=>true, :allow_null=>false}],
@@ -149,13 +179,13 @@ describe "A PostgreSQL dataset" do
     @db.create_table!(:atest){Integer :t; exclude [[Sequel.desc(:t, :nulls=>:last), '=']], :using=>:btree, :where=>proc{t > 0}}
     @db[:atest].insert(1)
     @db[:atest].insert(2)
-    proc{@db[:atest].insert(2)}.should raise_error(Sequel::DatabaseError)
+    proc{@db[:atest].insert(2)}.should raise_error(Sequel::Postgres::ExclusionConstraintViolation)
 
     @db.create_table!(:atest){Integer :t}
     @db.alter_table(:atest){add_exclusion_constraint [[:t, '=']], :using=>:btree, :name=>'atest_ex'}
     @db[:atest].insert(1)
     @db[:atest].insert(2)
-    proc{@db[:atest].insert(2)}.should raise_error(Sequel::DatabaseError)
+    proc{@db[:atest].insert(2)}.should raise_error(Sequel::Postgres::ExclusionConstraintViolation)
     @db.alter_table(:atest){drop_constraint 'atest_ex'}
   end if POSTGRES_DB.server_version >= 90000
 

data/spec/adapters/sqlite_spec.rb

@@ -175,6 +175,26 @@ describe "An SQLite database" do
   end
 end
 
+describe "SQLite temporary views" do
+  before do
+    @db = SQLITE_DB
+    @db.drop_view(:items) rescue nil
+    @db.create_table!(:items){Integer :number}
+    @db[:items].insert(10)
+    @db[:items].insert(20)
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+
+  specify "should be supported" do
+    @db.create_view(:items_view, @db[:items].where(:number=>10),  :temp=>true)
+    @db[:items_view].map(:number).should == [10]
+    @db.disconnect
+    lambda{@db[:items_view].map(:number)}.should raise_error(Sequel::DatabaseError)
+  end
+end
+    
 describe "SQLite type conversion" do
   before do
     @db = SQLITE_DB

data/spec/core/database_spec.rb

@@ -479,6 +479,26 @@ describe "Database#extend_datasets" do
   end
 end
   
+describe "Database#disconnect_connection" do
+  specify "should call close on the connection" do
+    o = Object.new
+    def o.close() @closed=true end
+    Sequel::Database.new.disconnect_connection(o)
+    o.instance_variable_get(:@closed).should be_true
+  end
+end
+
+describe "Database#valid_connection?" do
+  specify "should issue a query to validate the connection" do
+    db = Sequel.mock
+    db.synchronize{|c| db.valid_connection?(c)}.should be_true
+    db.synchronize do |c|
+      def c.execute(*) raise Sequel::DatabaseError, "error" end
+      db.valid_connection?(c)
+    end.should be_false
+  end
+end
+
 describe "Database#execute" do
   specify "should raise Sequel::NotImplemented" do
     proc {Sequel::Database.new.execute('blah blah')}.should raise_error(Sequel::NotImplemented)
@@ -1649,6 +1669,14 @@ describe "Database#raise_error" do
   specify "should convert the exception to a DatabaseDisconnectError if opts[:disconnect] is true" do
     proc{@db.send(:raise_error, Interrupt.new(''), :disconnect=>true)}.should raise_error(Sequel::DatabaseDisconnectError)
   end
+  
+  specify "should convert the exception to an appropriate error if exception message matches regexp" do
+    def @db.database_error_regexps
+      {/foo/ => Sequel::DatabaseDisconnectError, /bar/ => Sequel::ConstraintViolation}
+    end
+    proc{@db.send(:raise_error, Interrupt.new('foo'))}.should raise_error(Sequel::DatabaseDisconnectError)
+    proc{@db.send(:raise_error, Interrupt.new('bar'))}.should raise_error(Sequel::ConstraintViolation)
+  end
 end
 
 describe "Database#typecast_value" do
@@ -2018,6 +2046,18 @@ describe "Database#schema_autoincrementing_primary_key?" do
   end
 end
 
+describe "Database#supports_deferrable_constraints?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_deferrable_constraints?.should == false
+  end
+end
+
+describe "Database#supports_deferrable_foreign_key_constraints?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_deferrable_foreign_key_constraints?.should == false
+  end
+end
+
 describe "Database#supports_transactional_ddl?" do
   specify "should be false by default" do
     Sequel::Database.new.supports_transactional_ddl?.should == false

data/spec/core/dataset_spec.rb

@@ -40,6 +40,14 @@ describe "Dataset" do
     Sequel::Dataset.included_modules.should include(Enumerable)
   end
   
+  specify "should yield rows to each" do
+    ds = Sequel.mock[:t]
+    ds._fetch = {:x=>1}
+    called = false
+    ds.each{|a| called = true; a.should == {:x=>1}}
+    called.should be_true
+  end
+  
   specify "should get quote_identifiers default from database" do
     db = Sequel::Database.new(:quote_identifiers=>true)
     db[:a].quote_identifiers?.should == true
@@ -4359,10 +4367,6 @@ describe "Dataset feature defaults" do
   it "should not require placeholder type specifiers by default" do
     Sequel::Database.new.dataset.requires_placeholder_type_specifiers?.should be_false
   end
-
-  it "offset use should be returning a separate row number column by default" do
-    Sequel::Database.new.dataset.send(:offset_returns_row_number_column?).should be_false
-  end
 end
 
 describe "Dataset extensions" do
@@ -4465,6 +4469,11 @@ describe "Dataset#schema_and_table" do
     @ds.schema_and_table('s').should == [nil, 's']
   end
 
+  it "should correctly handle literal strings" do
+    s = Sequel.lit('s')
+    @ds.schema_and_table(s).last.should equal(s)
+  end
+
   it "should correctly handle identifiers" do
     @ds.schema_and_table(Sequel.identifier(:s)).should == [nil, 's']
   end
@@ -4521,3 +4530,81 @@ describe "Dataset#split_qualifiers" do
   end
 end
 
+describe "Dataset#paged_each" do
+  before do
+    @ds = Sequel.mock[:test].order(:x)
+    @db = (0...10).map{|i| {:x=>i}}
+    @ds._fetch = @db
+    @rows = []
+    @proc = lambda{|row| @rows << row}
+  end
+
+  it "should yield rows to the passed block" do
+    @ds.paged_each(&@proc)
+    @rows.should == @db
+  end
+
+  it "should respect the row_proc" do
+    @ds.row_proc = lambda{|row| {:x=>row[:x]*2}}
+    @ds.paged_each(&@proc)
+    @rows.should == @db.map{|row| {:x=>row[:x]*2}}
+  end
+
+  it "should use a transaction to ensure consistent results" do
+    @ds.paged_each(&@proc)
+    sqls = @ds.db.sqls
+    sqls[0].should == 'BEGIN'
+    sqls[-1].should == 'COMMIT'
+  end
+
+  it "should use a limit and offset to go through the dataset in chunks at a time" do
+    @ds.paged_each(&@proc)
+    @ds.db.sqls[1...-1].should == ['SELECT * FROM test ORDER BY x LIMIT 1000 OFFSET 0']
+  end
+
+  it "should accept a :rows_per_fetch option to change the number of rows per fetch" do
+    @ds._fetch = @db.each_slice(3).to_a
+    @ds.paged_each(:rows_per_fetch=>3, &@proc)
+    @rows.should == @db
+    @ds.db.sqls[1...-1].should == ['SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 0',
+      'SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 3',
+      'SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 6',
+      'SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 9']
+  end
+
+  it "should handle cases where the last query returns nothing" do
+    @ds._fetch = @db.each_slice(5).to_a
+    @ds.paged_each(:rows_per_fetch=>5, &@proc)
+    @rows.should == @db
+    @ds.db.sqls[1...-1].should == ['SELECT * FROM test ORDER BY x LIMIT 5 OFFSET 0',
+      'SELECT * FROM test ORDER BY x LIMIT 5 OFFSET 5',
+      'SELECT * FROM test ORDER BY x LIMIT 5 OFFSET 10']
+  end
+
+  it "should respect an existing server option to use" do
+    @ds = Sequel.mock(:servers=>{:foo=>{}})[:test].order(:x)
+    @ds._fetch = @db
+    @ds.server(:foo).paged_each(&@proc)
+    @rows.should == @db
+    @ds.db.sqls.should == ["BEGIN -- foo", "SELECT * FROM test ORDER BY x LIMIT 1000 OFFSET 0 -- foo", "COMMIT -- foo"]
+  end
+
+  it "should require an order" do
+    lambda{@ds.unordered.paged_each(&@proc)}.should raise_error(Sequel::Error)
+  end
+
+  it "should handle an existing limit and/or offset" do
+    @ds._fetch = @db.each_slice(3).to_a
+    @ds.limit(5).paged_each(:rows_per_fetch=>3, &@proc)
+    @ds.db.sqls[1...-1].should == ["SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 0", "SELECT * FROM test ORDER BY x LIMIT 2 OFFSET 3"]
+
+    @ds._fetch = @db.each_slice(3).to_a
+    @ds.limit(5, 2).paged_each(:rows_per_fetch=>3, &@proc)
+    @ds.db.sqls[1...-1].should == ["SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 2", "SELECT * FROM test ORDER BY x LIMIT 2 OFFSET 5"]
+
+    @ds._fetch = @db.each_slice(3).to_a
+    @ds.limit(nil, 2).paged_each(:rows_per_fetch=>3, &@proc)
+    @ds.db.sqls[1...-1].should == ["SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 2", "SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 5", "SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 8", "SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 11"]
+  end
+end
+