sequel_core 2.0.1 → 2.1.0

data/lib/sequel_core/dataset.rb

@@ -103,7 +103,16 @@ module Sequel
       ]
     }
 
-    attr_accessor :db, :opts, :row_proc
+    # The database that corresponds to this dataset
+    attr_accessor :db
+
+    # The hash of options for this dataset, keys are symbols.
+    attr_accessor :opts
+
+    # The row_proc for this database, should be a Proc that takes
+    # a single hash argument and returns the object you want to
+    # fetch_rows to return.
+    attr_accessor :row_proc
 
     # Whether to quote identifiers for this dataset
     attr_writer :quote_identifiers
@@ -158,8 +167,8 @@ module Sequel
 
     # Return the dataset as a column with the given alias, so it can be used in the
     # SELECT clause. This dataset should result in a single row and a single column.
-    def as(a)
-      ::Sequel::SQL::ColumnExpr.new(self, 'AS', a)
+    def as(aliaz)
+      ::Sequel::SQL::AliasedExpression.new(self, aliaz)
     end
 
     # Returns an array with all records in the dataset. If a block is given,
@@ -178,7 +187,7 @@ module Sequel
     def clone(opts = {})
       c = super()
       c.opts = @opts.merge(opts)
-      c.instance_variable_set(:@columns, nil) unless (opts.keys & COLUMN_CHANGE_OPTS).empty?
+      c.instance_variable_set(:@columns, nil) if c.options_overlap(COLUMN_CHANGE_OPTS)
       c
     end
     
@@ -424,6 +433,13 @@ module Sequel
     # Add the mutation methods via metaprogramming
     def_mutation_method(*MUTATION_METHODS)
 
+    protected
+
+    # Return true if the dataset has a non-nil value for any key in opts.
+    def options_overlap(opts)
+      !(@opts.collect{|k,v| k unless v.nil?}.compact & opts).empty?
+    end
+
     private
 
     # Modify the receiver with the results of sending the meth, args, and block

data/lib/sequel_core/deprecated.rb

@@ -22,11 +22,5 @@ module Sequel
         caller.each{|c| @dms.puts(c)} if @pt 
       end
     end
