sequel 3.24.1 → 3.25.0

data/CHANGELOG

@@ -1,3 +1,31 @@
+=== 3.25.0 (2011-07-01)
+
+* Work with tiny_tds-0.4.5 in the tinytds adapter, older versions are no longer supported (jeremyevans)
+
+* Make association_pks plugin typecast provided values to integer if the primary key column type is integer (jeremyevans)
+ 
+* Model.set_dataset now accepts Identifier, QualifiedIdentifier, and AliasedExpression arguments (jeremyevans)
+
+* Fix handling of nil values in bound variables and prepared statement and stored procedure arguments in the jdbc adapter (jeremyevans, wei)
+
+* Allow treating Datasets as Expressions, e.g. DB[:table1].select(:column1) > DB[:table2].select(:column2) (jeremyevans)
+
+* No longer use CASCADE by default when dropping tables on PostgreSQL (jeremyevans)
+
+* Support :cascade option to #drop_table, #drop_view, #drop_column, and #drop_constraint for using CASCADE (jeremyevans)
+
+* If validation error messages are LiteralStrings, don't add the column name to them in Errors#full_messages (jeremyevans)
+
+* Fix bug loading plugins on 1.9 where ::ClassMethods, ::InstanceMethods, or ::DatasetMethods is defined (jeremyevans)
+
+* Add Dataset#exclude_where and Dataset#exclude_having methods, so you can force use of having or where clause (jeremyevans)
+
+* Allow Dataset#select_all to take table name arguments and select all columns from each given table (jeremyevans)
+
+* Add Dataset#select_group method, for selecting and grouping on the same columns (jeremyevans)
+
+* Allow Dataset#group and Dataset#group_and_count to accept a virtual row block (jeremyevans)
+
 === 3.24.1 (2011-06-03)
 
 * Ignore index creation errors if using create_table? with the IF NOT EXISTS syntax (jeremyevans) (#362)

data/doc/association_basics.rdoc

@@ -247,7 +247,7 @@ example is a tree structure:
   
   class Node
     many_to_one :parent, :class=>self
-    one_to_many :children :key=>:parent_id, :class=>self
+    one_to_many :children, :key=>:parent_id, :class=>self
   end
 
 For many_to_many self_referential associations, it's fairly similar.  Here's
@@ -381,7 +381,7 @@ method, you have to pass a proc as an argument:
 == Filtering By Associations
 
 In addition to using the association method to get associated objects, you
-can also use associated objects in filters.  For example, while to get
+can also use associated objects in filters.  For example, to get
 all albums for a given artist, you would usually do:
 
   @artist.albums
@@ -479,7 +479,7 @@ would be bad association names.
 
 == Database Schema
 
-Creating an association, doesn't modify the database schema.  Sequel
+Creating an association doesn't modify the database schema.  Sequel
 assumes your associations reflect the existing database schema.  If not,
 you should modify your schema before creating the associations.
 

data/doc/dataset_basics.rdoc

@@ -74,12 +74,12 @@ Most Dataset methods that users will use can be broken down into two types:
 
 Most dataset methods fall into this category, which can be further broken down by the clause they affect:
 
-SELECT:: select, select_all, select_append, select_more
+SELECT:: select, select_all, select_append, select_group, select_more
 FROM:: from, from_self
 JOIN:: join, left_join, right_join, full_join, natural_join, natural_left_join, natural_right_join, natural_full_join, cross_join, inner_join, left_outer_join, right_outer_join, full_outer_join, join_table
-WHERE:: where, filter, exclude, and, or, grep, invert, unfiltered
-GROUP:: group, group_by, group_and_count, ungrouped
-HAVING:: having, filter, exclude, and, or, grep, invert, unfiltered
+WHERE:: where, filter, exclude, exclude_where, and, or, grep, invert, unfiltered
+GROUP:: group, group_by, group_and_count, select_group, ungrouped
+HAVING:: having, filter, exclude, exclude_having, and, or, grep, invert, unfiltered
 ORDER:: order, order_by, order_append, order_prepend, order_more, reverse, reverse_order, unordered
 LIMIT:: limit, unlimited
 compounds:: union, intersect, except

data/doc/migration.rdoc

@@ -117,7 +117,8 @@ This looks a little weird, but you need to be aware that inside an up or +down+
 self always refers to the <tt>Sequel::Database</tt> object that the migration is being applied to.
 Since <tt>Database#[]</tt> creates datasets, using <tt>self[:artists]</tt> inside the +up+ block creates
 a dataset on the database representing all columns in the +artists+ table, and updates it to set the
-+location+ column to <tt>'Sacramento'</tt>.
++location+ column to <tt>'Sacramento'</tt>.  You should avoid referencing the <tt>Sequel::Database</tt>
+object directly in your migration, and always use self to reference it, otherwise you may run into problems.
 
 It is possible to use model classes inside migrations, as long as they are loaded into the ruby interpreter,
 but it's a bad habit as changes to your model classes can then break old migrations, and this breakage is
@@ -897,8 +898,8 @@ artist per album to multiple artists per album:
       # Insert one row in the albums_artists table
       # for each row in the albums table where there
       # is an associated artist
-      DB[:albums_artists].insert([:album_id, :artist_id],
-       DB[:albums].select(:id, :artist_id).exclude(:artist_id=>nil))
+      self[:albums_artists].insert([:album_id, :artist_id],
+       self[:albums].select(:id, :artist_id).exclude(:artist_id=>nil))
 
       # Drop the now unnecesssary column from the albums table
       drop_column :albums, :artist_id
@@ -910,12 +911,12 @@ artist per album to multiple artists per album:
       # If possible, associate each album with one of the artists
       # it was associated with.  This loses information, but
       # there's no way around that.
-      DB[:albums_artists].
+      self[:albums_artists].
        group(:album_id).
        select{[album_id, max(artist_id).as(artist_id)]}.
        having{artist_id >  0}.
        all do |r|
-         DB[:artists].
+         self[:artists].
           filter(:id=>r[:album_id]).
           update(:artist_id=>r[:artist_id])
        end

data/doc/opening_databases.rdoc

@@ -355,14 +355,17 @@ Examples:
 
 Because the underscore is not a valid character in a URI schema, the adapter
 is named tinytds instead of tiny_tds.  The connection options are passed directly
-to tiny_tds, except that the tiny_tds :dataserver and :username options are set to
-the Sequel :host and :user options.  The :host option should be an entry in the
-freetds.conf file, it's not currently possible to a host not present in the
-freetds.conf file.  Some options that you may want to set are
-:login_timeout, :timeout, :appname, and :encoding, see the tiny_tds README for details.
+to tiny_tds, except that the tiny_tds :username option is set to
+the Sequel :user option.  If you want to use an entry in the freetds.conf file, you
+should specify the :dataserver option with that name as the value.  Some other
+options that you may want to set are :login_timeout, :timeout, :tds_version, :azure,
+:appname, and :encoding, see the tiny_tds README for details.
+
 For highest performance, you should disable any identifier output method when
 using the tinytds adapter, which probably means disabling any identifier input method
 as well.  The default for Microsoft SQL Server is to :downcase identifiers on output
 and :upcase them on input, so the highest performance will require changing the setting
 from the default.
 
+The Sequel tinytds adapter requires tiny_tds >= 0.4.5, and if you are using FreeTDS
+0.91, you must at least be using 0.91rc2 (0.91rc1 does not work).

data/doc/release_notes/3.25.0.txt

@@ -0,0 +1,88 @@
+= New Features
+
+* drop_table, drop_view, drop_column, and drop_constraint all now
+  support a :cascade option for using CASCADE.
+  
+    DB.drop_table(:tab, :cascade=>true)
+    # DROP TABLE tab CASCADE
+    
+    DB.drop_column(:tab, :col, :cascade=>true)
+    # ALTER TABLE tab DROP COLUMN col CASCADE
+    
+  A few databases support CASCADE for dropping tables and views,
+  but only PostgreSQL appears to support it for columns and
+  constraints.  Using the :cascade option when the underlying
+  database doesn't support it will probably result in a
+  DatabaseError being raised.
+
+* You can now use datasets as expressions, allowing things such as:
+  
+    DB[:table1].select(:column1) > DB[:table2].select(:column2)
+    # (SELECT column1 FROM table1) > (SELECT column2 FROM table2)
+
+    DB[:table1].select(:column1).cast(Integer)
+    # CAST((SELECT column1 FROM table1) AS integer)
+
+* Dataset#select_group has been added for grouping and selecting on
+  the same columns.
+  
+    DB[:a].select_group(:b, :c)
+    # SELECT b, c FROM a GROUP BY b, c
+
+* Dataset#exclude_where and #exclude_having methods have been added,
+  allowing you to specify which clause to affect.  #exclude's
+  behavior is still to add to the HAVING clause if one is present,
+  and use the WHERE clause otherwise.
+  
+* Dataset#select_all now accepts optional arguments and will select
+  all columns from those arguments if present:
+  
+    DB[:a].select_all(:a)
+    # SELECT a.* FROM a
+    
+    DB.from(:a, :b).select_all(:a, :b)
+    # SELECT a.*, b.* FROM a, b
+
+* Dataset#group and #group_and_count now both accept virtual row
+  blocks:
+  
+    DB[:a].select(:b).group{c(d)}
+    # SELECT b FROM a GROUP BY c(d)
+
+* If you use a LiteralString as a validation error message, 
+  Errors#full_messages will now not add the related column name to
+  the start of the error message.
+
+* Model.set_dataset now accepts SQL::Identifier,
+  SQL::QualifiedIdentifier, and SQL::AliasedExpression instances,
+  treating them like Symbols.
+  
+= Other Improvements
+
+* The association_pks plugin's setter method will now automatically
+  convert a given array of strings to an array of integers if the
+  primary key field is an integer field, which should make it easier
+  to use in web applications.
+  
+* nil bound variable, prepared statement, and stored procedure
+  arguments are now handled correctly in the JDBC adapter.
+
+* On 1.9, you can now load plugins even when ::ClassMethods,
+  ::InstanceMethods, or ::DatasetMethods is defined.
+
+= Backwards Compatibility
+
+* The tinytds adapter now only works with tiny_tds 0.4.5 and greater.
+  Also, if you were using the tinytds adapter with FreeTDS 0.91rc1,
+  you need to upgrade to FreeTDS 0.91rc2 for it to work.  Also, if
+  you were referencing an entry in the freetds.conf file, you now
+  need to specify it directly using the :dataserver option when
+  connecting, the adapter no longer copies the :host option to the
+  :dataserver option.
+
+* On postgresql, Sequel now no longer drops tables with CASCADE by
+  default.  You now have to use the :cascade option to drop_table if
+  you want to use CASCADE.
+
+* The Database#drop_table_sql private method now takes an additional
+  options hash argument.

data/lib/sequel/adapters/jdbc.rb

@@ -422,8 +422,8 @@ module Sequel
           cps.setDouble(i, arg)
         when TrueClass, FalseClass
           cps.setBoolean(i, arg)
-        when nil
-          cps.setNull(i, JavaSQL::Types::NULL)
+        when NilClass
+          cps.setString(i, nil)
         when DateTime
           cps.setTimestamp(i, java_sql_datetime(arg))
         when Date

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -60,6 +60,12 @@ module Sequel
         
         private
         
+        # Use setNull for nil arguments as the default behavior of setString
+        # with nil doesn't appear to work correctly on PostgreSQL.
+        def set_ps_arg(cps, arg, i)
+          arg.nil? ? cps.setNull(i, JavaSQL::Types::NULL) : super
+        end
+
         # Extend the adapter with the JDBC PostgreSQL AdapterMethods
         def setup_connection(conn)
           conn = super(conn)

data/lib/sequel/adapters/shared/postgres.rb

@@ -460,11 +460,6 @@ module Sequel
         "DROP LANGUAGE#{' IF EXISTS' if opts[:if_exists]} #{name}#{' CASCADE' if opts[:cascade]}"
       end
 
-      # Always CASCADE the table drop
-      def drop_table_sql(name)
-        "DROP TABLE #{quote_schema_table(name)} CASCADE"
-      end
-      
       # SQL for dropping a trigger from the database.
       def drop_trigger_sql(table, name, opts={})
         "DROP TRIGGER#{' IF EXISTS' if opts[:if_exists]} #{name} ON #{quote_schema_table(table)}#{' CASCADE' if opts[:cascade]}"

data/lib/sequel/adapters/tinytds.rb

@@ -11,7 +11,6 @@ module Sequel
       # :dataserver and :username options.
       def connect(server)
         opts = server_opts(server)
-        opts[:dataserver] = opts[:host]
         opts[:username] = opts[:user]
         set_mssql_unicode_strings
         TinyTds::Client.new(opts)
@@ -39,7 +38,7 @@ module Sequel
             end
             yield(r) if block_given?
           rescue TinyTds::Error => e
-            raise_error(e, :disconnect=>(c.closed? || (c.respond_to?(:dead?) && c.dead?)))
+            raise_error(e, :disconnect=>!c.active?)
           ensure
            r.cancel if r && c.sqlsent?
           end

data/lib/sequel/database/schema_generator.rb

@@ -329,15 +329,17 @@ module Sequel
       # Remove a column from the DDL for the table.
       #
       #   drop_column(:artist_id) # DROP COLUMN artist_id
-      def drop_column(name)
-        @operations << {:op => :drop_column, :name => name}
+      #   drop_column(:artist_id, :cascade=>true) # DROP COLUMN artist_id CASCADE
+      def drop_column(name, opts={})
+        @operations << {:op => :drop_column, :name => name}.merge(opts)
       end
       
       # Remove a constraint from the DDL for the table.
       #
       #   drop_constraint(:unique_name) # DROP CONSTRAINT unique_name
-      def drop_constraint(name)
-        @operations << {:op => :drop_constraint, :name => name}
+      #   drop_constraint(:unique_name, :cascade=>true) # DROP CONSTRAINT unique_name CASCADE
+      def drop_constraint(name, opts={})
+        @operations << {:op => :drop_constraint, :name => name}.merge(opts)
       end
       
       # Remove an index from the DDL for the table.

data/lib/sequel/database/schema_methods.rb

@@ -159,10 +159,13 @@ module Sequel
     
     # Drops one or more tables corresponding to the given names:
     #
+    #   DB.drop_table(:posts)
     #   DB.drop_table(:posts, :comments)
+    #   DB.drop_table(:posts, :comments, :cascade=>true)
     def drop_table(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
       names.each do |n|
-        execute_ddl(drop_table_sql(n))
+        execute_ddl(drop_table_sql(n, options))
         remove_cached_schema(n)
       end
       nil
@@ -171,9 +174,12 @@ module Sequel
     # Drops one or more views corresponding to the given names:
     #
     #   DB.drop_view(:cheap_items)
+    #   DB.drop_view(:cheap_items, :pricey_items)
+    #   DB.drop_view(:cheap_items, :pricey_items, :cascade=>true)
     def drop_view(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
       names.each do |n|
-        execute_ddl("DROP VIEW #{quote_schema_table(n)}")
+        execute_ddl(drop_view_sql(n, options))
         remove_cached_schema(n)
       end
       nil
@@ -228,7 +234,7 @@ module Sequel
       when :add_column
         "ADD COLUMN #{column_definition_sql(op)}"
       when :drop_column
-        "DROP COLUMN #{quoted_name}"
+        "DROP COLUMN #{quoted_name}#{' CASCADE' if op[:cascade]}"
       when :rename_column
         "RENAME COLUMN #{quoted_name} TO #{quote_identifier(op[:new_name])}"
       when :set_column_type
@@ -244,7 +250,7 @@ module Sequel
       when :add_constraint
         "ADD #{constraint_definition_sql(op)}"
       when :drop_constraint
-        "DROP CONSTRAINT #{quoted_name}"
+        "DROP CONSTRAINT #{quoted_name}#{' CASCADE' if op[:cascade]}"
       else
         raise Error, "Unsupported ALTER TABLE operation"
       end
@@ -391,10 +397,15 @@ module Sequel
     end
 
     # SQL DDL statement to drop the table with the given name.
-    def drop_table_sql(name)
-      "DROP TABLE #{quote_schema_table(name)}"
+    def drop_table_sql(name, options)
+      "DROP TABLE #{quote_schema_table(name)}#{' CASCADE' if options[:cascade]}"
     end
     
+    # SQL DDL statement to drop a view with the given name.
+    def drop_view_sql(name, options)
+      "DROP VIEW #{quote_schema_table(name)}#{' CASCADE' if options[:cascade]}"
+    end
+
     # Proxy the filter_expr call to the dataset, used for creating constraints.
     def filter_expr(*args, &block)
       schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))

data/lib/sequel/dataset.rb

@@ -26,6 +26,14 @@ module Sequel
     extend Metaprogramming
     include Metaprogramming
     include Enumerable
+    include SQL::AliasMethods
+    include SQL::BooleanMethods
+    include SQL::CastMethods
+    include SQL::ComplexExpressionMethods
+    include SQL::InequalityMethods
+    include SQL::NumericMethods
+    include SQL::OrderMethods
+    include SQL::StringMethods
   end
   
   require(%w"query actions features graph prepared_statements misc mutation sql", 'dataset')

data/lib/sequel/dataset/misc.rb

@@ -45,15 +45,6 @@ module Sequel
       self == o
     end
     
-    # Return the dataset as an aliased expression with the given alias. You can
-    # use this as a FROM or JOIN dataset, or as a column if this dataset
-    # returns a single row and column.
-    #
-    #   DB.from(DB[:table].as(:b)) # SELECT * FROM (SELECT * FROM table) AS b
-    def as(aliaz)
-      ::Sequel::SQL::AliasedExpression.new(self, aliaz)
-    end
-    
     # Yield a dataset for each server in the connection pool that is tied to that server.
     # Intended for use in sharded environments where all servers need to be modified
     # with the same data:

data/lib/sequel/dataset/query.rb

@@ -28,10 +28,10 @@ module Sequel
     JOIN_METHODS = (CONDITIONED_JOIN_TYPES + UNCONDITIONED_JOIN_TYPES).map{|x| "#{x}_join".to_sym} + [:join, :join_table]
     
     # Methods that return modified datasets
-    QUERY_METHODS = %w'add_graph_aliases and distinct except exclude
+    QUERY_METHODS = %w'add_graph_aliases and distinct except exclude exclude_having exclude_where
     filter for_update from from_self graph grep group group_and_count group_by having intersect invert
     limit lock_style naked or order order_append order_by order_more order_prepend paginate qualify query
-    reverse reverse_order select select_all select_append select_more server
+    reverse reverse_order select select_all select_append select_group select_more server
     set_defaults set_graph_aliases set_overrides unfiltered ungraphed ungrouped union
     unlimited unordered where with with_recursive with_sql'.collect{|x| x.to_sym} + JOIN_METHODS
 
@@ -103,12 +103,29 @@ module Sequel
     #   DB[:items].exclude(:category => 'software', :id=>3)
     #   # SELECT * FROM items WHERE ((category != 'software') OR (id != 3))
     def exclude(*cond, &block)
-      clause = (@opts[:having] ? :having : :where)
-      cond = cond.first if cond.size == 1
-      cond = filter_expr(cond, &block)
-      cond = SQL::BooleanExpression.invert(cond)
-      cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause]
-      clone(clause => cond)
+      _filter_or_exclude(true, @opts[:having] ? :having : :where, *cond, &block)
+    end
+
+    # Inverts the given conditions and adds them to the HAVING clause.
+    #
+    #   DB[:items].select_group(:name).exclude_having{count(name) < 2}
+    #   # SELECT name FROM items GROUP BY name HAVING (count(name) >= 2)
+    def exclude_having(*cond, &block)
+      _filter_or_exclude(true, :having, *cond, &block)
+    end
+
+    # Inverts the given conditions and adds them to the WHERE clause.
+    #
+    #   DB[:items].select_group(:name).exclude_where(:category => 'software')
+    #   # SELECT * FROM items WHERE (category != 'software')
+    #
+    #   DB[:items].select_group(:name).
+    #     exclude_having{count(name) < 2}.
+    #     exclude_where(:category => 'software')
+    #   # SELECT name FROM items WHERE (category != 'software')
+    #   # GROUP BY name HAVING (count(name) >= 2)
+    def exclude_where(*cond, &block)
+      _filter_or_exclude(true, :where, *cond, &block)
     end
 
     # Returns a copy of the dataset with the given conditions imposed upon it.  
