sequel 4.10.0 → 4.11.0

data/lib/sequel/extensions/constraint_validations.rb

@@ -70,8 +70,8 @@
 # length_range 3...5 :: CHECK char_length(column) >= 3 AND char_length(column) < 5
 # format /foo\\d+/ :: CHECK column ~ 'foo\\d+'
 # format /foo\\d+/i :: CHECK column ~* 'foo\\d+'
-# like 'foo%' :: CHECK column LIKE 'foo%'
-# ilike 'foo%' :: CHECK column ILIKE 'foo%'
+# like 'foo%' :: CHECK column LIKE 'foo%' ESCAPE '\'
+# ilike 'foo%' :: CHECK column ILIKE 'foo%' ESCAPE '\'
 # includes ['a', 'b'] :: CHECK column IN ('a', 'b')
 # includes [1, 2] :: CHECK column IN (1, 2)
 # includes 3..5 :: CHECK column >= 3 AND column <= 5

data/lib/sequel/extensions/date_arithmetic.rb

@@ -82,7 +82,7 @@ module Sequel
             each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
               args << "#{value} #{sql_unit}"
             end
-            return _function_sql_append(sql, :datetime, args)
+            return function_sql_append(sql, Sequel.function(:datetime, *args))
           when :mysql, :hsqldb, :cubrid
             if db_type == :hsqldb
               # HSQLDB requires 2.2.9+ for the DATE_ADD function

data/lib/sequel/extensions/eval_inspect.rb

@@ -74,7 +74,7 @@ module Sequel
             Sequel.eval_inspect(send(arg))
           end
         end
-        "#{klass}.new(#{args.join(', ')})"
+        "#{klass}.#{inspect_new_method}(#{args.join(', ')})"
       end
 
       private
@@ -83,6 +83,11 @@ module Sequel
       def inspect_args
         self.class.comparison_attrs
       end
+
+      # Use the new method by default for creating new objects.
+      def inspect_new_method
+        :new
+      end
     end
 
     class ComplexExpression
@@ -127,9 +132,10 @@ module Sequel
     class Function
       private
 
-      # Function's initializer uses a splat for the function arguments.
-      def inspect_args
-        [:f, "*args"]
+      # Function uses a new! method for creating functions with options,
+      # since Function.new does not allow for an options hash.
+      def inspect_new_method
+        :new!
       end
     end
 
@@ -139,7 +145,7 @@ module Sequel
       # JoinOnClause's initializer takes the on argument as the first argument
       # instead of the last.
       def inspect_args
-        [:on, :join_type, :table, :table_alias] 
+        [:on, :join_type, :table_expr] 
       end
     end
 
@@ -149,7 +155,7 @@ module Sequel
       # JoinOnClause's initializer takes the using argument as the first argument
       # instead of the last.
       def inspect_args
-        [:using, :join_type, :table, :table_alias] 
+        [:using, :join_type, :table_expr] 
       end
     end
 

data/lib/sequel/extensions/pg_array_ops.rb

@@ -41,6 +41,7 @@
 #
 #   ia.any             # ANY(int_array_column)
 #   ia.all             # ALL(int_array_column)
+#   ia.cardinality     # cardinality(int_array_column)
 #   ia.dims            # array_dims(int_array_column)
 #   ia.hstore          # hstore(int_array_column)
 #   ia.hstore(:a)      # hstore(int_array_column, a)
@@ -52,6 +53,7 @@
 #   ia.join(':')       # array_to_string(int_array_column, ':', NULL)
 #   ia.join(':', ' ')  # array_to_string(int_array_column, ':', ' ')
 #   ia.unnest          # unnest(int_array_column)
+#   ia.unnest(:b)      # unnest(int_array_column, b)
 # 
 # See the PostgreSQL array function and operator documentation for more
 # details on what these functions and operators do.
@@ -111,6 +113,13 @@ module Sequel
         function(:ANY)
       end
 
+      # Call the cardinality method:
+      #
+      #   array_op.cardinality # cardinality(array)
+      def cardinality
+        function(:cardinality)
+      end
+
       # Use the contains (@>) operator:
       #
       #   array_op.contains(:a) # (array @> a)
