sequel 3.21.0 → 3.36.0

data/spec/extensions/schema_spec.rb

@@ -23,22 +23,19 @@ describe Sequel::Model, "dataset & schema" do
 end
 
 describe Sequel::Model, "table_exists?" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
     @model = Class.new(Sequel::Model(:items))
   end
 
   it "should get the table name and question the model's db if table_exists?" do
-    @model.should_receive(:table_name).and_return(:items)
-    @model.db.should_receive(:table_exists?)
-    @model.table_exists?
+    @model.db.should_receive(:table_exists?).and_return(false)
+    @model.table_exists?.should == false
   end
 end
 
 describe Sequel::Model, "create_table and schema" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
     @model = Class.new(Sequel::Model) do
       set_schema(:items) do
@@ -60,7 +57,7 @@ describe Sequel::Model, "create_table and schema" do
 
   it "should reload the schema from the database" do
     schem = {:name=>{:type=>:string}, :price=>{:type=>:float}}
-    @model.db.should_receive(:schema).with(:items, :reload=>true).and_return(schem.to_a.sort_by{|x| x[0].to_s})
+    @model.db.should_receive(:schema).with(@model.dataset, :reload=>true).and_return(schem.to_a.sort_by{|x| x[0].to_s})
     @model.create_table
     @model.db_schema.should == schem
     @model.instance_variable_get(:@columns).should == [:name, :price]
@@ -84,19 +81,27 @@ describe Sequel::Model, "create_table and schema" do
 end
 
 describe Sequel::Model, "drop_table" do
-
-  before(:each) do
-    MODEL_DB.reset
+  before do
     @model = Class.new(Sequel::Model(:items))
+    MODEL_DB.reset
   end
 
-  it "should get the drop table SQL for the associated table and then execute the SQL." do
-    @model.should_receive(:table_name).and_return(:items)
-    @model.db.should_receive(:drop_table_sql).with(:items)
-    @model.db.should_receive(:execute).and_return(:true)
+  it "should drop the related table" do
     @model.drop_table
+    MODEL_DB.sqls.should == ['DROP TABLE items']
   end
+end
 
+describe Sequel::Model, "drop_table?" do
+  before do
+    @model = Class.new(Sequel::Model(:items))
+    MODEL_DB.reset
+  end
+
+  it "should drop the table if it exists" do
+    @model.drop_table?
+    MODEL_DB.sqls.should == ["SELECT NULL FROM items LIMIT 1", 'DROP TABLE items']
+  end
 end
 
 describe Sequel::Model, "create_table!" do
@@ -106,9 +111,8 @@ describe Sequel::Model, "create_table!" do
   end
   
   it "should drop table if it exists and then create the table" do
-    @model.should_receive(:drop_table).and_return(true)
-    @model.should_receive(:create_table).and_return(true)
     @model.create_table!
+    MODEL_DB.sqls.should == ["SELECT NULL FROM items LIMIT 1", 'DROP TABLE items', 'CREATE TABLE items ()']
   end
 end
 
@@ -120,13 +124,13 @@ describe Sequel::Model, "create_table?" do
   
   it "should not create the table if it already exists" do
     @model.should_receive(:table_exists?).and_return(true)
-    @model.should_not_receive(:create_table)
-    @model.create_table?.should == nil
+    @model.create_table?
+    MODEL_DB.sqls.should == []
   end
 
   it "should create the table if it doesn't exist" do
     @model.should_receive(:table_exists?).and_return(false)
-    @model.should_receive(:create_table).and_return(3)
-    @model.create_table?.should == 3
+    @model.create_table?
+    MODEL_DB.sqls.should == ['CREATE TABLE items ()']
   end
 end

