sequel 3.41.0 → 3.42.0

data/lib/sequel/model/dataset_module.rb

@@ -0,0 +1,30 @@
+module Sequel
+  class Model
+    # This Module subclass is used by Model.dataset_module
+    # to add dataset methods to classes.  It adds a couple
+    # of features standard Modules, allowing you to use
+    # the same subset method you can call on Model, as well
+    # as making sure that public methods added to the module
+    # automatically have class methods created for them.
+    class DatasetModule < ::Module
+      # Store the model related to this dataset module.
+      def initialize(model)
+        @model = model
+      end
+
+      # Define a named filter for this dataset, see
+      # Model.subset for details.
+      def subset(name, *args, &block)
+        define_method(name){filter(*args, &block)}
+      end
+
+      private
+
+      # Add a class method to the related model that
+      # calls the dataset method of the same name.
+      def method_added(meth)
+        @model.send(:def_model_dataset_method, meth)
+      end
+    end
+  end
+end

data/lib/sequel/plugins/force_encoding.rb

@@ -63,7 +63,10 @@ module Sequel
         # Force the encoding of all returned strings to the model's forced_encoding.
         def typecast_value(column, value)
           s = super
-          s.force_encoding(model.forced_encoding) if s.is_a?(String) && model.forced_encoding
+          if s.is_a?(String) && (fe = model.forced_encoding)
+            s = s.dup if s.frozen?
+            s.force_encoding(fe)
+          end
           s
         end
       end

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 41
+  MINOR = 42
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -159,6 +159,15 @@ describe "A PostgreSQL dataset" do
     @db.alter_table(:atest){drop_constraint 'atest_ex'}
   end if POSTGRES_DB.server_version >= 90000
 
+  specify "should support Database#do for executing anonymous code blocks" do
+    @db.drop_table?(:btest)
+    @db.do "BEGIN EXECUTE 'CREATE TABLE btest (a INTEGER)'; EXECUTE 'INSERT INTO btest VALUES (1)'; END"
+    @db[:btest].select_map(:a).should == [1]
+
+    @db.do "BEGIN EXECUTE 'DROP TABLE btest; CREATE TABLE atest (a INTEGER)'; EXECUTE 'INSERT INTO atest VALUES (1)'; END", :language=>:plpgsql
+    @db[:atest].select_map(:a).should == [1]
+  end if POSTGRES_DB.server_version >= 90000
+
   specify "should support adding foreign key constarints that are not yet valid, and validating them later" do
     @db.create_table!(:atest){primary_key :id; Integer :fk}
     @db[:atest].insert(1, 5)
@@ -1222,7 +1231,79 @@ if POSTGRES_DB.adapter_scheme == :postgres
   end
 end
 
