rom-sql 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc6edcd56b3aeda31a41f53c921aa2a79dd19ffc
-  data.tar.gz: d954520aa88474fcf6d61897ea0f1fed50e876ee
+  metadata.gz: 945fbfbd11ed73e702c332f2c86824cb32b97f7c
+  data.tar.gz: 7642f9bf09223210d49bf4b1440f42538ceeb38a
 SHA512:
-  metadata.gz: 9f9f16bab1aef147b4956217362a1e08ec3f08dda74fc624c1e82622b6614e7bf557f8a47026f94dad182f4c34fe9fddebb3f33e876902355938f051a9c239f2
-  data.tar.gz: faa2da9349e0f26bfe53ed96a6e145a444a21ce100930191324650399d26a9aeeaa23ff1485b4cddc20532fda67e7667276bcd98ec460eecb7f0a1053f498347
+  metadata.gz: f74fbc365378212045ad117f5d5af04182e4957beaec11681328a410f20fb9ce817621b2116d3dd50b347f579acfd3d3d8d45bc251ae64ba2c904b15341d6aed
+  data.tar.gz: 88e1f6ed6f65489daca34b8a325e939d6dec3cf37fe40af80821a91319029bc404d888d436324638aa0540f67605435d9b744588d31f052c75e8a88e3eb98ea3

data/.travis.yml

@@ -11,18 +11,22 @@ before_script:
   - mysql -u root -e 'create database rom_sql;'
   - rvm get master
 after_success:
-  - '[ "${TRAVIS_JOB_NUMBER#*.}" = "1" ] && [ "$TRAVIS_BRANCH" = "master" ] && bundle exec codeclimate-test-reporter'
+  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
 script: "bundle exec rake ci"
 rvm:
-  - 2.4.0
-  - 2.3
-  - 2.2
+  - 2.2.7
+  - 2.3.4
+  - 2.4.1
   - rbx-3
-  - jruby-9.1.7.0
+  - jruby-9.1.8.0
+matrix:
+  allow_failures:
+    - rvm: rbx-3
 env:
   global:
     - CODECLIMATE_REPO_TOKEN=03d7f66589572702b12426d2bc71c4de6281a96139e33b335b894264b1f8f0b0
     - JRUBY_OPTS='--dev -J-Xmx1024M'
+    - COVERAGE='true'
 notifications:
   webhooks:
     urls:

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## v1.3.0 2017-05-02
+
+### Added
+
+* New `Relation#exist?` predicate checks if the relation has at least one tuple (flash-gordon)
+* Support for JSONB transformations and queries using native DSL (flash-gordon)
+* Add `ROM::SQL::Attribute#not` for negated boolean equality expressions (AMHOL)
+* Add `ROM::SQL::Attribute#!` for negated attribute's sql expressions (solnic)
+* Inferrer gets limit constraints for string data types and stores them in type's meta (v-kolesnikov)
+
+### Fixed
+
+* Fixed usage of PostgreSQL's commands with a composite relation (flash-gordon)
+* Translation of `true/false/nil` equality checks to `is/is not` SQL statements in `ROM::SQL::Attribute#is` (AMHOL)
+
+### Changed
+
+* Global private interface `SQL::Gateway.instance` has been deprecated. Now if you run migrations
+  with ROM you should set up a ROM config in the `db:setup` task with something similar to
+
+  ```ruby
+    namespace :db
+      task :setup do
+        ROM::SQL::RakeSupport.env = ROM::Configuration.new(:sql, ENV['DATABASE_URL'])
+      end
+    end
+  ```
+
+[Compare v1.2.2...v1.3.0](https://github.com/rom-rb/rom-sql/compare/v1.2.2...v1.3.0)
+
 ## v1.2.2 2017-03-25
 
 ### Changed

data/lib/rom/plugins/relation/sql/auto_wrap.rb

@@ -35,9 +35,9 @@ module ROM
               rel, other =
                 if associations.key?(name)
                   assoc = associations[name]
-                  other = __registry__[assoc.target.to_sym]
+                  other = __registry__[assoc.target.relation]
 
-                  [assoc.join(__registry__, :inner_join, self), other]
+                  [assoc.join(__registry__, :inner_join, self, other), other]
                 else
                   # TODO: deprecate this before 2.0
                   other = __registry__[name]

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

@@ -46,6 +46,18 @@ module ROM
           end
         end
 
+        # @api private
+        def persist(relations, children, parents)
+          join_tuples = associate(relations, children, parents)
+          join_relation = join_relation(relations)
+          join_relation.multi_insert(join_tuples)
+        end
+
+        # @api private
+        def parent_combine_keys(relations)
+          relations[target].associations[source].combine_keys(relations).to_a.flatten(1)
+        end
+
         # @api public
         def join(relations, type, source = relations[self.source], target = relations[self.target])
           through_assoc = source.associations[through]

data/lib/rom/sql/attribute.rb

@@ -1,4 +1,5 @@
 require 'sequel/core'
+require 'dry/core/cache'
 
 require 'rom/schema/attribute'
 require 'rom/sql/projection_dsl'
@@ -10,10 +11,61 @@ module ROM
     # @api public
     class Attribute < ROM::Schema::Attribute
       OPERATORS = %i[>= <= > <].freeze
+      NONSTANDARD_EQUALITY_VALUES = [true, false, nil].freeze
 
       # Error raised when an attribute cannot be qualified
       QualifyError = Class.new(StandardError)
 
+      # Type-specific methods
+      #
+      # @api public
+      module TypeExtensions
+        class << self
+          # Gets extensions for a type
+          #
+          # @param [Dry::Types::Type] type
+          #
+          # @return [Hash]
+          #
+          # @api public
+          def [](type)
+            unwrapped = type.optional? ? type.right : type
+            @types[unwrapped.pristine] || EMPTY_HASH
+          end
+
+          # Registers a set of operations supported for a specific type
+          #
+          # @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)
+          #     end
+          #   end
+          #
+          # @param [Dry::Types::Type] type Type
+          #
+          # @api public
+          def register(type, &block)
+            raise ArgumentError, "Type #{ type } already registered" if @types.key?(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) }
+            @types[type] = functions
+          end
+        end
+
+        @types = {}
+      end
+
+      extend Dry::Core::Cache
+
+      # @api private
+      def self.[](*args)
+        fetch_or_store(args) { new(*args) }
+      end
+
+      option :extensions, type: Types::Hash, default: -> { TypeExtensions[type] }
+
       # Return a new attribute with an alias
       #
       # @example
