rom-sql 0.9.1 → 1.0.0.beta1

data/lib/rom/sql/schema.rb

@@ -1,5 +1,7 @@
 require 'rom/schema'
-require 'rom/support/constants'
+require 'rom/sql/order_dsl'
+require 'rom/sql/projection_dsl'
+require 'rom/sql/restriction_dsl'
 
 module ROM
   module SQL
@@ -13,19 +15,83 @@ module ROM
       #   @return [Array<Symbol>] A list of all pk names
       attr_reader :primary_key_names
 
+      # @api private
       def initialize(*)
         super
-        @primary_key_name = nil
-        @primary_key_names = EMPTY_ARRAY
+        initialize_primary_key_names
+      end
+
+      # @api public
+      def restriction(&block)
+        RestrictionDSL.new(self).call(&block)
+      end
+
+      # @api public
+      def order(&block)
+        OrderDSL.new(self).call(&block)
+      end
+
+      # Return a new schema with attributes marked as qualified
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def qualified
+        new(map(&:qualified))
+      end
+
+      # @api public
+      def project(*names, &block)
+        if block
+          super(*(names + ProjectionDSL.new(self).(&block)))
+        else
+          super
+        end
+      end
+
+      # @api private
+      def project_pk
+        project(*primary_key_names)
+      end
+
+      # @api private
+      def project_fk(mapping)
+        new(rename(mapping).map(&:foreign_key))
+      end
+
+      # @api public
+      def join(other)
+        merge(other.joined)
+      end
+
+      # @api public
+      def joined
+        new(map(&:joined))
+      end
+
+      # Create a new relation based on the schema definition
+      #
+      # @param [Relation] relation The source relation
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def call(relation)
+        relation.new(relation.dataset.select(*self), schema: self)
       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
+          initialize_primary_key_names
+        end
+      end
+
+      # @api private
+      def initialize_primary_key_names
+        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

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

@@ -1,3 +1,4 @@
+require 'dry/core/inflector'
 require 'rom/sql/association'
 
 module ROM
@@ -42,11 +43,11 @@ module ROM
         end
 
         def belongs_to(name, options = {})
-          many_to_one(dataset_name(name), options.merge(as: options[:as] || name))
+          many_to_one(dataset_name(name), {as: name}.merge(options))
         end
 
         def has_one(name, options = {})
-          one_to_one(dataset_name(name), options.merge(as: options[:as] || name))
+          one_to_one(dataset_name(name), {as: name}.merge(options))
         end
 
         def call
@@ -60,7 +61,7 @@ module ROM
         end
 
         def dataset_name(name)
-          Inflector.pluralize(name).to_sym
+          ::Dry::Core::Inflector.pluralize(name).to_sym
         end
       end
     end

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

@@ -1,3 +1,4 @@
+require 'rom/sql/type'
 require 'rom/sql/schema/inferrer'
 require 'rom/sql/schema/associations_dsl'
 
@@ -8,11 +9,13 @@ module ROM
         attr_reader :associations_dsl
 
         def associations(&block)
-          @associations_dsl = AssociationsDSL.new(name, &block)
+          @associations_dsl = AssociationsDSL.new(relation, &block)
         end
 
         def call
-          SQL::Schema.new(name, attributes, opts)
+          SQL::Schema.define(
+            relation, opts.merge(attributes: attributes.values, type_class: SQL::Type)
+          )
         end
 
         def opts

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

@@ -1,9 +1,11 @@
+require 'dry/core/class_attributes'
+
 module ROM
   module SQL
     class Schema < ROM::Schema
       # @api private
       class Inferrer
-        extend ClassMacros
+        extend Dry::Core::ClassAttributes
 
         defines :ruby_type_mapping, :numeric_pk_type, :db_type, :db_registry
 
@@ -37,14 +39,21 @@ module ROM
         end
 
         # @api private
-        def call(dataset, gateway)
+        def call(source, gateway)
+          dataset = source.dataset
+
           columns = gateway.connection.schema(dataset)
           fks = fks_for(gateway, dataset)
 
-          columns.each_with_object({}) do |(name, definition), attrs|
+          inferred = columns.map do |(name, definition)|
             type = build_type(definition.merge(foreign_key: fks[name]))
-            attrs[name] = type.meta(name: name)
-          end
+
+            if type
+              type.meta(name: name, source: source)
+            end
+          end.compact
+
+          [inferred, columns.map(&:first) - inferred.map { |attr| attr.meta[:name] }]
         end
 
         private