data/spec/extensions/select_remove_spec.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Dataset#select_remove" do
+  before do
+    @d = Sequel.mock.from(:test)
+    @d.columns :a, :b, :c
+  end
+  
+  specify "should remove columns from the selected columns" do
+    @d.sql.should == 'SELECT * FROM test'
+    @d.select_remove(:a).sql.should == 'SELECT b, c FROM test'
+    @d.select_remove(:b).sql.should == 'SELECT a, c FROM test'
+    @d.select_remove(:c).sql.should == 'SELECT a, b FROM test'
+  end
+
+  specify "should work correctly if there are already columns selected" do
+    d = @d.select(:a, :b, :c)
+    d.columns :a, :b, :c
+    d.select_remove(:c).sql.should == 'SELECT a, b FROM test'
+  end
+
+  specify "should have no effect if the columns given are not currently selected" do
+    @d.select_remove(:d).sql.should == 'SELECT a, b, c FROM test'
+  end
+
+  specify "should handle expressions where Sequel can't determine the alias by itself" do
+    d = @d.select(:a, :b.sql_function, :c.as(:b))
+    d.columns :a, :"b()", :b
+    d.select_remove(:"b()").sql.should == 'SELECT a, c AS b FROM test'
+  end
+
+  specify "should remove expressions if given exact expressions" do
+    d = @d.select(:a, :b.sql_function, :c.as(:b))
+    d.columns :a, :"b()", :b
+    d.select_remove(:b.sql_function).sql.should == 'SELECT a, c AS b FROM test'
+    d.select_remove(:c.as(:b)).sql.should == 'SELECT a, b() FROM test'
+  end
+end

data/spec/extensions/serialization_modification_detection_spec.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require 'yaml'
+
+describe "serialization_modification_detection plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      columns :id, :h
+      plugin :serialization, :yaml, :h
+      plugin :serialization_modification_detection
+    end
+    @o1 = @c.new(:h=>{})
+    @o2 = @c.load(:id=>1, :h=>"--- {}\n\n")
+    @o3 = @c.new
+    @o4 = @c.load(:id=>1, :h=>nil)
+    MODEL_DB.reset
+  end
+  
+  it "should not detect columns that haven't been changed" do
+    @o1.changed_columns.should == []
+    @o1.h.should == {}
+    @o1.h[1] = 2
+    @o1.h.clear
+    @o1.changed_columns.should == []
+
+    @o2.changed_columns.should == []
+    @o2.h.should == {}
+    @o2.h[1] = 2
+    @o2.h.clear
+    @o2.changed_columns.should == []
+  end
+  
+  it "should detect columns that have been changed" do
+    @o1.changed_columns.should == []
+    @o1.h.should == {}
+    @o1.h[1] = 2
+    @o1.changed_columns.should == [:h]
+
+    @o2.changed_columns.should == []
+    @o2.h.should == {}
+    @o2.h[1] = 2
+    @o2.changed_columns.should == [:h]
+
+    @o3.changed_columns.should == []
+    @o3.h.should == nil
+    @o3.h = {}
+    @o3.changed_columns.should == [:h]
+
+    @o4.changed_columns.should == []
+    @o4.h.should == nil
+    @o4.h = {}
+    @o4.changed_columns.should == [:h]
+  end
+  
+  it "should report correct changed_columns after saving" do
+    @o1.h[1] = 2
+    @o1.save
+    @o1.changed_columns.should == []
+
+    @o2.h[1] = 2
+    @o2.save_changes
+    @o2.changed_columns.should == []
+
+    @o3.h = {1=>2}
+    @o3.save
+    @o3.changed_columns.should == []
+
+    @o4.h = {1=>2}
+    @o4.save
+    @o4.changed_columns.should == []
+  end
+end

data/spec/extensions/serialization_spec.rb

@@ -9,10 +9,6 @@ else
 describe "Serialization plugin" do
   before do
     @c = Class.new(Sequel::Model(:items)) do
-      include(Module.new do
-        def before_save
-        end
-      end)
       no_primary_key
       columns :id, :abc, :def, :ghi
     end
@@ -22,11 +18,11 @@ describe "Serialization plugin" do
   it "should allow setting additional serializable attributes via plugin :serialization call" do
     @c.plugin :serialization, :yaml, :abc
     @c.create(:abc => 1, :def=> 2)
-    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n', 2|2, '--- 1\n')\)/
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 2|2, '--- 1\n(\.\.\.\n)?')\)/
 
     @c.plugin :serialization, :marshal, :def
     @c.create(:abc => 1, :def=> 1)
-    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n')\)/
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n(\.\.\.\n)?')\)/
     
     @c.plugin :serialization, :json, :ghi
     @c.create(:ghi => [123])
