sequel 3.6.0 → 3.7.0

data/lib/sequel/plugins/validation_helpers.rb

@@ -153,6 +153,8 @@ module Sequel
         #
         # Possible Options:
         # * :message - The message to use (default: 'is already taken')
+        # * :only_if_modified - Only check the uniqueness if the object is new or
+        #   one of the columns has been modified.
         def validates_unique(*atts)
           opts = default_validation_helpers_options(:unique)
           if atts.last.is_a?(Hash)
@@ -160,9 +162,12 @@ module Sequel
           end
           message = validation_error_message(opts[:message])
           atts.each do |a|
-            ds = model.filter(Array(a).map{|x| [x, send(x)]})
+            arr = Array(a)
+            next if opts[:only_if_modified] && !new? && !arr.any?{|x| changed_columns.include?(x)}
+            ds = model.filter(arr.map{|x| [x, send(x)]})
             ds = yield(ds) if block_given?
-            errors.add(a, message) unless (new? ? ds : ds.exclude(pk_hash)).count == 0
+            ds = ds.exclude(pk_hash) unless new?
+            errors.add(a, message) unless ds.count == 0
           end
         end
         

data/lib/sequel/sql.rb

@@ -446,6 +446,10 @@ module Sequel
             new(:AND, new(:>=, l, r.begin), new(r.exclude_end? ? :< : :<=, l, r.end))
           when Array, ::Sequel::Dataset, SQLArray
             new(:IN, l, r)
+          when NegativeBooleanConstant
+            new(:"IS NOT", l, r.constant)
+          when BooleanConstant
+            new(:IS, l, r.constant)
           when NilClass, TrueClass, FalseClass
             new(:IS, l, r)
           when Regexp
@@ -553,6 +557,20 @@ module Sequel
       
       to_s_method :constant_sql, '@constant'
     end
+
+    # Represents boolean constants such as NULL, NOTNULL, TRUE, and FALSE.
+    class BooleanConstant < Constant
+      # The underlying constant related for this object.
+      attr_reader :constant
+
+      to_s_method :boolean_constant_sql, '@constant'
+    end
+    
+    # Represents inverse boolean constants (currently only NOTNULL). A
+    # special class to allow for special behavior
+    class NegativeBooleanConstant < BooleanConstant
+      to_s_method :negative_boolean_constant_sql, '@constant'
+    end
     
     # Holds default generic constants that can be referenced.  These
     # are included in the Sequel top level module and are also available
@@ -562,6 +580,10 @@ module Sequel
       CURRENT_DATE = Constant.new(:CURRENT_DATE)
       CURRENT_TIME = Constant.new(:CURRENT_TIME)
       CURRENT_TIMESTAMP = Constant.new(:CURRENT_TIMESTAMP)
+      SQLTRUE = TRUE = BooleanConstant.new(true)
+      SQLFALSE = FALSE = BooleanConstant.new(false)
+      NULL = BooleanConstant.new(nil)
+      NOTNULL = NegativeBooleanConstant.new(nil)
     end
 
     # Represents an SQL function call.

data/lib/sequel/version.rb

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

data/spec/adapters/postgres_spec.rb

@@ -147,6 +147,10 @@ context "A PostgreSQL dataset" do
     @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}.should == nil
     POSTGRES_DB.transaction{@d.lock('EXCLUSIVE').should == nil; @d.insert(:name=>'a')}
   end
