class Sequel::Postgres::PGRange

  1. lib/sequel/extensions/pg_range.rb
  2. lib/sequel/extensions/pg_range_ops.rb
  3. show all
Superclass: Object

:nocov:

Included modules

  1. Sequel::SQL::AliasMethods
  2. Enumerable

Constants

ENDLESS_RANGE_NOT_SUPPORTED = RUBY_VERSION < '2.6'  
STARTLESS_RANGE_NOT_SUPPORTED = RUBY_VERSION < '2.7'  

Public Instance Aliases

== -> eql?

Attributes

begin [R]

The beginning of the range. If nil, the range has an unbounded beginning.
db_type [R]

The PostgreSQL database type for the range (e.g. ‘int4range’).
end [R]

The end of the range. If nil, the range has an unbounded ending.

Public Class methods

empty(db_type=nil)

Create an empty PGRange with the given database type.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
315 def self.empty(db_type=nil)
316   new(nil, nil, :empty=>true, :db_type=>db_type)
317 end
from_range(range, db_type=nil)

Create a new PGRange instance using the beginning and ending of the ruby Range, with the given db_type.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
310 def self.from_range(range, db_type=nil)
311   new(range.begin, range.end, :exclude_end=>range.exclude_end?, :db_type=>db_type)
312 end
new(beg, en, opts=OPTS)

Initialize a new PGRange instance. Accepts the following options:

:db_type

The PostgreSQL database type for the range.

:empty

Whether the range is empty (has no points)

:exclude_begin

Whether the beginning element is excluded from the range.

:exclude_end

Whether the ending element is excluded from the range.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
325 def initialize(beg, en, opts=OPTS)
326   @begin = beg
327   @end = en
328   @empty = !!opts[:empty]
329   @exclude_begin = !!opts[:exclude_begin]
330   @exclude_end = !!opts[:exclude_end]
331   @db_type = opts[:db_type]
332   if @empty
333     raise(Error, 'cannot have an empty range with either a beginning or ending') unless @begin.nil? && @end.nil? && opts[:exclude_begin].nil? && opts[:exclude_end].nil?
334   end
335 end

Public Instance methods

===(other)

Allow PGRange values in case statements, where they return true if they are equal to each other using eql?, or if this PGRange can be converted to a Range, delegating to that range.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
395 def ===(other)
396   if eql?(other)
397     true
398   else
399     if valid_ruby_range?
400       to_range === other 
401     else
402       false
403     end
404   end
405 end
cover?(value)

Return whether the value is inside the range.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
344 def cover?(value)
345   return false if empty?
346   b = self.begin
347   return false if b && b.public_send(exclude_begin? ? :>= : :>, value)
348   e = self.end
349   return false if e && e.public_send(exclude_end? ? :<= : :<, value)
350   true
351 end
empty?()

Whether this range is empty (has no points). Note that for manually created ranges (ones not retrieved from the database), this will only be true if the range was created using the :empty option.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
410 def empty?
411   @empty
412 end
eql?(other)

Consider the receiver equal to other PGRange instances with the same beginning, ending, exclusions, and database type. Also consider it equal to Range instances if this PGRange can be converted to a a Range and those ranges are equal.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
357 def eql?(other)
358   case other
359   when PGRange
360     if db_type == other.db_type
361       if empty?
362         other.empty?
363       elsif other.empty?
364         false
365       else
366         [:@begin, :@end, :@exclude_begin, :@exclude_end].all?{|v| instance_variable_get(v) == other.instance_variable_get(v)}
367       end
368     else
369       false
370     end
371   when Range
372     if valid_ruby_range?
373       to_range.eql?(other)
374     else
375       false
376     end
377   else
378     false
379   end
380 end
exclude_begin?()

Whether the beginning element is excluded from the range.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
415 def exclude_begin?
416   @exclude_begin
417 end
exclude_end?()

Whether the ending element is excluded from the range.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
420 def exclude_end?
421   @exclude_end
422 end
hash()

Make sure equal ranges have the same hash.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
384 def hash
385   if @empty
386     @db_type.hash
387   else
388     [@begin, @end, @exclude_begin, @exclude_end, @db_type].hash
389   end
390 end
op()

Wrap the PGRange instance in an RangeOp, allowing you to easily use the PostgreSQL range functions and operators with literal ranges.

[show source] 
    # File lib/sequel/extensions/pg_range_ops.rb
141 def op
142   RangeOp.new(self)
143 end
sequel_auto_param_type(ds)

Allow automatic parameterization for ranges with types.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
485 def sequel_auto_param_type(ds)
486   "::#{db_type}" if db_type
487 end
sql_literal_append(ds, sql)

Append a literalize version of the receiver to the sql.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
425 def sql_literal_append(ds, sql)
426   if (s = @db_type) && !empty?
427     sql << s.to_s << "("
428     ds.literal_append(sql, self.begin)
429     sql << ','
430     ds.literal_append(sql, self.end)
431     sql << ','
432     ds.literal_append(sql, "#{exclude_begin? ? "(" : "["}#{exclude_end? ? ")" : "]"}")
433     sql << ")"
434   else
435     ds.literal_append(sql, unquoted_literal(ds))
436     if s
437       sql << '::' << s.to_s
438     end
439   end
440 end
to_range()

Return a ruby Range object for this instance, if one can be created.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
446 def to_range
447   return @range if @range
448   raise(Error, "cannot create ruby range for an empty PostgreSQL range") if empty?
449   raise(Error, "cannot create ruby range when PostgreSQL range excludes beginning element") if exclude_begin?
450   # :nocov:
451   raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") if STARTLESS_RANGE_NOT_SUPPORTED && !self.begin
452   raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") if ENDLESS_RANGE_NOT_SUPPORTED && !self.end
453   # :nocov:
454   @range = Range.new(self.begin, self.end, exclude_end?)
455 end
unbounded_begin?()

Whether the beginning of the range is unbounded.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
465 def unbounded_begin?
466   self.begin.nil? && !empty?
467 end
unbounded_end?()

Whether the end of the range is unbounded.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
470 def unbounded_end?
471   self.end.nil? && !empty?
472 end
unquoted_literal(ds)

Return a string containing the unescaped version of the range. Separated out for use by the bound argument code.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
476 def unquoted_literal(ds)
477   if empty?
478     'empty'
479   else
480     "#{exclude_begin? ? "(" : "["}#{escape_value(self.begin, ds)},#{escape_value(self.end, ds)}#{exclude_end? ? ")" : "]"}"
481   end
482 end
valid_ruby_range?()

Whether or not this PGRange is a valid ruby range. In order to be a valid ruby range, it must have a beginning and an ending (no unbounded ranges), and it cannot exclude the beginning element.

[show source] 
    # File lib/sequel/extensions/pg_range.rb
460 def valid_ruby_range?
461   !(empty? || exclude_begin? || (STARTLESS_RANGE_NOT_SUPPORTED && !self.begin) || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end))
462 end