sequel 3.33.0 → 3.34.0

data/spec/extensions/schema_spec.rb

@@ -86,12 +86,24 @@ describe Sequel::Model, "drop_table" do
     MODEL_DB.reset
   end
 
-  it "should get the drop table SQL for the associated table and then execute the SQL." do
+  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
   before do
     MODEL_DB.reset
@@ -100,7 +112,7 @@ describe Sequel::Model, "create_table!" do
   
   it "should drop table if it exists and then create the table" do
     @model.create_table!
-    MODEL_DB.sqls.should == ['DROP TABLE items', 'CREATE TABLE items ()']
+    MODEL_DB.sqls.should == ["SELECT NULL FROM items LIMIT 1", 'DROP TABLE items', '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/sharding_spec.rb

@@ -5,19 +5,19 @@ describe "sharding plugin" do
     @db = Sequel.mock(:numrows=>1, :autoid=>proc{1}, :servers=>{:s1=>{}, :s2=>{}, :s3=>{}, :s4=>{}})
     @Artist = Class.new(Sequel::Model(@db[:artists]))
     @Artist.class_eval do
-      dataset._fetch = {:id=>2, :name=>'YJM'}
+      instance_dataset._fetch = dataset._fetch = {:id=>2, :name=>'YJM'}
       columns :id, :name
       plugin :sharding
     end
     @Album = Class.new(Sequel::Model(@db[:albums]))
     @Album.class_eval do
-      dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
+      instance_dataset._fetch = dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
       columns :id, :artist_id, :name
       plugin :sharding
     end
     @Tag = Class.new(Sequel::Model(@db[:tags]))
     @Tag.class_eval do
-      dataset._fetch = {:id=>3, :name=>'M'}
+      instance_dataset._fetch = dataset._fetch = {:id=>3, :name=>'M'}
       columns :id, :name
       plugin :sharding
     end
@@ -67,7 +67,7 @@ describe "sharding plugin" do
   end 
 
   specify "should not use current dataset's shard when eager loading if eagerly loaded dataset has its own shard" do
-    @Artist.dataset.opts[:server] = :s2
+    @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
     albums = @Album.server(:s1).eager(:artist).all
     @db.sqls.should == ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s2"]
     albums.length.should == 1
@@ -86,7 +86,7 @@ describe "sharding plugin" do
   end 
 
   specify "should not use current dataset's shard when eager graphing if eagerly graphed dataset has its own shard" do
-    @Artist.dataset.opts[:server] = :s2
+    @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
     ds = @Album.server(:s1).eager_graph(:artist)
     ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
     albums = ds.all
@@ -97,7 +97,7 @@ describe "sharding plugin" do
   end 
 
   specify "should use eagerly graphed dataset shard for eagerly graphed objects even if current dataset does not have a shard" do
-    @Artist.dataset.opts[:server] = :s2
+    @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
     ds = @Album.eager_graph(:artist)
     ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
     albums = ds.all

data/spec/extensions/skip_create_refresh_spec.rb

@@ -5,7 +5,7 @@ describe "Sequel::Plugins::SkipCreateRefresh" do
     c = Class.new(Sequel::Model(:a))
     c.columns :id, :x
     c.db.reset
-    c.dataset.meta_def(:insert){|*a| super(*a); 2}
+    c.instance_dataset.meta_def(:insert){|*a| super(*a); 2}
     c.create(:x=>1)
     c.db.sqls.should == ['INSERT INTO a (x) VALUES (1)', 'SELECT * FROM a WHERE (id = 2) LIMIT 1']
 

data/spec/extensions/spec_helper.rb

@@ -8,7 +8,7 @@ unless Sequel.const_defined?('Model')
   require 'sequel/model'
 end
 
-Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot columns_introspection server_block arbitrary_servers')
+Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot columns_introspection server_block arbitrary_servers pg_auto_parameterize pg_statement_cache pg_hstore pg_hstore_ops schema_caching null_dataset select_remove query_literals')
 {:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}.each{|p, opts| Sequel::Model.plugin(p, *opts)}
 
 Sequel::Dataset.introspect_all_columns if ENV['SEQUEL_COLUMNS_INTROSPECTION']
@@ -36,6 +36,7 @@ class << Sequel::Model
 end
 
 Sequel::Model.use_transactions = false
+Sequel::Model.cache_anonymous_models = false
 
 db = Sequel.mock(:fetch=>{:id => 1, :x => 1}, :numrows=>1, :autoid=>proc{|sql| 10})
 def db.schema(*) [[:id, {:primary_key=>true}]] end

data/spec/extensions/sql_expr_spec.rb

@@ -1,49 +1,58 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe "Sequel sql_expr extension" do
+  before do
+    @ds = Sequel.mock.dataset
+  end
+
   specify "Object#sql_expr should wrap the object in a GenericComplexExpression" do
     o = Object.new
+    def o.sql_literal(ds) 'foo' end
     s = o.sql_expr
-    s.should == Sequel::SQL::GenericComplexExpression.new(:NOOP, o)
-    (s+1).should == Sequel::SQL::NumericExpression.new(:+, s, 1)
-    (s & true).should == Sequel::SQL::BooleanExpression.new(:AND, s, true)
-    (s < 1).should == Sequel::SQL::BooleanExpression.new(:<, s, 1)
-    s.sql_subscript(1).should == Sequel::SQL::Subscript.new(s, [1])
-    s.like('a').should == Sequel::SQL::BooleanExpression.new(:LIKE, s, 'a')
-    s.as(:a).should == Sequel::SQL::AliasedExpression.new(s, :a)
-    s.cast(Integer).should == Sequel::SQL::Cast.new(s, Integer)
-    s.desc.should == Sequel::SQL::OrderedExpression.new(s, true)
-    s.sql_string.should == Sequel::SQL::StringExpression.new(:NOOP, s)
+    @ds.literal(s).should == "foo"
+    @ds.literal(s+1).should == "(foo + 1)"
+    @ds.literal(s & true).should == "(foo AND 't')"
+    @ds.literal(s < 1).should == "(foo < 1)"
+    @ds.literal(s.sql_subscript(1)).should == "foo[1]"
+    @ds.literal(s.like('a')).should == "(foo LIKE 'a')"
+    @ds.literal(s.as(:a)).should == "foo AS a"
+    @ds.literal(s.cast(Integer)).should == "CAST(foo AS integer)"
+    @ds.literal(s.desc).should == "foo DESC"
+    @ds.literal(s.sql_string + '1').should == "(foo || '1')"
   end
 
   specify "Numeric#sql_expr should wrap the object in a NumericExpression" do
     [1, 2.0, 2^70, BigDecimal.new('1.0')].each do |o|
-      o.sql_expr.should == Sequel::SQL::NumericExpression.new(:NOOP, o)
+      @ds.literal(o.sql_expr).should == @ds.literal(o)
+      @ds.literal(o.sql_expr + 1).should == "(#{@ds.literal(o)} + 1)"
     end
   end
 
   specify "String#sql_expr should wrap the object in a StringExpression" do
-    "".sql_expr.should == Sequel::SQL::StringExpression.new(:NOOP, "")
+    @ds.literal("".sql_expr).should == "''"
+    @ds.literal("".sql_expr + :a).should == "('' || a)"
   end
 
   specify "NilClass, TrueClass, and FalseClass#sql_expr should wrap the object in a BooleanExpression" do
     [nil, true, false].each do |o|
-      o.sql_expr.should == Sequel::SQL::BooleanExpression.new(:NOOP, o)
+      @ds.literal(o.sql_expr).should == @ds.literal(o)
+      @ds.literal(o.sql_expr & :a).should == "(#{@ds.literal(o)} AND a)"
     end
   end
 
   specify "Proc#sql_expr should should treat the object as a virtual row block" do
-    proc{a}.sql_expr.should == Sequel::SQL::Identifier.new(:a)
-    proc{a__b}.sql_expr.should == Sequel::SQL::QualifiedIdentifier.new('a', 'b')
-    proc{a(b)}.sql_expr.should == Sequel::SQL::Function.new(:a, Sequel::SQL::Identifier.new(:b))
+    @ds.literal(proc{a}.sql_expr).should == "a"
+    @ds.literal(proc{a__b}.sql_expr).should == "a.b"
+    @ds.literal(proc{a(b)}.sql_expr).should == "a(b)"
   end
 
   specify "Proc#sql_expr should should wrap the object in a GenericComplexExpression if the object is not already an expression" do
-    proc{1}.sql_expr.should == Sequel::SQL::GenericComplexExpression.new(:NOOP, 1)
+    @ds.literal(proc{1}.sql_expr).should == "1"
+    @ds.literal(proc{1}.sql_expr + 2).should == "(1 + 2)"
   end
 
   specify "Proc#sql_expr should should convert a hash or array of two element arrays to a BooleanExpression" do
-    proc{{a=>b}}.sql_expr.should == Sequel::SQL::BooleanExpression.new(:'=', Sequel::SQL::Identifier.new(:a), Sequel::SQL::Identifier.new(:b))
-    proc{[[a,b]]}.sql_expr.should == Sequel::SQL::BooleanExpression.new(:'=', Sequel::SQL::Identifier.new(:a), Sequel::SQL::Identifier.new(:b))
+    @ds.literal(proc{{a=>b}}.sql_expr).should == "(a = b)"
+    @ds.literal(proc{[[a, b]]}.sql_expr & :a).should == "((a = b) AND a)"
   end
 end

data/spec/extensions/static_cache_spec.rb

@@ -0,0 +1,145 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::StaticCache" do
+  before do
+    @db = Sequel.mock
+    @db.fetch = [{:id=>1}, {:id=>2}]
+    @c = Class.new(Sequel::Model(@db[:t]))
+    @c.columns :id
+    @c.plugin :static_cache
+    @c1 = @c.cache[1]
+    @c2 = @c.cache[2]
+    @db.sqls
+  end
+
+  it "should use a ruby hash as a cache of all model instances" do
+    @c.cache.should == {1=>@c.load(:id=>1), 2=>@c.load(:id=>2)}
+  end
+
+  it "should work correctly with composite keys" do
+    @db.fetch = [{:id=>1, :id2=>1}, {:id=>2, :id2=>1}]
+    @c = Class.new(Sequel::Model(@db[:t]))
+    @c.columns :id, :id2
+    @c.set_primary_key([:id, :id2])
+    @c.plugin :static_cache
+    @db.sqls
+    @c1 = @c.cache[[1, 2]]
+    @c2 = @c.cache[[2, 1]]
+    @c[[1, 2]].should equal(@c1)
+    @c[[2, 1]].should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should make .[] method with primary key use the cache" do
+    @c[1].should equal(@c1)
+    @c[2].should equal(@c2)
+    @c[3].should be_nil
+    @c[[1, 2]].should be_nil
+    @c[nil].should be_nil
+    @c[].should be_nil
+    @db.sqls.should == []
+  end
+
+  it "should have .[] with a hash not use the cache" do
+    @db.fetch = {:id=>2}
+    @c[:id=>2].should == @c2
+    @db.sqls.should == ['SELECT * FROM t WHERE (id = 2) LIMIT 1']
+  end
+
+  it "should support cache_get_pk" do
+    @c.cache_get_pk(1).should equal(@c1)
+    @c.cache_get_pk(2).should equal(@c2)
+    @c.cache_get_pk(3).should be_nil
+    @db.sqls.should == []
+  end
+
+  it "should have each just iterate over the hash's values without sending a query" do
+    a = []
+    @c.each{|o| a << o}
+    a = a.sort_by{|o| o.id}
+    a.first.should equal(@c1)
+    a.last.should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should have map just iterate over the hash's values without sending a query if no argument is given" do
+    @c.map{|v| v.id}.sort.should == [1, 2]
+    @db.sqls.should == []
+  end
+
+  it "should have map send a query if given an argument" do
+    @c.map(:id).sort.should == [1, 2]
+    @db.sqls.should == ["SELECT * FROM t"]
+  end
+
+  it "should have map without a block or argument not raise an exception or issue a query" do
+    @c.map
+    @db.sqls.should == []
+  end
+
+  it "should have map without a block not return a frozen object" do
+    @c.map.frozen?.should be_false
+  end
+
+  it "should have other enumerable methods work without sending a query" do
+    a = @c.sort_by{|o| o.id}
+    a.first.should equal(@c1)
+    a.last.should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should have all just return the hashes' values" do
+    a = @c.all.sort_by{|o| o.id}
+    a.first.should equal(@c1)
+    a.last.should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should have all not return a frozen object" do
+    @c.all.frozen?.should be_false
+  end
+
+  it "should have all return things in dataset order" do
+    @c.all.should == [@c1, @c2]
+  end
+
+  it "should have to_hash without arguments return the cached objects without a query" do
+    a = @c.to_hash
+    a[1].should equal(@c1)
+    a[2].should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should have to_hash with any arguments use a query" do
+    @c.to_hash(:id).should == {1=>@c1, 2=>@c2}
+    @db.sqls.should == ['SELECT * FROM t']
+    @c.to_hash(:id, :id).should == {1=>1, 2=>2}
+    @db.sqls.should == ['SELECT * FROM t']
+  end
+
+  it "should have all not return a frozen object" do
+    @c.to_hash.frozen?.should be_false
+  end
+
+  it "all of the static cache values (model instances) should be frozen" do
+    @c.all.all?{|o| o.frozen?}.should be_true
+  end
+
+  it "subclasses should work correctly" do
+    c = Class.new(@c)
+    c.all.should == [c.load(:id=>1), c.load(:id=>2)]
+    c.to_hash.should == {1=>c.load(:id=>1), 2=>c.load(:id=>2)}
+    @db.sqls.should == ['SELECT * FROM t']
+  end
+
+  it "set_dataset should work correctly" do
+    ds = @c.dataset.from(:t2)
+    ds.instance_variable_set(:@columns, [:id])
+    ds._fetch = {:id=>3}
+    @c.dataset = ds
+    @c.all.should == [@c.load(:id=>3)]
+    @c.to_hash.should == {3=>@c.load(:id=>3)}
+    @c.to_hash[3].should equal(@c.all.first)
+    @db.sqls.should == ['SELECT * FROM t2']
+  end
+end

data/spec/extensions/touch_spec.rb

@@ -105,7 +105,7 @@ describe "Touch plugin" do
     @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
     @Album.load(:id=>4, :artist_id=>1).destroy
     sqls = MODEL_DB.sqls
-    sqls.shift.should == "DELETE FROM albums WHERE (id = 4)"
+    sqls.shift.should == "DELETE FROM albums WHERE id = 4"
     sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end

data/spec/extensions/typecast_on_load_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "TypecastOnLoad plugin" do
   before do
-    @db = Sequel.mock(:fetch=>{:id=>1, :b=>"1", :y=>"0"}, :columns=>[:id, :b, :y])
+    @db = Sequel.mock(:fetch=>{:id=>1, :b=>"1", :y=>"0"}, :columns=>[:id, :b, :y], :numrows=>1)
     def @db.schema(*args)
       [[:id, {}], [:y, {:type=>:boolean, :db_type=>'tinyint(1)'}], [:b, {:type=>:integer, :db_type=>'integer'}]]
     end
@@ -30,6 +30,14 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
     o.bset.should == true
   end
 
+  specify "should call setter method with value when automatically reloading the object on creation via insert_select" do
+    @c.plugin :typecast_on_load, :b
+    @c.dataset.meta_def(:insert_select){|h| insert(h); first}
+    o = @c.new({:id=>1, :b=>"1", :y=>"0"}, true)
+    o.save.values.should == {:id=>1, :b=>1, :y=>"0"}
+    o.bset.should == true
+  end
+
   specify "should allowing setting columns separately via add_typecast_on_load_columns" do
     @c.plugin :typecast_on_load
     @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>"0"}

