sequel 5.20.0 → 5.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e092b5439a78eec1bb50a0bbc8a62c1d84ee5b27b9c5f034c250b632d03e17af
-  data.tar.gz: 231708d52405407b11113c55d5fdcd95e7d6155b0a8283f736876569ced6e4b1
+  metadata.gz: 33b35675e5f68471b8216acbbe10085992616ae93b6f47191c44bb3860b38285
+  data.tar.gz: e1be4ce80c4810a9022505f7e5d0becaa11912f6e91344b860195e6b11438d27
 SHA512:
-  metadata.gz: 4c2d7e19056e53f2d780f57f5da3c4675531f9678c6a54e922e0d59895bd2e485f12ee0b2644ed801c832a53653f75531d849cb7d60dcd9fb6a4edbfa8cb4c0b
-  data.tar.gz: 701b041185cc57c1966ea3b4be040e26a9e0aabfd6df45f0192f5b0b51133bfb94629f0634fa6edfc513a1c9193d455cb6222b388683d638e474b344e663ca50
+  metadata.gz: fedb31816a3c56136b007317f135072c318e71938c3375feff8c0ab2ec7ddc5744457008266434dff285095b09bfdf78ab33a24b0b4ac255119f9e80ae6758f1
+  data.tar.gz: eea67a798eedf2cb8b10bbf20eaf3b0deb7e9eabd1c9b8f238754ffbbd4afea394caa8b4574db7bda6373db987a8a088f83732ea353591eeca37ee4583d57730

data/CHANGELOG