+  
+  specify "should raise an error if attempting to update a joined dataset with a single FROM table" do
+    proc{POSTGRES_DB[:test].join(:test2, [:name]).update(:name=>'a')}.should raise_error(Sequel::Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs')
+  end
 end
 
 context "A PostgreSQL dataset with a timestamp field" do
@@ -235,6 +239,18 @@ context "A PostgreSQL database" do
     @db[:posts].order(:a).map(:a).should == [1, 2, 10, 20, 21]
   end
   
+  specify "should support specifying Integer/Bignum/Fixnum types in primary keys and have them be auto incrementing" do
+    @db.create_table(:posts){primary_key :a, :type=>Integer}
+    @db[:posts].insert.should == 1
+    @db[:posts].insert.should == 2
+    @db.create_table!(:posts){primary_key :a, :type=>Fixnum}
+    @db[:posts].insert.should == 1
+    @db[:posts].insert.should == 2
+    @db.create_table!(:posts){primary_key :a, :type=>Bignum}
+    @db[:posts].insert.should == 1
+    @db[:posts].insert.should == 2
+  end
+
   specify "should not raise an error if attempting to resetting the primary key sequence for a table without a primary key" do
     @db.create_table(:posts){Integer :a}
     @db.reset_primary_key_sequence(:posts).should == nil

data/spec/core/dataset_spec.rb

@@ -1489,6 +1489,25 @@ context "Dataset#group_and_count" do
   specify "should format column aliases in the select clause but not in the group clause" do
     @ds.group_and_count(:name___n).sql.should ==
       "SELECT name AS n, count(*) AS count FROM test GROUP BY name ORDER BY count"
+    @ds.group_and_count(:name__n).sql.should ==
+      "SELECT name.n, count(*) AS count FROM test GROUP BY name.n ORDER BY count"
+  end
+
+  specify "should handle identifiers" do
+    @ds.group_and_count(:name___n.identifier).sql.should ==
+      "SELECT name___n, count(*) AS count FROM test GROUP BY name___n ORDER BY count"
+  end
+
+  specify "should handle literal strings" do
+    @ds.group_and_count("name".lit).sql.should ==
+      "SELECT name, count(*) AS count FROM test GROUP BY name ORDER BY count"
+  end
+
+  specify "should handle aliased expressions" do
+    @ds.group_and_count(:name.as(:n)).sql.should ==
+      "SELECT name AS n, count(*) AS count FROM test GROUP BY name ORDER BY count"
+    @ds.group_and_count(:name.identifier.as(:n)).sql.should ==
+      "SELECT name AS n, count(*) AS count FROM test GROUP BY name ORDER BY count"
   end
 end
 
@@ -2095,6 +2114,15 @@ context "Dataset compound operations" do
       "SELECT * FROM (SELECT * FROM b WHERE (z = 2) EXCEPT ALL SELECT * FROM a WHERE (z = 1)) AS t1"
   end
     
+  specify "should support :alias option for specifying identifier" do
+    @a.union(@b, :alias=>:xx).sql.should == \
+      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) UNION SELECT * FROM b WHERE (z = 2)) AS xx"
+    @a.intersect(@b, :alias=>:xx).sql.should == \
+      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) INTERSECT SELECT * FROM b WHERE (z = 2)) AS xx"
+    @a.except(@b, :alias=>:xx).sql.should == \
+      "SELECT * FROM (SELECT * FROM a WHERE (z = 1) EXCEPT SELECT * FROM b WHERE (z = 2)) AS xx"
+  end
+
   specify "should support :from_self=>false option to not wrap the compound in a SELECT * FROM (...)" do
     @b.union(@a, :from_self=>false).sql.should == \
       "SELECT * FROM b WHERE (z = 2) UNION SELECT * FROM a WHERE (z = 1)"
@@ -3239,6 +3267,30 @@ describe Sequel::SQL::Constants do
     @db.literal(Sequel::SQL::Constants::CURRENT_TIMESTAMP) == 'CURRENT_TIMESTAMP'
     @db.literal(Sequel::CURRENT_TIMESTAMP) == 'CURRENT_TIMESTAMP'
   end
