sequel 4.1.1 → 4.2.0

data/lib/sequel/version.rb

@@ -3,10 +3,10 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 1
+  MINOR = 2
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
-  TINY  = 1
+  TINY  = 0
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/mssql_spec.rb

@@ -612,7 +612,7 @@ describe "Database#foreign_key_list" do
       DB.execute_ddl "drop schema vendor"
     end
     it "should support mixed schema bound tables" do
- DB.foreign_key_list(:vendor__mapping).sort_by{|h| h[:name].to_s}.should == [{:name => :fk_mapping_item, :table => :items, :columns => [:item_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }, {:name => :fk_mapping_vendor, :table => :vendor__vendors, :columns => [:vendor_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }]
+ DB.foreign_key_list(:vendor__mapping).sort_by{|h| h[:name].to_s}.should == [{:name => :fk_mapping_item, :table => :items, :columns => [:item_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }, {:name => :fk_mapping_vendor, :table => Sequel.qualify(:vendor, :vendors), :columns => [:vendor_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }]
     end
   end
 end

data/spec/adapters/postgres_spec.rb

@@ -60,6 +60,18 @@ describe "PostgreSQL", '#create_table' do
       @db.create_table(:temp_unlogged_dolls, :temp => true, :unlogged => true){text :name}
     end.should raise_error(Sequel::Error, "can't provide both :temp and :unlogged to create_table")
   end
+
+  specify "should support pg_loose_count extension" do
+    @db.extension :pg_loose_count
+    @db.create_table(:tmp_dolls){text :name}
+    @db.loose_count(:tmp_dolls).should be_a_kind_of(Integer)
+    @db.loose_count(:tmp_dolls).should == 0
+    @db.loose_count(:public__tmp_dolls).should == 0
+    @db[:tmp_dolls].insert('a')
+    @db << 'VACUUM ANALYZE tmp_dolls'
+    @db.loose_count(:tmp_dolls).should == 1
+    @db.loose_count(:public__tmp_dolls).should == 1
+  end
 end
 
 describe "PostgreSQL views" do
@@ -1411,6 +1423,21 @@ if DB.adapter_scheme == :postgres
       end
     end
 
+    specify "should respect the :cursor_name option" do
+      one_rows = []
+      two_rows = []
+      @ds.order(:x).use_cursor(:cursor_name => 'cursor_one').each do |one|
+        one_rows << one
+        if one[:x] % 1000 == 500 
+          two_rows = []
+          @ds.order(:x).use_cursor(:cursor_name => 'cursor_two').each do |two|
+            two_rows << two
+          end
+        end
+      end
+      one_rows.should == two_rows
+    end
+
     specify "should handle returning inside block" do
       def @ds.check_return
         use_cursor.each{|r| return}
@@ -3135,3 +3162,46 @@ describe 'PostgreSQL row-valued/composite types' do
     end
   end
 end
+
+describe 'pg_static_cache_updater extension' do
+  before(:all) do
+    @db = DB
+    @db.extension :pg_static_cache_updater
+    @db.drop_function(@db.default_static_cache_update_name, :cascade=>true, :if_exists=>true)
+    @db.create_static_cache_update_function
+
+    @db.create_table!(:things) do
+      primary_key :id
+      String :name
+    end
+    @Thing = Class.new(Sequel::Model(:things))
+    @Thing.plugin :static_cache
+    @db.create_static_cache_update_trigger(:things)
+  end
+  after(:all) do
+    @db.drop_table(:things)
+    @db.drop_function(@db.default_static_cache_update_name)
+  end
+
+  specify "should reload model static cache when underlying table changes" do
+    @Thing.all.should == []
+    q = Queue.new
+    q1 = Queue.new
+
+    @db.listen_for_static_cache_updates(@Thing, :timeout=>0, :loop=>proc{q.push(nil); q1.pop.call})
+    q.pop
+    q1.push(proc{@db[:things].insert(1, 'A')})
+    q.pop
+    @Thing.all.should == [@Thing.load(:id=>1, :name=>'A')]
+
+    q1.push(proc{@db[:things].update(:name=>'B')})
+    q.pop
+    @Thing.all.should == [@Thing.load(:id=>1, :name=>'B')]
+
+    q1.push(proc{@db[:things].delete})
+    q.pop
+    @Thing.all.should == []
+
+    q1.push(proc{throw :stop})
+  end
+end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && DB.server_version >= 90000

data/spec/core/dataset_spec.rb

@@ -421,7 +421,12 @@ describe "Dataset#where" do
   specify "should handle partial names" do
     @dataset.where('price < :price AND id = :p', :p=>2, :price=>100).select_sql.should == "SELECT * FROM test WHERE (price < 100 AND id = 2)"
   end
-  
+
+  specify "should handle ::cast syntax when no parameters are supplied" do
+    @dataset.where('price::float = 10', {}).select_sql.should == "SELECT * FROM test WHERE (price::float = 10)"
+    @dataset.where('price::float ? 10', {}).select_sql.should == "SELECT * FROM test WHERE (price::float ? 10)"
+  end
+
   specify "should affect select, delete and update statements" do
     @d1.select_sql.should == "SELECT * FROM test WHERE (region = 'Asia')"
     @d1.delete_sql.should == "DELETE FROM test WHERE (region = 'Asia')"
@@ -1139,6 +1144,10 @@ describe "Dataset#from" do
     @dataset.from(:a, :b){[i, abc(de)]}.select_sql.should == "SELECT * FROM a, b, i, abc(de)"
   end
 
+  specify "should handle LATERAL subqueries" do
+    @dataset.from(:a, @dataset.from(:b).lateral).select_sql.should == "SELECT * FROM a, LATERAL (SELECT * FROM b) AS t1"
+  end
+
   specify "should accept :schema__table___alias symbol format" do
     @dataset.from(:abc__def).select_sql.should == "SELECT * FROM abc.def"
     @dataset.from(:a_b__c).select_sql.should == "SELECT * FROM a_b.c"
@@ -2039,6 +2048,12 @@ describe "Dataset#join_table" do
   specify "should support multiple joins" do
     @d.join_table(:inner, :b, :items_id=>:id).join_table(:left_outer, :c, :b_id => :b__id).sql.should == 'SELECT * FROM "items" INNER JOIN "b" ON ("b"."items_id" = "items"."id") LEFT OUTER JOIN "c" ON ("c"."b_id" = "b"."id")'
   end
+
+  specify "should handle LATERAL subqueries" do
+    @d.join(@d.lateral, :a=>:b).select_sql.should == 'SELECT * FROM "items" INNER JOIN LATERAL (SELECT * FROM "items") AS "t1" ON ("t1"."a" = "items"."b")'
+    @d.left_join(@d.lateral, :a=>:b).select_sql.should == 'SELECT * FROM "items" LEFT JOIN LATERAL (SELECT * FROM "items") AS "t1" ON ("t1"."a" = "items"."b")'
+    @d.cross_join(@d.lateral).select_sql.should == 'SELECT * FROM "items" CROSS JOIN LATERAL (SELECT * FROM "items") AS "t1"'
+  end
   
   specify "should support arbitrary join types" do
     @d.join_table(:magic, :categories, :category_id=>:id).sql.should == 'SELECT * FROM "items" MAGIC JOIN "categories" ON ("categories"."category_id" = "items"."id")'
@@ -4513,3 +4528,45 @@ describe "Dataset#supports_replace?" do
     Sequel::Dataset.new(nil).supports_replace?.should be_false
   end
 end
+
+describe "Frozen Datasets" do
+  before do
+    @ds = Sequel.mock[:test].freeze
+  end
+
+  it "should be returned by Dataset#freeze" do
+    @ds.should be_frozen
+  end
+
+  it "should have Dataset#freeze return receiver" do
+    @ds = Sequel.mock[:test]
+    @ds.freeze.should equal(@ds)
+  end
+
+  it "should have Dataset#freeze be a no-op" do
+    @ds.freeze.should equal(@ds)
+  end
+
+  it "should have clones be frozen" do
+    @ds.clone.should be_frozen
+  end
+
+  it "should have dups not be frozen" do
+    @ds.dup.should_not be_frozen
+  end
+
+  it "should raise an error when calling mutation methods" do
+    proc{@ds.select!(:a)}.should raise_error
+    proc{@ds.identifier_input_method = :a}.should raise_error
+    proc{@ds.identifier_output_method = :a}.should raise_error
+    proc{@ds.quote_identifiers = false}.should raise_error
+    proc{@ds.row_proc = proc{}}.should raise_error
+    proc{@ds.extension! :query}.should raise_error
+    proc{@ds.naked!}.should raise_error
+    proc{@ds.from_self!}.should raise_error
+  end
+
+  it "should not raise an error when calling query methods" do
+    @ds.select(:a).sql.should == 'SELECT a FROM test'
+  end
+end

data/spec/core/deprecated_spec.rb

@@ -27,7 +27,7 @@ describe "Sequel::Deprecated" do
 
   specify "should consider two arguments to be a method name and additional text" do
     @d.deprecate("foo", "Use bar instead")
-    @output.should == ['foo is deprecated and will be removed in Sequel 4.0.  Use bar instead.']
+    @output.should == ['foo is deprecated and will be removed in a future version of Sequel.  Use bar instead.']
   end
 
   specify "should include a prefix if set" do

data/spec/core/schema_spec.rb

@@ -397,6 +397,24 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (name text, UNIQUE (name))"]
   end
 
+  specify "should accept partial index definitions" do
+    def @db.supports_partial_indexes?() true end
+    @db.create_table(:cats) do
+      integer :id
+      index :id, :where=>proc{id > 1}
+    end
+    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id) WHERE (id > 1)"]
+  end
+
+  specify "should raise an error if partial indexes are not supported" do
+    proc do 
+      @db.create_table(:cats) do
+        integer :id
+        index :id, :where=>proc{id > 1}
+      end
+    end.should raise_error(Sequel::Error)
+  end
+
   specify "should not raise on index error for unsupported index definitions if ignore_index_errors is used" do
     proc {
       @db.create_table(:cats, :ignore_index_errors=>true) do

data/spec/extensions/composition_spec.rb

@@ -201,6 +201,13 @@ describe "Composition plugin" do
     proc{@o.date = Date.today}.should raise_error
   end
 
+  it "should have #dup duplicate compositions" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @o.date.should == Date.new(1, 2, 3)
+    @o.dup.compositions.should == @o.compositions
+    @o.dup.compositions.should_not equal(@o.compositions)
+  end
+
   it "should work correctly with subclasses" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     c = Class.new(@c)

data/spec/extensions/dirty_spec.rb

@@ -122,6 +122,15 @@ describe "Sequel::Plugins::Dirty" do
       @o.initial_value(:initial).should == 'i'
       proc{@o.initial = 'b'}.should raise_error
     end
+
+    it "should have #dup duplicate structures" do
+      @o.dup.initial_values.should == @o.initial_values
+      @o.dup.initial_values.should_not equal(@o.initial_values)
+      @o.dup.instance_variable_get(:@missing_initial_values).should == @o.instance_variable_get(:@missing_initial_values)
+      @o.dup.instance_variable_get(:@missing_initial_values).should_not equal(@o.instance_variable_get(:@missing_initial_values))
+      @o.dup.previous_changes.should == @o.previous_changes
+      @o.dup.previous_changes.should_not equal(@o.previous_changes) if @o.previous_changes
+    end
   end
 
   describe "with new instance" do

data/spec/extensions/from_block_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "from_block extension" do
+  before do
+    @db = Sequel.mock
+    @db.extension(:from_block)
+  end
+
+  specify "should make Database#from blocks apply to FROM" do
+    @db.from{f}.sql.should == 'SELECT * FROM f'
+    @db.from{[f, g(f)]}.sql.should == 'SELECT * FROM f, g(f)'
+  end
+
+  specify "should handle from blocks with method arguments" do
+    @db.from(:f){g(f)}.sql.should == 'SELECT * FROM f, g(f)'
+  end
+
+  specify "should handle from without block" do
+    @db.from(:f).sql.should == 'SELECT * FROM f'
+  end
+end

data/spec/extensions/instance_filters_spec.rb

@@ -70,4 +70,10 @@ describe "instance_filters plugin" do
     @p.freeze
     proc{@p.instance_filter(:name=>'Jim')}.should raise_error
   end 
+
+  specify "should have dup duplicate internal structures" do
+    @p.instance_filter(:name=>'Joe')
+    @p.dup.send(:instance_filters).should == @p.send(:instance_filters)
+    @p.dup.send(:instance_filters).should_not equal(@p.send(:instance_filters))
+  end 
 end

data/spec/extensions/pg_loose_count_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_loose_count extension" do
+  before do
+    @db = Sequel.mock(:host=>'postgres', :fetch=>{:v=>1}).extension(:pg_loose_count)
+  end
+
+  specify "should add loose_count method getting fast count for entire table using table statistics" do
+    @db.loose_count(:a).should == 1
+    @db.sqls.should == ["SELECT CAST(reltuples AS integer) AS v FROM pg_class WHERE (oid = CAST(CAST('a' AS regclass) AS oid)) LIMIT 1"]
+  end
+
+  specify "should support schema qualified tables" do
+    @db.loose_count(:a__b).should == 1
+    @db.sqls.should == ["SELECT CAST(reltuples AS integer) AS v FROM pg_class WHERE (oid = CAST(CAST('a.b' AS regclass) AS oid)) LIMIT 1"]
+  end
+end

data/spec/extensions/pg_static_cache_updater_spec.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_static_cache_updater extension" do
+  before do
+    @db = Sequel.mock(:host=>'postgres')
+    def @db.listen(chan, opts={})
+      execute("LISTEN #{chan}")
+      yield(*opts[:yield])
+    end
+    @db.extension(:pg_static_cache_updater)
+    @model = Class.new(Sequel::Model(@db[:table]))
+    @model.plugin :static_cache
+    @db.sqls
+  end
+
+  specify "#create_static_cache_update_function should create a function in the database" do
+    @db.create_static_cache_update_function
+    @db.sqls.first.gsub(/\s+/, ' ').should == " CREATE FUNCTION sequel_static_cache_update() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN PERFORM pg_notify(''sequel_static_cache_update'', TG_RELID::text); RETURN NULL; END ' "
+  end
+
+  specify "#create_static_cache_update_function should support :channel_name and :function_name options" do
+    @db.create_static_cache_update_function(:channel_name=>'foo', :function_name=>'bar')
+    @db.sqls.first.gsub(/\s+/, ' ').should == " CREATE FUNCTION bar() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN PERFORM pg_notify(''foo'', TG_RELID::text); RETURN NULL; END ' "
+  end
+
+  specify "#create_static_cache_update_trigger should create a trigger for the database table" do
+    @db.create_static_cache_update_trigger(:tab)
+    @db.sqls.first.gsub(/\s+/, ' ').should == "CREATE TRIGGER sequel_static_cache_update AFTER INSERT OR UPDATE OR DELETE ON tab EXECUTE PROCEDURE sequel_static_cache_update()"
+  end
+
+  specify "#create_static_cache_update_trigger should support :trigger_name and :function_name options" do
+    @db.create_static_cache_update_trigger(:tab, :trigger_name=>'foo', :function_name=>'bar')
+    @db.sqls.first.gsub(/\s+/, ' ').should == "CREATE TRIGGER foo AFTER INSERT OR UPDATE OR DELETE ON tab EXECUTE PROCEDURE bar()"
+  end
+
+  specify "#default_static_cache_update_name should return the default name for function, trigger, and channel" do
+    @db.default_static_cache_update_name.should == :sequel_static_cache_update
+  end
+
+  specify "#listen_for_static_cache_updates should listen for changes to model tables and reload model classes" do
+    @db.fetch = {:v=>1234}
+    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 1234]).join
+    @db.sqls.should == ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN sequel_static_cache_update", "SELECT * FROM table"]
+  end
+
+  specify "#listen_for_static_cache_updates should not reload model classes if oid doesn't match" do
+    @db.fetch = {:v=>1234}
+    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345]).join
+    @db.sqls.should == ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN sequel_static_cache_update"]
+  end
+
+  specify "#listen_for_static_cache_updates should support a single model argument" do
+    @db.fetch = {:v=>1234}
+    @db.listen_for_static_cache_updates(@model, :yield=>[nil, nil, 1234]).join
+    @db.sqls.should == ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN sequel_static_cache_update", "SELECT * FROM table"]
+  end
+
+  specify "#listen_for_static_cache_updates should support the :channel_name option" do
+    @db.fetch = {:v=>1234}
+    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345], :channel_name=>:foo).join
+    @db.sqls.should == ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN foo"]
+  end
+
+  specify "#listen_for_static_cache_updates should raise an error if given an empty array" do
+    @db.fetch = {:v=>1234}
+    proc{@db.listen_for_static_cache_updates([])}.should raise_error(Sequel::Error)
+  end
+
+  specify "#listen_for_static_cache_updates should raise an error if one of the models is not using the static cache plugin" do
+    @db.fetch = {:v=>1234}
+    proc{@db.listen_for_static_cache_updates(Class.new(Sequel::Model(@db[:table])))}.should raise_error(Sequel::Error)
+  end
+
+  specify "#listen_for_static_cache_updates should raise an error if the database doesn't respond to listen" do
+    @db = Sequel.mock(:host=>'postgres')
+    @db.extension(:pg_static_cache_updater)
+    @db.fetch = {:v=>1234}
+    proc{@db.listen_for_static_cache_updates(Class.new(Sequel::Model(@db[:table])))}.should raise_error(Sequel::Error)
+  end
+end