@@ -1,3 +1,27 @@
+=== 5.21.0 (2019-06-01)
+
+* Recognize additional DatabaseLockTimeout errors in mysql and mysql2 adapters (jeremyevans)
+
+* Disallow eager_graph of ancestors and descendants associations when using the rcte_tree plugin (jeremyevans)
+
+* Make jdbc/mysql adapter work when using JRuby with Java 11 (jeremyevans)
+
+* Support window function options :window, :exclude, and :frame :type=>:groups, :start, and :end on SQLite 3.28.0+ (jeremyevans)
+
+* Make the server_block extension respect the :servers_hash Database option (jeremyevans)
+
+* Typecast string input for json/jsonb types as JSON strings instead of parsing as JSON in the pg_json extension when Database#typecast_json_strings is set to true (jeremyevans)
+
+* Wrap JSON primitives (string, number, true, false, nil) in the pg_json extension when Database#wrap_json_primitives is set to true (jeremyevans)
+
+* Convert the Database :timeout option to an integer in the sqlite adapter (jeremyevans) (#1620)
+
+* Improve performance in ado adapter using more efficient inner loop (jeremyevans)
+
+* Improve performance in ado adapter using faster callables for type conversion (jeremyevans)
+
+* Fix handling of decimal values in the ado adapter when using locales where the decimal separator is , and not . (jeremyevans) (#1619)
+
 === 5.20.0 (2019-05-01)
 
 * Fix reversing of alter_table add_foreign_key when :type option is used (jeremyevans) (#1615)

data/doc/opening_databases.rdoc

@@ -264,7 +264,8 @@ The following additional options are supported:
              or an array of symbols or strings (e.g. <tt>:sql_mode=>[:no_zero_date, :pipes_as_concat]</tt>).
 :timeout :: Sets the wait_timeout for the connection, defaults to 1 month.
 :read_timeout :: Set the timeout in seconds for reading back results to a query.
-:connect_timeout :: Set the timeout in seconds before a connection attempt is abandoned.
+:connect_timeout :: Set the timeout in seconds before a connection attempt is abandoned
+                    (may not be supported when using MariaDB 10.2+ client libraries).
 
 The :sslkey, :sslcert, :sslca, :sslcapath, and :sslca options (in that order) are passed to Mysql#ssl_set method
 if either the :sslca or :sslkey option is given.

data/doc/release_notes/5.21.0.txt

@@ -0,0 +1,87 @@
+= New Features
+
+* The pg_json extension now adds a Database#wrap_json_primitives
+  accessor.  When set to true, JSON primitive values (string, number,
+  true, false, and null) will be wrapped by delegate Ruby objects
+  instead of using Ruby primitives.  This allows the values to round
+  trip, so the following code will work even for primitive values in
+  json_column:
+
+    DB.extension :pg_json
+    DB.wrap_json_primitives = true
+    value = DB[:table].get(:json_column)
+    DB[:other_table].insert(json_column: value)
+
+  This should be enabled with care, especially in cases where false
+  and null JSON values are used, as the behavior will change if
+  the objects are used in a boolean context in Ruby, as only false
+  and nil in Ruby are treated as false:
+
+    # assume JSON false or null value
+    value = DB[:table].get(:json_column)
+
+    if value
+      # executed if wrap_json_primitives is true
+    else
+      # executed by default
+    end
+
+  When typecasting input in model objects to a JSON type, string
+  input will still be parsed as JSON.  However, you can set the
+  Database#typecast_json_strings accessor to true, and then string
+  input will be considered as a JSON string instead of parsing the
+  string as JSON.
+
+  To prevent backwards compatibility issues, Sequel.pg_json/pg_jsonb
+  behavior has not changed.  To support wrapping Ruby primitives in
+  the delegate objects, new Sequel.pg_json_wrap/pg_jsonb_wrap methods
+  have been added.  These methods only handle the Ruby primitives,
+  they cannot be used if the existing object is already a delegate
+  object.
+
+  As model objects always consider a nil value as SQL NULL and do
+  not typecast it, if you want to explicitly set a JSON null value,
+  you need to wrap it explicitly:
+
+    model_object.json_column = Sequel.pg_json_wrap(nil)
+
+= Other Improvements
+
+* Sequel now supports window function options :window, :exclude, and
+  :frame :type=>:groups, :start, and :end on SQLite 3.28.0+.
+
+* The server_block extension now respects the :servers_hash Database
+  option.  This makes it more similar to Sequel's default behavior.
+  However, that means by default, the server_block extension will
+  default to handling unknown shards as the default shard, instead
+  of raising an error for them.
+
+* The rcte_tree plugin now disallows eager graphing of the ancestors
+  and descendants associations.  Previously, eager graphing of these
+  associations generated incorrect results.  It is not possible to
+  eager graph these extensions, but normal eager loading does work.
+
+* The ado adapter's performance has been improved by using faster
+  callables for type conversion and a more efficient inner loop.
+
+* The sqlite adapter now converts a :timeout option given as a string
+  to an integer.  This allows you to use the option inside of a
+  connection string.
+
+* The mysql and mysql2 adapters now recognize an additional
+  DatabaseLockTimeout error.
+
+* The jdbc/mysql adapter now works correctly when using JRuby with
+  Java 11.
+
+* The ado adapter now handles numeric values when using locales that
+  use comma instead of period as the decimal separator.
+
+= Backwards Compatibility
+
+* In the pg_json extension, the following singleton methods of
+  Sequel::Postgres::JSONDatabaseMethods are now deprecated:
+
+  * parse_json
+  * db_parse_json
+  * db_parse_jsonb 

data/doc/sharding.rdoc

@@ -140,6 +140,8 @@ the shard to use.  This is fairly easy using a Sequel::Model:
   
   Rainbow.plaintext_for_hash("e580726d31f6e1ad216ffd87279e536d1f74e606")
 
+=== :servers_hash Option
+
 The connection pool can be further controlled to change how it handles attempts
 to access shards that haven't been configured.  The default is
 to assume the :default shard.  However, you can specify a

data/lib/sequel/adapters/ado.rb

@@ -47,34 +47,40 @@ module Sequel
     #AdVarWChar         = 202
     #AdWChar            = 130
 
-    cp = Object.new
-
-    def cp.bigint(v)
+    bigint = Object.new
+    def bigint.call(v)
       v.to_i
     end
 
-    def cp.numeric(v)
-      BigDecimal(v)
+    numeric = Object.new
+    def numeric.call(v)
+      if v.include?(',')
+        BigDecimal(v.tr(',', '.'))
+      else
+        BigDecimal(v)
+      end
     end
 
-    def cp.binary(v)
+    binary = Object.new
+    def binary.call(v)
       Sequel.blob(v.pack('c*'))
     end
 
-    def cp.date(v)
+    date = Object.new
+    def date.call(v)
       Date.new(v.year, v.month, v.day)
     end
 
     CONVERSION_PROCS = {}
     [
-      [:bigint, AdBigInt],
-      [:numeric, AdNumeric, AdVarNumeric],
-      [:date, AdDBDate],
-      [:binary, AdBinary, AdVarBinary, AdLongVarBinary]
-    ].each do |meth, *types|
-      method = cp.method(meth)
+      [bigint, AdBigInt],
+      [numeric, AdNumeric, AdVarNumeric],
+      [date, AdDBDate],
+      [binary, AdBinary, AdVarBinary, AdLongVarBinary]
+    ].each do |callable, *types|
+      callable.freeze
       types.each do |i|
-        CONVERSION_PROCS[i] = method
+        CONVERSION_PROCS[i] = callable
       end
     end
     CONVERSION_PROCS.freeze
@@ -227,7 +233,6 @@ module Sequel
           cols = []
           conversion_procs = db.conversion_procs
 
-          i = -1
           ts_cp = nil
           recordset.Fields.each do |field|
             type = field.Type
@@ -244,18 +249,21 @@ module Sequel
             else
               conversion_procs[type]
             end
-            cols << [output_identifier(field.Name), cp, i+=1]
+            cols << [output_identifier(field.Name), cp]
           end
 
           self.columns = cols.map(&:first)
           return if recordset.EOF
+          max = cols.length
 
           recordset.GetRows.transpose.each do |field_values|
             h = {}
 
-            cols.each do |name, cp, index|
-              h[name] = if (v = field_values[index]) && cp
-                cp[v]
+            i = -1
+            while (i += 1) < max
+              name, cp = cols[i]
+              h[name] = if (v = field_values[i]) && cp
+                cp.call(v)
               else
                 v
               end

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -54,12 +54,12 @@ module Sequel
         # MySQL 5.1.12 JDBC adapter requires generated keys
         # and previous versions don't mind.
         def execute_statement_insert(stmt, sql)
-          stmt.executeUpdate(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS)
+          stmt.executeUpdate(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS)
         end
 
         # Return generated keys for insert statements.
         def prepare_jdbc_statement(conn, sql, opts)
-          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS) : super
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS) : super
         end
 
         # Convert tinyint(1) type to boolean

