sequel 4.12.0 → 4.13.0

data/spec/extensions/list_spec.rb

@@ -106,6 +106,11 @@ describe "List plugin" do
       "SELECT * FROM items WHERE (id = 3) ORDER BY scope_id, position LIMIT 1"]
   end
 
+  it "should update positions automatically on deletion" do
+    @o.destroy
+    @db.sqls.should == ["DELETE FROM items WHERE (id = 7)", "UPDATE items SET position = (position - 1) WHERE (position > 3)"]
+  end
+
   it "should have last_position return the last position in the list" do
     @c.dataset._fetch  = {:max=>10}
     @o.last_position.should == 10

data/spec/extensions/modification_detection_spec.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require 'yaml'
+
+describe "serialization_modification_detection plugin" do
+  before do
+    @ds = Sequel.mock(:fetch=>{:id=>1, :a=>'a', :b=>1, :c=>['a'], :d=>{'b'=>'c'}}, :numrows=>1, :autoid=>1)[:items]
+    @c = Class.new(Sequel::Model(@ds))
+    @c.plugin :modification_detection
+    @c.columns :a, :b, :c, :d
+    @o = @c.first
+    @ds.db.sqls
+  end
+  
+  it "should only detect columns that have been changed" do
+    @o.changed_columns.should == []
+    @o.a << 'b'
+    @o.changed_columns.should == [:a]
+    @o.a.replace('a') 
+    @o.changed_columns.should == []
+
+    @o.values[:b] = 2
+    @o.changed_columns.should == [:b]
+    @o.values[:b] = 1
+    @o.changed_columns.should == []
+
+    @o.c[0] << 'b'
+    @o.d['b'] << 'b'
+    @o.changed_columns.sort_by{|c| c.to_s}.should == [:c, :d]
+    @o.c[0] = 'a'
+    @o.changed_columns.should == [:d]
+    @o.d['b'] = 'c'
+    @o.changed_columns.should == []
+  end
+  
+  it "should not list a column twice" do
+    @o.a = 'b'
+    @o.a << 'a'
+    @o.changed_columns.should == [:a]
+  end
+  
+  it "should report correct changed_columns after updating" do
+    @o.a << 'a'
+    @o.save_changes
+    @o.changed_columns.should == []
+
+    @o.values[:b] = 2
+    @o.save_changes
+    @o.changed_columns.should == []
+
+    @o.c[0] << 'b'
+    @o.save_changes
+    @o.changed_columns.should == []
+
+    @o.d['b'] << 'a'
+    @o.save_changes
+    @o.changed_columns.should == []
+
+    @ds.db.sqls.should == ["UPDATE items SET a = 'aa' WHERE (id = 1)",
+                       "UPDATE items SET b = 2 WHERE (id = 1)",
+                       "UPDATE items SET c = ('ab') WHERE (id = 1)",
+                       "UPDATE items SET d = ('b' = 'ca') WHERE (id = 1)"]
+  end
+
+  it "should report correct changed_columns after creating new object" do
+    o = @c.create
+    o.changed_columns.should == []
+    o.a << 'a'
+    o.changed_columns.should == [:a]
+    @ds.db.sqls.should == ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+  end
+
+  it "should report correct changed_columns after refreshing existing object" do
+    @o.a << 'a'
+    @o.changed_columns.should == [:a]
+    @o.refresh
+    @o.changed_columns.should == []
+    @o.a << 'a'
+    @o.changed_columns.should == [:a]
+  end
+end