@@ -54,9 +63,12 @@ module ROM
             map_pk_type(type, db_type)
           else
             mapped_type = map_type(type, db_type, rest)
-            mapped_type = mapped_type.optional if allow_null
-            mapped_type = mapped_type.meta(foreign_key: true, relation: foreign_key) if foreign_key
-            mapped_type
+
+            if mapped_type
+              mapped_type = mapped_type.optional if allow_null
+              mapped_type = mapped_type.meta(foreign_key: true, target: foreign_key) if foreign_key
+              mapped_type
+            end
           end
         end
 
@@ -65,9 +77,7 @@ module ROM
         end
 
         def map_type(ruby_type, db_type, **_kw)
-          self.class.ruby_type_mapping.fetch(ruby_type) {
-            raise UnknownDBTypeError, "Cannot find corresponding type for #{ruby_type || db_type}"
-          }
+          self.class.ruby_type_mapping[ruby_type]
         end
 
         # @api private

data/lib/rom/sql/transaction.rb

@@ -0,0 +1,19 @@
+module ROM
+  module SQL
+    # @api private
+    class Transaction < ::ROM::Transaction
+      attr_reader :connection
+      private :connection
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def run(opts = EMPTY_HASH)
+        connection.transaction(opts) { yield(self) }
+      rescue ::ROM::Transaction::Rollback
+        # noop
+      end
+    end
+  end
+end

data/lib/rom/sql/type.rb

@@ -0,0 +1,76 @@
+require 'rom/schema/type'
+
+module ROM
+  module SQL
+    class Type < ROM::Schema::Type
+      # Return a new type marked as a FK
+      #
+      # @return [SQL::Type]
+      #
+      # @api public
+      def foreign_key
+        meta(foreign_key: true)
+      end
+
+      # Return a new type marked as qualified
+      #
+      # @return [SQL::Type]
+      #
+      # @api public
+      def qualified
+        meta(qualified: true)
+      end
+
+      # Return a new type marked as joined
+      #
+      # @return [SQL::Type]
+      #
+      # @api public
+      def joined
+        meta(joined: true)
+      end
+
+      # Return if an attribute was used in a join
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def joined?
+        meta[:joined].equal?(true)
+      end
+
+      # Return if an attribute type is qualified
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def qualified?
+        meta[:qualified].equal?(true)
+      end
+
+      # @api public
+      def to_sym
+        @_to_sym ||=
+          if qualified? && aliased?
+            :"#{source.dataset}__#{name}___#{meta[:alias]}"
+          elsif qualified?
+            :"#{source.dataset}__#{name}"
+          elsif aliased?
+            :"#{name}___#{meta[:alias]}"
+          else
+            name
+          end
+      end
+
+      # @api private
+      def sql_literal(ds)
+        sql_expr.sql_literal(ds)
+      end
+
+      # @api private
+      def sql_expr
+        Sequel.expr(to_sym)
+      end
+    end
+  end
+end

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '0.9.1'.freeze
+    VERSION = '1.0.0.beta1'.freeze
   end
 end

data/rom-sql.gemspec

@@ -18,12 +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.25'
+  spec.add_runtime_dependency 'sequel', '~> 4.42'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
   spec.add_runtime_dependency 'dry-types', '~> 0.9'
-  spec.add_runtime_dependency 'dry-core', '~> 0.2'
-  spec.add_runtime_dependency 'rom', '~> 2.0'
-  spec.add_runtime_dependency 'rom-support', '~> 2.0'
+  spec.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.3'
+  spec.add_runtime_dependency 'rom', '~> 3.0.0.beta'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'

data/spec/extensions/postgres/inferrer_spec.rb

@@ -18,10 +18,15 @@ RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
       Decimal :money, null: false
       column :tags, "text[]"
       column :tag_ids, "bigint[]"
+      column :ip, "inet"
       rainbow :color
     end
   end
 
+  after do
+    conn.drop_table?(:test_inferrence)
+  end
+
   let(:dataset) { :test_inferrence }
 
   let(:schema) { container.relations[dataset].schema }
@@ -30,19 +35,24 @@ RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
     before do
       dataset = self.dataset
       conf.relation(dataset) do
-        schema(dataset, infer: true)
+        schema(dataset, infer: true) do
+          attribute :ip, ROM::SQL::Types::String
+        end
       end
     end
 
     it 'can infer attributes for dataset' do