@@ -215,8 +224,8 @@ module Sequel
       # Call the unnest method:
       #
       #   array_op.unnest # unnest(array)
-      def unnest
-        function(:unnest)
+      def unnest(*args)
+        function(:unnest, *args.map{|a| wrap_array(a)})
       end
       
       # Use the concatentation (||) operator, reversing the order:

data/lib/sequel/extensions/pg_json.rb

@@ -64,42 +64,74 @@ Sequel.require 'adapters/utils/pg_types'
 module Sequel
   module Postgres
     CAST_JSON = '::json'.freeze
+    CAST_JSONB = '::jsonb'.freeze
 
-    # Class representating PostgreSQL JSON column array values.
-    class JSONArray < DelegateClass(Array)
+    # 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, append a
-      # literalized version of the string to the sql, and explicitly
-      # cast the string to json.
+      # 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
+    end
+
+    class JSONArray < JSONArrayBase
+      # Cast as json
+      def sql_literal_append(ds, sql)
+        super
         sql << CAST_JSON
       end
     end
 
-    # Class representating PostgreSQL JSON column hash/object values.
-    class JSONHash < DelegateClass(Hash)
+    class JSONBArray < JSONArrayBase
+      # Cast as jsonb
+      def sql_literal_append(ds, sql)
+        super
+        sql << CAST_JSONB
+      end
+    end
+
+    # Class representing PostgreSQL JSON/JSONB column hash/object values.
+    class JSONHashBase < DelegateClass(Hash)
       include Sequel::SQL::AliasMethods
+      include Sequel::SQL::CastMethods
 
-      # Convert the hash to a json string, append a
-      # literalized version of the string to the sql, and explicitly
-      # cast the string to json.
+      # 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))
-        sql << CAST_JSON
       end
 
       # Return the object being delegated to.
       alias to_hash __getobj__
     end
 
+    class JSONHash < JSONHashBase
+      # Cast as json
+      def sql_literal_append(ds, sql)
+        super
+        sql << CAST_JSON
+      end
+    end
+
+    class JSONBHash < JSONHashBase
+      # Cast as jsonb
+      def sql_literal_append(ds, sql)
+        super
+        sql << CAST_JSONB
+      end
+    end
+
     # Methods enabling Database object integration with the json type.
     module JSONDatabaseMethods
       def self.extended(db)
         db.instance_eval do
-          copy_conversion_procs([114, 199])
+          copy_conversion_procs([114, 199, 3802, 3807])
           @schema_type_classes[:json] = [JSONHash, JSONArray]
+          @schema_type_classes[:jsonb] = [JSONBHash, JSONBArray]
         end
       end
 
@@ -113,10 +145,18 @@ module Sequel
         parse_json("[#{s}]").first
       end
 
+      # Same as db_parse_json, but consider the input as jsonb.
+      def self.db_parse_jsonb(s)
+        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, and raising an error if the JSON
       # parsing does not yield an array or hash.
-      def self.parse_json(s)
+      def self.parse_json(s, jsonb=false)
         begin
           value = Sequel.parse_json(s)
         rescue Sequel.json_parser_error_class => e
@@ -125,9 +165,9 @@ module Sequel
 
         case value
         when Array
-          JSONArray.new(value)
+          (jsonb ? JSONBArray : JSONArray).new(value)
         when Hash 
-          JSONHash.new(value)
+          (jsonb ? JSONBHash : JSONHash).new(value)
         else
           raise Sequel::InvalidValue, "unhandled json value: #{value.inspect} (from #{s.inspect})"
         end
@@ -136,7 +176,7 @@ module Sequel
       # Handle JSONArray and JSONHash in bound variables
       def bound_variable_arg(arg, conn)
         case arg
-        when JSONArray, JSONHash
+        when JSONArrayBase, JSONHashBase
           Sequel.object_to_json(arg)
         else
           super
@@ -148,7 +188,7 @@ module Sequel
       # Handle json[] types in bound variables.
       def bound_variable_array(a)
         case a
-        when JSONHash, JSONArray
+        when JSONHashBase, JSONArrayBase
           "\"#{Sequel.object_to_json(a).gsub('"', '\\"')}\""
         else
           super
@@ -160,17 +200,14 @@ module Sequel
         case db_type
         when 'json'
           :json