data/lib/sequel/adapters/shared/sqlite.rb

@@ -513,7 +513,7 @@ module Sequel
 
       Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
       Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert conflict into columns values on_conflict'], ["else", %w'insert conflict into columns values']])
-      Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'with values compounds'], ['else', %w'with select distinct columns from join where group having compounds order limit lock']])
+      Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'with values compounds'], ['else', %w'with select distinct columns from join where group having window compounds order limit lock']])
       Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
 
       def cast_sql_append(sql, expr, type)
@@ -732,6 +732,11 @@ module Sequel
       def supports_where_true?
         false
       end
+
+      # SQLite 3.28+ supports the WINDOW clause.
+      def supports_window_clause?
+        db.sqlite_version >= 32800
+      end
       
       # SQLite 3.25+ supports window functions.  However, support is only enabled
       # on SQLite 3.26.0+ because internal Sequel usage of window functions
@@ -741,6 +746,11 @@ module Sequel
         db.sqlite_version >= 32600
       end
     
+      # SQLite 3.28.0+ supports all window frame options that Sequel supports
+      def supports_window_function_frame_option?(option)
+        db.sqlite_version >= 32800 ? true : super
+      end
+
       private
       
       # SQLite uses string literals instead of identifiers in AS clauses.

data/lib/sequel/adapters/sqlite.rb

@@ -112,7 +112,7 @@ module Sequel
         sqlite3_opts = {}
         sqlite3_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
         db = ::SQLite3::Database.new(opts[:database].to_s, sqlite3_opts)
-        db.busy_timeout(opts.fetch(:timeout, 5000))
+        db.busy_timeout(typecast_value_integer(opts.fetch(:timeout, 5000)))
 
         if USE_EXTENDED_RESULT_CODES
           db.extended_result_codes = true

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -59,6 +59,8 @@ module Sequel
             ForeignKeyConstraintViolation
           when 4025
             CheckConstraintViolation
+          when 1205
+            DatabaseLockTimeout
           else
             super
           end

data/lib/sequel/extensions/named_timezones.rb

@@ -66,6 +66,7 @@ module Sequel
     # Handle both TZInfo 1 and TZInfo 2
     if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
       # :nodoc:
+      # :nocov:
       def convert_input_datetime_other(v, input_timezone)
         local_offset = Rational(input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset, 86400)
         (v - local_offset).new_offset(local_offset)
@@ -78,6 +79,7 @@ module Sequel
         DateTime.jd(v.jd, v.hour, v.minute, v.second + v.sec_fraction, v.offset, v.start)
       end
       # :nodoc:
+      # :nocov:
     else
       # Assume the given DateTime has a correct time but a wrong timezone.  It is
       # currently in UTC timezone, but it should be converted to the input_timezone.

data/lib/sequel/extensions/pg_json.rb

@@ -1,44 +1,99 @@
 # frozen-string-literal: true
 #
 # The pg_json extension adds support for Sequel to handle
-# PostgreSQL's json and jsonb types.  It is slightly more strict than the
-# PostgreSQL json types in that the object returned should be an
-# array or object (PostgreSQL's json type considers plain numbers
-# strings, true, false, and null as valid).  Sequel will work with
-# PostgreSQL json values that are not arrays or objects, but support
-# is fairly limited and the values do not roundtrip.
+# PostgreSQL's json and jsonb types.  By default, it wraps
+# JSON arrays and JSON objects with ruby array-like and
+# hash-like objects.  If you would like to wrap JSON primitives
+# (numbers, strings, +null+, +true+, and +false+), you need to
+# use the +wrap_json_primitives+ setter:
 #
