sequel_core 2.0.0 → 2.0.1

data/CHANGELOG

@@ -1,3 +1,17 @@
+=== 2.0.1 (2008-06-04)
+
+* Have PostgreSQL money type use BigDecimal instead of Float (jeremyevans)
+
+* Have the PostgreSQL and MySQL adapters use the Sequel.time_class setting for datetime/timestamp types (jeremyevans)
+
+* Add Sequel.time_class and String#to_sequel_time, used for converting time values from the database to either Time (default) or DateTime (jeremyevans)
+
+* Make identifier quoting uppercase by default, to work better with the SQL standard, override in PostgreSQL (jeremyevans) (#232)
+
+* Add StringExpression#+, for simple SQL string concatenation (:x.sql_string + :y) (jeremyevans)
+
+* Refactor ComplexExpression into three subclasses and a few modules, so operators that don't make sense are not defined for the class (jeremyevans)
+
 === 2.0.0 (2008-06-01)
 
 * Refactor String inflection support, you must use String.inflections instead of Inflector.inflections now (jeremyevans)

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "2.0.0"
+VERS = "2.0.1"
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
   'Sequel: The Database Toolkit for Ruby: Core Library and Adapters', \

data/lib/sequel_core/adapters/mysql.rb

@@ -10,12 +10,12 @@ class Mysql::Result
     4   => :to_f,     # MYSQL_TYPE_FLOAT
     5   => :to_f,     # MYSQL_TYPE_DOUBLE
     # 6   => ??,        # MYSQL_TYPE_NULL
-    7   => :to_time,  # MYSQL_TYPE_TIMESTAMP
+    7   => :to_sequel_time,  # MYSQL_TYPE_TIMESTAMP
     8   => :to_i,     # MYSQL_TYPE_LONGLONG
     9   => :to_i,     # MYSQL_TYPE_INT24
     10  => :to_date,  # MYSQL_TYPE_DATE
     11  => :to_time,  # MYSQL_TYPE_TIME
-    12  => :to_time,  # MYSQL_TYPE_DATETIME
+    12  => :to_sequel_time,  # MYSQL_TYPE_DATETIME
     13  => :to_i,     # MYSQL_TYPE_YEAR
     14  => :to_date,  # MYSQL_TYPE_NEWDATE
     # 15  => :to_s      # MYSQL_TYPE_VARCHAR
@@ -268,7 +268,7 @@ module Sequel
       def schema_ds_filter(table_name, opts)
         filt = super
         # Restrict it to the given or current database, unless specifically requesting :database = nil
-        filt = SQL::ComplexExpression.new(:AND, filt, {:c__table_schema=>opts[:database] || self.opts[:database]}) if opts[:database] || !opts.include?(:database)
+        filt = SQL::BooleanExpression.new(:AND, filt, {:c__table_schema=>opts[:database] || self.opts[:database]}) if opts[:database] || !opts.include?(:database)
         filt
       end
 
@@ -360,10 +360,8 @@ module Sequel
 
       def complex_expression_sql(op, args)
         case op
-        when :~, :'!~'
-          "#{'NOT ' if op == :'!~'}(#{literal(args.at(0))} REGEXP BINARY #{literal(args.at(1))})"
-        when :'~*', :'!~*'
-          "#{'NOT ' if op == :'!~*'}(#{literal(args.at(0))} REGEXP #{literal(args.at(1))})"
+        when :~, :'!~', :'~*', :'!~*', :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
+          "(#{literal(args.at(0))} #{'NOT ' if [:'NOT LIKE', :'NOT ILIKE', :'!~', :'!~*'].include?(op)}#{[:~, :'!~', :'~*', :'!~*'].include?(op) ? 'REGEXP' : 'LIKE'} #{'BINARY ' if [:~, :'!~', :LIKE, :'NOT LIKE'].include?(op)}#{literal(args.at(1))})"
         when :'||'
           if args.length > 1
             "CONCAT(#{args.collect{|a| literal(a)}.join(', ')})"

data/lib/sequel_core/adapters/postgres.rb

@@ -159,21 +159,22 @@ module Sequel
     end
 
     PG_TYPES = {
-      16 => lambda{ |s| Adapter.string_to_bool(s) },
-      17 => lambda{ |s| Adapter.unescape_bytea(s) },
-      20 => lambda{ |s| s.to_i },
-      21 => lambda{ |s| s.to_i },
-      22 => lambda{ |s| s.to_i },
-      23 => lambda{ |s| s.to_i },
-      26 => lambda{ |s| s.to_i },
-      700 => lambda{ |s| s.to_f },
-      701 => lambda{ |s| s.to_f },
-      790 => lambda{ |s| s.to_f },
-      1082 => lambda{ |s| s.to_date },
-      1083 => lambda{ |s| s.to_time },
-      1114 => lambda{ |s| s.to_time },
-      1184 => lambda{ |s| s.to_time },
-      1186 => lambda{ |s| s.to_i }
+      16 => lambda{ |s| Adapter.string_to_bool(s) }, # boolean
+      17 => lambda{ |s| Adapter.unescape_bytea(s) }, # bytea
+      20 => lambda{ |s| s.to_i }, # int8
+      21 => lambda{ |s| s.to_i }, # int2
+      22 => lambda{ |s| s.to_i }, # int2vector
+      23 => lambda{ |s| s.to_i }, # int4
+      26 => lambda{ |s| s.to_i }, # oid
+      700 => lambda{ |s| s.to_f }, # float4
+      701 => lambda{ |s| s.to_f }, # float8
+      790 => lambda{ |s| s.to_d }, # money
+      1082 => lambda{ |s| s.to_date }, # date
+      1083 => lambda{ |s| s.to_time }, # time without time zone
+      1114 => lambda{ |s| s.to_sequel_time }, # timestamp without time zone
+      1184 => lambda{ |s| s.to_sequel_time }, # timestamp with time zone
+      1186 => lambda{ |s| s.to_i }, # interval
+      1266 => lambda{ |s| s.to_time } # time with time zone
     }
 
     if Adapter.respond_to?(:translate_results=)
@@ -365,12 +366,15 @@ module Sequel
       def schema_ds_filter(table_name, opts)
         filt = super
         # Restrict it to the given or public schema, unless specifically requesting :schema = nil
-        filt = SQL::ComplexExpression.new(:AND, filt, {:c__table_schema=>opts[:schema] || 'public'}) if opts[:schema] || !opts.include?(:schema)
+        filt = SQL::BooleanExpression.new(:AND, filt, {:c__table_schema=>opts[:schema] || 'public'}) if opts[:schema] || !opts.include?(:schema)
         filt
       end
     end
   
     class Dataset < Sequel::Dataset
+      def quoted_identifier(c)
+        "\"#{c}\""
+      end
       
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
 

data/lib/sequel_core/adapters/sqlite.rb

@@ -193,6 +193,18 @@ module Sequel
         end
       end
 
+      def complex_expression_sql(op, args)
+        case op
+        when :~, :'!~', :'~*', :'!~*'
+          raise Error, "SQLite does not support pattern matching via regular expressions"
+        when :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
+          # SQLite is case insensitive for ASCII, and non case sensitive for other character sets
+          "#{'NOT ' if [:'NOT LIKE', :'NOT ILIKE'].include?(op)}(#{literal(args.at(0))} LIKE #{literal(args.at(1))})"
+        else
+          super(op, args)
+        end
+      end
+
       def insert_sql(*values)
         if (values.size == 1) && values.first.is_a?(Sequel::Dataset)
           "INSERT INTO #{source_list(@opts[:from])} #{values.first.sql};"

data/lib/sequel_core/core_ext.rb

@@ -183,6 +183,16 @@ class String
     end
   end
 
+  # Converts a string into a Time or DateTime object, depending on the
+  # value of Sequel.time_class
+  def to_sequel_time
+    begin
+      Sequel.time_class.parse(self)
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid time value '#{self}' (#{e.message})"
+    end
+  end
+
   # Converts a string into a Time object.
   def to_time
     begin

data/lib/sequel_core/core_sql.rb

@@ -2,31 +2,31 @@
 # code.
 
 class Array
-  # Return a Sequel::SQL::ComplexExpression created from this array, not matching any of the
+  # Return a Sequel::SQL::BooleanExpression created from this array, not matching any of the
   # conditions.
   def ~
     sql_expr_if_all_two_pairs(:OR, true)
   end
 
-  # Return a Sequel::SQL::ComplexExpression created from this array, matching all of the
+  # Return a Sequel::SQL::BooleanExpression created from this array, matching all of the
   # conditions.
   def sql_expr
     sql_expr_if_all_two_pairs
   end
 
-  # Return a Sequel::SQL::ComplexExpression created from this array, matching none
+  # Return a Sequel::SQL::BooleanExpression created from this array, matching none
   # of the conditions.
   def sql_negate
     sql_expr_if_all_two_pairs(:AND, true)
   end
 
-  # Return a Sequel::SQL::ComplexExpression created from this array, matching any of the
+  # Return a Sequel::SQL::BooleanExpression created from this array, matching any of the
   # conditions.
   def sql_or
     sql_expr_if_all_two_pairs(:OR)
   end
 
-  # Return a Sequel::SQL::ComplexExpression representing an SQL string made up of the
+  # Return a Sequel::SQL::BooleanExpression representing an SQL string made up of the
   # concatenation of this array's elements.  If an argument is passed
   # it is used in between each element of the array in the SQL
   # concatenation.
@@ -41,7 +41,7 @@ class Array
       args = self
     end
     args = args.collect{|a| a.is_one_of?(Symbol, ::Sequel::SQL::Expression, ::Sequel::LiteralString, TrueClass, FalseClass, NilClass) ? a : a.to_s}
-    ::Sequel::SQL::ComplexExpression.new(:'||', *args)
+    ::Sequel::SQL::StringExpression.new(:'||', *args)
   end
 
   # Concatenates an array of strings into an SQL string. ANSI SQL and C-style
@@ -53,50 +53,50 @@ class Array
 
   private
 
-  # Raise an error if this array is not made up of all two pairs, otherwise create a Sequel::SQL::ComplexExpression from this array.
+  # Raise an error if this array is not made up of all two pairs, otherwise create a Sequel::SQL::BooleanExpression from this array.
   def sql_expr_if_all_two_pairs(*args)
     raise(Sequel::Error, 'Not all elements of the array are arrays of size 2, so it cannot be converted to an SQL expression') unless all_two_pairs?
-    ::Sequel::SQL::ComplexExpression.from_value_pairs(self, *args)
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, *args)
   end
 end
 
 class Hash
-  # Return a Sequel::SQL::ComplexExpression created from this hash, matching
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching
   # all of the conditions in this hash and the condition specified by
   # the given argument.
   def &(ce)
-    ::Sequel::SQL::ComplexExpression.new(:AND, self, ce)
+    ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
   end
 
-  # Return a Sequel::SQL::ComplexExpression created from this hash, matching
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching
   # all of the conditions in this hash or the condition specified by
   # the given argument.
   def |(ce)
-    ::Sequel::SQL::ComplexExpression.new(:OR, self, ce)
+    ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
   end
 
-  # Return a Sequel::SQL::ComplexExpression created from this hash, not matching any of the
+  # Return a Sequel::SQL::BooleanExpression created from this hash, not matching any of the
   # conditions.
   def ~
-    ::Sequel::SQL::ComplexExpression.from_value_pairs(self, :OR, true)
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
   end
 
-  # Return a Sequel::SQL::ComplexExpression created from this hash, matching all of the
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching all of the
   # conditions.
   def sql_expr
-    ::Sequel::SQL::ComplexExpression.from_value_pairs(self)
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
   end
 
-  # Return a Sequel::SQL::ComplexExpression created from this hash, matching none
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching none
   # of the conditions.
   def sql_negate
-    ::Sequel::SQL::ComplexExpression.from_value_pairs(self, :AND, true)
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
   end
 
-  # Return a Sequel::SQL::ComplexExpression created from this hash, matching any of the
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching any of the
   # conditions.
   def sql_or
-    ::Sequel::SQL::ComplexExpression.from_value_pairs(self, :OR)
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
   end
 end
 
@@ -136,7 +136,7 @@ class Symbol
 
   # If no argument is given, returns a Sequel::SQL::ColumnAll object specifying all
   # columns for this table.
-  # If an argument is given, returns a Sequel::SQL::ComplexExpression using the *
+  # If an argument is given, returns a Sequel::SQL::NumericExpression using the *
   # (multiplication) operator with this and the given argument.
   def *(ce=(arg=false;nil))
     return super(ce) unless arg == false
@@ -151,7 +151,7 @@ class Symbol
 
   # If the given argument is an Integer or an array containing an Integer, returns
   # a Sequel::SQL::Subscript with this column and the given arg.
-  # Otherwise returns a Sequel::SQL::ComplexExpression where this column (which should be boolean)
+  # Otherwise returns a Sequel::SQL::BooleanExpression where this column (which should be boolean)
   # or the given argument is true.
   def |(sub)
     return super unless (Integer === sub) || ((Array === sub) && sub.any?{|x| Integer === x})

data/lib/sequel_core/database.rb

@@ -396,18 +396,24 @@ module Sequel
         else
           raise ArgumentError, "invalid value for Date: #{value.inspect}"
         end
-      when :datetime
+      when :time
         case value
-        when DateTime
-          value
-        when Date
-          DateTime.new(value.year, value.month, value.day)
         when Time
-          DateTime.new(value.year, value.month, value.day, value.hour, value.min, value.sec)
+          value
         when String
-          value.to_datetime
+          value.to_time
+        else
+          raise ArgumentError, "invalid value for Time: #{value.inspect}"
+        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
+          # Already the correct class, no need to convert
+          value
         else
-          raise ArgumentError, "invalid value for DateTime: #{value.inspect}"
+          # First convert it to standard ISO 8601 time, then
+          # parse that string using the time class.
+          (Time === value ? value.iso8601 : value.to_s).to_sequel_time
         end
       else
         value

data/lib/sequel_core/dataset/sql.rb

@@ -52,6 +52,8 @@ module Sequel
         "(#{args.collect{|a| literal(a)}.join(" #{op} ")})"
       when :NOT
         "NOT #{literal(args.at(0))}"
+      when :NOOP
+        literal(args.at(0))
       else
         raise(Sequel::Error, "invalid operator #{op}")
       end
@@ -107,8 +109,8 @@ module Sequel
       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 = SQL::ComplexExpression === cond ? ~cond : SQL::ComplexExpression.new(:NOT, cond)
-      cond = SQL::ComplexExpression.new(:AND, @opts[clause], cond) if @opts[clause]
+      cond = SQL::BooleanExpression.invert(cond)
+      cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause]
       clone(clause => cond)
     end
 