+
+  it "should have NULL" do
+    @db.literal(Sequel::SQL::Constants::NULL) == 'NULL'
+    @db.literal(Sequel::NULL) == 'NULL'
+  end
+
+  it "should have NOTNULL" do
+    @db.literal(Sequel::SQL::Constants::NOTNULL) == 'NOT NULL'
+    @db.literal(Sequel::NOTNULL) == 'NOT NULL'
+  end
+
+  it "should have TRUE and SQLTRUE" do
+    @db.literal(Sequel::SQL::Constants::TRUE) == '1'
+    @db.literal(Sequel::TRUE) == '1'
+    @db.literal(Sequel::SQL::Constants::SQLTRUE) == '1'
+    @db.literal(Sequel::SQLTRUE) == '1'
+  end
+
+  it "should have FALSE and SQLFALSE" do
+    @db.literal(Sequel::SQL::Constants::FALSE) == '0'
+    @db.literal(Sequel::FALSE) == '0'
+    @db.literal(Sequel::SQL::Constants::SQLFALSE) == '0'
+    @db.literal(Sequel::SQLFALSE) == '0'
+  end
 end
 
 describe "Sequel timezone support" do
@@ -3385,3 +3437,138 @@ describe "Sequel timezone support" do
     Sequel.typecast_timezone.should == :utc
   end
 end
+
+context "Sequel::Dataset#select_map" do
+  before do
+    @ds = MockDatabase.new[:t]
+    def @ds.fetch_rows(sql)
+      db << sql
+      yield({:c=>1})
+      yield({:c=>2})
+    end
+    @ds.db.reset
+  end
+
+  specify "should do select and map in one step" do
+    @ds.select_map(:a).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a FROM t']
+  end
+
+  specify "should handle implicit qualifiers in arguments" do
+    @ds.select_map(:a__b).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a.b FROM t']
+  end
+
+  specify "should handle implicit aliases in arguments" do
+    @ds.select_map(:a___b).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a AS b FROM t']
+  end
+
+  specify "should handle other objects" do
+    @ds.select_map("a".lit.as(:b)).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a AS b FROM t']
+  end
+  
+  specify "should accept a block" do
+    @ds.select_map{a(t__c)}.should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a(t.c) FROM t']
+  end
+end
+
+context "Sequel::Dataset#select_order_map" do
+  before do
+    @ds = MockDatabase.new[:t]
+    def @ds.fetch_rows(sql)
+      db << sql
+      yield({:c=>1})
+      yield({:c=>2})
+    end
+    @ds.db.reset
+  end
+
+  specify "should do select and map in one step" do
+    @ds.select_order_map(:a).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a FROM t ORDER BY a']
+  end
+
+  specify "should handle implicit qualifiers in arguments" do
+    @ds.select_order_map(:a__b).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a.b FROM t ORDER BY a.b']
+  end
+
+  specify "should handle implicit aliases in arguments" do
+    @ds.select_order_map(:a___b).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a AS b FROM t ORDER BY a']
+  end
+
+  specify "should handle implicit qualifiers and aliases in arguments" do
+    @ds.select_order_map(:t__a___b).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT t.a AS b FROM t ORDER BY t.a']
+  end
+
+  specify "should handle AliasedExpressions" do
+    @ds.select_order_map("a".lit.as(:b)).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a AS b FROM t ORDER BY a']
+  end
+  
+  specify "should accept a block" do
+    @ds.select_order_map{a(t__c)}.should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a(t.c) FROM t ORDER BY a(t.c)']
+  end
+end
+
+context "Sequel::Dataset#select_hash" do
+  before do
+    @ds = MockDatabase.new[:t]
+    def @ds.set_fr_yield(hs)
+      @hs = hs
+    end
+    def @ds.fetch_rows(sql)
+      db << sql
+      @hs.each{|h| yield h}
+    end
+    @ds.db.reset
+  end
+
+  specify "should do select and map in one step" do
+    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+    @ds.select_hash(:a, :b).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT a, b FROM t']
+  end
+
+  specify "should handle implicit qualifiers in arguments" do
+    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+    @ds.select_hash(:t__a, :t__b).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT t.a, t.b FROM t']
+  end
+
+  specify "should handle implicit aliases in arguments" do
+    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+    @ds.select_hash(:c___a, :d___b).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT c AS a, d AS b FROM t']
+  end
+
+  specify "should handle implicit qualifiers and aliases in arguments" do
+    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+    @ds.select_hash(:t__c___a, :t__d___b).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT t.c AS a, t.d AS b FROM t']
+  end
+end
+
+context "Modifying joined datasets" do
+  before do
+    @ds = MockDatabase.new.from(:b, :c).join(:d, [:id]).where(:id => 2)
+    @ds.meta_def(:supports_modifying_joins?){true}
+    @ds.db.reset
+  end
+
+  specify "should allow deleting from joined datasets" do
+    @ds.delete
+    @ds.db.sqls.should == ['DELETE FROM b, c WHERE (id = 2)']
+  end
+
+  specify "should allow updating joined datasets" do
+    @ds.update(:a=>1)
+    @ds.db.sqls.should == ['UPDATE b, c INNER JOIN d USING (id) SET a = 1 WHERE (id = 2)']
+  end
+end

