sequel 4.46.0 → 4.49.0

data/spec/extensions/pg_range_spec.rb

@@ -4,10 +4,10 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "pg_range extension" do
   before(:all) do
     Sequel.extension :pg_array, :pg_range
-    @pg_types = Sequel::Postgres::PG_TYPES.dup
+    @pg_types = Sequel::Postgres::PG__TYPES.dup # SEQUEL5: Remove
   end
   after(:all) do
-    Sequel::Postgres::PG_TYPES.replace(@pg_types)
+    Sequel::Postgres::PG__TYPES.replace(@pg_types) # SEQUEL5: Remove
   end
 
   before do
@@ -21,6 +21,46 @@ describe "pg_range extension" do
     @db.extension(:pg_array, :pg_range)
   end
 
+  deprecated "should set up conversion procs correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[3904].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int4range')
+    cp[3906].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'numrange')
+    cp[3908].call("[2011-01-02 10:20:30,2011-02-03 10:20:30)").must_equal @R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tsrange')
+    cp[3910].call("[2011-01-02 10:20:30,2011-02-03 10:20:30)").must_equal @R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tstzrange')
+    cp[3912].call("[2011-01-02,2011-02-03)").must_equal  @R.new(Date.new(2011, 1, 2),Date.new(2011, 2, 3), :exclude_begin=>false, :exclude_end=>true, :db_type=>'daterange')
+    cp[3926].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int8range')
+  end
+
+  deprecated "should set up conversion procs for arrays correctly" do
+    cp = Sequel::Postgres::PG__TYPES
+    cp[3905].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int4range')]
+    cp[3907].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'numrange')]
+    cp[3909].call("{\"[2011-01-02 10:20:30,2011-02-03 10:20:30)\"}").must_equal [@R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tsrange')]
+    cp[3911].call("{\"[2011-01-02 10:20:30,2011-02-03 10:20:30)\"}").must_equal [@R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tstzrange')]
+    cp[3913].call("{\"[2011-01-02,2011-02-03)\"}").must_equal [@R.new(Date.new(2011, 1, 2),Date.new(2011, 2, 3), :exclude_begin=>false, :exclude_end=>true, :db_type=>'daterange')]
+    cp[3927].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int8range')]
+  end
+
+  it "should set up conversion procs correctly" do
+    cp = @db.conversion_procs
+    cp[3904].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int4range')
+    cp[3906].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'numrange')
+    cp[3908].call("[2011-01-02 10:20:30,2011-02-03 10:20:30)").must_equal @R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tsrange')
+    cp[3910].call("[2011-01-02 10:20:30,2011-02-03 10:20:30)").must_equal @R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tstzrange')
+    cp[3912].call("[2011-01-02,2011-02-03)").must_equal  @R.new(Date.new(2011, 1, 2),Date.new(2011, 2, 3), :exclude_begin=>false, :exclude_end=>true, :db_type=>'daterange')
+    cp[3926].call("[1,2]").must_equal @R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int8range')
+  end
+
+  it "should set up conversion procs for arrays correctly" do
+    cp = @db.conversion_procs
+    cp[3905].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int4range')]
+    cp[3907].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'numrange')]
+    cp[3909].call("{\"[2011-01-02 10:20:30,2011-02-03 10:20:30)\"}").must_equal [@R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tsrange')]
+    cp[3911].call("{\"[2011-01-02 10:20:30,2011-02-03 10:20:30)\"}").must_equal [@R.new(Time.local(2011, 1, 2, 10, 20, 30),Time.local(2011, 2, 3, 10, 20, 30), :exclude_begin=>false, :exclude_end=>true, :db_type=>'tstzrange')]
+    cp[3913].call("{\"[2011-01-02,2011-02-03)\"}").must_equal [@R.new(Date.new(2011, 1, 2),Date.new(2011, 2, 3), :exclude_begin=>false, :exclude_end=>true, :db_type=>'daterange')]
+    cp[3927].call("{\"[1,2]\"}").must_equal [@R.new(1,2, :exclude_begin=>false, :exclude_end=>false, :db_type=>'int8range')]
+  end
+
   it "should literalize Range instances to strings correctly" do
     @db.literal(Date.new(2011, 1, 2)...Date.new(2011, 3, 2)).must_equal "'[2011-01-02,2011-03-02)'"
     @db.literal(Time.local(2011, 1, 2, 10, 20, 30)...Time.local(2011, 2, 3, 10, 20, 30)).must_equal "'[2011-01-02 10:20:30,2011-02-03 10:20:30)'"
@@ -131,43 +171,87 @@ describe "pg_range extension" do
     end
   end
 
-  it "should support registering custom range types" do
+  deprecated "should support registering custom range types" do
     @R.register('foorange')
     @db.typecast_value(:foorange, 1..2).must_be_kind_of(@R)
     @db.fetch = [{:name=>'id', :db_type=>'foorange'}]
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:foorange]
   end
 
