sequel 3.5.0 → 3.6.0

data/lib/sequel/dataset/sql.rb

@@ -7,6 +7,17 @@ module Sequel
       clauses.map{|clause| :"#{type}_#{clause}_sql"}.freeze
     end
 
+    # These symbols have _join methods created (e.g. inner_join) that
+    # call join_table with the symbol, passing along the arguments and
+    # block from the method call.
+    CONDITIONED_JOIN_TYPES = [:inner, :full_outer, :right_outer, :left_outer, :full, :right, :left]
+
+    # These symbols have _join methods created (e.g. natural_join) that
+    # call join_table with the symbol.  They only accept a single table
+    # argument which is passed to join_table, and they raise an error
+    # if called with a block.
+    UNCONDITIONED_JOIN_TYPES = [:natural, :natural_left, :natural_right, :natural_full, :cross]
+
     AND_SEPARATOR = " AND ".freeze
     BOOL_FALSE = "'f'".freeze
     BOOL_TRUE = "'t'".freeze
@@ -15,14 +26,12 @@ module Sequel
     COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
     COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
     DATASET_ALIAS_BASE_NAME = 't'.freeze
-    FROM_SELF_KEEP_OPTS = [:graph, :eager_graph, :graph_aliases]
     IS_LITERALS = {nil=>'NULL'.freeze, true=>'TRUE'.freeze, false=>'FALSE'.freeze}.freeze
     IS_OPERATORS = ::Sequel::SQL::ComplexExpression::IS_OPERATORS
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
     NULL = "NULL".freeze
     QUALIFY_KEYS = [:select, :where, :having, :order, :group]
     QUESTION_MARK = '?'.freeze
-    STOCK_COUNT_OPTS = {:select => [SQL::AliasedExpression.new(LiteralString.new("COUNT(*)").freeze, :count)], :order => nil}.freeze
     DELETE_CLAUSE_METHODS = clause_methods(:delete, %w'from where')
     INSERT_CLAUSE_METHODS = clause_methods(:insert, %w'into columns values')
     SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with distinct columns from join where group having compounds order limit')
@@ -33,16 +42,6 @@ module Sequel
     WILDCARD = '*'.freeze
     SQL_WITH = "WITH ".freeze
 
-    # 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
-
     # SQL fragment for the aliased expression
     def aliased_expression_sql(ae)
       as_sql(literal(ae.expression), ae.aliaz)
@@ -86,6 +85,14 @@ module Sequel
         else
           complex_expression_sql(:OR, [SQL::BooleanExpression.new(:"!=", *args), SQL::BooleanExpression.new(:IS, args.at(0), nil)])
         end
+      when :IN, :"NOT IN"
+        cols = args.at(0)
+        if !supports_multiple_column_in? && cols.is_a?(Array)
+          expr = SQL::BooleanExpression.new(:OR, *args.at(1).to_a.map{|vals| SQL::BooleanExpression.from_value_pairs(cols.zip(vals).map{|col, val| [col, val]})})
+          literal(op == :IN ? expr : ~expr)
+        else
+          "(#{literal(cols)} #{op} #{literal(args.at(1))})"
+        end
       when *TWO_ARITY_OPERATORS
         "(#{literal(args.at(0))} #{op} #{literal(args.at(1))})"
       when *N_ARITY_OPERATORS
@@ -108,7 +115,7 @@ module Sequel
 
     # Returns the number of records in the dataset.
     def count
-      options_overlap(COUNT_FROM_SELF_OPTS) ? from_self.count : clone(STOCK_COUNT_OPTS).single_value.to_i
+      aggregate_dataset.get{COUNT(:*){}.as(count)}.to_i
     end
 
     # Formats a DELETE statement using the given options and dataset options.
@@ -121,50 +128,6 @@ module Sequel
       clause_sql(:delete)
     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 an EXISTS clause for the dataset as a LiteralString.
     #
     #   DB.select(1).where(DB[:items].exists).sql
@@ -173,57 +136,6 @@ module Sequel
       LiteralString.new("EXISTS (#{select_sql})")
     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_filters.rdoc for more examples and details.