data/spec/core/expression_filters_spec.rb

@@ -399,6 +399,31 @@ context "Blockless Ruby Filters" do
     y.lit.should == y
   end
 
+  it "should return have .sql_literal operate like .to_s" do
+    y = :x + 1
+    y.sql_literal(@d).should == '(x + 1)'
+    y.sql_literal(@d).should == y.to_s(@d)
+    y.sql_literal(@d).should == @d.literal(y)
+  end
+
+  it "should support SQL::Constants" do
+    @d.l({:x => Sequel::NULL}).should == '(x IS NULL)'
+    @d.l({:x => Sequel::NOTNULL}).should == '(x IS NOT NULL)'
+    @d.l({:x => Sequel::TRUE}).should == '(x IS TRUE)'
+    @d.l({:x => Sequel::FALSE}).should == '(x IS FALSE)'
+    @d.l({:x => Sequel::SQLTRUE}).should == '(x IS TRUE)'
+    @d.l({:x => Sequel::SQLFALSE}).should == '(x IS FALSE)'
+  end
+  
+  it "should support negation of SQL::Constants" do
+    @d.l(~{:x => Sequel::NULL}).should == '(x IS NOT NULL)'
+    @d.l(~{:x => Sequel::NOTNULL}).should == '(x IS NULL)'
+    @d.l(~{:x => Sequel::TRUE}).should == '(x IS NOT TRUE)'
+    @d.l(~{:x => Sequel::FALSE}).should == '(x IS NOT FALSE)'
+    @d.l(~{:x => Sequel::SQLTRUE}).should == '(x IS NOT TRUE)'
+    @d.l(~{:x => Sequel::SQLFALSE}).should == '(x IS NOT FALSE)'
+  end
+  
   it "should raise an error if trying to create an invalid complex expression" do
     proc{Sequel::SQL::ComplexExpression.new(:BANG, 1, 2)}.should raise_error(Sequel::Error)
   end

data/spec/extensions/schema_dumper_spec.rb

@@ -80,6 +80,8 @@ describe "Sequel::Database dump methods" do
          [:c2, {:db_type=>'datetime', :allow_null=>false}]]
       when :t5
         [[:c1, {:db_type=>'blahblah', :allow_null=>true}]]
+      when :t6
+        [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true}]]
       end
     end
   end
@@ -88,6 +90,10 @@ describe "Sequel::Database dump methods" do
     @d.dump_table_schema(:t1).should == "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
   end
 
+  it "should dump non-Integer primary key columns with explicit :type" do
+    @d.dump_table_schema(:t6).should == "create_table(:t6) do\n  primary_key :c1, :type=>Bignum\nend"
+  end
+
   it "should use a composite primary_key calls if there is a composite primary key" do
     @d.dump_table_schema(:t2).should == "create_table(:t2) do\n  Integer :c1, :null=>false\n  BigDecimal :c2, :null=>false\n  \n  primary_key [:c1, :c2]\nend"
   end

