sequel 3.11.0 → 3.12.0

data/lib/sequel/plugins/string_stripper.rb

@@ -0,0 +1,26 @@
+module Sequel
+  module Plugins
+    # StringStripper is a very simple plugin that strips all input strings
+    # when assigning to the model's values. Example:
+    #
+    #   album = Album.new(:name=>' A ')
+    #   album.name # => 'A'
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances strip strings (called before loading subclasses)
+    #   Sequel::Model.plugin :string_stripper
+    #
+    #   # Make the Album class strip strings
+    #   Album.plugin :string_stripper
+    module StringStripper
+      module InstanceMethods
+        # Strip value if it is a string, before attempting to assign
+        # it to the model's values.
+        def []=(k, v)
+          v.is_a?(String) ? super(k, v.strip) : super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -17,6 +17,14 @@ module Sequel
     #   Album.filter{id<100}.all do |a|
     #     a.artists
     #   end
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances use tactical eager loading (called before loading subclasses)
+    #   Sequel::Model.plugin :tactical_eager_loading
+    #
+    #   # Make the Album class use tactical eager loading
+    #   Album.plugin :tactical_eager_loading
     module TacticalEagerLoading
       module InstanceMethods
         # The dataset that retrieved this object, set if the object was

data/lib/sequel/plugins/timestamps.rb

@@ -5,6 +5,19 @@ module Sequel
     # can also set whether to overwrite existing create timestamps (false
     # by default), or whether to set the update timestamp when creating (also
     # false by default).
+    # 
+    # Usage:
+    #
+    #   # Timestamp all model instances using +created_at+ and +updated_at+
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :timestamps
+    #
+    #   # Timestamp Album instances, with custom column names
+    #   Album.plugin :timestamps, :create=>:created_on, :update=>:updated_on
+    #
+    #   # Timestamp Artist instances, forcing an overwrite of the create
+    #   # timestamp, and setting the update timestamp when creating
+    #   Album.plugin :timestamps, :force=>true, :update_on_create=>true
     module Timestamps
       # Configure the plugin by setting the avialable options.  Note that
       # if this method is run more than once, previous settings are ignored,
@@ -51,14 +64,14 @@ module Sequel
       module InstanceMethods
         # Set the create timestamp when creating
         def before_create
-          super
           set_create_timestamp
+          super
         end
         
         # Set the update timestamp when updating
         def before_update
-          super
           set_update_timestamp
+          super
         end
         
         private

data/lib/sequel/plugins/touch.rb

@@ -13,6 +13,19 @@ module Sequel
     # on datasets, so it updates all related rows in a single query, using
     # the SQL standard CURRENT_TIMESTAMP.  Both of these can be overridden
     # easily if necessary.
+    # 
+    # Usage:
+    #
+    #   # Allow touching of all model instances (called before loading subclasses)
+    #   Sequel::Model.plugin :touch
+    #
+    #   # Allow touching of Album instances, with a custom column
+    #   Album.plugin :touch, :column=>:updated_on
+    #
+    #   # Allow touching of Artist instances, updating the albums and tags
+    #   # associations when touching, touching the +updated_on+ column for
+    #   # albums and the +updated_at+ column for tags
+    #   Artist.plugin :touch, :associations=>[{:albums=>:updated_on}, :tags]
     module Touch
       # The default column to update when touching
       TOUCH_COLUMN_DEFAULT = :updated_at

data/lib/sequel/plugins/update_primary_key.rb

@@ -0,0 +1,48 @@
+module Sequel
+  module Plugins
+    # The update_primary_key plugin allows you to modify an objects
+    # primary key and then save the record.  Sequel does not work
+    # correctly with primary key modifications by default.  Sequel
+    # is designed to work with surrogate primary keys that never need to be
+    # modified, but this plugin makes it work correctly with natural
+    # primary keys that may need to be modified. Example:
+    #
+    #   album = Album[1]
+    #   album.id = 2
+    #   album.save
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support primary key updates
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :update_primary_key
+    #
+    #   # Make the Album class support primary key updates
+    #   Album.plugin :update_primary_key
+    module UpdatePrimaryKey
+      module ClassMethods
+        # Cache the pk_hash when loading records
+        def load(h)
+          r = super(h)
+          r.pk_hash
+          r
+        end
+      end
+
+      module InstanceMethods
+        # Clear the pk_hash and object dataset cache, and recache
+        # the pk_hash
+        def after_update
+          super
+          @pk_hash = nil
+          pk_hash
+        end
+
+        # Cache the pk_hash instead of generating it every time
+        def pk_hash
+          @pk_hash ||= super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -7,6 +7,14 @@ module Sequel
     #
     # It is recommended to use the validation_helpers plugin instead of this one,
     # as it is less complex and more flexible.
