rom-sql 1.0.0.rc2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93ca7d5248744905dadd655401fb8e9534b466d2
-  data.tar.gz: 0712f79b9575ff7da7017d5bbf7329daae35dc3b
+  metadata.gz: 83c439ad1fcf4ee22b0a4f8d92f924b41b2a0d19
+  data.tar.gz: ebd68c2d754a959b7f669cbcc1269d23108a663c
 SHA512:
-  metadata.gz: 2c8c09bf8ec81e1f6c5452c79047ef46529e5fbb9aa8b2c017797120d6c6ef74d2e8ce279fb490d9844a640bc4a117aa0a75d2ef428d0aeba20b79244288c358
-  data.tar.gz: fac22ae5b662fbc8bc4bf7529a84efcb9bb0328a62ebd5ab91ca8e0662aaf4697cdfc6b40936211e26d7806bab8e9d717d83beb7a5d19ac5e044300ec7072f26
+  metadata.gz: 4a8081d7fb278e307d71b3be25fe4d386e2a33aa6794b4706a1d7096daf2a29364a867e52e945a41c388f211ecbc0c280af23fe1a9ab9b9c0e730a0a7e5991cc
+  data.tar.gz: 8de227092aa395b288d281cbfc69c5370424d76c856ef24f96ef308a4f1f110633556c9021207f74f96b01ee279f0916fc66dcbc20d8d9f4a5d7a99992c5391e

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-## v1.0.0 to-be-released
+## v1.0.0 2017-01-29
 
 This release is based on rom core 3.0.0 with its improved Schema API, which is extended with SQL-specific features.
 