data/spec/extensions/validation_helpers_spec.rb

@@ -377,4 +377,39 @@ describe "Sequel::Plugins::ValidationHelpers" do
     MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND active) LIMIT 1",
                     "SELECT COUNT(*) AS count FROM items WHERE (((username = '0records') AND active) AND (id != 3)) LIMIT 1"]
   end
+
+  it "should support :only_if_modified option for validates_unique, and not check uniqueness for existing records if values haven't changed" do
+    @c.columns(:id, :username, :password)
+    @c.set_dataset MODEL_DB[:items]
+    @c.set_validations{validates_unique([:username, :password], :only_if_modified=>true)}
+    
+    @c.dataset.extend(Module.new {
+      def fetch_rows (sql)
+        @db << sql
+        yield({:v => 0})
+      end
+    })
+    
+    MODEL_DB.reset
+    @c.new(:username => "0records", :password => "anothertest").should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"]
+    MODEL_DB.reset
+    m = @c.load(:id=>3, :username => "0records", :password => "anothertest")
+    m.should be_valid
+    MODEL_DB.sqls.should == []
+
+    m.username = '1'
+    m.should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE (((username = '1') AND (password = 'anothertest')) AND (id != 3)) LIMIT 1"]
+
+    m = @c.load(:id=>3, :username => "0records", :password => "anothertest")
+    MODEL_DB.reset
+    m.password = '1'
+    m.should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE (((username = '0records') AND (password = '1')) AND (id != 3)) LIMIT 1"]
+    MODEL_DB.reset
+    m.username = '2'
+    m.should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE (((username = '2') AND (password = '1')) AND (id != 3)) LIMIT 1"]
+  end
 end 

data/spec/integration/dataset_test.rb

@@ -870,3 +870,40 @@ describe "Dataset defaults and overrides" do
     @ds.all.should == [{:a=>10}, {:a=>10}]
   end
 end
+
+if INTEGRATION_DB.dataset.supports_modifying_joins?
+  describe "Modifying joined datasets" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:a){Integer :a; Integer :d}
+      @db.create_table!(:b){Integer :b; Integer :e}
+      @db.create_table!(:c){Integer :c; Integer :f}
+      @ds = @db.from(:a, :b).join(:c, :c=>:e.identifier).where(:d=>:b, :f=>6)
+      @db[:a].insert(1, 2)
+      @db[:a].insert(3, 4)
+      @db[:b].insert(2, 5)
+      @db[:c].insert(5, 6)
+      @db[:b].insert(4, 7)
+      @db[:c].insert(7, 8)
+    end
+    after do
+      @db.drop_table(:a, :b, :c)
+    end
+    
+    it "#update should allow updating joined datasets" do
+      @ds.update(:a=>10)
+      @ds.all.should == [{:c=>5, :b=>2, :a=>10, :d=>2, :e=>5, :f=>6}]
+      @db[:a].order(:a).all.should == [{:a=>3, :d=>4}, {:a=>10, :d=>2}]
+      @db[:b].order(:b).all.should == [{:b=>2, :e=>5}, {:b=>4, :e=>7}]
+      @db[:c].order(:c).all.should == [{:c=>5, :f=>6}, {:c=>7, :f=>8}]
+    end
+    
+    it "#delete should allow deleting from joined datasets" do
+      @ds.delete
+      @ds.all.should == []
+      @db[:a].order(:a).all.should == [{:a=>3, :d=>4}]
+      @db[:b].order(:b).all.should == [{:b=>2, :e=>5}, {:b=>4, :e=>7}]
+      @db[:c].order(:c).all.should == [{:c=>5, :f=>6}, {:c=>7, :f=>8}]
+    end
+  end
+end