@@ -270,21 +287,25 @@ module Sequel
     end
 
     # Returns a copy of the dataset with the results grouped by the value of 
-    # the given columns.
+    # the given columns.  If a block is given, it is treated
+    # as a virtual row block, similar to +filter+.
     #
     #   DB[:items].group(:id) # SELECT * FROM items GROUP BY id
     #   DB[:items].group(:id, :name) # SELECT * FROM items GROUP BY id, name
-    def group(*columns)
+    #   DB[:items].group{[a, sum(b)]} # SELECT * FROM items GROUP BY a, sum(b)
+    def group(*columns, &block)
+      virtual_row_columns(columns, block)
       clone(:group => (columns.compact.empty? ? nil : columns))
     end
 
     # Alias of group
-    def group_by(*columns)
-      group(*columns)
+    def group_by(*columns, &block)
+      group(*columns, &block)
     end
     
     # Returns a dataset grouped by the given column with count by group.
     # Column aliases may be supplied, and will be included in the select clause.
+    # If a block is given, it is treated as a virtual row block, similar to +filter+.
     #
     # Examples:
     #
@@ -299,8 +320,12 @@ module Sequel
     #   DB[:items].group_and_count(:first_name___name).all
     #   # SELECT first_name AS name, count(*) AS count FROM items GROUP BY first_name
     #   # => [{:name=>'a', :count=>1}, ...]
