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, line 369
def -(other)
  self.class.new(super)
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, line 348
def [](key)
  if is_array?(key)
    super
  else
    case @value
    when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, JSONBSubscriptOp
      # Only use subscripts for identifiers.  In other cases, switching from
      # the -> operator to [] for subscripts causes SQL syntax issues.  You
      # only need the [] for subscripting when doing assignment, and
      # assignment is generally done on identifiers.
      self.class.new(JSONBSubscriptOp.new(self, key))
    else
      super
    end
  end
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, line 377
def concat(other)
  json_op(CONCAT, wrap_input_jsonb(other))
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, line 384
def contain_all(other)
  bool_op(CONTAIN_ALL, wrap_input_array(other))
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, line 391
def contain_any(other)
  bool_op(CONTAIN_ANY, wrap_input_array(other))
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, line 405
def contained_by(other)
  bool_op(CONTAINED_BY, wrap_input_jsonb(other))
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, line 398
def contains(other)
  bool_op(CONTAINS, wrap_input_jsonb(other))
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, line 412
def delete_path(other)
  json_op(DELETE_PATH, wrap_input_array(other))
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, line 419
def has_key?(key)
  bool_op(HAS_KEY, key)
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, line 430
def insert(path, other, insert_after=false)
  self.class.new(function(:insert, wrap_input_array(path), wrap_input_jsonb(other), insert_after))
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, line 437
def path_exists(path)
  bool_op(PATH_EXISTS, path)
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, line 451
def path_exists!(path, vars=nil, silent=nil)
  Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists, path, vars, silent))
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, line 456
def path_exists_tz!(path, vars=nil, silent=nil)
  Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists_tz, path, vars, silent))
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, line 464
def path_match(path)
  bool_op(PATH_MATCH, path)
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, line 479
def path_match!(path, vars=nil, silent=nil)
  Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match, path, vars, silent))
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, line 484
def path_match_tz!(path, vars=nil, silent=nil)
  Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match_tz, path, vars, silent))
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, line 499
def path_query(path, vars=nil, silent=nil)
  _path_function(:jsonb_path_query, path, vars, silent)
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, line 519
def path_query_array(path, vars=nil, silent=nil)
  JSONBOp.new(_path_function(:jsonb_path_query_array, path, vars, silent))
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, line 524
def path_query_array_tz(path, vars=nil, silent=nil)
  JSONBOp.new(_path_function(:jsonb_path_query_array_tz, path, vars, silent))
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, line 539
def path_query_first(path, vars=nil, silent=nil)
  JSONBOp.new(_path_function(:jsonb_path_query_first, path, vars, silent))
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, line 544
def path_query_first_tz(path, vars=nil, silent=nil)
  JSONBOp.new(_path_function(:jsonb_path_query_first_tz, path, vars, silent))
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, line 504
def path_query_tz(path, vars=nil, silent=nil)
  _path_function(:jsonb_path_query_tz, path, vars, silent)
end

pg_jsonb() click to toggle source

Return the receiver, since it is already a JSONBOp.

# File lib/sequel/extensions/pg_json_ops.rb, line 549
def pg_jsonb
  self
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, line 556
def pretty
  Sequel::SQL::StringExpression.new(:NOOP, function(:pretty))
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, line 566
def set(path, other, create_missing=true)
  self.class.new(function(:set, wrap_input_array(path), wrap_input_jsonb(other), create_missing))
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, line 572
def set_lax(path, other, create_missing=true, null_value_treatment='use_json_null')
  self.class.new(function(:set_lax, wrap_input_array(path), wrap_input_jsonb(other), create_missing, null_value_treatment))
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, line 579
def _path_function(func, path, vars, silent)
  args = []
  if vars
    if vars.is_a?(Hash)
      vars = vars.to_json
    end
    args << vars

    unless silent.nil?
      args << silent
    end
  end
  SQL::Function.new(func, self, path, *args)
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, line 596
def bool_op(str, other)
  Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(str, [value, other]))
end

function_name(name) click to toggle source

The jsonb type functions are prefixed with jsonb_

# File lib/sequel/extensions/pg_json_ops.rb, line 619
def function_name(name)
  "jsonb_#{name}"
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, line 601
def wrap_input_array(obj)
  if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
    Sequel.pg_array(obj)
  else
    obj
  end
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, line 610
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