+    # 
+    # Usage:
+    #
+    #   # Add the validation class methods to all model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :validation_class_methods
+    #
+    #   # Add the validation class methods to the Album class
+    #   Album.plugin :validation_class_methods
     module ValidationClassMethods
       # Setup the validations hash for the given model.
       def self.apply(model)

data/lib/sequel/plugins/validation_helpers.rb

@@ -3,8 +3,8 @@ module Sequel
     # The validation_helpers plugin contains instance method equivalents for most of the legacy
     # class-level validations.  The names and APIs are different, though. Example:
     #
+    #   Sequel::Model.plugin :validation_helpers
     #   class Album < Sequel::Model
-    #     plugin :validation_helpers
     #     def validate
     #       validates_min_length 1, :num_tracks
     #     end

data/lib/sequel/sql.rb

@@ -68,23 +68,32 @@ module Sequel
       end
       private_class_method :to_s_method
 
+      # Alias of eql?
+      def ==(other)
+        eql?(other)
+      end
+
+      # Returns true if the receiver is the same expression as the
+      # the +other+ expression.
+      def eql?(other)
+        other.is_a?(self.class) && !self.class.comparison_attrs.find {|a| send(a) != other.send(a)}
+      end
+
+      # Make sure that the hash value is the same if the attributes are the same.
+      def hash
+        ([self.class] + self.class.comparison_attrs.map{|x| send(x)}).hash
+      end
+
       # Returns self, because SQL::Expression already acts like
       # LiteralString.
       def lit
         self
       end
       
-      # Alias for to_s
+      # Alias of to_s
       def sql_literal(ds)
         to_s(ds)
       end
-
-      # Returns true if the receiver is the same expression as the
-      # the +other+ expression.
-      def eql?(other)
-        other.is_a?(self.class) && !self.class.comparison_attrs.find {|a| send(a) != other.send(a)}
-      end
-      alias == eql?
     end
 
     # Represents a complex SQL expression, with a given operator and one
@@ -559,12 +568,6 @@ module Sequel
         @table = table
       end
 
-      # ColumnAll expressions are considered equivalent if they
-      # have the same class and string representation
-      def ==(x)
-        x.class == self.class and @table == x.table
-      end
-
       to_s_method :column_all_sql
     end
     
@@ -626,12 +629,6 @@ module Sequel
         @f, @args = f, args
       end
 
-      # Functions are considered equivalent if they
-      # have the same class, function, and arguments.
-      def ==(x)
-         x.class == self.class && @f == x.f && @args == x.args
-      end
-
       to_s_method :function_sql
     end
     

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 3
-  MINOR = 11
+  MINOR = 12
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/postgres_spec.rb

@@ -541,7 +541,7 @@ context "Postgres::Database schema qualified tables" do
   after do
     POSTGRES_DB.quote_identifiers = false
     POSTGRES_DB << "DROP SCHEMA schema_test CASCADE"
-    POSTGRES_DB.default_schema = :public
+    POSTGRES_DB.default_schema = nil
   end
   
   specify "should be able to create, drop, select and insert into tables in a given schema" do
@@ -914,7 +914,7 @@ context "Postgres::Database functions, languages, and triggers" do
   specify "#create_trigger and #drop_trigger should create and drop triggers" do
     @d.create_language(:plpgsql)
     @d.create_function(:tf, 'BEGIN IF NEW.value IS NULL THEN RAISE EXCEPTION \'Blah\'; END IF; RETURN NEW; END;', :language=>:plpgsql, :returns=>:trigger)
-    @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON public.test FOR EACH ROW EXECUTE PROCEDURE tf()'
+    @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON test FOR EACH ROW EXECUTE PROCEDURE tf()'
     @d.create_table(:test){String :name; Integer :value}
     @d.create_trigger(:test, :identity, :tf, :each_row=>true)
     @d[:test].insert(:name=>'a', :value=>1)
@@ -923,10 +923,10 @@ context "Postgres::Database functions, languages, and triggers" do
     @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>1}]
     @d[:test].filter(:name=>'a').update(:value=>3)
     @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>3}]
-    @d.send(:drop_trigger_sql, :test, :identity).should == 'DROP TRIGGER identity ON public.test'
+    @d.send(:drop_trigger_sql, :test, :identity).should == 'DROP TRIGGER identity ON test'
     @d.drop_trigger(:test, :identity)
