rom-sql 3.7.0 → 4.0.0.alpha1

data/lib/rom/sql/extensions/postgres/types/geometric.rb

@@ -34,55 +34,55 @@ module ROM
         # The list of geometric data types supported by PostgreSQL
         # @see https://www.postgresql.org/docs/current/static/datatype-geometric.html
 
-        Point = Type('point') do
+        Point = Type("point") do
           SQL::Types.define(Values::Point) do
             input do |point|
               "(#{point.x},#{point.y})"
             end
 
             output do |point|
-              x, y = point.to_s[1...-1].split(',', 2)
+              x, y = point.to_s[1...-1].split(",", 2)
               Values::Point.new(Float(x), Float(y))
             end
           end
         end
 
-        Line = Type('line') do
+        Line = Type("line") do
           SQL::Types.define(Values::Line) do
             input do |line|
               "{#{line.a},#{line.b},#{line.c}}"
             end
 
             output do |line|
-              a, b, c = line.to_s[1..-2].split(',', 3)
+              a, b, c = line.to_s[1..-2].split(",", 3)
               Values::Line.new(Float(a), Float(b), Float(c))
             end
           end
         end
 
-        Circle = Type('circle') do
+        Circle = Type("circle") do
           SQL::Types.define(Values::Circle) do
             input do |circle|
               "<(#{circle.center.x},#{circle.center.y}),#{circle.radius}>"
             end
 
             output do |circle|
-              x, y, r = circle.to_s.tr('()<>', '').split(',', 3)
+              x, y, r = circle.to_s.tr("()<>", "").split(",", 3)
               center = Values::Point.new(Float(x), Float(y))
               Values::Circle.new(center, Float(r))
             end
           end
         end
 
-        Box = Type('box') do
+        Box = Type("box") do
           SQL::Types.define(Values::Box) do
             input do |box|
-              "((#{box.upper_right.x},#{box.upper_right.y})," \
+              "((#{box.upper_right.x},#{box.upper_right.y}),"\
                 "(#{box.lower_left.x},#{box.lower_left.y}))"
             end
 
             output do |box|
-              x_right, y_right, x_left, y_left = box.to_s.tr('()', '').split(',', 4)
+              x_right, y_right, x_left, y_left = box.to_s.tr("()", "").split(",", 4)
               upper_right = Values::Point.new(Float(x_right), Float(y_right))
               lower_left = Values::Point.new(Float(x_left), Float(y_left))
               Values::Box.new(upper_right, lower_left)
@@ -90,15 +90,15 @@ module ROM
           end
         end
 
-        LineSegment = Type('lseg') do
+        LineSegment = Type("lseg") do
           SQL::Types.define(Values::LineSegment) do
             input do |segment|
-              "[(#{segment.begin.x},#{segment.begin.y})," \
+              "[(#{segment.begin.x},#{segment.begin.y}),"\
                 "(#{segment.end.x},#{segment.end.y})]"
             end
 
             output do |segment|
-              x_begin, y_begin, x_end, y_end = segment.to_s.tr('()[]', '').split(',', 4)
+              x_begin, y_begin, x_end, y_end = segment.to_s.tr("()[]", "").split(",", 4)
               point_begin = Values::Point.new(Float(x_begin), Float(y_begin))
               point_end = Values::Point.new(Float(x_end), Float(y_end))
               Values::LineSegment.new(point_begin, point_end)
@@ -106,24 +106,24 @@ module ROM
           end
         end
 
-        Polygon = Type('polygon') do
+        Polygon = Type("polygon") do
           SQL::Types.define(::Array) do
             input do |points|
-              points_joined = points.map { |p| "(#{p.x},#{p.y})" }.join(',')
+              points_joined = points.map { |p| "(#{p.x},#{p.y})" }.join(",")
               "(#{points_joined})"
             end
 
             output do |polygon|
-              coordinates = polygon.to_s.tr('()', '').split(',').each_slice(2)
+              coordinates = polygon.to_s.tr("()", "").split(",").each_slice(2)
               coordinates.map { |x, y| Values::Point.new(Float(x), Float(y)) }
             end
           end
         end
 
