rom-sql 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33d9d062a6396ba9cf578abc3181d5d7aadfc2b9
-  data.tar.gz: 5940f64e388cd42a0dbe28a0f6d3517622154fcc
+  metadata.gz: 0d964bf81ba3e921c992aff816f2c09bc1c91c3a
+  data.tar.gz: 1f8516a4f8420e4a009d41b98d9d1f1dd9bcb608
 SHA512:
-  metadata.gz: 22a3d5592b184cb7de84439a7312c0ed97cee07f85e02a876c0c0d6e97758c9f4da65e3ba070183aa2e06640fac4dcf3ea9fdcf5b3989199d37441bbdf04385f
-  data.tar.gz: d300f4387513f789f3840be6bd561657419ff572de6ceb1decf3a470207448acf36d3d039c2284658c8e11c1445bd0412c6a572e7788f8883d32cb574a868cdd
+  metadata.gz: 21ac8dc3534190ed1a72d6b0a798cdc60c0ff9207995a304a9edfc44356e41c53a0123fa49718b91b7c093cd53060d1c1adb15a2fd02694e85ceaf310b7647aa
+  data.tar.gz: 63dcf1fcc5c3bc2e5f4dc09335eb2da9138abf83790934daf725651df004c5333e4f15669a7a64c2c78160ffd9326a25fe4feec0d75d1dbbee19b7b41f88ba2d

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## v2.1.0 2017-10-23
+
+### Added
+
+* Support for PG's range types (v-kolesnikov)
+* Support for PG's `ltree` (GustavoCaso + solnic)
+
+### Fixed
+
+* Schema inference works with primary keys that have custom types (ie an enum PK column) (v-kolesnikov)
+* Ruby warnings are gone (solnic)
+
+[Compare v2.0.0...v2.1.0](https://github.com/rom-rb/rom-sql/compare/v2.0.0...v2.1.0)
+
 ## v2.0.0 2017-10-18
 
 ### Added

data/lib/rom/sql/extensions/postgres/commands.rb

@@ -10,9 +10,9 @@ module ROM
           #
           # @api private
           def insert(tuples)
-            dataset = tuples.map do |tuple|
+            dataset = tuples.flat_map do |tuple|
               relation.dataset.returning.insert(tuple)
-            end.flatten(1)
+            end
 
             wrap_dataset(dataset)
           end

data/lib/rom/sql/extensions/postgres/type_builder.rb

@@ -27,16 +27,23 @@ module ROM
           'box' => Types::Box,
           'lseg' => Types::LineSegment,
           'polygon' => Types::Polygon,
-          'path' => Types::Path
+          'path' => Types::Path,
+          'int4range' => Types::Int4Range,
+          'int8range' => Types::Int8Range,
+          'numrange' => Types::NumRange,
+          'tsrange' => Types::TsRange,
+          'tstzrange' => Types::TsTzRange,
+          'daterange' => Types::DateRange,
+          'ltree' => Types::LTree
         ).freeze
 
         db_array_type_matcher '[]'.freeze
 
-        def map_pk_type(type, db_type)
+        def map_pk_type(type, db_type, options = {})
           if numeric?(type, db_type)
             type = self.class.numeric_pk_type
           else
-            type = map_type(type, db_type)
+            type = map_type(type, db_type, options)
           end
 
           type.meta(primary_key: true)
@@ -44,7 +51,10 @@ module ROM
 
         def map_type(ruby_type, db_type, enum_values: nil, **_)
           if db_type.end_with?(self.class.db_array_type_matcher)
-            Types::Array(db_type[0...-2])
+            member_name = db_type[0...-2]
+            member_type = self.class.db_type_mapping[member_name]
+
+            Types::Array(member_name, member_type)
           elsif enum_values
             SQL::Types::String.enum(*enum_values)
           else

data/lib/rom/sql/extensions/postgres/type_serializer.rb

@@ -20,7 +20,14 @@ module ROM
             Types::Box => 'box',
             Types::LineSegment => 'lseg',
             Types::Polygon => 'polygon',