@@ -135,7 +137,7 @@ module Sequel
     #     specified.
     # * String - taken literally
     # * Symbol - taken as a boolean column argument (e.g. WHERE active)
-    # * Sequel::SQL::ComplexExpression - an existing condition expression,
+    # * Sequel::SQL::BooleanExpression - an existing condition expression,
     #   probably created using the Sequel blockless filter DSL.
     #
     # filter also takes a block, but use of this is discouraged as it requires
@@ -169,7 +171,7 @@ module Sequel
       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 = SQL::ComplexExpression.new(:AND, @opts[clause], cond) if @opts[clause] && !@opts[clause].blank?
+      cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause] && !@opts[clause].blank?
       clone(clause => cond)
     end
     alias_method :where, :filter
@@ -215,11 +217,11 @@ module Sequel
 
     # 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::ComplexExpression.like.  Note that the
+    # 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.
     def grep(cols, terms)
-      filter(SQL::ComplexExpression.new(:OR, *Array(cols).collect{|c| SQL::ComplexExpression.like(c, *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 
@@ -312,12 +314,8 @@ module Sequel
       having, where = @opts[:having], @opts[:where]
       raise(Error, "No current filter") unless having || where
       o = {}
-      if having
-        o[:having] = SQL::ComplexExpression === having ? ~having : SQL::ComplexExpression.new(:NOT, having)
-      end
-      if where
-        o[:where] = SQL::ComplexExpression === where ? ~where : SQL::ComplexExpression.new(:NOT, where)
-      end
+      o[:having] = SQL::BooleanExpression.invert(having) if having
+      o[:where] = SQL::BooleanExpression.invert(where) if where
       clone(o)
     end
 
@@ -451,7 +449,7 @@ module Sequel
       clause = (@opts[:having] ? :having : :where)
       cond = cond.first if cond.size == 1
       if @opts[clause]
-        clone(clause => SQL::ComplexExpression.new(:OR, @opts[clause], filter_expr(block || cond)))
+        clone(clause => SQL::BooleanExpression.new(:OR, @opts[clause], filter_expr(block || cond)))
       else
         raise Error::NoExistingFilter, "No existing filter found."
       end
@@ -494,11 +492,17 @@ module Sequel
     end
     alias_method :quote_column_ref, :quote_identifier
 
-    # This method quotes the given name with the SQL standard double quote. It
+    # This method quotes the given name with the SQL standard double quote. 
+    # It uppercases the name given to conform with the SQL standard. This
     # should be overridden by subclasses to provide quoting not matching the
-    # SQL standard, such as backtick (used by MySQL and SQLite). 
+    # SQL standard, such as backtick (used by MySQL and SQLite), or where
+    # lowercase is the default for unquoted identifiers (PostgreSQL).
+    #
+    # If you are using a database such as Oracle that defaults to uppercase
+    # but you are using lower case identifiers, you should override this
+    # method to not upcase the name for those identifiers.
     def quoted_identifier(name)
-      "\"#{name}\""
+      "\"#{name.to_s.upcase}\""
     end
 
     # Returns a copy of the dataset with the order reversed. If no order is
@@ -710,21 +714,23 @@ module Sequel
     def filter_expr(expr)
       case expr
       when Hash
-        SQL::ComplexExpression.from_value_pairs(expr)
+        SQL::BooleanExpression.from_value_pairs(expr)
       when Array
         if String === expr[0]
           filter_expr(expr.shift.gsub(QUESTION_MARK){literal(expr.shift)}.lit)
         else
-          SQL::ComplexExpression.from_value_pairs(expr)
+          SQL::BooleanExpression.from_value_pairs(expr)
         end
       when Proc
         expr.to_sql(self).lit
+      when SQL::NumericExpression, SQL::StringExpression
+        raise(Error, "Invalid SQL Expression type: #{expr.inspect}") 
       when Symbol, SQL::Expression
         expr
       when String
         "(#{expr})".lit
       else
-        raise(Sequel::Error, 'Invalid filter argument')
+        raise(Error, 'Invalid filter argument')
       end
     end
 

data/lib/sequel_core/schema/sql.rb

@@ -231,10 +231,12 @@ module Sequel
           :integer
         when /\A(character( varying)?|varchar|text)\z/
           :string
-        when /\A(date)\z/
+        when /\Adate\z/
           :date
-        when /\A(datetime|time|timestamp( with(out)? time zone)?)\z/
+        when /\A(datetime|timestamp( with(out)? time zone)?)\z/
           :datetime
+        when /\Atime( with(out)? time zone)?\z/
+          :time
         when /\A(boolean|tinyint)\z/
           :boolean
         when /\A(real|float|double( precision)?)\z/

data/lib/sequel_core/sql.rb

@@ -6,11 +6,38 @@ module Sequel
   # It also holds modules that are included in core ruby classes that
   # make Sequel a friendly DSL.
   module SQL
-    
-    ### Classes ###
+    # 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
 
+      # 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
@@ -67,52 +94,44 @@ module Sequel
     # a tree).  This class is the backbone of the blockless filter support in
     # Sequel.
     #
-    # Most ruby operators methods are defined via metaprogramming: +, -, /, *, <, >, <=,
-    # >=, & (AND), | (OR). This allows for a simple DSL after some core
-    # classes have been overloaded with ComplexExpressionMethods.
+    # This is an abstract class that is not that useful by itself.  The
+    # subclasses BooleanExpression, NumericExpression, and StringExpression
+    # define the behavior of the DSL via operators.
     class ComplexExpression < Expression
-      # A hash of the opposite for each operator symbol, used for inverting 
+      # A hash of the opposite for each operator symbol, used for inverting
       # objects.
       OPERTATOR_INVERSIONS = {:AND => :OR, :OR => :AND, :< => :>=, :> => :<=,
         :<= => :>, :>= => :<, :'=' => :'!=' , :'!=' => :'=', :LIKE => :'NOT LIKE',
         :'NOT LIKE' => :LIKE, :~ => :'!~', :'!~' => :~, :IN => :'NOT IN',
         :'NOT IN' => :IN, :IS => :'IS NOT', :'IS NOT' => :IS, :'~*' => :'!~*',
-        :'!~*' => :'~*'}
+        :'!~*' => :'~*', :NOT => :NOOP, :NOOP => :NOT, :ILIKE => :'NOT ILIKE',
+        :'NOT ILIKE'=>:ILIKE}
 
+      # Mathematical Operators used in NumericMethods
       MATHEMATICAL_OPERATORS = [:+, :-, :/, :*]
-      INEQUALITY_OPERATORS = [:<, :>, :<=, :>=]
-      STRING_OPERATORS = [:'||']
-      SEARCH_OPERATORS = [:LIKE, :'NOT LIKE', :~, :'!~', :'~*', :'!~*']
-      INCLUSION_OPERATORS = [:IN, :'NOT IN']
-      BOOLEAN_OPERATORS = [:AND, :OR]
-
-      # Collection of all equality/inequality operator symbols
-      EQUALITY_OPERATORS = [:'=', :'!=', :IS, :'IS NOT', *INEQUALITY_OPERATORS]
-
-      # Operator symbols that do not work on boolean SQL input
-      NO_BOOLEAN_INPUT_OPERATORS = MATHEMATICAL_OPERATORS + INEQUALITY_OPERATORS + STRING_OPERATORS
 
-      # Operator symbols that result in boolean SQL output
-      BOOLEAN_RESULT_OPERATORS = BOOLEAN_OPERATORS + EQUALITY_OPERATORS + SEARCH_OPERATORS + INCLUSION_OPERATORS + [:NOT]
-
-      # Literal SQL booleans that are not allowed
-      BOOLEAN_LITERALS = [true, false, nil]
+      # Inequality Operators used in InequalityMethods
+      INEQUALITY_OPERATORS = [:<, :>, :<=, :>=]
 
-      # Hash of ruby operator symbols to SQL operators, used for method creation
+      # Hash of ruby operator symbols to SQL operators, used in BooleanMethods
       BOOLEAN_OPERATOR_METHODS = {:& => :AND, :| =>:OR}
 
       # Operator symbols that take exactly two arguments
-      TWO_ARITY_OPERATORS = EQUALITY_OPERATORS + SEARCH_OPERATORS + INCLUSION_OPERATORS
+      TWO_ARITY_OPERATORS = [:'=', :'!=', :IS, :'IS NOT', :LIKE, :'NOT LIKE', \
+        :~, :'!~', :'~*', :'!~*', :IN, :'NOT IN', :ILIKE, :'NOT ILIKE'] + INEQUALITY_OPERATORS
 
       # Operator symbols that take one or more arguments
-      N_ARITY_OPERATORS = MATHEMATICAL_OPERATORS + BOOLEAN_OPERATORS + STRING_OPERATORS
+      N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS
+
+      # Operator symbols that take one argument
+      ONE_ARITY_OPERATORS = [:NOT, :NOOP]
 
       # An array of args for this object
       attr_reader :args
 
       # The operator symbol for this object
       attr_reader :op
-
+      
       # Set the operator symbol and arguments for this object to the ones given.
       # Convert all args that are hashes or arrays with all two pairs to ComplexExpressions.
       # Raise an error if the operator doesn't allow boolean input and a boolean argument is given.
@@ -128,31 +147,184 @@ module Sequel
             a
           end
         end
-        if NO_BOOLEAN_INPUT_OPERATORS.include?(op)
-          args.each do |a|
-            if BOOLEAN_LITERALS.include?(a) || ((ComplexExpression === a) && BOOLEAN_RESULT_OPERATORS.include?(a.op))
-              raise(Sequel::Error, "cannot apply #{op} to a boolean expression")
-            end
-          end
-        end
         case op
         when *N_ARITY_OPERATORS
-          raise(Sequel::Error, 'mathematical and boolean operators require at least 1 argument') unless args.length >= 1
+          raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
         when *TWO_ARITY_OPERATORS
-          raise(Sequel::Error, '(in)equality operators require precisely 2 arguments') unless args.length == 2
-        when :NOT
-          raise(Sequel::Error, 'the NOT operator requires a single argument') unless args.length == 1
+          raise(Error, "The #{op} operator requires precisely 2 arguments") unless args.length == 2
+        when *ONE_ARITY_OPERATORS
+          raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
         else
-          raise(Sequel::Error, "invalid operator #{op}")
+          raise(Error, "Invalid operator #{op}")
         end
         @op = op
         @args = args
       end
+      
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.complex_expression_sql(@op, @args)
+      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).
+    #
+    # This defines the ~ (NOT), & (AND), and | (OR) methods.
+    module BooleanMethods
+      # Create a new BooleanExpression with NOT, representing the inversion of whatever self represents.
+      def ~
+        BooleanExpression.invert(self)
+      end
+      
+      ComplexExpression::BOOLEAN_OPERATOR_METHODS.each do |m, o|
+        define_method(m) do |ce|
+          case ce
+          when BooleanExpression
+            BooleanExpression.new(o, self, ce)
+          when ComplexExpression
+            raise(Sequel::Error, "cannot apply #{o} to a non-boolean expression")
+          else  
+            BooleanExpression.new(o, self, ce)
+          end
+        end
+      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).
+    #
+    # This defines the +, -, *, and / methods.
+    module NumericMethods
+      ComplexExpression::MATHEMATICAL_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
+    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).
+    #
+    # This defines the like (LIKE) method, used for pattern matching.
+    module StringMethods
+      # Create a BooleanExpression case insensitive pattern match of self
+      # with the given patterns.  See StringExpression.like.
+      def ilike(*ces)
+        StringExpression.like(self, *(ces << {:case_insensitive=>true}))
+      end
+
+      # Create a BooleanExpression case sensitive pattern match of self with
+      # the given patterns.  See StringExpression.like.
+      def like(*ces)
+        StringExpression.like(self, *ces)
+      end
+    end
+
+    # This module is included in StringExpression and can be included elsewhere
+    # to allow the use of the + operator to represent concatenation of SQL
+    # Strings:
+    #
+    #   :x.sql_string + :y => # SQL: x || y
+    module StringConcatenationMethods
+      def +(ce)
+        StringExpression.new(:'||', self, ce)
+      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 other Sequel::SQL::*Methods modules and is
+    # included in other classes that are could be either booleans,
+    # strings, or numbers.  It also adds three methods so that
+    # can specify behavior in case one of the operator methods has
+    # been overridden (such as Symbol#/).
+    #
+    # For example, if Symbol#/ is overridden to produce a string (for
+    # example, to make file system path creation easier), the
+    # following code will not do what you want:
+    #
+    #   :price/10 > 100
+    #
+    # In that case, you need to do the following:
+    #
+    #   :price.sql_number/10 > 100
+    module ComplexExpressionMethods
+      include BooleanMethods
+      include NumericMethods
+      include StringMethods
+      include InequalityMethods
+
+      # Return a BooleanExpression representation of self.
+      def sql_boolean
+        BooleanExpression.new(:NOOP, self)
+      end
 