@@ -38,15 +34,7 @@ describe "Serialization plugin" do
     @c.create(:abc => 1)
     @c.create(:abc => "hello")
 
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('--- 1\n')", \
-      "INSERT INTO items (abc) VALUES ('--- hello\n')", \
-    ]
-  end
-
-  it "serialization_format should be the serialization format used" do
-    @c.plugin :serialization, :yaml, :abc
-    @c.serialization_format.should == :yaml
+    MODEL_DB.sqls.map{|s| s.sub("...\n", '')}.should == ["INSERT INTO items (abc) VALUES ('--- 1\n')", "INSERT INTO items (abc) VALUES ('--- hello\n')"]
   end
 
   it "serialized_columns should be the columns serialized" do
@@ -78,15 +66,21 @@ describe "Serialization plugin" do
     ]
   end
 
+  it "should allow serializing attributes using arbitrary callable" do
+    @c.plugin :serialization, [proc{|s| s.reverse}, proc{}], :abc
+    @c.create(:abc => "hello")
+    MODEL_DB.sqls.should == ["INSERT INTO items (abc) VALUES ('olleh')"]
+  end
+  
+  it "should raise an error if specificing serializer as an unregistered symbol" do
+    proc{@c.plugin :serialization, :foo, :abc}.should raise_error(Sequel::Error)
+  end
+  
   it "should translate values to and from yaml serialization format using accessor methods" do
     @c.set_primary_key :id
     @c.plugin :serialization, :yaml, :abc, :def
     vals = nil
-
-    ds = @c.dataset
-    def ds.fetch_rows(sql, &block)
-      block.call(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-    end
+    @c.dataset._fetch = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
 
     o = @c.first
     o.id.should == 1
@@ -97,18 +91,16 @@ describe "Serialization plugin" do
 
     o.update(:abc => 23)
     @c.create(:abc => [1, 2, 3])
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '--- 23\n' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "should translate values to and from marshal serialization format using accessor methods" do
     @c.set_primary_key :id
     @c.plugin :serialization, :marshal, :abc, :def
-
-    ds = @c.dataset
-    def ds.fetch_rows(sql, &block)
-      block.call(:id => 1, :abc =>[Marshal.dump(1)].pack('m'), :def =>[Marshal.dump('hello')].pack('m'))
-    end
+    @c.dataset._fetch = [:id => 1, :abc =>[Marshal.dump(1)].pack('m'), :def =>[Marshal.dump('hello')].pack('m')]
 
     o = @c.first
     o.id.should == 1
@@ -119,18 +111,16 @@ describe "Serialization plugin" do
 
     o.update(:abc => 23)
     @c.create(:abc => [1, 2, 3])
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{[Marshal.dump(23)].pack('m')}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[Marshal.dump([1, 2, 3])].pack('m')}')"]
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = '#{[Marshal.dump(23)].pack('m')}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[Marshal.dump([1, 2, 3])].pack('m')}')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
   
   it "should translate values to and from json serialization format using accessor methods" do
     @c.set_primary_key :id
     @c.plugin :serialization, :json, :abc, :def
-    
-    ds = @c.dataset
-    def ds.fetch_rows(sql, &block)
-      block.call(:id => 1, :abc => [1].to_json, :def => ["hello"].to_json)
-    end
+    @c.dataset._fetch = {:id => 1, :abc => [1].to_json, :def => ["hello"].to_json}
     
     o = @c.first
     o.id.should == 1
@@ -142,18 +132,59 @@ describe "Serialization plugin" do
     o.update(:abc => [23])
     @c.create(:abc => [1,2,3])
     
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{[23].to_json}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[1,2,3].to_json}')"]
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = '#{[23].to_json}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1,2,3].to_json}')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+  end
+
+  it "should translate values to and from arbitrary callables using accessor methods" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, [proc{|s| s.reverse}, proc{|s| s.reverse}], :abc, :def
+    @c.dataset._fetch = {:id => 1, :abc => 'cba', :def => 'olleh'}
+    
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 'abc'
+    o.abc.should == 'abc'
+    o.def.should == "hello"
+    o.def.should == "hello"
+    
+    o.update(:abc => 'foo')
+    @c.create(:abc => 'bar')
+    
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = 'oof' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('rab')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+  end
+
+  it "should handle registration of custom serializer/deserializer pairs" do
+    @c.set_primary_key :id
+    Sequel::Plugins::Serialization.register_format(:reverse, proc{|s| s.reverse}, proc{|s| s.reverse})
+    @c.plugin :serialization, :reverse, :abc, :def
+    @c.dataset._fetch = {:id => 1, :abc => 'cba', :def => 'olleh'}
+    
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 'abc'
+    o.abc.should == 'abc'
+    o.def.should == "hello"
+    o.def.should == "hello"
+    
+    o.update(:abc => 'foo')
+    @c.create(:abc => 'bar')
+    
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = 'oof' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('rab')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "should copy serialization formats and columns to subclasses" do
     @c.set_primary_key :id
     @c.plugin :serialization, :yaml, :abc, :def