-  it "should support using a block as a custom conversion proc given as block" do
+  deprecated "should support using a block as a custom conversion proc given as block" do
     @R.register('foo2range'){|s| (s*2).to_i}
     @db.typecast_value(:foo2range, '[1,2]').must_be :==, (11..22)
   end
 
-  it "should support using a block as a custom conversion proc given as :converter option" do
+  deprecated "should support using a block as a custom conversion proc given as :converter option" do
     @R.register('foo3range', :converter=>proc{|s| (s*2).to_i})
     @db.typecast_value(:foo3range, '[1,2]').must_be :==, (11..22)
   end
 
-  it "should support using an existing scaler conversion proc via the :subtype_oid option" do
+  deprecated "should support using an existing scaler conversion proc via the :subtype_oid option" do
     @R.register('foo4range', :subtype_oid=>16)
     @db.typecast_value(:foo4range, '[t,f]').must_equal @R.new(true, false, :db_type=>'foo4range')
   end
 
-  it "should raise an error if using :subtype_oid option with unexisting scalar conversion proc" do
+  deprecated "should raise an error if using :subtype_oid option with unexisting scalar conversion proc" do
     proc{@R.register('fooirange', :subtype_oid=>0)}.must_raise(Sequel::Error)
   end
 
-  it "should raise an error if using :converter option and a block argument" do
+  deprecated "should raise an error if using :converter option and a block argument" do
     proc{@R.register('fooirange', :converter=>proc{}){}}.must_raise(Sequel::Error)
   end
 
-  it "should raise an error if using :subtype_oid option and a block argument" do
+  deprecated "should raise an error if using :subtype_oid option and a block argument" do
     proc{@R.register('fooirange', :subtype_oid=>16){}}.must_raise(Sequel::Error)
   end
 
-  it "should support registering custom types with :oid option" do
+  deprecated "should support registering custom types with :oid option" do
     @R.register('foo5range', :oid=>331)
-    Sequel::Postgres::PG_TYPES[331].call('[1,3)').must_be_kind_of(@R)
+    Sequel::Postgres::PG__TYPES[331].call('[1,3)').must_be_kind_of(@R)
+  end
+
+  deprecated "should not support registering custom range types on a per-Database basis for frozen databases" do
+    @db.freeze
+    proc{@db.register_range_type('banana', :oid=>7865){|s| s}}.must_raise RuntimeError, TypeError
+  end
+
+  it "should support registering custom range types" do
+    @db.register_range_type('foorange')
+    @db.typecast_value(:foorange, 1..2).must_be_kind_of(@R)
+    @db.fetch = [{:name=>'id', :db_type=>'foorange'}]
+    @db.schema(:items).map{|e| e[1][:type]}.must_equal [:foorange]
+  end
+
+  it "should support using a block as a custom conversion proc given as block" do
+    @db.register_range_type('foo2range'){|s| (s*2).to_i}
+    @db.typecast_value(:foo2range, '[1,2]').must_be :==, (11..22)
+  end
+
+  it "should support using a block as a custom conversion proc given as :converter option" do
+    @db.register_range_type('foo3range', :converter=>proc{|s| (s*2).to_i})
+    @db.typecast_value(:foo3range, '[1,2]').must_be :==, (11..22)
+  end
+
+  it "should support using an existing scaler conversion proc via the :subtype_oid option" do
+    @db.register_range_type('foo4range', :subtype_oid=>16)
+    @db.typecast_value(:foo4range, '[t,f]').must_equal @R.new(true, false, :db_type=>'foo4range')
+  end
+
+  it "should raise an error if using :subtype_oid option with unexisting scalar conversion proc" do
+    proc{@db.register_range_type('fooirange', :subtype_oid=>0)}.must_raise(Sequel::Error)
+  end
+
+  it "should raise an error if using :converter option and a block argument" do
+    proc{@db.register_range_type('fooirange', :converter=>proc{}){}}.must_raise(Sequel::Error)
+  end
+
+  it "should raise an error if using :subtype_oid option and a block argument" do
+    proc{@db.register_range_type('fooirange', :subtype_oid=>16){}}.must_raise(Sequel::Error)
+  end
+
+  it "should support registering custom types with :oid option" do
+    @db.register_range_type('foo5range', :oid=>331)
+    @db.conversion_procs[331].call('[1,3)').must_be_kind_of(@R)
   end
 
   it "should not support registering custom range types on a per-Database basis for frozen databases" do
