rom-sql 2.0.0.beta1 → 2.0.0.beta2

data/lib/rom/sql/version.rb

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

data/spec/integration/auto_migrations/indexes_spec.rb

@@ -6,6 +6,7 @@ RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
   end
 
   let(:table_name) { :users }
+  let(:relation_name) { ROM::Relation::Name.new(table_name) }
 
   subject(:gateway) { container.gateways[:default] }
 
@@ -18,6 +19,14 @@ RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
 
   let(:attributes) { migrated_schema.to_a }
 
+  def indexdef(index)
+    gateway.connection[<<-SQL, index].first[:indexdef]
+      select indexdef
+      from   pg_indexes
+      where  indexname = ?
+    SQL
+  end
+
   describe 'create table' do
     describe 'one-column indexes' do
       before do
@@ -25,6 +34,10 @@ RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
           schema do
             attribute :id,    ROM::SQL::Types::Serial
             attribute :name,  ROM::SQL::Types::String.meta(index: true)
+
+            indexes do
+              index :name, name: :unique_name, unique: true
+            end
           end
         end
       end
@@ -43,6 +56,13 @@ RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
                       [:definition, [String, {}]],
                       source: :users]],
                   ])
+
+        expect(migrated_schema.indexes.first).
+          to eql(ROM::SQL::Index.new(
+                   [define_attribute(:name, :String, source: relation_name)],
+                   name: :unique_name,
+                   unique: true
+                 ))
       end
     end
   end
@@ -51,23 +71,54 @@ RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
     describe 'one-column indexes' do
       context 'adding' do
         before do
+        end
+
+        it 'adds indexed column' do
+          conn.create_table :users do
+            primary_key :id
+          end
+
           conf.relation(:users) do
             schema do
               attribute :id,    ROM::SQL::Types::Serial
               attribute :name,  ROM::SQL::Types::String.meta(index: true)
             end
           end
+
+          gateway.auto_migrate!(conf)
+
+          name_index = migrated_schema.indexes.first
+
+          expect(migrated_schema.attributes[1].name).to eql(:name)
+          expect(migrated_schema.indexes.size).to eql(1)
+          expect(name_index.name).to eql(:users_name_index)
+          expect(name_index.attributes.map(&:name)).to eql(%i(name))
         end
 
-        it 'adds indexed column' do
+        it 'supports custom names' do
           conn.create_table :users do
             primary_key :id
           end
 
+          conf.relation(:users) do
+            schema do
+              attribute :id,    ROM::SQL::Types::Serial
+              attribute :name,  ROM::SQL::Types::String
+
+              indexes do
+                index :name, name: :custom_idx
+              end
+            end
+          end
+
           gateway.auto_migrate!(conf)
 
+          name_index = migrated_schema.indexes.first
+
           expect(migrated_schema.attributes[1].name).to eql(:name)
-          expect(migrated_schema.indexes.map { |idx| idx.attributes.map(&:name) }).to eql([%i(name)])
+          expect(migrated_schema.indexes.size).to eql(1)
+          expect(name_index.name).to eql(:custom_idx)
+          expect(name_index.attributes.map(&:name)).to eql(%i(name))
         end
 
         it 'adds index to existing column' do
@@ -76,9 +127,98 @@ RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
             column :name, String
           end
 
+          conf.relation(:users) do
+            schema do
+              attribute :id,    ROM::SQL::Types::Serial
+              attribute :name,  ROM::SQL::Types::String
+
+              indexes do
+                index :name
+              end
+            end
+          end
+
+          gateway.auto_migrate!(conf)
+
+          name_index = migrated_schema.indexes.first
+
+          expect(name_index.name).to eql(:users_name_index)
+          expect(name_index.attributes.map(&:name)).to eql(%i(name))
+          expect(name_index).not_to be_unique
+        end
+
+        it 'supports unique indexes' do
+          conn.create_table :users do
+            primary_key :id
+            column :name, String
+          end
+
+          conf.relation(:users) do
+            schema do
+              attribute :id,    ROM::SQL::Types::Serial
+              attribute :name,  ROM::SQL::Types::String
+
+              indexes do
+                index :name, unique: true
+              end
+            end
+          end
+
           gateway.auto_migrate!(conf)
 
