class Sequel::Postgres::PGRange

:nocov:

Constants

ENDLESS_RANGE_NOT_SUPPORTED
STARTLESS_RANGE_NOT_SUPPORTED

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) click to toggle source

Create an empty PGRange with the given database type.

    # File lib/sequel/extensions/pg_range.rb
325 def self.empty(db_type=nil)
326   new(nil, nil, :empty=>true, :db_type=>db_type)
327 end
from_range(range, db_type=nil) click to toggle source

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

    # File lib/sequel/extensions/pg_range.rb
320 def self.from_range(range, db_type=nil)
321   new(range.begin, range.end, :exclude_end=>range.exclude_end?, :db_type=>db_type)
322 end
new(beg, en, opts=OPTS) click to toggle source

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.

    # File lib/sequel/extensions/pg_range.rb
335 def initialize(beg, en, opts=OPTS)
336   @begin = beg
337   @end = en
338   @empty = !!opts[:empty]
339   @exclude_begin = !!opts[:exclude_begin]
340   @exclude_end = !!opts[:exclude_end]
341   @db_type = opts[:db_type]
342   if @empty
343     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?
344   end
345 end

Public Instance Methods

==(other)
Alias for: eql?
===(other) click to toggle source

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.

    # File lib/sequel/extensions/pg_range.rb
405 def ===(other)
406   if eql?(other)
407     true
408   else
409     if valid_ruby_range?
410       to_range === other 
411     else
412       false
413     end
414   end
415 end
cover?(value) click to toggle source

Return whether the value is inside the range.

    # File lib/sequel/extensions/pg_range.rb
354 def cover?(value)
355   return false if empty?
356   b = self.begin
357   return false if b && b.public_send(exclude_begin? ? :>= : :>, value)
358   e = self.end
359   return false if e && e.public_send(exclude_end? ? :<= : :<, value)
360   true
361 end
empty?() click to toggle source

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.

    # File lib/sequel/extensions/pg_range.rb
420 def empty?
421   @empty
422 end
eql?(other) click to toggle source

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.

    # File lib/sequel/extensions/pg_range.rb
367 def eql?(other)
368   case other
369   when PGRange
370     if db_type == other.db_type
371       if empty?
372         other.empty?
373       elsif other.empty?
374         false
375       else
376         [:@begin, :@end, :@exclude_begin, :@exclude_end].all?{|v| instance_variable_get(v) == other.instance_variable_get(v)}
377       end
378     else
379       false
380     end
381   when Range
382     if valid_ruby_range?
383       to_range.eql?(other)
384     else
385       false
386     end
387   else
388     false
389   end
390 end
Also aliased as: ==
exclude_begin?() click to toggle source

Whether the beginning element is excluded from the range.

    # File lib/sequel/extensions/pg_range.rb
425 def exclude_begin?
426   @exclude_begin
427 end
exclude_end?() click to toggle source

Whether the ending element is excluded from the range.

    # File lib/sequel/extensions/pg_range.rb
430 def exclude_end?
431   @exclude_end
432 end
hash() click to toggle source

Make sure equal ranges have the same hash.

    # File lib/sequel/extensions/pg_range.rb
394 def hash
395   if @empty
396     @db_type.hash
397   else
398     [@begin, @end, @exclude_begin, @exclude_end, @db_type].hash
399   end
400 end
op() click to toggle source

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

    # File lib/sequel/extensions/pg_range_ops.rb
141 def op
142   RangeOp.new(self)
143 end
sql_literal_append(ds, sql) click to toggle source

Append a literalize version of the receiver to the sql.

    # File lib/sequel/extensions/pg_range.rb
435 def sql_literal_append(ds, sql)
436   if (s = @db_type) && !empty?
437     sql << s.to_s << "("
438     ds.literal_append(sql, self.begin)
439     sql << ','
440     ds.literal_append(sql, self.end)
441     sql << ','
442     ds.literal_append(sql, "#{exclude_begin? ? "(" : "["}#{exclude_end? ? ")" : "]"}")
443     sql << ")"
444   else
445     ds.literal_append(sql, unquoted_literal(ds))
446     if s
447       sql << '::' << s.to_s
448     end
449   end
450 end
to_range() click to toggle source

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

    # File lib/sequel/extensions/pg_range.rb
456 def to_range
457   return @range if @range
458   raise(Error, "cannot create ruby range for an empty PostgreSQL range") if empty?
459   raise(Error, "cannot create ruby range when PostgreSQL range excludes beginning element") if exclude_begin?
460   # :nocov:
461   raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") if STARTLESS_RANGE_NOT_SUPPORTED && !self.begin
462   raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") if ENDLESS_RANGE_NOT_SUPPORTED && !self.end
463   # :nocov:
464   @range = Range.new(self.begin, self.end, exclude_end?)
465 end
unbounded_begin?() click to toggle source

Whether the beginning of the range is unbounded.

    # File lib/sequel/extensions/pg_range.rb
475 def unbounded_begin?
476   self.begin.nil? && !empty?
477 end
unbounded_end?() click to toggle source

Whether the end of the range is unbounded.

    # File lib/sequel/extensions/pg_range.rb
480 def unbounded_end?
481   self.end.nil? && !empty?
482 end
unquoted_literal(ds) click to toggle source

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

    # File lib/sequel/extensions/pg_range.rb
486 def unquoted_literal(ds)
487   if empty?
488     'empty'
489   else
490     "#{exclude_begin? ? "(" : "["}#{escape_value(self.begin, ds)},#{escape_value(self.end, ds)}#{exclude_end? ? ")" : "]"}"
491   end
492 end
valid_ruby_range?() click to toggle source

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.

    # File lib/sequel/extensions/pg_range.rb
470 def valid_ruby_range?
471   !(empty? || exclude_begin? || (STARTLESS_RANGE_NOT_SUPPORTED && !self.begin) || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end))
472 end

Private Instance Methods

escape_value(k, ds) click to toggle source

Escape common range types. Instead of quoting, just backslash escape all special characters.

    # File lib/sequel/extensions/pg_range.rb
498 def escape_value(k, ds)
499   case k
500   when nil
501     ''
502   when Date, Time
503     ds.literal(k)[1...-1]
504   when Integer, Float
505     k.to_s
506   when BigDecimal
507     k.to_s('F')
508   when LiteralString
509     k
510   when String
511     if k.empty?
512       '""'
513     else
514       k.gsub(/("|,|\\|\[|\]|\(|\))/, '\\\\\1')
515     end
516   else
517     ds.literal(k).gsub(/("|,|\\|\[|\]|\(|\))/, '\\\\\1')
518   end
519 end