-            Types::Path => 'path'
+            Types::Path => 'path',
+            Types::Int4Range => 'int4range',
+            Types::Int8Range => 'int8range',
+            Types::NumRange => 'numrange',
+            Types::TsRange => 'tsrange',
+            Types::TsTzRange => 'tstzrange',
+            Types::DateRange => 'daterange',
+            Types::LTree => 'ltree'
           )
         )
 

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

@@ -41,3 +41,5 @@ require 'rom/sql/extensions/postgres/types/array'
 require 'rom/sql/extensions/postgres/types/json'
 require 'rom/sql/extensions/postgres/types/geometric'
 require 'rom/sql/extensions/postgres/types/network'
+require 'rom/sql/extensions/postgres/types/range'
+require 'rom/sql/extensions/postgres/types/ltree'

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

@@ -2,6 +2,8 @@ require 'sequel/core'
 
 Sequel.extension(*%i(pg_array pg_array_ops))
 
+require 'rom/sql/extensions/postgres/types/array_types'
+
 module ROM
   module SQL
     module Postgres
@@ -10,18 +12,14 @@ module ROM
 
         ArrayRead = Array.constructor { |v| v.respond_to?(:to_ary) ? v.to_ary : v }
 
-        constructor = -> type { -> value { Sequel.pg_array(value, type) } }
-
-        @array_types = ::Hash.new do |hash, type|
-          name = "#{ type }[]"
-          array_type = Type(name, Array.constructor(constructor.(type))).
-                         meta(type: type, read: ArrayRead)
-          TypeExtensions.register(array_type) { include ArrayMethods }
-          hash[type] = array_type
+        # @api private
+        def self.array_types
+          @array_types ||= ArrayTypes.new(Postgres::Types::Array, Postgres::Types::ArrayRead)
         end
 
-        def self.Array(db_type)
-          @array_types[db_type]
+        # @api private
+        def self.Array(db_type, member_type = nil)
+          array_types[db_type, member_type]
         end
 
         # @!parse

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