-          expect(migrated_schema.indexes.map { |idx| idx.attributes.map(&:name) }).to eql([%i(name)])
+          name_index = migrated_schema.indexes.first
+
+          expect(name_index.name).to eql(:users_name_index)
+          expect(name_index.attributes.map(&:name)).to eql(%i(name))
+          expect(name_index).to be_unique
+        end
+
+        if metadata[:postgres]
+          it 'uses index method' do
+            conn.create_table :users do
+              primary_key :id
+              column :props, :jsonb, null: false
+            end
+
+            conf.relation(:users) do
+              schema do
+                attribute :id,     ROM::SQL::Types::Serial
+                attribute :props,  ROM::SQL::Types::PG::JSONB
+
+                indexes do
+                  index :props, type: :gin
+                end
+              end
+            end
+
+            gateway.auto_migrate!(conf)
+
+            expect(indexdef('users_props_index')).
+              to eql('CREATE INDEX users_props_index ON users USING gin (props)')
+          end
+
+          it 'supports partial indexes' do
+            conn.create_table :users do
+              primary_key :id
+              column :name, String
+            end
+
+            conf.relation(:users) do
+              schema do
+                attribute :id,     ROM::SQL::Types::Serial
+                attribute :name,   ROM::SQL::Types::String
+
+                indexes do
+                  index :name, name: :long_names_only, predicate: 'length(name) > 10'
+                end
+              end
+            end
+
+            gateway.auto_migrate!(conf)
+
+            expect(indexdef('long_names_only')).
+              to eql('CREATE INDEX long_names_only ON users USING btree (name) WHERE (length(name) > 10)')
+          end
         end
       end
 
@@ -88,19 +228,23 @@ RSpec.describe ROM::SQL::Gateway, :postgres, :helpers do
             schema do
               attribute :id,    ROM::SQL::Types::Serial
               attribute :name,  ROM::SQL::Types::String
+              attribute :email, ROM::SQL::Types::String
             end
           end
 
           conn.create_table :users do
             primary_key :id
             column :name, String
+            column :email, String
 
             index :name
+            index :email, name: :email_idx
           end
         end
 
         it 'removes index' do
           gateway.auto_migrate!(conf)
+
           expect(migrated_schema.indexes).to be_empty
         end
       end

data/spec/integration/{graph_spec.rb → combine_with_spec.rb}

@@ -34,7 +34,7 @@ RSpec.describe 'Eager loading' do
       tasks = container.relations[:tasks]
       tags = container.relations[:tags]
 
-      relation = users.graph(tasks.for_users.graph(tags.for_tasks))
+      relation = users.combine_with(tasks.for_users.combine_with(tags.for_tasks))
 
       # TODO: figure out a way to assert correct number of issued queries
       expect(relation.call).to be_instance_of(ROM::Relation::Loaded)

data/spec/integration/commands/create_spec.rb

@@ -46,37 +46,37 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
   with_adapters do
     describe '#transaction' do
       it 'creates record if nothing was raised' do