-    def filter(*cond, &block)
-      _filter(@opts[:having] ? :having : :where, *cond, &block)
-    end
-
     # The first source (primary table) for this dataset.  If the dataset doesn't
     # have a table, raises an error.  If the table is aliased, returns the aliased name.
     def first_source_alias
@@ -243,87 +155,12 @@ module Sequel
     end
     alias first_source first_source_alias
 
-    # 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
-
     # SQL fragment specifying an SQL function call
     def function_sql(f)
       args = f.args
       "#{f.f}#{args.empty? ? '()' : literal(args)}"
     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. Raises 
-    # an error if the dataset has not been grouped. 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)
-      raise(InvalidOperation, "Can only specify a HAVING clause on a grouped dataset") unless @opts[:group]
-      _filter(:having, *cond, &block)
-    end
-    
     # Inserts multiple values. If a block is given it is invoked for each
     # item in the given array before inserting it.  See #multi_insert as
     # a possible faster version that inserts multiple records in one
@@ -390,36 +227,6 @@ module Sequel
       clone(:columns=>columns, :values=>values)._insert_sql
     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
-
     # SQL fragment specifying a JOIN clause without ON or USING.
     def join_clause_sql(jc)
       table = jc.table
@@ -470,6 +277,13 @@ module Sequel
     #   the table alias/name for the last joined (or first table), and an array of previous
     #   SQL::JoinClause.
     def join_table(type, table, expr=nil, options={}, &block)
+      using_join = expr.is_a?(Array) && !expr.empty? && expr.all?{|x| x.is_a?(Symbol)}
+      if using_join && !supports_join_using?
+        h = {}
+        expr.each{|s| h[s] = s}
+        return join_table(type, table, h, options)
+      end
+
       if [Symbol, String].any?{|c| options.is_a?(c)}
         table_alias = options
         last_alias = nil 
@@ -490,7 +304,7 @@ module Sequel
 
       join = if expr.nil? and !block_given?
         SQL::JoinClause.new(type, table, table_alias)
-      elsif Array === expr and !expr.empty? and expr.all?{|x| Symbol === x}
+      elsif using_join
         raise(Sequel::Error, "can't use a block if providing an array of symbols as expr") if block_given?
         SQL::JoinUsingClause.new(expr, type, table, table_alias)
       else
@@ -514,30 +328,6 @@ module Sequel
       clone(opts)
     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
-    
     # Returns a literal representation of a value to be used as part
     # of an SQL expression. 
     # 
@@ -596,46 +386,6 @@ module Sequel
       values.map{|r| insert_sql(columns, r)}
     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
-    
     # SQL fragment for the ordered expression, used in the ORDER BY
     # clause.
     def ordered_expression_sql(oe)
@@ -644,8 +394,14 @@ module Sequel
 
     # SQL fragment for a literal string with placeholders
     def placeholder_literal_string_sql(pls)
