Class: Sequel::Postgres::JSONBOp

Inherits:
JSONBaseOp show all
Defined in:
lib/sequel/extensions/pg_json_ops.rb

Overview

JSONBaseOp subclass for the jsonb type.

In the method documentation examples, assume that:

jsonb_op = Sequel.pg_jsonb(:jsonb)

Constant Summary collapse

CONCAT = 
["(".freeze, " || ".freeze, ")".freeze].freeze
CONTAIN_ALL = 
["(".freeze, " ?& ".freeze, ")".freeze].freeze
CONTAIN_ANY = 
["(".freeze, " ?| ".freeze, ")".freeze].freeze
CONTAINS = 
["(".freeze, " @> ".freeze, ")".freeze].freeze
CONTAINED_BY = 
["(".freeze, " <@ ".freeze, ")".freeze].freeze
DELETE_PATH = 
["(".freeze, " #- ".freeze, ")".freeze].freeze
HAS_KEY = 
["(".freeze, " ? ".freeze, ")".freeze].freeze
PATH_EXISTS = 
["(".freeze, " @? ".freeze, ")".freeze].freeze
PATH_MATCH = 
["(".freeze, " @@ ".freeze, ")".freeze].freeze

Constants inherited from JSONBaseOp

Sequel::Postgres::JSONBaseOp::GET, Sequel::Postgres::JSONBaseOp::GET_PATH, Sequel::Postgres::JSONBaseOp::GET_PATH_TEXT, Sequel::Postgres::JSONBaseOp::GET_TEXT

Instance Attribute Summary

Attributes inherited from SQL::Wrapper

#value

Instance Method Summary collapse

Methods inherited from JSONBaseOp

#array_elements, #array_elements_text, #array_length, #each, #each_text, #extract, #extract_text, #get_text, #keys, #populate, #populate_set, #strip_nulls, #to_record, #to_recordset, #typeof

Methods inherited from SQL::Wrapper

#initialize

Methods included from HStoreOpMethods

#hstore

Methods included from RangeOpMethods

#pg_range

Methods included from ArrayOpMethods

#pg_array

Methods included from JSONOpMethods

#pg_json

Methods included from InetOpMethods

#pg_inet

Methods included from PGRowOp::ExpressionMethods

#pg_row

Methods included from SQL::SubscriptMethods

#sql_subscript

Methods included from SQL::StringMethods

#escaped_ilike, #escaped_like, #ilike, #like

Methods included from SQL::PatternMatchMethods

#!~, #=~

Methods included from SQL::OrderMethods

#asc, #desc

Methods included from SQL::NumericMethods

#+, #coerce

Methods included from SQL::ComplexExpressionMethods

#extract, #sql_boolean, #sql_number, #sql_string

Methods included from SQL::CastMethods

#cast, #cast_numeric, #cast_string

Methods included from SQL::BooleanMethods

#~

Methods included from SQL::AliasMethods

#as

Methods inherited from SQL::Expression

#==, attr_reader, #clone, #eql?, #hash, inherited, #inspect

Constructor Details

This class inherits a constructor from Sequel::SQL::Wrapper

Instance Method Details

#-(other) ⇒ Object

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

jsonb_op - "a" # (jsonb - 'a')



369
370
371
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 369

def -(other)
  self.class.new(super)
end

#[](key) ⇒ Object

Support subscript syntax for JSONB.



348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
 
# 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) ⇒ Object

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

jsonb_op.concat(:h) # (jsonb || h)



377
378
379
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 377

def concat(other)
  json_op(CONCAT, wrap_input_jsonb(other))
end

#contain_all(other) ⇒ Object

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

jsonb_op.contain_all(:a) # (jsonb ?& a)



384
385
386
 
# 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) ⇒ Object

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

jsonb_op.contain_any(:a) # (jsonb ?| a)



391
392
393
 
# 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) ⇒ Object

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

jsonb_op.contained_by(:h) # (jsonb <@ h)



405
406
407
 
# 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) ⇒ Object

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

jsonb_op.contains(:h) # (jsonb @> h)



398
399
400
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 398

def contains(other)
  bool_op(CONTAINS, wrap_input_jsonb(other))
end

#delete_path(other) ⇒ Object

Removes the given path from the receiver.

jsonb_op.delete_path(:h) # (jsonb #- h)



412
413
414
 
# 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) ⇒ Boolean Also known as: include?

Check if the receiver contains the given key:

jsonb_op.has_key?('a') # (jsonb ? 'a')

Returns:

  • (Boolean) 


419
420
421
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 419

def has_key?(key)
  bool_op(HAS_KEY, key)
end

#insert(path, other, insert_after = false) ⇒ Object

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)



430
431
432
 
# 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) ⇒ Object

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

json_op.path_exists("$.foo") # (json @? '$.foo')



437
438
439
 
# 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) ⇒ Object

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)



451
452
453
 
# 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) ⇒ Object

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



456
457
458
 
# 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) ⇒ Object

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')



464
465
466
 
# 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) ⇒ Object

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)



479
480
481
 
# 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) ⇒ Object

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



484
485
486
 
# 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) ⇒ Object

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)



499
500
501
 
# 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) ⇒ Object

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)



519
520
521
 
# 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) ⇒ Object

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



524
525
526
 
# 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) ⇒ Object

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)



539
540
541
 
# 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) ⇒ Object

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



544
545
546
 
# 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) ⇒ Object

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



504
505
506
 
# 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 ⇒ Object

Return the receiver, since it is already a JSONBOp.



549
550
551
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 549

def pg_jsonb
  self
end

#pretty ⇒ Object

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

jsonb_op.pretty # jsonb_pretty(jsonb)



556
557
558
 
# 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) ⇒ Object

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)



566
567
568
 
# 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') ⇒ Object

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’.



572
573
574
 
# 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