data/spec/extensions/pg_enum_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_inet extension" do
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extend(Module.new do
+      def schema_parse_table(*)
+        [[:a, {:oid=>1}]]
+      end
+    end)
+    @db.send(:metadata_dataset)._fetch = [[{:v=>1, :enumlabel=>'a'}, {:v=>1, :enumlabel=>'b'}, {:v=>1, :enumlabel=>'c'}],
+      [{:typname=>'enum1', :v=>212389}]]
+    @db.extension(:pg_array, :pg_enum)
+    @db.sqls
+  end
+
+  it "should include enum information in the schema entry" do
+    @db.schema(:a).should == [[:a, {:oid=>1, :ruby_default=>nil, :type=>:enum, :enum_values=>%w'a b c'}]]
+  end
+
+  it "should typecast objects to string" do
+    @db.typecast_value(:enum, :a).should == 'a'
+  end
+
+  it "should add array parsers for enum values" do
+    @db.conversion_procs[212389].call('{a,b,c}').should == %w'a b c'
+  end
+
+  it "should support #create_enum method for adding a new enum" do
+    @db.create_enum(:foo, [:a, :b, :c])
+    @db.sqls.first.should == "CREATE TYPE foo AS ENUM ('a', 'b', 'c')"
+    @db.create_enum(:sch__foo, %w'a b c')
+    @db.sqls.first.should == "CREATE TYPE sch.foo AS ENUM ('a', 'b', 'c')"
+  end
+
+  it "should support #drop_enum method for dropping an enum" do
+    @db.drop_enum(:foo)
+    @db.sqls.first.should == "DROP TYPE foo"
+    @db.drop_enum(:sch__foo, :if_exists=>true)
+    @db.sqls.first.should == "DROP TYPE IF EXISTS sch.foo"
+    @db.drop_enum('foo', :cascade=>true)
+    @db.sqls.first.should == "DROP TYPE foo CASCADE"
+  end
+
+  it "should support #add_enum_value method for adding value to an existing enum" do
+    @db.add_enum_value(:foo, :a)
+    @db.sqls.first.should == "ALTER TYPE foo ADD VALUE 'a'"
+  end
+
+  it "should support :before option for #add_enum_value method for adding value before an existing enum value" do
+    @db.add_enum_value('foo', :a, :before=>:b)
+    @db.sqls.first.should == "ALTER TYPE foo ADD VALUE 'a' BEFORE 'b'"
+  end
+
+  it "should support :after option for #add_enum_value method for adding value after an existing enum value" do
+    @db.add_enum_value(:sch__foo, :a, :after=>:b)
+    @db.sqls.first.should == "ALTER TYPE sch.foo ADD VALUE 'a' AFTER 'b'"
+  end
+
+  it "should support :if_not_exists option for #add_enum_value method for not adding the value if it exists" do
+    @db.add_enum_value(:foo, :a, :if_not_exists=>true)
+    @db.sqls.first.should == "ALTER TYPE foo ADD VALUE IF NOT EXISTS 'a'"
+  end
+end

data/spec/extensions/pg_json_spec.rb

@@ -10,17 +10,6 @@ describe "pg_json extension" do
     @ac = m::JSONArray
     @bhc = m::JSONBHash
     @bac = m::JSONBArray
-
-    # Create subclass in correct namespace for easily overriding methods
-    j = m::JSON = JSON.dup
-    j.instance_eval do
-      Parser = JSON::Parser
-      alias old_parse parse
-      def parse(s)
-        return 1 if s == '1'
-        old_parse(s) 
-      end
-    end
   end
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
@@ -64,10 +53,15 @@ describe "pg_json extension" do
       Sequel.instance_eval do
         alias pj parse_json
         def parse_json(v)
-          v
+          {'1'=>1, "'a'"=>'a', 'true'=>true, 'false'=>false, 'null'=>nil, 'o'=>Object.new}.fetch(v){pj(v)}
         end
       end
-      proc{@m.parse_json('1')}.should raise_error(Sequel::InvalidValue)
+      @m.parse_json('1').should == 1
+      @m.parse_json("'a'").should == 'a'
+      @m.parse_json('true').should == true
+      @m.parse_json('false').should == false
+      @m.parse_json('null').should == nil
+      proc{@m.parse_json('o')}.should raise_error(Sequel::InvalidValue)
     ensure
       Sequel.instance_eval do
         alias parse_json pj