data/spec/extensions/query_spec.rb

@@ -87,6 +87,14 @@ describe "Dataset#query" do
     q.sql.should == "SELECT * FROM xyz"
   end
   
+  specify "should have an appropriate mutation method" do
+    @d.query! do
+      select :a, :b___mongo
+      from :yyy
+    end
+    @d.sql.should == "SELECT a, b AS mongo FROM yyy"
+  end
+
   specify "should raise on non-chainable method calls" do
     proc {@d.query {row_proc}}.should raise_error(Sequel::Error)
     proc {@d.query {all}}.should raise_error(Sequel::Error)

data/spec/extensions/serialization_modification_detection_spec.rb

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

data/spec/extensions/serialization_spec.rb

@@ -293,4 +293,11 @@ describe "Serialization plugin" do
     proc{o.abc = 2}.should raise_error
     proc{o.def = 'h'}.should raise_error
   end
+
+  it "should have dup duplicate internal structures" do
+    @c.plugin :serialization, :yaml, :abc, :def
+    o = @c.new
+    o.dup.deserialized_values.should == o.deserialized_values
+    o.dup.deserialized_values.should_not equal(o.deserialized_values)
+  end
 end

data/spec/extensions/set_overrides_spec.rb

@@ -24,6 +24,12 @@ describe "Sequel::Dataset #set_defaults" do
   specify "should not affect String update arguments" do
     @ds.update_sql('y = 2').should == "UPDATE items SET y = 2"
   end
+
+  specify "should have working mutation method" do
+    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides)
+    @ds.set_defaults!(:x=>1)
+    @ds.insert_sql.should == "INSERT INTO items (x) VALUES (1)"
+  end
 end
 
 describe "Sequel::Dataset #set_overrides" do
@@ -46,4 +52,10 @@ describe "Sequel::Dataset #set_overrides" do
     @ds.set_overrides(:y=>2).update_sql.should =~ /UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/
     @ds.set_overrides(:x=>2).update_sql.should == "UPDATE items SET x = 1"
   end
+
+  specify "should have working mutation method" do
+    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides)
+    @ds.set_overrides!(:x=>1)
+    @ds.insert_sql.should == "INSERT INTO items (x) VALUES (1)"
+  end
 end