-    def group_and_count(*columns)
-      group(*columns.map{|c| unaliased_identifier(c)}).select(*(columns + [COUNT_OF_ALL_AS_COUNT]))
+    #
+    #   DB[:items].group_and_count{substr(first_name, 1, 1).as(initial)}.all
+    #   # SELECT substr(first_name, 1, 1) AS initial, count(*) AS count FROM items GROUP BY substr(first_name, 1, 1)
+    #   # => [{:initial=>'a', :count=>1}, ...]
+    def group_and_count(*columns, &block)
+      select_group(*columns, &block).select_more(COUNT_OF_ALL_AS_COUNT)
     end
 
     # Returns a copy of the dataset with the HAVING conditions changed. See #filter for argument types.
@@ -532,7 +557,7 @@ module Sequel
     #   DB[:items].order{sum(name).desc} # SELECT * FROM items ORDER BY sum(name) DESC
     #   DB[:items].order(nil) # SELECT * FROM items
     def order(*columns, &block)
-      columns += Array(Sequel.virtual_row(&block)) if block
+      virtual_row_columns(columns, block)
       clone(:order => (columns.compact.empty?) ? nil : columns)
     end
     
@@ -630,7 +655,7 @@ module Sequel
     #   DB[:items].select(:a, :b) # SELECT a, b FROM items
     #   DB[:items].select{[a, sum(b)]} # SELECT a, sum(b) FROM items
     def select(*columns, &block)