-# This extension integrates with Sequel's native postgres and jdbc/postgresql adapters, so
-# that when json fields are retrieved, they are parsed and returned
-# as instances of Sequel::Postgres::JSONArray or
-# Sequel::Postgres::JSONHash (or JSONBArray or JSONBHash for jsonb
-# columns).  JSONArray and JSONHash are
-# DelegateClasses of Array and Hash, so they mostly act the same, but
-# not completely (json_array.is_a?(Array) is false).  If you want
-# the actual array for a JSONArray, call JSONArray#to_a.  If you want
-# the actual hash for a JSONHash, call JSONHash#to_hash.
-# This is done so that Sequel does not treat JSONArray and JSONHash
-# like Array and Hash by default, which would cause issues.
+#   DB.extension :pg_json
+#   DB.wrap_json_primitives = true
+#
+# Note that wrapping JSON primitives changes the behavior for
+# JSON false and null values.  Because only +false+ and +nil+
+# in Ruby are considered falesy, wrapping these objects results
+# in unexpected behavior if you use the values directly in
+# conditionals:
+#
+#   if DB[:table].get(:json_column)
+#     # called if the value of json_column is null/false
+#     # if you are wrapping primitives
+#   end
 #
-# To turn an existing Array or Hash into a JSONArray or JSONHash,
-# use Sequel.pg_json:
+# To extract the Ruby primitive object from the wrapper object,
+# you can use +__getobj__+ (this comes from Ruby's delegate library).
 #
-#   Sequel.pg_json(array) # or Sequel.pg_jsonb(array) for jsonb type
-#   Sequel.pg_json(hash)  # or Sequel.pg_jsonb(hash) for jsonb type
+# To wrap an existing Ruby array, hash, string, integer, float,
+# +nil+, +true+, or +false+, use +Sequel.pg_json_wrap+ or +Sequel.pg_jsonb_wrap+:
+#
+#   Sequel.pg_json_wrap(object)  # json type
+#   Sequel.pg_jsonb_wrap(object) # jsonb type
+#
+# So if you want to insert an array or hash into an json database column:
+#
+#   DB[:table].insert(column: Sequel.pg_json_wrap([1, 2, 3]))
+#   DB[:table].insert(column: Sequel.pg_json_wrap({'a'=>1, 'b'=>2}))
+#
+# Note that the +pg_json_wrap+ and +pg_jsonb_wrap+ methods only handle Ruby primitives,
+# they do not handle already wrapped objects.
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
-# and have activated refinements for the file, you can also use Array#pg_json and Hash#pg_json:
+# and have activated refinements for the file, you can also use the
+# +pg_json+ and +pg_jsonb+ methods directly on Array or Hash:
 #
-#   array.pg_json # or array.pg_jsonb for jsonb type
-#   hash.pg_json  # or hash.pg_jsonb for jsonb type
+#   array.pg_json  # json type
+#   array.pg_jsonb # jsonb type
 #
-# So if you want to insert an array or hash into an json database column:
+#   hash.pg_json   # json type
+#   hash.pg_jsonb  # jsonb type
+#
+# Model classes that use json or jsonb columns will have typecasting automatically
+# setup, so you can assign Ruby primitives to model columns and have the wrapped
+# objects automatically created.  However, for backwards compatibility, passing
+# a string object will parse the string as JSON, not create a JSON string object.
+# 
+#   obj = Model.new
+#   obj.json_column = {'a'=>'b'}
+#   obj.json_column.class
+#   # => Sequel::Postgres::JSONHash
+#   obj.json_column['a']
+#   # => 'b'
+#
+#   obj.json_column = '{"a": "b"}'
+#   obj.json_column.class
+#   # => Sequel::Postgres::JSONHash
+#   obj.json_column['a']
+#   # => 'b'
 #
-#   DB[:table].insert(column: Sequel.pg_json([1, 2, 3]))
-#   DB[:table].insert(column: Sequel.pg_json({'a'=>1, 'b'=>2}))
+# You can change the handling of string typecasting by using +typecast_json_strings+:
 #