@@ -23,6 +23,7 @@ Please refer to [the upgrading guide](https://github.com/rom-rb/rom-sql/wiki/Upg
 * Support for inferring more PG types: `macaddr`, `xml` (flash-gordon)
 * `ROM::SQL::Relation::SequelAPI` extension for backward-compatible query API (this will be deprecated in 1.1.0 and removed in 2.0.0) (solnic)
 * Added `Object` type for `SQLite` which is used by the inferrer for columns without a type affinity (flash-gordon)
+* Support for composite PKs in the default `by_pk` view (solnic)
 
 ### Changed
 
@@ -32,6 +33,7 @@ Please refer to [the upgrading guide](https://github.com/rom-rb/rom-sql/wiki/Upg
 * [BREAKING] Deprecated `Commands::Update#change` has been removed (solnic)
 * [BREAKING] Deprecated `Commands.validator` has been removed (solnic)
 * [BREAKING] `assoc_macros` plugin has been removed, please use associations from now (solnic)
+* Default `by_pk` uses schema attributes, it will raise exception if PK attribute is missing in the schema (solnic)
 * [internal] Associations use schemas for relation projections (solnic)
 * [internal] `select`, `select_append`, `project`, `inner_join` and `left_join` use schemas internally (solnic)
 * [internal] Deprecation and constants are now based on dry-core (flash-gordon)

data/lib/rom/sql/association.rb

@@ -58,6 +58,11 @@ module ROM
         )
       end
 
+      # @api public
+      def join(relations, type, source = relations[self.source], target = relations[self.target])
+        source.__send__(type, target.name.dataset, join_keys(relations)).qualified
+      end
+
       # Returns a qualified attribute name for a given dataset
       #
       # This is compatible with Sequel's SQL generator and can be used in query

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

@@ -48,6 +48,13 @@ module ROM
           end
         end
 
+        # @api public
+        def join(relations, type, source = relations[self.source], target = relations[self.target])
+          through_assoc = source.associations[through]
+          joined = through_assoc.join(relations, type, source)
+          joined.__send__(type, target.name.dataset, join_keys(relations)).qualified
+        end
+
         # @api public
         def join_keys(relations)
           with_keys(relations) { |source_key, target_key|

data/lib/rom/sql/attribute.rb

@@ -1,4 +1,7 @@
+require 'sequel/core'
+
 require 'rom/schema/attribute'
+require 'rom/sql/projection_dsl'
 
 module ROM
   module SQL
@@ -22,6 +25,17 @@ module ROM
       end
       alias_method :as, :aliased
 
+      # Return a new attribute in its canonical form
+      #
+      # @api public
+      def canonical
+        if aliased?
+          meta(alias: nil, sql_expr: nil)
+        else
+          self
+        end
+      end
+
       # Return a new attribute marked as qualified
       #
       # @example
@@ -124,6 +138,49 @@ module ROM
           end
       end
 
+      # Return a boolean expression with `=` operator
+      #
+      # @example
+      #   users.where { id.is(1) }
+      #
+      #   users.where(users[:id].is(1))
+      #
+      # @param [Object] other Any SQL-compatible object type
+      #
+      # @api public
+      def is(other)
+        Sequel::SQL::BooleanExpression.new(:'=', self, other)
+      end
+
+      # Create a function DSL from the attribute
+      #
+      # @example
+      #   users[:id].func { int::count(id).as(:count) }
+      #
+      # @return [SQL::Function]
+      #
+      # @api public
+      def func(&block)
+        ProjectionDSL.new(name => self).call(&block).first
+      end
+
+      # Create a CONCAT function from the attribute
+      #
+      # @example with default separator (' ')
+      #   users[:id].concat(users[:name])
+      #
+      # @example with custom separator
+      #   users[:id].concat(users[:name], '-')
+      #
+      # @param [SQL::Attribute] other
+      #
+      # @return [SQL::Function]
+      #
+      # @api public
+      def concat(other, sep = ' ')
+        Function.new(type).concat(self, sep, other)
+      end
+
       # Sequel calls this method to coerce an attribute into SQL string
       #
       # @param [Sequel::Dataset]

data/lib/rom/sql/function.rb

@@ -16,6 +16,16 @@ module ROM
         meta[:alias] || super
       end
 
+      def qualified
+        meta(
+          func: ::Sequel::SQL::Function.new(func.name, *func.args.map { |arg| arg.respond_to?(:qualified) ? arg.qualified : arg })
+        )
+      end
+
+      def is(other)
+        ::Sequel::SQL::BooleanExpression.new(:'=', func, other)
+      end
+
       private
 
       def func

data/lib/rom/sql/group_dsl.rb

@@ -0,0 +1,19 @@
+require 'rom/sql/dsl'
+
+module ROM
+  module SQL
+    # @api private
+    class GroupDSL < DSL
+      private
+
+      # @api private
+      def method_missing(meth, *args, &block)
+        if schema.key?(meth)
+          schema[meth].canonical
+        else
+          ::Sequel::VIRTUAL_ROW.__send__(meth.to_s.upcase, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/relation.rb

@@ -67,13 +67,32 @@ module ROM
 
       # @api private
       def self.define_default_views!
-        # @!method by_pk(pk)
-        #   Return a relation restricted by its primary key
-        #   @param [Object] pk The primary key value
-        #   @return [SQL::Relation]
-        #   @api public
-        view(:by_pk, schema.map(&:name)) do |pk|
-          where(primary_key => pk)
+        if schema.primary_key.size > 1
+          # @!method by_pk(val1, val2)
+          #   Return a relation restricted by its composite primary key
+          #
+          #   @param [Array] args A list with composite pk values
+          #
+          #   @return [SQL::Relation]
+          #
+          #   @api public
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def by_pk(#{schema.primary_key.map(&:name).join(', ')})
+              where(#{schema.primary_key.map { |attr| "schema[:#{attr.name}] => #{attr.name}" }.join(', ')})
+            end
+          RUBY
+        else
+          # @!method by_pk(pk)
+          #   Return a relation restricted by its primary key
+          #
+          #   @param [Object] pk The primary key value
+          #
+          #   @return [SQL::Relation]
+          #
+          #   @api public
+          define_method(:by_pk) do |pk|
+            where(schema[primary_key] => pk)
+          end
         end
       end
 

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

@@ -640,13 +640,68 @@ module ROM
         #   @example
         #     tasks.group(tasks[:id], tasks[:title])
         #
-        #   @param [Array<SQL::Attribute>] columns A list with column names
+        #   @param [Array<SQL::Attribute>] columns A list with relation attributes
+        #
+        # @overload group(*attributes, &block)
+        #   Return a new relation grouped by provided attributes from a block
+        #
+        #   @example
+        #     tasks.group(tasks[:id]) { title.qualified }
+        #
+        #   @param [Array<SQL::Attributes>] attributes A list with relation attributes
         #
         # @return [Relation]
         #
         # @api public
         def group(*args, &block)
-          new(dataset.__send__(__method__, *args, &block))
+          if block
+            if args.size > 0
+              group(*args).group_append(&block)
+            else
+              new(dataset.__send__(__method__, *schema.group(&block)))
+            end
+          else
+            new(dataset.__send__(__method__, *schema.project(*args).canonical))
+          end
+        end
+
+        # Group by more columns
+        #
+        # @overload group_append(*columns)
+        #   Return a new relation grouped by provided columns
+        #
+        #   @example
+        #     tasks.group_append(:user_id)
+        #
+        #   @param [Array<Symbol>] columns A list with column names
+        #
+        # @overload group_append(*attributes)
+        #   Return a new relation grouped by provided schema attributes
+        #
+        #   @example
+        #     tasks.group_append(tasks[:id], tasks[:title])
+        #
+        # @overload group_append(*attributes, &block)
+        #   Return a new relation grouped by provided schema attributes from a block
+        #
+        #   @example
+        #     tasks.group_append(tasks[:id]) { id.qualified }
+        #
+        #   @param [Array<SQL::Attribute>] columns A list with column names
+        #
+        # @return [Relation]
+        #
+        # @api public
+        def group_append(*args, &block)
+          if block
+            if args.size > 0
+              group_append(*args).group_append(&block)
+            else
+              new(dataset.group_append(*schema.group(&block)))
+            end
+          else
+            new(dataset.group_append(*args))
+          end
         end
 
         # Group by specific columns and count by group
@@ -742,18 +797,11 @@ module ROM
           when Symbol, Association::Name
             new(dataset.__send__(type, other.to_sym, join_cond, opts, &block))
           when Relation
-            __send__(type, other.name.dataset, join_keys(other))
+            associations[other.name.dataset].join(__registry__, type, self, other)
           else
             raise ArgumentError, "+other+ must be either a symbol or a relation, #{other.class} given"
           end
         end
-
-        # Return join key conditions for the provided relation
-        #
-        # @api private
-        def join_keys(other)
-          other.associations[name].join_keys(__registry__)
-        end
       end
     end
   end

data/lib/rom/sql/schema.rb

@@ -1,5 +1,6 @@
 require 'rom/schema'
 require 'rom/sql/order_dsl'
+require 'rom/sql/group_dsl'
 require 'rom/sql/projection_dsl'
 require 'rom/sql/restriction_dsl'
 
@@ -31,6 +32,11 @@ module ROM
         OrderDSL.new(self).call(&block)
       end
 
+      # @api public
+      def group(&block)
+        GroupDSL.new(self).call(&block)
+      end
+
       # Return a new schema with attributes marked as qualified
       #
       # @return [Schema]
@@ -40,6 +46,15 @@ module ROM
         new(map(&:qualified))
       end
 
+      # Return a new schema with attributes restored to canonical form
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def canonical
+        new(map(&:canonical))
+      end
+
       # @api public
       def project(*names, &block)
         if block

data/lib/rom/sql/version.rb

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

data/rom-sql.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
   spec.add_runtime_dependency 'dry-types', '~> 0.9', '>= 0.9.4'
   spec.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.3'
-  spec.add_runtime_dependency 'rom', '~> 3.0.0.rc'
+  spec.add_runtime_dependency 'rom', '~> 3.0'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'

data/spec/integration/plugins/auto_wrap_spec.rb

@@ -14,6 +14,16 @@ RSpec.describe 'Plugins / :auto_wrap' do
             id: 2, user_id: 1, title: "Jane's task", users_name: "Jane", users_id: 1
           )
         end
+
+        it 'works with by_pk' do
+          task_with_user = tasks
+                             .for_wrap({ id: :user_id }, users.name.relation)
+                             .by_pk(1)
+                             .one
+
+          expect(task_with_user).
+            to eql(id: 1, user_id: 2, title: "Joe's task", users_name: "Joe", users_id: 2)
+        end
       end
 
       context 'when parent relation is registered under dataset name' do

data/spec/unit/attribute_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Attribute, :postgres do
+  include_context 'users and tasks'
+
+  let(:users) { relations[:users] }
+  let(:ds) { users.dataset }
+
+  describe '#is' do
+    it 'returns a boolean expression' do
+      expect(users[:id].is(1).sql_literal(ds)).to eql('("id" = 1)')
+    end
+
+    it 'returns a boolean expression for qualified attribute' do
+      expect((users[:id].qualified.is(1)).sql_literal(ds)).to eql('("users"."id" = 1)')
+    end
+  end
+
+  describe '#concat' do
+    it 'returns a concat function attribute' do
+      expect(users[:id].concat(users[:name]).as(:uid).sql_literal(ds)).
+        to eql(%(CONCAT("id", ' ', "name") AS "uid"))
+    end
+  end
+end

data/spec/unit/function_spec.rb

@@ -22,6 +22,12 @@ RSpec.describe ROM::SQL::Function, :postgres do
     end
   end
 
+  describe '#is' do
+    it 'returns an sql boolean expression' do
+      expect((func.count(:id).is(1)).sql_literal(ds)).to eql(%((COUNT("id") = 1)))
+    end
+  end
+
   describe '#method_missing' do
     it 'responds to anything when not set' do
       expect(func.count(:id)).to be_instance_of(func.class)

data/spec/unit/relation/assoc_spec.rb

@@ -1,38 +1,87 @@
 require 'spec_helper'
 
-RSpec.describe ROM::SQL::Relation, :sqlite do
+RSpec.describe ROM::SQL::Relation do
   include_context 'users and tasks'
 
-  let(:users) { relations[:users] }
-  let(:tasks) { relations[:tasks] }
+  context 'with has_many' do
+    subject(:users) { relations[:users] }
 
-  before do
-    conf.relation(:users) do
-      schema(infer: true) do
-        associations do
-          has_many :tasks
+    let(:tasks) { relations[:tasks] }
+
+    before do
+      conf.relation(:users) do
+        schema(infer: true) do
+          associations do
+            has_many :tasks
+          end
         end
       end
     end
 
-    conf.relation(:tasks) do
-      schema(infer: true) do
-        associations do
-          belongs_to :users, as: :user
+    with_adapters do
+      it 'returns child tuples for a relation' do
+        expect(users.assoc(:tasks).where(name: 'Jane').to_a).
+          to eql([{ id: 2, user_id: 1, title: "Jane's task" }])
+      end
+    end
+  end
+
+  context 'with has_many-through' do
+    subject(:tasks) { relations[:tasks] }
+
+    before do
+      conf.relation(:task_tags) do
+        schema(infer: true) do
+          associations do
+            belongs_to :tasks
+            belongs_to :tags
+          end
         end
       end
+
+      conf.relation(:tasks) do
+        schema(infer: true) do
+          associations do
+            has_many :tags, through: :task_tags
+          end
+        end
+      end
+
+      conn[:tags].insert id: 2, name: 'whatevah'
+      conn[:task_tags].insert(tag_id: 2, task_id: 2)
+    end
+
+    with_adapters do
+      it 'returns child tuples for a relation' do
+        expect(tasks.assoc(:tags).to_a).
+          to eql([{ id: 1, name: 'important', task_id: 1 }, { id: 2, name: 'whatevah', task_id: 2 }])
+      end
+
+      it 'returns child tuples for a restricted relation' do
+        expect(tasks.assoc(:tags).where(title: "Jane's task").to_a).
+          to eql([{ id: 2, name: 'whatevah', task_id: 2 }])
+      end
     end
   end
 
-  with_adapters(:sqlite) do
-    it 'returns child tuples for a relation' do
-      expect(users.assoc(:tasks).where(name: 'Jane').to_a).
-        to eql([{ id: 2, user_id: 1, title: "Jane's task" }])
+  context 'with belongs_to' do
+    subject(:tasks) { relations[:tasks] }
+
+    before do
+      conf.relation(:tasks) do
+        schema(infer: true) do
+          associations do
+            belongs_to :users, as: :user
+          end
+        end
+      end
     end
 
-    it 'returns parent tuples for a relation' do
-      expect(tasks.assoc(:user).where(title: "Jane's task").to_a).
-        to eql([{ id: 1, task_id: 2, name: 'Jane' }])
+    with_adapters do
+      it 'returns parent tuples for a relation' do
+        expect(tasks.assoc(:user).where(title: "Jane's task").to_a).
+          to eql([{ id: 1, task_id: 2, name: 'Jane' }])
+      end
     end
   end
 end

data/spec/unit/relation/by_pk_spec.rb

@@ -1,15 +1,29 @@
 RSpec.describe ROM::Relation, '#by_pk' do
-  subject(:relation) { container.relations.users }
-
   include_context 'users and tasks'
 
   with_adapters do
-    it 'restricts a relation by its PK' do
-      expect(relation.by_pk(1).to_a).to eql([id: 1, name: 'Jane'])
+    context 'with a single PK' do
+      subject(:relation) { relations[:users] }
+
+      it 'restricts a relation by its PK' do
+        expect(relation.by_pk(1).to_a).to eql([id: 1, name: 'Jane'])
+      end
+
+      it 'is available as a view' do
+        expect(relation.by_pk).to be_curried
+      end
+
+      it 'qualifies pk attr' do
+        expect(relation.qualified.by_pk(1).select(:id).join(:tasks, user_id: :id).one).to eql(id: 1)
+      end
     end
 
-    it 'is available as a view' do
-      expect(relation.by_pk).to be_curried
+    context 'with a composite PK' do
+      subject(:relation) { relations[:task_tags] }
+
+      it 'restricts a relation by is PK' do
+        expect(relation.by_pk(1, 1).to_a).to eql([{ tag_id: 1, task_id: 1 }])
+      end
     end
   end
 end

data/spec/unit/relation/group_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe ROM::Relation, '#group' do
+  subject(:relation) { relations[:users] }
+
+  let(:tasks) { relations[:tasks] }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    it 'groups by provided attribute name' do
+      grouped = relation.
+                  qualified.
+                  left_join(:tasks, tasks[:user_id].qualified => relation[:id].qualified).
+                  group(:id)
+
+      expect(grouped.to_a).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe'}])
+    end
+
+    it 'groups by provided attribute name in a block' do
+      grouped = relation.
+                  qualified.
+                  left_join(:tasks, tasks[:user_id].qualified => relation[:id].qualified).
+                  group { id.qualified }
+
+      expect(grouped.to_a).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe'}])
+    end
+
+    it 'groups by aliased attributes' do
+      grouped = relation.
+                  select { id.as(:user_id) }.
+                  group(:id)
+
+      expect(grouped.to_a).to eql([{ user_id: 1 }, { user_id: 2 }])
+    end
+  end
+
+  with_adapters :postgres do
+    it 'groups by provided attribute name in and attributes from a block' do
+      grouped = relation.
+                  qualified.
+                  left_join(:tasks, tasks[:user_id].qualified => relation[:id].qualified).
+                  group(tasks[:title]) { id.qualified }
+
+      expect(grouped.to_a).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe'}])
+    end
+  end
+end

data/spec/unit/relation/inner_join_spec.rb

@@ -2,6 +2,7 @@ RSpec.describe ROM::Relation, '#inner_join' do
   subject(:relation) { relations[:users] }
 
   let(:tasks) { relations[:tasks] }
+  let(:tags) { relations[:tags] }
 
   include_context 'users and tasks'
 
@@ -44,9 +45,22 @@ RSpec.describe ROM::Relation, '#inner_join' do
           end
         end
 
+        conf.relation(:task_tags) do
+          schema(infer: true) do
+            associations do
+              belongs_to :tasks
+              belongs_to :tags
+            end
+          end
+        end
+
         conf.relation(:tasks) do
           schema(infer: true) do
-            associations { belongs_to :user }
+            associations do
+              belongs_to :user
+              has_many :task_tags
+              has_many :tags, through: :task_tags
+            end
           end
         end
 
@@ -65,6 +79,12 @@ RSpec.describe ROM::Relation, '#inner_join' do
                                      { name: 'Joe', title: "Joe's task" }
                                    ])
       end
+
+      it 'joins relation with join keys inferred for m:m-through' do
+        result = tasks.inner_join(tags)
+
+        expect(result.to_a).to eql([{ id: 1, user_id: 2, title: "Joe's task" }])
+      end
     end
 
     it 'raises error when column names are ambiguous' do

data/spec/unit/relation/order_spec.rb

@@ -37,4 +37,15 @@ RSpec.describe ROM::Relation, '#order' do
         to eql([{ id: 2, name: 'Joe' }, { id: 1, name: 'Jane' }, { id: 3, name: 'Jade' }])
     end
   end
+
+  with_adapters :postgres, :mysql do
+    it 'orders by virtual attributes' do
+      ordered = relation.
+                  select { string::concat(id, '-', name).as(:uid) }.
+                  order(:uid)
+
+      expect(ordered.to_a).
+        to eql([{ uid: '1-Jane' }, { uid: '2-Joe' }, { uid: '3-Jade' }])
+    end
+  end
 end

data/spec/unit/relation/qualified_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe ROM::Relation, '#qualified' do
+  subject(:relation) { relations[:users] }
+
+  let(:tasks) { relations[:tasks] }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    it 'qualifies all attributes' do
+      qualified = relation.qualified
+
+      expect(qualified.schema.all?(&:qualified)).to be(true)
+    end
+
+    it 'qualifies virtual attributes' do
+      qualified = relation.
+                    left_join(:tasks, tasks[:user_id].qualified => relation[:id].qualified).
+                    select(:id, tasks[:id].func { int::count(id).as(:count) }).
+                    qualified.
+                    group(:id)
+
+      expect(qualified.schema.all?(&:qualified)).to be(true)
+
+      expect(qualified.to_a).to eql([{ id: 1, count: 1 }, { id: 2, count: 1 }])
+    end
+  end
+end

data/spec/unit/relation/select_spec.rb

@@ -29,13 +29,5 @@ RSpec.describe ROM::Relation, '#select' do
     it 'supports blocks' do
       expect(relation.select { [id, title] }.schema.map(&:name)).to eql(%i[id title])
     end
-
-    it 'supports blocks with custom expressions' do
-      selected = relation
-                   .select { [int::count(id).as(:id_count), title.prefixed(:task)] }
-                   .group { [id, title] }
-
-      expect(selected.first).to eql(id_count: 1, task_title: "Joe's task")
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc2
+  version: 1.0.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-27 00:00:00.000000000 Z
+date: 2017-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -84,14 +84,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0.rc
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0.rc
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -173,6 +173,7 @@ files:
 - lib/rom/sql/extensions/sqlite/types.rb
 - lib/rom/sql/function.rb
 - lib/rom/sql/gateway.rb
+- lib/rom/sql/group_dsl.rb
 - lib/rom/sql/migration.rb
 - lib/rom/sql/migration/migrator.rb
 - lib/rom/sql/migration/template.rb
@@ -253,6 +254,7 @@ files:
 - spec/unit/association/one_to_many_spec.rb
 - spec/unit/association/one_to_one_spec.rb
 - spec/unit/association/one_to_one_through_spec.rb
+- spec/unit/attribute_spec.rb
 - spec/unit/function_spec.rb
 - spec/unit/gateway_spec.rb
 - spec/unit/logger_spec.rb
@@ -270,6 +272,7 @@ files:
 - spec/unit/relation/distinct_spec.rb
 - spec/unit/relation/exclude_spec.rb
 - spec/unit/relation/fetch_spec.rb
+- spec/unit/relation/group_spec.rb
 - spec/unit/relation/having_spec.rb
 - spec/unit/relation/inner_join_spec.rb
 - spec/unit/relation/inspect_spec.rb
@@ -284,6 +287,7 @@ files:
 - spec/unit/relation/primary_key_spec.rb
 - spec/unit/relation/project_spec.rb
 - spec/unit/relation/qualified_columns_spec.rb
+- spec/unit/relation/qualified_spec.rb
 - spec/unit/relation/read_spec.rb
 - spec/unit/relation/rename_spec.rb
 - spec/unit/relation/right_join_spec.rb
@@ -311,9 +315,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1
@@ -374,6 +378,7 @@ test_files:
 - spec/unit/association/one_to_many_spec.rb
 - spec/unit/association/one_to_one_spec.rb
 - spec/unit/association/one_to_one_through_spec.rb
+- spec/unit/attribute_spec.rb
 - spec/unit/function_spec.rb
 - spec/unit/gateway_spec.rb
 - spec/unit/logger_spec.rb
@@ -391,6 +396,7 @@ test_files:
 - spec/unit/relation/distinct_spec.rb
 - spec/unit/relation/exclude_spec.rb
 - spec/unit/relation/fetch_spec.rb
+- spec/unit/relation/group_spec.rb
 - spec/unit/relation/having_spec.rb
 - spec/unit/relation/inner_join_spec.rb
 - spec/unit/relation/inspect_spec.rb
@@ -405,6 +411,7 @@ test_files:
 - spec/unit/relation/primary_key_spec.rb
 - spec/unit/relation/project_spec.rb
 - spec/unit/relation/qualified_columns_spec.rb
+- spec/unit/relation/qualified_spec.rb
 - spec/unit/relation/read_spec.rb
 - spec/unit/relation/rename_spec.rb
 - spec/unit/relation/right_join_spec.rb