sequel 5.20.0 → 5.21.0

data/lib/sequel/extensions/server_block.rb

@@ -52,6 +52,12 @@
 #     DB[:a].server(:read_only).delete # Uses shard2
 #   end
 #
+# If you use an invalid server when calling with_server, it will be
+# treated the same way as if you called Dataset#server with an invalid
+# server.  By default, the default server will be used in such cases.
+# If you would like a different server to be used, or an exception to
+# be raised, then use the :servers_hash Database option.
+#
 # Related modules: Sequel::ServerBlock, Sequel::UnthreadedServerBlock,
 # Sequel::ThreadedServerBlock
 
@@ -110,9 +116,9 @@ module Sequel
       else
         case server
         when :default, nil
-          @default_servers[-1][0]
+          @servers[@default_servers[-1][0]]
         when :read_only
-          @default_servers[-1][1]
+          @servers[@default_servers[-1][1]]
         else
           super
         end
@@ -155,11 +161,16 @@ module Sequel
       if !a || a.empty?
         super
       else
+        # Hash handling required to work when loaded after arbitrary servers plugin.
         case server
         when :default, nil
-          a[-1][0]
+          v = a[-1][0]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
         when :read_only
-          a[-1][1]
+          v = a[-1][1]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
         else
           super
         end

data/lib/sequel/plugins/rcte_tree.rb

@@ -126,6 +126,9 @@ module Sequel
         a = opts.merge(opts.fetch(:ancestors, OPTS))
         ancestors = a.fetch(:name, :ancestors)
         a[:read_only] = true unless a.has_key?(:read_only)