@@ -0,0 +1,70 @@
+require 'rom/sql/type_extensions'
+
+module ROM
+  module SQL
+    module Postgres
+      module Types
+        # @api private
+        class ArrayTypes
+          attr_reader :elements
+
+          attr_reader :constructor
+
+          attr_reader :base_write_type
+
+          attr_reader :base_read_type
+
+          def initialize(base_write_type, base_read_type)
+            @elements = {}
+            @base_write_type = base_write_type
+            @base_read_type = base_read_type
+            @constructor = proc { |db_type, member|
+              if member
+                -> arr { Sequel.pg_array(arr.map { |v| member[v] }, db_type) }
+              else
+                -> arr { Sequel.pg_array(arr, db_type) }
+              end
+            }
+          end
+
+          def [](db_type, member_type = nil)
+            elements.fetch(db_type) do
+              name = "#{db_type}[]"
+
+              write_type = build_write_type(db_type, member_type)
+              read_type = build_read_type(db_type, member_type)
+
+              array_type = Types.Type(name, write_type).meta(type: db_type, read: read_type)
+
+              register_extension(array_type)
+
+              elements[db_type] = array_type
+            end
+          end
+
+          private
+
+          def build_write_type(db_type, member_type)
+            if member_type
+              base_write_type.constructor(constructor[db_type, member_type])
+            else
+              base_write_type.constructor(constructor[db_type])
+            end
+          end
+
+          def build_read_type(db_type, member_type)
+            if member_type && member_type.meta[:read]
+              base_read_type.of(member_type.meta[:read])
+            else
+              base_read_type
+            end
+          end
+
+          def register_extension(type)
+            TypeExtensions.register(type) { include ArrayMethods }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,329 @@
+require 'rom/types/values'
+
+module ROM
+  module SQL
+    module Postgres
+      # @api public
+      module Types
+        # @see https://www.postgresql.org/docs/current/static/ltree.html
+
+        LTree = Type('ltree') do
+          SQL::Types.define(ROM::Types::Values::TreePath) do
+            input do |label_path|
+              label_path.to_s
+            end
+
+            output do |label_path|
+              ROM::Types::Values::TreePath.new(label_path.to_s) if label_path
+            end
+          end
+        end
+
+        # @!parse
+        #   class SQL::Attribute
+        #     # @!method match(value)
+        #     #   Check whether the LTree match a lquery value
+        #     #   Translates to the ~ operator
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { ltree_tags.match('Bottom.Cities') }
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method match_any(value)
+        #     #   Check whether the LTree match any of the lquery values
+        #     #   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.*') }
+        #     #
+        #     #   @param [Array,String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method match_ltextquery(value)
+        #     #   Check whether the LTree match a ltextquery
+        #     #   Translates to the @ operator
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { ltree_tags.match_ltextquery('Countries & Brasil') }
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method contain_descendant(value)
+        #     #   Check whether the LTree is a descendant of the LTree values
+        #     #   Translates to the <@ operator
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { ltree_tags.contain_descendant(['Bottom.Cities']) }
+        #     #     people.select(:name).where { ltree_tags.contain_descendant('Bottom.Cities, Bottom.Parks') }
+        #     #
+        #     #   @param [Array<String>, String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method descendant(value)
+        #     #   Check whether the LTree is a descendant of the LTree value
+        #     #   Translates to the <@ operator
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { ltree_tags.descendant('Bottom.Cities') }
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method contain_ascendant(value)
+        #     #   Check whether the LTree is a ascendant of the LTree values
+        #     #   Translates to the @> operator
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { ltree_tags.contain_ascendant(['Bottom.Cities']) }
+        #     #     people.select(:name).where { ltree_tags.contain_ascendant('Bottom.Cities, Bottom.Parks') }
+        #     #
+        #     #   @param [Array<String>, String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method ascendant(value)
+        #     #   Check whether the LTree is a ascendant of the LTree value
+        #     #   Translates to the @> operator
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { ltree_tags.ascendant('Bottom.Cities') }
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method +(value)
+        #     #   Concatenate two LTree values
+        #     #   Translates to ||
+        #     #
+        #     #   @example
+        #     #     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') }
+        #     #
+        #     #   @param [LTree, String] keys
+        #     #
+        #     #   @return [SQL::Attribute<Types::LTree>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method contain_any_ltextquery(value)
+        #     #   Does LTree array contain any path matching ltxtquery
+        #     #   Translates to @
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { parents_tags.contain_any_ltextquery('Parks')}
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method contain_ancestor(value)
+        #     #   Does LTree array contain an ancestor of ltree
+        #     #   Translates to @>
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { parents_tags.contain_ancestor('Top.Building.EmpireState.381')}
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method contain_descendant(value)
+        #     #   Does LTree array contain an descendant of ltree
+        #     #   Translates to <@
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { parents_tags.contain_descendant('Top.Building.EmpireState.381')}
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method find_ancestor(value)
+        #     #   Return first LTree array entry that is an ancestor of ltree, NULL if none
+        #     #   Translates to ?@>
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { parents_tags.find_ancestor('Left.Parks').not(nil)}
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::LTree>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method find_descendant(value)
+        #     #   Return first LTree array entry that is an descendant of ltree, NULL if none
+        #     #   Translates to ?<@
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { parents_tags.find_descendant('Left.Parks').not(nil)}
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::LTree>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method match_any_lquery(value)
+        #     #   Return first LTree array entry that matches lquery, NULL if none
+        #     #   Translates to ?~
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { parents_tags.match_any_lquery('Right.*').not(nil)}
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::LTree>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method match_any_ltextquery(value)
+        #     #   Return first LTree array entry that matches ltextquery, NULL if none
+        #     #   Translates to ?@
+        #     #
+        #     #   @example
+        #     #     people.select(:name).where { parents_tags.match_any_ltextquery('EmpireState').not(nil)}
+        #     #
+        #     #   @param [String] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::LTree>]
+        #     #
+        #     #   @api public
+        #
+        #   end
+        module LTreeMethods
+          ASCENDANT = ["(".freeze, " @> ".freeze, ")".freeze].freeze
+          FIND_ASCENDANT = ["(".freeze, " ?@> ".freeze, ")".freeze].freeze
+          DESCENDANT = ["(".freeze, " <@ ".freeze, ")".freeze].freeze
+          FIND_DESCENDANT = ["(".freeze, " ?<@ ".freeze, ")".freeze].freeze
+          MATCH_ANY = ["(".freeze, " ? ".freeze, ")".freeze].freeze
+          MATCH_ANY_LQUERY = ["(".freeze, " ?~ ".freeze, ")".freeze].freeze
+          MATCH_LTEXTQUERY = ["(".freeze, " @ ".freeze, ")".freeze].freeze
+          MATCH_ANY_LTEXTQUERY = ["(".freeze, " ?@ ".freeze, ")".freeze].freeze
+
+          def match(type, 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))
+          end
+
+          private
+
+          def custom_operator_expr(string, expr, query)
+            Sequel::SQL::PlaceholderLiteralString.new(string, [expr, query])
+          end
+
+          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(',')]
+            end
+          end
+        end
+
+        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))
+          end
+
+          def contain_ancestor(type, 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))
+          end
+
+          def find_ancestor(type, 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))
+          end
+
+          def match_any_lquery(type, expr, query)
+            Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_ANY_LQUERY, expr, query))
+          end
+
+          def match_any_ltextquery(type, expr, query)
+            Attribute[LTree].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_ANY_LTEXTQUERY, expr, query))
+          end
+        end
+
+        TypeExtensions.register(LTree) do
+          include LTreeMethods
+
+          def match_ltextquery(type, expr, query)
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::MATCH_LTEXTQUERY, expr, query))
+          end
+
+          def contain_descendant(type, expr, query)
+            array = build_array_query(query, 'ltree')
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::DESCENDANT, expr, array))
+          end
+
+          def descendant(type, expr, query)
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::DESCENDANT, expr, query))
+          end
+
+          def contain_ascendant(type, expr, query)
+            array = build_array_query(query, 'ltree')
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::ASCENDANT, expr, array))
+          end
+
+          def ascendant(type, expr, query)
+            Attribute[SQL::Types::Bool].meta(sql_expr: custom_operator_expr(LTreeMethods::ASCENDANT, expr, query))
+          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))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,207 @@
+require 'sequel/core'
+
+Sequel.extension(:pg_range, :pg_range_ops)
+
+module ROM
+  module SQL
+    module Postgres
+      module Values
+        Range = ::Struct.new(:lower, :upper, :bounds) do
+          PAREN_LEFT  = '('.freeze
+          PAREN_RIGHT = ')'.freeze
+
+          def initialize(lower, upper, bounds = :'[)')
+            super
+          end
+
+          def exclude_begin?
+            bounds[0] == PAREN_LEFT
+          end
+
+          def exclude_end?
+            bounds[1] == PAREN_RIGHT
+          end
+        end
+      end
+
+      # @api public
+      module Types
+        # The list of range types supported by PostgreSQL
+        # @see https://www.postgresql.org/docs/current/static/rangetypes.html
+
+        @range_parsers = {
+          int4range: Sequel::Postgres::PGRange::Parser.new(
+            'int4range', SQL::Types::Coercible::Int
+          ),
+          int8range: Sequel::Postgres::PGRange::Parser.new(
+            'int8range', SQL::Types::Coercible::Int
+          ),
+          numrange:  Sequel::Postgres::PGRange::Parser.new(
+            'numrange', SQL::Types::Coercible::Int
+          ),
+          tsrange:   Sequel::Postgres::PGRange::Parser.new(
+            'tsrange', SQL::Types::Form::Time
+          ),
+          tstzrange: Sequel::Postgres::PGRange::Parser.new(
+            'tstzrange', SQL::Types::Form::Time
+          ),
+          daterange: Sequel::Postgres::PGRange::Parser.new(
+            'daterange', SQL::Types::Form::Date
+          )
+        }.freeze
+
+        # @api private
+        def self.range_read_type(name)
+          SQL::Types.Constructor(Values::Range) do |value|
+            pg_range =
+              if value.is_a?(Sequel::Postgres::PGRange)
+                value
+              elsif value && value.respond_to?(:to_s)
+                @range_parsers[name].(value.to_s)
+              else
+                value
+              end
+
+            Values::Range.new(
+              pg_range.begin,
+              pg_range.end,
+              [pg_range.exclude_begin? ? :'(' : :'[',
+               pg_range.exclude_end? ? :')' : :']']
+              .join('').to_sym
+            )
+          end
+        end
+
+        # @api private
+        def self.range(name, read_type)
+          Type(name) do
+            type = SQL::Types.Definition(Values::Range).constructor do |range|
+              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))
+
+        module RangeOperators
+          def contain(_type, expr, value)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).contains(value)
+            )
+          end
+
+          def contained_by(_type, expr, value)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).contained_by(value)
+            )
+          end
+
+          def overlap(_type, expr, value)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).overlaps(value)
+            )
+          end
+
+          def left_of(_type, expr, value)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).left_of(value)
+            )
+          end
+
+          def right_of(_type, expr, value)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).right_of(value)
+            )
+          end
+
+          def starts_after(_type, expr, value)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).starts_after(value)
+            )
+          end
+
+          def ends_before(_type, expr, value)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).ends_before(value)
+            )
+          end
+
+          def adjacent_to(_type, expr, value)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).adjacent_to(value)
+            )
+          end
+        end
+
+        module RangeFunctions
+          def lower(_type, expr)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).lower
+            )
+          end
+
+          def upper(_type, expr)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).upper
+            )
+          end
+
+          def is_empty(_type, expr)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).isempty
+            )
+          end
+
+          def lower_inc(_type, expr)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).lower_inc
+            )
+          end
+
+          def upper_inc(_type, expr)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).upper_inc
+            )
+          end
+
+          def lower_inf(_type, expr)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).lower_inf
+            )
+          end
+
+          def upper_inf(_type, expr)
+            Attribute[SQL::Types::Bool].meta(
+              sql_expr: Sequel.pg_range(expr).upper_inf
+            )
+          end
+        end
+
+        [
+          Int4Range,
+          Int8Range,
+          NumRange,
+          TsRange,
+          TsTzRange,
+          DateRange
+        ].each do |type|
+          TypeExtensions.register(type) do
+            include RangeOperators
+            include RangeFunctions
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/function.rb

