rom-sql 0.7.0 → 0.8.0

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

@@ -2,6 +2,27 @@ module ROM
   module SQL
     class Relation < ROM::Relation
       module Writing
+        # Add upsert option (only PostgreSQL >= 9.5)
+        # Uses internal Sequel implementation
+        # Default - ON CONFLICT DO NOTHING
+        # more options: http://sequel.jeremyevans.net/rdoc-adapters/classes/Sequel/Postgres/DatasetMethods.html#method-i-insert_conflict
+        #
+        # @example
+        #   users.upsert({ name: 'Jane', email: 'jane@foo.com' },
+        #                { target: :email, update: { name: :excluded__name } }
+        #
+        # @api public
+        def upsert(*args, &block)
+          if args.size > 1 && args[-1].is_a?(Hash)
+            *values, opts = args
+          else
+            values = args
+            opts = EMPTY_HASH
+          end
+
+          dataset.insert_conflict(opts).insert(*values, &block)
+        end
+
         # Insert tuple into relation
         #
         # @example

data/lib/rom/sql/schema.rb

@@ -0,0 +1,35 @@
+require 'rom/schema'
+require 'rom/support/constants'
+
+module ROM
+  module SQL
+    class Schema < ROM::Schema
+      # @!attribute [r] primary_key_name
+      #   @return [Symbol] The name of the primary key. This is set because in
+      #                    most of the cases relations don't have composite pks
+      attr_reader :primary_key_name
+
+      # @!attribute [r] primary_key_names
+      #   @return [Array<Symbol>] A list of all pk names
+      attr_reader :primary_key_names
+
+      def initialize(*)
+        super
+        @primary_key_name = nil
+        @primary_key_names = EMPTY_ARRAY
+      end
+
+      # @api private
+      def finalize!(*)
+        super do
+          if primary_key.size > 0
+            @primary_key_name = primary_key[0].meta[:name]
+            @primary_key_names = primary_key.map { |type| type.meta[:name] }
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'rom/sql/schema/dsl'

data/lib/rom/sql/schema/associations_dsl.rb

@@ -0,0 +1,68 @@
+require 'rom/sql/association'
+
+module ROM
+  module SQL
+    class Schema < ROM::Schema
+      class AssociationsDSL < BasicObject
+        attr_reader :source, :registry
+
+        def initialize(source, &block)
+          @source = source
+          @registry = {}
+          instance_exec(&block)
+        end
+
+        def one_to_many(target, options = {})
+          if options[:through]
+            many_to_many(target, options)
+          else
+            add(Association::OneToMany.new(source, target, options))
+          end
+        end
+        alias_method :has_many, :one_to_many
+
+        def one_to_one(target, options = {})
+          if options[:through]
+            one_to_one_through(target, options)
+          else
+            add(Association::OneToOne.new(source, target, options))
+          end
+        end
+
+        def one_to_one_through(target, options = {})
+          add(Association::OneToOneThrough.new(source, target, options))
+        end
+
+        def many_to_many(target, options = {})
+          add(Association::ManyToMany.new(source, target, options))
+        end
+
+        def many_to_one(target, options = {})
+          add(Association::ManyToOne.new(source, target, options))
+        end
+
+        def belongs_to(name, options = {})
+          many_to_one(dataset_name(name), options.merge(as: options[:as] || name))
+        end
+
+        def has_one(name, options = {})
+          one_to_one(dataset_name(name), options.merge(as: options[:as] || name))
+        end
+
+        def call
+          AssociationSet.new(registry)
+        end
+
+        private
+
+        def add(association)
+          registry[association.name] = association
+        end
+
+        def dataset_name(name)
+          Inflector.pluralize(name).to_sym
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/schema/dsl.rb

@@ -0,0 +1,27 @@
+require 'rom/sql/schema/inferrer'
+require 'rom/sql/schema/associations_dsl'
+
+module ROM
+  module SQL
+    class Schema < ROM::Schema
+      class DSL < ROM::Schema::DSL
+        attr_reader :associations_dsl
+
+        def associations(&block)
+          @associations_dsl = AssociationsDSL.new(name, &block)
+        end
+
+        def call
+          SQL::Schema.new(name, attributes, opts)
+        end
+
+        def opts
+          opts = {}
+          opts[:associations] = associations_dsl.call if associations_dsl
+          opts[:inferrer] = inferrer.new(self) if inferrer
+          opts
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/schema/inferrer.rb