+        when 'jsonb'
+          :jsonb
         else
           super
         end
       end
 
-      # Given a value to typecast to the json column
-      # * If given a JSONArray or JSONHash, just return the value
-      # * If given an Array, return a JSONArray
-      # * If given a Hash, return a JSONHash
-      # * If given a String, parse it as would be done during
-      #   database retrieval.
+      # Convert the value given to a JSONArray or JSONHash
       def typecast_value_json(value)
         case value
         when JSONArray, JSONHash
@@ -179,17 +216,43 @@ module Sequel
           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)
         else
           raise Sequel::InvalidValue, "invalid value for json: #{value.inspect}"
         end
       end
+
+      # Convert the value given to a JSONBArray or JSONBHash
+      def typecast_value_jsonb(value)
+        case value
+        when JSONBArray, JSONBHash
+          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)
+        else
+          raise Sequel::InvalidValue, "invalid value for jsonb: #{value.inspect}"
+        end
+      end
     end
 
     PG_TYPES[114] = JSONDatabaseMethods.method(:db_parse_json)
+    PG_TYPES[3802] = JSONDatabaseMethods.method(:db_parse_jsonb)
     if defined?(PGArray) && PGArray.respond_to?(:register)
       PGArray.register('json', :oid=>199, :scalar_oid=>114)
+      PGArray.register('jsonb', :oid=>3807, :scalar_oid=>3802)
     end
   end
 
@@ -203,6 +266,28 @@ module Sequel
         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)
+      else
+        Sequel.pg_json_op(v)
+      end
+    end
+
+    # Wrap the array or hash in a Postgres::JSONArray or Postgres::JSONHash.
+    def pg_jsonb(v)
+      case v
+      when Postgres::JSONBArray, Postgres::JSONBHash
+        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)
       else
         Sequel.pg_json_op(v)
       end
@@ -221,6 +306,13 @@ if Sequel.core_extensions?
     def pg_json
       Sequel::Postgres::JSONArray.new(self)
     end
+
+    # Return a Sequel::Postgres::JSONArray proxy to the receiver.
+    # This is mostly useful as a short cut for creating JSONArray
+    # objects that didn't come from the database.
+    def pg_jsonb
+      Sequel::Postgres::JSONBArray.new(self)
+    end
   end
 
   class Hash
@@ -230,6 +322,13 @@ if Sequel.core_extensions?
     def pg_json
       Sequel::Postgres::JSONHash.new(self)
     end
+
+    # Return a Sequel::Postgres::JSONHash proxy to the receiver.
+    # This is mostly useful as a short cut for creating JSONHash
+    # objects that didn't come from the database.
+    def pg_jsonb
+      Sequel::Postgres::JSONBHash.new(self)
+    end
   end
 end
 
@@ -239,12 +338,20 @@ if defined?(Sequel::CoreRefinements)
       def pg_json
         Sequel::Postgres::JSONArray.new(self)
       end
+
+      def pg_jsonb
+        Sequel::Postgres::JSONBArray.new(self)
+      end
     end
 
     refine Hash do
       def pg_json
         Sequel::Postgres::JSONHash.new(self)
       end
+
+      def pg_jsonb
+        Sequel::Postgres::JSONBHash.new(self)
+      end
     end
   end
 end

data/lib/sequel/extensions/pg_json_ops.rb

@@ -1,32 +1,39 @@
 # The pg_json_ops extension adds support to Sequel's DSL to make
 # it easier to call PostgreSQL JSON functions and operators (added
-# first in PostgreSQL 9.3).
+# first in PostgreSQL 9.3).  It also supports the JSONB functions
+# and operators added in PostgreSQL 9.4).
 #
 # To load the extension:
 #
 #   Sequel.extension :pg_json_ops
 #
-# The most common usage is passing an expression to Sequel.pg_json_op:
+# The most common usage is passing an expression to Sequel.pg_json_op
+# or Sequel.pg_jsonb_op:
 #
 #   j = Sequel.pg_json_op(:json_column)
+#   jb = Sequel.pg_jsonb_op(:jsonb_column)
 #
 # If you have also loaded the pg_json extension, you can use
-# Sequel.pg_json as well:
+# Sequel.pg_json or Sequel.pg_jsonb as well:
 #
 #  j = Sequel.pg_json(:json_column)
