sequel 3.5.0 → 3.6.0

data/lib/sequel/dataset/actions.rb

@@ -0,0 +1,123 @@
+module Sequel
+  class Dataset
+
+    # Alias for insert, but not aliased directly so subclasses
+    # don't have to override both methods.
+    def <<(*args)
+      insert(*args)
+    end
+
+    # Returns an array with all records in the dataset. If a block is given,
+    # the array is iterated over after all items have been loaded.
+    def all(&block)
+      a = []
+      each{|r| a << r}
+      post_load(a)
+      a.each(&block) if block
+      a
+    end
+  
+    # Returns the columns in the result set in order.
+    # If the columns are currently cached, returns the cached value. Otherwise,
+    # a SELECT query is performed to get a single row. Adapters are expected
+    # to fill the columns cache with the column information when a query is performed.
+    # If the dataset does not have any rows, this may be an empty array depending on how
+    # the adapter is programmed.
+    #
+    # If you are looking for all columns for a single table and maybe some information about
+    # each column (e.g. type), see Database#schema.
+    def columns
+      return @columns if @columns
+      ds = unfiltered.unordered.clone(:distinct => nil, :limit => 1)
+      ds.each{break}
+      @columns = ds.instance_variable_get(:@columns)
+      @columns || []
+    end
+    
+    # Remove the cached list of columns and do a SELECT query to find
+    # the columns.
+    def columns!
+      @columns = nil
+      columns
+    end
+    
+    # Deletes the records in the dataset.  The returned value is generally the
+    # number of records deleted, but that is adapter dependent.  See delete_sql.
+    def delete
+      execute_dui(delete_sql)
+    end
+    
+    # Iterates over the records in the dataset as they are yielded from the
+    # database adapter, and returns self.
+    #
+    # Note that this method is not safe to use on many adapters if you are
+    # running additional queries inside the provided block.  If you are
+    # running queries inside the block, you use should all instead of each.
+    def each(&block)
+      if @opts[:graph]
+        graph_each(&block)
+      else
+        if row_proc = @row_proc
+          fetch_rows(select_sql){|r| yield row_proc.call(r)}
+        else
+          fetch_rows(select_sql, &block)
+        end
+      end
+      self
+    end
+
+    # Executes a select query and fetches records, passing each record to the
+    # supplied block.  The yielded records should be hashes with symbol keys.
+    def fetch_rows(sql, &block)
+      raise NotImplementedError, NOTIMPL_MSG
+    end
+  
+    # Inserts values into the associated table.  The returned value is generally
+    # the value of the primary key for the inserted row, but that is adapter dependent.
+    # See insert_sql.
+    def insert(*values)
+      execute_insert(insert_sql(*values))
+    end
+  
+    # Alias for set, but not aliased directly so subclasses
+    # don't have to override both methods.
+    def set(*args)
+      update(*args)
+    end
+
+    # Truncates the dataset.  Returns nil.
+    def truncate
+      execute_ddl(truncate_sql)
+    end
+
+    # Updates values for the dataset.  The returned value is generally the
+    # number of rows updated, but that is adapter dependent.  See update_sql.
+    def update(values={})
+      execute_dui(update_sql(values))
+    end
+
+    private
+
+    # Execute the given SQL on the database using execute.
+    def execute(sql, opts={}, &block)
+      @db.execute(sql, {:server=>@opts[:server] || :read_only}.merge(opts), &block)
+    end
+    
+    # Execute the given SQL on the database using execute_ddl.
+    def execute_ddl(sql, opts={}, &block)
+      @db.execute_ddl(sql, default_server_opts(opts), &block)
+      nil
+    end
+    
+    # Execute the given SQL on the database using execute_dui.
+    def execute_dui(sql, opts={}, &block)
+      @db.execute_dui(sql, default_server_opts(opts), &block)
+    end
+    
+    # Execute the given SQL on the database using execute_insert.
+    def execute_insert(sql, opts={}, &block)
+      @db.execute_insert(sql, default_server_opts(opts), &block)
+    end
+  
+  end
+end

data/lib/sequel/dataset/convenience.rb