@@ -222,7 +306,7 @@ describe "pg_range extension" do
 
   describe "parser" do
     before do
-      @p = Sequel::Postgres::PG_TYPES[3904]
+      @p = @R::Parser.new('int4range', proc(&:to_i))
       @sp = @R::Parser.new(nil)
     end
 
@@ -265,14 +349,14 @@ describe "pg_range extension" do
     end
   end
 
-  it "should set appropriate timestamp range conversion procs when resetting conversion procs" do
+  deprecated "should set appropriate timestamp range conversion procs when resetting conversion procs" do
     @db.reset_conversion_procs
     procs = @db.conversion_procs
     procs[3908].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').must_be :==, (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
     procs[3910].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').must_be :==, (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
   end
 
-  it "should set appropriate timestamp range array conversion procs when resetting conversion procs" do
+  deprecated "should set appropriate timestamp range array conversion procs when resetting conversion procs" do
     @db.reset_conversion_procs
     procs = @db.conversion_procs
     procs[3909].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').must_be :==, [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]

data/spec/extensions/pg_row_spec.rb

@@ -9,8 +9,18 @@ describe "pg_row extension" do
     @db.sqls
   end
 
+  deprecated "should parse record objects as arrays" do
+    a = Sequel::Postgres::PG__TYPES[2249].call("(a,b,c)")
+    a.class.must_equal(@m::ArrayRow)
+    a.to_a.must_be_kind_of(Array)
+    a[0].must_equal 'a'
+    a.must_equal %w'a b c'
+    a.db_type.must_be_nil
+    @db.literal(a).must_equal "ROW('a', 'b', 'c')"
+  end
+
   it "should parse record objects as arrays" do
-    a = Sequel::Postgres::PG_TYPES[2249].call("(a,b,c)")
+    a = @db.conversion_procs[2249].call("(a,b,c)")
     a.class.must_equal(@m::ArrayRow)
     a.to_a.must_be_kind_of(Array)
     a[0].must_equal 'a'
@@ -20,7 +30,7 @@ describe "pg_row extension" do
   end
 
   it "should parse arrays of record objects as arrays of arrays" do
-    as = Sequel::Postgres::PG_TYPES[2287].call('{"(a,b,c)","(d,e,f)"}')
+    as = @db.conversion_procs[2287].call('{"(a,b,c)","(d,e,f)"}')
     as.must_equal [%w'a b c', %w'd e f']
     as.each do |a|
       a.class.must_equal(@m::ArrayRow)
@@ -135,7 +145,7 @@ describe "pg_row extension" do
     p.column_converters.must_equal [Array]
   end
 
-  it "should reload registered row types when reseting conversion procs" do
+  deprecated "should reload registered row types when reseting conversion procs" do
     db = Sequel.mock(:host=>'postgres')
     db.extend_datasets{def quote_identifiers?; false end}
     db.extension(:pg_row)
@@ -292,7 +302,7 @@ describe "pg_row extension" do
     @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').must_equal(:bar=>1, :baz=>'bb')
   end
 