+#  jb = Sequel.pg_jsonb(:jsonb_column)
 #
 # Also, on most Sequel expression objects, you can call the pg_json
-# method:
+# or pg_jsonb # method:
 #
 #   j = Sequel.expr(:json_column).pg_json
+#   jb = Sequel.expr(:jsonb_column).pg_jsonb
 #
 # 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 Symbol#pg_json:
+# and have activated refinements for the file, you can also use Symbol#pg_json or
+# Symbol#pg_jsonb:
 #
 #   j = :json_column.pg_json
+#   jb = :jsonb_column.pg_jsonb
 #
-# This creates a Sequel::Postgres::JSONOp object that can be used
+# This creates a Sequel::Postgres::JSONOp or Sequel::Postgres::JSONBOp object that can be used
 # for easier querying:
 #
 #   j[1]                     # (json_column -> 1)
@@ -38,17 +45,21 @@
 #
 #   j.array_length           # json_array_length(json_column)
 #   j.array_elements         # json_array_elements(json_column)
+#   j.array_elements_text    # json_array_elements_text(json_column)
 #   j.each                   # json_each(json_column)
 #   j.each_text              # json_each_text(json_column)
 #   j.keys                   # json_object_keys(json_column)
+#   j.typeof                 # json_typeof(json_column)
 #
 #   j.populate(:a)           # json_populate_record(:a, json_column)
 #   j.populate_set(:a)       # json_populate_recordset(:a, json_column)
+#   j.to_record              # json_to_record(json_column)
+#   j.to_recordset           # json_to_recordset(json_column)
 #
 # If you are also using the pg_json extension, you should load it before
-# loading this extension.  Doing so will allow you to use JSONHash#op and
-# JSONArray#op to get a JSONOp, allowing you to perform json operations
-# on json literals.
+# loading this extension.  Doing so will allow you to use the #op method on
+# JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
+# on json/jsonb literals.
 #
 # In order to get the automatic conversion from a ruby array to a PostgreSQL array
 # (as shown in the #[] and #get_text examples above), you need to load the pg_array
@@ -56,14 +67,14 @@
 
 module Sequel
   module Postgres
-    # The JSONOp class is a simple container for a single object that
+    # The JSONBaseOp class is a simple container for a single object that
     # defines methods that yield Sequel expression objects representing
     # PostgreSQL json operators and functions.
     #
     # In the method documentation examples, assume that:
     #
     #   json_op = Sequel.pg_json(:json)
-    class JSONOp < Sequel::SQL::Wrapper
+    class JSONBaseOp < Sequel::SQL::Wrapper
       GET = ["(".freeze, " -> ".freeze, ")".freeze].freeze
       GET_TEXT = ["(".freeze, " ->> ".freeze, ")".freeze].freeze
       GET_PATH = ["(".freeze, " #> ".freeze, ")".freeze].freeze
@@ -86,16 +97,23 @@ module Sequel
 
       # Returns a set of json values for the elements in the json array.
       #
-      #   json_op.array_elements # json_oarray_elements(json)
+      #   json_op.array_elements # json_array_elements(json)
       def array_elements
-        function(:json_array_elements)
+        function(:array_elements)
+      end
+
+      # Returns a set of text values for the elements in the json array.
+      #
+      #   json_op.array_elements_text # json_array_elements_text(json)
+      def array_elements_text
+        function(:array_elements_text)
       end
 
       # Get the length of the outermost json array.
       #
       #   json_op.array_length # json_array_length(json)
       def array_length
-        Sequel::SQL::NumericExpression.new(:NOOP, function(:json_array_length))
+        Sequel::SQL::NumericExpression.new(:NOOP, function(:array_length))
       end
 
       # Returns a set of key and value pairs, where the keys
@@ -103,7 +121,7 @@ module Sequel
       #
       #   json_op.each # json_each(json)
       def each
-        function(:json_each)
+        function(:each)
       end
 
       # Returns a set of key and value pairs, where the keys
@@ -111,7 +129,7 @@ module Sequel
       #
       #   json_op.each_text # json_each_text(json)
       def each_text
