sequel 5.19.0 → 5.24.0

data/spec/extensions/migration_spec.rb

@@ -195,6 +195,19 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
       [:drop_table, :a, {:foo=>:bar}]]
   end
   
+  it "should reverse add_foreign_key with :type option" do
+    Sequel.migration{change{alter_table(:t){add_foreign_key :b, :c, :type=>:f}}}.apply(@db, :down)
+    actions = @db.actions
+    actions.must_equal [[:alter_table, [[:drop_foreign_key, :b, {:type=>:f}]]]]
+    @db.sqls
+    db = Sequel.mock
+    args = nil
+    db.define_singleton_method(:foreign_key_list){|*a| args = a; [{:name=>:fbc, :columns=>[:b]}]}
+    db.alter_table(:t){send(*actions[0][1][0])}
+    db.sqls.must_equal ["ALTER TABLE t DROP CONSTRAINT fbc", "ALTER TABLE t DROP COLUMN b"]
+    args.must_equal [:t]
+  end
+  
   it "should reverse add_foreign_key with :foreign_key_constraint_name option" do
     Sequel.migration{change{alter_table(:t){add_foreign_key :b, :c, :foreign_key_constraint_name=>:f}}}.apply(@db, :down)
     actions = @db.actions

data/spec/extensions/named_timezones_spec.rb

@@ -9,7 +9,7 @@ Sequel.extension :thread_local_timezones
 Sequel.extension :named_timezones
 Sequel.datetime_class = Time
 
-describe "Sequel named_timezones extension" do
+describe "Sequel named_timezones extension with DateTime class" do
   before do
     @tz_in = TZInfo::Timezone.get('America/Los_Angeles')
     @tz_out = TZInfo::Timezone.get('America/New_York')
@@ -54,10 +54,12 @@ describe "Sequel named_timezones extension" do
   
   it "should convert datetimes coming out of the database from database_timezone to application_timezone" do
     dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30-0400')
+    dt.must_be_instance_of DateTime
     dt.must_equal @dt
     dt.offset.must_equal(-7/24.0)
     
     dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30+0000')
+    dt.must_be_instance_of DateTime
     dt.must_equal @dt
     dt.offset.must_equal(-7/24.0)
   end
@@ -68,7 +70,9 @@ describe "Sequel named_timezones extension" do
 
   it "should support tzinfo_disambiguator= to handle ambiguous timezones automatically" do
     Sequel.tzinfo_disambiguator = proc{|datetime, periods| periods.first}
-    Sequel.database_to_application_timestamp('2004-10-31T01:30:00').must_equal DateTime.parse('2004-10-30T22:30:00-07:00')
+    dt = Sequel.database_to_application_timestamp('2004-10-31T01:30:00')
+    dt.must_equal DateTime.parse('2004-10-30T22:30:00-07:00')
+    dt.offset.must_equal(-7/24.0)
   end
 
   it "should assume datetimes coming out of the database that don't have an offset as coming from database_timezone" do
@@ -108,4 +112,107 @@ describe "Sequel named_timezones extension" do
     tz2.must_equal @tz_in
   end
 end