-      expect(schema.attributes).to eql(
-        id: ROM::SQL::Types::PG::UUID.meta(name: :id, primary_key: true),
-        json_data: ROM::SQL::Types::PG::JSON.optional.meta(name: :json_data),
-        jsonb_data: ROM::SQL::Types::PG::JSONB.optional.meta(name: :jsonb_data),
-        money: ROM::SQL::Types::Decimal.meta(name: :money),
-        tags: ROM::SQL::Types::PG::Array('text').optional.meta(name: :tags),
-        tag_ids: ROM::SQL::Types::PG::Array('biging').optional.meta(name: :tag_ids),
-        color: ROM::SQL::Types::String.enum(*colors).optional.meta(name: :color)
+      source = container.relations[:test_inferrence].name
+
+      expect(schema.to_h).to eql(
+        id: ROM::SQL::Types::PG::UUID.meta(name: :id, source: source, primary_key: true),
+        json_data: ROM::SQL::Types::PG::JSON.optional.meta(name: :json_data, source: source),
+        jsonb_data: ROM::SQL::Types::PG::JSONB.optional.meta(name: :jsonb_data, source: source),
+        money: ROM::SQL::Types::Decimal.meta(name: :money, source: source),
+        tags: ROM::SQL::Types::PG::Array('text').optional.meta(name: :tags, source: source),
+        tag_ids: ROM::SQL::Types::PG::Array('biging').optional.meta(name: :tag_ids, source: source),
+        color: ROM::SQL::Types::String.enum(*colors).optional.meta(name: :color, source: source),
+        ip: ROM::SQL::Types::String.meta(name: :ip, source: source)
       )
     end
   end

data/spec/integration/association/many_to_many/custom_fks_spec.rb

@@ -0,0 +1,73 @@
+RSpec.describe ROM::SQL::Association::ManyToMany, '#call' do
+  subject(:assoc) do
+    relations[:users].associations[:puzzles]
+  end
+
+  include_context 'database setup'
+
+  with_adapters do
+    before do
+      conn.create_table(:puzzles) do
+        primary_key :id
+        column :text, String, null: false
+      end
+
+      conn.create_table(:puzzle_solvers) do
+        foreign_key :solver_id, :users, null: false
+        foreign_key :puzzle_id, :puzzles, null: false
+        primary_key [:solver_id, :puzzle_id]
+      end
+
+      conf.relation(:puzzle_solvers) do
+        schema(infer: true) do
+          associations do
+            belongs_to :user, foreign_key: :solver_id
+            belongs_to :puzzle
+          end
+        end
+      end
+
+      conf.relation(:users) do
+        schema(infer: true) do
+          associations do
+            has_many :puzzle_solvers
+            has_many :puzzles, through: :puzzle_solvers, foreign_key: :solver_id
+          end
+        end
+      end
+
+      joe_id = relations[:users].insert(name: 'Joe')
+      jane_id = relations[:users].insert(name: 'Jane')
+
+      p1_id = relations[:puzzles].insert(text: 'P1')
+      p2_id = relations[:puzzles].insert(text: 'P2')
+      p3_id = relations[:puzzles].insert(text: 'P3')
+
+      relations[:puzzle_solvers].insert(solver_id: joe_id, puzzle_id: p2_id)
+      relations[:puzzle_solvers].insert(solver_id: jane_id, puzzle_id: p2_id)
+
+      relations[:puzzle_solvers].insert(solver_id: joe_id, puzzle_id: p1_id)
+      relations[:puzzle_solvers].insert(solver_id: jane_id, puzzle_id: p3_id)
+    end
+
+    after do
+      conn.drop_table?(:puzzle_solvers)
+      conn.drop_table?(:puzzles)
+    end
+
+    it 'prepares joined relations using custom FK' do
+      relation = assoc.call(relations).order(:puzzles__text)
+
+      expect(relation.schema.map(&:to_sym)).
+        to eql(%i[puzzles__id puzzles__text puzzle_solvers__solver_id])
+
+      expect(relation.to_a).
+        to eql([
+                 { id: 1, solver_id: 1, text: 'P1' },
+                 { id: 2, solver_id: 1, text: 'P2' },
+                 { id: 2, solver_id: 2, text: 'P2' },
+                 { id: 3, solver_id: 2, text: 'P3' }
+               ])
+    end
+  end
+end