sequel_core 2.0.1 → 2.1.0

data/lib/sequel_core/adapters/sqlite.rb

@@ -138,7 +138,7 @@ module Sequel
       
       private
       def connection_pool_default_options
-        o = super.merge(:pool_reuse_connections=>:always, :pool_convert_exceptions=>false)
+        o = super.merge(:pool_convert_exceptions=>false)
         # Default to only a single connection if a memory database is used,
         # because otherwise each connection will get a separate database
         o[:max_connections] = 1 if @opts[:database] == ':memory:' || @opts[:database].blank?

data/lib/sequel_core/connection_pool.rb

@@ -1,8 +1,9 @@
 # A ConnectionPool manages access to database connections by keeping
 # multiple connections and giving threads exclusive access to each
 # connection.
-class ConnectionPool
-  # An array of connections currently being used
+class Sequel::ConnectionPool
+  # A hash of connections currently being used, key is the Thread,
+  # value is the connection.
   attr_reader :allocated
   
   # An array of connections opened but not currently used
@@ -42,13 +43,6 @@ class ConnectionPool
   #   will open (default 4)
   # * :pool_convert_exceptions - Whether to convert non-StandardError based exceptions
   #   to RuntimeError exceptions (default true)
-  # * :pool_reuse_connections - Which strategy to follow in regards to reusing connections:
-  #   * :always - Always reuse a connection that belongs to the same thread
-  #   * :allow - Only reuse a connection that belongs to the same thread if
-  #     another cannot be acquired immediately (default)
-  #   * :last_resort - Only reuse a connection that belongs to the same thread if
-  #     the pool timeout has expired
-  #   * :never - Never reuse a connection that belongs to the same thread
   # * :pool_sleep_time - The amount of time to sleep before attempting to acquire
   #   a connection again (default 0.001)
   # * :pool_timeout - The amount of seconds to wait to acquire a connection
@@ -59,11 +53,10 @@ class ConnectionPool
     @connection_proc = block
 
     @available_connections = []
-    @allocated = []
+    @allocated = {}
     @created_count = 0
     @timeout = opts[:pool_timeout] || 5
     @sleep_time = opts[:pool_sleep_time] || 0.001
-    @reuse_connections = opts[:pool_reuse_connections] || :allow
     @convert_exceptions = opts.include?(:pool_convert_exceptions) ? opts[:pool_convert_exceptions] : true
   end
   
@@ -72,10 +65,8 @@ class ConnectionPool
   # 
   #   pool.hold {|conn| conn.execute('DROP TABLE posts')}
   # 
-  # Pool#hold can be re-entrant, meaning it can be called recursively in
-  # the same thread without blocking if the :pool_reuse_connections option
-  # was set to :always or :allow.  Depending on the :pool_reuse_connections
-  # option you may get the connection currently used by the thread or a new connection.
+  # Pool#hold is re-entrant, meaning it can be called recursively in
+  # the same thread without blocking.
   #
   # If no connection is immediately available and the pool is already using the maximum
   # number of connections, Pool#hold will block until a connection
@@ -88,21 +79,11 @@ class ConnectionPool
       time = Time.new
       timeout = time + @timeout
       sleep_time = @sleep_time
-      reuse = @reuse_connections
-      if (reuse == :always) && (conn = owned_connection(t))
+      if conn = owned_connection(t)
         return yield(conn)
       end
-      reuse = reuse == :allow ? true : false
       until conn = acquire(t)
-        if reuse && (conn = owned_connection(t))
-          return yield(conn)
-        end
-        if Time.new > timeout
-          if (@reuse_connections == :last_resort) && (conn = owned_connection(t))
-            return yield(conn)
-          end
-          raise(::Sequel::Error::PoolTimeoutError)
-        end
+        raise(::Sequel::Error::PoolTimeoutError) if Time.new > timeout
         sleep sleep_time
       end
       begin
@@ -131,18 +112,14 @@ class ConnectionPool
 
   # Returns the connection owned by the supplied thread, if any.
   def owned_connection(thread)