-        Path = Type('path') do
+        Path = Type("path") do
           SQL::Types.define(Values::Path) do
             input do |path|
-              points_joined = path.to_a.map { |p| "(#{p.x},#{p.y})" }.join(',')
+              points_joined = path.to_a.map { |p| "(#{p.x},#{p.y})" }.join(",")
 
               if path.open?
                 "[#{points_joined}]"
@@ -133,8 +133,8 @@ module ROM
             end
 
             output do |path|
-              open = path.to_s.start_with?('[') && path.to_s.end_with?(']')
-              coordinates = path.to_s.tr('()[]', '').split(',').each_slice(2)
+              open = path.to_s.start_with?("[") && path.to_s.end_with?("]")
+              coordinates = path.to_s.tr("()[]", "").split(",").each_slice(2)
               points = coordinates.map { |x, y| Values::Point.new(Float(x), Float(y)) }
 
               if open

data/lib/rom/sql/extensions/postgres/types/json.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'sequel/core'
-require 'singleton'
+require "sequel/core"
+require "singleton"
 
 Sequel.extension(:pg_json, :pg_json_ops)
 
@@ -23,11 +23,11 @@ module ROM
           include ::Singleton
 
           def to_s
-            'null'
+            "null"
           end
 
           def inspect
-            'null'
+            "null"
           end
         end
 
@@ -44,7 +44,7 @@ module ROM
             SQL::Types::False
           ]
 
-          JSON = Type('json') do
+          JSON = Type("json") do
             casts = ::Hash.new(-> v { ::Sequel.pg_json(v) })
             json_null = ::Sequel.pg_json_wrap(nil)
             casts[JSONNullType] = -> _ { json_null }
@@ -60,7 +60,7 @@ module ROM
               .meta(read: JSONRead)
           end
 
-          JSONB = Type('jsonb') do
+          JSONB = Type("jsonb") do
             casts = ::Hash.new(-> v { ::Sequel.pg_jsonb(v) })
             jsonb_null = ::Sequel.pg_jsonb_wrap(nil)
             casts[JSONNullType] = -> _ { jsonb_null }
@@ -76,16 +76,12 @@ module ROM
               .meta(read: JSONRead)
           end
         else
-          JSON = Type('json') do
-            (SQL::Types::Array | SQL::Types::Hash).constructor(
-              ::Sequel.method(:pg_json)
-            ).meta(read: JSONRead)
+          JSON = Type("json") do
+            (SQL::Types::Array | SQL::Types::Hash).constructor(Sequel.method(:pg_json)).meta(read: JSONRead)
           end
 
-          JSONB = Type('jsonb') do
-            (SQL::Types::Array | SQL::Types::Hash).constructor(
-              ::Sequel.method(:pg_jsonb)
-            ).meta(read: JSONRead)
+          JSONB = Type("jsonb") do
+            (SQL::Types::Array | SQL::Types::Hash).constructor(Sequel.method(:pg_jsonb)).meta(read: JSONRead)
           end
         end
 
@@ -246,7 +242,7 @@ module ROM
 
           def path_args(path)
             case path.size
-            when 0 then raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)'
+            when 0 then raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
             when 1 then path[0]
             else path
             end
@@ -269,9 +265,7 @@ module ROM
           end
 
           def has_key(_type, expr, key)
-            Attribute[SQL::Types::Bool].meta(
-              sql_expr: wrap(expr).has_key?(key) # rubocop:disable Style/PreferredHashMethods
-            )
+            Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).has_key?(key))
           end
 
           def has_any_key(_type, expr, *keys)

data/lib/rom/sql/extensions/postgres/types/ltree.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
-require 'rom/types/values'
+require "rom/types/values"
 
 module ROM
   module SQL
     module Postgres
       # @api public
-      #
-      # rubocop:disable Metrics/ModuleLength
       module Types
         # @see https://www.postgresql.org/docs/current/static/ltree.html
 
-        LTree = Type('ltree') do
+        LTree = Type("ltree") do
           SQL::Types.define(ROM::Types::Values::TreePath) do
             input(&:to_s)
 