+
+describe "Sequel named_timezones extension with Time class" do
+  before do
+    @tz_in = TZInfo::Timezone.get('America/Los_Angeles')
+    @tz_out = TZInfo::Timezone.get('America/New_York')
+    @db = Sequel.mock
+    Sequel.application_timezone = 'America/Los_Angeles'
+    Sequel.database_timezone = 'America/New_York'
+  end
+  after do
+    Sequel.tzinfo_disambiguator = nil
+    Sequel.default_timezone = nil
+    Sequel.datetime_class = Time
+  end
+  
+  it "should convert string arguments to *_timezone= to TZInfo::Timezone instances" do
+    Sequel.application_timezone.must_equal @tz_in
+    Sequel.database_timezone.must_equal @tz_out
+  end
+    
+  it "should convert string arguments for Database#timezone= to TZInfo::Timezone instances for database-specific timezones" do
+    @db.extension :named_timezones
+    @db.timezone = 'America/Los_Angeles'
+    @db.timezone.must_equal @tz_in
+  end
+    
+  it "should accept TZInfo::Timezone instances in *_timezone=" do
+    Sequel.application_timezone = @tz_in
+    Sequel.database_timezone = @tz_out
+    Sequel.application_timezone.must_equal @tz_in
+    Sequel.database_timezone.must_equal @tz_out
+  end
+    
+  it "should convert datetimes going into the database to named database_timezone" do
+    ds = @db[:a].with_extend do
+      def supports_timestamp_timezones?; true; end
+      def supports_timestamp_usecs?; false; end
+    end
+    ds.insert([Time.new(2009,6,1,3,20,30, RUBY_VERSION >= '2.6' ? @tz_in : -25200), Time.new(2009,6,1,3,20,30,-25200), Time.new(2009,6,1,6,20,30,-14400)])
+    @db.sqls.must_equal ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
+  end
+  
+  it "should convert datetimes coming out of the database from database_timezone to application_timezone" do
+    dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30-0400')
+    dt.must_be_instance_of Time
+    dt.must_equal Time.new(2009,6,1,3,20,30,-25200)
+    dt.utc_offset.must_equal -25200
+    
+    dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30+0000')
+    dt.must_be_instance_of Time
+    dt.must_equal Time.new(2009,6,1,3,20,30,-25200)
+    dt.utc_offset.must_equal -25200
+  end
+    
+  it "should raise an error for ambiguous timezones by default" do
+    proc{Sequel.database_to_application_timestamp('2004-10-31T01:30:00')}.must_raise(Sequel::InvalidValue)
+  end
+
+  it "should support tzinfo_disambiguator= to handle ambiguous timezones automatically" do
+    Sequel.tzinfo_disambiguator = proc{|datetime, periods| periods.first}
+    Sequel.database_to_application_timestamp('2004-10-31T01:30:00').must_equal Time.new(2004, 10, 30, 22, 30, 0, -25200)
+    dt = Sequel.database_to_application_timestamp('2004-10-31T01:30:00')
+    dt.must_equal Time.new(2004, 10, 30, 22, 30, 0, -25200)
+    dt.utc_offset.must_equal -25200
+  end
+
+  it "should assume datetimes coming out of the database that don't have an offset as coming from database_timezone" do
+    dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30')
+    dt.must_be_instance_of Time
+    dt.must_equal Time.new(2009,6,1,3,20,30, -25200)
+    dt.utc_offset.must_equal -25200
+    
+    dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30')
+    dt.must_be_instance_of Time
+    dt.must_equal Time.new(2009,6,1,7,20,30, -25200)
+    dt.utc_offset.must_equal -25200
+  end
+  
+  it "should work with the thread_local_timezones extension" do
+    q, q1, q2 = Queue.new, Queue.new, Queue.new
+    tz1, tz2 = nil, nil
+    t1 = Thread.new do
+      Sequel.thread_application_timezone = 'America/New_York'
+      q2.push nil
+      q.pop
+      tz1 = Sequel.application_timezone
+    end
+    t2 = Thread.new do
+      Sequel.thread_application_timezone = 'America/Los_Angeles'
+      q2.push nil
+      q1.pop
+      tz2 = Sequel.application_timezone
+    end
+    q2.pop
+    q2.pop
+    q.push nil
+    q1.push nil
+    t1.join
+    t2.join
+    tz1.must_equal @tz_out
+    tz2.must_equal @tz_in
+  end
+end
 end

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -161,4 +161,49 @@ describe "pg_auto_constraint_validations plugin" do
     proc{o.save}.must_raise Sequel::ValidationFailed
     o.errors.must_equal(:i=>['is invalid'], :id=>['is invalid'])
   end