data/spec/integration/associations_test.rb

@@ -536,7 +536,7 @@ end
 describe "Sequel::Model Simple Associations" do
   before(:all) do
     @db = INTEGRATION_DB
-    [:albums_tags, :tags, :albums, :artists].each{|t| @db.drop_table(t) rescue nil}
+    @db.drop_table?(:albums_tags, :tags, :albums, :artists)
     @db.create_table(:artists) do
       primary_key :id
       String :name
@@ -598,7 +598,7 @@ describe "Sequel::Model Simple Associations" do
     [:Tag, :Album, :Artist].each{|x| Object.send(:remove_const, x)}
   end
   after(:all) do
-    @db.drop_table(:albums_tags, :tags, :albums, :artists)
+    @db.drop_table?(:albums_tags, :tags, :albums, :artists)
   end
   
   it_should_behave_like "regular and composite key associations"
@@ -733,7 +733,7 @@ end
 describe "Sequel::Model Composite Key Associations" do
   before(:all) do
     @db = INTEGRATION_DB
-    [:albums_tags, :tags, :albums, :artists].each{|t| @db.drop_table(t) rescue nil}
+    @db.drop_table?(:albums_tags, :tags, :albums, :artists)
     @db.create_table(:artists) do
       Integer :id1
       Integer :id2
@@ -813,7 +813,7 @@ describe "Sequel::Model Composite Key Associations" do
     [:Tag, :Album, :Artist].each{|x| Object.send(:remove_const, x)}
   end
   after(:all) do
-    @db.drop_table(:albums_tags, :tags, :albums, :artists)
+    @db.drop_table?(:albums_tags, :tags, :albums, :artists)
   end
 
   it_should_behave_like "regular and composite key associations"
@@ -868,7 +868,7 @@ end
 describe "Sequel::Model Associations with clashing column names" do
   before(:all) do
     @db = INTEGRATION_DB
-    [:bars_foos, :bars, :foos].each{|t| @db.drop_table(t) rescue nil}
+    @db.drop_table?(:bars_foos, :bars, :foos)
     @db.create_table(:foos) do
       primary_key :id
       Integer :object_id
@@ -899,7 +899,7 @@ describe "Sequel::Model Associations with clashing column names" do
     @Foo.db[:bars_foos].insert(2, 2)
   end
   after(:all) do
-    @db.drop_table(:bars_foos, :bars, :foos)
+    @db.drop_table?(:bars_foos, :bars, :foos)
   end
 
   it "should have working regular association methods" do