rom-sql 0.9.1 → 1.0.0.beta1

data/spec/integration/schema/prefix_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Schema, '#prefix' do
+  include_context 'database setup'
+
+  with_adapters :postgres do
+    before do
+      conf.relation(:users) do
+        schema(infer: true)
+      end
+    end
+
+    it 'auto-projects a relation with renamed columns using provided prefix' do
+      expect(relations[:users].schema.prefix(:user).(relations[:users]).dataset.sql)
+        .to eql('SELECT "id" AS "user_id", "name" AS "user_name" FROM "users" ORDER BY "users"."id"')
+    end
+  end
+end

data/spec/integration/schema/qualified_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Schema, '#qualified' do
+  include_context 'database setup'
+
+  with_adapters :postgres do
+    before do
+      conf.relation(:users) do
+        schema(infer: true)
+      end
+    end
+
+    it 'qualifies column names' do
+      expect(relations[:users].schema.qualified.(relations[:users]).dataset.sql)
+        .to eql('SELECT "users"."id", "users"."name" FROM "users" ORDER BY "users"."id"')
+    end
+  end
+end

data/spec/integration/schema/rename_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Schema, '#rename' do
+  include_context 'database setup'
+
+  with_adapters :postgres do
+    before do
+      conf.relation(:users) do
+        schema(infer: true)
+      end
+    end
+
+    it 'auto-projects a relation with renamed columns' do
+      expect(relations[:users].schema.rename(id: :user_id, name: :user_name).(relations[:users]).dataset.sql)
+        .to eql('SELECT "id" AS "user_id", "name" AS "user_name" FROM "users" ORDER BY "users"."id"')
+    end
+
+    it 'auto-projects a relation with renamed and qualified columns' do
+      expect(relations[:users].schema.qualified.rename(id: :user_id, name: :user_name).(relations[:users]).dataset.sql)
+        .to eql('SELECT "users"."id" AS "user_id", "users"."name" AS "user_name" FROM "users" ORDER BY "users"."id"')
+    end
+  end
+end

data/spec/integration/schema/view_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe 'Defining a view using schemas' do
+  include_context 'database setup'
+
+  with_adapters do
+    describe 'defining a projected view' do
+      before do
+        conf.relation(:users) do
+          schema(infer: true)
+
+          view(:names) do
+            schema { project(:name) }
+            relation { order(:name, :id) }
+          end
+        end
+
+        container.relations[:users].insert(name: 'Joe')
+        container.relations[:users].insert(name: 'Jane')
+        container.relations[:users].insert(name: 'Jade')
+      end
+
+      it 'automatically projects a relation view' do
+        expect(relations[:users].names.to_a)
+          .to eql([{ name: 'Jade' }, { name: 'Jane' }, { name: 'Joe' }])
+      end
+    end
+  end
+end

data/spec/integration/schema_inference_spec.rb

@@ -19,25 +19,28 @@ RSpec.describe 'Schema inference for common datatypes' do
 
       context 'for simple table' do
         let(:dataset) { :users }
+        let(:source) { ROM::Relation::Name[dataset] }
 
         it 'can infer attributes for dataset' do