-# To use this extension, please load it into the Database instance:
+#   DB.typecast_json_strings = true
+#   obj.json_column = '{"a": "b"}'
+#   obj.json_column.class
+#   # => Sequel::Postgres::JSONString
+#   obj.json_column
+#   # => '{"a": "b"}'
+#
+# Note that +nil+ values are never automatically wrapped:
+#
+#   obj.json_column = nil
+#   obj.json_column.class
+#   # => NilClass
+#   obj.json_column
+#   # => nil
+#
+# If you want to set a JSON null value when using a model, you must wrap it
+# explicitly:
+#
+#   obj.json_column = Sequel.pg_json_wrap(nil)
+#   obj.json_column.class
+#   # => Sequel::Postgres::JSONNull
+#   obj.json_column
+#   # => nil
+#
+# To use this extension, load it into the Database instance:
 #
 #   DB.extension :pg_json
 #
@@ -46,7 +101,7 @@
 # for details on using json columns in CREATE/ALTER TABLE statements.
 #
 # This extension integrates with the pg_array extension.  If you plan
-# to use the json[] type, load the pg_array extension before the
+# to use the json[] or jsonb[] types, load the pg_array extension before the
 # pg_json extension:
 #
 #   DB.extension :pg_array, :pg_json
@@ -54,114 +109,148 @@
 # Note that when accessing json hashes, you should always use strings for keys.
 # Attempting to use other values (such as symbols) will not work correctly.
 #
-# This extension requires both the json and delegate libraries.
+# This extension requires both the json and delegate libraries.  However, you
+# can override +Sequel.parse_json+, +Sequel.object_to_json+, and
+# +Sequel.json_parser_error_class+ to use an alternative JSON implementation.
 #
-# Related modules: Sequel::Postgres::JSONArrayBase, Sequel::Postgres::JSONArray,
-# Sequel::Postgres::JSONArray, Sequel::Postgres::JSONBArray, Sequel::Postgres::JSONHashBase,
-# Sequel::Postgres::JSONHash, Sequel::Postgres::JSONBHash, Sequel::Postgres::JSONDatabaseMethods
+# Related modules: Sequel::Postgres::JSONDatabaseMethods
 
 require 'delegate'
 require 'json'
 
 module Sequel
   module Postgres
-    # Class representing PostgreSQL JSON/JSONB column array values.
-    class JSONArrayBase < DelegateClass(Array)
-      include Sequel::SQL::AliasMethods
-      include Sequel::SQL::CastMethods
-
-      # Convert the array to a json string and append a
-      # literalized version of the string to the sql.
-      def sql_literal_append(ds, sql)
-        ds.literal_append(sql, Sequel.object_to_json(self))
-      end
+    # A module included in all of the JSON wrapper classes.
+    module JSONObject
     end
 
-    class JSONArray < JSONArrayBase
-      # Cast as json
-      def sql_literal_append(ds, sql)
-        super
-        sql << '::json'
-      end
+    # A module included in all of the JSONB wrapper classes.
+    module JSONBObject
     end
 
-    class JSONBArray < JSONArrayBase
-      # Cast as jsonb
-      def sql_literal_append(ds, sql)
-        super
-        sql << '::jsonb'
+    create_delegate_class = lambda do |name, delegate_class|
+      base_class = DelegateClass(delegate_class)
+      base_class.class_eval do
+        include Sequel::SQL::AliasMethods
+        include Sequel::SQL::CastMethods
       end
-    end
 
-    # Class representing PostgreSQL JSON/JSONB column hash/object values.
-    class JSONHashBase < DelegateClass(Hash)
-      include Sequel::SQL::AliasMethods
-      include Sequel::SQL::CastMethods
+      json_class = Class.new(base_class) do
+        include JSONObject
 
-      # Convert the hash to a json string and append a
-      # literalized version of the string to the sql.
-      def sql_literal_append(ds, sql)
-        ds.literal_append(sql, Sequel.object_to_json(self))
+        def sql_literal_append(ds, sql)
+          ds.literal_append(sql, Sequel.object_to_json(self))
+          sql << '::json'
+        end
       end
 
-      # Return the object being delegated to.
-      alias to_hash __getobj__
-    end
+      jsonb_class = Class.new(base_class) do
+        include JSONBObject
 
-    class JSONHash < JSONHashBase
-      # Cast as json
-      def sql_literal_append(ds, sql)
-        super
-        sql << '::json'
+        def sql_literal_append(ds, sql)
+          ds.literal_append(sql, Sequel.object_to_json(self))
+          sql << '::jsonb'
+        end
       end
+
+      const_set(:"JSON#{name}Base", base_class)
+      const_set(:"JSON#{name}", json_class)
+      const_set(:"JSONB#{name}", jsonb_class)
     end
 