-      columns += Array(Sequel.virtual_row(&block)) if block
+      virtual_row_columns(columns, block)
       m = []
       columns.each do |i|
         i.is_a?(Hash) ? m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)}) : m << i
@@ -638,11 +663,19 @@ module Sequel
       clone(:select => m)
     end
     
-    # Returns a copy of the dataset selecting the wildcard.
+    # Returns a copy of the dataset selecting the wildcard if no arguments
+    # are given.  If arguments are given, treat them as tables and select
+    # all columns (using the wildcard) from each table.
     #
     #   DB[:items].select(:a).select_all # SELECT * FROM items
-    def select_all
-      clone(:select => nil)
+    #   DB[:items].select_all(:items) # SELECT items.* FROM items
+    #   DB[:items].select_all(:items, :foo) # SELECT items.*, foo.* FROM items
+    def select_all(*tables)
+      if tables.empty?
+        clone(:select => nil)
+      else
+        select(*tables.map{|t| SQL::ColumnAll.new(t)})
+      end
     end
     
     # Returns a copy of the dataset with the given columns added
@@ -658,6 +691,20 @@ module Sequel
       select(*(cur_sel + columns), &block)
     end
 
+    # Set both the select and group clauses with the given +columns+.
+    # Column aliases may be supplied, and will be included in the select clause.
+    # This also takes a virtual row block similar to +filter+.
+    #
+    #   DB[:items].select_group(:a, :b)
+    #   # SELECT a, b FROM items GROUP BY a, b
+    #
+    #   DB[:items].select_group(:c___a){f(c2)}
+    #   # SELECT c AS a, f(c2) FROM items GROUP BY c, f(c2)
+    def select_group(*columns, &block)
+      virtual_row_columns(columns, block)
+      select(*columns).group(*columns.map{|c| unaliased_identifier(c)})
+    end
+
     # Returns a copy of the dataset with the given columns added
     # to the existing selected columns. If no columns are currently selected
     # it will just select the columns given. 
@@ -840,17 +887,29 @@ module Sequel
 
     private
 
-    # Internal filter method so it works on either the having or where clauses.
-    def _filter(clause, *cond, &block)
+    # Internal filter/exclude method so it works on either the having or where clauses.
+    def _filter_or_exclude(invert, clause, *cond, &block)
       cond = cond.first if cond.size == 1
       if cond.respond_to?(:empty?) && cond.empty? && !block
         clone
       else
         cond = filter_expr(cond, &block)
+        cond = SQL::BooleanExpression.invert(cond) if invert
         cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause]
         clone(clause => cond)
       end
     end
+
+    # Internal filter method so it works on either the having or where clauses.
+    def _filter(clause, *cond, &block)
+      _filter_or_exclude(false, clause, *cond, &block)
+    end
+
+    # Treat the +block+ as a virtual_row block if not +nil+ and
+    # add the resulting columns to the +columns+ array (modifies +columns+).
+    def virtual_row_columns(columns, block)
+      columns.concat(Array(Sequel.virtual_row(&block))) if block
+    end
     
     # Add the dataset to the list of compounds
     def compound_clone(type, dataset, opts)