+
+  it "should handle overridden constraint failures as validation errors when updating" do
+    o = @c.load(:i=>3)
+    @c.pg_auto_constraint_validation_override(:items_i_ocheck, :i, "foo bar")
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_ocheck']
+    proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['foo bar'])
+  end
+
+  it "should handle dumping cached metadata and loading metadata from cache" do
+    cache_file = "spec/files/pgacv-spec-#{$$}.cache"
+    begin
+      @ds = @db[:items]
+      @ds.send(:columns=, [:id, :i])
+      @db.fetch = @metadata_results.dup
+      c = Sequel::Model(@ds)
+      def c.name; 'Foo' end
+      @db.sqls
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      @db.sqls.length.must_equal 5
+
+      o = c.new(:i=>12)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+      proc{o.save}.must_raise Sequel::ValidationFailed
+
+      c.dump_pg_auto_constraint_validations_cache
+
+      @db.fetch = []
+      c = Sequel::Model(@ds)
+      def c.name; 'Foo' end
+      @db.sqls
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      @db.sqls.must_be_empty
+
+      o = c.new(:i=>12)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+      proc{o.save}.must_raise Sequel::ValidationFailed
+    ensure
+      File.delete(cache_file) if File.file?(cache_file)
+    end
+  end
+
+  it "should raise error if attempting to dump cached metadata when not using caching" do
+    proc{@c.dump_pg_auto_constraint_validations_cache}.must_raise Sequel::Error
+  end
 end

data/spec/extensions/pg_json_spec.rb

@@ -3,6 +3,8 @@ require_relative "spec_helper"
 Sequel.extension :pg_array, :pg_json
 
 describe "pg_json extension" do
+  integer_class = RUBY_VERSION >= '2.4' ? Integer : Fixnum
+
   before(:all) do
     m = Sequel::Postgres
     @m = m::JSONDatabaseMethods
@@ -29,7 +31,7 @@ describe "pg_json extension" do
     cp[3807].call("{[]}").must_equal [@bac.new([])]
   end
 
-  it "should parse json strings correctly" do
+  deprecated "should parse json strings correctly" do
     @m.parse_json('[]').class.must_equal(@ac)
     @m.parse_json('[]').to_a.must_equal []
     @m.parse_json('[1]').to_a.must_equal [1]
@@ -40,46 +42,82 @@ describe "pg_json extension" do
     @m.parse_json('{"a": "b"}').to_hash.must_equal('a'=>'b')
     @m.parse_json('{"a": "b", "c": [1, 2, 3]}').to_hash.must_equal('a'=>'b', 'c'=>[1, 2, 3])
     @m.parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.must_equal('a'=>'b', 'c'=>{'d'=>'e'})
+    proc{@m.parse_json("a")}.must_raise Sequel::InvalidValue
+
+    begin
+      Sequel.instance_eval do
+        alias pj parse_json
+        def parse_json(v)
+          {'1'=>1, "'a'"=>'a', 'true'=>true, 'false'=>false, 'null'=>nil, 'o'=>Object.new, '[one]'=>[1]}.fetch(v){pj(v)}
+        end
+      end
+      proc{@m.parse_json('o')}.must_raise(Sequel::InvalidValue)
+    ensure
+      Sequel.instance_eval do
+        alias parse_json pj
+      end
+    end
   end
 
-  it "should parse json and non-json plain strings, integers, and floats correctly in db_parse_json" do
+  deprecated "should parse json and non-json plain strings, integers, and floats correctly in db_parse_json" do
     @m.db_parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.must_equal('a'=>'b', 'c'=>{'d'=>'e'})
     @m.db_parse_json('[1, [2], {"a": "b"}]').to_a.must_equal [1, [2], {'a'=>'b'}]
     @m.db_parse_json('1').must_equal 1
     @m.db_parse_json('"b"').must_equal 'b'
     @m.db_parse_json('1.1').must_equal 1.1
+    proc{@m.db_parse_json("a")}.must_raise Sequel::InvalidValue
   end
 
-  it "should parse json and non-json plain strings, integers, and floats correctly in db_parse_jsonb" do
+  deprecated "should parse jsonb and non-jsonb plain strings, integers, and floats correctly in db_parse_jsonb" do
     @m.db_parse_jsonb('{"a": "b", "c": {"d": "e"}}').to_hash.must_equal('a'=>'b', 'c'=>{'d'=>'e'})
     @m.db_parse_jsonb('[1, [2], {"a": "b"}]').to_a.must_equal [1, [2], {'a'=>'b'}]
     @m.db_parse_jsonb('1').must_equal 1
     @m.db_parse_jsonb('"b"').must_equal 'b'
     @m.db_parse_jsonb('1.1').must_equal 1.1