@@ -140,7 +192,7 @@ module ROM
           end
       end
 
-      # Return a boolean expression with `=` operator
+      # Return a boolean expression with an equality operator
       #
       # @example
       #   users.where { id.is(1) }
@@ -151,7 +203,38 @@ module ROM
       #
       # @api public
       def is(other)
-        __cmp__(:'=', other)
+        self =~ other
+      end
+
+      # @api public
+      def =~(other)
+        meta(sql_expr: sql_expr =~ binary_operation_arg(other))
+      end
+
+      # Return a boolean expression with a negated equality operator
+      #
+      # @example
+      #   users.where { id.not(1) }
+      #
+      #   users.where(users[:id].not(1))
+      #
+      # @param [Object] other Any SQL-compatible object type
+      #
+      # @api public
+      def not(other)
+        !is(other)
+      end
+
+      # Negate the attribute's sql expression
+      #
+      # @example
+      #   users.where(!users[:id].is(1))
+      #
+      # @return [Attribute]
+      #
+      # @api public
+      def !
+        ~self
       end
 
       # Return a boolean expression with an inclusion test
@@ -241,6 +324,8 @@ module ROM
       def method_missing(meth, *args, &block)
         if OPERATORS.include?(meth)
           __cmp__(meth, args[0])
+        elsif extensions.key?(meth)
+          extensions[meth].(type, sql_expr, *args, &block)
         elsif sql_expr.respond_to?(meth)
           meta(sql_expr: sql_expr.__send__(meth, *args, &block))
         else
@@ -253,15 +338,19 @@ module ROM
       #
       # @api private
       def __cmp__(op, other)
-        value =
-          case other
-          when Sequel::SQL::Expression
-            value
-          else
-            type[other]
-          end
+        Sequel::SQL::BooleanExpression.new(op, self, binary_operation_arg(other))
+      end
 
-        Sequel::SQL::BooleanExpression.new(op, self, value)
+      # Preprocess input value for binary operations
+      #
+      # @api private
+      def binary_operation_arg(value)
+        case value
+        when Sequel::SQL::Expression
+          value
+        else
+          type[value]
+        end
       end
     end
   end

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

@@ -10,9 +10,11 @@ module ROM
           #
           # @api private
           def insert(tuples)
-            tuples.map do |tuple|
+            dataset = tuples.map do |tuple|
               relation.dataset.returning(*relation.columns).insert(tuple)
             end.flatten(1)
+
+            wrap_dataset(dataset)
           end
 
           # Executes multi_insert statement and returns inserted tuples
@@ -36,7 +38,8 @@ module ROM
           #
           # @api private
           def update(tuple)
-            relation.dataset.returning(*relation.columns).update(tuple)
+            dataset = relation.dataset.returning(*relation.columns).update(tuple)
+            wrap_dataset(dataset)
           end
         end
 

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

@@ -40,6 +40,166 @@ module ROM
 
         JSONB = JSONBArray | JSONBHash | JSONBOp
 
+        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)
+          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
+
         # HStore
 
         HStoreR = Types.Constructor(Hash, &:to_hash)