@@ -25,7 +25,7 @@ module Sequel
 
     # Returns the average value for the given column.
     def avg(column)
-      get{|o| o.avg(column)}
+      aggregate_dataset.get{avg(column)}
     end
     
     # Returns true if no records exist in the dataset, false otherwise
@@ -82,12 +82,20 @@ module Sequel
     end
 
     # Returns a dataset grouped by the given column with count by group,
-    # order by the count of records.  Examples:
+    # order by the count of records (in ascending order). Column aliases
+    # may be supplied, and will be included in the select clause.
     #
-    #   ds.group_and_count(:name) => [{:name=>'a', :count=>1}, ...]
-    #   ds.group_and_count(:first_name, :last_name) => [{:first_name=>'a', :last_name=>'b', :count=>1}, ...]
+    # Examples:
+    #
+    #   ds.group_and_count(:name).all => [{:name=>'a', :count=>1}, ...]
+    #   ds.group_and_count(:first_name, :last_name).all => [{:first_name=>'a', :last_name=>'b', :count=>1}, ...]
+    #   ds.group_and_count(:first_name___name).all => [{:name=>'a', :count=>1}, ...]
     def group_and_count(*columns)
-      group(*columns).select(*(columns + [COUNT_OF_ALL_AS_COUNT])).order(:count)
+      groups = columns.map do |c|
+        c_table, column, _ = split_symbol(c)
+        c_table ? column.to_sym.qualify(c_table) : column.to_sym
+      end
+      group(*groups).select(*(columns + [COUNT_OF_ALL_AS_COUNT])).order(:count)
     end
     
     # Inserts multiple records into the associated table. This method can be
@@ -130,7 +138,7 @@ module Sequel
     # Returns the interval between minimum and maximum values for the given 
     # column.
     def interval(column)
-      get{|o| o.max(column) - o.min(column)}
+      aggregate_dataset.get{max(column) - min(column)}
     end
 
     # Reverses the order and then runs first.  Note that this
@@ -159,12 +167,12 @@ module Sequel
 
     # Returns the maximum value for the given column.
     def max(column)
-      get{|o| o.max(column)}
+      aggregate_dataset.get{max(column)}
     end
 
     # Returns the minimum value for the given column.
     def min(column)
-      get{|o| o.min(column)}
+      aggregate_dataset.get{min(column)}
     end
 
     # This is a front end for import that allows you to submit an array of
@@ -186,7 +194,7 @@ module Sequel
     # Returns a Range object made from the minimum and maximum values for the
     # given column.
     def range(column)
-      if r = select{|o| [o.min(column).as(:v1), o.max(column).as(:v2)]}.first
+      if r = aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
         (r[:v1]..r[:v2])
       end
     end
@@ -207,7 +215,7 @@ module Sequel
     
     # Returns the sum for the given column.
     def sum(column)
-      get{|o| o.sum(column)}
+      aggregate_dataset.get{sum(column)}
     end
 
     # Returns a string in CSV format containing the dataset records. By 

data/lib/sequel/dataset/features.rb

@@ -0,0 +1,65 @@
+module Sequel
+  class Dataset
+    # Whether this dataset quotes identifiers.
+    def quote_identifiers?
+      @quote_identifiers
+    end
+    
+    # Whether the dataset requires SQL standard datetimes (false by default,
+    # as most allow strings with ISO 8601 format.
+    def requires_sql_standard_datetimes?
+      false
+    end
+
+    # Whether the dataset supports common table expressions (the WITH clause).
+    def supports_cte?
+      select_clause_methods.include?(WITH_SUPPORTED)
+    end
+
+    # Whether the dataset supports the DISTINCT ON clause, true by default.
+    def supports_distinct_on?
+      true
+    end
+
+    # Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
+    def supports_intersect_except?
+      true
+    end
+
+    # Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default.
+    def supports_intersect_except_all?
+      true
+    end
+
+    # Whether the dataset supports the IS TRUE syntax.
+    def supports_is_true?
+      true
+    end
+    
+    # Whether the dataset supports the JOIN table USING (column1, ...) syntax.
+    def supports_join_using?
+      true
+    end
+    
+    # Whether the IN/NOT IN operators support multiple columns when an
+    # array of values is given.
+    def supports_multiple_column_in?
+      true
+    end
+    
+    # Whether the dataset supports timezones in literal timestamps
+    def supports_timestamp_timezones?
+      false
+    end
+    
+    # Whether the dataset supports fractional seconds in literal timestamps
+    def supports_timestamp_usecs?
+      true
+    end
+    
+    # Whether the dataset supports window functions.
+    def supports_window_functions?
+      false
+    end
+  end
+end