-
-    # Formats the message with a message that it will be removed in Sequel 2.0.
-    # This is the method that is added to the classes that include Sequel::Deprecation.
-    def deprecate(meth, message = nil)
-      ::Sequel::Deprecation.deprecate("#{meth} is deprecated, and will be removed in Sequel 2.0.#{"  #{message}." if message}")
-    end
   end
 end

data/lib/sequel_core/migration.rb

@@ -22,6 +22,10 @@ module Sequel
   #
   #   DB = Sequel.open ('sqlite://mydb')
   #   CreateSessions.apply(DB, :up)
+  #
+  # See Sequel::Schema::Generator for the syntax to use for creating tables,
+  # and Sequel::Schema::AlterTableGenerator for the syntax to use when
+  # altering existing tables.
   class Migration
     # Creates a new instance of the migration and sets the @db attribute.
     def initialize(db)

data/lib/sequel_core/object_graph.rb

@@ -38,11 +38,11 @@ module Sequel
     #     used more than once.
     #   * :join_type - The type of join to use (passed to join_table).  Defaults to
     #     :left_outer.
-    #   * :select - Whether to select the columns from the you are joining, and 
-    #     include them as a separate hash in the output.  With this set to false,
-    #     it is like simply joining the tables.  This is designed to be used for
-    #     many_to_many join tables, where the columns are just foreign keys to primary
-    #     keys in other tables.
+    #   * :select - An array of columns to select.  When not used, selects
+    #     all columns in the given dataset.  When set to false, selects no
+    #     columns and is like simply joining the tables, though graph keeps
+    #     some metadata about join that makes it important to use graph instead
+    #     of join.
     def graph(dataset, join_conditions, options = {})
       # Allow the use of a model, dataset, or symbol as the first argument
       # Find the table name/dataset based on the argument
@@ -112,12 +112,14 @@ module Sequel
         select = opts[:select]
         column_aliases = graph[:column_aliases]
         ca_num = graph[:column_alias_num]
+        # Which columns to add to the result set
+        cols = options[:select] || dataset.columns
         # If the column hasn't been used yet, don't alias it.
         # If it has been used, try table_column.
         # If that has been used, try table_column_N 
         # using the next value of N that we know hasn't been
         # used
-        dataset.columns.each do |column|
+        cols.each do |column|
           col_alias, c = if column_aliases[column]
             tc = :"#{table_alias}_#{column}"
             if column_aliases[tc]

data/lib/sequel_core/pretty_table.rb

@@ -65,7 +65,7 @@ module Sequel
       '+' << columns.map {|c| '-' * sizes[c]}.join('+') << '+'
     end
 
-    metaprivate :column_sizes, :data_line, :format_cell, :header_line, :separator_line
+    private_class_method :column_sizes, :data_line, :format_cell, :header_line, :separator_line
   end
 end
 

data/lib/sequel_core/schema/sql.rb

@@ -241,6 +241,8 @@ module Sequel
           :boolean
         when /\A(real|float|double( precision)?)\z/
           :float
+        when /\A(numeric|decimal|money)\z/
+          :decimal
         end
       end
 

data/lib/sequel_core/sql.rb

@@ -1,94 +1,22 @@
-# This file holds classes and modules under Sequel that are related to SQL
-# creation.
-
 module Sequel
   # 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.
   module SQL
-    # Holds methods that should be called on columns only.
-    module ColumnMethods
-      AS = 'AS'.freeze
-      DESC = 'DESC'.freeze
-      ASC = 'ASC'.freeze
-      
-      # Create an SQL column alias of the receiving column to the given alias.
-      def as(a)
-        ColumnExpr.new(self, AS, a)
-      end
-      
-      # Mark the receiving SQL column as sorting in a descending fashion.
-      def desc
-        ColumnExpr.new(self, DESC)
-      end
-      
-      # Mark the receiving SQL column as sorting in an ascending fashion (generally a no-op).
-      def asc
-        ColumnExpr.new(self, ASC)
-      end
+    ### Parent Classes ###
+
+    # Classes/Modules aren't an alphabetical order due to the fact that
+    # some reference constants defined in others at load time.
 
-      # Cast the reciever to the given SQL type
-      def cast_as(t)
-        t = t.to_s.lit if t.is_a?(Symbol)
-        Sequel::SQL::Function.new(:cast, self.as(t))
-      end
-    end
-    
     # Base class for all SQL fragments
     class Expression
-      include ColumnMethods
-
       # Returns self, because SQL::Expression already acts like
       # LiteralString.
       def lit
         self
       end
     end
-    
-    # Represents all columns in a given table, table.* in SQL
-    class ColumnAll < Expression
-      # The table containing the columns being selected
-      attr_reader :table
-
-      # Create an object with the given table
-      def initialize(table)
-        @table = table
-      end
-
-      # ColumnAll expressions are considered equivalent if they
-      # have the same class and string representation
-      def ==(x)
-        x.class == self.class && @table == x.table
-      end
-
-      # Delegate the creation of the resulting SQL to the given dataset,
-      # since it may be database dependent.
-      def to_s(ds)
-        ds.column_all_sql(self)
-      end
-    end
-
-    # Represents a generic column expression, used for specifying order
-    # and aliasing of columns.
-    class ColumnExpr < Expression
-      # Created readers for the left, operator, and right expression.
-      attr_reader :l, :op, :r
 
-      # Sets the attributes for the object to those given.
-      # The right (r) is not required, it is used when aliasing.
-      # The left (l) usually specifies the column name, and the
-      # operator (op) is usually 'ASC', 'DESC', or 'AS'.
-      def initialize(l, op, r = nil)
-        @l, @op, @r = l, op, r
-      end
-      
-      # Delegate the creation of the resulting SQL to the given dataset,
-      # since it may be database dependent.
-      def to_s(ds)
-        ds.column_expr_sql(self)
-      end
-    end
-    
     # Represents a complex SQL expression, with a given operator and one
     # or more attributes (which may also be ComplexExpressions, forming
     # a tree).  This class is the backbone of the blockless filter support in
@@ -110,6 +38,9 @@ module Sequel
       # Mathematical Operators used in NumericMethods
       MATHEMATICAL_OPERATORS = [:+, :-, :/, :*]
 
+      # Mathematical Operators used in NumericMethods
+      BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>]
+
       # Inequality Operators used in InequalityMethods
       INEQUALITY_OPERATORS = [:<, :>, :<=, :>=]
 