+      # Return a NumericExpression representation of self.
+      def sql_number
+        NumericExpression.new(:NOOP, self)
+      end
+
+      # Return a StringExpression representation of self.
+      def sql_string
+        StringExpression.new(:NOOP, self)
+      end
+    end
+
+    # Subclass of ComplexExpression where the expression results
+    # in a boolean value in SQL.
+    class BooleanExpression < ComplexExpression
+      include BooleanMethods
+      
       # Take pairs of values (e.g. a hash or array of arrays of two pairs)
       # and converts it to a ComplexExpression.  The operator and args
       # used depends on the case of the right (2nd) argument:
-      # 
+      #
       # * 0..10 - left >= 0 AND left <= 10
       # * [1,2] - left IN (1,2)
       # * nil - left IS NULL
@@ -177,15 +349,51 @@ module Sequel
           when NilClass
             new(:IS, l, r)
           when Regexp
-            like(l, r)
+            StringExpression.like(l, r)
           else
             new(:'=', l, r)
           end
-          negate ? ~ce : ce
+          negate ? invert(ce) : ce
         end
         pairs.length == 1 ? pairs.at(0) : new(op, *pairs)
       end
+      
+      # Invert the expression, if possible.  If the expression cannot
+      # be inverted, raise an error.  An inverted expression should match everything that the
+      # uninverted expression did not match, and vice-versa.
+      def self.invert(ce)
+        case ce
+        when BooleanExpression
+          case op = ce.op
+          when :AND, :OR
+            BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.collect{|a| BooleanExpression.invert(a)})
+          else
+            BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+          end
+        when ComplexExpression
+          raise(Sequel::Error, "operator #{ce.op} cannot be inverted")
+        else
+          BooleanExpression.new(:NOT, ce)
+        end
+      end
+    end
+
+    # Subclass of ComplexExpression where the expression results
+    # in a numeric value in SQL.
+    class NumericExpression < ComplexExpression
+      include NumericMethods
+      include InequalityMethods
+      include NoBooleanInputMethods
+    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
@@ -193,55 +401,26 @@ module Sequel
       # 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 