-    @mutex.synchronize do 
-      x = @allocated.assoc(thread)
-      x[1] if x
-    end
+    @mutex.synchronize{@allocated[thread]}
   end
   
   # Assigns a connection to the supplied thread, if one is available.
   def acquire(thread)
     @mutex.synchronize do
       if conn = available
-        @allocated << [thread, conn]
-        conn
+        @allocated[thread] = conn
       end
     end
   end
@@ -166,7 +143,7 @@ class ConnectionPool
   # Releases the connection assigned to the supplied thread.
   def release(thread, conn)
     @mutex.synchronize do
-      @allocated.delete([thread, conn])
+      @allocated.delete(thread)
       @available_connections << conn
     end
   end
@@ -178,7 +155,7 @@ end
 #
 # Note that using a single threaded pool with some adapters can cause
 # errors in certain cases, see Sequel.single_threaded=.
-class SingleThreadedPool
+class Sequel::SingleThreadedPool
   # The single database connection for the pool
   attr_reader :conn
 

data/lib/sequel_core/core_ext.rb

@@ -1,7 +1,3 @@
-# This file includes augmentations to the core ruby classes the Sequel uses,
-# which are unrelated to the creation of SQL.  It includes common
-# idioms to reduce the amount of code duplication.
-
 class Array
   # True if the array is not empty and all of its elements are
   # arrays of size 2.  This is used to determine if the array
@@ -65,7 +61,7 @@ class Module
   #     alias_method to, from
   #   end
   def metaalias(to, from)
-    metaclass.instance_eval{alias_method to, from}
+    meta_eval{alias_method to, from}
   end
   
   # Make a singleton/class attribute accessor method(s).
@@ -75,7 +71,7 @@ class Module
   #     attr_accessor *meths
   #   end
   def metaattr_accessor(*meths)
-    metaclass.instance_eval{attr_accessor(*meths)}
+    meta_eval{attr_accessor(*meths)}
   end
 
   # Make a singleton/class method(s) private.
@@ -86,17 +82,7 @@ class Module
   #     attr_reader *meths
   #   end
   def metaattr_reader(*meths)
-    metaclass.instance_eval{attr_reader(*meths)}
-  end
-
-  # Make a singleton/class method(s) private.
-  # Replaces the construct:
-  #
-  #   class << self
-  #     private *meths
-  #   end
-  def metaprivate(*meths)
-    metaclass.instance_eval{private(*meths)}
+    meta_eval{attr_reader(*meths)}
   end
 end
 
@@ -184,10 +170,10 @@ class String
   end
 
   # Converts a string into a Time or DateTime object, depending on the
-  # value of Sequel.time_class
+  # value of Sequel.datetime_class
   def to_sequel_time
     begin
-      Sequel.time_class.parse(self)
+      Sequel.datetime_class.parse(self)
     rescue => e
       raise Sequel::Error::InvalidValue, "Invalid time value '#{self}' (#{e.message})"
     end

data/lib/sequel_core/core_sql.rb

@@ -1,6 +1,3 @@
-# This file holds the extensions to core ruby classes that relate to the creation of SQL
-# code.
-
 class Array
   # Return a Sequel::SQL::BooleanExpression created from this array, not matching any of the
   # conditions.
@@ -8,6 +5,12 @@ class Array
     sql_expr_if_all_two_pairs(:OR, true)
   end
 
+  # Return a Sequel::SQL::CaseExpression with this array as the conditions and the given
+  # default value.
+  def case(default)
+    ::Sequel::SQL::CaseExpression.new(self, default)
+  end
+
   # Return a Sequel::SQL::BooleanExpression created from this array, matching all of the
   # conditions.
   def sql_expr
@@ -81,6 +84,13 @@ class Hash
     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
   end
 
+  # Return a Sequel::SQL::CaseExpression with this hash as the conditions and the given
+  # default value.  Note that the order of the conditions will be arbitrary, so all
+  # conditions should be orthogonal.
+  def case(default)
+    ::Sequel::SQL::CaseExpression.new(to_a, default)
+  end
+
   # Return a Sequel::SQL::BooleanExpression created from this hash, matching all of the
   # conditions.
   def sql_expr