@@ -41,12 +39,8 @@ module ROM
         #     #   Translates to the ? operator
         #     #
         #     #   @example
-        #     #     people.select(:name).where {
-        #     #       ltree_tags.match_any(['Bottom', 'Bottom.Cities.*'])
-        #     #     }
-        #     #     people.select(:name).where {
-        #     #       ltree_tags.match_any('Bottom,Bottom.Cities.*')
-        #     #     }
+        #     #     people.select(:name).where { ltree_tags.match_any(['Bottom', 'Bottom.Cities.*']) }
+        #     #     people.select(:name).where { ltree_tags.match_any('Bottom,Bottom.Cities.*') }
         #     #
         #     #   @param [Array,String] value
         #     #
@@ -73,9 +67,7 @@ module ROM
         #     #
         #     #   @example
         #     #     people.select(:name).where { ltree_tags.contain_descendant(['Bottom.Cities']) }
-        #     #     people.select(:name).where {
-        #     #       ltree_tags.contain_descendant('Bottom.Cities, Bottom.Parks')
-        #     #     }
+        #     #     people.select(:name).where { ltree_tags.contain_descendant('Bottom.Cities, Bottom.Parks') }
         #     #
         #     #   @param [Array<String>, String] value
         #     #
@@ -102,9 +94,7 @@ module ROM
         #     #
         #     #   @example
         #     #     people.select(:name).where { ltree_tags.contain_ascendant(['Bottom.Cities']) }
-        #     #     people.select(:name).where {
-        #     #       ltree_tags.contain_ascendant('Bottom.Cities, Bottom.Parks')
-        #     #     }
+        #     #     people.select(:name).where { ltree_tags.contain_ascendant('Bottom.Cities, Bottom.Parks') }
         #     #
         #     #   @param [Array<String>, String] value
         #     #
@@ -133,9 +123,11 @@ module ROM
         #     #     people.select {
         #     #       (ltree_tags + ROM::Types::Values::TreePath.new('Moscu')).as(:ltree_tags)
         #     #     }.where { name.is('Jade Doe') }
+        #     #
         #     #     people.select {
         #     #       (ltree_tags + 'Moscu').as(:ltree_tags)
-        #     #     }.where { name.is('Jade Doe') }
+        #     #     }
+        #     #     .where { name.is('Jade Doe') }
         #     #
         #     #   @param [LTree, String] keys
         #     #
@@ -161,9 +153,7 @@ module ROM
         #     #   Translates to @>
         #     #
         #     #   @example
-        #     #     people.select(:name).where {
-        #     #       parents_tags.contain_ancestor('Top.Building.EmpireState.381')
-        #     #     }
+        #     #     people.select(:name).where { parents_tags.contain_ancestor('Top.Building.EmpireState.381')}
         #     #
         #     #   @param [String] value
         #     #
@@ -176,9 +166,7 @@ module ROM
         #     #   Translates to <@
         #     #
         #     #   @example
-        #     #     people.select(:name).where {
-        #     #       parents_tags.contain_descendant('Top.Building.EmpireState.381')
-        #     #     }
+        #     #     people.select(:name).where { parents_tags.contain_descendant('Top.Building.EmpireState.381')}
         #     #
         #     #   @param [String] value
         #     #
@@ -191,9 +179,7 @@ module ROM
         #     #   Translates to ?@>
         #     #
         #     #   @example
-        #     #     people.select(:name).where {
-        #     #       parents_tags.find_ancestor('Left.Parks').not(nil)
-        #     #     }
+        #     #     people.select(:name).where { parents_tags.find_ancestor('Left.Parks').not(nil)}
         #     #
         #     #   @param [String] value
         #     #
@@ -206,9 +192,7 @@ module ROM
         #     #   Translates to ?<@
         #     #
         #     #   @example
-        #     #     people.select(:name).where {
-        #     #       parents_tags.find_descendant('Left.Parks').not(nil)
-        #     #     }
+        #     #     people.select(:name).where { parents_tags.find_descendant('Left.Parks').not(nil)}
         #     #
         #     #   @param [String] value
         #     #
@@ -221,9 +205,7 @@ module ROM
         #     #   Translates to ?~
         #     #
         #     #   @example