-          expect(schema.attributes).to eql(
-            id: ROM::SQL::Types::Serial.meta(name: :id),
-            name: ROM::SQL::Types::String.meta(name: :name)
+          expect(schema.to_h).to eql(
+            id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
+            name: ROM::SQL::Types::String.meta(name: :name, source: source)
           )
         end
       end
 
       context 'for a table with FKs' do
         let(:dataset) { :tasks }
+        let(:source) { ROM::Relation::Name[:tasks] }
 
         it 'can infer attributes for dataset' do
-          expect(schema.attributes).to eql(
-            id: ROM::SQL::Types::Serial.meta(name: :id),
-            title: ROM::SQL::Types::String.optional.meta(name: :title),
+          expect(schema.to_h).to eql(
+            id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
+            title: ROM::SQL::Types::String.optional.meta(name: :title, source: source),
             user_id: ROM::SQL::Types::Int.optional.meta(name: :user_id,
                                                         foreign_key: true,
-                                                        relation: :users)
+                                                        source: source,
+                                                        target: :users)
          )
         end
       end
@@ -63,15 +66,16 @@ RSpec.describe 'Schema inference for common datatypes' do
         end
 
         let(:dataset) { :test_inferrence }
+        let(:source) { ROM::Relation::Name[dataset] }
 
         it 'can infer attributes for dataset' do
-          expect(schema.attributes).to eql(
-            id: ROM::SQL::Types::Serial.meta(name: :id),
-            text: ROM::SQL::Types::String.meta(name: :text),
-            flag: ROM::SQL::Types::Bool.meta(name: :flag),
-            date: ROM::SQL::Types::Date.optional.meta(name: :date),
-            datetime: ROM::SQL::Types::Time.meta(name: :datetime),
-            data: ROM::SQL::Types::Blob.optional.meta(name: :data)
+          expect(schema.to_h).to eql(
+            id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
+            text: ROM::SQL::Types::String.meta(name: :text, source: source),
+            flag: ROM::SQL::Types::Bool.meta(name: :flag, source: source),
+            date: ROM::SQL::Types::Date.optional.meta(name: :date, source: source),
+            datetime: ROM::SQL::Types::Time.meta(name: :datetime, source: source),
+            data: ROM::SQL::Types::Blob.optional.meta(name: :data, source: source)
           )
         end
       end
@@ -226,4 +230,17 @@ RSpec.describe 'Schema inference for common datatypes' do
       end
     end
   end
+
+  with_adapters(:postgres) do
+    context 'with a table without columns' do
+      before do
+        conn.create_table(:dummy) unless conn.table_exists?(:dummy) 
+        conf.relation(:dummy) { schema(infer: true) }
+      end
+
+      it 'does not fail with a weird error when a relation does not have attributes' do
+        expect(container.relations[:dummy].schema).to be_empty
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -44,8 +44,8 @@ TMP_PATH = root.join('../tmp')
 Dir[root.join('shared/**/*')].each { |f| require f }
 Dir[root.join('support/**/*')].each { |f| require f }
 
-require 'rom/support/deprecations'
-ROM::Deprecations.set_logger!(root.join('../log/deprecations.log'))
+require 'dry/core/deprecations'
+Dry::Core::Deprecations.set_logger!(root.join('../log/deprecations.log'))
 
 ROM::SQL.load_extensions(:postgres)
 

data/spec/support/helpers.rb

@@ -6,4 +6,11 @@ module Helpers
   def assoc_name(*args)
     ROM::SQL::Association::Name[*args]
   end
+
+  def define_schema(name, attrs)
+    ROM::SQL::Schema.define(
+      name,
+      attributes: attrs.map { |key, value| ROM::SQL::Type.new(value.meta(name: key)) }
+    )
+  end
 end

data/spec/unit/gateway_spec.rb

@@ -38,19 +38,20 @@ RSpec.describe ROM::SQL::Gateway, :postgres do
       migrator = double('migrator')
 
       expect(Sequel).to receive(:connect)
-        .with(uri, host: '127.0.0.1')
+        .with(uri, host: '127.0.0.1', migrator: migrator)
         .and_return(conn)
 
       gateway = ROM::SQL::Gateway.new(uri, migrator: migrator, host: '127.0.0.1')
 
-      expect(gateway.options).to eql(migrator: migrator)
+      expect(gateway.options).to eql(migrator: migrator, host: '127.0.0.1')
     end
 
     it 'allows extensions' do
-      extensions = [:pg_array, :pg_enum]
+      extensions = [:pg_array, :pg_array_ops]
       connection = Sequel.connect uri
 
-      expect(connection).to receive(:extension).with(:pg_array, :pg_json, :pg_enum)
+      expect(connection).to receive(:extension).with(:pg_array, :pg_json, :pg_enum, :pg_array_ops)
+      expect(connection).to receive(:extension).with(:freeze_datasets) unless RUBY_ENGINE == 'rbx'
 
       ROM::SQL::Gateway.new(connection, extensions: extensions)
     end

data/spec/unit/projection_dsl_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::ProjectionDSL, :sqlite, helpers: true do
+  include_context 'database setup'
+
+  subject(:dsl) do
+    ROM::SQL::ProjectionDSL.new(schema)
+  end
+
+  let(:schema) do
+    define_schema(:users, id: ROM::SQL::Types::Serial, name: ROM::SQL::Types::String)
+  end
+
+  let(:ds) do
+    conn[:users]
+  end
+
+  describe '#call' do
+    it 'evaluates the block and returns an array with attribute types' do
+      literals = dsl
+                   .call { int::count(id).as(:count) }
+                   .map { |attr| attr.sql_literal(ds) }
+
+      expect(literals).to eql(["count(`id`) AS 'count'"])
+    end
+  end
+
+  describe '#method_missing' do
+    it 'responds to methods matching attribute names' do
+      expect(dsl.id).to eql(schema[:id])
+      expect(dsl.name).to eql(schema[:name])
+    end
+
+    it 'responds to methods matching type identifiers' do
+      expect(dsl.int).to eql(ROM::SQL::Types::Int)
+      expect(dsl.string).to eql(ROM::SQL::Types::String)
+      expect(dsl.bool).to eql(ROM::SQL::Types::Bool)
+    end
+
+    it 'responds to methods matching type names' do
+      expect(dsl.DateTime).to eql(ROM::SQL::Types::DateTime)
+    end
+
+    it 'returns sql functions with return type specified' do
+      function = ROM::SQL::Function.new(ROM::SQL::Types::String).upper(schema[:name])
+
+      expect(dsl.string::upper(schema[:name])).to eql(function)
+    end
+
+    it 'raises NoMethodError when there is no matching attribute or type' do
+      expect { dsl.not_here }.to raise_error(NoMethodError, /not_here/)
+    end
+  end
+end

data/spec/unit/relation/dataset_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe ROM::Relation, '#dataset' do
       end
 
       it 'uses schema to infer default dataset' do
-        expect(relation.dataset).to eql(dataset.select(:id, :name).order(:users__id))
+        expect(relation.dataset.sql).to eql(dataset.select(:id, :name).order(:users__id).sql)
       end
     end
 
@@ -31,7 +31,7 @@ RSpec.describe ROM::Relation, '#dataset' do
       end
 
       it 'uses schema to infer default dataset' do
-        expect(relation.dataset).to eql(dataset.select(:id).order(:users__id))
+        expect(relation.dataset.sql).to eql(dataset.select(:id).order(:users__id).sql)
       end
     end
 
@@ -41,7 +41,7 @@ RSpec.describe ROM::Relation, '#dataset' do
       end
 
       it 'selects all qualified columns and sorts by pk' do
-        expect(relation.dataset).to eql(dataset.select(*relation.columns).order(:users__id))
+        expect(relation.dataset.sql).to eql(dataset.select(*relation.columns).order(:users__id).sql)
       end
     end
   end

data/spec/unit/relation/distinct_spec.rb

@@ -1,14 +1,15 @@
 RSpec.describe ROM::Relation, '#distinct' do
-  subject(:relation) { container.relations.users }
+  subject(:relation) { relations[:users] }
 
   include_context 'users and tasks'
 
-  with_adapters do
-    if !metadata[:sqlite]
-      it 'delegates to dataset and returns a new relation' do
-        expect(relation.dataset).to receive(:distinct).with(:name).and_call_original
-        expect(relation.distinct(:name)).to_not eql(relation)
-      end
+  before do
+    relation.insert id: 3, name: 'Jane'
+  end
+
+  with_adapters :postgres do
+    it 'delegates to dataset and returns a new relation' do
+      expect(relation.distinct(:name).order(:name).group(:name, :id).to_a).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }])
     end
   end
 end