-if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRES_DB.server_version >= 90000
+if ((POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || POSTGRES_DB.adapter_scheme == :jdbc) && POSTGRES_DB.server_version >= 90000
+  describe "Postgres::Database#copy_into" do
+    before(:all) do
+      @db = POSTGRES_DB
+      @db.create_table!(:test_copy){Integer :x; Integer :y}
+      @ds = @db[:test_copy].order(:x, :y)
+    end
+    before do
+      @db[:test_copy].delete
+    end
+    after(:all) do
+      @db.drop_table?(:test_copy)
+    end
+
+    specify "should work with a :data option containing data in PostgreSQL text format" do
+      @db.copy_into(:test_copy, :data=>"1\t2\n3\t4\n")
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should work with :format=>:csv option and :data option containing data in CSV format" do
+      @db.copy_into(:test_copy, :format=>:csv, :data=>"1,2\n3,4\n")
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should respect given :options" do
+      @db.copy_into(:test_copy, :options=>"FORMAT csv, HEADER TRUE", :data=>"x,y\n1,2\n3,4\n")
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should respect given :options options when :format is used" do
+      @db.copy_into(:test_copy, :options=>"QUOTE '''', DELIMITER '|'", :format=>:csv, :data=>"'1'|'2'\n'3'|'4'\n")
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should accept :columns option to online copy the given columns" do
+      @db.copy_into(:test_copy, :data=>"1\t2\n3\t4\n", :columns=>[:y, :x])
+      @ds.select_map([:x, :y]).should == [[2, 1], [4, 3]]
+    end
+
+    specify "should accept a block and use returned values for the copy in data stream" do
+      buf = ["1\t2\n", "3\t4\n"]
+      @db.copy_into(:test_copy){buf.shift}
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should work correctly with a block and :format=>:csv" do
+      buf = ["1,2\n", "3,4\n"]
+      @db.copy_into(:test_copy, :format=>:csv){buf.shift}
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should accept an enumerable as the :data option" do
+      @db.copy_into(:test_copy, :data=>["1\t2\n", "3\t4\n"])
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should have an exception, cause a rollback of copied data and still have a usable connection" do
+      2.times do
+        sent = false
+        proc{@db.copy_into(:test_copy){raise ArgumentError if sent; sent = true; "1\t2\n"}}.should raise_error(ArgumentError)
+        @ds.select_map([:x, :y]).should == []
+      end
+    end
+
+    specify "should raise an Error if both :data and a block are provided" do
+      proc{@db.copy_into(:test_copy, :data=>["1\t2\n", "3\t4\n"]){}}.should raise_error(Sequel::Error)
+    end
+
+    specify "should raise an Error if neither :data or a block are provided" do
+      proc{@db.copy_into(:test_copy)}.should raise_error(Sequel::Error)
+    end
+  end
+
   describe "Postgres::Database#copy_table" do
     before(:all) do
       @db = POSTGRES_DB
@@ -1293,79 +1374,9 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
       @db[:test_copy].select_order_map(:x).should == [1, 3]
     end
   end
+end
 
-  describe "Postgres::Database#copy_table_from" do
-    before(:all) do
-      @db = POSTGRES_DB
-      @db.create_table!(:test_copy){Integer :x; Integer :y}
-      @ds = @db[:test_copy].order(:x, :y)
-    end
-    before do
-      @db[:test_copy].delete
-    end
-    after(:all) do
-      @db.drop_table?(:test_copy)
-    end
-
-    specify "should work with a :data option containing data in PostgreSQL text format" do
-      @db.copy_into(:test_copy, :data=>"1\t2\n3\t4\n")
-      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
-    end
-
-    specify "should work with :format=>:csv option and :data option containing data in CSV format" do
-      @db.copy_into(:test_copy, :format=>:csv, :data=>"1,2\n3,4\n")
-      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
-    end
-
-    specify "should respect given :options" do
-      @db.copy_into(:test_copy, :options=>"FORMAT csv, HEADER TRUE", :data=>"x,y\n1,2\n3,4\n")
-      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
-    end
-
-    specify "should respect given :options options when :format is used" do
-      @db.copy_into(:test_copy, :options=>"QUOTE '''', DELIMITER '|'", :format=>:csv, :data=>"'1'|'2'\n'3'|'4'\n")
-      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
-    end
-
-    specify "should accept :columns option to online copy the given columns" do
-      @db.copy_into(:test_copy, :data=>"1\t2\n3\t4\n", :columns=>[:y, :x])
-      @ds.select_map([:x, :y]).should == [[2, 1], [4, 3]]
-    end
-
-    specify "should accept a block and use returned values for the copy in data stream" do
-      buf = ["1\t2\n", "3\t4\n"]
-      @db.copy_into(:test_copy){buf.shift}
-      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
-    end
-
-    specify "should work correctly with a block and :format=>:csv" do
-      buf = ["1,2\n", "3,4\n"]
-      @db.copy_into(:test_copy, :format=>:csv){buf.shift}
-      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
-    end
-
-    specify "should accept an enumerable as the :data option" do
-      @db.copy_into(:test_copy, :data=>["1\t2\n", "3\t4\n"])
-      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
-    end
-
-    specify "should have an exception should cause a rollback of copied data and still have a usable connection" do
-      2.times do
-        sent = false
-        proc{@db.copy_into(:test_copy){raise ArgumentError if sent; sent = true; "1\t2\n"}}.should raise_error(ArgumentError)
-        @ds.select_map([:x, :y]).should == []
-      end
-    end
-
-    specify "should raise an Error if both :data and a block are provided" do
-      proc{@db.copy_into(:test_copy, :data=>["1\t2\n", "3\t4\n"]){}}.should raise_error(Sequel::Error)
-    end
-
-    specify "should raise an Error if neither :data or a block are provided" do
-      proc{@db.copy_into(:test_copy)}.should raise_error(Sequel::Error)
-    end
-  end
-
+if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRES_DB.server_version >= 90000
   describe "Postgres::Database LISTEN/NOTIFY" do
     before(:all) do
       @db = POSTGRES_DB

data/spec/core/database_spec.rb

@@ -22,10 +22,18 @@ describe "A new Database" do
     Sequel::Database.new(1 => 2, :logger => 4, :loggers => 3).loggers.should == [4,3]
     Sequel::Database.new(1 => 2, :logger => [4], :loggers => [3]).loggers.should == [4,3]
   end
+
+  specify "should handle the default string column size" do
+    @db.default_string_column_size.should == 255
+    db = Sequel::Database.new(:default_string_column_size=>50)
+    db.default_string_column_size.should == 50
+    db.default_string_column_size = 2
+    db.default_string_column_size.should == 2
+  end
   
   specify "should set the sql_log_level from opts[:sql_log_level]" do
-    db = Sequel::Database.new(1 => 2, :sql_log_level=>:debug).sql_log_level.should == :debug
-    db = Sequel::Database.new(1 => 2, :sql_log_level=>'debug').sql_log_level.should == :debug
+    Sequel::Database.new(1 => 2, :sql_log_level=>:debug).sql_log_level.should == :debug
+    Sequel::Database.new(1 => 2, :sql_log_level=>'debug').sql_log_level.should == :debug
   end
   
   specify "should create a connection pool" do
@@ -675,7 +683,7 @@ shared_examples_for "Database#transaction" do
     end
     e.should_not be_nil
     e.wrapped_exception.should be_a_kind_of(ec)
-    @db.sqls.should == ['BEGIN', 'DROP TABLE test;']
+    @db.sqls.should == ['BEGIN', 'DROP TABLE test;', 'ROLLBACK']
   end
   
   specify "should handle errors when sending ROLLBACK" do

data/spec/core/dataset_spec.rb

@@ -1885,6 +1885,11 @@ describe "Dataset#count" do
     @db.sqls.should == ["SELECT COUNT(*) AS count FROM (SELECT * FROM test LIMIT 5) AS t1 LIMIT 1"]
   end
   
+  specify "should work correctly with offsets" do
+    @dataset.limit(nil, 5).count.should == 1
+    @db.sqls.should == ["SELECT COUNT(*) AS count FROM (SELECT * FROM test OFFSET 5) AS t1 LIMIT 1"]
+  end
+  
   it "should work on a graphed_dataset" do
     @dataset.should_receive(:columns).twice.and_return([:a])
     @dataset.graph(@dataset, [:a], :table_alias=>:test2).count.should == 1
@@ -2382,6 +2387,13 @@ describe "Dataset aggregate methods" do
     d.min(:a).should == 'SELECT min(a) FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
     d.max(:a).should == 'SELECT max(a) FROM (SELECT * FROM test ORDER BY a LIMIT 5) AS t1 LIMIT 1'
   end
+  
+  specify "should accept virtual row blocks" do
+    @d.avg{a(b)}.should == 'SELECT avg(a(b)) FROM test LIMIT 1'
+    @d.sum{a(b)}.should == 'SELECT sum(a(b)) FROM test LIMIT 1'
+    @d.min{a(b)}.should == 'SELECT min(a(b)) FROM test LIMIT 1'
+    @d.max{a(b)}.should == 'SELECT max(a(b)) FROM test LIMIT 1'
+  end
 end
 
 describe "Dataset#range" do
@@ -2406,6 +2418,11 @@ describe "Dataset#range" do
     @ds.order(:stamp).limit(5).range(:stamp).should == (1..10)
     @db.sqls.should == ['SELECT min(stamp) AS v1, max(stamp) AS v2 FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
   end
+  
+  specify "should accept virtual row blocks" do
+    @ds.range{a(b)}
+    @db.sqls.should == ["SELECT min(a(b)) AS v1, max(a(b)) AS v2 FROM test LIMIT 1"]
+  end
 end
 
 describe "Dataset#interval" do
@@ -2426,6 +2443,11 @@ describe "Dataset#interval" do
     @ds.order(:stamp).limit(5).interval(:stamp).should == 1234
     @db.sqls.should == ['SELECT (max(stamp) - min(stamp)) FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
   end
+
+  specify "should accept virtual row blocks" do
+    @ds.interval{a(b)}
+    @db.sqls.should == ["SELECT (max(a(b)) - min(a(b))) FROM test LIMIT 1"]
+  end
 end
 
 describe "Dataset #first and #last" do

data/spec/core/schema_spec.rb

@@ -67,6 +67,20 @@ describe "DB#create_table" do
     @db.sqls.should == ['CREATE TABLE cats (o varchar(255) PRIMARY KEY AUTOINCREMENT, a varchar(255), b integer, c integer, d bigint, e double precision, f numeric, g date, h timestamp, i timestamp, j numeric, k blob, l boolean, m boolean, n integer, p date REFERENCES f)']
   end
 
+  specify "should transform types given as ruby classes to database-specific types" do
+    @db.default_string_column_size = 50
+    @db.create_table(:cats) do
+      String :a
+      String :a2, :size=>13
+      String :a3, :fixed=>true
+      String :a4, :size=>13, :fixed=>true
+      String :a5, :text=>true
+      varchar :a6
+      varchar :a7, :size=>13
+    end
+    @db.sqls.should == ['CREATE TABLE cats (a varchar(50), a2 varchar(13), a3 char(50), a4 char(13), a5 text, a6 varchar(50), a7 varchar(13))']
+  end
+
   specify "should allow the use of modifiers with ruby class types" do
     @db.create_table(:cats) do
       String :a, :size=>50
@@ -133,6 +147,33 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (id integer, name text UNIQUE)"]
   end
   
+  specify "should handle not deferred unique constraints" do
+    @db.create_table(:cats) do
+      integer :id
+      text :name
+      unique :name, :deferrable=>false
+    end
+    @db.sqls.should == ["CREATE TABLE cats (id integer, name text, UNIQUE (name) NOT DEFERRABLE)"]
+  end
+  
+  specify "should handle deferred unique constraints" do
+    @db.create_table(:cats) do
+      integer :id
+      text :name
+      unique :name, :deferrable=>true
+    end
+    @db.sqls.should == ["CREATE TABLE cats (id integer, name text, UNIQUE (name) DEFERRABLE INITIALLY DEFERRED)"]
+  end
+  
+  specify "should handle deferred initially immediate unique constraints" do
+    @db.create_table(:cats) do
+      integer :id
+      text :name
+      unique :name, :deferrable=>:immediate
+    end
+    @db.sqls.should == ["CREATE TABLE cats (id integer, name text, UNIQUE (name) DEFERRABLE INITIALLY IMMEDIATE)"]
+  end
+  
   specify "should accept unsigned definition" do
     @db.create_table(:cats) do
       integer :value, :unsigned => true

data/spec/extensions/force_encoding_spec.rb

@@ -25,6 +25,15 @@ describe "force_encoding plugin" do
     o.x.encoding.should == @e1
   end
   
+  specify "should work correctly when given a frozen string" do
+    s = 'blah'
+    s.force_encoding('US-ASCII')
+    s.freeze
+    o = @c.new(:x=>s)
+    o.x.should == 'blah'
+    o.x.encoding.should == @e1
+  end
+  
   specify "should have a forced_encoding class accessor" do
     s = 'blah'
     s.force_encoding('US-ASCII')

data/spec/integration/schema_test.rb

@@ -163,20 +163,23 @@ describe "Database index parsing" do
   end
 
   specify "should parse indexes into a hash" do
+    # Delete :deferrable entry, since not all adapters implement it
+    f = lambda{h = INTEGRATION_DB.indexes(:items); h.values.each{|h2| h2.delete(:deferrable)}; h}
+
     INTEGRATION_DB.create_table!(:items){Integer :n; Integer :a}
-    INTEGRATION_DB.indexes(:items).should == {}
+    f.call.should == {}
     INTEGRATION_DB.add_index(:items, :n)
-    INTEGRATION_DB.indexes(:items).should == {:items_n_index=>{:columns=>[:n], :unique=>false}}
+    f.call.should == {:items_n_index=>{:columns=>[:n], :unique=>false}}
     INTEGRATION_DB.drop_index(:items, :n)
-    INTEGRATION_DB.indexes(:items).should == {}
+    f.call.should == {}
     INTEGRATION_DB.add_index(:items, :n, :unique=>true, :name=>:blah_blah_index)
-    INTEGRATION_DB.indexes(:items).should == {:blah_blah_index=>{:columns=>[:n], :unique=>true}}
+    f.call.should == {:blah_blah_index=>{:columns=>[:n], :unique=>true}}
     INTEGRATION_DB.add_index(:items, [:n, :a])
-    INTEGRATION_DB.indexes(:items).should == {:blah_blah_index=>{:columns=>[:n], :unique=>true}, :items_n_a_index=>{:columns=>[:n, :a], :unique=>false}}
+    f.call.should == {:blah_blah_index=>{:columns=>[:n], :unique=>true}, :items_n_a_index=>{:columns=>[:n, :a], :unique=>false}}
     INTEGRATION_DB.drop_index(:items, :n, :name=>:blah_blah_index)
-    INTEGRATION_DB.indexes(:items).should == {:items_n_a_index=>{:columns=>[:n, :a], :unique=>false}}
+    f.call.should == {:items_n_a_index=>{:columns=>[:n, :a], :unique=>false}}
     INTEGRATION_DB.drop_index(:items, [:n, :a])
-    INTEGRATION_DB.indexes(:items).should == {}
+    f.call.should == {}
   end
   
   specify "should not include a primary key index" do
@@ -619,6 +622,28 @@ describe "Database schema modifiers" do
     @db[:items].insert(:number=>1)
     @db[:items].get(:name).should == 'A13'
   end
+
+  specify "should support deferrable foreign key constraints" do
+    @db.create_table!(:items2){Integer :id, :primary_key=>true}
+    @db.create_table!(:items){foreign_key :id, :items2, :deferrable=>true}
+    proc{@db[:items].insert(1)}.should raise_error(Sequel::DatabaseError)
+    proc{@db.transaction{proc{@db[:items].insert(1)}.should_not raise_error}}.should raise_error(Sequel::DatabaseError)
+  end if INTEGRATION_DB.supports_deferrable_foreign_key_constraints?
+
+  specify "should support deferrable unique constraints when creating or altering tables" do
+    @db.create_table!(:items){Integer :t; unique [:t], :name=>:atest_def, :deferrable=>true, :using=>:btree}
+    @db[:items].insert(1)
+    @db[:items].insert(2)
+    proc{@db[:items].insert(2)}.should raise_error(Sequel::DatabaseError)
+    proc{@db.transaction{proc{@db[:items].insert(2)}.should_not raise_error}}.should raise_error(Sequel::DatabaseError)
+
+    @db.create_table!(:items){Integer :t}
+    @db.alter_table(:items){add_unique_constraint [:t], :name=>:atest_def, :deferrable=>true, :using=>:btree}
+    @db[:items].insert(1)
+    @db[:items].insert(2)
+    proc{@db[:items].insert(2)}.should raise_error(Sequel::DatabaseError)
+    proc{@db.transaction{proc{@db[:items].insert(2)}.should_not raise_error}}.should raise_error(Sequel::DatabaseError)
+  end if INTEGRATION_DB.supports_deferrable_constraints?
 end
 
 test_tables = begin

data/spec/model/base_spec.rb

@@ -182,11 +182,21 @@ describe Sequel::Model, ".dataset_module" do
     @c.dataset.return_3.should == 3
   end
 
+  it "should also extend the instance_dataset with the module if the model has a dataset" do
+    @c.dataset_module{def return_3() 3 end}
+    @c.instance_dataset.return_3.should == 3
+  end
+
   it "should add methods defined in the module to the class" do
     @c.dataset_module{def return_3() 3 end}
     @c.return_3.should == 3
   end
 
+  it "should add methods defined in the module outside the block to the class" do
+    @c.dataset_module.module_eval{def return_3() 3 end}
+    @c.return_3.should == 3
+  end
+
   it "should cache calls and readd methods if set_dataset is used" do
     @c.dataset_module{def return_3() 3 end}
     @c.set_dataset :items
@@ -251,6 +261,12 @@ describe Sequel::Model, ".dataset_module" do
     Object.new.extend(@c.dataset_module Module.new{def return_3() 3 end}).return_3.should == 3
   end
 
+  it "should have dataset_module support a subset method" do
+    @c.dataset_module{subset :released, :released}
+    @c.released.sql.should == 'SELECT * FROM items WHERE released'
+    @c.where(:foo).released.sql.should == 'SELECT * FROM items WHERE (foo AND released)'
+  end
+
   it "should raise error if called with both an argument and ablock" do
     proc{@c.dataset_module(Module.new{def return_3() 3 end}){}}.should raise_error(Sequel::Error)
   end