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 SQL::IsDistinctFrom::Methods

#is_distinct_from

Methods included from SQLite::JSONOpMethods

#sqlite_json_op

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



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

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

#[](key) ⇒ Object

Support subscript syntax for JSONB.



349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 349

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)



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

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)



385
386
387
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 385

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)



392
393
394
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 392

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)



406
407
408
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 406

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)



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

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)



413
414
415
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 413

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) 


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

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)



431
432
433
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 431

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



438
439
440
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 438

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)



452
453
454
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 452

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.



457
458
459
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 457

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



465
466
467
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 465

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)



480
481
482
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 480

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.



485
486
487
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 485

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)



500
501
502
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 500

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)



520
521
522
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 520

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.



525
526
527
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 525

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)



540
541
542
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 540

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.



545
546
547
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 545

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.



505
506
507
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 505

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.



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

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)



557
558
559
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 557

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)



567
568
569
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 567

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



573
574
575
 
# File 'lib/sequel/extensions/pg_json_ops.rb', line 573

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