+    proc{@m.db_parse_jsonb("a")}.must_raise Sequel::InvalidValue
   end
 
-  it "should raise an error when attempting to parse invalid json" do
-    proc{@m.parse_json('')}.must_raise(Sequel::InvalidValue)
-    proc{@m.parse_json('a')}.must_raise(Sequel::InvalidValue)
+  it "should parse json and non-json plain strings, integers, and floats correctly in conversion_proc" do
+    cp = @db.conversion_procs[114]
+    cp.call('{"a": "b", "c": {"d": "e"}}').to_hash.must_equal('a'=>'b', 'c'=>{'d'=>'e'})
+    cp.call('[1, [2], {"a": "b"}]').to_a.must_equal [1, [2], {'a'=>'b'}]
+    cp.call('1').must_equal 1
+    cp.call('"b"').must_equal 'b'
+    cp.call('1.1').must_equal 1.1
+  end
 
-    begin
-      Sequel.instance_eval do
-        alias pj parse_json
-        def parse_json(v)
-          {'1'=>1, "'a'"=>'a', 'true'=>true, 'false'=>false, 'null'=>nil, 'o'=>Object.new, '[one]'=>[1]}.fetch(v){pj(v)}
+  it "should parse jsonb and non-jsonb plain strings, integers, and floats correctly in conversion_proc" do
+    cp = @db.conversion_procs[3802]
+    cp.call('{"a": "b", "c": {"d": "e"}}').to_hash.must_equal('a'=>'b', 'c'=>{'d'=>'e'})
+    cp.call('[1, [2], {"a": "b"}]').to_a.must_equal [1, [2], {'a'=>'b'}]
+    cp.call('1').must_equal 1
+    cp.call('"b"').must_equal 'b'
+    cp.call('1.1').must_equal 1.1
+  end
+
+  it "should raise an error when attempting to parse invalid json" do
+    [114, 3802].each do |oid|
+      cp = @db.conversion_procs[oid]
+      proc{cp.call('a')}.must_raise(Sequel::InvalidValue)
+
+      begin
+        Sequel.instance_eval do
+          alias pj parse_json
+          def parse_json(v)
+            {'1'=>1, "'a'"=>'a', 'true'=>true, 'false'=>false, 'null'=>nil, 'o'=>Object.new, '[one]'=>[1]}.fetch(v){pj(v)}
+          end
+        end
+        cp.call('1').must_equal 1
+        cp.call("'a'").must_equal 'a'
+        cp.call('true').must_equal true
+        cp.call('false').must_equal false
+        cp.call('null').must_be_nil
+        proc{cp.call('o')}.must_raise(Sequel::InvalidValue)
+        cp.call('one').must_equal 1
+      ensure
+        Sequel.instance_eval do
+          alias parse_json pj
         end
-      end
-      @m.parse_json('1').must_equal 1
-      @m.parse_json("'a'").must_equal 'a'
-      @m.parse_json('true').must_equal true
-      @m.parse_json('false').must_equal false
-      @m.parse_json('null').must_be_nil
-      proc{@m.parse_json('o')}.must_raise(Sequel::InvalidValue)
-      @m.db_parse_json('one').must_equal 1
-      @m.db_parse_jsonb('one').must_equal 1
-    ensure
-      Sequel.instance_eval do
-        alias parse_json pj
       end
     end
   end
@@ -173,6 +211,129 @@ describe "pg_json extension" do
     @db.bound_variable_arg(Sequel.pg_array([Sequel.pg_jsonb([{"a"=>1}]), Sequel.pg_jsonb("b"=>[1, 2])]), nil).must_equal '{"[{\\"a\\":1}]","{\\"b\\":[1,2]}"}'
   end
 
