class Sequel::Postgres::JSONBOp

JSONBaseOp subclass for the jsonb type.

In the method documentation examples, assume that:

jsonb_op = Sequel.pg_jsonb(:jsonb)

Constants

CONCAT
CONTAINED_BY
CONTAINS
CONTAIN_ALL
CONTAIN_ANY
DELETE_PATH
HAS_KEY
PATH_EXISTS
PATH_MATCH

Public Instance Methods

-(other) click to toggle source

jsonb expression for deletion of the given argument from the current jsonb.

jsonb_op - "a" # (jsonb - 'a')
Calls superclass method
    # File lib/sequel/extensions/pg_json_ops.rb
370 def -(other)
371   self.class.new(super)
372 end
[](key) click to toggle source

Support subscript syntax for JSONB.

Calls superclass method Sequel::Postgres::JSONBaseOp#[]
    # File lib/sequel/extensions/pg_json_ops.rb
349 def [](key)
350   if is_array?(key)
351     super
352   else
353     case @value
354     when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, JSONBSubscriptOp
355       # Only use subscripts for identifiers.  In other cases, switching from
356       # the -> operator to [] for subscripts causes SQL syntax issues.  You
357       # only need the [] for subscripting when doing assignment, and
358       # assignment is generally done on identifiers.
359       self.class.new(JSONBSubscriptOp.new(self, key))
360     else
361       super
362     end
363   end
364 end
concat(other) click to toggle source

jsonb expression for concatenation of the given jsonb into the current jsonb.

jsonb_op.concat(:h) # (jsonb || h)
    # File lib/sequel/extensions/pg_json_ops.rb
378 def concat(other)
379   json_op(CONCAT, wrap_input_jsonb(other))
380 end
contain_all(other) click to toggle source

Check if the receiver contains all of the keys in the given array:

jsonb_op.contain_all(:a) # (jsonb ?& a)
    # File lib/sequel/extensions/pg_json_ops.rb
385 def contain_all(other)
386   bool_op(CONTAIN_ALL, wrap_input_array(other))
387 end
contain_any(other) click to toggle source

Check if the receiver contains any of the keys in the given array:

jsonb_op.contain_any(:a) # (jsonb ?| a)
    # File lib/sequel/extensions/pg_json_ops.rb
392 def contain_any(other)
393   bool_op(CONTAIN_ANY, wrap_input_array(other))
394 end
contained_by(other) click to toggle source

Check if the other jsonb contains all entries in the receiver:

jsonb_op.contained_by(:h) # (jsonb <@ h)
    # File lib/sequel/extensions/pg_json_ops.rb
406 def contained_by(other)
407   bool_op(CONTAINED_BY, wrap_input_jsonb(other))
408 end
contains(other) click to toggle source

Check if the receiver contains all entries in the other jsonb:

jsonb_op.contains(:h) # (jsonb @> h)
    # File lib/sequel/extensions/pg_json_ops.rb
399 def contains(other)
400   bool_op(CONTAINS, wrap_input_jsonb(other))
401 end
delete_path(other) click to toggle source

Removes the given path from the receiver.

jsonb_op.delete_path(:h) # (jsonb #- h)
    # File lib/sequel/extensions/pg_json_ops.rb
413 def delete_path(other)
414   json_op(DELETE_PATH, wrap_input_array(other))
415 end
has_key?(key) click to toggle source

Check if the receiver contains the given key:

jsonb_op.has_key?('a') # (jsonb ? 'a')
    # File lib/sequel/extensions/pg_json_ops.rb
420 def has_key?(key)
421   bool_op(HAS_KEY, key)
422 end
Also aliased as: include?
include?(key)
Alias for: has_key?
insert(path, other, insert_after=false) click to toggle source

Inserts the given jsonb value at the given path in the receiver. The default is to insert the value before the given path, but insert_after can be set to true to insert it after the given path.

jsonb_op.insert(['a', 'b'], h) # jsonb_insert(jsonb, ARRAY['a', 'b'], h, false)
jsonb_op.insert(['a', 'b'], h, true) # jsonb_insert(jsonb, ARRAY['a', 'b'], h, true)
    # File lib/sequel/extensions/pg_json_ops.rb
431 def insert(path, other, insert_after=false)
432   self.class.new(function(:insert, wrap_input_array(path), wrap_input_jsonb(other), insert_after))
433 end
path_exists(path) click to toggle source

Returns whether the JSON path returns any item for the json object.

json_op.path_exists("$.foo") # (json @? '$.foo')
    # File lib/sequel/extensions/pg_json_ops.rb
438 def path_exists(path)
439   bool_op(PATH_EXISTS, path)
440 end
path_exists!(path, vars=nil, silent=nil) click to toggle source

