rom-sql 3.2.0 → 3.3.0

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2019 rom-rb team
+Copyright (c) 2015-2020 rom-rb team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.md

@@ -1,70 +1,28 @@
 [gem]: https://rubygems.org/gems/rom-sql
 [actions]: https://github.com/rom-rb/rom-sql/actions
-[codeclimate]: https://codeclimate.com/github/rom-rb/rom-sql
-[inchpages]: http://inch-ci.org/github/rom-rb/rom-sql
+[codacy]: https://www.codacy.com/gh/rom-rb/rom-sql
 [chat]: https://rom-rb.zulipchat.com
+[inchpages]: http://inch-ci.org/github/rom-rb/rom-sql
 
-# rom-sql [![Join the chat at https://rom-rb.zulipchat.com](https://img.shields.io/badge/rom--rb-join%20chat-942283.svg)][chat]
+# rom-sql [![Join the chat at https://rom-rb.zulipchat.com](https://img.shields.io/badge/rom--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://badge.fury.io/rb/rom-sql.svg)][gem]
 [![CI Status](https://github.com/rom-rb/rom-sql/workflows/ci/badge.svg)][actions]
-[![Code Climate](https://codeclimate.com/github/rom-rb/rom-sql/badges/gpa.svg)][codeclimate]
-[![Test Coverage](https://codeclimate.com/github/rom-rb/rom-sql/badges/coverage.svg)][codeclimate]
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/8e2cbaf78af44185876c8fa41540d7ea)][codacy]
+[![Codacy Badge](https://api.codacy.com/project/badge/Coverage/8e2cbaf78af44185876c8fa41540d7ea)][codacy]
 [![Inline docs](http://inch-ci.org/github/rom-rb/rom-sql.svg?branch=master)][inchpages]
 
-SQL support for [rom-rb](https://github.com/rom-rb/rom).
-
-Resources:
-
-- [User Documentation](http://rom-rb.org/learn/sql/)
-- [API Documentation](http://rubydoc.info/gems/rom-sql)
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'rom-sql'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install rom-sql
-
-## Docker
-
-### Development
-
-In order to have reproducible environment for development, Docker can be used. Provided it's installed, in order to start developing, one can simply execute:
-
-```bash
-docker-compose run --rm gem "bash"
-```
-
-If this is the first time this command is executed, it will take some time to set up the dependencies and build the rom-sql container. This should happen only on first execution and in case dependency images are removed.
-
-After dependencies are set container will be started in a bash shell.
-
-### Testing
-
-In order to test the changes, execute:
+## Links
 
-```bash
-docker-compose build gem
-bin/run-specs
-```
+* [User documentation](http://rom-rb.org/learn/sql)
+* [API documentation](http://rubydoc.info/gems/rom-sql)
 
-### Stopping the dependencies
+## Supported Ruby versions
 
-In order to stop the dependencies, execute:
+This library officially supports the following Ruby versions:
 
-```bash
-docker-compose down --remove-orphans --volumes
-```
+* MRI >= `2.5`
+* jruby >= `9.2`
 
 ## License
 

data/lib/rom/plugins/relation/sql/postgres/full_text_search.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ROM
+  module Plugins
+    module Relation
+      module SQL
+        module Postgres
+          # PG-specific extensions which adds `Relation#full_text_search` method
+          #
+          # @api public
+          module FullTextSearch
+            # Run a full text search on PostgreSQL.
+            # By default, searching for the inclusion of any of the terms in any of the cols.
+            #
+            # @example
+            #   posts.full_text_search([:title, :content], 'apples', language: 'english') # => Relation which match the 'apples' phrase
+            #
+            # @option :headline [String] Append a expression to the selected columns aliased to headline that contains an extract of the matched text.
+            #
+            # @option :language [String] The language to use for the search (default: 'simple')
+            #
+            # @option :plain [Boolean] Whether a plain search should be used (default: false).  In this case, terms should be a single string, and it will do a search where cols contains all of the words in terms.  This ignores search operators in terms.
+            #
+            # @option :phrase [Boolean] Similar to :plain, but also adding an ILIKE filter to ensure that returned rows also include the exact phrase used.
+            #
+            # @option :rank [Boolean] Set to true to order by the rank, so that closer matches are returned first.
+            #
+            # @option :to_tsquery [Symbol] Can be set to :plain or :phrase to specify the function to use to convert the terms to a ts_query.
+            #
+            # @option :tsquery [Boolean] Specifies the terms argument is already a valid SQL expression returning a tsquery, and can be used directly in the query.
+            #
+            # @option :tsvector [Boolean] Specifies the cols argument is already a valid SQL expression returning a tsvector, and can be used directly in the query.
+            #
+            # @return [Relation]
+            #
+            # @see https://www.postgresql.org/docs/current/textsearch.html PostgreSQL docs
+            #
+            # @api public
+            def full_text_search(*args, &block)
+              new dataset.__send__(__method__, *args, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ROM.plugins do
+  adapter :sql do
+    register :pg_full_text_search, ROM::Plugins::Relation::SQL::Postgres::FullTextSearch, type: :relation
+  end
+end

data/lib/rom/plugins/relation/sql/postgres/streaming.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module ROM
+  module Plugins
+    module Relation
+      module SQL
+        module Postgres
+          # PG-specific extensions which adds `Relation#stream` method
+          #
+          # @api public
+          module Streaming
+            extend Notifications::Listener
+
+            class StreamingNotSupportedError < StandardError; end
+
+            subscribe("configuration.gateway.connected") do |opts|
+              conn = opts[:connection]
+
+              next unless conn.database_type.to_sym == :postgres
+
+              next if defined?(JRUBY_VERSION)
+
+              begin
+                require "sequel_pg"
+              rescue LoadError
+                raise StreamingNotSupportedError, "add sequel_pg to Gemfile to use pg_streaming"
+              end
+
+              unless Sequel::Postgres.supports_streaming?
+                raise StreamingNotSupportedError, "postgres version does not support streaming"
+              end
+
+              conn.extension(:pg_streaming)
+            end
+
+            def self.included(klass)
+              super
+              ROM::Relation::Graph.include(Combined)
+            end
+
+            if defined?(JRUBY_VERSION)
+              # Allows you to stream returned rows one at a time, instead of
+              # collecting the entire result set in memory. Requires the `sequel_pg` gem
+              #
+              # @see https://github.com/jeremyevans/sequel_pg#streaming- sequel_pg docs
+              #
+              # @example
+              #   posts.steam_each { |post| puts CSV.generate_line(post) }
+              #
+              # @return [Relation]
+              #
+              # @api publicY_VERSION
+              def stream_each
+                raise StreamingNotSupportedError, "not supported on jruby"
+              end
+            else
+              # Allows you to stream returned rows one at a time, instead of
+              # collecting the entire result set in memory. Requires the `sequel_pg` gem
+              #
+              # @see https://github.com/jeremyevans/sequel_pg#streaming- sequel_pg docs
+              #
+              # @example
+              #   posts.steam_each { |post| puts CSV.generate_line(post) }
+              #
+              # @return [Relation]
+              #
+              # @api public
+              def stream_each
+                return to_enum unless block_given?
+
+                ds = dataset.stream
+
+                if auto_map?
+                  ds.each { |tuple| yield(mapper.([output_schema[tuple]]).first) }
+                else
+                  ds.each { |tuple| yield(output_schema[tuple]) }
+                end
+              end
+
+              module Combined
+                def stream_each
+                  raise StreamingNotSupportedError, "not supported on combined relations"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ROM.plugins do
+  adapter :sql do
+    register :pg_streaming, ROM::Plugins::Relation::SQL::Postgres::Streaming, type: :relation
+  end
+end

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

@@ -20,7 +20,7 @@ module ROM
               if target != self.target
                 target.schema.merge(join_schema)
               else
-                left.schema.project(*columns)
+                left.schema.uniq.project(*columns)
               end
             else
               target_schema

data/lib/rom/sql/attribute.rb

@@ -67,6 +67,21 @@ module ROM
         end
       end
 
+      # Return a new attribute that is aliased and marked as qualified
+      #
+      # Intended to be used when passing attributes to `dataset#select`
+      #
+      # @return [SQL::Attribute]
+      #
+      # @api public
+      def qualified_projection(table_alias = nil)
+        if aliased?
+          qualified(table_alias).aliased(self.alias)
+        else
+          qualified(table_alias)
+        end
+      end
+
       # Return a new attribute marked as joined
       #
       # Whenever you join two schemas, the right schema's attribute
@@ -285,11 +300,11 @@ module ROM
       # @api private
       def to_sql_name
         @_to_sql_name ||=
-          if qualified? && aliased?
+          if qualified? && aliased_projection?
             Sequel.qualify(table_name, name).as(self.alias)
           elsif qualified?
             Sequel.qualify(table_name, name)
-          elsif aliased?
+          elsif aliased_projection?
             Sequel.as(name, self.alias)
           else
             Sequel[name]

data/lib/rom/sql/attribute_aliasing.rb

@@ -21,6 +21,34 @@ module ROM
       end
       alias as aliased
 
+
+      # Return true if this attribute is an aliased projection
+      #
+      # @example
+      #   class Tasks < ROM::Relation[:memory]
+      #     schema do
+      #       attribute :user_id, Types::Integer, alias: :id
+      #       attribute :name, Types::String
+      #     end
+      #   end
+      #
+      #   Users.schema[:user_id].aliased?
+      #   # => true
+      #   Users.schema[:user_id].aliased_projection?
+      #   # => false
+      #
+      #   Users.schema[:user_id].qualified_projection.aliased?
+      #   # => true
+      #   Users.schema[:user_id].qualified_projection.aliased_projection?
+      #   # => true
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @api private
+      def aliased_projection?
+        self.meta[:sql_expr].is_a?(Sequel::SQL::AliasedExpression)
+      end
+
       private
 
       # @api private

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

@@ -5,3 +5,5 @@ require 'rom/sql/extensions/postgres/types'
 require 'rom/sql/extensions/postgres/type_builder'
 require 'rom/sql/extensions/postgres/type_serializer'
 require 'rom/plugins/relation/sql/postgres/explain'
+require 'rom/plugins/relation/sql/postgres/full_text_search'
+require "rom/plugins/relation/sql/postgres/streaming"

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

@@ -17,7 +17,7 @@ module ROM
           #
           # @api private
           def returning_dataset
-            relation.dataset.returning(*relation.qualified_columns)
+            relation.dataset.returning(*relation.schema.qualified_projection)
           end
         end
 

data/lib/rom/sql/function.rb

@@ -78,6 +78,15 @@ module ROM
         )
       end
 
+      # @see Attribute#qualified_projection
+      #
+      # @api private
+      def qualified_projection(table_alias = nil)
+        meta(
+          func: ::Sequel::SQL::Function.new(func.name, *func.args.map { |arg| arg.respond_to?(:qualified_projection) ? arg.qualified_projection(table_alias) : arg })
+        )
+      end
+
       # @see Attribute#qualified?
       #
       # @api private
@@ -186,7 +195,7 @@ module ROM
       #   users.project { integer::count(:id).filter(name.is("Jack")).as(:jacks) }.order(nil)
       #   users.project { integer::count(:id).filter { name.is("John") }).as(:johns) }.order(nil)
       #
-      # @param [Hash,SQL::Attribute] Conditions
+      # @param condition [Hash,SQL::Attribute] Conditions
       # @yield [block] A block with restrictions
       #
       # @return [SQL::Function]
@@ -211,7 +220,7 @@ module ROM
       # @example
       #   households.project { fload::percentile_cont(0.5).within_group(income).as(:percentile) }
       #
-      # @param [Array] A list of expressions for sorting within a group
+      # @param args [Array] A list of expressions for sorting within a group
       # @yield [block] A block for getting the expressions using the Order DSL
       #
       # @return [SQL::Function]

data/lib/rom/sql/gateway.rb

@@ -81,6 +81,7 @@ module ROM
       def initialize(uri, options = EMPTY_HASH)
         @connection = connect(uri, options)
         load_extensions(Array(options[:extensions]))
+        Notifications.trigger("configuration.gateway.connected", connection: @connection)
 
         @options = options
 
@@ -247,4 +248,6 @@ module ROM
       end
     end
   end
+
+  Configuration.register_event("configuration.gateway.connected")
 end

data/lib/rom/sql/projection_dsl.rb

@@ -31,7 +31,7 @@ module ROM
       #   users.select { function(:count, :id).as(:total) }
       #
       # @param [Symbol] name SQL function
-      # @param [Symbol] attr
+      # @param [Symbol] attrs
       #
       # @return [Rom::SQL::Function]
       #

data/lib/rom/sql/relation.rb

@@ -37,7 +37,7 @@ module ROM
           table = opts[:from].first
 
           if db.table_exists?(table)
-            select(*schema.map(&:qualified)).order(*schema.project(*schema.primary_key_names).qualified)
+            select(*schema.qualified_projection).order(*schema.project(*schema.primary_key_names).qualified)
           else
             self
           end

data/lib/rom/sql/relation/reading.rb

@@ -1094,7 +1094,7 @@ module ROM
                 join_opts = EMPTY_HASH
               end
 
-              new(dataset.__send__(type, other.name.to_sym, join_cond, join_opts))
+              new(dataset.__send__(type, other.name.dataset.to_sym, join_cond, join_opts))
             else
               associations[other.name.key].join(type, self, other)
             end

data/lib/rom/sql/schema.rb

@@ -67,6 +67,18 @@ module ROM
         new(map { |attr| attr.qualified(table_alias) })
       end
 
+      # Return a new schema with attributes that are aliased
+      # and marked as qualified
+      #
+      # Intended to be used when passing attributes to `dataset#select`
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def qualified_projection(table_alias = nil)
+        new(map { |attr| attr.qualified_projection(table_alias) })
+      end
+
       # Project a schema
       #
       # @see ROM::Schema#project
@@ -129,7 +141,7 @@ module ROM
       #
       # @api public
       def call(relation)
-        relation.new(relation.dataset.select(*self), schema: self)
+        relation.new(relation.dataset.select(*self.qualified_projection), schema: self)
       end
 
       # Return an empty schema