-      args = pls.args.dup
-      s = pls.str.gsub(QUESTION_MARK){literal(args.shift)}
+      args = pls.args
+      s = if args.is_a?(Hash)
+        re = /:(#{args.keys.map{|k| Regexp.escape(k.to_s)}.join('|')})\b/
+        pls.str.gsub(re){literal(args[$1.to_sym])}
+      else
+        i = -1
+        pls.str.gsub(QUESTION_MARK){literal(args.at(i+=1))}
+      end
       s = "(#{s})" if pls.parens
       s
     end
@@ -710,13 +466,6 @@ module Sequel
       "\"#{name.to_s.gsub('"', '""')}\""
     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
-
     # Split the schema information from the table
     def schema_and_table(table_name)
       sch = db.default_schema if db
@@ -735,39 +484,6 @@ module Sequel
       end
     end
 
-    # 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
-    
     # Formats a SELECT statement
     #
     #   dataset.select_sql # => "SELECT * FROM items"
@@ -797,48 +513,6 @@ module Sequel
       end
     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
-
     # Formats an UPDATE statement using the given values.
     #
     #   dataset.update_sql(:price => 100, :category => 'software') #=>
@@ -913,9 +587,12 @@ module Sequel
       clone(:sql=>sql)
     end
 
-    [:inner, :full_outer, :right_outer, :left_outer].each do |jtype|
+    CONDITIONED_JOIN_TYPES.each do |jtype|
       class_eval("def #{jtype}_join(*args, &block); join_table(:#{jtype}, *args, &block) end", __FILE__, __LINE__)
     end
+    UNCONDITIONED_JOIN_TYPES.each do |jtype|
+      class_eval("def #{jtype}_join(table); raise(Sequel::Error, '#{jtype}_join does not accept join table blocks') if block_given?; join_table(:#{jtype}, table) end", __FILE__, __LINE__)
+    end
     alias join inner_join
 
     protected
@@ -938,20 +615,20 @@ module Sequel
     
     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
-    
     # Formats the truncate statement.  Assumes the table given has already been
     # literalized.
     def _truncate_sql(table)
       "TRUNCATE TABLE #{table}"
     end
 
+    # Clone of this dataset usable in aggregate operations.  Does
+    # a from_self if dataset contains any parameters that would
+    # affect normal aggregation, or just removes an existing
+    # order if not.
+    def aggregate_dataset
+      options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered
+    end
+
     # Do a simple join of the arguments (which should be strings or symbols) separated by commas
     def argument_list(args)
       args.join(COMMA_SEPARATOR)
@@ -982,12 +659,6 @@ module Sequel
       (columns.nil? || columns.empty?) ? WILDCARD : expression_list(columns)
     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
-
     # The alias to use for datasets, takes a number to make sure the name is unique.
     def dataset_alias(number)
       :"#{DATASET_ALIAS_BASE_NAME}#{number}"
@@ -1009,40 +680,6 @@ module Sequel
       requires_sql_standard_datetimes? ? STANDARD_TIMESTAMP_FORMAT : TIMESTAMP_FORMAT
     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 String === expr[0]
-          SQL::PlaceholderLiteralString.new(expr.shift, expr, 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
-    
     # Format the timestamp based on the default_timestamp_format, with a couple
     # of modifiers.  First, allow %N to be used for fractions seconds (if the
     # database supports them), and override %z to always use a numeric offset
@@ -1111,25 +748,6 @@ module Sequel
       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
-    
     # SQL fragment specifying a JOIN type, converts underscores to
     # spaces and upcases.
     def join_type_sql(join_type)
@@ -1192,11 +810,18 @@ module Sequel
       v.to_s
     end
 
-    # SQL fragmento for a type of object not handled by Dataset#literal.
-    # Raises an error.  If a database specific type is allowed,
-    # this should be overriden in a subclass.
+    # SQL fragment for a type of object not handled by Dataset#literal.
+    # Calls sql_literal if object responds to it, otherwise raises an error.
+    # Classes implementing sql_literal should call a class-specific method on the dataset
+    # provided and should add that method to Sequel::Dataset, allowing for adapters
+    # to provide customized literalizations.
+    # If a database specific type is allowed, this should be overriden in a subclass.
     def literal_other(v)
-      raise Error, "can't express #{v.inspect} as a SQL literal"
+      if v.respond_to?(:sql_literal)
+        v.sql_literal(self)
+      else
+        raise Error, "can't express #{v.inspect} as a SQL literal"
+      end
     end
 
     # SQL fragment for String.  Doubles \ and ' by default.
@@ -1293,7 +918,14 @@ module Sequel
         o[:order] = qualified_expression(o[:order], table) if o[:order]
         SQL::Window.new(o)
       when SQL::PlaceholderLiteralString
-        SQL::PlaceholderLiteralString.new(e.str, qualified_expression(e.args, table), e.parens)
+        args = if e.args.is_a?(Hash)
+          h = {}
+          e.args.each{|k,v| h[k] = qualified_expression(v, table)}
+          h
+        else
+          qualified_expression(e.args, table)
+        end
+        SQL::PlaceholderLiteralString.new(e.str, args, e.parens)
       else
         e
       end