@@ -118,13 +49,14 @@ module Sequel
 
       # Operator symbols that take exactly two arguments
       TWO_ARITY_OPERATORS = [:'=', :'!=', :IS, :'IS NOT', :LIKE, :'NOT LIKE', \
-        :~, :'!~', :'~*', :'!~*', :IN, :'NOT IN', :ILIKE, :'NOT ILIKE'] + INEQUALITY_OPERATORS
+        :~, :'!~', :'~*', :'!~*', :IN, :'NOT IN', :ILIKE, :'NOT ILIKE'] + \
+        INEQUALITY_OPERATORS + BITWISE_OPERATORS 
 
       # Operator symbols that take one or more arguments
       N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS
 
       # Operator symbols that take one argument
-      ONE_ARITY_OPERATORS = [:NOT, :NOOP]
+      ONE_ARITY_OPERATORS = [:NOT, :NOOP, :'B~']
 
       # An array of args for this object
       attr_reader :args
@@ -168,6 +100,56 @@ module Sequel
       end
     end
 
+    # The base class for expressions that can be used in multiple places in
+    # the SQL query.  
+    class GenericExpression < Expression
+    end
+    
+    # The base class for expressions that are specific and can only be used
+    # in a certain place in the SQL query (ordering, selecting).
+    class SpecificExpression < Expression
+    end
+
+    ### Modules ###
+
+    # Methods the create aliased identifiers
+    module AliasMethods
+      # Create an SQL column alias of the receiving column to the given alias.
+      def as(aliaz)
+        AliasedExpression.new(self, aliaz)
+      end
+    end
+
+    # This defines the bitwise methods &, |, ^, ~, <<, and >>.  Because these
+    # methods overlap with the standard BooleanMethods methods, and they only
+    # make sense for numbers, they are only included in NumericExpression.
+    module BitwiseMethods
+      ComplexExpression::BITWISE_OPERATORS.each do |o|
+        define_method(o) do |ce|
+          case ce
+          when NumericExpression 
+            NumericExpression.new(o, self, ce)
+          when ComplexExpression
+            raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
+          else  
+            NumericExpression.new(o, self, ce)
+          end
+        end
+      end
+
+      # Do the bitwise compliment of the self
+      def ~
+        case self
+        when NumericExpression 
+          NumericExpression.new(:'B~', self)
+        when ComplexExpression
+          raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
+        else  
+          NumericExpression.new(:'B~', self)
+        end
+      end
+    end
+
     # This module includes the methods that are defined on objects that can be 
     # used in a boolean context in SQL (Symbol, LiteralString, SQL::Function,
     # and SQL::BooleanExpression).
@@ -193,6 +175,64 @@ module Sequel
       end
     end
 
+    # Holds methods that are used to cast objects to differen SQL types.
+    module CastMethods 
+      # Cast the reciever to the given SQL type
+      def cast(sql_type)
+        IrregularFunction.new(:cast, self, :AS, sql_type.to_s.lit)
+      end
+      alias_method :cast_as, :cast
+
+      # Cast the reciever to the given SQL type (or integer if none given),
+      # and return the result as a NumericExpression. 
+      def cast_numeric(sql_type = nil)
+        cast(sql_type || :integer).sql_number
+      end
+
+      # Cast the reciever to the given SQL type (or text if none given),
+      # and return the result as a StringExpression, so you can use +
+      # directly on the result for SQL string concatenation.
+      def cast_string(sql_type = nil)
+        cast(sql_type || :text).sql_string
+      end
+    end
+    
+    # This module includes the methods that are defined on objects that can be 
+    # used in a numeric or string context in SQL (Symbol, LiteralString, 
+    # SQL::Function, and SQL::StringExpression).
+    #
+    # This defines the >, <, >=, and <= methods.
+    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
+      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.
+    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 methods that are defined on objects that can be 
     # used in a numeric context in SQL (Symbol, LiteralString, SQL::Function,
     # and SQL::NumericExpression).