+      # 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)
-        ces.collect! do |ce| 
-          op, expr = Regexp === ce ? [ce.casefold? ? :'~*' : :~, ce.source] : [:LIKE, ce.to_s]
-          new(op, l, expr)
-        end
-        ces.length == 1 ? ces.at(0) : new(:OR, *ces)
-      end
-
-      # Invert the regular expression, if possible.  If the expression cannot
-      # be inverted, raise an error.  An inverted expression should match everything that the
-      # uninverted expression did not match, and vice-versa.
-      def ~
-        case @op
-        when *BOOLEAN_OPERATORS
-          self.class.new(OPERTATOR_INVERSIONS[@op], *@args.collect{|a| ComplexExpression === a ? ~a : ComplexExpression.new(:NOT, a)})
-        when *TWO_ARITY_OPERATORS
-          self.class.new(OPERTATOR_INVERSIONS[@op], *@args.dup)
-        when :NOT
-          @args.first
-        else
-          raise(Sequel::Error, "operator #{@op} cannot be inverted")
-        end
-      end
-
-      # Delegate the creation of the resulting SQL to the given dataset,
-      # since it may be database dependent.
-      def to_s(ds)
-        ds.complex_expression_sql(@op, @args)
-      end
-
-      BOOLEAN_OPERATOR_METHODS.each do |m, o|
-        define_method(m) do |ce|
-          raise(Sequel::Error, "cannot apply #{o} to a non-boolean expression") unless BOOLEAN_RESULT_OPERATORS.include?(@op)
-          super
-        end
-      end
-
-      (MATHEMATICAL_OPERATORS + INEQUALITY_OPERATORS).each do |o|
-        define_method(o) do |ce|
-          raise(Sequel::Error, "cannot apply #{o} to a boolean expression") unless NO_BOOLEAN_INPUT_OPERATORS.include?(@op)
-          super
+        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 function call.
     class Function < Expression