-        function(:json_each_text)
+        function(:each_text)
       end
 
       # Returns a json value for the object at the given path.
@@ -119,7 +137,7 @@ module Sequel
       #   json_op.extract('a') # json_extract_path(json, 'a')
       #   json_op.extract('a', 'b') # json_extract_path(json, 'a', 'b')
       def extract(*a)
-        JSONOp.new(function(:json_extract_path, *a))
+        self.class.new(function(:extract_path, *a))
       end
 
       # Returns a text value for the object at the given path.
@@ -127,7 +145,7 @@ module Sequel
       #   json_op.extract_text('a') # json_extract_path_text(json, 'a')
       #   json_op.extract_text('a', 'b') # json_extract_path_text(json, 'a', 'b')
       def extract_text(*a)
-        Sequel::SQL::StringExpression.new(:NOOP, function(:json_extract_path_text, *a))
+        Sequel::SQL::StringExpression.new(:NOOP, function(:extract_path_text, *a))
       end
 
       # Get JSON array element or object field as text.  If an array is given,
@@ -148,26 +166,44 @@ module Sequel
       #
       #   json_op.keys # json_object_keys(json)
       def keys
-        function(:json_object_keys)
-      end
-
-      # Return the receiver, since it is already a JSONOp.
-      def pg_json
-        self
+        function(:object_keys)
       end
 
       # Expands the given argument using the columns in the json.
       #
       #   json_op.populate(arg) # json_populate_record(arg, json)
       def populate(arg)
-        SQL::Function.new(:json_populate_record, arg, self)
+        SQL::Function.new(function_name(:populate_record), arg, self)
       end
 
       # Expands the given argument using the columns in the json.
       #
       #   json_op.populate_set(arg) # json_populate_recordset(arg, json)
       def populate_set(arg)
-        SQL::Function.new(:json_populate_recordset, arg, self)
+        SQL::Function.new(function_name(:populate_recordset), arg, self)
+      end
+
+      # Builds arbitrary record from json object.  You need to define the
+      # structure of the record using #as on the resulting object:
+      #
+      #   json_op.to_record.as(:x, [Sequel.lit('a integer'), Sequel.lit('b text')]) # json_to_record(json) AS x(a integer, b text)
+      def to_record(nested_as_text=false)
+        function(:to_record, nested_as_text)
+      end
+
+      # Builds arbitrary set of records from json array of objects.  You need to define the
+      # structure of the records using #as on the resulting object:
+      #
+      #   json_op.to_recordset.as(:x, [Sequel.lit('a integer'), Sequel.lit('b text')]) # json_to_recordset(json) AS x(a integer, b text)
+      def to_recordset(nested_as_text=false)
+        function(:to_recordset, nested_as_text)
+      end
+
+      # Returns the type of the outermost json value as text.
+      #
+      #   json_op.typeof # json_typeof(json)
+      def typeof
+        function(:typeof)
       end
 
       private
@@ -181,7 +217,7 @@ module Sequel
       # Return a function with the given name, and the receiver as the first
       # argument, with any additional arguments given.
       def function(name, *args)
-        SQL::Function.new(name, self, *args)
+        SQL::Function.new(function_name(name), self, *args)
       end
 
       # Whether the given object represents an array in PostgreSQL.
@@ -200,17 +236,123 @@ module Sequel
       end
     end
 