@@ -101,7 +111,8 @@ class Hash
 end
 
 class String
-  include Sequel::SQL::ColumnMethods
+  include Sequel::SQL::AliasMethods
+  include Sequel::SQL::CastMethods
 
   # Converts a string into an LiteralString, in order to override string
   # literalization, e.g.:
@@ -131,8 +142,8 @@ class String
 end
 
 class Symbol
-  include Sequel::SQL::ColumnMethods
-  include Sequel::SQL::ComplexExpressionMethods
+  include Sequel::SQL::QualifyingMethods
+  include Sequel::SQL::GenericExpressionMethods
 
   # If no argument is given, returns a Sequel::SQL::ColumnAll object specifying all
   # columns for this table.

data/lib/sequel_core/database.rb

@@ -172,7 +172,8 @@ module Sequel
       @scheme = scheme
       @@adapters[scheme.to_sym] = self
     end
-    metaprivate :set_adapter_scheme
+    
+    private_class_method :set_adapter_scheme
     
     ### Instance Methods ###
 
@@ -378,6 +379,17 @@ module Sequel
         value.to_s
       when :float
         Float(value)
+      when :decimal
+        case value
+        when BigDecimal
+          value
+        when String, Float
+          value.to_d
+        when Integer
+          value.to_s.to_d
+        else
+          raise ArgumentError, "invalid value for BigDecimal: #{value.inspect}"
+        end
       when :boolean
         case value
         when false, 0, "0", /\Af(alse)?\z/i
@@ -407,7 +419,7 @@ module Sequel
         end
       when :datetime
         raise(ArgumentError, "invalid value for #{tc}: #{value.inspect}") unless value.is_one_of?(DateTime, Date, Time, String)
-        if Sequel.time_class === value
+        if Sequel.datetime_class === value
           # Already the correct class, no need to convert
           value
         else

data/lib/sequel_core/dataset/callback.rb

@@ -1,6 +1,3 @@
-# This file holds empty methods that can be
-# overridden to provide callback behavior.
-
 module Sequel
   class Dataset
     private

data/lib/sequel_core/dataset/convenience.rb

@@ -233,10 +233,11 @@ module Sequel
     
     # Returns a hash with one column used as key and another used as value.
     # If rows have duplicate values for the key column, the latter row(s)
-    # will overwrite the value of the previous row(s).
-    def to_hash(key_column, value_column)
+    # will overwrite the value of the previous row(s). If the value_column
+    # is not given or nil, uses the entire hash as the value.
+    def to_hash(key_column, value_column = nil)
       inject({}) do |m, r|
-        m[r[key_column]] = r[value_column]
+        m[r[key_column]] = value_column ? r[value_column] : r
         m
       end
     end

data/lib/sequel_core/dataset/parse_tree_sequelizer.rb

@@ -1,24 +1,3 @@
-# This file includes dataset methods for translating Ruby expressions
-# into SQL expressions, making it possible to specify dataset filters using
-# blocks, e.g.:
-#
-#   DB[:items].filter {:price < 100}
-#   DB[:items].filter {:category == 'ruby' && :date < Date.today - 7}
-#
-# Block filters can refer to literals, variables, constants, arguments, 
-# instance variables or anything else in order to create parameterized 
-# queries. Block filters can also refer to other dataset objects as 
-# sub-queries. Block filters are pretty much limitless!
-#
-# Block filters are based on ParseTree. If you do not have the ParseTree
-# gem installed, block filters will raise an error.
-#
-# To enable full block filter support make sure you have both ParseTree and
-# Ruby2Ruby installed:
-#
-#   sudo gem install parsetree
-#   sudo gem install ruby2ruby
-
 module Sequel
   class Dataset
    private

data/lib/sequel_core/dataset/sequelizer.rb

@@ -1,51 +1,50 @@
-begin
-  require 'parse_tree'
-  require 'sequel_core/dataset/parse_tree_sequelizer'
-  class Proc
-    def to_sql(dataset, opts = {})
-      dataset.send(:pt_expr, to_sexp[2], self.binding, opts)
-    end
-  end
+unless defined?(SEQUEL_NO_PARSE_TREE)
   begin