-        result = create_user.transaction {
+        result = users.transaction {
           create_user.call(name: 'Jane')
         }
 
-        expect(result.value).to eql(id: 1, name: 'Jane')
+        expect(result).to eql(id: 1, name: 'Jane')
       end
 
       it 'creates multiple records if nothing was raised' do
-        result = create_user.transaction {
+        result = users.transaction {
           create_users.call([{ name: 'Jane' }, { name: 'Jack' }])
         }
 
-        expect(result.value).to match_array([
+        expect(result).to match_array([
           { id: 1, name: 'Jane' }, { id: 2, name: 'Jack' }
         ])
       end
 
       it 'allows for nested transactions' do
-        result = create_user.transaction {
-          create_user.transaction {
+        result = users.transaction {
+          users.transaction {
             create_user.call(name: 'Jane')
           }
         }
 
-        expect(result.value).to eql(id: 1, name: 'Jane')
+        expect(result).to eql(id: 1, name: 'Jane')
       end
 
       it 'creates nothing if command error was raised' do
         expect {
           begin
-            create_user.transaction {
+            users.transaction {
               create_user.call(name: 'Jane')
               create_user.call(name: nil)
             }
@@ -87,19 +87,13 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
 
       it 'creates nothing if rollback was raised' do
         expect {
-          passed = false
-
-          result = create_user.transaction {
+          result = users.transaction { |t|
             create_user.call(name: 'Jane')
             create_user.call(name: 'John')
-            raise ROM::SQL::Rollback
-          } >-> _value {
-            passed = true
+            t.rollback!
           }
 
-          expect(result.value).to be(nil)
-          expect(result.error).to be(nil)
-          expect(passed).to be(false)
+          expect(result).to be(nil)
         }.to_not change { container.relations.users.count }
       end
 
@@ -108,10 +102,9 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
           begin
             passed = false
 
-            create_user.transaction {
+            users.transaction {
               create_user.call(name: 'Jane')
               create_user.call(name: 'Jane')
-            } >-> _value {
               passed = true
             }
           rescue => error
@@ -124,9 +117,10 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
       it 'creates nothing if anything was raised in any nested transaction' do
         expect {
           expect {
-            create_user.transaction {
+            users.transaction {
               create_user.call(name: 'John')
-              create_user.transaction {
+
+              users.transaction {
                 create_user.call(name: 'Jane')
                 raise Exception
               }
@@ -158,24 +152,22 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
     end
 
     it 'returns a single tuple when result is set to :one' do
-      result = user_commands.try { create_user.call(name: 'Jane') }
+      result = create_user.call(name: 'Jane')
 
-      expect(result.value).to eql(id: 1, name: 'Jane')
+      expect(result).to eql(id: 1, name: 'Jane')
     end
 
     it 'returns tuples when result is set to :many' do
-      result = user_commands.try do
-        create_users.call([{ name: 'Jane' }, { name: 'Jack' }])
-      end
+      result = create_users.call([{ name: 'Jane' }, { name: 'Jack' }])
 
-      expect(result.value.to_a).to match_array([
+      expect(result.to_a).to match_array([
         { id: 1, name: 'Jane' }, { id: 2, name: 'Jack' }
       ])
     end
 
     it 're-raises not-null constraint violation error' do
       expect {
-        user_commands.try { create_user.call(name: nil) }
+        create_user.call(name: nil)
       }.to raise_error(ROM::SQL::NotNullConstraintError)
     end
 
@@ -198,34 +190,27 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
         it 're-raises not-null constraint violation error with nil boolean' do
           puppies = commands[:puppies]
 
-          expect {
-            puppies.try { puppies.create.call(name: 'Charlie', cute: nil) }
-          }.to raise_error(ROM::SQL::NotNullConstraintError)
+          expect { puppies.create.call(name: 'Charlie', cute: nil) }.
+            to raise_error(ROM::SQL::NotNullConstraintError)
         end
       end
     end
 
-    it 're-raises uniqueness constraint violation error' do
+    it 'raises uniqueness constraint violation error' do
       expect {
-        user_commands.try {
-          create_user.call(name: 'Jane')
-        } >-> user {
-          user_commands.try { create_user.call(name: user[:name]) }
-        }
+        user = create_user.call(name: 'Jane')
+        create_user.call(name: user[:name])
       }.to raise_error(ROM::SQL::UniqueConstraintError)
     end
 
     it 're-raises fk constraint violation error' do |ex|
-      expect {
-        task_commands.try {
-          create_task.call(user_id: 918_273_645)
-        }
-      }.to raise_error(ROM::SQL::ForeignKeyConstraintError)
+      expect { create_task.call(user_id: 918_273_645) }.
+        to raise_error(ROM::SQL::ForeignKeyConstraintError)
     end
 
     it 're-raises database errors' do
       expect {
-        user_commands.try { create_user.call(name: nil) }
+        create_user.call(name: nil)
       }.to raise_error(ROM::SQL::NotNullConstraintError)
     end
 
@@ -233,9 +218,8 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
       context 'with a single record' do
         it 'materializes the result' do
           result = create_user.execute(name: 'Jane')
-          expect(result).to eq([
-            { id: 1, name: 'Jane' }
-          ])
+
+          expect(result).to eq([{ id: 1, name: 'Jane' }])
         end
       end
 
@@ -245,10 +229,8 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
             { name: 'Jane' },
             { name: 'John' }
           ])
-          expect(result).to eq([
-            { id: 1, name: 'Jane' },
-            { id: 2, name: 'John' }
-          ])
+
+          expect(result).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'John' }])
         end
       end
 
@@ -288,20 +270,13 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
   end
 
   describe '#call' do
-    it 're-raises check constraint violation error' do
-      expect {
-        user_commands.try {
-          create_user.call(name: 'J')
-        }
-      }.to raise_error(ROM::SQL::CheckConstraintError, /name/)
+    it 'raises check constraint violation error' do
+      expect { create_user.call(name: 'J') }.
+        to raise_error(ROM::SQL::CheckConstraintError, /name/)
     end
 
-    it 're-raises constraint violation error' do
-      expect {
-        user_commands.try {
-          create_task.call(title: '')
-        }
-      }.to raise_error(ROM::SQL::ConstraintError, /title/)
+    it 'raises constraint violation error' do
+      expect { create_task.call(title: '') }.to raise_error(ROM::SQL::ConstraintError, /title/)
     end
   end