+  it "should support using wrapped JSON and JSONB primitives as bound variables" do
+    @db.bound_variable_arg(Sequel.pg_json_wrap(1), nil).must_equal '1'
+    @db.bound_variable_arg(Sequel.pg_json_wrap(2.5), nil).must_equal '2.5'
+    @db.bound_variable_arg(Sequel.pg_json_wrap('a'), nil).must_equal '"a"'
+    @db.bound_variable_arg(Sequel.pg_json_wrap(true), nil).must_equal 'true'
+    @db.bound_variable_arg(Sequel.pg_json_wrap(false), nil).must_equal 'false'
+    @db.bound_variable_arg(Sequel.pg_json_wrap(nil), nil).must_equal 'null'
+  end
+
+  it "should support using json[] and jsonb[] types in bound variables with ruby primitives" do
+    @db.bound_variable_arg(Sequel.pg_array([1, 2.5, 'a', true, false, nil].map{|v| Sequel.pg_json_wrap(v)}), nil).must_equal '{"1","2.5","\"a\"","true","false","null"}'
+  end
+
+  it "Sequel.pg_json_wrap should wrap Ruby primitives in JSON wrappers" do
+    Sequel.pg_json_wrap({}).class.must_equal Sequel::Postgres::JSONHash
+    Sequel.pg_json_wrap({}).must_equal({})
+    Sequel.pg_json_wrap([]).class.must_equal Sequel::Postgres::JSONArray
+    Sequel.pg_json_wrap([]).must_equal []
+    Sequel.pg_json_wrap('a').class.must_equal Sequel::Postgres::JSONString
+    Sequel.pg_json_wrap('a').must_equal 'a'
+    Sequel.pg_json_wrap(1).class.must_equal Sequel::Postgres::JSONInteger
+    Sequel.pg_json_wrap(1).must_equal 1
+    Sequel.pg_json_wrap(2.5).class.must_equal Sequel::Postgres::JSONFloat
+    Sequel.pg_json_wrap(2.5).must_equal 2.5
+    Sequel.pg_json_wrap(true).class.must_equal Sequel::Postgres::JSONTrue
+    Sequel.pg_json_wrap(true).must_equal true
+    Sequel.pg_json_wrap(false).class.must_equal Sequel::Postgres::JSONFalse
+    Sequel.pg_json_wrap(false).must_equal false
+    Sequel.pg_json_wrap(nil).class.must_equal Sequel::Postgres::JSONNull
+    Sequel.pg_json_wrap(nil).must_be_nil
+
+    c = Class.new(Hash).new
+    Sequel.pg_json_wrap(c).class.must_equal Sequel::Postgres::JSONHash
+    Sequel.pg_json_wrap(c).must_equal(c)
+
+    c = Class.new(Array).new
+    Sequel.pg_json_wrap(c).class.must_equal Sequel::Postgres::JSONArray
+    Sequel.pg_json_wrap(c).must_equal c
+
+    c = Class.new(String).new('a')
+    Sequel.pg_json_wrap(c).class.must_equal Sequel::Postgres::JSONString
+    Sequel.pg_json_wrap(c).must_equal c
+  end
+
+  it "Sequel.pg_json_wrap should fail when passed an unsupported object" do
+    proc{Sequel.pg_json_wrap(Object.new)}.must_raise Sequel::Error
+  end
+
+  it "Sequel.pg_jsonb_wrap should wrap Ruby primitives in JSONB wrappers" do
+    Sequel.pg_jsonb_wrap({}).class.must_equal Sequel::Postgres::JSONBHash
+    Sequel.pg_jsonb_wrap({}).must_equal({})
+    Sequel.pg_jsonb_wrap([]).class.must_equal Sequel::Postgres::JSONBArray
+    Sequel.pg_jsonb_wrap([]).must_equal []
+    Sequel.pg_jsonb_wrap('a').class.must_equal Sequel::Postgres::JSONBString
+    Sequel.pg_jsonb_wrap('a').must_equal 'a'
+    Sequel.pg_jsonb_wrap(1).class.must_equal Sequel::Postgres::JSONBInteger
+    Sequel.pg_jsonb_wrap(1).must_equal 1
+    Sequel.pg_jsonb_wrap(2.5).class.must_equal Sequel::Postgres::JSONBFloat
+    Sequel.pg_jsonb_wrap(2.5).must_equal 2.5
+    Sequel.pg_jsonb_wrap(true).class.must_equal Sequel::Postgres::JSONBTrue
+    Sequel.pg_jsonb_wrap(true).must_equal true
+    Sequel.pg_jsonb_wrap(false).class.must_equal Sequel::Postgres::JSONBFalse
+    Sequel.pg_jsonb_wrap(false).must_equal false
+    Sequel.pg_jsonb_wrap(nil).class.must_equal Sequel::Postgres::JSONBNull
+    Sequel.pg_jsonb_wrap(nil).must_be_nil
+  end
+
+  it "Sequel.pg_jsonb_wrap should fail when passed an unsupported object" do
+    proc{Sequel.pg_jsonb_wrap(Object.new)}.must_raise Sequel::Error
+  end
+
+  it "should not wrap JSON primitives in json and jsonb conversion_proc when not setting wrap_json_primitives" do
+    [114, 3802].each do |oid|
+      cp = @db.conversion_procs[oid]
+      cp.call('1').class.must_equal(integer_class)
+      cp.call('1').must_equal 1
+      cp.call('2.5').class.must_equal Float
+      cp.call('2.5').must_equal 2.5
+      cp.call('"a"').class.must_equal String
+      cp.call('"a"').must_equal 'a'
+      cp.call('true').class.must_equal TrueClass
+      cp.call('true').must_equal true
+      cp.call('false').class.must_equal FalseClass
+      cp.call('false').must_equal false
+      cp.call('null').class.must_equal NilClass
+      cp.call('null').must_be_nil
+    end
+  end
+
+  it "should wrap JSON primitives in json conversion_proc when setting wrap_json_primitives" do
+    cp = @db.conversion_procs[114]
+    @db.wrap_json_primitives = true
+    cp.call('1').class.must_equal Sequel::Postgres::JSONInteger
+    cp.call('1').must_equal 1
+    cp.call('2.5').class.must_equal Sequel::Postgres::JSONFloat
+    cp.call('2.5').must_equal 2.5
+    cp.call('"a"').class.must_equal Sequel::Postgres::JSONString
+    cp.call('"a"').must_equal "a"
+    cp.call('true').class.must_equal Sequel::Postgres::JSONTrue
+    cp.call('true').must_equal true
+    cp.call('false').class.must_equal Sequel::Postgres::JSONFalse
+    cp.call('false').must_equal false
+    cp.call('null').class.must_equal Sequel::Postgres::JSONNull
+    cp.call('null').must_be_nil
+  end
+
+  it "should wrap JSON primitives in jsonb conversion_proc when setting wrap_json_primitives" do
+    cp = @db.conversion_procs[3802]
+    @db.wrap_json_primitives = true
+    cp.call('1').class.must_equal Sequel::Postgres::JSONBInteger
+    cp.call('1').must_equal 1
+    cp.call('2.5').class.must_equal Sequel::Postgres::JSONBFloat
+    cp.call('2.5').must_equal 2.5
+    cp.call('"a"').class.must_equal Sequel::Postgres::JSONBString
+    cp.call('"a"').must_equal "a"
+    cp.call('true').class.must_equal Sequel::Postgres::JSONBTrue
+    cp.call('true').must_equal true
+    cp.call('false').class.must_equal Sequel::Postgres::JSONBFalse
+    cp.call('false').must_equal false
+    cp.call('null').class.must_equal Sequel::Postgres::JSONBNull
+    cp.call('null').must_be_nil
+  end
+
   it "should parse json type from the schema correctly" do
     @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'json'}]
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :json]
@@ -229,8 +390,22 @@ describe "pg_json extension" do
     @db.typecast_value(:json, '[]').class.must_equal(@ac)
     @db.typecast_value(:json, '{"a": "b"}').must_equal Sequel.pg_json("a"=>"b")
     @db.typecast_value(:json, '{"a": "b"}').class.must_equal(@hc)