+      include ComplexExpressionMethods
       # The array of arguments to pass to the function (may be blank)
       attr_reader :args
 
@@ -309,78 +488,6 @@ module Sequel
         ds.subscript_sql(self)
       end
     end
-
-    ### Modules ###
-    
-    # Module included in core classes giving them a simple and easy DSL
-    # for creation of ComplexExpressions.
-    #
-    # Most ruby operators methods are defined via metaprogramming: +, -, /, *, <, >, <=,
-    # >=, & (AND), | (OR). 
-    module ComplexExpressionMethods
-      NO_BOOLEAN_INPUT_OPERATORS = ComplexExpression::NO_BOOLEAN_INPUT_OPERATORS
-      BOOLEAN_RESULT_OPERATORS = ComplexExpression::BOOLEAN_RESULT_OPERATORS
-      BOOLEAN_OPERATOR_METHODS = ComplexExpression::BOOLEAN_OPERATOR_METHODS
-
-      BOOLEAN_OPERATOR_METHODS.each do |m, o|
-        define_method(m) do |ce|
-          raise(Sequel::Error, "cannot apply #{o} to a non-boolean expression") if (ComplexExpression === ce) && !BOOLEAN_RESULT_OPERATORS.include?(ce.op)
-          ComplexExpression.new(o, self, ce)   
-        end
-      end
-
-      (ComplexExpression::MATHEMATICAL_OPERATORS + ComplexExpression::INEQUALITY_OPERATORS).each do |o|
-        define_method(o) do |ce|
-          raise(Sequel::Error, "cannot apply #{o} to a boolean expression") if (ComplexExpression === ce) && !NO_BOOLEAN_INPUT_OPERATORS.include?(ce.op)
-          ComplexExpression.new(o, self, ce)   
-        end
-      end
-
-      # Create a new ComplexExpression with NOT, representing the inversion of whatever self represents.
-      def ~
-        ComplexExpression.new(:NOT, self)
-      end
-
-      # Create a ComplexExpression pattern match of self with the given patterns.
-      def like(*ces)
-        ComplexExpression.like(self, *ces)
-      end
-    end
-
-    # 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
-
-      # 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
-
-    class Expression
-      # Include the modules in Expression, couldn't be done
-      # earlier due to cyclic dependencies.
-      include ColumnMethods
-      include ComplexExpressionMethods
-    end
   end
 
   # LiteralString is used to represent literal SQL expressions. An 