-    require 'ruby2ruby'
-    class Sequel::Dataset
-      # Evaluates a method call. This method is used to evaluate Ruby expressions
-      # referring to indirect values, e.g.:
-      #
-      #   dataset.filter {:category => category.to_s}
-      #   dataset.filter {:x > y[0..3]}
-      #
-      # This method depends on the Ruby2Ruby gem. If you do not have Ruby2Ruby
-      # installed, this method will raise an error.
-      def ext_expr(e, b, opts)
-        eval(::RubyToRuby.new.process(e), b)
-      end
-    end
+    require 'parse_tree'
+    require 'sequel_core/dataset/parse_tree_sequelizer'
     class Proc
-      remove_method :to_sexp
-    end
-  rescue LoadError
-    class Sequel::Dataset
-      def ext_expr(*args)
-        raise Sequel::Error, "You must have the Ruby2Ruby gem installed in order to use this block filter."
+      def to_sql(dataset, opts = {})
+        Sequel::Deprecation.deprecate("ParseTree filters are deprecated and will be removed in Sequel 2.2")
+        dataset.send(:pt_expr, to_sexp[2], self.binding, opts)
       end
     end
-  ensure
-    class Proc
-      # replacement for Proc#to_sexp as defined in ruby2ruby.
-      # see also: http://rubyforge.org/tracker/index.php?func=detail&aid=18095&group_id=1513&atid=5921
-      # The ruby2ruby implementation leaks memory, so we fix it.
-      def to_sexp
-        block = self
-        c = Class.new {define_method(:m, &block)}
-        ParseTree.translate(c, :m)[2]
+    begin
+      require 'ruby2ruby'
+      class Sequel::Dataset
+        # Evaluates a method call. This method is used to evaluate Ruby expressions
+        # referring to indirect values, e.g.:
+        #
+        #   dataset.filter {:category => category.to_s}
+        #   dataset.filter {:x > y[0..3]}
+        #
+        # This method depends on the Ruby2Ruby gem. If you do not have Ruby2Ruby
+        # installed, this method will raise an error.
+        def ext_expr(e, b, opts)
+          eval(::RubyToRuby.new.process(e), b)
+        end
+      end
+      class Proc
+        remove_method :to_sexp
+      end
+    rescue LoadError
+      class Sequel::Dataset
+        def ext_expr(*args)
+          raise Sequel::Error, "You must have the Ruby2Ruby gem installed in order to use this block filter."
+        end
+      end
+    ensure
+      class Proc
+        # replacement for Proc#to_sexp as defined in ruby2ruby.
+        # see also: http://rubyforge.org/tracker/index.php?func=detail&aid=18095&group_id=1513&atid=5921
+        # The ruby2ruby implementation leaks memory, so we fix it.
+        def to_sexp
+          block = self
+          c = Class.new {define_method(:m, &block)}
+          ParseTree.translate(c, :m)[2]
+        end
       end
     end
-  end
-rescue LoadError
-  class Proc
-    def to_sql(*args)
-      raise Sequel::Error, "You must have the ParseTree gem installed in order to use block filters."
-    end
+  rescue LoadError
+    SEQUEL_NO_PARSE_TREE = true
   end
 end

data/lib/sequel_core/dataset/sql.rb

@@ -1,6 +1,3 @@
-# This file includes all the dataset methods concerned with
-# generating SQL statements for retrieving and manipulating records.
-
 module Sequel
   class Dataset
     AND_SEPARATOR = " AND ".freeze
