Class: Sequel::Postgres::PGRange

Classes and Modules

Module Sequel::Postgres::PGRange::DatabaseMethods
Module Sequel::Postgres::PGRange::DatasetMethods
Class Sequel::Postgres::PGRange::Parser

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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 337
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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 332
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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 347
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)

Alias for eql?

===(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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 408
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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 366
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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 423
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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 379
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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 428
428:       def exclude_begin?
429:         @exclude_begin
430:       end

exclude_end?()

Whether the ending element is excluded from the range.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 433
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.

[Source]

     # File lib/sequel/extensions/pg_range_ops.rb, line 123
123:         def op
124:           RangeOp.new(self)
125:         end

sql_literal_append(ds, sql)

Append a literalize version of the receiver to the sql.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 438
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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 456
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:         raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") unless self.begin
461:         raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") unless self.end
462:         @range = Range.new(self.begin, self.end, exclude_end?)
463:       end

unbounded_begin?()

Whether the beginning of the range is unbounded.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 473
473:       def unbounded_begin?
474:         self.begin.nil? && !empty?
475:       end

unbounded_end?()

Whether the end of the range is unbounded.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 478
478:       def unbounded_end?
479:         self.end.nil? && !empty?
480:       end

unquoted_literal(ds)

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

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 484
484:       def unquoted_literal(ds)
485:         if empty?
486:           'empty'
487:         else
488:           "#{exclude_begin? ? "(" : "["}#{escape_value(self.begin, ds)},#{escape_value(self.end, ds)}#{exclude_end? ? ")" : "]"}"
489:         end
490:       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.

[Source]

     # File lib/sequel/extensions/pg_range.rb, line 468
468:       def valid_ruby_range?
469:         !(empty? || exclude_begin? || !self.begin || !self.end)
470:       end

Methods

Included Modules

Classes and Modules

Attributes

Public Class methods

Public Instance methods