data/lib/sequel_core.rb

@@ -21,7 +21,15 @@ end
 # object, which is closed when the block exits.  For example:
 #
 #   Sequel.sqlite('blog.db'){|db| puts db.users.count}  
+#
+# Sequel can use either Time or DateTime for times returned from the
+# database.  It defaults to Time.  To change it to DateTime, use:
+#
+#   Sequel.time_class = DateTime
 module Sequel
+  @time_class = Time
+  metaattr_accessor :time_class
+
   # Creates a new database object based on the supplied connection string
   # and optional arguments.  The specified scheme determines the database
   # class used, and the rest of the string specifies the connection options.

data/spec/adapters/mysql_spec.rb

@@ -713,14 +713,15 @@ context "MySQL::Dataset#complex_expression_sql" do
     @d = MYSQL_DB.dataset
   end
 
-  specify "should handle case insensitive regular expressions with REGEXP" do
-    @d.literal(:x.like(/a/i)).should == "(x REGEXP 'a')"
-    @d.literal(~:x.like(/a/i)).should == "NOT (x REGEXP 'a')"
-  end
-
-  specify "should handle case sensitive regular expressions with REGEXP BINARY" do
+  specify "should handle pattern matches correctly" do
+    @d.literal(:x.like('a')).should == "(x LIKE BINARY 'a')"
+    @d.literal(~:x.like('a')).should == "(x NOT LIKE BINARY 'a')"
+    @d.literal(:x.ilike('a')).should == "(x LIKE 'a')"
+    @d.literal(~:x.ilike('a')).should == "(x NOT LIKE 'a')"
     @d.literal(:x.like(/a/)).should == "(x REGEXP BINARY 'a')"
-    @d.literal(~:x.like(/a/)).should == "NOT (x REGEXP BINARY 'a')"
+    @d.literal(~:x.like(/a/)).should == "(x NOT REGEXP BINARY 'a')"
+    @d.literal(:x.like(/a/i)).should == "(x REGEXP 'a')"
+    @d.literal(~:x.like(/a/i)).should == "(x NOT REGEXP 'a')"
   end
 
   specify "should handle string concatenation with CONCAT if more than one record" do

data/spec/adapters/sqlite_spec.rb

@@ -256,6 +256,20 @@ context "An SQLite dataset" do
     @d.count.should == 1
     @d.first[:name].should == 'def'
   end
+
+  specify "should handle string pattern matches correctly" do
+    @d.literal(:x.like('a')).should == "(x LIKE 'a')"
+    @d.literal(~:x.like('a')).should == "NOT (x LIKE 'a')"
+    @d.literal(:x.ilike('a')).should == "(x LIKE 'a')"
+    @d.literal(~:x.ilike('a')).should == "NOT (x LIKE 'a')"
+  end
+
+  specify "should raise errors if given a regexp pattern match" do
+    proc{@d.literal(:x.like(/a/))}.should raise_error(Sequel::Error)
+    proc{@d.literal(~:x.like(/a/))}.should raise_error(Sequel::Error)
+    proc{@d.literal(:x.like(/a/i))}.should raise_error(Sequel::Error)
+    proc{@d.literal(~:x.like(/a/i))}.should raise_error(Sequel::Error)
+  end
 end
 
 context "An SQLite dataset" do