+        a[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{ancestors} association for #{self} does not support eager graphing"
+        end
         a[:eager_loader_key] = key
         a[:dataset] ||= proc do
           base_ds = model.where(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
@@ -221,6 +224,9 @@ module Sequel
         d = opts.merge(opts.fetch(:descendants, OPTS))
         descendants = d.fetch(:name, :descendants)
         d[:read_only] = true unless d.has_key?(:read_only)
+        d[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{descendants} association for #{self} does not support eager graphing"
+        end
         la = d[:level_alias] ||= :x_level_x
         d[:dataset] ||= proc do
           base_ds = model.where(key_array.zip(prkey_array.map{|k| get_column_value(k)}))

data/lib/sequel/version.rb

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

data/spec/adapters/mssql_spec.rb

@@ -40,6 +40,30 @@ describe "A MSSQL database" do
   end
 end
 
+describe "MSSQL decimal locale handling" do
+  before do
+    @locale = WIN32OLE.locale
+    @decimal = BigDecimal('1234.56')
+  end
+  after do
+    WIN32OLE.locale = @locale
+  end
+
+  it "should work with current locale" do
+    DB.get(Sequel.cast(@decimal, 'decimal(16,4)').as(:v)).must_equal @decimal
+  end
+
+  it "should work with 1031 locale" do
+    WIN32OLE.locale = 1031
+    DB.get(Sequel.cast(@decimal, 'decimal(16,4)').as(:v)).must_equal @decimal
+  end
+
+  it "should work with 1033 locale" do
+    WIN32OLE.locale = 1033
+    DB.get(Sequel.cast(@decimal, 'decimal(16,4)').as(:v)).must_equal @decimal
+  end
+end if DB.adapter_scheme == :ado
+
 describe "MSSQL" do
   before(:all) do
     @db = DB

data/spec/adapters/mysql_spec.rb

@@ -551,11 +551,6 @@ describe "A MySQL database" do
     db = Sequel.connect(DB.opts.merge(:read_timeout=>22342))
     db.test_connection
   end
-
-  it "should accept a connect_timeout option when connecting" do
-    db = Sequel.connect(DB.opts.merge(:connect_timeout=>22342))
-    db.test_connection
-  end
 end
 
 describe "MySQL foreign key support" do

data/spec/adapters/postgres_spec.rb

@@ -2944,6 +2944,8 @@ describe 'PostgreSQL json type' do
     @h = {'a'=>'b', '1'=>[3, 4, 5]}
   end
   after do
+    @db.wrap_json_primitives = nil
+    @db.typecast_json_strings = nil
     @db.drop_table?(:items)
   end
 
@@ -2951,9 +2953,12 @@ describe 'PostgreSQL json type' do
   json_types << :jsonb if DB.server_version >= 90400
   json_types.each do |json_type|
     json_array_type = "#{json_type}[]"
-    pg_json = lambda{|v| Sequel.send(:"pg_#{json_type}", v)}
+    pg_json = Sequel.method(:"pg_#{json_type}")
+    pg_json_wrap = Sequel.method(:"pg_#{json_type}_wrap")
     hash_class = json_type == :jsonb ? Sequel::Postgres::JSONBHash : Sequel::Postgres::JSONHash
     array_class = json_type == :jsonb ? Sequel::Postgres::JSONBArray : Sequel::Postgres::JSONArray
+    str_class = json_type == :jsonb ? Sequel::Postgres::JSONBString : Sequel::Postgres::JSONString
+    object_class = json_type == :jsonb ? Sequel::Postgres::JSONBObject : Sequel::Postgres::JSONObject
 
     it 'insert and retrieve json values' do
       @db.create_table!(:items){column :j, json_type}
@@ -2983,6 +2988,44 @@ describe 'PostgreSQL json type' do
       @ds.all.must_equal rs
     end
 
+    it 'insert and retrieve json primitive values' do
+      @db.create_table!(:items){column :j, json_type}
+      ['str', 1, 2.5, nil, true, false].each do |rv|
+        @ds.delete
+        @ds.insert(pg_json_wrap.call(rv))
+        @ds.count.must_equal 1
+        rs = @ds.all
+        v = rs.first[:j]
+        v.class.must_equal(rv.class)
+        if rv.nil?
+          v.must_be_nil
+        else
+          v.must_equal rv
+        end
+      end
+
+      @db.wrap_json_primitives = true
+      ['str', 1, 2.5, nil, true, false].each do |rv|
+        @ds.delete
+        @ds.insert(pg_json_wrap.call(rv))
+        @ds.count.must_equal 1
+        rs = @ds.all
+        v = rs.first[:j]
+        v.class.ancestors.must_include(object_class)
+        v.__getobj__.must_be_kind_of(rv.class)
+        if rv.nil?
+          v.must_be_nil
+          v.__getobj__.must_be_nil
+        else
+          v.must_equal rv
+          v.__getobj__.must_equal rv
+        end
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all[0][:j].must_equal rs[0][:j]
+      end
+    end
+
     it 'insert and retrieve json[] values' do
       @db.create_table!(:items){column :j, json_array_type}
       j = Sequel.pg_array([pg_json.call('a'=>1), pg_json.call(['b', 2])])
@@ -2999,16 +3042,122 @@ describe 'PostgreSQL json type' do
       @ds.all.must_equal rs
     end
 
+    it 'insert and retrieve json[] values with json primitives' do
+      @db.create_table!(:items){column :j, json_array_type}
+      raw = ['str', 1, 2.5, nil, true, false]
+      j = Sequel.pg_array(raw.map(&pg_json_wrap), json_type)
+      @ds.insert(j)
+      @ds.count.must_equal 1
+      rs = @ds.all
+      v = rs.first[:j]
+      v.class.must_equal(Sequel::Postgres::PGArray)
+      v.to_a.must_be_kind_of(Array)
+      v.map(&:class).must_equal raw.map(&:class)
+      v.must_equal raw
+      v.to_a.must_equal raw
+
+      @db.wrap_json_primitives = true
+      j = Sequel.pg_array(raw.map(&pg_json_wrap), json_type)
+      @ds.insert(j)
+      rs = @ds.all
+      v = rs.first[:j]
+      v.class.must_equal(Sequel::Postgres::PGArray)
+      v.to_a.must_be_kind_of(Array)
+      v.map(&:class).each{|c| c.ancestors.must_include(object_class)}
+      [v, v.to_a].each do |v0|
+        v0.zip(raw) do |v1, r1|
+          if r1.nil?
+            v1.must_be_nil
+            v1.__getobj__.must_be_nil
+          else
+            v1.must_equal r1
+            v1.__getobj__.must_equal r1
+          end
+        end
+      end
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all[0][:j].zip(rs[0][:j]) do |v1, r1|
+        if v1.__getobj__.nil?
+          v1.must_be_nil
+          v1.__getobj__.must_be_nil
+        else
+          v1.must_equal r1
+          v1.must_equal r1.__getobj__
+          v1.__getobj__.must_equal r1
+          v1.__getobj__.must_equal r1.__getobj__
+        end
+      end
+    end
+
     it 'with models' do
       @db.create_table!(:items) do
         primary_key :id
         column :h, json_type
       end
       c = Class.new(Sequel::Model(@db[:items]))
+      c.create(:h=>@h).h.must_equal @h
+      c.create(:h=>@a).h.must_equal @a
       c.create(:h=>pg_json.call(@h)).h.must_equal @h
       c.create(:h=>pg_json.call(@a)).h.must_equal @a
     end
 
+    it 'with models with json primitives' do
+      @db.create_table!(:items) do
+        primary_key :id
+        column :h, json_type
+      end
+      c = Class.new(Sequel::Model(@db[:items]))
+
+      ['str', 1, 2.5, nil, true, false].each do |v|
+        @db.wrap_json_primitives = nil
+        cv = c[c.insert(:h=>pg_json_wrap.call(v))]
+        cv.h.class.ancestors.wont_include(object_class)
+        if v.nil?
+          cv.h.must_be_nil
+        else
+          cv.h.must_equal v
+        end
+
+        @db.wrap_json_primitives = true
+        cv.refresh
+        cv.h.class.ancestors.must_include(object_class)
+        cv.save
+        cv.refresh
+        cv.h.class
+
+        if v.nil?
+          cv.h.must_be_nil
+        else
+          cv.h.must_equal v
+        end
+
+        c.new(:h=>cv.h).h.class.ancestors.must_include(object_class)
+      end
+
+      v = c.new(:h=>'{}').h
+      v.class.must_equal hash_class
+      v.must_equal({})
+      @db.typecast_json_strings = true
+      v = c.new(:h=>'{}').h
+      v.class.must_equal str_class
+      v.must_equal '{}'
+
+      c.new(:h=>'str').h.class.ancestors.must_include(object_class)
+      c.new(:h=>'str').h.must_equal 'str'
+      c.new(:h=>1).h.class.ancestors.must_include(object_class)
+      c.new(:h=>1).h.must_equal 1
+      c.new(:h=>2.5).h.class.ancestors.must_include(object_class)
+      c.new(:h=>2.5).h.must_equal 2.5
+      c.new(:h=>true).h.class.ancestors.must_include(object_class)
+      c.new(:h=>true).h.must_equal true
+      c.new(:h=>false).h.class.ancestors.must_include(object_class)
+      c.new(:h=>false).h.must_equal false
+
+      c.new(:h=>nil).h.class.ancestors.wont_include(object_class)
+      c.new(:h=>nil).h.must_be_nil
+    end
+
     it 'with empty json default values and defaults_setter plugin' do
       @db.create_table!(:items) do
         column :h, json_type, :default=>hash_class.new({})
@@ -3043,6 +3192,36 @@ describe 'PostgreSQL json type' do
       @ds.get(:i).must_equal j
     end if uses_pg_or_jdbc
 
+    it 'use json primitives in bound variables' do
+      @db.create_table!(:items){column :i, json_type}
+      @db.wrap_json_primitives = true
+      raw = ['str', 1, 2.5, nil, true, false]
+      raw.each do |v|
+        @ds.delete
+        @ds.call(:insert, {:i=>@db.get(pg_json_wrap.call(v))}, {:i=>:$i})
+        rv = @ds.get(:i)
+        rv.class.ancestors.must_include(object_class)
+        if v.nil?
+          rv.must_be_nil
+        else
+          rv.must_equal v
+        end
+      end
+
+      @db.create_table!(:items){column :i, json_array_type}
+      j = Sequel.pg_array(raw.map(&pg_json_wrap), json_type)
+      @ds.call(:insert, {:i=>j}, {:i=>:$i})
+      @ds.all[0][:i].zip(raw) do |v1, r1|
+        if v1.__getobj__.nil?
+          v1.must_be_nil
+          v1.__getobj__.must_be_nil
+        else
+          v1.must_equal r1
+          v1.__getobj__.must_equal r1
+        end
+      end
+    end if uses_pg_or_jdbc
+
     it 'operations/functions with pg_json_ops' do
       Sequel.extension :pg_json_ops
       jo = pg_json.call('a'=>1, 'b'=>{'c'=>2, 'd'=>{'e'=>3}}).op

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,117 @@ 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
+  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 +378,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 +413,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