data/spec/extensions/prepared_statements_spec.rb

@@ -38,13 +38,15 @@ describe "prepared_statements plugin" do
         def supports_insert_select?
           true
         end
+        def supports_returning?(type)
+          true
+        end
         def insert_select(h)
           self._fetch = {:id=>1, :name=>'foo', :i => 2}
-          ds = opts[:returning] ? self : returning
-          ds.server(:default).with_sql(:insert_sql, h).first
+          server(:default).with_sql_first(insert_select_sql(h))
         end
-        def insert_sql(*)
-          "#{super}#{" RETURNING #{opts[:returning] && !opts[:returning].empty? ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}" if opts.has_key?(:returning)}"
+        def insert_select_sql(*v)
+          "#{insert_sql(*v)} RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
         end
       end
       @c.create(:name=>'foo').should == @c.load(:id=>1, :name=>'foo', :i => 2)

data/spec/extensions/round_timestamps_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+if RUBY_VERSION >= '1.9.0'
+describe "Sequel::Dataset::RoundTimestamps" do
+  before do
+    @dataset = Sequel.mock.dataset.extension(:round_timestamps)
+  end
+
+  specify "should round times properly for databases supporting microsecond precision" do
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499999.5)).should == "'01:02:03.500000'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4999995)).should == "'2010-01-02 03:04:05.500000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54999995, 10000000))).should == "'2010-01-02 03:04:05.500000'"
+
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499999.4)).should == "'01:02:03.499999'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4999994)).should == "'2010-01-02 03:04:05.499999'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54999994, 10000000))).should == "'2010-01-02 03:04:05.499999'"
+  end
+  
+  specify "should round times properly for databases supporting millisecond precision" do
+    def @dataset.timestamp_precision() 3 end
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499500)).should == "'01:02:03.500'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4995)).should == "'2010-01-02 03:04:05.500'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54995, 10000))).should == "'2010-01-02 03:04:05.500'"
+
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499499)).should == "'01:02:03.499'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4994)).should == "'2010-01-02 03:04:05.499'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54994, 10000))).should == "'2010-01-02 03:04:05.499'"
+  end
+  
+  specify "should round times properly for databases supporting second precision" do
+    def @dataset.supports_timestamp_usecs?() false end
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).should == "'01:02:04'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.5)).should == "'2010-01-02 03:04:06'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).should == "'2010-01-02 03:04:06'"
+
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499999)).should == "'01:02:03'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4999999)).should == "'2010-01-02 03:04:05'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54999999, 10000000))).should == "'2010-01-02 03:04:05'"
+  end
+end
+else
+  skip_warn "round_timestamps extension: only works on ruby 1.9+"
+end

data/spec/extensions/serialization_modification_detection_spec.rb

@@ -78,7 +78,7 @@ describe "serialization_modification_detection plugin" do
     @o1.changed_columns.should == [:h]
   end
 
-  it "should work with frozen objects" do
+  it "should work with duplicating objects" do
     @o2.changed_columns.should == []
     o = @o2.dup
     @o2.h.should == {}
@@ -86,4 +86,13 @@ describe "serialization_modification_detection plugin" do
     @o2.changed_columns.should == [:h]
     o.changed_columns.should == []
   end
+
+  it "should work with duplicating objects after modifying them" do
+    @o2.changed_columns.should == []
+    @o2.h.should == {}
+    @o2.h[1] = 2
+    @o2.changed_columns.should == [:h]
+    o = @o2.dup
+    o.changed_columns.should == [:h]
+  end
 end

data/spec/extensions/serialization_spec.rb

@@ -26,6 +26,24 @@ describe "Serialization plugin" do
     DB.sqls.last.should =~ /INSERT INTO items \((ghi)\) VALUES \('\[123\]'\)/
   end
 
