Class: Sequel::Postgres::PGRange
- Includes:
- Enumerable, SQL::AliasMethods
- Defined in:
- lib/sequel/extensions/pg_range_ops.rb,
lib/sequel/extensions/pg_range.rb
Overview
:nocov:
Defined Under Namespace
Modules: DatabaseMethods, DatasetMethods Classes: Parser
Constant Summary collapse
- ENDLESS_RANGE_NOT_SUPPORTED =
RUBY_VERSION < '2.6'
- STARTLESS_RANGE_NOT_SUPPORTED =
RUBY_VERSION < '2.7'
Instance Attribute Summary collapse
-
#begin ⇒ Object
readonly
The beginning of the range.
-
#db_type ⇒ Object
readonly
The PostgreSQL database type for the range (e.g. 'int4range').
-
#end ⇒ Object
readonly
The end of the range.
Class Method Summary collapse
-
.empty(db_type = nil) ⇒ Object
Create an empty PGRange with the given database type.
-
.from_range(range, db_type = nil) ⇒ Object
Create a new PGRange instance using the beginning and ending of the ruby Range, with the given db_type.
Instance Method Summary collapse
-
#===(other) ⇒ Object
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.
-
#cover?(value) ⇒ Boolean
Return whether the value is inside the range.
-
#empty? ⇒ Boolean
Whether this range is empty (has no points).
-
#eql?(other) ⇒ Boolean
(also: #==)
Consider the receiver equal to other PGRange instances with the same beginning, ending, exclusions, and database type.
-
#exclude_begin? ⇒ Boolean
Whether the beginning element is excluded from the range.
-
#exclude_end? ⇒ Boolean
Whether the ending element is excluded from the range.
-
#hash ⇒ Object
Make sure equal ranges have the same hash.
-
#initialize(beg, en, opts = OPTS) ⇒ PGRange
constructor
Initialize a new PGRange instance.
-
#op ⇒ Object
Wrap the PGRange instance in an RangeOp, allowing you to easily use the PostgreSQL range functions and operators with literal ranges.
-
#sql_literal_append(ds, sql) ⇒ Object
Append a literalize version of the receiver to the sql.
-
#to_range ⇒ Object
Return a ruby Range object for this instance, if one can be created.
-
#unbounded_begin? ⇒ Boolean
Whether the beginning of the range is unbounded.
-
#unbounded_end? ⇒ Boolean
Whether the end of the range is unbounded.
-
#unquoted_literal(ds) ⇒ Object
Return a string containing the unescaped version of the range.
-
#valid_ruby_range? ⇒ Boolean
Whether or not this PGRange is a valid ruby range.
Methods included from SQL::AliasMethods
Constructor Details
#initialize(beg, en, opts = OPTS) ⇒ PGRange
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.
343 344 345 346 347 348 349 350 351 352 353 |
# File 'lib/sequel/extensions/pg_range.rb', line 343 def initialize(beg, en, opts=OPTS) @begin = beg @end = en @empty = !!opts[:empty] @exclude_begin = !!opts[:exclude_begin] @exclude_end = !!opts[:exclude_end] @db_type = opts[:db_type] if @empty 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? end end |
Instance Attribute Details
#begin ⇒ Object (readonly)
The beginning of the range. If nil, the range has an unbounded beginning.
318 319 320 |
# File 'lib/sequel/extensions/pg_range.rb', line 318 def begin @begin end |
#db_type ⇒ Object (readonly)
The PostgreSQL database type for the range (e.g. 'int4range').
324 325 326 |
# File 'lib/sequel/extensions/pg_range.rb', line 324 def db_type @db_type end |
#end ⇒ Object (readonly)
The end of the range. If nil, the range has an unbounded ending.
321 322 323 |
# File 'lib/sequel/extensions/pg_range.rb', line 321 def end @end end |
Class Method Details
.empty(db_type = nil) ⇒ Object
Create an empty PGRange with the given database type.
333 334 335 |
# File 'lib/sequel/extensions/pg_range.rb', line 333 def self.empty(db_type=nil) new(nil, nil, :empty=>true, :db_type=>db_type) end |
.from_range(range, db_type = nil) ⇒ Object
Create a new PGRange instance using the beginning and ending of the ruby Range, with the given db_type.
328 329 330 |
# File 'lib/sequel/extensions/pg_range.rb', line 328 def self.from_range(range, db_type=nil) new(range.begin, range.end, :exclude_end=>range.exclude_end?, :db_type=>db_type) end |
Instance Method Details
#===(other) ⇒ Object
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.
413 414 415 416 417 418 419 420 421 422 423 |
# File 'lib/sequel/extensions/pg_range.rb', line 413 def ===(other) if eql?(other) true else if valid_ruby_range? to_range === other else false end end end |
#cover?(value) ⇒ Boolean
Return whether the value is inside the range.
362 363 364 365 366 367 368 369 |
# File 'lib/sequel/extensions/pg_range.rb', line 362 def cover?(value) return false if empty? b = self.begin return false if b && b.public_send(exclude_begin? ? :>= : :>, value) e = self.end return false if e && e.public_send(exclude_end? ? :<= : :<, value) true end |
#empty? ⇒ Boolean
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.
428 429 430 |
# File 'lib/sequel/extensions/pg_range.rb', line 428 def empty? @empty end |
#eql?(other) ⇒ Boolean Also known as: ==
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.
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 |
# File 'lib/sequel/extensions/pg_range.rb', line 375 def eql?(other) case other when PGRange if db_type == other.db_type if empty? other.empty? elsif other.empty? false else [:@begin, :@end, :@exclude_begin, :@exclude_end].all?{|v| instance_variable_get(v) == other.instance_variable_get(v)} end else false end when Range if valid_ruby_range? to_range.eql?(other) else false end else false end end |
#exclude_begin? ⇒ Boolean
Whether the beginning element is excluded from the range.
433 434 435 |
# File 'lib/sequel/extensions/pg_range.rb', line 433 def exclude_begin? @exclude_begin end |
#exclude_end? ⇒ Boolean
Whether the ending element is excluded from the range.
438 439 440 |
# File 'lib/sequel/extensions/pg_range.rb', line 438 def exclude_end? @exclude_end end |
#hash ⇒ Object
Make sure equal ranges have the same hash.
402 403 404 405 406 407 408 |
# File 'lib/sequel/extensions/pg_range.rb', line 402 def hash if @empty @db_type.hash else [@begin, @end, @exclude_begin, @exclude_end, @db_type].hash end end |
#op ⇒ Object
Wrap the PGRange instance in an RangeOp, allowing you to easily use the PostgreSQL range functions and operators with literal ranges.
125 126 127 |
# File 'lib/sequel/extensions/pg_range_ops.rb', line 125 def op RangeOp.new(self) end |
#sql_literal_append(ds, sql) ⇒ Object
Append a literalize version of the receiver to the sql.
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 |
# File 'lib/sequel/extensions/pg_range.rb', line 443 def sql_literal_append(ds, sql) if (s = @db_type) && !empty? sql << s.to_s << "(" ds.literal_append(sql, self.begin) sql << ',' ds.literal_append(sql, self.end) sql << ',' ds.literal_append(sql, "#{exclude_begin? ? "(" : "["}#{exclude_end? ? ")" : "]"}") sql << ")" else ds.literal_append(sql, unquoted_literal(ds)) if s sql << '::' << s.to_s end end end |
#to_range ⇒ Object
Return a ruby Range object for this instance, if one can be created.
464 465 466 467 468 469 470 471 472 473 |
# File 'lib/sequel/extensions/pg_range.rb', line 464 def to_range return @range if @range raise(Error, "cannot create ruby range for an empty PostgreSQL range") if empty? raise(Error, "cannot create ruby range when PostgreSQL range excludes beginning element") if exclude_begin? # :nocov: raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") if STARTLESS_RANGE_NOT_SUPPORTED && !self.begin raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") if ENDLESS_RANGE_NOT_SUPPORTED && !self.end # :nocov: @range = Range.new(self.begin, self.end, exclude_end?) end |
#unbounded_begin? ⇒ Boolean
Whether the beginning of the range is unbounded.
483 484 485 |
# File 'lib/sequel/extensions/pg_range.rb', line 483 def unbounded_begin? self.begin.nil? && !empty? end |
#unbounded_end? ⇒ Boolean
Whether the end of the range is unbounded.
488 489 490 |
# File 'lib/sequel/extensions/pg_range.rb', line 488 def unbounded_end? self.end.nil? && !empty? end |
#unquoted_literal(ds) ⇒ Object
Return a string containing the unescaped version of the range. Separated out for use by the bound argument code.
494 495 496 497 498 499 500 |
# File 'lib/sequel/extensions/pg_range.rb', line 494 def unquoted_literal(ds) if empty? 'empty' else "#{exclude_begin? ? "(" : "["}#{escape_value(self.begin, ds)},#{escape_value(self.end, ds)}#{exclude_end? ? ")" : "]"}" end end |
#valid_ruby_range? ⇒ Boolean
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.
478 479 480 |
# File 'lib/sequel/extensions/pg_range.rb', line 478 def valid_ruby_range? !(empty? || exclude_begin? || (STARTLESS_RANGE_NOT_SUPPORTED && !self.begin) || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end)) end |