data/lib/sequel/dataset/prepared_statements.rb

@@ -16,11 +16,10 @@ module Sequel
       attr_accessor :bind_arguments
       
       # Set the bind arguments based on the hash and call super.
-      def call(hash, &block)
-        ds = clone
+      def call(bind_vars={}, &block)
+        ds = bind(bind_vars)
         ds.prepared_sql
-        ds.bind_arguments = ds.map_to_prepared_args(hash)
-        ds.prepared_args = hash
+        ds.bind_arguments = ds.map_to_prepared_args(ds.opts[:bind_vars])
         ds.run(&block)
       end
         
@@ -55,7 +54,7 @@ module Sequel
       # :insert, :update, or :delete
       attr_accessor :prepared_type
       
-      # The bind variable hash to use when substituting
+      # The array/hash of bound variable placeholder names.
       attr_accessor :prepared_args
       
       # The argument to supply to insert and update, which may use
@@ -64,10 +63,8 @@ module Sequel
       
       # Sets the prepared_args to the given hash and runs the
       # prepared statement.
-      def call(hash, &block)
-        ds = clone
-        ds.prepared_args = hash
-        ds.run(&block)
+      def call(bind_vars={}, &block)
+        bind(bind_vars).run(&block)
       end
       
       # Returns the SQL for the prepared statement, depending on
@@ -79,9 +76,9 @@ module Sequel
         when :first
           clone(:limit=>1).select_sql
         when :insert
-          insert_sql(@prepared_modify_values)
+          insert_sql(*@prepared_modify_values)
         when :update
-          update_sql(@prepared_modify_values)
+          update_sql(*@prepared_modify_values)
         when :delete
           delete_sql
         end
@@ -91,8 +88,9 @@ module Sequel
       # prepared_args is present.  If so, they are considered placeholders,
       # and they are substituted using prepared_arg.
       def literal_symbol(v)
-        if match = PLACEHOLDER_RE.match(v.to_s) and @prepared_args
-          literal(prepared_arg(match[1].to_sym))
+        if @opts[:bind_vars] and match = PLACEHOLDER_RE.match(v.to_s)
+          v2 = prepared_arg(match[1].to_sym)
+          v2 ? literal(v2) : v
         else
           super
         end
@@ -117,9 +115,9 @@ module Sequel
         when :first
           first
         when :insert
-          insert(@prepared_modify_values)
+          insert(*@prepared_modify_values)
         when :update
-          update(@prepared_modify_values)
+          update(*@prepared_modify_values)
         when :delete
           delete
         end
@@ -129,7 +127,7 @@ module Sequel
       
       # Returns the value of the prepared_args hash for the given key.
       def prepared_arg(k)
-        @prepared_args[k]
+        @opts[:bind_vars][k]
       end
 
       # Use a clone of the dataset extended with prepared statement
@@ -137,6 +135,7 @@ module Sequel
       # bind variables/prepared arguments in subselects.
       def subselect_sql(ds)
         ps = ds.prepare(:select)
+        ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
         ps.prepared_args = prepared_args
         ps.prepared_sql
       end
@@ -154,8 +153,8 @@ module Sequel
       # Returns a single output array mapping the values of the input hash.
       # Keys in the input hash that are used more than once in the query
       # have multiple entries in the output array.
-      def map_to_prepared_args(hash)
-        @prepared_args.map{|v| hash[v]}
+      def map_to_prepared_args(bind_vars)
+        prepared_args.map{|v| bind_vars[v]}
       end
       
       private
@@ -163,18 +162,25 @@ module Sequel
       # Associates the argument with name k with the next position in
       # the output array.
       def prepared_arg(k)