-    @d.send(:create_trigger_sql, :test, :identity, :tf, :after=>true, :events=>:insert, :args=>[1, 'a']).should == 'CREATE TRIGGER identity AFTER INSERT ON public.test EXECUTE PROCEDURE tf(1, \'a\')'
-    @d.send(:drop_trigger_sql, :test, :identity, :if_exists=>true, :cascade=>true).should == 'DROP TRIGGER IF EXISTS identity ON public.test CASCADE'
+    @d.send(:create_trigger_sql, :test, :identity, :tf, :after=>true, :events=>:insert, :args=>[1, 'a']).should == 'CREATE TRIGGER identity AFTER INSERT ON test EXECUTE PROCEDURE tf(1, \'a\')'
+    @d.send(:drop_trigger_sql, :test, :identity, :if_exists=>true, :cascade=>true).should == 'DROP TRIGGER IF EXISTS identity ON test CASCADE'
     # Make sure if exists works
     @d.drop_trigger(:test, :identity, :if_exists=>true, :cascade=>true)
   end

data/spec/core/core_sql_spec.rb

@@ -410,8 +410,24 @@ context "Sequel::SQL::OrderedExpression" do
 end
 
 context "Expression" do
-  specify "should ==" do
+  specify "should consider objects == only if they have the same attributes" do
     :column.qualify(:table).cast(:type).*(:numeric_column).asc.should == :column.qualify(:table).cast(:type).*(:numeric_column).asc
     :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.should_not == :column.qualify(:table).cast(:type).*(:numeric_column).asc
+
+    :column.qualify(:table).cast(:type).*(:numeric_column).asc.should eql(:column.qualify(:table).cast(:type).*(:numeric_column).asc)
+    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.should_not eql(:column.qualify(:table).cast(:type).*(:numeric_column).asc)
+  end
+
+  specify "should use the same hash value for objects that have the same attributes" do
+    :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash.should == :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash
+    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.hash.should_not == :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash
+
+    h = {}
+    a = :column.qualify(:table).cast(:type).*(:numeric_column).asc
+    b = :column.qualify(:table).cast(:type).*(:numeric_column).asc
+    h[a] = 1
+    h[b] = 2
+    h[a].should == 2
+    h[b].should == 2
   end
 end

data/spec/core/database_spec.rb

@@ -204,8 +204,8 @@ context "Sequel.extension" do
 end
 
 context "Database#connect" do
-  specify "should raise NotImplementedError" do
-    proc {Sequel::Database.new.connect(:default)}.should raise_error(NotImplementedError)
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.connect(:default)}.should raise_error(Sequel::NotImplemented)
   end
 end
 
@@ -363,9 +363,21 @@ context "Database#dataset" do
 end
 
 context "Database#execute" do
-  specify "should raise NotImplementedError" do
-    proc {Sequel::Database.new.execute('blah blah')}.should raise_error(NotImplementedError)
-    proc {Sequel::Database.new << 'blah blah'}.should raise_error(NotImplementedError)
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.execute('blah blah')}.should raise_error(Sequel::NotImplemented)
+    proc {Sequel::Database.new << 'blah blah'}.should raise_error(Sequel::NotImplemented)
+  end
+end
+
+context "Database#tables" do
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.tables}.should raise_error(Sequel::NotImplemented)
+  end
+end
+
+context "Database#indexes" do
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.indexes(:table)}.should raise_error(Sequel::NotImplemented)
   end
 end
 

data/spec/core/dataset_spec.rb

@@ -1316,24 +1316,47 @@ context "Dataset#order_by" do
   end
 end
 
-context "Dataset#order_more" do
+context "Dataset#order_more and order_append" do
   before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
   end
   
   specify "should include an ORDER BY clause in the select statement" do
-    @dataset.order_more(:name).sql.should == 
-      'SELECT * FROM test ORDER BY name'
+    @dataset.order_more(:name).sql.should == 'SELECT * FROM test ORDER BY name'
+    @dataset.order_append(:name).sql.should == 'SELECT * FROM test ORDER BY name'
   end
   