-        #     #     people.select(:name).where {
-        #     #       parents_tags.match_any_lquery('Right.*').not(nil)
-        #     #     }
+        #     #     people.select(:name).where { parents_tags.match_any_lquery('Right.*').not(nil)}
         #     #
         #     #   @param [String] value
         #     #
@@ -236,9 +218,7 @@ module ROM
         #     #   Translates to ?@
         #     #
         #     #   @example
-        #     #     people.select(:name).where {
-        #     #       parents_tags.match_any_ltextquery('EmpireState').not(nil)
-        #     #     }
+        #     #     people.select(:name).where { parents_tags.match_any_ltextquery('EmpireState').not(nil)}
         #     #
         #     #   @param [String] value
         #     #
@@ -248,26 +228,23 @@ module ROM
         #
         #   end
         module LTreeMethods
-          ASCENDANT = ['(', ' @> ', ')'].freeze
-          FIND_ASCENDANT = ['(', ' ?@> ', ')'].freeze
-          DESCENDANT = ['(', ' <@ ', ')'].freeze
-          FIND_DESCENDANT = ['(', ' ?<@ ', ')'].freeze
-          MATCH_ANY = ['(', ' ? ', ')'].freeze
-          MATCH_ANY_LQUERY = ['(', ' ?~ ', ')'].freeze
-          MATCH_LTEXTQUERY = ['(', ' @ ', ')'].freeze
-          MATCH_ANY_LTEXTQUERY = ['(', ' ?@ ', ')'].freeze
+          ASCENDANT = ["(", " @> ", ")"].freeze
+          FIND_ASCENDANT = ["(", " ?@> ", ")"].freeze
+          DESCENDANT = ["(", " <@ ", ")"].freeze
+          FIND_DESCENDANT = ["(", " ?<@ ", ")"].freeze
+          MATCH_ANY = ["(", " ? ", ")"].freeze
+          MATCH_ANY_LQUERY = ["(", " ?~ ", ")"].freeze
+          MATCH_LTEXTQUERY = ["(", " @ ", ")"].freeze
+          MATCH_ANY_LTEXTQUERY = ["(", " ?@ ", ")"].freeze
 
           def match(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(
-              sql_expr: ::Sequel::SQL::BooleanExpression.new(:~, expr, query)
-            )
+            Attribute[SQL::Types::Bool].meta(sql_expr: Sequel::SQL::BooleanExpression.new(:~,
+expr, query))
           end
 
           def match_any(_type, expr, query)
             array = build_array_query(query)
-            Attribute[SQL::Types::Bool].meta(
-              sql_expr: custom_operator_expr(MATCH_ANY, expr, array)
-            )
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(MATCH_ANY, expr, array))
           end
 
           private
@@ -276,65 +253,50 @@ module ROM
             Sequel::SQL::PlaceholderLiteralString.new(string, [expr, query])
           end
 
-          def build_array_query(query, array_type = 'lquery')
+          def build_array_query(query, array_type = "lquery")
             case query
             when ::Array
               ROM::SQL::Types::PG::Array(array_type)[query]
             when ::String
-              ROM::SQL::Types::PG::Array(array_type)[query.split(',')]
+              ROM::SQL::Types::PG::Array(array_type)[query.split(",")]
             end
           end
         end
 
-        TypeExtensions.register(ROM::SQL::Types::PG::Array('ltree', LTree)) do
+        TypeExtensions.register(ROM::SQL::Types::PG::Array("ltree", LTree)) do
           include LTreeMethods
 
           def contain_any_ltextquery(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(
-              sql_expr: custom_operator_expr(
-                LTreeMethods::MATCH_LTEXTQUERY, expr, query
-              )
-            )
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
+              LTreeMethods::MATCH_LTEXTQUERY, expr, query
+            ))
           end
 
           def contain_ancestor(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(
-              sql_expr: custom_operator_expr(
-                LTreeMethods::ASCENDANT, expr, query
-              )
-            )
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
+              LTreeMethods::ASCENDANT, expr, query
+            ))
           end
 
           def contain_descendant(_type, expr, query)