@@ -132,8 +132,39 @@ module ROM
         Attribute[type].meta(sql_expr: ::Sequel.cast(expr, db_type))
       end
 
+      # Add a FILTER clause to aggregate function (supported by PostgreSQL 9.4+)
+      # @see https://www.postgresql.org/docs/current/static/sql-expressions.html
+      #
+      # Filter aggregate using the specified conditions
+      #
+      # @example
+      #   users.project { int::count(:id).filter(name.is("Jack")).as(:jacks) }.order(nil)
+      #   users.project { int::count(:id).filter { name.is("John") }).as(:johns) }.order(nil)
+      #
+      # @param [Hash,SQL::Attribute] Conditions
+      # @yield [block] A block with restrictions
+      #
+      # @return [SQL::Function]
+      #
+      # @api public
+      def filter(condition = Undefined, &block)
+        if block
+          conditions = schema.restriction(&block)
+          conditions = conditions & condition unless condition.equal?(Undefined)
+        else
+          conditions = condition
+        end
+
+        super(conditions)
+      end
+
       private
 
+      # @api private
+      def schema
+        meta[:schema]
+      end
+
       # @api private
       def func
         meta[:func]

data/lib/rom/sql/migration/migrator.rb

@@ -2,7 +2,7 @@ require 'pathname'
 
 require 'rom/types'
 require 'rom/initializer'