-        @prepared_args << k
+        prepared_args << k
         prepared_arg_placeholder
       end
     end
     
+    # Set the bind variables to use for the call.  If bind variables have
+    # already been set for this dataset, they are updated with the contents
+    # of bind_vars.
+    def bind(bind_vars={})
+      clone(:bind_vars=>@opts[:bind_vars] ? @opts[:bind_vars].merge(bind_vars) : bind_vars)
+    end
+    
     # For the given type (:select, :insert, :update, or :delete),
     # run the sql with the bind variables
     # specified in the hash.  values is a hash of passed to
     # insert or update (if one of those types is used),
     # which may contain placeholders.
-    def call(type, bind_variables={}, values=nil)
-      prepare(type, nil, values).call(bind_variables)
+    def call(type, bind_variables={}, *values, &block)
+      prepare(type, nil, *values).call(bind_variables, &block)
     end
     
     # Prepare an SQL statement for later execution. This returns
@@ -186,7 +192,7 @@ module Sequel
     #   ps = prepare(:select, :select_by_name)
     #   ps.call(:name=>'Blah')
     #   db.call(:select_by_name, :name=>'Blah')
-    def prepare(type, name=nil, values=nil)
+    def prepare(type, name=nil, *values)
       ps = to_prepared_statement(type, values)
       db.prepared_statements[name] = ps if name
       ps
@@ -197,7 +203,7 @@ module Sequel
     # Return a cloned copy of the current dataset extended with
     # PreparedStatementMethods, setting the type and modify values.
     def to_prepared_statement(type, values=nil)
-      ps = clone
+      ps = bind
       ps.extend(PreparedStatementMethods)
       ps.prepared_type = type
       ps.prepared_modify_values = values

data/lib/sequel/dataset/query.rb