+  it "should handle validations of underlying column" do
+    @c.plugin :serialization, :yaml, :abc
+    o = @c.new
+    def o.validate
+      errors.add(:abc, "not present") unless self[:abc]
+    end
+    o.valid?.should == false
+    o.abc = {}
+    o.valid?.should == true
+  end
+
+  it "should set column values even when not validating" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :yaml, :abc
+    @c.load({:id=>1}).set(:abc=>{}).save(:validate=>false)
+    DB.sqls.last.gsub("\n", '').should == "UPDATE items SET abc = '--- {}' WHERE (id = 1)"
+  end
+
   it "should allow serializing attributes to yaml" do
     @c.plugin :serialization, :yaml, :abc
     @c.create(:abc => 1)

data/spec/extensions/single_table_inheritance_spec.rb

@@ -85,6 +85,11 @@ describe Sequel::Model, "single table inheritance plugin" do
     o.valid?.should == true
   end
 
+  it "should set type column field even if validations are skipped" do
+    StiTestSub1.new.save(:validate=>false)
+    DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "SELECT * FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub1')) AND (id = 10)) LIMIT 1"]
+  end
+
   it "should override an existing value in the class name field" do
     StiTest.create(:kind=>'StiTestSub1')
     DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "SELECT * FROM sti_tests WHERE (id = 10) LIMIT 1"]

data/spec/extensions/timestamps_spec.rb

@@ -32,6 +32,12 @@ describe "Sequel::Plugins::Timestamps" do
     o.valid?.should == true
   end
 
+  it "should set timestamp fields when skipping validations" do
+    @c.plugin :timestamps
+    @c.new.save(:validate=>false)
+    @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-01')"]
+  end
+
   it "should set the create timestamp field on creation" do
     o = @c.create
     @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-01')"]

data/spec/integration/plugin_test.rb

@@ -1,8 +1,5 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
-# DB2 does not seem to support USING joins in every version; it seems to be
-# valid expression in DB2 iSeries UDB though.
-unless !DB.dataset.supports_join_using? || Sequel.guarded?(:db2)
 describe "Class Table Inheritance Plugin" do
   before(:all) do
     @db = DB
@@ -37,7 +34,7 @@ describe "Class Table Inheritance Plugin" do
     class ::Executive < Manager
     end 
     class ::Staff < Employee
-      many_to_one :manager, :qualify=>false
+      many_to_one :manager
     end 
     
     @i1 =@db[:employees].insert(:name=>'E', :kind=>'Employee')
@@ -96,10 +93,10 @@ describe "Class Table Inheritance Plugin" do
   end
   
   specify "should handle associations only defined in subclasses" do
-    Employee.filter(:id=>@i2).all.first.manager.id.should == @i4
+    Employee.filter(:employees__id=>@i2).all.first.manager.id.should == @i4
   end
 
-  cspecify "should insert rows into all tables", [proc{|db| db.sqlite_version < 30709}, :sqlite] do
+  specify "should insert rows into all tables" do
     e = Executive.create(:name=>'Ex2', :num_managers=>8, :num_staff=>9)
     i = e.id
     @db[:employees][:id=>i].should == {:id=>i, :name=>'Ex2', :kind=>'Executive'}
@@ -138,13 +135,12 @@ describe "Class Table Inheritance Plugin" do
     Executive.limit(1).eager(:staff_members).first.staff_members.should == [Staff[@i2]]
   end
   
-  cspecify "should handle eagerly graphing one_to_many relationships", [proc{|db| db.sqlite_version < 30709}, :sqlite] do
+  specify "should handle eagerly graphing one_to_many relationships" do
     es = Executive.limit(1).eager_graph(:staff_members).all
     es.should == [Executive[@i4]]
     es.map{|x| x.staff_members}.should == [[Staff[@i2]]]
   end
 end
-end
 
 describe "Many Through Many Plugin" do
   before(:all) do
@@ -1494,6 +1490,11 @@ describe "List plugin without a scope" do
     proc { @c[:name => "def"].move_up(10) }.should raise_error(Sequel::Error)
     proc { @c[:name => "def"].move_down(10) }.should raise_error(Sequel::Error)
   end