@@ -213,6 +253,29 @@ module Sequel
       end
     end
 
+    # Methods that create OrderedExpressions, used for sorting by columns
+    # or more complex expressions.
+    module OrderMethods
+      # Mark the receiving SQL column as sorting in a descending fashion.
+      def desc
+        OrderedExpression.new(self)
+      end
+      
+      # Mark the receiving SQL column as sorting in an ascending fashion (generally a no-op).
+      def asc
+        OrderedExpression.new(self, false)
+      end
+    end
+
+    # Methods that created QualifiedIdentifiers, used for qualifying column
+    # names with a table or table names with a schema.
+    module QualifyingMethods
+      # Qualify the current object with the given table/schema.
+      def qualify(ts)
+        QualifiedIdentifier.new(ts, self)
+      end
+    end
+
     # This module includes the methods that are defined on objects that can be 
     # used in a numeric context in SQL (Symbol, LiteralString, SQL::Function,
     # and SQL::StringExpression).
@@ -243,41 +306,7 @@ module Sequel
       end
     end
 
-    # This module includes the methods that are defined on objects that can be 
-    # used in a numeric or string context in SQL (Symbol, LiteralString, 
-    # SQL::Function, and SQL::StringExpression).
-    #
-    # This defines the >, <, >=, and <= methods.
-    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
-      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.
-    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
+    ### Modules that include other modules ###
 
     # This module includes other Sequel::SQL::*Methods modules and is
     # included in other classes that are could be either booleans,
@@ -300,6 +329,16 @@ module Sequel
       include StringMethods
       include InequalityMethods
 
+      # Extract a datetime_part (e.g. year, month) from self:
+      #
+      #   :date.extract(:year) # SQL:  extract(year FROM date)
+      #
+      # Also has the benefit of returning the result as a
+      # NumericExpression instead of a generic ComplexExpression.
+      def extract(datetime_part)
+        IrregularFunction.new(:extract, datetime_part.to_s.lit, :FROM, self).sql_number
+      end
+
       # Return a BooleanExpression representation of self.
       def sql_boolean
         BooleanExpression.new(:NOOP, self)
@@ -316,6 +355,48 @@ module Sequel
       end
     end
 
+    module SpecificExpressionMethods
+      include AliasMethods
+      include CastMethods
+      include OrderMethods
+    end
+
+    module GenericExpressionMethods
+      include SpecificExpressionMethods
+      include ComplexExpressionMethods
+    end
+
+    class ComplexExpression
+      include SpecificExpressionMethods
+    end
+
+    class GenericExpression
+      include GenericExpressionMethods
+    end
+
+    ### Classes ###
+
+    # Represents an aliasing of an expression/column to a given name.
+    class AliasedExpression < SpecificExpression
+      # The expression to alias
+      attr_reader :expression
+
+      # The alias to use for the expression, not alias since that is
+      # a keyword in ruby.
+      attr_reader :aliaz
+
+      # default value.
+      def initialize(expression, aliaz)
+        @expression, @aliaz = expression, aliaz
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.aliased_expression_sql(self)
+      end
+    end
+
     # Subclass of ComplexExpression where the expression results
     # in a boolean value in SQL.
     class BooleanExpression < ComplexExpression
@@ -378,49 +459,54 @@ module Sequel
       end
     end
 
-    # Subclass of ComplexExpression where the expression results
-    # in a numeric value in SQL.
-    class NumericExpression < ComplexExpression
-      include NumericMethods
-      include InequalityMethods
-      include NoBooleanInputMethods
+    # Represents an SQL CASE expression, used for conditions.
+    class CaseExpression < GenericExpression
+      # An array of all two pairs with the first element specifying the
+      # condition and the second element specifying the result.
+      attr_reader :conditions
+
+      # The default value if no conditions are true
+      attr_reader :default
+
+      # Create an object with the given conditions and
+      # default value.
+      def initialize(conditions, default)
+        raise(Sequel::Error, 'CaseExpression conditions must be an array with all_two_pairs') unless Array === conditions and conditions.all_two_pairs?
+        @conditions, @default = conditions, default
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.case_expression_sql(self)
+      end
     end
 