@@ -9,13 +6,8 @@ module Sequel
     COLUMN_REF_RE1 = /\A([\w ]+)__([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE2 = /\A([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
+    COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql]
     DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
-    JOIN_TYPES = {
-      :left_outer => 'LEFT OUTER JOIN'.freeze,
-      :right_outer => 'RIGHT OUTER JOIN'.freeze,
-      :full_outer => 'FULL OUTER JOIN'.freeze,
-      :inner => 'INNER JOIN'.freeze
-    }
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
     NULL = "NULL".freeze
     QUESTION_MARK = '?'.freeze
@@ -32,17 +24,21 @@ module Sequel
       filter(*cond, &block)
     end
 
+    # SQL fragment for the aliased expression
+    def aliased_expression_sql(ae)
+      "#{literal(ae.expression)} AS #{quote_identifier(ae.aliaz)}"
+    end
+
+    # SQL fragment for specifying given CaseExpression.
+    def case_expression_sql(ce)
+      "(CASE #{ce.conditions.collect{|c,r| "WHEN #{literal(c)} THEN #{literal(r)} "}.join}ELSE #{literal(ce.default)} END)"
+    end
+
     # SQL fragment for specifying all columns in a given table.
     def column_all_sql(ca)
       "#{quote_identifier(ca.table)}.*"
     end
 
-    # SQL fragment for column expressions
-    def column_expr_sql(ce)
-      r = ce.r
-      "#{literal(ce.l)} #{ce.op}#{" #{literal(r)}" if r}"
-    end
-
     # SQL fragment for complex expressions
     def complex_expression_sql(op, args)
       case op
@@ -54,6 +50,8 @@ module Sequel
         "NOT #{literal(args.at(0))}"
       when :NOOP
         literal(args.at(0))
+      when :'B~'
+        "~#{literal(args.at(0))}"
       else
         raise(Sequel::Error, "invalid operator #{op}")
       end
@@ -61,11 +59,7 @@ module Sequel
 
     # Returns the number of records in the dataset.
     def count
-      if @opts[:sql] || @opts[:group]
-        from_self.count
-      else
-        single_value(STOCK_COUNT_OPTS).to_i
-      end
+      options_overlap(COUNT_FROM_SELF_OPTS) ? from_self.count : single_value(STOCK_COUNT_OPTS).to_i
     end
     alias_method :size, :count
 
@@ -108,7 +102,7 @@ module Sequel
       clause = (@opts[:having] ? :having : :where)
       cond = cond.first if cond.size == 1
       cond = cond.sql_or if (Hash === cond) || ((Array === cond) && (cond.all_two_pairs?))
-      cond = filter_expr(block || cond)
+      cond = filter_expr(cond, &block)
       cond = SQL::BooleanExpression.invert(cond)
       cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause]
       clone(clause => cond)
@@ -168,9 +162,8 @@ module Sequel
     def filter(*cond, &block)
       clause = (@opts[:having] ? :having : :where)
       cond = cond.first if cond.size == 1
-      raise(Error::InvalidFilter, "Invalid filter specified. Did you mean to supply a block?") if cond === true || cond === false
       cond = transform_save(cond) if @transform if cond.is_a?(Hash)
-      cond = filter_expr(block || cond)
+      cond = filter_expr(cond, &block)
       cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause] && !@opts[clause].blank?
       clone(clause => cond)
     end
@@ -187,6 +180,9 @@ module Sequel
       case s = source.first
       when Hash
         s.values.first
+      when Symbol
+        sch, table, aliaz = split_symbol(s)
+        aliaz ? aliaz.to_sym : s
       else
         s
       end
@@ -319,6 +315,30 @@ module Sequel
       clone(o)
     end
 
+    # SQL fragment specifying an Irregular (cast/extract) SQL function call
+    def irregular_function_sql(f)
+      "#{f.f}(#{literal(f.arg1)} #{f.joiner} #{literal(f.arg2)})"
+    end
+
+    # SQL fragment specifying a JOIN clause without ON or USING.
+    def join_clause_sql(jc)
+      table = jc.table
+      table_alias = jc.table_alias
+      table_alias = nil if table == table_alias
+      " #{join_type_sql(jc.join_type)} #{table_ref(table)}" \
+        "#{" AS #{quote_identifier(jc.table_alias)}" if table_alias}"
+    end
+
+    # SQL fragment specifying a JOIN clause with ON.
+    def join_on_clause_sql(jc)
+      "#{join_clause_sql(jc)} ON #{literal(filter_expr(jc.on))}"
+    end
+
+    # SQL fragment specifying a JOIN clause with USING.
+    def join_using_clause_sql(jc)
+      "#{join_clause_sql(jc)} USING (#{column_list(jc.using)})"
+    end
+
     # Returns a joined dataset.  Uses the following arguments:
     #
     # * type - The type of join to do (:inner, :left_outer, :right_outer, :full)
@@ -326,39 +346,59 @@ module Sequel
     #   * Dataset - a subselect is performed with an alias of tN for some value of N
     #   * Model (or anything responding to :table_name) - table.table_name
     #   * String, Symbol: table
-    # * expr - Depends on type:
-    #   * Hash, Array - Assumes key (1st arg) is column of joined table (unless already
+    # * expr - specifies conditions, depends on type:
+    #   * Hash, Array with all two pairs - Assumes key (1st arg) is column of joined table (unless already
     #     qualified), and value (2nd arg) is column of the last joined or primary table.
     #     To specify multiple conditions on a single joined table column, you must use an array.
-    #   * Symbol - Assumed to be a column in the joined table that points to the id
-    #     column in the last joined or primary table.
+    #     Uses a JOIN with an ON clause.
+    #   * Array - If all members of the array are symbols, considers them as columns and 
+    #     uses a JOIN with a USING clause.  Most databases will remove duplicate columns from
+    #     the result set if this is used.
+    #   * nil - If a block is not given, doesn't use ON or USING, so the JOIN should be a NATURAL
+    #     or CROSS join. If a block is given, uses a ON clause based on the block, see below.
+    #   * Everything else - pretty much the same as a using the argument in a call to filter,
+    #     so strings are considered literal, symbols specify boolean columns, and blockless
+    #     filter expressions can be used. Uses a JOIN with an ON clause.
     # * table_alias - the name of the table's alias when joining, necessary for joining
     #   to the same table more than once.  No alias is used by default.
-    def join_table(type, table, expr=nil, table_alias=nil)
-      raise(Error::InvalidJoinType, "Invalid join type: #{type}") unless join_type = JOIN_TYPES[type || :inner]
-
-      table = if Dataset === table
-        table_alias = unless table_alias
+    # * block - The block argument should only be given if a JOIN with an ON clause is used,
+    #   in which case it yields the table alias/name for the table currently being joined,
+    #   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, table_alias=nil, &block)
+      if Dataset === table
+        if table_alias.nil?
           table_alias_num = (@opts[:num_dataset_sources] || 0) + 1
-          "t#{table_alias_num}"
+          table_alias = "t#{table_alias_num}"
         end
-        table.to_table_reference
+        table_name = table_alias
       else
         table = table.table_name if table.respond_to?(:table_name)
-        table_alias ||= table
-        table_ref(table)
+        table_name = table_alias || table
       end
 
-      expr = [[expr, :id]] unless expr.is_one_of?(Hash, Array)
-      join_conditions = expr.collect do |k, v|
-        k = qualified_column_name(k, table_alias) if k.is_a?(Symbol)
-        v = qualified_column_name(v, @opts[:last_joined_table] || first_source) if v.is_a?(Symbol)
-        [k,v]
+      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}
+        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
+        last_alias = @opts[:last_joined_table] || first_source
+        if Hash === expr or (Array === expr and expr.all_two_pairs?)
+          expr = expr.collect do |k, v|
+            k = qualified_column_name(k, table_name) if k.is_a?(Symbol)
+            v = qualified_column_name(v, last_alias) if v.is_a?(Symbol)
+            [k,v]
+          end
+        end
+        if block_given?
+          expr2 = yield(table_name, last_alias, @opts[:join] || [])
+          expr = expr ? SQL::BooleanExpression.new(:AND, expr, expr2) : expr2
+        end
+        SQL::JoinOnClause.new(expr, type, table, table_alias)
       end
 