-    proc{@db.typecast_value(:json, '')}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:json, 1)}.must_raise(Sequel::InvalidValue)
+    @db.typecast_value(:json, 1).class.must_equal Sequel::Postgres::JSONInteger
+    @db.typecast_value(:json, 1).must_equal 1
+    @db.typecast_value(:json, 2.5).class.must_equal Sequel::Postgres::JSONFloat
+    @db.typecast_value(:json, 2.5).must_equal 2.5
+    @db.typecast_value(:json, true).class.must_equal Sequel::Postgres::JSONTrue
+    @db.typecast_value(:json, true).must_equal true
+    @db.typecast_value(:json, false).class.must_equal Sequel::Postgres::JSONFalse
+    @db.typecast_value(:json, false).must_equal false
+    @db.typecast_value(:json, nil).class.must_equal NilClass
+    @db.typecast_value(:json, nil).must_be_nil
+    proc{@db.typecast_value(:json, 'a')}.must_raise(Sequel::InvalidValue)
+    proc{@db.typecast_value(:json, Object.new)}.must_raise(Sequel::InvalidValue)
+
+    @db.typecast_json_strings = true
+    @db.typecast_value(:json, '[]').class.must_equal(Sequel::Postgres::JSONString)
+    @db.typecast_value(:json, '[]').must_equal '[]'
   end
 
   it "should support typecasting for the jsonb type" do