-
-    ds = @c.dataset
-    def ds.fetch_rows(sql, &block)
-      block.call(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-    end
+    @c.dataset._fetch = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
 
     o = Class.new(@c).first
     o.id.should == 1
@@ -164,8 +195,10 @@ describe "Serialization plugin" do
 
     o.update(:abc => 23)
     Class.new(@c).create(:abc => [1, 2, 3])
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '--- 23\n' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "should clear the deserialized columns when refreshing" do
@@ -179,6 +212,15 @@ describe "Serialization plugin" do
     o.deserialized_values.length.should == 0
   end
   
+  it "should clear the deserialized columns when refreshing after saving a new object" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :yaml, :abc, :def
+    o = @c.new(:abc => "--- 1\n", :def => "--- hello\n")
+    o.deserialized_values.length.should == 2
+    o.save
+    o.deserialized_values.length.should == 0
+  end
+  
   it "should raise an error if calling internal serialization methods with bad columns" do
     @c.set_primary_key :id
     @c.plugin :serialization

data/spec/extensions/server_block_spec.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+shared_examples_for "Database#with_server" do  
+  specify "should set the default server to use in the block" do
+    @db.with_server(:a){@db[:t].all}
+    @db.sqls.should == ["SELECT * FROM t -- a"]
+    @db.with_server(:b){@db[:t].all}
+    @db.sqls.should == ["SELECT * FROM t -- b"]
+  end
+
+  specify "should have no affect after the block" do
+    @db.with_server(:a){@db[:t].all}
+    @db.sqls.should == ["SELECT * FROM t -- a"]
+    @db[:t].all
+    @db.sqls.should == ["SELECT * FROM t"]
+  end
+
+  specify "should not override specific server inside the block" do
+    @db.with_server(:a){@db[:t].server(:b).all}
+    @db.sqls.should == ["SELECT * FROM t -- b"]
+  end
+
+  specify "should work correctly when blocks are nested" do
+    @db[:t].all
+    @db.with_server(:a) do
+      @db[:t].all
+      @db.with_server(:b){@db[:t].all}
+      @db[:t].all
+    end
+    @db[:t].all
+    @db.sqls.should == ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t"]
+  end
+
+  specify "should work correctly for inserts/updates/deletes" do
+    @db.with_server(:a) do
+      @db[:t].insert
+      @db[:t].update(:a=>1)
+      @db[:t].delete
+    end
+    @db.sqls.should == ["INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
+  end
+end
+
+describe "Database#with_server single threaded" do
+  before do
+    @db = Sequel.mock(:single_threaded=>true, :servers=>{:a=>{}, :b=>{}})
+    @db.extend Sequel::ServerBlock
+  end
+
+  it_should_behave_like "Database#with_server"
+end
+
+describe "Database#with_server multi threaded" do
+  before do
+    @db = Sequel.mock(:servers=>{:a=>{}, :b=>{}, :c=>{}, :d=>{}})
+    @db.extend Sequel::ServerBlock
+  end
+
+  it_should_behave_like "Database#with_server"
+
+  specify "should respect multithreaded access" do
+    q, q1 = Queue.new, Queue.new
+    
+    t = nil
+    @db[:t].all
+    @db.with_server(:a) do
+      @db[:t].all
+      t = Thread.new do
+        @db[:t].all
+        @db.with_server(:c) do
+          @db[:t].all
+          @db.with_server(:d){@db[:t].all}
+          q.push nil
+          q1.pop
+          @db[:t].all
+        end
+        @db[:t].all
+      end
+      q.pop
+      @db.with_server(:b){@db[:t].all}
+      @db[:t].all
+    end
+    @db[:t].all
+    q1.push nil
+    t.join
+    @db.sqls.should == ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t -- d",
+      "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t"]
+  end
+end
+