Returns whether the JSON path returns any item for the json object.

json_op.path_exists!("$.foo")
# jsonb_path_exists(json, '$.foo')

json_op.path_exists!("$.foo ? ($ > $x)", x: 2)
# jsonb_path_exists(json, '$.foo ? ($ > $x)', '{"x":2}')

json_op.path_exists!("$.foo ? ($ > $x)", {x: 2}, true)
# jsonb_path_exists(json, '$.foo ? ($ > $x)', '{"x":2}', true)
    # File lib/sequel/extensions/pg_json_ops.rb
452 def path_exists!(path, vars=nil, silent=nil)
453   Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists, path, vars, silent))
454 end
path_exists_tz!(path, vars=nil, silent=nil) click to toggle source

The same as path_exists!, except that timezone-aware conversions are used for date/time values.

    # File lib/sequel/extensions/pg_json_ops.rb
457 def path_exists_tz!(path, vars=nil, silent=nil)
458   Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists_tz, path, vars, silent))
459 end
path_match(path) click to toggle source

Returns the first item of the result of JSON path predicate check for the json object. Returns nil if the first item is not true or false.

json_op.path_match("$.foo") # (json @@ '$.foo')
    # File lib/sequel/extensions/pg_json_ops.rb
465 def path_match(path)
466   bool_op(PATH_MATCH, path)
467 end
path_match!(path, vars=nil, silent=nil) click to toggle source

Returns the first item of the result of JSON path predicate check for the json object. Returns nil if the first item is not true or false and silent is true.

json_op.path_match!("$.foo")
# jsonb_path_match(json, '$.foo')

json_op.path_match!("$.foo ? ($ > $x)", x: 2)
# jsonb_path_match(json, '$.foo ? ($ > $x)', '{"x":2}')

json_op.path_match!("$.foo ? ($ > $x)", {x: 2}, true)
# jsonb_path_match(json, '$.foo ? ($ > $x)', '{"x":2}', true)
    # File lib/sequel/extensions/pg_json_ops.rb
480 def path_match!(path, vars=nil, silent=nil)
481   Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match, path, vars, silent))
482 end
path_match_tz!(path, vars=nil, silent=nil) click to toggle source

The same as path_match!, except that timezone-aware conversions are used for date/time values.

    # File lib/sequel/extensions/pg_json_ops.rb
485 def path_match_tz!(path, vars=nil, silent=nil)
486   Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match_tz, path, vars, silent))
487 end
path_query(path, vars=nil, silent=nil) click to toggle source

Returns a set of all jsonb values specified by the JSON path for the json object.

json_op.path_query("$.foo")
# jsonb_path_query(json, '$.foo')

json_op.path_query("$.foo ? ($ > $x)", x: 2)
# jsonb_path_query(json, '$.foo ? ($ > $x)', '{"x":2}')

json_op.path_query("$.foo ? ($ > $x)", {x: 2}, true)
# jsonb_path_query(json, '$.foo ? ($ > $x)', '{"x":2}', true)
    # File lib/sequel/extensions/pg_json_ops.rb
500 def path_query(path, vars=nil, silent=nil)
501   _path_function(:jsonb_path_query, path, vars, silent)
502 end
path_query_array(path, vars=nil, silent=nil) click to toggle source

Returns a jsonb array of all values specified by the JSON path for the json object.

json_op.path_query_array("$.foo")
# jsonb_path_query_array(json, '$.foo')

json_op.path_query_array("$.foo ? ($ > $x)", x: 2)
# jsonb_path_query_array(json, '$.foo ? ($ > $x)', '{"x":2}')

json_op.path_query_array("$.foo ? ($ > $x)", {x: 2}, true)
# jsonb_path_query_array(json, '$.foo ? ($ > $x)', '{"x":2}', true)
    # File lib/sequel/extensions/pg_json_ops.rb
520 def path_query_array(path, vars=nil, silent=nil)
521   JSONBOp.new(_path_function(:jsonb_path_query_array, path, vars, silent))
522 end
path_query_array_tz(path, vars=nil, silent=nil) click to toggle source

The same as path_query_array, except that timezone-aware conversions are used for date/time values.

    # File lib/sequel/extensions/pg_json_ops.rb
525 def path_query_array_tz(path, vars=nil, silent=nil)
526   JSONBOp.new(_path_function(:jsonb_path_query_array_tz, path, vars, silent))
527 end
path_query_first(path, vars=nil, silent=nil) click to toggle source

Returns the first item of the result specified by the JSON path for the json object.

json_op.path_query_first("$.foo")
# jsonb_path_query_first(json, '$.foo')

json_op.path_query_first("$.foo ? ($ > $x)", x: 2)
# jsonb_path_query_first(json, '$.foo ? ($ > $x)', '{"x":2}')