data/spec/unit/relation/exclude_spec.rb

@@ -1,13 +1,11 @@
 RSpec.describe ROM::Relation, '#exclude' do
-  subject(:relation) { container.relations.users }
+  subject(:relation) { relations[:users] }
 
   include_context 'users and tasks'
 
   with_adapters do
     it 'delegates to dataset and returns a new relation' do
-      expect(relation.dataset)
-        .to receive(:exclude).with(name: 'Jane').and_call_original
-      expect(relation.exclude(name: 'Jane')).to_not eq(relation)
+      expect(relation.exclude(name: 'Jane').to_a).to eql([{ id: 2, name: 'Joe' }])
     end
   end
 end

data/spec/unit/relation/having_spec.rb

@@ -1,9 +1,10 @@
 RSpec.describe ROM::Relation, '#having' do
   subject(:relation) do
-    container.relations.users
+    relations[:users]
       .inner_join(:tasks, user_id: :id)
-      .select_group(:users__id, :users__name)
-      .select_append { count(:tasks).as(:task_count) }
+      .qualified
+      .select_group(:id, :name)
+      .select_append { int::count(:tasks).as(:task_count) }
   end
 
   include_context 'users and tasks'
@@ -14,7 +15,8 @@ RSpec.describe ROM::Relation, '#having' do
     end
 
     it 'restricts a relation using HAVING clause' do