-    # Subclass of ComplexExpression where the expression results
-    # in a text/string/varchar value in SQL.
-    class StringExpression < ComplexExpression
-      include StringMethods
-      include StringConcatenationMethods
-      include InequalityMethods
-      include NoBooleanInputMethods
-      
-      # Creates a SQL pattern match exprssion. left (l) is the SQL string we
-      # are matching against, and ces are the patterns we are matching.
-      # The match succeeds if any of the patterns match (SQL OR).  Patterns
-      # can be given as strings or regular expressions.  Strings will cause
-      # the SQL LIKE operator to be used, and should be supported by most
-      # databases.  Regular expressions will probably only work on MySQL
-      # and PostgreSQL, and SQL regular expression syntax is not fully compatible
-      # with ruby regular expression syntax, so be careful if using regular
-      # expressions.
-      # 
-      # The pattern match will be case insensitive if the last argument is a hash
-      # with a key of :case_insensitive that is not false or nil. Also,
-      # if a case insensitive regular expression is used (//i), that particular
-      # pattern which will always be case insensitive.
-      def self.like(l, *ces)
-        case_insensitive = ces.extract_options![:case_insensitive]
-        ces.collect! do |ce|
-          op, expr = Regexp === ce ? [ce.casefold? || case_insensitive ? :'~*' : :~, ce.source] : [case_insensitive ? :ILIKE : :LIKE, ce.to_s]
-          BooleanExpression.new(op, l, expr)
-        end
-        ces.length == 1 ? ces.at(0) : BooleanExpression.new(:OR, *ces)
+    # Represents all columns in a given table, table.* in SQL
+    class ColumnAll < SpecificExpression
+      # The table containing the columns being selected
+      attr_reader :table
+
+      # Create an object with the given table
+      def initialize(table)
+        @table = table
+      end
+
+      # ColumnAll expressions are considered equivalent if they
+      # have the same class and string representation
+      def ==(x)
+        x.class == self.class && @table == x.table
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.column_all_sql(self)
       end
     end
 
     # Represents an SQL function call.
-    class Function < Expression
-      include ComplexExpressionMethods
+    class Function < GenericExpression
       # The array of arguments to pass to the function (may be blank)
       attr_reader :args
 
@@ -445,9 +531,130 @@ module Sequel
       end
     end
     