-            Attribute[SQL::Types::Bool].meta(
-              sql_expr: custom_operator_expr(
-                LTreeMethods::DESCENDANT, expr, query
-              )
-            )
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
+              LTreeMethods::DESCENDANT, expr, query
+            ))
           end
 
           def find_ancestor(_type, expr, query)
-            Attribute[LTree].meta(
-              sql_expr: custom_operator_expr(
-                LTreeMethods::FIND_ASCENDANT, expr, query
-              )
-            )
+            Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::FIND_ASCENDANT,
+expr, query))
           end
 
           def find_descendant(_type, expr, query)
-            Attribute[LTree].meta(
-              sql_expr: custom_operator_expr(
-                LTreeMethods::FIND_DESCENDANT, expr, query
-              )
-            )
+            Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::FIND_DESCENDANT,
+expr, query))
           end
 
           def match_any_lquery(_type, expr, query)
-            Attribute[LTree].meta(
-              sql_expr: custom_operator_expr(
-                LTreeMethods::MATCH_ANY_LQUERY, expr, query
-              )
-            )
+            Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_ANY_LQUERY,
+expr, query))
           end
 
           def match_any_ltextquery(_type, expr, query)
@@ -354,7 +316,7 @@ module ROM
           end
 
           def contain_descendant(_type, expr, query)
-            array = build_array_query(query, 'ltree')
+            array = build_array_query(query, "ltree")
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
               LTreeMethods::DESCENDANT, expr, array
             ))
@@ -367,7 +329,7 @@ module ROM
           end
 
           def contain_ascendant(_type, expr, query)
-            array = build_array_query(query, 'ltree')
+            array = build_array_query(query, "ltree")
             Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(
               LTreeMethods::ASCENDANT, expr, array
             ))
@@ -380,22 +342,17 @@ module ROM
           end
 
           def +(_type, expr, other)
-            other_value =
-              case other
-              when ::ROM::Types::Values::TreePath
-                other
-              else
-                ::ROM::Types::Values::TreePath.new(other)
-              end
-            Attribute[LTree].meta(
-              sql_expr: ::Sequel::SQL::StringExpression.new(
-                :'||', expr, other_value.to_s
-              )
-            )
+            other_value = case other
+                          when ROM::Types::Values::TreePath
+                            other
+                          else
+                            ROM::Types::Values::TreePath.new(other)
+                          end
+            Attribute[LTree].meta(sql_expr: Sequel::SQL::StringExpression.new(:"||", expr,
+other_value.to_s))
           end
         end
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rom/sql/extensions/postgres/types/network.rb

@@ -1,28 +1,15 @@
 # frozen_string_literal: true
 
-require 'ipaddr'
+require "ipaddr"
 
 module ROM
   module SQL
     module Postgres
       module Types
-        IPAddress = Type('inet') do
-          read = SQL::Types.Constructor(IPAddr) { |ip| ::IPAddr.new(ip.to_s) }
+        IPAddress = Type("inet") do
+          read = SQL::Types.Constructor(IPAddr) { |ip| IPAddr.new(ip.to_s) }
 
-          SQL::Types.Constructor(::IPAddr, &:to_s).meta(read: read)
-        end
-
-        IPNetwork = Type('cidr') do
-          read = SQL::Types.Constructor(IPAddr) do |ip|
-            case ip
-            when ::IPAddr
-              ip
-            when String
-              ::IPAddr.new(ip)
-            end
-          end
-
-          SQL::Types.Constructor(::IPAddr) { |ip| "#{ip}/#{ip.prefix}" }.meta(read: read)
+          SQL::Types.Constructor(IPAddr, &:to_s).meta(read: read)
         end
       end
     end

data/lib/rom/sql/extensions/postgres/types/range.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'sequel/core'
+require "sequel/core"
 
 Sequel.extension(:pg_range, :pg_range_ops)
 
@@ -9,16 +9,19 @@ module ROM
     module Postgres
       module Values
         Range = ::Struct.new(:lower, :upper, :bounds) do
-          def initialize(lower, upper, bounds = :'[)')
+          PAREN_LEFT  = "("
+          PAREN_RIGHT = ")"
+
+          def initialize(lower, upper, bounds = :"[)")
             super
           end
 
           def exclude_begin?