@@ -0,0 +1,429 @@
+module Sequel
+  class Dataset
+
+    FROM_SELF_KEEP_OPTS = [:graph, :eager_graph, :graph_aliases]
+
+    # Adds an further filter to an existing filter using AND. If no filter 
+    # exists an error is raised. This method is identical to #filter except
+    # it expects an existing filter.
+    #
+    #   ds.filter(:a).and(:b) # SQL: WHERE a AND b
+    def and(*cond, &block)
+      raise(InvalidOperation, "No existing filter found.") unless @opts[:having] || @opts[:where]
+      filter(*cond, &block)
+    end
+
+    # Returns a copy of the dataset with the SQL DISTINCT clause.
+    # The DISTINCT clause is used to remove duplicate rows from the
+    # output.  If arguments are provided, uses a DISTINCT ON clause,
+    # in which case it will only be distinct on those columns, instead
+    # of all returned columns.  Raises an error if arguments
+    # are given and DISTINCT ON is not supported.
+    #
+    #  dataset.distinct # SQL: SELECT DISTINCT * FROM items
+    #  dataset.order(:id).distinct(:id) # SQL: SELECT DISTINCT ON (id) * FROM items ORDER BY id
+    def distinct(*args)
+      raise(InvalidOperation, "DISTINCT ON not supported") if !args.empty? && !supports_distinct_on?
+      clone(:distinct => args)
+    end
+
+    # Adds an EXCEPT clause using a second dataset object.
+    # An EXCEPT compound dataset returns all rows in the current dataset
+    # that are not in the given dataset.
+    # Raises an InvalidOperation if the operation is not supported.
+    # Options:
+    # * :all - Set to true to use EXCEPT ALL instead of EXCEPT, so duplicate rows can occur
+    # * :from_self - Set to false to not wrap the returned dataset in a from_self, use with care.
+    #
+    #   DB[:items].except(DB[:other_items]).sql
+    #   #=> "SELECT * FROM items EXCEPT SELECT * FROM other_items"
+    def except(dataset, opts={})
+      opts = {:all=>opts} unless opts.is_a?(Hash)
+      raise(InvalidOperation, "EXCEPT not supported") unless supports_intersect_except?
+      raise(InvalidOperation, "EXCEPT ALL not supported") if opts[:all] && !supports_intersect_except_all?
+      compound_clone(:except, dataset, opts)
+    end
+
+    # Performs the inverse of Dataset#filter.
+    #
+    #   dataset.exclude(:category => 'software').sql #=>
+    #     "SELECT * FROM items WHERE (category != 'software')"
+    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)
+    end
+
+    # Returns a copy of the dataset with the given conditions imposed upon it.  
+    # If the query already has a HAVING clause, then the conditions are imposed in the 
+    # HAVING clause. If not, then they are imposed in the WHERE clause.
+    # 
+    # filter accepts the following argument types:
+    #
+    # * Hash - list of equality/inclusion expressions
+    # * Array - depends:
+    #   * If first member is a string, assumes the rest of the arguments
+    #     are parameters and interpolates them into the string.
+    #   * If all members are arrays of length two, treats the same way
+    #     as a hash, except it allows for duplicate keys to be
+    #     specified.
+    # * String - taken literally
+    # * Symbol - taken as a boolean column argument (e.g. WHERE active)
+    # * Sequel::SQL::BooleanExpression - an existing condition expression,
+    #   probably created using the Sequel expression filter DSL.
+    #
+    # filter also takes a block, which should return one of the above argument
+    # types, and is treated the same way.  This block yields a virtual row object,
+    # which is easy to use to create identifiers and functions.
+    #
+    # If both a block and regular argument
+    # are provided, they get ANDed together.
+    #
+    # Examples:
+    #
+    #   dataset.filter(:id => 3).sql #=>
+    #     "SELECT * FROM items WHERE (id = 3)"
+    #   dataset.filter('price < ?', 100).sql #=>
+    #     "SELECT * FROM items WHERE price < 100"
+    #   dataset.filter([[:id, (1,2,3)], [:id, 0..10]]).sql #=>
+    #     "SELECT * FROM items WHERE ((id IN (1, 2, 3)) AND ((id >= 0) AND (id <= 10)))"
+    #   dataset.filter('price < 100').sql #=>
+    #     "SELECT * FROM items WHERE price < 100"
+    #   dataset.filter(:active).sql #=>
+    #     "SELECT * FROM items WHERE :active
+    #   dataset.filter{|o| o.price < 100}.sql #=>
+    #     "SELECT * FROM items WHERE (price < 100)"
+    # 
+    # Multiple filter calls can be chained for scoping:
+    #
+    #   software = dataset.filter(:category => 'software')
+    #   software.filter{|o| o.price < 100}.sql #=>
+    #     "SELECT * FROM items WHERE ((category = 'software') AND (price < 100))"
+    #
+    # See doc/dataset_filtering.rdoc for more examples and details.
+    def filter(*cond, &block)
+      _filter(@opts[:having] ? :having : :where, *cond, &block)
+    end
+
+    # Returns a copy of the dataset with the source changed.
+    #
+    #   dataset.from # SQL: SELECT *
+    #   dataset.from(:blah) # SQL: SELECT * FROM blah
+    #   dataset.from(:blah, :foo) # SQL: SELECT * FROM blah, foo
+    def from(*source)
+      table_alias_num = 0
+      sources = []
+      source.each do |s|
+        case s
+        when Hash
+          s.each{|k,v| sources << SQL::AliasedExpression.new(k,v)}
+        when Dataset
+          sources << SQL::AliasedExpression.new(s, dataset_alias(table_alias_num+=1))
+        when Symbol
+          sch, table, aliaz = split_symbol(s)
+          if aliaz
+            s = sch ? SQL::QualifiedIdentifier.new(sch.to_sym, table.to_sym) : SQL::Identifier.new(table.to_sym)
+            sources << SQL::AliasedExpression.new(s, aliaz.to_sym)
+          else
+            sources << s
+          end
+        else
+          sources << s
+        end
+      end
+      o = {:from=>sources.empty? ? nil : sources}
+      o[:num_dataset_sources] = table_alias_num if table_alias_num > 0
+      clone(o)
+    end
+
+    # Returns a dataset selecting from the current dataset.
+    # Supplying the :alias option controls the name of the result.
+    #
+    #   ds = DB[:items].order(:name).select(:id, :name)
+    #   ds.sql                         #=> "SELECT id,name FROM items ORDER BY name"
+    #   ds.from_self.sql               #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS 't1'"
+    #   ds.from_self(:alias=>:foo).sql #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS 'foo'"
+    def from_self(opts={})
+      fs = {}
+      @opts.keys.each{|k| fs[k] = nil unless FROM_SELF_KEEP_OPTS.include?(k)}
+      clone(fs).from(opts[:alias] ? as(opts[:alias]) : self)
+    end
+
+    # Pattern match any of the columns to any of the terms.  The terms can be
+    # strings (which use LIKE) or regular expressions (which are only supported
+    # in some databases).  See Sequel::SQL::StringExpression.like.  Note that the
+    # total number of pattern matches will be cols.length * terms.length,
+    # which could cause performance issues.
+    #
+    #   dataset.grep(:a, '%test%') # SQL: SELECT * FROM items WHERE a LIKE '%test%'
+    #   dataset.grep([:a, :b], %w'%test% foo') # SQL: SELECT * FROM items WHERE a LIKE '%test%' OR a LIKE 'foo' OR b LIKE '%test%' OR b LIKE 'foo' 
+    def grep(cols, terms)
+      filter(SQL::BooleanExpression.new(:OR, *Array(cols).collect{|c| SQL::StringExpression.like(c, *terms)}))
+    end
+
+    # Returns a copy of the dataset with the results grouped by the value of 
+    # the given columns.
+    #
+    #   dataset.group(:id) # SELECT * FROM items GROUP BY id
+    #   dataset.group(:id, :name) # SELECT * FROM items GROUP BY id, name
+    def group(*columns)
+      clone(:group => (columns.compact.empty? ? nil : columns))
+    end
+    alias group_by group
+
+    # Returns a copy of the dataset with the HAVING conditions changed. See #filter for argument types.
+    #
+    #   dataset.group(:sum).having(:sum=>10) # SQL: SELECT * FROM items GROUP BY sum HAVING sum = 10 
+    def having(*cond, &block)
+      _filter(:having, *cond, &block)
+    end
+    
+    # Adds an INTERSECT clause using a second dataset object.
+    # An INTERSECT compound dataset returns all rows in both the current dataset
+    # and the given dataset.
+    # Raises an InvalidOperation if the operation is not supported.
+    # Options:
+    # * :all - Set to true to use INTERSECT ALL instead of INTERSECT, so duplicate rows can occur
+    # * :from_self - Set to false to not wrap the returned dataset in a from_self, use with care.
+    #
+    #   DB[:items].intersect(DB[:other_items]).sql
+    #   #=> "SELECT * FROM items INTERSECT SELECT * FROM other_items"
+    def intersect(dataset, opts={})
+      opts = {:all=>opts} unless opts.is_a?(Hash)
+      raise(InvalidOperation, "INTERSECT not supported") unless supports_intersect_except?
+      raise(InvalidOperation, "INTERSECT ALL not supported") if opts[:all] && !supports_intersect_except_all?
+      compound_clone(:intersect, dataset, opts)
+    end
+
+    # Inverts the current filter
+    #
+    #   dataset.filter(:category => 'software').invert.sql #=>
+    #     "SELECT * FROM items WHERE (category != 'software')"
+    def invert
+      having, where = @opts[:having], @opts[:where]
+      raise(Error, "No current filter") unless having || where
+      o = {}
+      o[:having] = SQL::BooleanExpression.invert(having) if having
+      o[:where] = SQL::BooleanExpression.invert(where) if where
+      clone(o)
+    end
+
+    # If given an integer, the dataset will contain only the first l results.
+    # If given a range, it will contain only those at offsets within that
+    # range. If a second argument is given, it is used as an offset.
+    #
+    #   dataset.limit(10) # SQL: SELECT * FROM items LIMIT 10
+    #   dataset.limit(10, 20) # SQL: SELECT * FROM items LIMIT 10 OFFSET 20
+    def limit(l, o = nil)
+      return from_self.limit(l, o) if @opts[:sql]
+
+      if Range === l
+        o = l.first
+        l = l.last - l.first + (l.exclude_end? ? 0 : 1)
+      end
+      l = l.to_i
+      raise(Error, 'Limits must be greater than or equal to 1') unless l >= 1
+      opts = {:limit => l}
+      if o
+        o = o.to_i
+        raise(Error, 'Offsets must be greater than or equal to 0') unless o >= 0
+        opts[:offset] = o
+      end
+      clone(opts)
+    end
+    
+    # Adds an alternate filter to an existing filter using OR. If no filter 
+    # exists an error is raised.
+    #
+    #   dataset.filter(:a).or(:b) # SQL: SELECT * FROM items WHERE a OR b
+    def or(*cond, &block)
+      clause = (@opts[:having] ? :having : :where)
+      raise(InvalidOperation, "No existing filter found.") unless @opts[clause]
+      cond = cond.first if cond.size == 1
+      clone(clause => SQL::BooleanExpression.new(:OR, @opts[clause], filter_expr(cond, &block)))
+    end
+
+    # Returns a copy of the dataset with the order changed. If a nil is given
+    # the returned dataset has no order. This can accept multiple arguments
+    # of varying kinds, and even SQL functions.  If a block is given, it is treated
+    # as a virtual row block, similar to filter.
+    #
+    #   ds.order(:name).sql #=> 'SELECT * FROM items ORDER BY name'
+    #   ds.order(:a, :b).sql #=> 'SELECT * FROM items ORDER BY a, b'
+    #   ds.order('a + b'.lit).sql #=> 'SELECT * FROM items ORDER BY a + b'
+    #   ds.order(:a + :b).sql #=> 'SELECT * FROM items ORDER BY (a + b)'
+    #   ds.order(:name.desc).sql #=> 'SELECT * FROM items ORDER BY name DESC'
+    #   ds.order(:name.asc).sql #=> 'SELECT * FROM items ORDER BY name ASC'
+    #   ds.order{|o| o.sum(:name)}.sql #=> 'SELECT * FROM items ORDER BY sum(name)'
+    #   ds.order(nil).sql #=> 'SELECT * FROM items'
+    def order(*columns, &block)
+      columns += Array(Sequel.virtual_row(&block)) if block
+      clone(:order => (columns.compact.empty?) ? nil : columns)
+    end
+    alias_method :order_by, :order
+    
+    # Returns a copy of the dataset with the order columns added
+    # to the existing order.
+    #
+    #   ds.order(:a).order(:b).sql #=> 'SELECT * FROM items ORDER BY b'
+    #   ds.order(:a).order_more(:b).sql #=> 'SELECT * FROM items ORDER BY a, b'
+    def order_more(*columns, &block)
+      columns = @opts[:order] + columns if @opts[:order]
+      order(*columns, &block)
+    end
+    
+    # Returns a copy of the dataset with the order reversed. If no order is
+    # given, the existing order is inverted.
+    def reverse_order(*order)
+      order(*invert_order(order.empty? ? @opts[:order] : order))
+    end
+    alias reverse reverse_order
+
+    # Returns a copy of the dataset with the columns selected changed
+    # to the given columns. This also takes a virtual row block,
+    # similar to filter.
+    #
+    #   dataset.select(:a) # SELECT a FROM items
+    #   dataset.select(:a, :b) # SELECT a, b FROM items
+    #   dataset.select{|o| o.a, o.sum(:b)} # SELECT a, sum(b) FROM items
+    def select(*columns, &block)
+      columns += Array(Sequel.virtual_row(&block)) if block
+      m = []
+      columns.map do |i|
+        i.is_a?(Hash) ? m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)}) : m << i
+      end
+      clone(:select => m)
+    end
+    
+    # Returns a copy of the dataset selecting the wildcard.
+    #
+    #   dataset.select(:a).select_all # SELECT * FROM items
+    def select_all
+      clone(:select => nil)
+    end
+
+    # Returns a copy of the dataset with the given columns added
+    # to the existing selected columns.
+    #
+    #   dataset.select(:a).select(:b) # SELECT b FROM items
+    #   dataset.select(:a).select_more(:b) # SELECT a, b FROM items
+    def select_more(*columns, &block)
+      columns = @opts[:select] + columns if @opts[:select]
+      select(*columns, &block)
+    end
+    
+    # Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
+    # 
+    #   dataset.group(:a).having(:a=>1).where(:b).unfiltered # SELECT * FROM items GROUP BY a
+    def unfiltered
+      clone(:where => nil, :having => nil)
+    end
+
+    # Returns a copy of the dataset with no grouping (GROUP or HAVING clause) applied.
+    # 
+    #   dataset.group(:a).having(:a=>1).where(:b).ungrouped # SELECT * FROM items WHERE b
+    def ungrouped
+      clone(:group => nil, :having => nil)
+    end
+
+    # Adds a UNION clause using a second dataset object.
+    # A UNION compound dataset returns all rows in either the current dataset
+    # or the given dataset.
+    # Options:
+    # * :all - Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
+    # * :from_self - Set to false to not wrap the returned dataset in a from_self, use with care.
+    #
+    #   DB[:items].union(DB[:other_items]).sql
+    #   #=> "SELECT * FROM items UNION SELECT * FROM other_items"
+    def union(dataset, opts={})
+      opts = {:all=>opts} unless opts.is_a?(Hash)
+      compound_clone(:union, dataset, opts)
+    end
+    
+    # Returns a copy of the dataset with no limit or offset.
+    # 
+    #   dataset.limit(10, 20).unlimited # SELECT * FROM items
+    def unlimited
+      clone(:limit=>nil, :offset=>nil)
+    end
+
+    # Returns a copy of the dataset with no order.
+    # 
+    #   dataset.order(:a).unordered # SELECT * FROM items
+    def unordered
+      order(nil)
+    end
+
+    private
+
+    # Internal filter method so it works on either the having or where clauses.
+    def _filter(clause, *cond, &block)
+      cond = cond.first if cond.size == 1
+      cond = filter_expr(cond, &block)
+      cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause]
+      clone(clause => cond)
+    end
+    
+    # Add the dataset to the list of compounds
+    def compound_clone(type, dataset, opts)
+      ds = compound_from_self.clone(:compounds=>Array(@opts[:compounds]).map{|x| x.dup} + [[type, dataset.compound_from_self, opts[:all]]])
+      opts[:from_self] == false ? ds : ds.from_self
+    end
+
+    # SQL fragment based on the expr type.  See #filter.
+    def filter_expr(expr = nil, &block)
+      expr = nil if expr == []
+      if expr && block
+        return SQL::BooleanExpression.new(:AND, filter_expr(expr), filter_expr(block))
+      elsif block
+        expr = block
+      end
+      case expr
+      when Hash
+        SQL::BooleanExpression.from_value_pairs(expr)
+      when Array
+        if (sexpr = expr.at(0)).is_a?(String)
+          SQL::PlaceholderLiteralString.new(sexpr, expr[1..-1], true)
+        elsif Sequel.condition_specifier?(expr)
+          SQL::BooleanExpression.from_value_pairs(expr)
+        else
+          SQL::BooleanExpression.new(:AND, *expr.map{|x| filter_expr(x)})
+        end
+      when Proc
+        filter_expr(Sequel.virtual_row(&expr))
+      when SQL::NumericExpression, SQL::StringExpression
+        raise(Error, "Invalid SQL Expression type: #{expr.inspect}") 
+      when Symbol, SQL::Expression
+        expr
+      when TrueClass, FalseClass
+        SQL::BooleanExpression.new(:NOOP, expr)
+      when String
+        LiteralString.new("(#{expr})")
+      else
+        raise(Error, 'Invalid filter argument')
+      end
+    end
+    
+    # Inverts the given order by breaking it into a list of column references
+    # and inverting them.
+    #
+    #   dataset.invert_order([:id.desc]]) #=> [:id]
+    #   dataset.invert_order(:category, :price.desc]) #=>
+    #     [:category.desc, :price]
+    def invert_order(order)
+      return nil unless order
+      new_order = []
+      order.map do |f|
+        case f
+        when SQL::OrderedExpression
+          f.invert
+        else
+          SQL::OrderedExpression.new(f)
+        end
+      end
+    end
+  end
+end