-  it "should handle conversion procs that aren't added until later" do
+  deprecated "should handle conversion procs that aren't added until later" do
     @db.conversion_procs[5] = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
     c = proc{|h| [h]}

data/spec/extensions/pg_typecast_on_load_spec.rb

@@ -7,28 +7,30 @@ describe Sequel::Model, "PgTypecastOnLoad plugin" do
       [[:id, {}], [:b, {:type=>:boolean, :oid=>16}], [:y, {:type=>:integer, :oid=>20}]]
     end
     @c = Class.new(Sequel::Model(@db[:items]))
-    @c.plugin :pg_typecast_on_load, :b, :y
+    deprecated do
+      @c.plugin :pg_typecast_on_load, :b, :y
+    end
   end 
 
-  it "should call the database conversion proc for all given columns" do
+  deprecated "should call the database conversion proc for all given columns" do
     @c.first.values.must_equal(:id=>1, :b=>true, :y=>0)
   end
 
-  it "should call the database conversion proc with value when reloading the object, for all given columns" do
+  deprecated "should call the database conversion proc with value when reloading the object, for all given columns" do
     @c.first.refresh.values.must_equal(:id=>1, :b=>true, :y=>0)
   end
 
-  it "should not fail if schema oid does not have a related conversion proc" do
+  deprecated "should not fail if schema oid does not have a related conversion proc" do
     @c.db_schema[:b][:oid] = 0
     @c.first.refresh.values.must_equal(:id=>1, :b=>"t", :y=>0)
   end
 
-  it "should call the database conversion proc with value when automatically reloading the object on creation via insert_select" do
+  deprecated "should call the database conversion proc with value when automatically reloading the object on creation via insert_select" do
     @c.dataset = @c.dataset.with_extend{def insert_select(h) insert(h); first end}
     @c.create.values.must_equal(:id=>1, :b=>true, :y=>0)
   end
 
-  it "should allowing setting columns separately via add_pg_typecast_on_load_columns" do
+  deprecated "should allowing setting columns separately via add_pg_typecast_on_load_columns" do
     @c = Class.new(Sequel::Model(@db[:items]))
     @c.plugin :pg_typecast_on_load
     @c.first.values.must_equal(:id=>1, :b=>"t", :y=>"0")
@@ -38,7 +40,7 @@ describe Sequel::Model, "PgTypecastOnLoad plugin" do
     @c.first.values.must_equal(:id=>1, :b=>true, :y=>0)
   end
 
-  it "should work with subclasses" do
+  deprecated "should work with subclasses" do
     @c = Class.new(Sequel::Model(@db[:items]))
     @c.plugin :pg_typecast_on_load
     @c.first.values.must_equal(:id=>1, :b=>"t", :y=>"0")
@@ -57,11 +59,11 @@ describe Sequel::Model, "PgTypecastOnLoad plugin" do
     c1.first.values.must_equal(:id=>1, :b=>"t", :y=>0)
   end
 
-  it "should not mark the object as modified" do
+  deprecated "should not mark the object as modified" do
     @c.first.modified?.must_equal false
   end
 
-  it "should freeze pg_typecast_on_load_columns" do
+  deprecated "should freeze pg_typecast_on_load_columns" do
     @c.freeze
     @c.pg_typecast_on_load_columns.frozen?.must_equal true
   end

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -53,7 +53,7 @@ describe "prepared_statements_safe plugin" do
     c = Class.new(Sequel::Model)
     c.plugin :prepared_statements_safe
     c1 = Class.new(c)
-    c1.meta_def(:get_db_schema){@db_schema = {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}}}
+    def c1.get_db_schema; @db_schema = {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}} end
     c1.set_dataset(:people)
     c1.prepared_statements_column_defaults.must_equal(:name=>'foo')
     Class.new(c1).prepared_statements_column_defaults.must_equal(:name=>'foo')

data/spec/extensions/query_literals_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "query_literals extension" do
   before do
-    @ds = Sequel.mock.dataset.from(:t).extension(:query_literals)
+    deprecated do
+      @ds = Sequel.mock.dataset.from(:t).extension(:query_literals)
+    end
   end
 
   it "should not use special support if given a block" do