-            bounds[0] == '('
+            bounds[0] == PAREN_LEFT
           end
 
           def exclude_end?
-            bounds[1] == ')'
+            bounds[1] == PAREN_RIGHT
           end
         end
       end
@@ -30,22 +33,22 @@ module ROM
 
         @range_parsers = {
           int4range: Sequel::Postgres::PGRange::Parser.new(
-            'int4range', SQL::Types::Coercible::Integer
+            "int4range", SQL::Types::Coercible::Integer
           ),
           int8range: Sequel::Postgres::PGRange::Parser.new(
-            'int8range', SQL::Types::Coercible::Integer
+            "int8range", SQL::Types::Coercible::Integer
           ),
           numrange: Sequel::Postgres::PGRange::Parser.new(
-            'numrange', SQL::Types::Coercible::Integer
+            "numrange", SQL::Types::Coercible::Integer
           ),
           tsrange: Sequel::Postgres::PGRange::Parser.new(
-            'tsrange', ::Time.method(:parse)
+            "tsrange", ::Time.method(:parse)
           ),
           tstzrange: Sequel::Postgres::PGRange::Parser.new(
-            'tstzrange', ::Time.method(:parse)
+            "tstzrange", ::Time.method(:parse)
           ),
           daterange: Sequel::Postgres::PGRange::Parser.new(
-            'daterange', ::Date.method(:parse)
+            "daterange", ::Date.method(:parse)
           )
         }.freeze
 
@@ -53,21 +56,20 @@ module ROM
         def self.range_read_type(name)
           SQL::Types.Constructor(Values::Range) do |value|
             pg_range =
-              if value.is_a?(::Sequel::Postgres::PGRange)
+              if value.is_a?(Sequel::Postgres::PGRange)
                 value
-              elsif value && value.respond_to?(:to_s) # rubocop:disable Style/SafeNavigation
+              elsif value.respond_to?(:to_s)
                 @range_parsers[name].(value.to_s)
-              else # rubocop:disable Lint/DuplicateBranch
+              else
                 value
               end
 
             Values::Range.new(
               pg_range.begin,
               pg_range.end,
-              [
-                pg_range.exclude_begin? ? :'(' : :'[',
-                pg_range.exclude_end? ? :')' : :']'
-              ].join.to_sym
+              [pg_range.exclude_begin? ? :"(" : :"[",
+               pg_range.exclude_end? ? :")" : :"]"]
+              .join("").to_sym
             )
           end
         end
@@ -76,25 +78,23 @@ module ROM
         def self.range(name, read_type)
           Type(name) do
             type = SQL::Types.Nominal(Values::Range).constructor do |range|
-              format(
-                '%<begin>s%<lower>s,%<upper>s%<end>s',
-                begin: range.exclude_begin? ? :'(' : :'[',
-                lower: range.lower,
-                upper: range.upper,
-                end: range.exclude_end? ? :')' : :']'
-              )
+              format("%s%s,%s%s",
+                     range.exclude_begin? ? :"(" : :"[",
+                     range.lower,
+                     range.upper,
+                     range.exclude_end? ? :")" : :"]")
             end
 
             type.meta(read: read_type)
           end
         end
 
-        Int4Range = range('int4range', range_read_type(:int4range))
-        Int8Range = range('int8range', range_read_type(:int8range))
-        NumRange  = range('numrange',  range_read_type(:numrange))
-        TsRange   = range('tsrange',   range_read_type(:tsrange))
-        TsTzRange = range('tstzrange', range_read_type(:tstzrange))
-        DateRange = range('daterange', range_read_type(:daterange))
+        Int4Range = range("int4range", range_read_type(:int4range))
+        Int8Range = range("int8range", range_read_type(:int8range))
+        NumRange  = range("numrange",  range_read_type(:numrange))
+        TsRange   = range("tsrange",   range_read_type(:tsrange))
+        TsTzRange = range("tstzrange", range_read_type(:tstzrange))
+        DateRange = range("daterange", range_read_type(:daterange))
 
         module RangeOperators
           def contain(_type, expr, value)