-require 'rom/sql/migration'
+
 require 'rom/sql/migration/runner'
 require 'rom/sql/migration/inline_runner'
 require 'rom/sql/migration/writer'

data/lib/rom/sql/plugin/associates.rb

@@ -121,9 +121,9 @@ module ROM
 
                 case parent
                 when Array
-                  parent.map do |p|
+                  parent.flat_map do |p|
                     tuples.map { |tuple| Hash(tuple).merge(fk => p[pk]) }
-                  end.flatten(1)
+                  end
                 else
                   tuples.map { |tuple| Hash(tuple).update(fk => parent[pk]) }
                 end

data/lib/rom/sql/projection_dsl.rb

@@ -38,7 +38,7 @@ module ROM
           type = type(meth)
 
           if type
-            ::ROM::SQL::Function.new(type)
+            ::ROM::SQL::Function.new(type, schema: schema)
           else
             super
           end

data/lib/rom/sql/schema/attributes_inferrer.rb

@@ -33,6 +33,8 @@ module ROM
           [inferred, missing]
         end
 
+        undef :with
+
         # @api private
         def with(new_options)
           self.class.new(options.merge(new_options))

data/lib/rom/sql/schema/type_builder.rb

@@ -37,7 +37,7 @@ module ROM
 
         def call(primary_key:, db_type:, type:, allow_null:, **rest)
           if primary_key