-    class JSONBHash < JSONHashBase
-      # Cast as jsonb
-      def sql_literal_append(ds, sql)
-        super
-        sql << '::jsonb'
-      end
+    create_delegate_class.call(:Array, Array)
+    create_delegate_class.call(:Hash, Hash)
+    create_delegate_class.call(:String, String)
+    create_delegate_class.call(:Integer, Integer)
+    create_delegate_class.call(:Float, Float)
+    create_delegate_class.call(:Null, NilClass)
+    create_delegate_class.call(:True, TrueClass)
+    create_delegate_class.call(:False, FalseClass)
+
+    JSON_WRAPPER_MAPPING = {
+      ::Array => JSONArray,
+      ::Hash => JSONHash,
+    }.freeze
+
+    JSONB_WRAPPER_MAPPING = {
+      ::Array => JSONBArray,
+      ::Hash => JSONBHash,
+    }.freeze
+
+    JSON_PRIMITIVE_WRAPPER_MAPPING = {
+      ::String => JSONString,
+      ::Integer => JSONInteger,
+      ::Float => JSONFloat,
+      ::NilClass => JSONNull,
+      ::TrueClass => JSONTrue,
+      ::FalseClass => JSONFalse,
+    }
+
+    JSONB_PRIMITIVE_WRAPPER_MAPPING = {
+      ::String => JSONBString,
+      ::Integer => JSONBInteger,
+      ::Float => JSONBFloat,
+      ::NilClass => JSONBNull,
+      ::TrueClass => JSONBTrue,
+      ::FalseClass => JSONBFalse,
+    }
+
+    if RUBY_VERSION < '2.4'
+      # :nocov:
+      JSON_PRIMITIVE_WRAPPER_MAPPING[Fixnum] = JSONInteger
+      JSON_PRIMITIVE_WRAPPER_MAPPING[Bignum] = JSONInteger
+      JSONB_PRIMITIVE_WRAPPER_MAPPING[Fixnum] = JSONBInteger
+      JSONB_PRIMITIVE_WRAPPER_MAPPING[Bignum] = JSONBInteger
+      # :nocov:
     end
 
+    JSON_PRIMITIVE_WRAPPER_MAPPING.freeze
+    JSONB_PRIMITIVE_WRAPPER_MAPPING.freeze
+
+    JSON_COMBINED_WRAPPER_MAPPING =JSON_WRAPPER_MAPPING.merge(JSON_PRIMITIVE_WRAPPER_MAPPING).freeze
+    JSON_WRAP_CLASSES = JSON_COMBINED_WRAPPER_MAPPING.keys.freeze
+
+    JSONB_COMBINED_WRAPPER_MAPPING =JSONB_WRAPPER_MAPPING.merge(JSONB_PRIMITIVE_WRAPPER_MAPPING).freeze
+    JSONB_WRAP_CLASSES = JSONB_COMBINED_WRAPPER_MAPPING.keys.freeze
+
     # Methods enabling Database object integration with the json type.
     module JSONDatabaseMethods
       def self.extended(db)
         db.instance_exec do
-          add_conversion_proc(114, JSONDatabaseMethods.method(:db_parse_json))
-          add_conversion_proc(3802, JSONDatabaseMethods.method(:db_parse_jsonb))
+          add_conversion_proc(114, method(:_db_parse_json))
+          add_conversion_proc(3802, method(:_db_parse_jsonb))
           if respond_to?(:register_array_type)
             register_array_type('json', :oid=>199, :scalar_oid=>114)
             register_array_type('jsonb', :oid=>3807, :scalar_oid=>3802)
           end
-          @schema_type_classes[:json] = [JSONHash, JSONArray]
-          @schema_type_classes[:jsonb] = [JSONBHash, JSONBArray]
+          @schema_type_classes[:json] = [JSONObject]
+          @schema_type_classes[:jsonb] = [JSONBObject]
         end
       end
 
-      # Parse JSON data coming from the database.  Since PostgreSQL allows
-      # non JSON data in JSON fields (such as plain numbers and strings),
-      # we don't want to raise an exception for that.
+
+      # Deprecated
       def self.db_parse_json(s)
+        # SEQUEL6: Remove
         parse_json(s)
       rescue Sequel::InvalidValue
         raise unless s.is_a?(String)
         parse_json("[#{s}]").first
       end
 
-      # Same as db_parse_json, but consider the input as jsonb.
+      # Deprecated
       def self.db_parse_jsonb(s)
+        # SEQUEL6: Remove
         parse_json(s, true)
       rescue Sequel::InvalidValue
         raise unless s.is_a?(String)
         parse_json("[#{s}]").first
       end
 
