rom-sql 2.0.0.beta2 → 2.0.0.beta3

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

@@ -0,0 +1,163 @@
+require 'sequel/core'
+
+Sequel.extension(*%i(pg_array pg_array_ops))
+
+module ROM
+  module SQL
+    module Postgres
+      module Types
+        Array = SQL::Types::Array
+
+        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
+        end
+
+        def self.Array(db_type)
+          @array_types[db_type]
+        end
+
+        # @!parse
+        #   class SQL::Attribute
+        #     # @!method contain(other)
+        #     #   Check whether the array includes another array
+        #     #   Translates to the @> operator
+        #     #
+        #     #   @param [Array] other
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method get(idx)
+        #     #   Get element by index (PG uses 1-based indexing)
+        #     #
+        #     #   @param [Integer] idx
+        #     #
+        #     #   @return [SQL::Attribute]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method any(value)
+        #     #   Check whether the array includes a value
+        #     #   Translates to the ANY operator
+        #     #
+        #     #   @param [Object] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method contained_by(other)
+        #     #   Check whether the array is contained by another array
+        #     #   Translates to the <@ operator
+        #     #
+        #     #   @param [Array] other
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method length
+        #     #   Return array size
+        #     #
+        #     #   @return [SQL::Attribute<Types::Int>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method overlaps(other)
+        #     #   Check whether the arrays have common values
+        #     #   Translates to &&
+        #     #
+        #     #   @param [Array] other
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method remove_value(value)
+        #     #   Remove elements by value
+        #     #
+        #     #   @param [Object] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::Array>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method join(delimiter, null_repr)
+        #     #   Convert the array to a string by joining
+        #     #   values with a delimiter (empty stirng by default)
+        #     #   and optional filler for NULL values
+        #     #   Translates to an `array_to_string` call
+        #     #
+        #     #   @param [Object] delimiter
+        #     #   @param [Object] null
+        #     #
+        #     #   @return [SQL::Attribute<Types::String>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method +(other)
+        #     #   Concatenate two arrays
+        #     #
+        #     #   @param [Array] other
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::Array>]
+        #     #
+        #     #   @api public
+        #   end
+        module ArrayMethods
+          def contain(type, expr, other)
+            Attribute[SQL::Types::Bool].meta(sql_expr: expr.pg_array.contains(type[other]))
+          end
+
+          def get(type, expr, idx)
+            Attribute[type].meta(sql_expr: expr.pg_array[idx])
+          end
+
+          def any(type, expr, value)
+            Attribute[SQL::Types::Bool].meta(sql_expr: { value => expr.pg_array.any })
+          end
+
+          def contained_by(type, expr, other)
+            Attribute[SQL::Types::Bool].meta(sql_expr: expr.pg_array.contained_by(type[other]))
+          end
+
+          def length(type, expr)
+            Attribute[SQL::Types::Int].meta(sql_expr: expr.pg_array.length)
+          end
+
+          def overlaps(type, expr, other_array)
+            Attribute[SQL::Types::Bool].meta(sql_expr: expr.pg_array.overlaps(type[other_array]))
+          end
+
+          def remove_value(type, expr, value)
+            Attribute[type].meta(sql_expr: expr.pg_array.remove(cast(type, value)))
+          end
+
+          def join(type, expr, delimiter = '', null = nil)
+            Attribute[SQL::Types::String].meta(sql_expr: expr.pg_array.join(delimiter, null))
+          end
+
+          def +(type, expr, other)
+            Attribute[type].meta(sql_expr: expr.pg_array.concat(other))
+          end
+
+          private
+
+          def cast(type, value)
+            db_type = type.optional? ? type.right.meta[:type] : type.meta[:type]
+            Sequel.cast(value, db_type)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+module ROM
+  module SQL
+    module Postgres
+      module Values
+        Point = ::Struct.new(:x, :y)
+
+        Line = ::Struct.new(:a, :b, :c)
+
+        Circle = ::Struct.new(:center, :radius)
+
+        Box = ::Struct.new(:upper_right, :lower_left)
+
+        LineSegment = ::Struct.new(:begin, :end)
+
+        Path = ::Struct.new(:points, :type) do
+          def open?
+            type == :open
+          end
+
+          def closed?
+            type == :closed
+          end
+
+          def to_a
+            points
+          end
+        end
+      end
+
+      # @api public
+      module Types
+        # The list of geometric data types supported by PostgreSQL
+        # @see https://www.postgresql.org/docs/current/static/datatype-geometric.html
+
+        Point = 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)
+            Values::Point.new(Float(x), Float(y))
+          end
+        end
+
+        Line = 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)
+            Values::Line.new(Float(a), Float(b), Float(c))
+          end
+        end
+
+        Circle = 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)
+            center = Values::Point.new(Float(x), Float(y))
+            Values::Circle.new(center, Float(r))
+          end
+        end
+
+        Box = SQL::Types.define(Values::Box) do
+          input do |box|
+            "((#{ 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)
+            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)
+          end
+        end
+
+        LineSegment = SQL::Types.define(Values::LineSegment) do
+          input do |segment|
+            "[(#{ 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)
+            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)
+          end
+        end
+
+        Polygon = SQL::Types.define(::Array) do
+          input do |points|
+            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.map { |x, y| Values::Point.new(Float(x), Float(y)) }
+          end
+        end
+
+        Path = SQL::Types.define(Values::Path) do
+          input do |path|
+            points_joined = path.to_a.map { |p| "(#{ p.x },#{ p.y })" }.join(',')
+
+            if path.open?
+              "[#{ points_joined }]"
+            else
+              "(#{ points_joined })"
+            end
+          end
+
+          output do |path|
+            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
+              Values::Path.new(points, :open)
+            else
+              Values::Path.new(points, :closed)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,235 @@
+require 'sequel/core'
+
+Sequel.extension(*%i(pg_json pg_json_ops))
+
+module ROM
+  module SQL
+    module Postgres
+      module Types
+        JSONRead = (SQL::Types::Array | SQL::Types::Hash).constructor do |value|
+          if value.respond_to?(:to_hash)
+            value.to_hash
+          elsif value.respond_to?(:to_ary)
+            value.to_ary
+          else
+            value
+          end
+        end
+
+        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)
+        end
+
+        # @!parse
+        #   class SQL::Attribute
+        #     # @!method contain(value)
+        #     #   Check whether the JSON value includes a json value
+        #     #   Translates to the @> operator
+        #     #
+        #     #   @example
+        #     #     people.where { fields.contain(gender: 'Female') }
+        #     #     people.where(people[:fields].contain([name: 'age']))
+        #     #     people.select { fields.contain(gender: 'Female').as(:is_female) }
+        #     #
+        #     #   @param [Hash,Array,Object] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method contained_by(value)
+        #     #   Check whether the JSON value is contained by other value
+        #     #   Translates to the <@ operator
+        #     #
+        #     #   @example
+        #     #     people.where { custom_values.contained_by(age: 25, foo: 'bar') }
+        #     #
+        #     #   @param [Hash,Array] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method get(*path)
+        #     #   Extract the JSON value using at the specified path
+        #     #   Translates to -> or #> depending on the number of arguments
+        #     #
+        #     #   @example
+        #     #     people.select { data.get('age').as(:person_age) }
+        #     #     people.select { fields.get(0).as(:first_field) }
+        #     #     people.select { fields.get('0', 'value').as(:first_field_value) }
+        #     #
+        #     #   @param [Array<Integer>,Array<String>] path Path to extract
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::JSON>,SQL::Attribute<Types::PG::JSONB>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method get_text(*path)
+        #     #   Extract the JSON value as text using at the specified path
+        #     #   Translates to ->> or #>> depending on the number of arguments
+        #     #
+        #     #   @example
+        #     #     people.select { data.get('age').as(:person_age) }
+        #     #     people.select { fields.get(0).as(:first_field) }
+        #     #     people.select { fields.get('0', 'value').as(:first_field_value) }
+        #     #
+        #     #   @param [Array<Integer>,Array<String>] path Path to extract
+        #     #
+        #     #   @return [SQL::Attribute<Types::String>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method has_key(key)
+        #     #   Does the JSON value have the specified top-level key
+        #     #   Translates to ?
+        #     #
+        #     #   @example
+        #     #     people.where { data.has_key('age') }
+        #     #
+        #     #   @param [String] key
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method has_any_key(*keys)
+        #     #   Does the JSON value have any of the specified top-level keys
+        #     #   Translates to ?|
+        #     #
+        #     #   @example
+        #     #     people.where { data.has_any_key('age', 'height') }
+        #     #
+        #     #   @param [Array<String>] keys
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method has_all_keys(*keys)
+        #     #   Does the JSON value have all the specified top-level keys
+        #     #   Translates to ?&
+        #     #
+        #     #   @example
+        #     #     people.where { data.has_all_keys('age', 'height') }
+        #     #
+        #     #   @param [Array<String>] keys
+        #     #
+        #     #   @return [SQL::Attribute<Types::Bool>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method merge(value)
+        #     #   Concatenate two JSON values
+        #     #   Translates to ||
+        #     #
+        #     #   @example
+        #     #     people.select { data.merge(fetched_at: Time.now).as(:data) }
+        #     #     people.select { (fields + [name: 'height', value: 165]).as(:fields) }
+        #     #
+        #     #   @param [Hash,Array] value
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::JSONB>]
+        #     #
+        #     #   @api public
+        #
+        #     # @!method +(value)
+        #     #   An alias for SQL::Attribute<JSONB>#merge
+        #     #
+        #     #   @api public
+        #
+        #     # @!method delete(*path)
+        #     #   Deletes the specified value by key, index, or path
+        #     #   Translates to - or #- depending on the number of arguments
+        #     #
+        #     #   @example
+        #     #     people.select { data.delete('age').as(:data_without_age) }
+        #     #     people.select { fields.delete(0).as(:fields_without_first) }
+        #     #     people.select { fields.delete(-1).as(:fields_without_last) }
+        #     #     people.select { data.delete('deeply', 'nested', 'value').as(:data) }
+        #     #     people.select { fields.delete('0', 'name').as(:data) }
+        #     #
+        #     #   @param [Array<String>] path
+        #     #
+        #     #   @return [SQL::Attribute<Types::PG::JSONB>]
+        #     #
+        #     #   @api public
+        #   end
+        module JSONMethods
+          def self.[](type, wrap)
+            parent = self
+            Module.new do
+              include parent
+              define_method(:json_type) { type }
+              define_method(:wrap, wrap)
+            end
+          end
+
+          def get(type, expr, *path)
+            Attribute[json_type].meta(sql_expr: wrap(expr)[path_args(path)])
+          end
+
+          def get_text(type, expr, *path)
+            Attribute[SQL::Types::String].meta(sql_expr: wrap(expr).get_text(path_args(path)))
+          end
+
+          private
+
+          def path_args(path)
+            case path.size
+            when 0 then raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
+            when 1 then path[0]
+            else path
+            end
+          end
+        end
+
+        TypeExtensions.register(JSON) do
+          include JSONMethods[JSON, :pg_json.to_proc]
+        end
+
+        TypeExtensions.register(JSONB) do
+          include JSONMethods[JSONB, :pg_jsonb.to_proc]
+
+          def contain(type, expr, value)
+            Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).contains(value))
+          end
+
+          def contained_by(type, expr, value)
+            Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).contained_by(value))
+          end
+
+          def has_key(type, expr, key)
+            Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).has_key?(key))
+          end
+
+          def has_any_key(type, expr, *keys)
+            Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).contain_any(keys))
+          end
+
+          def has_all_keys(type, expr, *keys)
+            Attribute[SQL::Types::Bool].meta(sql_expr: wrap(expr).contain_all(keys))
+          end
+
+          def merge(type, expr, value)
+            Attribute[JSONB].meta(sql_expr: wrap(expr).concat(value))
+          end
+          alias_method :+, :merge
+
+          def delete(type, expr, *path)
+            sql_expr = path.size == 1 ? wrap(expr) - path : wrap(expr).delete_path(path)
+            Attribute[JSONB].meta(sql_expr: sql_expr)
+          end
+        end
+      end
+    end
+  end
+end