@@ -0,0 +1,80 @@
+module ROM
+  module SQL
+    class Schema < ROM::Schema
+      class Inferrer
+        extend ClassMacros
+
+        defines :type_mapping, :pk_type
+
+        type_mapping(
+          integer: Types::Strict::Int,
+          string: Types::Strict::String,
+          date: Types::Strict::Date,
+          datetime: Types::Strict::Time,
+          boolean: Types::Strict::Bool,
+          decimal: Types::Strict::Decimal,
+          blob: Types::Strict::String
+        ).freeze
+
+        pk_type Types::Serial
+
+        attr_reader :dsl
+
+        def initialize(dsl)
+          @dsl = dsl
+        end
+
+        # @api private
+        def call(dataset, gateway)
+          columns = gateway.connection.schema(dataset)
+          fks = fks_for(gateway, dataset)
+
+          columns.each do |(name, definition)|
+            dsl.attribute name, build_type(definition.merge(foreign_key: fks[name]))
+          end
+
+          pks = columns
+            .map { |(name, definition)| name if definition.fetch(:primary_key) }
+            .compact
+
+          dsl.primary_key(*pks) if pks.any?
+
+          dsl.attributes
+        end
+
+        private
+
+        # @api private
+        def build_type(primary_key: , type: , allow_null: , foreign_key: , **rest)
+          if primary_key
+            self.class.pk_type
+          else
+            type = self.class.type_mapping.fetch(type)
+            type = type.optional if allow_null
+            type = type.meta(foreign_key: true, relation: foreign_key) if foreign_key
+            type
+          end
+        end
+
+        # @api private
+        def fks_for(gateway, dataset)
+          gateway.connection.foreign_key_list(dataset).each_with_object({}) do |definition, fks|
+            column, fk = build_fk(definition)
+
+            fks[column] = fk if fk
+          end
+        end
+
+        # @api private
+        def build_fk(columns: , table: , **rest)
+          if columns.size == 1
+            [columns[0], table]
+          else
+            # We don't have support for multicolumn foreign keys
+            columns[0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/support/active_support_notifications.rb

@@ -1,26 +1,36 @@
 require 'sequel/database/logging'
 require 'active_support/notifications'
 
-module Sequel
-  class Database
-    def log_yield_with_instrumentation(sql, args = nil, &block)
-      ActiveSupport::Notifications.instrument(
-        'sql.rom',
-        sql: sql,
-        name: instrumentation_name,
-        binds: args
-      ) do
-        log_yield_without_instrumentation(sql, args, &block)
+module ROM
+  module SQL
+    module ActiveSupportInstrumentation
+      if Sequel::MAJOR == 4 && Sequel::MINOR < 35
+        def log_yield(sql, args = nil)
+          ActiveSupport::Notifications.instrument(
+            'sql.rom',
+            sql: sql,
+            name: instrumentation_name,
+            binds: args
+          ) { super }
+        end
+      else
+        def log_connection_yield(sql, _conn, args = nil)
+          ActiveSupport::Notifications.instrument(
+            'sql.rom',
+            sql: sql,
+            name: instrumentation_name,
+            binds: args
+          ) { super }
+        end
       end
-    end
-
-    alias_method :log_yield_without_instrumentation, :log_yield
-    alias_method :log_yield, :log_yield_with_instrumentation
 
-    private
+      private
 
-    def instrumentation_name
-      "ROM[#{database_type}]"
+      def instrumentation_name
+        "ROM[#{database_type}]"
+      end
     end
   end
 end
+
+Sequel::Database.send(:prepend, ROM::SQL::ActiveSupportInstrumentation)

data/lib/rom/sql/types.rb

@@ -0,0 +1,11 @@
+require 'rom/types'
+
+module ROM
+  module SQL
+    module Types
+      include ROM::Types
+
+      Serial = Strict::Int.constrained(gt: 0).meta(primary_key: true)
+    end
+  end
+end

data/lib/rom/sql/types/pg.rb

@@ -0,0 +1,26 @@
+require 'dry-types'
+require 'sequel'
+
+module ROM
+  module SQL
+    module Types
+      module PG
+        Sequel.extension(:pg_json)
+
+        Array = Dry::Types::Definition
+          .new(Sequel::Postgres::JSONArray)
+          .constructor(Sequel.method(:pg_json))
+
+        Hash = Dry::Types::Definition
+          .new(Sequel::Postgres::JSONHash)
+          .constructor(Sequel.method(:pg_json))
+
+        JSON = Array | Hash
+
+        Bytea = Dry::Types::Definition
+          .new(Sequel::SQL::Blob)
+          .constructor(Sequel::SQL::Blob.method(:new))
+      end
+    end
+  end
+end

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '0.7.0'.freeze
+    VERSION = '0.8.0'.freeze
   end
 end

data/rom-sql.gemspec

@@ -18,9 +18,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "sequel", "~> 4.18"
+  spec.add_runtime_dependency "sequel", "~> 4.25"
   spec.add_runtime_dependency "dry-equalizer", "~> 0.2"
-  spec.add_runtime_dependency "rom", "~> 1.0.0"
+  spec.add_runtime_dependency "dry-types", "~> 0.8"
+  spec.add_runtime_dependency "rom", "~> 2.0"
+  spec.add_runtime_dependency "rom-support", "~> 2.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 10.0"

data/spec/integration/association/many_to_many_spec.rb

@@ -0,0 +1,137 @@
+RSpec.describe ROM::SQL::Association::ManyToMany do
+  include_context 'users and tasks'
+
+  with_adapters :sqlite do
+    context 'with two associations pointing to the same target relation' do
+      let(:container) do
+        ROM.container(:sql, uri) do |conf|
+          conf.default.create_table(:users_tasks) do
+            foreign_key :user_id, :users
+            foreign_key :task_id, :tasks
+            primary_key [:user_id, :task_id]
+          end
+
+          conf.relation(:users) do
+            schema(infer: true) do
+              associations do
+                has_many :users_tasks
+                has_many :tasks, through: :users_tasks
+                has_many :tasks, as: :priv_tasks
+              end
+            end
+          end
+
+          conf.relation(:users_tasks) do
+            schema(infer: true) do
+              associations do
+                belongs_to :user
+                belongs_to :task
+              end
+            end
+          end
+
+          conf.relation(:tasks) do
+            schema(infer: true) do
+              associations do
+                has_many :users_tasks
+                has_many :users, through: :users_tasks
+              end
+            end
+          end
+        end
+      end
+
+      it 'does not conflict with two FKs' do
+        users = container.relations[:users]
+        tasks = container.relations[:tasks]
+        assoc = users.associations[:tasks]
+
+        relation = tasks.for_combine(assoc).call(users.call)
+
+        expect(relation.to_a).to be_empty
+      end
+
+      it 'preloads using FK' do
+        users = container.relations[:users]
+        tasks = container.relations[:tasks]
+        assoc = users.associations[:priv_tasks]
+
+        relation = tasks.for_combine(assoc).call(users.where(id: 2).call)
+
+        expect(relation.to_a).to eql([id: 1, user_id: 2, title: "Joe's task"])
+      end
+    end
+  end
+
+  with_adapters do
+    subject(:assoc) {
+      ROM::SQL::Association::ManyToMany.new(:tasks, :tags, through: :task_tags)
+    }
+
+    let(:tasks) { container.relations[:tasks] }
+    let(:tags) { container.relations[:tags] }
+
+    before do
+      conf.relation(:task_tags) do
+        schema do
+          attribute :task_id, ROM::SQL::Types::ForeignKey(:tasks)
+          attribute :tag_id, ROM::SQL::Types::ForeignKey(:tags)
+
+          primary_key :task_id, :tag_id
+
+          associations do
+            many_to_one :tasks
+            many_to_one :tags
+          end
+        end
+      end
+
+      conf.relation(:tasks) do
+        schema do
+          attribute :id, ROM::SQL::Types::Serial
+          attribute :user_id, ROM::SQL::Types::ForeignKey(:users)
+          attribute :title, ROM::SQL::Types::String
+
+          associations do
+            one_to_many :task_tags
+            one_to_many :tags, through: :task_tags
+          end
+        end
+      end
+    end
+
+    describe '#result' do
+      specify { expect(ROM::SQL::Association::ManyToMany.result).to be(:many) }
+    end
+
+    describe '#call' do
+      it 'prepares joined relations' do
+        relation = assoc.call(container.relations)
+
+        expect(relation.attributes).to eql(%i[id name task_id])
+        expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
+      end
+    end
+
+    describe ':through another assoc' do
+      subject(:assoc) do
+        ROM::SQL::Association::ManyToMany.new(:users, :tags, through: :tasks)
+      end
+
+      it 'prepares joined relations through other association' do
+        relation = assoc.call(container.relations)
+
+        expect(relation.attributes).to eql(%i[id name user_id])
+        expect(relation.to_a).to eql([id: 1, name: 'important', user_id: 2])
+      end
+    end
+
+    describe ROM::Plugins::Relation::SQL::AutoCombine, '#for_combine' do
+      it 'preloads relation based on association' do
+        relation = tags.for_combine(assoc).call(tasks.call)
+
+        expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
+      end
+    end
+  end
+end