-      quoted_table_alias = quote_identifier(table_alias) 
-      clause = "#{@opts[:join]} #{join_type} #{table}#{" #{quoted_table_alias}" if quoted_table_alias != table} ON #{literal(filter_expr(join_conditions))}"
-      opts = {:join => clause, :last_joined_table => table_alias}
+      opts = {:join => (@opts[:join] || []) + [join], :last_joined_table => table_name}
       opts[:num_dataset_sources] = table_alias_num if table_alias_num
       clone(opts)
     end
@@ -449,7 +489,7 @@ module Sequel
       clause = (@opts[:having] ? :having : :where)
       cond = cond.first if cond.size == 1
       if @opts[clause]
-        clone(clause => SQL::BooleanExpression.new(:OR, @opts[clause], filter_expr(block || cond)))
+        clone(clause => SQL::BooleanExpression.new(:OR, @opts[clause], filter_expr(cond, &block)))
       else
         raise Error::NoExistingFilter, "No existing filter found."
       end
@@ -478,9 +518,15 @@ module Sequel
       order(*((@opts[:order] || []) + order))
     end
     
-    # SQL fragment for the qualifed column reference, specifying
-    # a table and a column.
-    def qualified_column_ref_sql(qcr)
+    # SQL fragment for the ordered expression, used in the ORDER BY
+    # clause.
+    def ordered_expression_sql(oe)
+      "#{literal(oe.expression)} #{oe.descending ? 'DESC' : 'ASC'}"
+    end
+
+    # SQL fragment for the qualifed identifier, specifying
+    # a table and a column (or schema and table).
+    def qualified_identifier_sql(qcr)
       "#{quote_identifier(qcr.table)}.#{quote_identifier(qcr.column)}"
     end
 