+    # IrregularFunction is used for the SQL EXTRACT and CAST functions,
+    # which don't use regular function calling syntax. The IrregularFunction
+    # replaces the commas the regular function uses with a custom
+    # join string.
+    #
+    # This shouldn't be used directly, see CastMethods#cast and 
+    # ComplexExpressionMethods#extract.
+    class IrregularFunction < Function
+      # The arguments to pass to the function (may be blank)
+      attr_reader :arg1, :arg2
+
+      # The SQL function to call
+      attr_reader :f
+      
+      # The literal string to use in place of a comma to join arguments
+      attr_reader :joiner
+
+      # Set the attributes to the given arguments
+      def initialize(f, arg1, joiner, arg2)
+        @f, @arg1, @joiner, @arg2 = f, arg1, joiner, arg2
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.irregular_function_sql(self)
+      end
+    end
+
+    # Represents an SQL JOIN clause, used for joining tables.
+    class JoinClause < SpecificExpression
+      # The type of join to do
+      attr_reader :join_type
+
+      # The actual table to join
+      attr_reader :table
+
+      # The table alias to use for the join, if any
+      attr_reader :table_alias
+
+      # Create an object with the given conditions and
+      # default value.
+      def initialize(join_type, table, table_alias = nil)
+        @join_type, @table, @table_alias = join_type, table, table_alias
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.join_clause_sql(self)
+      end
+    end
+
+    # Represents an SQL JOIN table ON conditions clause.
+    class JoinOnClause < JoinClause
+      # The conditions for the join
+      attr_reader :on
+
+      # Create an object with the given conditions and
+      # default value.
+      def initialize(on, *args)
+        @on = on
+        super(*args)
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.join_on_clause_sql(self)
+      end
+    end
+
+    # Represents an SQL JOIN table USING (columns) clause.
+    class JoinUsingClause < JoinClause
+      # The columns that appear both tables that should be equal 
+      # for the conditions to match.
+      attr_reader :using
+
+      # Create an object with the given conditions and
+      # default value.
+      def initialize(using, *args)
+        @using = using
+        super(*args)
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.join_using_clause_sql(self)
+      end
+    end
+
+    # Subclass of ComplexExpression where the expression results
+    # in a numeric value in SQL.
+    class NumericExpression < ComplexExpression
+      include BitwiseMethods 
+      include NumericMethods
+      include InequalityMethods
+      include NoBooleanInputMethods
+    end
+
+    # Represents a column/expression to order the result set by.
+    class OrderedExpression < SpecificExpression
+      # The expression to order the result set by.
+      attr_reader :expression
+
+      # Whether the expression should order the result set in a descening manner
+      attr_reader :descending
+
+      # default value.
+      def initialize(expression, descending = true)
+        @expression, @descending = expression, descending
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.ordered_expression_sql(self)
+      end
+    end
+
     # Represents a qualified (column with table) reference.  Used when
     # joining tables to disambiguate columns.
-    class QualifiedColumnRef < Expression
+    class QualifiedIdentifier < GenericExpression
       # The table and column to reference
       attr_reader :table, :column
 
@@ -459,12 +666,44 @@ module Sequel
       # Delegate the creation of the resulting SQL to the given dataset,
       # since it may be database dependent.
       def to_s(ds)
-        ds.qualified_column_ref_sql(self)
+        ds.qualified_identifier_sql(self)
       end 
     end
     
+    # Subclass of ComplexExpression where the expression results
+    # in a text/string/varchar value in SQL.
+    class StringExpression < ComplexExpression
+      include StringMethods
+      include StringConcatenationMethods
+      include InequalityMethods
+      include NoBooleanInputMethods
+      
+      # Creates a SQL pattern match exprssion. left (l) is the SQL string we
+      # are matching against, and ces are the patterns we are matching.
+      # The match succeeds if any of the patterns match (SQL OR).  Patterns
+      # can be given as strings or regular expressions.  Strings will cause
+      # the SQL LIKE operator to be used, and should be supported by most
+      # databases.  Regular expressions will probably only work on MySQL
+      # and PostgreSQL, and SQL regular expression syntax is not fully compatible
+      # with ruby regular expression syntax, so be careful if using regular
+      # expressions.
+      # 
+      # The pattern match will be case insensitive if the last argument is a hash
+      # with a key of :case_insensitive that is not false or nil. Also,
+      # if a case insensitive regular expression is used (//i), that particular
+      # pattern which will always be case insensitive.
+      def self.like(l, *ces)
+        case_insensitive = ces.extract_options![:case_insensitive]
+        ces.collect! do |ce|
+          op, expr = Regexp === ce ? [ce.casefold? || case_insensitive ? :'~*' : :~, ce.source] : [case_insensitive ? :ILIKE : :LIKE, ce.to_s]
+          BooleanExpression.new(op, l, expr)
+        end
+        ces.length == 1 ? ces.at(0) : BooleanExpression.new(:OR, *ces)
+      end
+    end
+
     # Represents an SQL array access, with multiple possible arguments.
-    class Subscript < Expression
+    class Subscript < GenericExpression
       # The SQL array column
       attr_reader :f
 
@@ -496,6 +735,7 @@ module Sequel
   # LiteralStrings can use all of the SQL::ColumnMethods and the 
   # SQL::ComplexExpressionMethods.
   class LiteralString < ::String
+    include SQL::OrderMethods
     include SQL::ComplexExpressionMethods
   end
 end