-      # Parse the given string as json, returning either a JSONArray
-      # or JSONHash instance (or JSONBArray or JSONBHash instance if jsonb
-      # argument is true), or a String, Numeric, true, false, or nil
-      # if the json library used supports that.
+      # Deprecated
       def self.parse_json(s, jsonb=false)
+        # SEQUEL6: Remove
+        Sequel::Deprecation.deprecate("Sequel::Postgres::JSONDatabaseMethods.{parse_json,db_parse_json,db_parse_jsonb} are deprecated and will be removed in Sequel 6.")
         begin
           value = Sequel.parse_json(s)
         rescue Sequel.json_parser_error_class => e
@@ -180,10 +269,22 @@ module Sequel
         end
       end
 
+      # Whether to wrap JSON primitives instead of using Ruby objects.
+      # Wrapping the primitives allows the primitive values to roundtrip,
+      # but it can cause problems, especially as false/null JSON values
+      # will be treated as truthy in Ruby due to the wrapping.  False by
+      # default.
+      attr_accessor :wrap_json_primitives
+
+      # Whether to typecast strings for json/jsonb types as JSON
+      # strings, instead of trying to parse the string as JSON.
+      # False by default.
+      attr_accessor :typecast_json_strings
+
       # Handle json and jsonb types in bound variables
       def bound_variable_arg(arg, conn)
         case arg
-        when JSONArrayBase, JSONHashBase
+        when JSONObject, JSONBObject
           Sequel.object_to_json(arg)
         else
           super
@@ -192,10 +293,72 @@ module Sequel
 
       private
 
+      # Parse JSON data coming from the database.  Since PostgreSQL allows
+      # non JSON data in JSON fields (such as plain numbers and strings),
+      # we don't want to raise an exception for that.
+      def _db_parse_json(s)
+        _wrap_json(_parse_json(s))
+      rescue Sequel::InvalidValue
+        raise unless s.is_a?(String)
+        _wrap_json(_parse_json("[#{s}]").first)
+      end
+
+      # Same as _db_parse_json, but consider the input as jsonb.
+      def _db_parse_jsonb(s)
+        _wrap_jsonb(_parse_json(s))
+      rescue Sequel::InvalidValue
+        raise unless s.is_a?(String)
+        _wrap_jsonb(_parse_json("[#{s}]").first)
+      end
+
+      # Parse the given string as json, returning either a JSONArray
+      # or JSONHash instance (or JSONBArray or JSONBHash instance if jsonb
+      # argument is true), or a String, Numeric, true, false, or nil
+      # if the json library used supports that.
+      def _parse_json(s)
+        begin
+          Sequel.parse_json(s)
+        rescue Sequel.json_parser_error_class => e
+          raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+        end
+      end
+
+      # Wrap the parsed JSON value in the appropriate JSON wrapper class.
+      # Only wrap primitive values if wrap_json_primitives is set.
+      def _wrap_json(value)
+        if klass = JSON_WRAPPER_MAPPING[value.class]
+          klass.new(value)
+        elsif klass = JSON_PRIMITIVE_WRAPPER_MAPPING[value.class]
+          if wrap_json_primitives
+            klass.new(value)
+          else
+            value
+          end
+        else
+          raise Sequel::InvalidValue, "unhandled json value: #{value.inspect}"
+        end
+      end
+
+      # Wrap the parsed JSON value in the appropriate JSONB wrapper class.
+      # Only wrap primitive values if wrap_json_primitives is set.
+      def _wrap_jsonb(value)
+        if klass = JSONB_WRAPPER_MAPPING[value.class]
+          klass.new(value)
+        elsif klass = JSONB_PRIMITIVE_WRAPPER_MAPPING[value.class]
+          if wrap_json_primitives
+            klass.new(value)
+          else
+            value
+          end
+        else
+          raise Sequel::InvalidValue, "unhandled jsonb value: #{value.inspect}"
+        end
+      end
+
       # Handle json[] and jsonb[] types in bound variables.
       def bound_variable_array(a)
         case a
-        when JSONHashBase, JSONArrayBase
+        when JSONObject, JSONBObject
           "\"#{Sequel.object_to_json(a).gsub('"', '\\"')}\""
         else
           super
@@ -238,41 +401,43 @@ module Sequel
         end
       end
 
-      # Convert the value given to a JSONArray or JSONHash
+      # Convert the value given to a JSON wrapper object.
       def typecast_value_json(value)
         case value
-        when JSONArray, JSONHash
+        when JSONObject
           value
-        when Array
-          JSONArray.new(value)
-        when Hash 
-          JSONHash.new(value)
-        when JSONBArray
-          JSONArray.new(value.to_a)
-        when JSONBHash
-          JSONHash.new(value.to_hash)
         when String