-  specify "should add to a previous ordering" do
-    @dataset.order(:name).order_more(:stamp.desc).sql.should ==
-      'SELECT * FROM test ORDER BY name, stamp DESC'
+  specify "should add to the end of a previous ordering" do
+    @dataset.order(:name).order_more(:stamp.desc).sql.should == 'SELECT * FROM test ORDER BY name, stamp DESC'
+    @dataset.order(:name).order_append(:stamp.desc).sql.should == 'SELECT * FROM test ORDER BY name, stamp DESC'
   end
 
   specify "should accept a block that yields a virtual row" do
     @dataset.order(:a).order_more{|o| o.b}.sql.should == 'SELECT * FROM test ORDER BY a, b'
     @dataset.order(:a, :b).order_more(:c, :d){[e, f(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY a, b, c, d, e, f(1, 2)'
+    @dataset.order(:a).order_append{|o| o.b}.sql.should == 'SELECT * FROM test ORDER BY a, b'
+    @dataset.order(:a, :b).order_append(:c, :d){[e, f(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY a, b, c, d, e, f(1, 2)'
+  end
+end
+
+context "Dataset#order_prepend" do
+  before do
+    @dataset = Sequel::Dataset.new(nil).from(:test)
+  end
+  
+  specify "should include an ORDER BY clause in the select statement" do
+    @dataset.order_prepend(:name).sql.should == 
+      'SELECT * FROM test ORDER BY name'
+  end
+  
+  specify "should add to the beginning of a previous ordering" do
+    @dataset.order(:name).order_prepend(:stamp.desc).sql.should ==
+      'SELECT * FROM test ORDER BY stamp DESC, name'
+  end
+
+  specify "should accept a block that yields a virtual row" do
+    @dataset.order(:a).order_prepend{|o| o.b}.sql.should == 'SELECT * FROM test ORDER BY b, a'
+    @dataset.order(:a, :b).order_prepend(:c, :d){[e, f(1, 2)]}.sql.should == 'SELECT * FROM test ORDER BY c, d, e, f(1, 2), a, b'
   end
 end
 
@@ -3074,8 +3097,8 @@ context "Dataset default #fetch_rows, #insert, #update, #delete, #truncate, #exe
     @ds = @db[:items]
   end
 
-  specify "#fetch_rows should raise a NotImplementedError" do
-    proc{@ds.fetch_rows(''){}}.should raise_error(NotImplementedError)
+  specify "#fetch_rows should raise a Sequel::NotImplemented" do
+    proc{@ds.fetch_rows(''){}}.should raise_error(Sequel::NotImplemented)
   end
 
   specify "#delete should execute delete SQL" do

data/spec/core/schema_generator_spec.rb

@@ -12,6 +12,7 @@ describe Sequel::Schema::Generator do
       index :title
       index [:title, :body], :unique => true
       foreign_key :node_id, :nodes
+      foreign_key :deferrable_node_id, :nodes, :deferrable => true
       primary_key [:title, :parent_id], :name => :cpk
       foreign_key [:node_id, :prop_id], :nodes_props, :name => :cfk
     end
@@ -26,7 +27,7 @@ describe Sequel::Schema::Generator do
   end
   
   it "counts definitions correctly" do
-    @columns.size.should == 5
+    @columns.size.should == 6
     @indexes.size.should == 2
     @constraints.size.should == 4
   end
@@ -48,6 +49,12 @@ describe Sequel::Schema::Generator do
     @columns[4][:name].should == :node_id
     @columns[4][:type].should == Integer
   end
+
+  it "creates deferrable altered foreign key column" do
+    @columns[5][:name].should == :deferrable_node_id
+    @columns[5][:type].should == Integer
+    @columns[5][:deferrable].should == true
+  end
   
   it "uses table for foreign key columns, if specified" do
     @columns[3][:table].should == nil

data/spec/core/schema_spec.rb

@@ -23,6 +23,12 @@ context "DB#create_table" do
     proc{@db.create_table(:cats.as(:c)) {}}.should raise_error(Sequel::Error)
   end
 
+  specify "should remove cached schema entry" do
+    @db.instance_variable_set(:@schemas, {'cats'=>[]})
+    @db.create_table(:cats){Integer :a}
+    @db.instance_variable_get(:@schemas).should be_empty
+  end
+  
   specify "should accept multiple columns" do
     @db.create_table(:cats) do
       column :id, :integer
@@ -268,6 +274,13 @@ context "DB#create_table" do
     @db.sqls.clear
   end
   
+  specify "should accept foreign keys with deferrable option" do
+    @db.create_table(:cats) do
+      foreign_key :project_id, :projects, :deferrable=>true
+    end
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects DEFERRABLE INITIALLY DEFERRED)"]
+  end
+
   specify "should accept inline index definition" do
     @db.create_table(:cats) do
       integer :id, :index => true