rom-sql 0.7.0 → 0.8.0

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

@@ -0,0 +1,9 @@
+module ROM
+  module SQL
+    class Association
+      class OneToMany < OneToOne
+        result :many
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module ROM
+  module SQL
+    class Association
+      class OneToOne < Association
+        result :one
+
+        # @api public
+        def call(relations)
+          with_keys(relations) do |left_pk, right_fk|
+            right = relations[target.relation]
+            columns = right.header.qualified.to_a
+
+            relation = right
+              .inner_join(source, left_pk => right_fk)
+              .select(*columns)
+              .order(*right.header.project(*right.primary_key).qualified)
+
+            relation.with(attributes: relation.header.names)
+          end
+        end
+
+        # @api public
+        def combine_keys(relations)
+          Hash[*with_keys(relations)]
+        end
+
+        # @api public
+        def join_keys(relations)
+          with_keys(relations) { |source_key, target_key|
+            { qualify(source, source_key) => qualify(target, target_key) }
+          }
+        end
+
+        protected
+
+        # @api private
+        def with_keys(relations, &block)
+          source_key = relations[source.relation].primary_key
+          target_key = relations[target.relation].foreign_key(source.relation)
+          return [source_key, target_key] unless block
+          yield(source_key, target_key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module ROM
+  module SQL
+    class Association
+      class OneToOneThrough < ManyToMany
+        result :one
+      end
+    end
+  end
+end

data/lib/rom/sql/commands.rb

@@ -3,4 +3,6 @@ require 'rom/commands'
 require 'rom/sql/commands/create'
 require 'rom/sql/commands/update'
 require 'rom/sql/commands/delete'
+
+require 'rom/sql/commands/postgres'
 require 'rom/sql/commands_ext/postgres'

data/lib/rom/sql/commands/create.rb

@@ -1,4 +1,3 @@
-require 'rom/sql/commands'
 require 'rom/sql/commands/error_wrapper'
 require 'rom/sql/commands/transaction'
 
@@ -15,6 +14,7 @@ module ROM
         include ErrorWrapper
 
         use :associates
+        use :schema
 
         # Inserts provided tuples into the database table
         #
@@ -40,7 +40,7 @@ module ROM
         # @api private
         def insert(tuples)
           pks = tuples.map { |tuple| relation.insert(tuple) }
-          relation.where(relation.primary_key => pks)
+          relation.where(relation.primary_key => pks).to_a
         end
 
         # Executes multi_insert statement and returns inserted tuples

data/lib/rom/sql/commands/delete.rb

@@ -1,4 +1,3 @@
-require 'rom/sql/commands'
 require 'rom/sql/commands/error_wrapper'
 require 'rom/sql/commands/transaction'
 

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

@@ -0,0 +1,76 @@
+module ROM
+  module SQL
+    module Commands
+      module Postgres
+        # Upsert command
+        #
+        # Uses a feature of PostgreSQL 9.5 commonly called an "upsert".
+        # The command been called attempts to perform an insert and
+        # can make an update (or silently do nothing) in case of
+        # the insertion was unsuccessful due to a violation of a unique
+        # constraint.
+        # Very important implementation detail is that the whole operation
+        # is atomic, i.e. aware of concurrent transactions, and doesn't raise
+        # exceptions if used properly.
+        #
+        # See PG's docs in INSERT statement for details
+        # https://www.postgresql.org/docs/current/static/sql-insert.html
+        #
+        # Normally, the command should configured via class level settings.
+        # By default, that is without any settings provided, the command
+        # uses ON CONFLICT DO NOTHING clause.
+        #
+        # This implementation uses Sequel's API underneath, the docs are available at
+        # http://sequel.jeremyevans.net/rdoc-adapters/classes/Sequel/Postgres/DatasetMethods.html#method-i-insert_conflict
+        #
+        # @api public
+        class Upsert < SQL::Commands::Create
+          adapter :sql
+
+          defines :constraint, :conflict_target, :update_statement, :update_where
+
+          # @!attribute [r] constraint
+          #  @return [Symbol] the name of the constraint expected to be violated
+          option :constraint, reader: true, default: -> c { c.class.constraint }
+
+          # @!attribute [r] conflict_target
+          #  @return [Object] the column or expression to handle a violation on
+          option :conflict_target, reader: true, default: -> c { c.class.conflict_target }
+
+          # @!attribute [r] update_statement
+          #  @return [Object] the update statement which will be executed in case of a violation
+          option :update_statement, reader: true, default: -> c { c.class.update_statement }
+
+          # @!attribute [r] update_where
+          #  @return [Object] the WHERE clause to be added to the update
+          option :update_where, reader: true, default: -> c { c.class.update_where }
+
+          # Tries to insert provided tuples and do an update (or nothing)
+          # when the inserted record violates a unique constraint and hence
+          # cannot be appended to the table
+          #
+          # @return [Array<Hash>]
+          #
+          # @api public
+          def execute(tuples)
+            inserted_tuples = with_input_tuples(tuples) do |tuple|
+              upsert(input[tuple], upsert_options)
+            end
+
+            inserted_tuples.flatten
+          end
+
+          # @api private
+          def upsert_options
+            @upsert_options ||= {
+              constraint: constraint,
+              target: conflict_target,
+              update_where: update_where,
+              update: update_statement
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/commands/update.rb

@@ -1,6 +1,6 @@
 require 'rom/support/deprecations'
+require 'rom/support/constants'
 
-require 'rom/sql/commands'
 require 'rom/sql/commands/error_wrapper'
 require 'rom/sql/commands/transaction'
 
@@ -20,6 +20,8 @@ module ROM
 
         option :original, reader: true
 
+        use :schema
+
         deprecate :set, :call
         deprecate :to, :call
 
@@ -34,10 +36,10 @@ module ROM
 
           changed = diff(attributes.to_h)
 
-          if changed.any?
+          if changed.size > 0
             update(changed)
           else
-            []
+            EMPTY_ARRAY
           end
         end
 
@@ -55,6 +57,7 @@ module ROM
         #
         # @api public
         def change(original)
+          Deprecations.warn("#{self.class}#change is deprecated. Use repositories with changesets instead")
           self.class.build(relation, options.merge(original: original.to_h))
         end
 

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

@@ -6,18 +6,35 @@ module ROM
     module Commands
       module Postgres
         module Create
+          # Executes insert statement and returns inserted tuples
+          #
+          # @api private
           def insert(tuples)
             tuples.map do |tuple|
               relation.dataset.returning(*relation.columns).insert(tuple)
             end.flatten
           end
 
+          # Executes multi_insert statement and returns inserted tuples
+          #
+          # @api private
           def multi_insert(tuples)
             relation.dataset.returning(*relation.columns).multi_insert(tuples)
           end
+
+          # Executes upsert statement (INSERT with ON CONFLICT clause)
+          # and returns inserted/updated tuples
+          #
+          # @api private
+          def upsert(tuple, opts = EMPTY_HASH)
+            relation.dataset.returning(*relation.columns).insert_conflict(opts).insert(tuple)
+          end
         end
 
         module Update
+          # Executes update statement and returns updated tuples
+          #
+          # @api private
           def update(tuple)
             relation.dataset.returning(*relation.columns).update(tuple)
           end

data/lib/rom/sql/gateway.rb

@@ -30,20 +30,6 @@ module ROM
       # @api public
       attr_reader :logger
 
-      # Returns a list of datasets inferred from table names
-      #
-      # @return [Array] array with table names
-      #
-      # @api public
-      attr_reader :schema
-
-      # @param [String,Symbol] scheme
-      #
-      # @api public
-      def self.database_file?(scheme)
-        scheme.to_s.include?('sqlite')
-      end
-
       # SQL gateway interface
       #
       # @overload connect(uri, options)
@@ -70,7 +56,6 @@ module ROM
         conn_options = options.reject { |k, _| repo_options.include?(k) }
 
         @connection = connect(uri, conn_options)
-        @schema = connection.tables
         add_extensions(Array(options[:extensions])) if options[:extensions]
 
         super(uri, options.reject { |k, _| conn_options.keys.include?(k) })
@@ -153,6 +138,29 @@ module ROM
         klass
       end
 
+      # Create a table using the configured connection
+      #
+      # @api public
+      def create_table(*args, &block)
+        connection.create_table(*args, &block)
+      end
+
+      # Drops a table
+      #
+      # @api public
+      def drop_table(*args, &block)
+        connection.drop_table(*args, &block)
+      end
+
+      # Returns a list of datasets inferred from table names
+      #
+      # @return [Array] array with table names
+      #
+      # @api public
+      def schema
+        @schema ||= connection.tables
+      end
+
       private
 
       # Connect to database or reuse established connection instance

data/lib/rom/sql/header.rb

@@ -4,6 +4,8 @@ module ROM
     class Header
       include Dry::Equalizer(:columns, :table)
 
+      SEP_REGEX = /_{2,3}/.freeze
+
       attr_reader :columns, :table
 
       def initialize(columns, table)
@@ -24,7 +26,11 @@ module ROM
       end
 
       def names
-        columns.map { |col| :"#{col.to_s.split('___').last}" }
+        columns.map { |col| :"#{col.to_s.split(SEP_REGEX).last}" }
+      end
+
+      def exclude(*names)
+        self.class.new(columns.find_all { |col| !names.include?(col) }, table)
       end
 
       def project(*names)

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

@@ -66,7 +66,7 @@ module ROM
           if assoc.nil?
             raise NoAssociationError,
               "Association #{assoc_name.inspect} has not been " \
-              "defined for relation #{name.inspect}"
+              "defined for relation #{name.relation.inspect}"
           end
 
           type = assoc[:type]
@@ -103,7 +103,7 @@ module ROM
           l_graph = graph(
             assoc[:join_table],
             { assoc[:left_key] => primary_key },
-            select: l_select, implicit_qualifier: self.name
+            select: l_select, implicit_qualifier: self.name.dataset
           )
 
           l_graph.graph(
@@ -124,7 +124,7 @@ module ROM
 
           graph(
             name, join_keys,
-            options.merge(join_type: join_type, implicit_qualifier: self.name)
+            options.merge(join_type: join_type, implicit_qualifier: self.name.dataset)
           )
         end
       end

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

@@ -1,3 +1,5 @@
+require 'rom/support/deprecations'
+
 module ROM
   module SQL
     module Plugin
@@ -12,6 +14,21 @@ module ROM
         end
 
         module InstanceMethods
+          attr_reader :assoc, :__registry__
+
+          # @api private
+          def initialize(*)
+            super
+            @__registry__ = relation.__registry__
+            assoc_name, assoc_opts = self.class.associations[0]
+            @assoc =
+              if assoc_opts.any?
+                assoc_opts[:key]
+              else
+                relation.associations[assoc_name]
+              end
+          end
+
           # Set fk on tuples from parent tuple
           #
           # @param [Array<Hash>, Hash] tuples The input tuple(s)
@@ -23,13 +40,36 @@ module ROM
           #
           # @api public
           def execute(tuples, parent)
-            fk, pk = association[:key]
+            input_tuples =
+              case assoc
+              when Array
+                fk, pk = assoc
 
-            input_tuples = with_input_tuples(tuples).map { |tuple|
-              tuple.merge(fk => parent.fetch(pk))
-            }
+                input_tuples = with_input_tuples(tuples).map { |tuple|
+                  tuple.merge(fk => parent.fetch(pk))
+                }
 
-            super(input_tuples)
+                super(input_tuples)
+              when Association::ManyToMany
+                new_tuples = super(tuples)
+
+                join_tuples = assoc.associate(__registry__, new_tuples, parent)
+                join_relation = assoc.join_relation(__registry__)
+                join_relation.multi_insert(join_tuples)
+
+                pk, fk = __registry__[assoc.target]
+                  .associations[assoc.source]
+                  .combine_keys(__registry__).to_a.flatten
+
+                pk_extend = { fk => parent[pk] }
+
+                new_tuples.map { |tuple| tuple.update(pk_extend) }
+              when Association
+                input_tuples = with_input_tuples(tuples).map { |tuple|
+                  assoc.associate(relation.__registry__, tuple, parent)
+                }
+                super(input_tuples)
+              end
           end
         end
 
@@ -62,16 +102,17 @@ module ROM
           # @option options [Array] :key The association keys
           #
           # @api public
-          def associates(name, options)
-            if associations.include?(name)
+          def associates(name, options = {})
+            if associations.map(&:first).include?(name)
               raise ArgumentError,
                 "#{name} association is already defined for #{self.class}"
             end
 
-            option :association, reader: true, default: -> _command { options }
+            option :association, reader: true, default: {}
+
             include InstanceMethods
 
-            associations << name
+            associations << [name, options]
           end
         end
       end