@@ -356,38 +370,32 @@ context "SQLite dataset" do
   end
 end
 
-__END__
-
 context "A SQLite database" do
   setup do
     @db = SQLITE_DB
+    @db.create_table! :test2 do
+      text :name
+      integer :value
+    end
   end
 
   specify "should support add_column operations" do
     @db.add_column :test2, :xyz, :text
     
     @db[:test2].columns.should == [:name, :value, :xyz]
-    @db[:test2] << {:name => 'mmm', :value => 111}
-    @db[:test2].first[:xyz].should == '000'
+    @db[:test2] << {:name => 'mmm', :value => 111, :xyz=>'000'}
+    @db[:test2].first.should == {:name => 'mmm', :value => 111, :xyz=>'000'}
   end
   
   specify "should not support drop_column operations" do
-    proc {@db.drop_column :test2, :xyz}.should raise_error(Sequel::Error)
+    proc {@db.drop_column :test2, :value}.should raise_error(Sequel::Error)
   end
   
   specify "should not support rename_column operations" do
-    @db[:test2].delete
-    @db.add_column :test2, :xyz, :text, :default => '000'
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
-
-    @db[:test2].columns.should == [:name, :value, :xyz]
-    proc {@db.rename_column :test2, :xyz, :zyx}.should raise_error(Sequel::Error)
+    proc {@db.rename_column :test2, :value, :zyx}.should raise_error(Sequel::Error)
   end
   
   specify "should not support set_column_type operations" do
-    @db.add_column :test2, :xyz, :float
-    @db[:test2].delete
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 56.78}
-    proc {@db.set_column_type :test2, :xyz, :integer}.should raise_error(Sequel::Error)
+    proc {@db.set_column_type :test2, :value, :integer}.should raise_error(Sequel::Error)
   end
 end  

data/spec/blockless_filters_spec.rb

@@ -8,6 +8,9 @@ context "Blockless Ruby Filters" do
     def @d.l(*args)
       literal(filter_expr(*args))
     end
+    def @d.lit(*args)
+      literal(*args)
+    end
   end
   
   it "should support boolean columns directly" do
@@ -81,7 +84,7 @@ context "Blockless Ruby Filters" do
     @d.l(:x.like('a')).should == '(x LIKE \'a\')'
     @d.l(:x.like(/a/)).should == '(x ~ \'a\')'
     @d.l(:x.like('a', 'b')).should == '((x LIKE \'a\') OR (x LIKE \'b\'))'
-    @d.l(:x.like(/a/, /b/)).should == '((x ~ \'a\') OR (x ~ \'b\'))'
+    @d.l(:x.like(/a/, /b/i)).should == '((x ~ \'a\') OR (x ~* \'b\'))'
     @d.l(:x.like('a', /b/)).should == '((x LIKE \'a\') OR (x ~ \'b\'))'
   end
 
@@ -89,10 +92,26 @@ context "Blockless Ruby Filters" do
     @d.l(~:x.like('a')).should == '(x NOT LIKE \'a\')'
     @d.l(~:x.like(/a/)).should == '(x !~ \'a\')'
     @d.l(~:x.like('a', 'b')).should == '((x NOT LIKE \'a\') AND (x NOT LIKE \'b\'))'
-    @d.l(~:x.like(/a/, /b/)).should == '((x !~ \'a\') AND (x !~ \'b\'))'
+    @d.l(~:x.like(/a/, /b/i)).should == '((x !~ \'a\') AND (x !~* \'b\'))'
     @d.l(~:x.like('a', /b/)).should == '((x NOT LIKE \'a\') AND (x !~ \'b\'))'
   end
 
+  it "should support ILIKE via Symbol#ilike" do
+    @d.l(:x.ilike('a')).should == '(x ILIKE \'a\')'
+    @d.l(:x.ilike(/a/)).should == '(x ~* \'a\')'
+    @d.l(:x.ilike('a', 'b')).should == '((x ILIKE \'a\') OR (x ILIKE \'b\'))'
+    @d.l(:x.ilike(/a/, /b/i)).should == '((x ~* \'a\') OR (x ~* \'b\'))'
+    @d.l(:x.ilike('a', /b/)).should == '((x ILIKE \'a\') OR (x ~* \'b\'))'
+  end
+
+  it "should support NOT ILIKE via Symbol#ilike and Symbol#~" do
+    @d.l(~:x.ilike('a')).should == '(x NOT ILIKE \'a\')'
+    @d.l(~:x.ilike(/a/)).should == '(x !~* \'a\')'
+    @d.l(~:x.ilike('a', 'b')).should == '((x NOT ILIKE \'a\') AND (x NOT ILIKE \'b\'))'
+    @d.l(~:x.ilike(/a/, /b/i)).should == '((x !~* \'a\') AND (x !~* \'b\'))'
+    @d.l(~:x.ilike('a', /b/)).should == '((x NOT ILIKE \'a\') AND (x !~* \'b\'))'
+  end
+
   it "should support negating ranges via Hash#~ and Range" do
     @d.l(~{:x => 1..5}).should == '((x < 1) OR (x > 5))'
     @d.l(~{:x => 1...5}).should == '((x < 1) OR (x >= 5))'
@@ -113,7 +132,10 @@ context "Blockless Ruby Filters" do
   
   it "should not allow negation of non-boolean expressions" do
     proc{~(:x + 1 > 100)}.should_not raise_error 
-    proc{~(:x + 1)}.should raise_error(Sequel::Error)
+    proc{~(:x + 1)}.should raise_error
+    proc{~:x.sql_string}.should raise_error
+    proc{~:x.sql_number}.should raise_error
+    proc{~([:x, :y].sql_string_join)}.should raise_error
   end
 
   it "should not allow mathematical, inequality, or string operations on true, false, or nil" do
@@ -189,7 +211,7 @@ context "Blockless Ruby Filters" do
   it "should support LiteralString" do
     @d.l('x'.lit).should == '(x)'
     @d.l(~'x'.lit).should == 'NOT x'