-            map_pk_type(type, db_type)
+            map_pk_type(type, db_type, **rest)
           else
             mapped_type = map_type(type, db_type, rest)
 
@@ -56,7 +56,7 @@ module ROM
         end
 
         # @api private
-        def map_pk_type(_ruby_type, _db_type)
+        def map_pk_type(_ruby_type, _db_type, **)
           self.class.numeric_pk_type.meta(primary_key: true)
         end
 

data/lib/rom/sql/type_extensions.rb

@@ -34,11 +34,10 @@ module ROM
           extensions = @types[type.meta[:database]]
           db_type = type.meta[:db_type]
 
-          raise ArgumentError, "Type #{ db_type } already registered" if extensions.key?(db_type)
           mod = Module.new(&block)
           ctx = Object.new.extend(mod)
           functions = mod.public_instance_methods.each_with_object({}) { |m, ms| ms[m] = ctx.method(m) }
-          extensions[db_type] = functions
+          extensions[db_type] = (extensions[db_type] || {}).merge(functions)
         end
       end
 

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '2.0.0'.freeze
+    VERSION = '2.1.0'.freeze
   end
 end

data/lib/rom/types/values.rb

@@ -0,0 +1,22 @@
+require 'rom/sql/types'
+
+module ROM
+  module Types
+    module Values
+      class TreePath < ::Struct.new(:value, :separator)
+        DEFAULT_SEPARATOR = '.'.freeze
+
+        # @api public
+        def self.new(value, separator = DEFAULT_SEPARATOR)
+          super
+        end
+
+        # @api public
+        def to_s
+          value
+        end
+        alias_method :to_str, :to_s
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-18 00:00:00.000000000 Z
+date: 2017-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -169,9 +169,12 @@ files:
 - lib/rom/sql/extensions/postgres/type_serializer.rb
 - lib/rom/sql/extensions/postgres/types.rb
 - lib/rom/sql/extensions/postgres/types/array.rb
+- lib/rom/sql/extensions/postgres/types/array_types.rb
 - lib/rom/sql/extensions/postgres/types/geometric.rb
 - lib/rom/sql/extensions/postgres/types/json.rb
+- lib/rom/sql/extensions/postgres/types/ltree.rb
 - lib/rom/sql/extensions/postgres/types/network.rb
+- lib/rom/sql/extensions/postgres/types/range.rb
 - lib/rom/sql/extensions/rails_log_subscriber.rb
 - lib/rom/sql/extensions/sqlite.rb
 - lib/rom/sql/extensions/sqlite/type_builder.rb
@@ -216,6 +219,7 @@ files:
 - lib/rom/sql/types.rb
 - lib/rom/sql/version.rb
 - lib/rom/sql/wrap.rb
+- lib/rom/types/values.rb
 homepage: http://rom-rb.org
 licenses:
 - MIT
@@ -236,7 +240,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: SQL databases support for ROM