-          JSONDatabaseMethods.parse_json(value)
+          if typecast_json_strings
+            JSONString.new(value)
+          else
+            _wrap_json(_parse_json(value))
+          end
+        when *JSON_WRAP_CLASSES
+          JSON_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+        when JSONBObject
+          value = value.__getobj__
+          JSON_COMBINED_WRAPPER_MAPPING[value.class].new(value)
         else
           raise Sequel::InvalidValue, "invalid value for json: #{value.inspect}"
         end
       end
 
-      # Convert the value given to a JSONBArray or JSONBHash
+      # Convert the value given to a JSONB wrapper object.
       def typecast_value_jsonb(value)
         case value
-        when JSONBArray, JSONBHash
+        when JSONBObject
           value
-        when Array
-          JSONBArray.new(value)
-        when Hash 
-          JSONBHash.new(value)
-        when JSONArray
-          JSONBArray.new(value.to_a)
-        when JSONHash
-          JSONBHash.new(value.to_hash)
         when String
-          JSONDatabaseMethods.parse_json(value, true)
+          if typecast_json_strings
+            JSONBString.new(value)
+          else
+            _wrap_jsonb(_parse_json(value))
+          end
+        when *JSONB_WRAP_CLASSES
+          JSONB_COMBINED_WRAPPER_MAPPING[value.class].new(value)
+        when JSONObject
+          value = value.__getobj__
+          JSONB_COMBINED_WRAPPER_MAPPING[value.class].new(value)
         else
           raise Sequel::InvalidValue, "invalid value for jsonb: #{value.inspect}"
         end
@@ -282,40 +447,68 @@ module Sequel
 
   module SQL::Builders
     # Wrap the array or hash in a Postgres::JSONArray or Postgres::JSONHash.
+    # Also handles Postgres::JSONObject and JSONBObjects.
+    # For other objects, calls +Sequel.pg_json_op+ (which is defined
+    # by the pg_json_ops extension).
     def pg_json(v)
       case v
-      when Postgres::JSONArray, Postgres::JSONHash
+      when Postgres::JSONObject
         v
       when Array
         Postgres::JSONArray.new(v)
       when Hash
         Postgres::JSONHash.new(v)
-      when Postgres::JSONBArray
-        Postgres::JSONArray.new(v.to_a)
-      when Postgres::JSONBHash
-        Postgres::JSONHash.new(v.to_hash)
+      when Postgres::JSONBObject
+        v = v.__getobj__
+        Postgres::JSON_COMBINED_WRAPPER_MAPPING[v.class].new(v)
       else
         Sequel.pg_json_op(v)
       end
     end
 
+    # Wraps Ruby array, hash, string, integer, float, true, false, and nil
+    # values with the appropriate JSON wrapper.  Raises an exception for
+    # other types.
+    def pg_json_wrap(v)
+      case v
+      when *Postgres::JSON_WRAP_CLASSES
+        Postgres::JSON_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+      else
+        raise Error, "invalid value passed to Sequel.pg_json_wrap: #{v.inspect}"
+      end
+    end
+
     # Wrap the array or hash in a Postgres::JSONBArray or Postgres::JSONBHash.
+    # Also handles Postgres::JSONObject and JSONBObjects.
+    # For other objects, calls +Sequel.pg_json_op+ (which is defined
+    # by the pg_json_ops extension).
     def pg_jsonb(v)
       case v
-      when Postgres::JSONBArray, Postgres::JSONBHash
+      when Postgres::JSONBObject
         v
       when Array
         Postgres::JSONBArray.new(v)
       when Hash
         Postgres::JSONBHash.new(v)
-      when Postgres::JSONArray
-        Postgres::JSONBArray.new(v.to_a)
-      when Postgres::JSONHash
-        Postgres::JSONBHash.new(v.to_hash)
+      when Postgres::JSONObject
+        v = v.__getobj__
+        Postgres::JSONB_COMBINED_WRAPPER_MAPPING[v.class].new(v)
       else
         Sequel.pg_jsonb_op(v)
       end
     end
+
+    # Wraps Ruby array, hash, string, integer, float, true, false, and nil
+    # values with the appropriate JSONB wrapper.  Raises an exception for
+    # other types.
+    def pg_jsonb_wrap(v)
+      case v
+      when *Postgres::JSONB_WRAP_CLASSES
+        Postgres::JSONB_COMBINED_WRAPPER_MAPPING[v.class].new(v)
+      else
+        raise Error, "invalid value passed to Sequel.pg_jsonb_wrap: #{v.inspect}"
+      end
+    end
   end
 
   Database.register_extension(:pg_json, Postgres::JSONDatabaseMethods)