json_op.path_query_first("$.foo ? ($ > $x)", {x: 2}, true)
# jsonb_path_query_first(json, '$.foo ? ($ > $x)', '{"x":2}', true)
    # File lib/sequel/extensions/pg_json_ops.rb
540 def path_query_first(path, vars=nil, silent=nil)
541   JSONBOp.new(_path_function(:jsonb_path_query_first, path, vars, silent))
542 end
path_query_first_tz(path, vars=nil, silent=nil) click to toggle source

The same as path_query_first, except that timezone-aware conversions are used for date/time values.

    # File lib/sequel/extensions/pg_json_ops.rb
545 def path_query_first_tz(path, vars=nil, silent=nil)
546   JSONBOp.new(_path_function(:jsonb_path_query_first_tz, path, vars, silent))
547 end
path_query_tz(path, vars=nil, silent=nil) click to toggle source

The same as path_query, except that timezone-aware conversions are used for date/time values.

    # File lib/sequel/extensions/pg_json_ops.rb
505 def path_query_tz(path, vars=nil, silent=nil)
506   _path_function(:jsonb_path_query_tz, path, vars, silent)
507 end
pg_jsonb() click to toggle source

Return the receiver, since it is already a JSONBOp.

    # File lib/sequel/extensions/pg_json_ops.rb
550 def pg_jsonb
551   self
552 end
pretty() click to toggle source

Return a pretty printed version of the receiver as a string expression.

jsonb_op.pretty # jsonb_pretty(jsonb)
    # File lib/sequel/extensions/pg_json_ops.rb
557 def pretty
558   Sequel::SQL::StringExpression.new(:NOOP, function(:pretty))
559 end
set(path, other, create_missing=true) click to toggle source

Set the given jsonb value at the given path in the receiver. By default, this will create the value if it does not exist, but create_missing can be set to false to not create a new value.

jsonb_op.set(['a', 'b'], h) # jsonb_set(jsonb, ARRAY['a', 'b'], h, true)
jsonb_op.set(['a', 'b'], h, false) # jsonb_set(jsonb, ARRAY['a', 'b'], h, false)
    # File lib/sequel/extensions/pg_json_ops.rb
567 def set(path, other, create_missing=true)
568   self.class.new(function(:set, wrap_input_array(path), wrap_input_jsonb(other), create_missing))
569 end
set_lax(path, other, create_missing=true, null_value_treatment='use_json_null') click to toggle source

The same as set, except if other is nil, then behaves according to null_value_treatment, which can be one of ‘raise_exception’, ‘use_json_null’ (default), ‘delete_key’, or ‘return_target’.

    # File lib/sequel/extensions/pg_json_ops.rb
573 def set_lax(path, other, create_missing=true, null_value_treatment='use_json_null')
574   self.class.new(function(:set_lax, wrap_input_array(path), wrap_input_jsonb(other), create_missing, null_value_treatment))
575 end

Private Instance Methods

_path_function(func, path, vars, silent) click to toggle source

Internals of the jsonb SQL/JSON path functions.

    # File lib/sequel/extensions/pg_json_ops.rb
580 def _path_function(func, path, vars, silent)
581   args = []
582   if vars
583     if vars.is_a?(Hash)
584       vars = vars.to_json
585     end
586     args << vars
587 
588     unless silent.nil?
589       args << silent
590     end
591   end
592   SQL::Function.new(func, self, path, *args)
593 end
bool_op(str, other) click to toggle source

Return a placeholder literal with the given str and args, wrapped in a boolean expression, used by operators that return booleans.

    # File lib/sequel/extensions/pg_json_ops.rb
597 def bool_op(str, other)
598   Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(str, [value, other]))
599 end
function_name(name) click to toggle source

The jsonb type functions are prefixed with jsonb_

    # File lib/sequel/extensions/pg_json_ops.rb
620 def function_name(name)
621   "jsonb_#{name}"
622 end
wrap_input_array(obj) click to toggle source

Wrap argument in a PGArray if it is an array

    # File lib/sequel/extensions/pg_json_ops.rb
602 def wrap_input_array(obj)
603   if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
604     Sequel.pg_array(obj)
605   else
606     obj
607   end
608 end
wrap_input_jsonb(obj) click to toggle source

Wrap argument in a JSONBArray or JSONBHash if it is an array or hash.

    # File lib/sequel/extensions/pg_json_ops.rb
611 def wrap_input_jsonb(obj)
612   if Sequel.respond_to?(:pg_jsonb) && (obj.is_a?(Array) || obj.is_a?(Hash))
613     Sequel.pg_jsonb(obj)
614   else
615     obj
616   end
617 end