sequel 3.21.0 → 3.36.0

data/lib/sequel/sql.rb

@@ -38,6 +38,16 @@ module Sequel
   class LiteralString < ::String
   end
 
+  # Time subclass that gets literalized with only the time value, so it operates
+  # like a standard SQL time type.
+  class SQLTime < ::Time
+    # Create a new SQLTime instance given an hour, minute, and second.
+    def self.create(hour, minute, second, usec = 0)
+      t = now
+      local(t.year, t.month, t.day, hour, minute, second, usec)
+    end
+  end
+
   # The SQL module holds classes whose instances represent SQL fragments.
   # It also holds modules that are included in core ruby classes that
   # make Sequel a friendly DSL.
@@ -69,7 +79,8 @@ module Sequel
       # the method provided on the dataset with args as the argument (self by default).
       # Used to DRY up some code.
       def self.to_s_method(meth, args=:self) # :nodoc:
-        class_eval("def to_s(ds); ds.#{meth}(#{args}) end", __FILE__, __LINE__)
+        class_eval("def to_s(ds) ds.#{meth}(#{args}) end", __FILE__, __LINE__)
+        class_eval("def to_s_append(ds, sql) ds.#{meth}_append(sql, #{args}) end", __FILE__, __LINE__)
       end
       private_class_method :to_s_method
 
@@ -127,7 +138,7 @@ module Sequel
       MATHEMATICAL_OPERATORS = [:+, :-, :/, :*]
 
       # Bitwise mathematical operators used in +NumericMethods+
-      BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>]
+      BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>, :%]
 
       # Inequality operators used in +InequalityMethods+
       INEQUALITY_OPERATORS = [:<, :>, :<=, :>=]
@@ -144,14 +155,17 @@ module Sequel
       # Operator symbols that take exactly two arguments
       TWO_ARITY_OPERATORS = [:'=', :'!=', :LIKE, :'NOT LIKE', \
         :~, :'!~', :'~*', :'!~*', :ILIKE, :'NOT ILIKE'] + \
-        INEQUALITY_OPERATORS + BITWISE_OPERATORS + IS_OPERATORS + IN_OPERATORS
+        INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS
 
       # Operator symbols that take one or more arguments
-      N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS
+      N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS + BITWISE_OPERATORS
 
       # Operator symbols that take only a single argument
       ONE_ARITY_OPERATORS = [:NOT, :NOOP, :'B~']
 
+      # Custom expressions that may have different syntax on different databases
+      CUSTOM_EXPRESSIONS = [:extract]
+
       # An array of args for this object
       attr_reader :args
 
@@ -180,6 +194,8 @@ module Sequel
           args[1] = orig_args[1] if IN_OPERATORS.include?(op)
         when *ONE_ARITY_OPERATORS
           raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
+        when *CUSTOM_EXPRESSIONS
+          # nothing
         else
           raise(Error, "Invalid operator #{op}")
         end
@@ -219,14 +235,7 @@ module Sequel
     #   ~:a.sql_number # ~"a"
     module BitwiseMethods
       ComplexExpression::BITWISE_OPERATORS.each do |o|
-        define_method(o) do |ce|
-          case ce
-          when BooleanExpression, StringExpression
-            raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
-          else  
-            NumericExpression.new(o, self, ce)
-          end
-        end
+        module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
       end
 
       # Do the bitwise compliment of the self
@@ -244,16 +253,24 @@ module Sequel
     #   :a & :b # "a" AND "b"
     #   :a | :b # "a" OR "b"
     #   ~:a # NOT "a"
+    #
+    # One exception to this is when a NumericExpression or Integer is the argument
+    # to & or |, in which case a bitwise method will be used:
+    #
+    #   :a & 1 # "a" & 1 
+    #   :a | (:b + 1) # "a" | ("b" + 1)
     module BooleanMethods
       ComplexExpression::BOOLEAN_OPERATOR_METHODS.each do |m, o|