@@ -250,13 +425,27 @@ describe "pg_json extension" do
     @db.typecast_value(:jsonb, '[]').class.must_equal(@bac)
     @db.typecast_value(:jsonb, '{"a": "b"}').must_equal Sequel.pg_jsonb("a"=>"b")
     @db.typecast_value(:jsonb, '{"a": "b"}').class.must_equal(@bhc)
-    proc{@db.typecast_value(:jsonb, '')}.must_raise(Sequel::InvalidValue)
-    proc{@db.typecast_value(:jsonb, 1)}.must_raise(Sequel::InvalidValue)
+    @db.typecast_value(:jsonb, 1).class.must_equal Sequel::Postgres::JSONBInteger
+    @db.typecast_value(:jsonb, 1).must_equal 1
+    @db.typecast_value(:jsonb, 2.5).class.must_equal Sequel::Postgres::JSONBFloat
+    @db.typecast_value(:jsonb, 2.5).must_equal 2.5
+    @db.typecast_value(:jsonb, true).class.must_equal Sequel::Postgres::JSONBTrue
+    @db.typecast_value(:jsonb, true).must_equal true
+    @db.typecast_value(:jsonb, false).class.must_equal Sequel::Postgres::JSONBFalse
+    @db.typecast_value(:jsonb, false).must_equal false
+    @db.typecast_value(:jsonb, nil).class.must_equal NilClass
+    @db.typecast_value(:jsonb, nil).must_be_nil
+    proc{@db.typecast_value(:jsonb, 'a')}.must_raise(Sequel::InvalidValue)
+    proc{@db.typecast_value(:jsonb, Object.new)}.must_raise(Sequel::InvalidValue)
+
+    @db.typecast_json_strings = true
+    @db.typecast_value(:jsonb, '[]').class.must_equal(Sequel::Postgres::JSONBString)
+    @db.typecast_value(:jsonb, '[]').must_equal '[]'
   end
 
   it "should return correct results for Database#schema_type_class" do
-    @db.schema_type_class(:json).must_equal [Sequel::Postgres::JSONHash, Sequel::Postgres::JSONArray]
-    @db.schema_type_class(:jsonb).must_equal [Sequel::Postgres::JSONBHash, Sequel::Postgres::JSONBArray]
+    @db.schema_type_class(:json).must_equal [Sequel::Postgres::JSONObject]
+    @db.schema_type_class(:jsonb).must_equal [Sequel::Postgres::JSONBObject]
     @db.schema_type_class(:integer).must_equal Integer
   end
 end