rom-sql 1.3.1 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7bcf2dc42045eeec0c29f7f4eb833b9e1381e63
-  data.tar.gz: 43a0ea01c51a400e1af5c1bb84aaf54d05851597
+  metadata.gz: dfb29b79f9b58b2fc9b30752951636130b525440
+  data.tar.gz: 2f6b70d93abf536152d991cb689bd77c699a6e83
 SHA512:
-  metadata.gz: 86b7528f10243b97aabc0c0c17f2d1c55bf7e8f4827d6e85b882635c27a83bb100c24edab9c2d4c5d6ff79b5307dc83f3bd14c10414c8f452cbae995f4fb1f59
-  data.tar.gz: a341dca4d4034d960e2f991f37177a4681a23d8aff252cc9e239ac96625f9277ca968b253acff75fa9aaf1ce2ce54672cc29357a2eb1a8a96e7824d41fa655e7
+  metadata.gz: ac6401a56919535a010c3ad049d63df969873c73169f629c5875edd343b404cf02ffc81f3458e9bbb6d3c20edc066fa5e26b2db30840a321f5ea10d5a86c5de4
+  data.tar.gz: d9e27f5a201c515fcd2d2d0a2f5cacae6cfdd2f44d1dfd5c0260c2121714c0491f8c49f87ed6120690d8d7f1603dcbc7308598c7e1000c4da4b775cf8d5494fa

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## v1.3.2 to-be-released
+
+## Added
+
+* Support for filtering with a SQL function in the `WHERE` clause. Be sure you're using it wisely and don't call it on large datasets ;) (flash-gordon)
+* `Void` type for calling functions without returning value (flash-gordon)
+* Support for `PG::Array` transformations and queries (flash-gordon)
+
+## Fixed
+
+* A bunch of warnings from Sequel 4.46
+
+## v1.3.1 2017-05-05
+
+## Changed
+
+* [internal] Compatibility with `dry-core` v0.3.0 (flash-gordon)
+
+[Compare v1.3.0...v1.3.1](https://github.com/rom-rb/rom-sql/compare/v1.3.0...v1.3.1)
+
 ## v1.3.0 2017-05-02
 
 ### Added

data/lib/rom/sql/association.rb

@@ -81,7 +81,7 @@ module ROM
       # @api protected
       def apply_view(schema, relation)
         view_rel = relation.public_send(view)
-        schema.merge(view_rel.schema.qualified).uniq(&:to_sym).(view_rel)
+        schema.merge(view_rel.schema.qualified).uniq(&:to_sql_name).(view_rel)
       end
 
       # @api private

data/lib/rom/sql/association/many_to_one.rb

@@ -52,7 +52,7 @@ module ROM
 
         # @api private
         def source_table
-          self_ref? ? :"#{source.dataset}___#{source_alias}" : source
+          self_ref? ? Sequel.as(source.dataset, source_alias) : source
         end
 
         # @api private

data/lib/rom/sql/association/name.rb

@@ -70,7 +70,7 @@ module ROM
         end
 
         def sql_literal(ds)
-          Sequel.expr(aliased? ? :"#{dataset}___#{key}" : dataset).sql_literal(ds)
+          ds.literal(aliased? ? Sequel[dataset] : Sequel.as(dataset, key))
         end
       end
     end

data/lib/rom/sql/association/one_to_many.rb

@@ -39,7 +39,7 @@ module ROM
 
         # @api private
         def source_table
-          self_ref? ? :"#{source.dataset}___#{source_alias}" : source
+          self_ref? ? Sequel.as(source.dataset, source_alias) : source
         end
 
         # @api private

data/lib/rom/sql/attribute.rb

@@ -37,8 +37,8 @@ module ROM
           #
           # @example
           #   ROM::SQL::Attribute::TypeExtensions.register(ROM::SQL::Types::PG::JSONB) do
-          #     def contains(type, keys)
-          #       Sequel::Postgres::JSONBOp.new(type.meta[:name]).contains(keys)
+          #     def contain(type, expr, keys)
+          #       Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contains(value))
           #     end
           #   end
           #
@@ -104,7 +104,7 @@ module ROM
         case sql_expr
         when Sequel::SQL::AliasedExpression, Sequel::SQL::Identifier
           type = meta(qualified: true)
-          type.meta(qualified: true, sql_expr: Sequel[type.to_sym])
+          type.meta(sql_expr: type.to_sql_name)
         else
           raise QualifyError, "can't qualify #{name.inspect} (#{sql_expr.inspect})"
         end
@@ -302,11 +302,25 @@ module ROM
       #
       # @api private
       def sql_literal(ds)
-        if sql_expr
-          sql_expr.sql_literal(ds)
-        else
-          Sequel[to_sym].sql_literal(ds)
-        end
+        ds.literal(sql_expr)
+      end
+
+      # Sequel column representation
+      #
+      # @return [Sequel::SQL::AliasedExpression,Sequel::SQL::Identifier]
+      #
+      # @api private
+      def to_sql_name
+        @_to_sql_name ||=
+          if qualified? && aliased?
+            Sequel.qualify(source.dataset, name).as(meta[:alias])
+          elsif qualified?
+            Sequel.qualify(source.dataset, name)
+          elsif aliased?
+            Sequel.as(name, meta[:alias])
+          else
+            Sequel[name]
+          end
       end
 
       private
@@ -315,7 +329,7 @@ module ROM
       #
       # @api private
       def sql_expr
-        @sql_expr ||= (meta[:sql_expr] || Sequel[to_sym])
+        @sql_expr ||= (meta[:sql_expr] || to_sql_name)
       end
 
       # Delegate to sql expression if it responds to a given method

data/lib/rom/sql/dsl.rb

@@ -25,6 +25,19 @@ module ROM
       def respond_to_missing?(name, include_private = false)
         super || schema.key?(name)
       end
+
+      private
+
+      # @api private
+      def type(identifier)
+        type_name = ::Dry::Core::Inflector.classify(identifier)
+        types.const_get(type_name) if types.const_defined?(type_name)
+      end
+
+      # @api private
+      def types
+        ::ROM::SQL::Types
+      end
     end
   end
 end

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

@@ -11,7 +11,7 @@ module ROM
           # @api private
           def insert(tuples)
             dataset = tuples.map do |tuple|
-              relation.dataset.returning(*relation.columns).insert(tuple)
+              relation.dataset.returning.insert(tuple)
             end.flatten(1)
 
             wrap_dataset(dataset)
@@ -21,7 +21,7 @@ module ROM
           #
           # @api private
           def multi_insert(tuples)
-            relation.dataset.returning(*relation.columns).multi_insert(tuples)
+            relation.dataset.returning.multi_insert(tuples)
           end
 
           # Executes upsert statement (INSERT with ON CONFLICT clause)
@@ -29,7 +29,7 @@ module ROM
           #
           # @api private
           def upsert(tuple, opts = EMPTY_HASH)
-            relation.dataset.returning(*relation.columns).insert_conflict(opts).insert(tuple)
+            relation.dataset.returning.insert_conflict(opts).insert(tuple)
           end
         end
 
@@ -38,7 +38,7 @@ module ROM
           #
           # @api private
           def update(tuple)
-            dataset = relation.dataset.returning(*relation.columns).update(tuple)
+            dataset = relation.dataset.returning.update(tuple)
             wrap_dataset(dataset)
           end
         end

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

@@ -20,6 +20,133 @@ module ROM
           Array.constructor(-> (v) { Sequel.pg_array(v, db_type) }).meta(type: db_type)
         end
 
+        # @!parse
+        #   class ROM::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
+        Attribute::TypeExtensions.register(Array.constructor -> {  }) do
+          def contain(type, expr, other)
+            Attribute[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[Types::Bool].meta(sql_expr: { value => expr.pg_array.any })
+          end
+
+          def contained_by(type, expr, other)
+            Attribute[Types::Bool].meta(sql_expr: expr.pg_array.contained_by(type[other]))
+          end
+
+          def length(type, expr)
+            Attribute[Types::Int].meta(sql_expr: expr.pg_array.length)
+          end
+
+          def overlaps(type, expr, other_array)
+            Attribute[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(value))
+          end
+
+          def join(type, expr, delimiter = '', null = nil)
+            Attribute[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
+        end
+
         # JSON
 
         JSONArray = Types.Constructor(Sequel::Postgres::JSONArray, &Sequel.method(:pg_json))
@@ -40,150 +167,175 @@ module ROM
 
         JSONB = JSONBArray | JSONBHash | JSONBOp
 
+        # @!parse
+        #   class ROM::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::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 has 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 has 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 has 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 ROM::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
         Attribute::TypeExtensions.register(JSONB) do
-          # Checks 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
           def contain(type, expr, value)
             Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contains(value))
           end
 
-          # Checks 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
           def contained_by(type, expr, value)
             Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contained_by(value))
           end
 
-          # Extracts 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::JSONB>]
-          #
-          # @api public
           def get(type, expr, *path)
             Attribute[JSONB].meta(sql_expr: expr.pg_jsonb[path_args(path)])
           end
 
-          # Extracts 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
           def get_text(type, expr, *path)
             Attribute[Types::String].meta(sql_expr: expr.pg_jsonb.get_text(path_args(path)))
           end
 
-          # Does the JSON value has the specified top-level key
-          # Translates to ?
-          #
-          # @example
-          #   people.where { data.has_key('age') }
-          #
-          # @param [String] key
-          #
-          # @return [SQL::Attribute<Types::Bool>]
-          #
-          # @api public
           def has_key(type, expr, key)
             Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.has_key?(key))
           end
 
-          # Does the JSON value has 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
           def has_any_key(type, expr, *keys)
             Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contain_any(keys))
           end
 
-          # Does the JSON value has 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
           def has_all_keys(type, expr, *keys)
             Attribute[Types::Bool].meta(sql_expr: expr.pg_jsonb.contain_all(keys))
           end
 
-          # Concatenates 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
           def merge(type, expr, value)
             Attribute[JSONB].meta(sql_expr: expr.pg_jsonb.concat(value))
           end
           alias_method :+, :merge
 
-          # 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
           def delete(type, expr, *path)
             sql_expr = path.size == 1 ? expr.pg_jsonb - path : expr.pg_jsonb.delete_path(path)
             Attribute[JSONB].meta(sql_expr: sql_expr)