-        define_method(m) do |ce|
-          case ce
-          when NumericExpression, StringExpression
-            raise(Sequel::Error, "cannot apply #{o} to a non-boolean expression")
-          else  
-            BooleanExpression.new(o, self, ce)
+        module_eval(<<-END, __FILE__, __LINE__+1)
+          def #{m}(o)
+            case o
+            when NumericExpression, Integer
+              NumericExpression.new(#{m.inspect}, self, o)
+            else  
+              BooleanExpression.new(#{o.inspect}, self, o)
+            end
           end
-        end
+        END
       end
       
       # Create a new BooleanExpression with NOT, representing the inversion of whatever self represents.
@@ -264,6 +281,293 @@ module Sequel
       end
     end
 
+    # These methods are designed as replacements for the core extensions, so that
+    # Sequel is still easy to use if the core extensions are not enabled.
+    module Builders
+      # Create an SQL::AliasedExpression for the given expression and alias.
+      #
+      #   Sequel.as(:column, :alias) # "column" AS "alias"
+      def as(exp, aliaz)
+        SQL::AliasedExpression.new(exp, aliaz)
+      end
+
+      # Order the given argument ascending.
+      # Options:
+      #
+      # :nulls :: Set to :first to use NULLS FIRST (so NULL values are ordered
+      #           before other values), or :last to use NULLS LAST (so NULL values
+      #           are ordered after other values).
+      #
+      #   Sequel.asc(:a) # a ASC
+      #   Sequel.asc(:b, :nulls=>:last) # b ASC NULLS LAST
+      def asc(arg, opts={})
+        SQL::OrderedExpression.new(arg, false, opts)
+      end
+
+      # Return an <tt>SQL::Blob</tt> that holds the same data as this string.
+      # Blobs provide proper escaping of binary data.  If given a blob, returns it
+      # directly.
+      def blob(s)
+        if s.is_a?(SQL::Blob)
+          s
+        else
+          SQL::Blob.new(s)
+        end
+      end
+
+      # Return an <tt>SQL::CaseExpression</tt> created with the given arguments.
+      #
+      #   Sequel.case([[{:a=>[2,3]}, 1]], 0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+      #   Sequel.case({:a=>1}, 0, :b) # SQL: CASE b WHEN a THEN 1 ELSE 0 END
+      def case(*args) # core_sql ignore
+        SQL::CaseExpression.new(*args)
+      end
+
+      # Cast the reciever to the given SQL type.  You can specify a ruby class as a type,
+      # and it is handled similarly to using a database independent type in the schema methods.
+      #
+      #   Sequel.cast(:a, :integer) # CAST(a AS integer)
+      #   Sequel.cast(:a, String) # CAST(a AS varchar(255))
+      def cast(arg, sql_type)
+        SQL::Cast.new(arg, sql_type)
+      end
+
+      # Cast the reciever to the given SQL type (or the database's default Integer type if none given),
+      # and return the result as a +NumericExpression+, so you can use the bitwise operators
+      # on the result. 
+      #
+      #   Sequel.cast_numeric(:a) # CAST(a AS integer)
+      #   Sequel.cast_numeric(:a, Float) # CAST(a AS double precision)
+      def cast_numeric(arg, sql_type = nil)
+        cast(arg, sql_type || Integer).sql_number
+      end
+
+      # Cast the reciever to the given SQL type (or the database's default String type if none given),
+      # and return the result as a +StringExpression+, so you can use +
+      # directly on the result for SQL string concatenation.
+      #
+      #   Sequel.cast_string(:a) # CAST(a AS varchar(255))
+      #   Sequel.cast_string(:a, :text) # CAST(a AS text)
+      def cast_string(arg, sql_type = nil)
+        cast(arg, sql_type || String).sql_string
+      end
+
+      # Order the given argument descending.
+      # Options:
+      #
+      # :nulls :: Set to :first to use NULLS FIRST (so NULL values are ordered
+      #           before other values), or :last to use NULLS LAST (so NULL values
+      #           are ordered after other values).
+      #
+      #   Sequel.desc(:a) # b DESC
+      #   Sequel.desc(:b, :nulls=>:first) # b DESC NULLS FIRST
+      def desc(arg, opts={})
+        SQL::OrderedExpression.new(arg, true, opts)
+      end
+
+      # Wraps the given object in an appropriate Sequel wrapper.
+      # If the given object is already a Sequel object, return it directly.
+      # For condition specifiers (hashes and arrays of two pairs), true, and false,
+      # return a boolean expressions.  For numeric objects, return a numeric
+      # expression.  For strings, return a string expression.  For procs or when
+      # the method is passed a block, evaluate it as a virtual row and wrap it
+      # appropriately.  In all other cases, use a generic wrapper.
+      #
+      # This method allows you to construct SQL expressions that are difficult
+      # to construct via other methods.  For example:
+      #
+      #   Sequel.expr(1) - :a # SQL: (1 - a)
+      def expr(arg=(no_arg=true), &block)
+        if block_given?
+          if no_arg
+            return expr(block)
+          else
+            raise Error, 'cannot provide both an argument and a block to Sequel.expr'
+          end
+        elsif no_arg
+          raise Error, 'must provide either an argument or a block to Sequel.expr'
+        end
+
+        case arg
+        when SQL::Expression, LiteralString, SQL::Blob
+          arg
+        when Hash
+          SQL::BooleanExpression.from_value_pairs(arg, :AND)
+        when Array
+          if condition_specifier?(arg)
+            SQL::BooleanExpression.from_value_pairs(arg, :AND)
+          else
+            SQL::Wrapper.new(arg)
+          end
+        when Numeric
+          SQL::NumericExpression.new(:NOOP, arg)
+        when String
+          SQL::StringExpression.new(:NOOP, arg)
+        when TrueClass, FalseClass
+          SQL::BooleanExpression.new(:NOOP, arg)
+        when Proc
+          expr(virtual_row(&arg))
+        else
+          SQL::Wrapper.new(arg)
+        end
+      end
+
+      # Extract a datetime_part (e.g. year, month) from the given
+      # expression:
+      #
+      #   Sequel.extract(:year, :date) # extract(year FROM "date")
+      def extract(datetime_part, exp)
+        SQL::NumericExpression.new(:extract, datetime_part, exp)
+      end
+
+      # Returns a <tt>Sequel::SQL::Function</tt> with the function name
+      # and the given arguments.
+      #
+      #   Sequel.function(:now) # SQL: now()
+      #   Sequel.function(:substr, :a, 1) # SQL: substr(a, 1)
+      def function(name, *args)
+        SQL::Function.new(name, *args)
+      end
+
+      # Return the argument wrapped as an <tt>SQL::Identifier</tt>.
+      #
+      #   Sequel.identifier(:a__b) # "a__b"
+      def identifier(name)
+        SQL::Identifier.new(name)
+      end
+
+      # Return a <tt>Sequel::SQL::StringExpression</tt> representing an SQL string made up of the
+      # concatenation of the given array's elements.  If an argument is passed,
+      # it is used in between each element of the array in the SQL
+      # concatenation.
+      #
+      #   Sequel.join([:a]) # SQL: a
+      #   Sequel.join([:a, :b]) # SQL: a || b
+      #   Sequel.join([:a, 'b']) # SQL: a || 'b'
+      #   Sequel.join(['a', :b], ' ') # SQL: 'a' || ' ' || b
+      def join(args, joiner=nil)
+        raise Error, 'argument to Sequel.join must be an array' unless args.is_a?(Array)
+        if joiner
+          args = args.zip([joiner]*args.length).flatten
+          args.pop
+        end
+
+        return SQL::StringExpression.new(:NOOP, '') if args.empty?
+
+        args = args.map do |a|
+          case a
+          when Symbol, ::Sequel::SQL::Expression, ::Sequel::LiteralString, TrueClass, FalseClass, NilClass
+            a
+          else
+            a.to_s
+          end
+        end
+        SQL::StringExpression.new(:'||', *args)
+      end
+
+      # Create a <tt>BooleanExpression</tt> case insensitive (if the database supports it) pattern match of the receiver with
+      # the given patterns.  See <tt>SQL::StringExpression.like</tt>.
+      #
+      #   Sequel.ilike(:a, 'A%') # "a" ILIKE 'A%'
+      def ilike(*args)
+        SQL::StringExpression.like(*(args << {:case_insensitive=>true}))
+      end
+
+      # Create a <tt>SQL::BooleanExpression</tt> case sensitive (if the database supports it) pattern match of the receiver with
+      # the given patterns.  See <tt>SQL::StringExpression.like</tt>.
+      #
+      #   Sequel.like(:a, 'A%') # "a" LIKE 'A%'
+      def like(*args)
+        SQL::StringExpression.like(*args)
+      end
+
+      # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
+      # literalization, e.g.:
+      #
+      #   DB[:items].filter(:abc => 'def').sql #=>
+      #     "SELECT * FROM items WHERE (abc = 'def')"
+      #
+      #   DB[:items].filter(:abc => Sequel.lit('def')).sql #=>
+      #     "SELECT * FROM items WHERE (abc = def)"
+      #
+      # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:
+      #
+      #    DB[:items].select{|o| o.count(Sequel.lit('DISTINCT ?', :a))}.sql #=>
+      #      "SELECT count(DISTINCT a) FROM items"
+      def lit(s, *args) # core_sql ignore
+        if args.empty?
+          if s.is_a?(LiteralString)
+            s
+          else
+            LiteralString.new(s)
+          end
+        else
+          SQL::PlaceholderLiteralString.new(s, args) 
+        end
+      end
+
+      # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from the condition
+      # specifier, matching none of the conditions.
+      #
+      #   Sequel.negate(:a=>true) # SQL: a IS NOT TRUE
+      #   Sequel.negate([[:a, true]]) # SQL: a IS NOT TRUE
+      #   Sequel.negate([[:a, 1], [:b, 2]]) # SQL: ((a != 1) AND (b != 2))
+      def negate(arg)
+        if condition_specifier?(arg)
+          SQL::BooleanExpression.from_value_pairs(arg, :AND, true)
+        else
+          raise Error, 'must pass a conditions specifier to Sequel.negate'
+        end
+      end
+
+      # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from the condition
+      # specifier, matching any of the conditions.
+      #
+      #   Sequel.or(:a=>true) # SQL: a IS TRUE
+      #   Sequel.or([[:a, true]]) # SQL: a IS TRUE
+      #   Sequel.or([[:a, 1], [:b, 2]]) # SQL: ((a = 1) OR (b = 2))
+      def or(arg)
+        if condition_specifier?(arg)
+          SQL::BooleanExpression.from_value_pairs(arg, :OR, false)
+        else
+          raise Error, 'must pass a conditions specifier to Sequel.or'
+        end
+      end
+
+      # Create a qualified identifier with the given qualifier and identifier
+      #
+      #   Sequel.qualify(:table, :column) # "table"."column"
+      #   Sequel.qualify(:schema, :table) # "schema"."table"
+      #   Sequel.qualify(:table, :column).qualify(:schema) # "schema"."table"."column"
+      def qualify(qualifier, identifier)
+        SQL::QualifiedIdentifier.new(qualifier, identifier)
+      end
+
+      # Return an <tt>SQL::Subscript</tt> with the given arguments, representing an
+      # SQL array access.
+      #
+      #   Sequel.subscript(:array, 1) # array[1]
+      #   Sequel.subscript(:array, 1, 2) # array[1, 2]
+      #   Sequel.subscript(:array, [1, 2]) # array[1, 2]
+      def subscript(exp, *subs)
+        SQL::Subscript.new(exp, subs.flatten)
+      end
+
+      # Return a <tt>SQL::ValueList</tt> created from the given array.  Used if the array contains
+      # all two element arrays and you want it treated as an SQL value list (IN predicate) 
+      # instead of as a conditions specifier (similar to a hash).  This is not necessary if you are using
+      # this array as a value in a filter, but may be necessary if you are using it as a
+      # value with placeholder SQL:
+      #
+      #   DB[:a].filter([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
+      #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
+      #   DB[:a].filter('(a, b) IN ?', Sequel.value_list([[1, 2], [3, 4]])) # SQL: (a, b) IN ((1, 2), (3, 4))
+      def value_list(arg)
+        raise Error, 'argument to Sequel.value_list must be an array' unless arg.is_a?(Array)
+        SQL::ValueList.new(arg)
+      end
+    end
+
     # Holds methods that are used to cast objects to different SQL types.
     module CastMethods 
       # Cast the reciever to the given SQL type.  You can specify a ruby class as a type,
@@ -316,12 +620,8 @@ module Sequel
       #
       # Also has the benefit of returning the result as a
       # NumericExpression instead of a generic ComplexExpression.
-      #
-      # The extract function is in the SQL standard, but it doesn't
-      # doesn't use the standard function calling convention, and it
-      # doesn't work on all databases.
       def extract(datetime_part)
-        Function.new(:extract, PlaceholderLiteralString.new("#{datetime_part} FROM ?", [self])).sql_number
+        NumericExpression.new(:extract, datetime_part, self)
       end
 
       # Return a BooleanExpression representation of +self+.
@@ -367,34 +667,12 @@ module Sequel
     #   'a'.lit <= :b # a <= "b"
     module InequalityMethods
       ComplexExpression::INEQUALITY_OPERATORS.each do |o|
-        define_method(o) do |ce|
-          case ce
-          when BooleanExpression, TrueClass, FalseClass, NilClass, Hash, ::Array
-            raise(Error, "cannot apply #{o} to a boolean expression")
-          else  
-            BooleanExpression.new(o, self, ce)
-          end
-        end
+        module_eval("def #{o}(o) BooleanExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
       end
     end
 
-    # This module augments the default initalize method for the 
-    # +ComplexExpression+ subclass it is included in, so that
-    # attempting to use boolean input when initializing a +NumericExpression+
-    # or +StringExpression+ results in an error.  It is not expected to be
-    # used directly.
+    # Only exists for backwards compatibility, ignore it.
     module NoBooleanInputMethods
-      # Raise an +Error+ if one of the args would be boolean in an SQL
-      # context, otherwise call super.
-      def initialize(op, *args)
-        args.each do |a|
-          case a
-          when BooleanExpression, TrueClass, FalseClass, NilClass, Hash, ::Array
-            raise(Error, "cannot apply #{op} to a boolean expression")
-          end
-        end
-        super
-      end
     end
 
     # This module includes the standard mathematical methods (+, -, *, and /)
@@ -405,15 +683,66 @@ module Sequel
     #   :a - :b # "a" - "b"
     #   :a * :b # "a" * "b"
     #   :a / :b # "a" / "b"
+    #
+    # One exception to this is if + is called with a +String+ or +StringExpression+,
+    # in which case the || operator is used instead of the + operator:
+    #
+    #   :a + 'b' # "a" || 'b'
     module NumericMethods
       ComplexExpression::MATHEMATICAL_OPERATORS.each do |o|
-        define_method(o) do |ce|
-          case ce
-          when BooleanExpression, StringExpression
-            raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
-          else  
-            NumericExpression.new(o, self, ce)
+        module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__) unless o == :+
+      end
+
+      # Use || as the operator when called with StringExpression and String instances,
+      # and the + operator for LiteralStrings and all other types.
+      def +(ce)
+        case ce
+        when LiteralString
+          NumericExpression.new(:+, self, ce)
+        when StringExpression, String
+          StringExpression.new(:'||', self, ce)
+        else
+          NumericExpression.new(:+, self, ce)
+        end
+      end
+    end
+
+    # These methods are designed as replacements for the core extension operator
+    # methods, so that Sequel is still easy to use if the core extensions are not
+    # enabled.
+    #
+    # The following methods are defined via metaprogramming: +, -, *, /, &, |.
+    # The +, -, *, and / operators return numeric expressions combining all the
+    # arguments with the appropriate operator, and the & and | operators return
+    # boolean expressions combining all of the arguments with either AND or OR.
+    module OperatorBuilders
+      %w'+ - * /'.each do |op|
+        class_eval(<<-END, __FILE__, __LINE__ + 1)
+          def #{op}(*args)
+            SQL::NumericExpression.new(:#{op}, *args)
+          end
+        END
+      end
+
+      {'&'=>'AND', '|'=>'OR'}.each do |m, op|
+        class_eval(<<-END, __FILE__, __LINE__ + 1)
+          def #{m}(*args)
+            SQL::BooleanExpression.new(:#{op}, *args)
           end
+        END
+      end
+      
+      # Invert the given expression.  Returns a <tt>Sequel::SQL::BooleanExpression</tt>
+      # created from this argument, not matching all of the conditions.
+      #
+      #   Sequel.~(nil) # SQL: NOT NULL
+      #   Sequel.~([[:a, true]]) # SQL: a IS NOT TRUE
+      #   Sequel.~([[:a, 1], [:b, [2, 3]]]) # SQL: a != 1 OR b NOT IN (2, 3)
+      def ~(arg)
+        if condition_specifier?(arg)
+          SQL::BooleanExpression.from_value_pairs(arg, :OR, true)
+        else
+          SQL::BooleanExpression.invert(arg)
         end
       end
     end
@@ -595,10 +924,27 @@ module Sequel
           end
         when StringExpression, NumericExpression
           raise(Sequel::Error, "cannot invert #{ce.inspect}")
+        when Constant
+          CONSTANT_INVERSIONS[ce] || raise(Sequel::Error, "cannot invert #{ce.inspect}")
         else
           BooleanExpression.new(:NOT, ce)
         end
       end
+
+      # Always use an AND operator for & on BooleanExpressions
+      def &(ce)
+        BooleanExpression.new(:AND, self, ce)
+      end
+
+      # Always use an OR operator for | on BooleanExpressions
+      def |(ce)
+        BooleanExpression.new(:OR, self, ce)
+      end
+
+      # Return self instead of creating a new object to save on memory.
+      def sql_boolean
+        self
+      end
     end
 
     # Represents an SQL CASE expression, used for conditional branching in SQL.
@@ -666,6 +1012,21 @@ module Sequel
       include CastMethods
       include OrderMethods
       include SubscriptMethods
+
+      # Return a BooleanExpression with the same op and args.
+      def sql_boolean
+        BooleanExpression.new(self.op, *self.args)
+      end
+
+      # Return a NumericExpression with the same op and args.
+      def sql_number
+        NumericExpression.new(self.op, *self.args)
+      end
+
+      # Return a StringExpression with the same op and args.
+      def sql_string
+        StringExpression.new(self.op, *self.args)
+      end
     end
 
     # Represents constants or psuedo-constants (e.g. +CURRENT_DATE+) in SQL.
@@ -706,6 +1067,12 @@ module Sequel
       NOTNULL = NegativeBooleanConstant.new(nil)
     end
 
+    class ComplexExpression
+      # A hash of the opposite for each constant, used for inverting constants.
+      CONSTANT_INVERSIONS = {Constants::TRUE=>Constants::FALSE, Constants::FALSE=>Constants::TRUE,
+                             Constants::NULL=>Constants::NOTNULL, Constants::NOTNULL=>Constants::NULL}
+    end
+
     # Represents an SQL function call.
     class Function < GenericExpression
       # The array of arguments to pass to the function (may be blank)
@@ -812,7 +1179,8 @@ module Sequel
       # substituted for :key phrases).
       attr_reader :args
 
-      # The literal string containing placeholders
+      # The literal string containing placeholders.  This can also be an array
+      # of strings, where each arg in args goes between the string elements. 
       attr_reader :str
 
       # Whether to surround the expression with parantheses
@@ -834,7 +1202,16 @@ module Sequel
       include BitwiseMethods 
       include NumericMethods
       include InequalityMethods
-      include NoBooleanInputMethods
+
+      # Always use + for + operator for NumericExpressions.
+      def +(ce)
+        NumericExpression.new(:+, self, ce)
+      end
+
+      # Return self instead of creating a new object to save on memory.
+      def sql_number
+        self
+      end
     end
 
     # Represents a column/expression to order the result set by.
@@ -891,7 +1268,7 @@ module Sequel
         @table, @column = table, column
       end
       
-      to_s_method :qualified_identifier_sql
+      to_s_method :qualified_identifier_sql, "@table, @column"
     end
     
     # Subclass of +ComplexExpression+ where the expression results
@@ -900,7 +1277,6 @@ module Sequel
       include StringMethods
       include StringConcatenationMethods
       include InequalityMethods
-      include NoBooleanInputMethods
 
       # Map of [regexp, case_insenstive] to +ComplexExpression+ operator symbol
       LIKE_MAP = {[true, true]=>:'~*', [true, false]=>:~, [false, true]=>:ILIKE, [false, false]=>:LIKE}
@@ -949,6 +1325,11 @@ module Sequel
         end
       end
       private_class_method :like_element
+
+      # Return self instead of creating a new object to save on memory.
+      def sql_string
+        self
+      end
     end
 
     # Represents an SQL array access, with multiple possible arguments.
@@ -966,9 +1347,21 @@ module Sequel
 
       # Create a new +Subscript+ appending the given subscript(s)
       # the the current array of subscripts.
+      #
+      #   :a.sql_subscript(2) # a[2]
+      #   :a.sql_subscript(2) | 1 # a[2, 1]
       def |(sub)
         Subscript.new(@f, @sub + Array(sub))
       end
+
+      # Create a new +Subscript+ by accessing a subarray of a multidimensional
+      # array.
+      #
+      #   :a.sql_subscript(2) # a[2]
+      #   :a.sql_subscript(2)[1] # a[2][1]
+      def [](sub)
+        Subscript.new(self, Array(sub))
+      end
       
       to_s_method :subscript_sql
     end
@@ -1019,28 +1412,71 @@ module Sequel
     # Examples:
     #
     #   ds = DB[:t]
+    #
     #   # Argument yielded to block
     #   ds.filter{|r| r.name < 2} # SELECT * FROM t WHERE (name < 2)
+    #
     #   # Block without argument (instance_eval)
     #   ds.filter{name < 2} # SELECT * FROM t WHERE (name < 2)
+    #
     #   # Qualified identifiers
     #   ds.filter{table__column + 1 < 2} # SELECT * FROM t WHERE ((table.column + 1) < 2)
+    #
     #   # Functions
     #   ds.filter{is_active(1, 'arg2')} # SELECT * FROM t WHERE is_active(1, 'arg2')
     #   ds.select{version{}} # SELECT version() FROM t
     #   ds.select{count(:*){}} # SELECT count(*) FROM t
     #   ds.select{count(:distinct, col1){}} # SELECT count(DISTINCT col1) FROM t
+    #
     #   # Window Functions
     #   ds.select{rank(:over){}} # SELECT rank() OVER () FROM t
     #   ds.select{count(:over, :*=>true){}} # SELECT count(*) OVER () FROM t
     #   ds.select{sum(:over, :args=>col1, :partition=>col2, :order=>col3){}} # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM t
     #
+    #   # Math Operators
+    #   ds.select{|o| o.+(1, :a).as(:b)} # SELECT (1 + a) AS b FROM t
+    #   ds.select{|o| o.-(2, :a).as(:b)} # SELECT (2 - a) AS b FROM t
+    #   ds.select{|o| o.*(3, :a).as(:b)} # SELECT (3 * a) AS b FROM t
+    #   ds.select{|o| o./(4, :a).as(:b)} # SELECT (4 / a) AS b FROM t
+    #
+    #   # Boolean Operators
+    #   ds.filter{|o| o.&({:a=>1}, :b)}    # SELECT * FROM t WHERE ((a = 1) AND b)
+    #   ds.filter{|o| o.|({:a=>1}, :b)}    # SELECT * FROM t WHERE ((a = 1) OR b)
+    #   ds.filter{|o| o.~({:a=>1})}        # SELECT * FROM t WHERE (a != 1)
+    #   ds.filter{|o| o.~({:a=>1, :b=>2})} # SELECT * FROM t WHERE ((a != 1) OR (b != 2))
+    #
+    #   # Inequality Operators
+    #   ds.filter{|o| o.>(1, :a)}  # SELECT * FROM t WHERE (1 > a)
+    #   ds.filter{|o| o.<(2, :a)}  # SELECT * FROM t WHERE (2 < a)
+    #   ds.filter{|o| o.>=(3, :a)} # SELECT * FROM t WHERE (3 >= a)
+    #   ds.filter{|o| o.<=(4, :a)} # SELECT * FROM t WHERE (4 <= a)
+    #
+    #   # Literal Strings
+    #   ds.filter{{a=>`some SQL`}} # SELECT * FROM t WHERE (a = some SQL)
+    #
     # For a more detailed explanation, see the {Virtual Rows guide}[link:files/doc/virtual_rows_rdoc.html].
     class VirtualRow < BasicObject
       WILDCARD = LiteralString.new('*').freeze
       QUESTION_MARK = LiteralString.new('?').freeze
       COMMA_SEPARATOR = LiteralString.new(', ').freeze
       DOUBLE_UNDERSCORE = '__'.freeze
+      DISTINCT = ["DISTINCT ".freeze].freeze
+      COMMA_ARRAY = [COMMA_SEPARATOR].freeze
+
+      include OperatorBuilders
+
+      %w'> < >= <='.each do |op|
+        class_eval(<<-END, __FILE__, __LINE__ + 1)
+          def #{op}(*args)
+            SQL::BooleanExpression.new(:#{op}, *args)
+          end
+        END
+      end
+
+      # Return a literal string created with the given string.
+      def `(s)
+        Sequel::LiteralString.new(s)
+      end
 
       # Return an +Identifier+, +QualifiedIdentifier+, +Function+, or +WindowFunction+, depending
       # on arguments and whether a block is provided.  Does not currently call the block.
@@ -1054,7 +1490,7 @@ module Sequel
             when :*
               Function.new(m, WILDCARD)
             when :distinct
-              Function.new(m, PlaceholderLiteralString.new("DISTINCT #{args.map{QUESTION_MARK}.join(COMMA_SEPARATOR)}", args))
+              Function.new(m, PlaceholderLiteralString.new(DISTINCT + COMMA_ARRAY * (args.length-1), args))
             when :over
               opts = args.shift || {}
               fun_args = ::Kernel.Array(opts[:*] ? WILDCARD : opts[:args])
@@ -1108,6 +1544,20 @@ module Sequel
 
       to_s_method :window_function_sql, '@function, @window'
     end
+
+    # A +Wrapper+ is a simple way to wrap an existing object so that it supports
+    # the Sequel DSL.
+    class Wrapper < GenericExpression
+      # The underlying value wrapped by this object.
+      attr_reader :value
+
+      # Set the value wrapped by the object.
+      def initialize(value)
+        @value = value
+      end
+
+      to_s_method :literal, '@value'
+    end
   end
 
   # +LiteralString+ is used to represent literal SQL expressions. A 
@@ -1120,7 +1570,24 @@ module Sequel
     include SQL::NumericMethods
     include SQL::StringMethods
     include SQL::InequalityMethods
+
+    # If the core extensions are enabled, these will already be included
+    # in String, so we don't need to include/define them here.
+    unless Sequel.core_extensions?
+      include Sequel::SQL::AliasMethods
+      include Sequel::SQL::CastMethods
+      
+      def lit(*args)
+        args.empty? ? self : SQL::PlaceholderLiteralString.new(self, args)
+      end
+      
+      def to_sequel_blob
+        SQL::Blob.new(self)
+      end
+    end
   end
   
   include SQL::Constants
+  extend SQL::Builders
+  extend SQL::OperatorBuilders
 end