-    @d.l(~~'x'.lit).should == '(x)'
+    @d.l(~~'x'.lit).should == 'x'
     @d.l(~(('x'.lit | :y) & :z)).should == '((NOT x AND NOT y) OR NOT z)'
     @d.l(~(:x | 'y'.lit)).should == '(NOT x AND NOT y)'
     @d.l(~('x'.lit & 'y'.lit)).should == '(NOT x OR NOT y)'
@@ -253,17 +275,23 @@ context "Blockless Ruby Filters" do
   end
   
   it "should support Array#sql_string_join for concatenation of SQL strings" do
-    @d.l([:x].sql_string_join).should == '(x)'
-    @d.l([:x].sql_string_join(', ')).should == '(x)'
-    @d.l([:x, :y].sql_string_join).should == '(x || y)'
-    @d.l([:x, :y].sql_string_join(', ')).should == "(x || ', ' || y)"
-    @d.l([:x[1], :y|1].sql_string_join).should == '(x(1) || y[1])'
-    @d.l([:x[1], 'y.z'.lit].sql_string_join(', ')).should == "(x(1) || ', ' || y.z)"
-    @d.l([:x, 1, :y].sql_string_join).should == "(x || '1' || y)"
-    @d.l([:x, 1, :y].sql_string_join(', ')).should == "(x || ', ' || '1' || ', ' || y)"
-    @d.l([:x, 1, :y].sql_string_join(:y__z)).should == "(x || y.z || '1' || y.z || y)"
-    @d.l([:x, 1, :y].sql_string_join(1)).should == "(x || '1' || '1' || '1' || y)"
-    @d.l([:x, :y].sql_string_join('y.x || x.y'.lit)).should == "(x || y.x || x.y || y)"
-    @d.l([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).should == "((x || y) || (a || b))"
+    @d.lit([:x].sql_string_join).should == '(x)'
+    @d.lit([:x].sql_string_join(', ')).should == '(x)'
+    @d.lit([:x, :y].sql_string_join).should == '(x || y)'
+    @d.lit([:x, :y].sql_string_join(', ')).should == "(x || ', ' || y)"
+    @d.lit([:x[1], :y|1].sql_string_join).should == '(x(1) || y[1])'
+    @d.lit([:x[1], 'y.z'.lit].sql_string_join(', ')).should == "(x(1) || ', ' || y.z)"
+    @d.lit([:x, 1, :y].sql_string_join).should == "(x || '1' || y)"
+    @d.lit([:x, 1, :y].sql_string_join(', ')).should == "(x || ', ' || '1' || ', ' || y)"
+    @d.lit([:x, 1, :y].sql_string_join(:y__z)).should == "(x || y.z || '1' || y.z || y)"
+    @d.lit([:x, 1, :y].sql_string_join(1)).should == "(x || '1' || '1' || '1' || y)"
+    @d.lit([:x, :y].sql_string_join('y.x || x.y'.lit)).should == "(x || y.x || x.y || y)"
+    @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).should == "((x || y) || (a || b))"
+  end
+
+  it "should support StringExpression#+ for concatenation of SQL strings" do
+    @d.lit(:x.sql_string + :y).should == '(x || y)'
+    @d.lit([:x].sql_string_join + :y).should == '((x) || y)'
+    @d.lit([:x, :z].sql_string_join(' ') + :y).should == "((x || ' ' || z) || y)"
   end
 end

data/spec/core_sql_spec.rb

@@ -213,7 +213,7 @@ end
 
 context "Symbol#to_column_ref" do
   setup do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = MockDataset.new(nil)
   end
   
   specify "should convert qualified symbol notation into dot notation" do
@@ -305,6 +305,29 @@ context "String#to_datetime" do
   end
 end
 
+context "String#to_sequel_time" do
+  after do
+    Sequel.time_class = Time
+  end
+
+  specify "should convert the string into a Time object by default" do
+    "2007-07-11 10:11:12a".to_sequel_time.class.should == Time
+    "2007-07-11 10:11:12a".to_sequel_time.should == Time.parse("2007-07-11 10:11:12a")
+  end
+  
+  specify "should convert the string into a DateTime object if that is set" do
+    Sequel.time_class = DateTime
+    "2007-07-11 10:11:12a".to_sequel_time.class.should == DateTime
+    "2007-07-11 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a")
+  end
+  
+  specify "should raise Error::InvalidValue for an invalid time" do
+    proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::Error::InvalidValue)
+    Sequel.time_class = DateTime
+    proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::Error::InvalidValue)
+  end
+end
+
 context "Sequel::SQL::Function#==" do
   specify "should be true for functions with the same name and arguments, false otherwise" do
     a = :date[:t]

data/spec/dataset_spec.rb

@@ -1183,7 +1183,7 @@ end
 
 context "Dataset#join_table" do
   setup do
-    @d = Sequel::Dataset.new(nil).from(:items)
+    @d = MockDataset.new(nil).from(:items)
     @d.quote_identifiers = true
   end
   
@@ -1269,7 +1269,7 @@ context "Dataset#join_table" do
     @d.from('stats').join('players', {:id => :player_id}, 'p').sql.should ==
       'SELECT * FROM "stats" INNER JOIN "players" "p" ON ("p"."id" = "stats"."player_id")'
 
-    ds = Sequel::Dataset.new(nil).from(:foo => :f)
+    ds = MockDataset.new(nil).from(:foo => :f)
     ds.quote_identifiers = true
     ds.join_table(:inner, :bar, :id => :bar_id).sql.should ==
       'SELECT * FROM "foo" "f" INNER JOIN "bar" ON ("bar"."id" = "f"."bar_id")'

data/spec/spec_helper.rb

@@ -20,6 +20,10 @@ class MockDataset < Sequel::Dataset
     @db.execute(sql)
     yield({:id => 1, :x => 1})
   end
+
+  def quoted_identifier(c)
+    "\"#{c}\""
+  end
 end
 
 class MockDatabase < Sequel::Database

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_core
 version: !ruby/object:Gem::Version 
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-01 00:00:00 -07:00
+date: 2008-06-04 00:00:00 -07:00
 default_executable: 
 dependencies: []