class Sequel::Postgres::PGRange

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

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
337 def self.empty(db_type=nil)
338   new(nil, nil, :empty=>true, :db_type=>db_type)
339 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
332 def self.from_range(range, db_type=nil)
333   new(range.begin, range.end, :exclude_end=>range.exclude_end?, :db_type=>db_type)
334 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
347 def initialize(beg, en, opts=OPTS)
348   @begin = beg
349   @end = en
350   @empty = !!opts[:empty]
351   @exclude_begin = !!opts[:exclude_begin]
352   @exclude_end = !!opts[:exclude_end]
353   @db_type = opts[:db_type]
354   if @empty
355     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?
356   end
357 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
408 def ===(other)
409   if eql?(other)
410     true
411   else
412     if valid_ruby_range?
413       to_range === other 
414     else
415       false
416     end
417   end
418 end
cover? (value)

Return whether the value is inside the range.

[show source]
    # File lib/sequel/extensions/pg_range.rb
366 def cover?(value)
367   return false if empty?
368   b = self.begin
369   return false if b && b.public_send(exclude_begin? ? :>= : :>, value)
370   e = self.end
371   return false if e && e.public_send(exclude_end? ? :<= : :<, value)
372   true
373 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
423 def empty?
424   @empty
425 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
379 def eql?(other)
380   case other
381   when PGRange
382     if db_type == other.db_type
383       if empty?
384         other.empty?
385       elsif other.empty?
386         false
387       else
388         [:@begin, :@end, :@exclude_begin, :@exclude_end].all?{|v| instance_variable_get(v) == other.instance_variable_get(v)}
389       end
390     else
391       false
392     end
393   when Range
394     if valid_ruby_range?
395       to_range.eql?(other)
396     else
397       false
398     end
399   else
400     false
401   end
402 end
exclude_begin? ()

Whether the beginning element is excluded from the range.

[show source]
    # File lib/sequel/extensions/pg_range.rb
428 def exclude_begin?
429   @exclude_begin
430 end
exclude_end? ()

Whether the ending element is excluded from the range.

[show source]
    # File lib/sequel/extensions/pg_range.rb
433 def exclude_end?
434   @exclude_end
435 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
123 def op
124   RangeOp.new(self)
125 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
438 def sql_literal_append(ds, sql)
439   if (s = @db_type) && !empty?
440     sql << s.to_s << "("
441     ds.literal_append(sql, self.begin)
442     sql << ','
443     ds.literal_append(sql, self.end)
444     sql << ','
445     ds.literal_append(sql, "#{exclude_begin? ? "(" : "["}#{exclude_end? ? ")" : "]"}")
446     sql << ")"
447   else
448     ds.literal_append(sql, unquoted_literal(ds))
449     if s
450       sql << '::' << s.to_s
451     end
452   end
453 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
459 def to_range
460   return @range if @range
461   raise(Error, "cannot create ruby range for an empty PostgreSQL range") if empty?
462   raise(Error, "cannot create ruby range when PostgreSQL range excludes beginning element") if exclude_begin?
463   raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") if STARTLESS_RANGE_NOT_SUPPORTED && !self.begin
464   raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") if ENDLESS_RANGE_NOT_SUPPORTED && !self.end
465   @range = Range.new(self.begin, self.end, exclude_end?)
466 end
unbounded_begin? ()

Whether the beginning of the range is unbounded.

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

Whether the end of the range is unbounded.

[show source]
    # File lib/sequel/extensions/pg_range.rb
481 def unbounded_end?
482   self.end.nil? && !empty?
483 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
487 def unquoted_literal(ds)
488   if empty?
489     'empty'
490   else
491     "#{exclude_begin? ? "(" : "["}#{escape_value(self.begin, ds)},#{escape_value(self.end, ds)}#{exclude_end? ? ")" : "]"}"
492   end
493 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
471 def valid_ruby_range?
472   !(empty? || exclude_begin? || (STARTLESS_RANGE_NOT_SUPPORTED && !self.begin) || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end))
473 end