-      expect(relation.having { count(:tasks__id) >= 2 }.to_a).to eq([{ id: 2, name: 'Joe', task_count: 2 }])
+      expect(relation.having { count(id.qualified) >= 2 }.to_a).
+        to eq([{ id: 2, name: 'Joe', task_count: 2 }])
     end
   end
 end

data/spec/unit/relation/inner_join_spec.rb

@@ -1,11 +1,19 @@
 RSpec.describe ROM::Relation, '#inner_join' do
-  subject(:relation) { container.relations.users }
+  subject(:relation) { relations[:users] }
+
+  let(:tasks) { relations[:tasks] }
 
   include_context 'users and tasks'
 
   with_adapters do
     it 'joins relations using inner join' do
-      result = relation.inner_join(:tasks, user_id: :id).select(:name, :title)
+      relation.insert id: 3, name: 'Jade'
+
+      result = relation.
+                 inner_join(:tasks, user_id: :id).
+                 select(:name, tasks[:title])
+
+      expect(result.schema.map(&:name)).to eql(%i[name title])
 
       expect(result.to_a).to eql([
         { name: 'Jane', title: "Jane's task" },
@@ -13,10 +21,47 @@ RSpec.describe ROM::Relation, '#inner_join' do
       ])
     end
 
+    context 'with associations' do
+      before do
+        conf.relation(:users) do
+          schema(infer: true) do
+            associations { has_many :tasks }
+          end
+        end
+
+        conf.relation(:tasks) do
+          schema(infer: true) do
+            associations { belongs_to :user }
+          end
+        end
+
+        relation.insert id: 3, name: 'Jade'
+      end
+
+      it 'joins relation with join keys inferred' do
+        result = relation.
+                   inner_join(tasks).
+                   select(:name, tasks[:title])
+
+        expect(result.schema.map(&:name)).to eql(%i[name title])
+
+        expect(result.to_a).to eql([
+                                     { name: 'Jane', title: "Jane's task" },
+                                     { name: 'Joe', title: "Joe's task" }
+                                   ])
+      end
+    end
+
     it 'raises error when column names are ambiguous' do
       expect {
         relation.inner_join(:tasks, user_id: :id).to_a
       }.to raise_error(Sequel::DatabaseError, /ambiguous/)
     end
+
+    it 'raises error when join arg is unsupported' do
+      expect {
+        relation.inner_join(421)
+      }.to raise_error(ArgumentError, /other/)
+    end
   end
 end

data/spec/unit/relation/invert_spec.rb

@@ -1,12 +1,11 @@
 RSpec.describe ROM::Relation, '#invert' do
-  subject(:relation) { container.relations.users }
+  subject(:relation) { relations[:users] }
 
   include_context 'users and tasks'
 
   with_adapters do
     it 'delegates to dataset and returns a new relation' do
-      expect(relation.dataset).to receive(:invert).and_call_original
-      expect(relation.invert).to_not eq(relation)
+      expect(relation.where(name: 'Jane').invert.to_a).to eql([{ id: 2, name: 'Joe' }])
     end
   end
 end