+
+  it "should update positions on destroy" do
+    @c[:name => "def"].destroy
+    @c.select_map([:position, :name]).should == [[1, 'abc'], [2, 'hig']]
+  end
 end
 
 describe "List plugin with a scope" do
@@ -1572,6 +1573,11 @@ describe "List plugin with a scope" do
     proc { @c[:name => "P1"].move_up(10) }.should raise_error(Sequel::Error)
     proc { @c[:name => "P1"].move_down(10) }.should raise_error(Sequel::Error)
   end
+
+  it "should update positions on destroy" do
+    @c[:name => "P2"].destroy
+    @c.select_order_map([:pos, :name]).should == [[1, "Hm"], [1, "P1"], [1, "Ps"], [2, "Au"], [2, "P3"]]
+  end
 end
 
 describe "Sequel::Plugins::Tree" do

data/spec/integration/prepared_statement_test.rb

@@ -117,6 +117,12 @@ describe "Prepared Statements and Bound Arguments" do
     @ds.filter(:id=>2).first[:numb].should == 20
   end
 
+  specify "should support bound variables with insert_select" do
+    @ds.call(:insert_select, {:n=>20}, :numb=>:$n).should == {:id=>2, :numb=>20}
+    @ds.count.should == 2
+    @ds.order(:id).map(:numb).should == [10, 20]
+  end if DB.dataset.supports_insert_select?
+
   specify "should support bound variables with delete" do
     @ds.filter(:numb=>:$n).call(:delete, :n=>10).should == 1
     @ds.count.should == 0
@@ -228,6 +234,12 @@ describe "Prepared Statements and Bound Arguments" do
     @ds.filter(:id=>2).first[:numb].should == 20
   end
 
+  specify "should support prepared_statements with insert_select" do
+    @ds.prepare(:insert_select, :insert_select_n, :numb=>:$n).call(:n=>20).should == {:id=>2, :numb=>20}
+    @ds.count.should == 2
+    @ds.order(:id).map(:numb).should == [10, 20]
+  end if DB.dataset.supports_insert_select?
+
   specify "should support prepared statements with delete" do
     @ds.filter(:numb=>:$n).prepare(:delete, :delete_n)
     @db.call(:delete_n, :n=>10).should == 1

data/spec/model/associations_spec.rb

@@ -1890,6 +1890,30 @@ describe Sequel::Model, "many_to_many" do
     end
   end
   
+  it "should not override a selection consisting completely of qualified columns using Sequel::SQL::QualifiedIdentifier" do
+    @c1.dataset = @c1.dataset.select(Sequel.qualify(:attributes, :id), Sequel.qualify(:attributes, :b))
+    @c2.many_to_many :attributes, :class => @c1
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.id, attributes.b FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
+  end
+  
+  it "should not override a selection consisting completely of qualified columns using symbols" do
+    @c1.dataset = @c1.dataset.select(:attributes__id, :attributes__b)
+    @c2.many_to_many :attributes, :class => @c1
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.id, attributes.b FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
+  end
+  
+  it "should not override a selection consisting completely of qualified columns using Sequel::SQL::AliasedExpression" do
+    @c1.dataset = @c1.dataset.select(Sequel.qualify(:attributes, :id).as(:a), Sequel.as(:attributes__b, :c))
+    @c2.many_to_many :attributes, :class => @c1
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.id AS a, attributes.b AS c FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
+  end
+  
+  it "should override a selection consisting of non qualified columns" do
+    @c1.dataset = @c1.dataset.select{foo(:bar)}
+    @c2.many_to_many :attributes, :class => @c1
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
+  end
+  
   it "should respect :eager_loader_predicate_key when lazily loading" do
     @c2.many_to_many :attributes, :class => @c1, :eager_loading_predicate_key=>Sequel.subscript(:attributes_nodes__node_id, 0)
     @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id[0] = 1234)'