@@ -553,7 +599,7 @@ module Sequel
       end
       
       if join = opts[:join]
-        sql << join
+        join.each{|j| sql << literal(j)}
       end
 
       if where = opts[:where]
@@ -564,14 +610,14 @@ module Sequel
         sql << " GROUP BY #{column_list(group)}"
       end
 
-      if order = opts[:order]
-        sql << " ORDER BY #{column_list(order)}"
-      end
-
       if having = opts[:having]
         sql << " HAVING #{literal(having)}"
       end
 
+      if order = opts[:order]
+        sql << " ORDER BY #{column_list(order)}"
+      end
+
       if limit = opts[:limit]
         sql << " LIMIT #{limit}"
         if offset = opts[:offset]
@@ -683,7 +729,7 @@ module Sequel
     end
 
     [:inner, :full_outer, :right_outer, :left_outer].each do |jtype|
-      define_method("#{jtype}_join"){|*args| join_table(jtype, *args)}
+      class_eval("def #{jtype}_join(*args, &block); join_table(:#{jtype}, *args, &block) end")
     end
     alias_method :join, :inner_join
 
@@ -711,7 +757,13 @@ module Sequel
     end
     
     # SQL fragment based on the expr type.  See #filter.
-    def filter_expr(expr)
+    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)
@@ -722,11 +774,13 @@ module Sequel
           SQL::BooleanExpression.from_value_pairs(expr)
         end
       when Proc
-        expr.to_sql(self).lit
+        Sequel.use_parse_tree ? expr.to_sql(self).lit : filter_expr(expr.call)
       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
         "(#{expr})".lit
       else
@@ -749,16 +803,21 @@ module Sequel
       return nil unless order
       new_order = []
       order.map do |f|
-        if f.is_a?(SQL::ColumnExpr) && (f.op == SQL::ColumnMethods::DESC)
-          f.l
-        elsif f.is_a?(SQL::ColumnExpr) && (f.op == SQL::ColumnMethods::ASC)
-          f.l.desc
+        case f
+        when SQL::OrderedExpression
+          SQL::OrderedExpression.new(f.expression, !f.descending)
         else
-          f.desc
+          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)
+      "#{join_type.to_s.gsub('_', ' ').upcase} JOIN"
+    end
+
     # Returns a qualified column name (including a table name) if the column
     # name isn't already qualified.
     def qualified_column_name(column, table)
@@ -766,7 +825,7 @@ module Sequel
         c_table, column, c_alias = split_symbol(column)
         schema, table, t_alias = split_symbol(table) if Symbol === table
         c_table ||= t_alias || table
-        ::Sequel::SQL::QualifiedColumnRef.new(c_table, column)
+        ::Sequel::SQL::QualifiedIdentifier.new(c_table, column)
       else
         column
       end