+    # JSONBaseOp subclass for the json type
+    class JSONOp < JSONBaseOp
+      # Return the receiver, since it is already a JSONOp.
+      def pg_json
+        self
+      end
+
+      private
+
+      # The json type functions are prefixed with json_
+      def function_name(name)
+        "json_#{name}"
+      end
+    end
+
+    # JSONBaseOp subclass for the jsonb type.
+    #
+    # In the method documentation examples, assume that:
+    #
+    #   jsonb_op = Sequel.pg_jsonb(:jsonb)
+    class JSONBOp < JSONBaseOp
+      CONTAIN_ALL = ["(".freeze, " ?& ".freeze, ")".freeze].freeze
+      CONTAIN_ANY = ["(".freeze, " ?| ".freeze, ")".freeze].freeze
+      CONTAINS = ["(".freeze, " @> ".freeze, ")".freeze].freeze
+      CONTAINED_BY = ["(".freeze, " <@ ".freeze, ")".freeze].freeze
+      HAS_KEY = ["(".freeze, " ? ".freeze, ")".freeze].freeze
+
+      # Check if the receiver contains all of the keys in the given array:
+      #
+      #   jsonb_op.contain_all(:a) # (jsonb ?& a)
+      def contain_all(other)
+        bool_op(CONTAIN_ALL, wrap_input_array(other))
+      end
+
+      # Check if the receiver contains any of the keys in the given array:
+      #
+      #   jsonb_op.contain_any(:a) # (jsonb ?| a)
+      def contain_any(other)
+        bool_op(CONTAIN_ANY, wrap_input_array(other))
+      end
+
+      # Check if the receiver contains all entries in the other jsonb:
+      #
+      #   jsonb_op.contains(:h) # (jsonb @> h)
+      def contains(other)
+        bool_op(CONTAINS, wrap_input_jsonb(other))
+      end
+
+      # Check if the other jsonb contains all entries in the receiver:
+      #
+      #   jsonb_op.contained_by(:h) # (jsonb <@ h)
+      def contained_by(other)
+        bool_op(CONTAINED_BY, wrap_input_jsonb(other))
+      end
+
+      # Check if the receiver contains the given key:
+      #
+      #   jsonb_op.has_key?('a') # (jsonb ? 'a')
+      def has_key?(key)
+        bool_op(HAS_KEY, key)
+      end
+      alias include? has_key?
+
+      # Return the receiver, since it is already a JSONBOp.
+      def pg_jsonb
+        self
+      end
+
+      private
+
+      # Return a placeholder literal with the given str and args, wrapped
+      # in a boolean expression, used by operators that return booleans.
+      def bool_op(str, other)
+        Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(str, [value, other]))
+      end
+
+      # Wrap argument in a PGArray if it is an array
+      def wrap_input_array(obj)
+        if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
+          Sequel.pg_array(obj)
+        else
+          obj
+        end
+      end
+
+      # Wrap argument in a JSONBArray or JSONBHash if it is an array or hash.
+      def wrap_input_jsonb(obj)
+        if Sequel.respond_to?(:pg_jsonb) && (obj.is_a?(Array) || obj.is_a?(Hash))
+          Sequel.pg_jsonb(obj)
+        else
+          obj
+        end
+      end
+
+      # The jsonb type functions are prefixed with jsonb_
+      def function_name(name)
+        "jsonb_#{name}"
+      end
+    end
+
     module JSONOpMethods
       # Wrap the receiver in an JSONOp so you can easily use the PostgreSQL
       # json functions and operators with it.
       def pg_json
         JSONOp.new(self)
       end
+      #
+      # Wrap the receiver in an JSONBOp so you can easily use the PostgreSQL
+      # jsonb functions and operators with it.
+      def pg_jsonb
+        JSONBOp.new(self)
+      end
     end
 
     if defined?(JSONArray)
       class JSONArray
-        # Wrap the JSONHash instance in an JSONOp, allowing you to easily use
+        # Wrap the JSONArray instance in an JSONOp, allowing you to easily use
         # the PostgreSQL json functions and operators with literal jsons.
         def op
           JSONOp.new(self)
@@ -224,6 +366,22 @@ module Sequel
           JSONOp.new(self)
         end
       end
+
+      class JSONBArray
+        # Wrap the JSONBArray instance in an JSONBOp, allowing you to easily use
+        # the PostgreSQL jsonb functions and operators with literal jsonbs.
+        def op
+          JSONBOp.new(self)
+        end
+      end
+
+      class JSONBHash
+        # Wrap the JSONBHash instance in an JSONBOp, allowing you to easily use
+        # the PostgreSQL jsonb functions and operators with literal jsonbs.
+        def op
+          JSONBOp.new(self)
+        end
+      end
     end
   end
 
@@ -237,6 +395,16 @@ module Sequel
         Postgres::JSONOp.new(v)
       end
     end
+
+    # Return the object wrapped in an Postgres::JSONBOp.
+    def pg_jsonb_op(v)
+      case v
+      when Postgres::JSONBOp
+        v
+      else
+        Postgres::JSONBOp.new(v)
+      end
+    end
   end
 
   class SQL::GenericExpression