sequel 3.3.0 → 3.4.0

data/lib/sequel/plugins/serialization.rb

@@ -31,9 +31,13 @@ module Sequel
 
       module ClassMethods
         # A map of the serialized columns for this model.  Keys are column
-        # symbols, values are serialization formats (:marshal or :yaml).
+        # symbols, values are serialization formats (:marshal, :yaml, or :json).
         attr_reader :serialization_map
 
+        # Module to store the serialized column accessor methods, so they can
+        # call be overridden and call super to get the serialization behavior
+        attr_accessor :serialization_module
+
         # Copy the serialization format and columns to serialize into the subclass.
         def inherited(subclass)
           super
@@ -51,22 +55,9 @@ module Sequel
         # and instance level writer that stores new deserialized value in deserialized
         # columns
         def serialize_attributes(format, *columns)
-          raise(Error, "Unsupported serialization format (#{format}), should be :marshal or :yaml") unless [:marshal, :yaml].include?(format)
+          raise(Error, "Unsupported serialization format (#{format}), should be :marshal, :yaml, or :json") unless [:marshal, :yaml, :json].include?(format)
           raise(Error, "No columns given.  The serialization plugin requires you specify which columns to serialize") if columns.empty?
-          columns.each do |column|
-            serialization_map[column] = format
-            define_method(column) do 
-              if deserialized_values.has_key?(column)
-                deserialized_values[column]
-              else
-                deserialized_values[column] = deserialize_value(column, @values[column])
-              end
-            end
-            define_method("#{column}=") do |v| 
-              changed_columns << column unless changed_columns.include?(column)
-              deserialized_values[column] = v
-            end
-          end
+          define_serialized_attribute_accessor(format, *columns)
         end
         
         # The columns that will be serialized.  This is only for
@@ -74,6 +65,30 @@ module Sequel
         def serialized_columns
           serialization_map.keys
         end
+
+        private
+
+        # Add serializated attribute acessor methods to the serialization_module
+        def define_serialized_attribute_accessor(format, *columns)
+          m = self
+          include(self.serialization_module ||= Module.new) unless serialization_module
+          serialization_module.class_eval do
+            columns.each do |column|
+              m.serialization_map[column] = format
+              define_method(column) do 
+                if deserialized_values.has_key?(column)
+                  deserialized_values[column]
+                else
+                  deserialized_values[column] = deserialize_value(column, super())
+                end
+              end
+              define_method("#{column}=") do |v| 
+                changed_columns << column unless changed_columns.include?(column)
+                deserialized_values[column] = v
+              end
+            end
+          end
+        end
       end
 
       module InstanceMethods
@@ -110,6 +125,8 @@ module Sequel
             Marshal.load(v.unpack('m')[0]) rescue Marshal.load(v)
           when :yaml
             YAML.load v if v
+          when :json
+            JSON.parse v if v
           else
             raise Error, "Bad serialization format (#{model.serialization_map[column].inspect}) for column #{column.inspect}"
           end
@@ -123,6 +140,8 @@ module Sequel
             [Marshal.dump(v)].pack('m')
           when :yaml
             v.to_yaml
+          when :json
+            JSON.generate v
           else
             raise Error, "Bad serialization format (#{model.serialization_map[column].inspect}) for column #{column.inspect}"
           end

data/lib/sequel/plugins/timestamps.rb

@@ -0,0 +1,87 @@
+module Sequel
+  module Plugins
+    # The timestamps plugin creates hooks that automatically set create and
+    # update timestamp fields.  Both field names used are configurable, and you 
+    # can also set whether to overwrite existing create timestamps (false
+    # by default), or whether to set the update timestamp when creating (also
+    # false by default).
+    module Timestamps
+      # Configure the plugin by setting the avialable options.  Note that
+      # if this method is run more than once, previous settings are ignored,
+      # and it will just use the settings given or the default settings.  Options:
+      # * :create - The field to hold the create timestamp (default: :created_at)
+      # * :force - Whether to overwrite an existing create timestamp (default: false)
+      # * :update - The field to hold the update timestamp (default: :updated_at)
+      # * :update_on_create - Whether to set the update timestamp to the create timestamp when creating (default: false)
+      def self.configure(model, opts={})
+        model.instance_eval do
+          @create_timestamp_field = opts[:create]||:created_at
+          @update_timestamp_field = opts[:update]||:updated_at
+          @create_timestamp_overwrite = opts[:force]||false
+          @set_update_timestamp_on_create = opts[:update_on_create]||false
+        end
+      end
+
+      module ClassMethods
+        # The field to store the create timestamp
+        attr_reader :create_timestamp_field
+
+        # The field to store the update timestamp
+        attr_reader :update_timestamp_field
+        
+        # Whether to overwrite the create timestamp if it already exists
+        def create_timestamp_overwrite?
+          @create_timestamp_overwrite
+        end
+        
+        # Copy the class instance variables used from the superclass to the subclass
+        def inherited(subclass)
+          super
+          [:@create_timestamp_field, :@update_timestamp_field, :@create_timestamp_overwrite, :@set_update_timestamp_on_create].each do |iv|
+            subclass.instance_variable_set(iv, instance_variable_get(iv))
+          end
+        end
+        
+        # Whether to set the update timestamp to the create timestamp when creating
+        def set_update_timestamp_on_create?
+          @set_update_timestamp_on_create
+        end
+      end
+
+      module InstanceMethods
+        # Set the create timestamp when creating
+        def before_create
+          super
+          set_create_timestamp
+        end
+        
+        # Set the update timestamp when updating
+        def before_update
+          super
+          set_update_timestamp
+        end
+        
+        private
+        
+        # If the object has accessor methods for the create timestamp field, and
+        # the create timestamp value is nil or overwriting it is allowed, set the
+        # create timestamp field to the time given or the current time.  If setting
+        # the update timestamp on creation is configured, set the update timestamp
+        # as well.
+        def set_create_timestamp(time=nil)
+          field = model.create_timestamp_field
+          meth = :"#{field}="
+          self.send(meth, time||=Sequel.datetime_class.now) if respond_to?(field) && respond_to?(meth) && (model.create_timestamp_overwrite? || send(field).nil?)
+          set_update_timestamp(time) if model.set_update_timestamp_on_create?
+        end
+        
+        # Set the update timestamp to the time given or the current time if the
+        # object has a setter method for the update timestamp field.
+        def set_update_timestamp(time=nil)
+          meth = :"#{model.update_timestamp_field}="
+          self.send(meth, time||Sequel.datetime_class.now) if respond_to?(meth)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_helpers.rb

@@ -117,11 +117,17 @@ module Sequel
         #   validates_unique(:column1, :column2)
         # validates them separately.
         #
+        # You can pass a block, which is yielded the dataset in which the columns
+        # must be unique. So if you are doing a soft delete of records, in which
+        # the name must be unique, but only for active records:
+        #
+        #   validates_unique(:name){|ds| ds.filter(:active)}
+        #
         # You should also add a unique index in the
         # database, as this suffers from a fairly obvious race condition.
         #
         # This validation does not respect the :allow_* options that the other validations accept,
-        # since it can deals with multiple attributes at once.
+        # since it can deal with a grouping of multiple attributes.
         #
         # Possible Options:
         # * :message - The message to use (default: 'is already taken')
@@ -129,6 +135,7 @@ module Sequel
           message = (atts.pop[:message] if atts.last.is_a?(Hash)) || 'is already taken'
           atts.each do |a|
             ds = model.filter(Array(a).map{|x| [x, send(x)]})
+            ds = yield(ds) if block_given?
             errors.add(a, message) unless (new? ? ds : ds.exclude(pk_hash)).count == 0
           end
         end

data/lib/sequel/sql.rb

@@ -540,6 +540,22 @@ module Sequel
 
       to_s_method :column_all_sql
     end
+    
+    # Represents constants or psuedo-constants (e.g. CURRENT_DATE) in SQL
+    class Constant < GenericExpression
+      # Create an object with the given table
+      def initialize(constant)
+        @constant = constant
+      end
+      
+      to_s_method :constant_sql, '@constant'
+    end
+    
+    module Constants
+      CURRENT_DATE = Constant.new(:CURRENT_DATE)
+      CURRENT_TIME = Constant.new(:CURRENT_TIME)
+      CURRENT_TIMESTAMP = Constant.new(:CURRENT_TIMESTAMP)
+    end
 
     # Represents an SQL function call.
     class Function < GenericExpression
@@ -675,6 +691,21 @@ module Sequel
         @expression, @descending = expression, descending
       end
 
+      # Return a copy that is ASC
+      def asc
+        OrderedExpression.new(@expression, false)
+      end
+
+      # Return a copy that is DESC
+      def desc
+        OrderedExpression.new(@expression)
+      end
+
+      # Return an inverted expression, changing ASC to DESC and vice versa
+      def invert
+        OrderedExpression.new(@expression, !@descending)
+      end
+
       to_s_method :ordered_expression_sql
     end
 
@@ -912,4 +943,6 @@ module Sequel
     include SQL::StringMethods
     include SQL::InequalityMethods
   end
+  
+  include SQL::Constants
 end

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 3
-  MINOR = 3
+  MINOR = 4
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/sqlite_spec.rb

@@ -343,6 +343,8 @@ context "A SQLite database" do
   end
   
   specify "should choose a temporary table name that isn't already used when dropping or renaming columns" do
+    sqls = []
+    @db.loggers << (l=Class.new{define_method(:info){|sql| sqls << sql}}.new)
     @db.create_table! :test3 do
       Integer :h
       Integer :i
@@ -357,9 +359,10 @@ context "A SQLite database" do
     @db[:test3].columns.should == [:h, :i]
     @db[:test3_backup0].columns.should == [:j]
     @db[:test3_backup1].columns.should == [:k]
-    sqls = @db.drop_column(:test3, :i)
-    sqls.any?{|x| x =~ /test3_backup2/}.should == true
-    sqls.any?{|x| x =~ /test3_backup[01]/}.should == false
+    sqls.clear
+    @db.drop_column(:test3, :i)
+    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup2/}.should == true
+    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup[01]/}.should == false
     @db[:test3].columns.should == [:h]
     @db[:test3_backup0].columns.should == [:j]
     @db[:test3_backup1].columns.should == [:k]
@@ -368,13 +371,15 @@ context "A SQLite database" do
       Integer :l
     end
 
-    sqls = @db.rename_column(:test3, :h, :i)
-    sqls.any?{|x| x =~ /test3_backup3/}.should == true
-    sqls.any?{|x| x =~ /test3_backup[012]/}.should == false
+    sqls.clear
+    @db.rename_column(:test3, :h, :i)
+    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup3/}.should == true
+    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup[012]/}.should == false
     @db[:test3].columns.should == [:i]
     @db[:test3_backup0].columns.should == [:j]
     @db[:test3_backup1].columns.should == [:k]
     @db[:test3_backup2].columns.should == [:l]
+    @db.loggers.delete(l)
   end
   
   specify "should support add_index" do

data/spec/core/core_sql_spec.rb

@@ -249,6 +249,15 @@ context "Symbol" do
     @ds.literal(:column.qualify(:table.qualify(:schema))).should == '"SCHEMA"."TABLE"."COLUMN"'
     @ds.literal(:column.qualify(:table__name.identifier.qualify(:schema))).should == '"SCHEMA"."TABLE__NAME"."COLUMN"'
   end
+
+  specify "should be able to specify order" do
+    @oe = :xyz.desc
+    @oe.class.should == Sequel::SQL::OrderedExpression
+    @oe.descending.should == true
+    @oe = :xyz.asc
+    @oe.class.should == Sequel::SQL::OrderedExpression
+    @oe.descending.should == false
+  end
 end
 
 context "Dataset#literal" do
@@ -370,3 +379,23 @@ context "Sequel::SQL::Function#==" do
     (c == d).should == false
   end
 end
+
+context "Sequel::SQL::OrderedExpression" do
+  specify "should #desc" do
+    @oe = :column.asc
+    @oe.descending.should == false
+    @oe.desc.descending.should == true
+  end
+
+  specify "should #asc" do
+    @oe = :column.desc
+    @oe.descending.should == true
+    @oe.asc.descending.should == false
+  end
+
+  specify "should #invert" do
+    @oe = :column.desc
+    @oe.invert.descending.should == false
+    @oe.invert.invert.descending.should == true
+  end
+end

data/spec/core/database_spec.rb

@@ -286,21 +286,30 @@ context "Database#execute" do
   end
 end
 
-context "Database#<<" do
+context "Database#<< and run" do
   before do
+    sqls = @sqls = []
     @c = Class.new(Sequel::Database) do
-      define_method(:execute) {|sql, opts| sql}
+      define_method(:execute_ddl){|sql, *opts| sqls.clear; sqls << sql; sqls.concat(opts)}
     end
     @db = @c.new({})
   end
   
-  specify "should pass the supplied sql to #execute" do
-    (@db << "DELETE FROM items").should == "DELETE FROM items"
+  specify "should pass the supplied sql to #execute_ddl" do
+    (@db << "DELETE FROM items")
+    @sqls.should == ["DELETE FROM items", {}]
+    @db.run("DELETE FROM items2")
+    @sqls.should == ["DELETE FROM items2", {}]
   end
   
-  specify "should not remove comments and whitespace from strings" do
-    s = "INSERT INTO items VALUES ('---abc')"
-    (@db << s).should == s
+  specify "should return nil" do
+    (@db << "DELETE FROM items").should == nil
+    @db.run("DELETE FROM items").should == nil
+  end
+  
+  specify "should accept options passed to execute_ddl" do
+    @db.run("DELETE FROM items", :server=>:s1)
+    @sqls.should == ["DELETE FROM items", {:server=>:s1}]
   end
 end
 

data/spec/core/dataset_spec.rb

@@ -172,6 +172,10 @@ context "A simple dataset" do
     @dataset.delete_sql.should == 'DELETE FROM test'
   end
   
+  specify "should format a truncate statement" do
+    @dataset.truncate_sql.should == 'TRUNCATE TABLE test'
+  end
+  
   specify "should format an insert statement with default values" do
     @dataset.insert_sql.should == 'INSERT INTO test DEFAULT VALUES'
   end
@@ -233,6 +237,7 @@ context "A simple dataset" do
     ds.insert_sql.should == sql
     ds.delete_sql.should == sql
     ds.update_sql.should == sql
+    ds.truncate_sql.should == sql
   end
 end
 
@@ -248,6 +253,14 @@ context "A dataset with multiple tables in its FROM clause" do
   specify "should raise on #delete_sql" do
     proc {@dataset.delete_sql}.should raise_error(Sequel::InvalidOperation)
   end
+  
+  specify "should raise on #truncate_sql" do
+    proc {@dataset.truncate_sql}.should raise_error(Sequel::InvalidOperation)
+  end
+
+  specify "should raise on #insert_sql" do
+    proc {@dataset.insert_sql}.should raise_error(Sequel::InvalidOperation)
+  end
 
   specify "should generate a select query FROM all specified tables" do
     @dataset.select_sql.should == "SELECT * FROM t1, t2"
@@ -357,12 +370,6 @@ context "Dataset#where" do
       "SELECT * FROM test WHERE ((a = 1) AND (e < 5))"
   end
   
-  specify "should raise if the dataset is grouped" do
-    proc {@dataset.group(:t).where(:a => 1)}.should_not raise_error
-    @dataset.group(:t).where(:a => 1).sql.should ==
-      "SELECT * FROM test WHERE (a = 1) GROUP BY t"
-  end
-  
   specify "should accept ranges" do
     @dataset.filter(:id => 4..7).sql.should ==
       'SELECT * FROM test WHERE ((id >= 4) AND (id <= 7))'
@@ -651,6 +658,14 @@ context "a grouped dataset" do
   specify "should raise when trying to generate a delete statement" do
     proc {@dataset.delete_sql}.should raise_error
   end
+  
+  specify "should raise when trying to generate a truncate statement" do
+    proc {@dataset.truncate_sql}.should raise_error
+  end
+
+  specify "should raise when trying to generate an insert statement" do
+    proc {@dataset.insert_sql}.should raise_error
+  end
 
   specify "should specify the grouping in generated select statement" do
     @dataset.select_sql.should ==
@@ -682,13 +697,24 @@ context "Dataset#group_by" do
       "SELECT * FROM test GROUP BY type_id"
     @dataset.group_by(:a, :b).select_sql.should ==
       "SELECT * FROM test GROUP BY a, b"
-  end
-
-  specify "should specify the grouping in generated select statement" do
     @dataset.group_by(:type_id=>nil).select_sql.should ==
       "SELECT * FROM test GROUP BY (type_id IS NULL)"
   end
 
+  specify "should ungroup when passed nil, empty, or no arguments" do
+    @dataset.group_by.select_sql.should ==
+      "SELECT * FROM test"
+    @dataset.group_by(nil).select_sql.should ==
+      "SELECT * FROM test"
+  end
+
+  specify "should undo previous grouping" do
+    @dataset.group_by(:a).group_by(:b).select_sql.should ==
+      "SELECT * FROM test GROUP BY b"
+    @dataset.group_by(:a, :b).group_by.select_sql.should ==
+      "SELECT * FROM test"
+  end
+
   specify "should be aliased as #group" do
     @dataset.group(:type_id=>nil).select_sql.should ==
       "SELECT * FROM test GROUP BY (type_id IS NULL)"
@@ -753,14 +779,14 @@ context "Dataset#literal" do
   
   specify "should literalize Time properly" do
     t = Time.now
-    s = t.strftime("'%Y-%m-%dT%H:%M:%S%z'").gsub(/(\d\d')\z/, ':\1')
-    @dataset.literal(t).should == s
+    s = t.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.usec)}'"
   end
   
   specify "should literalize DateTime properly" do
     t = DateTime.now
-    s = t.strftime("'%Y-%m-%dT%H:%M:%S%z'").gsub(/(\d\d')\z/, ':\1')
-    @dataset.literal(t).should == s
+    s = t.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* 86400000000)}'"
   end
   
   specify "should literalize Date properly" do
@@ -773,18 +799,52 @@ context "Dataset#literal" do
     @dataset.meta_def(:requires_sql_standard_datetimes?){true}
 
     t = Time.now
-    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
-    @dataset.literal(t).should == s
+    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.usec)}'"
 
     t = DateTime.now
-    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
-    @dataset.literal(t).should == s
+    s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* 86400000000)}'"
 
     d = Date.today
     s = d.strftime("DATE '%Y-%m-%d'")
     @dataset.literal(d).should == s
   end
   
+  specify "should literalize Time and DateTime properly if the database support timezones in timestamps" do
+    @dataset.meta_def(:supports_timestamp_timezones?){true}
+
+    t = Time.now.utc
+    s = t.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.usec)}+0000'"
+
+    t = DateTime.now.new_offset(0)
+    s = t.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* 86400000000)}+0000'"
+  end
+  
+  specify "should literalize Time and DateTime properly if the database doesn't support usecs in timestamps" do
+    @dataset.meta_def(:supports_timestamp_usecs?){false}
+    
+    t = Time.now.utc
+    s = t.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}'"
+
+    t = DateTime.now.new_offset(0)
+    s = t.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}'"
+    
+    @dataset.meta_def(:supports_timestamp_timezones?){true}
+    
+    t = Time.now.utc
+    s = t.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}+0000'"
+
+    t = DateTime.now.new_offset(0)
+    s = t.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}+0000'"
+  end
+  
   specify "should not modify literal strings" do
     @dataset.literal('col1 + 2'.lit).should == 'col1 + 2'
     
@@ -1029,6 +1089,12 @@ context "Dataset#unlimited" do
   end
 end
 
+context "Dataset#ungrouped" do
+  specify "should remove group and having clauses from the dataset" do
+    Sequel::Dataset.new(nil).from(:test).group(:a).having(:b).ungrouped.sql.should == 'SELECT * FROM test'
+  end
+end
+
 context "Dataset#unordered" do
   specify "should remove ordering from the dataset" do
     Sequel::Dataset.new(nil).from(:test).order(:name).unordered.sql.should == 'SELECT * FROM test'
@@ -1680,6 +1746,13 @@ context "Dataset#join_table" do
     @d.join(:categories, :a=>:d){|j,lj,js| :b.qualify(j) > :c.qualify(lj)}.sql.should ==
       'SELECT * FROM "items" INNER JOIN "categories" ON (("categories"."a" = "items"."d") AND ("categories"."b" > "items"."c"))'
   end
+  
+  specify "should not allow insert, update, delete, or truncate" do
+    proc{@d.join(:categories, :a=>:d).insert_sql}.should raise_error(Sequel::InvalidOperation)
+    proc{@d.join(:categories, :a=>:d).update_sql(:a=>1)}.should raise_error(Sequel::InvalidOperation)
+    proc{@d.join(:categories, :a=>:d).delete_sql}.should raise_error(Sequel::InvalidOperation)
+    proc{@d.join(:categories, :a=>:d).truncate_sql}.should raise_error(Sequel::InvalidOperation)
+  end
 end
 
 context "Dataset#[]=" do
@@ -2254,7 +2327,7 @@ context "Dataset#import" do
     @ds.import([:x, :y], @ds2)
     @db.sqls.should == [
       'BEGIN',
-      "INSERT INTO items (x, y) VALUES (SELECT a, b FROM cats WHERE (purr IS TRUE))",
+      "INSERT INTO items (x, y) SELECT a, b FROM cats WHERE (purr IS TRUE)",
       'COMMIT'
     ]
   end
@@ -2617,7 +2690,7 @@ context "Dataset#grep" do
   end
 end
 
-context "Dataset default #fetch_rows, #insert, #update, and #delete, #execute" do
+context "Dataset default #fetch_rows, #insert, #update, #delete, #truncate, #execute" do
   before do
     @db = Sequel::Database.new
     @ds = @db[:items]
@@ -2630,16 +2703,33 @@ context "Dataset default #fetch_rows, #insert, #update, and #delete, #execute" d
   specify "#delete should execute delete SQL" do
     @db.should_receive(:execute).once.with('DELETE FROM items', :server=>:default)
     @ds.delete
+    @db.should_receive(:execute_dui).once.with('DELETE FROM items', :server=>:default)
+    @ds.delete
   end
 
   specify "#insert should execute insert SQL" do
     @db.should_receive(:execute).once.with('INSERT INTO items DEFAULT VALUES', :server=>:default)
     @ds.insert([])
+    @db.should_receive(:execute_insert).once.with('INSERT INTO items DEFAULT VALUES', :server=>:default)
+    @ds.insert([])
   end
 
   specify "#update should execute update SQL" do
     @db.should_receive(:execute).once.with('UPDATE items SET number = 1', :server=>:default)
     @ds.update(:number=>1)
+    @db.should_receive(:execute_dui).once.with('UPDATE items SET number = 1', :server=>:default)
+    @ds.update(:number=>1)
+  end
+  
+  specify "#truncate should execute truncate SQL" do
+    @db.should_receive(:execute).once.with('TRUNCATE TABLE items', :server=>:default)
+    @ds.truncate.should == nil
+    @db.should_receive(:execute_ddl).once.with('TRUNCATE TABLE items', :server=>:default)
+    @ds.truncate.should == nil
+  end
+  
+  specify "#truncate should raise an InvalidOperation exception if the dataset is filtered" do
+    proc{@ds.filter(:a=>1).truncate}.should raise_error(Sequel::InvalidOperation)
   end
   
   specify "#execute should execute the SQL on the database" do
@@ -2985,4 +3075,158 @@ context "Sequel::Dataset #with and #with_recursive" do
     proc{@ds.with(:t, @db[:x], :args=>[:b])}.should raise_error(Sequel::Error)
     proc{@ds.with_recursive(:t, @db[:x], @db[:t], :args=>[:b, :c])}.should raise_error(Sequel::Error)
   end
-end
+end
+
+describe Sequel::SQL::Constants do
+  before do
+    @db = MockDatabase.new
+  end
+  
+  it "should have CURRENT_DATE" do
+    @db.literal(Sequel::SQL::Constants::CURRENT_DATE) == 'CURRENT_DATE'
+    @db.literal(Sequel::CURRENT_DATE) == 'CURRENT_DATE'
+  end
+
+  it "should have CURRENT_TIME" do
+    @db.literal(Sequel::SQL::Constants::CURRENT_TIME) == 'CURRENT_TIME'
+    @db.literal(Sequel::CURRENT_TIME) == 'CURRENT_TIME'
+  end
+
+  it "should have CURRENT_TIMESTAMP" do
+    @db.literal(Sequel::SQL::Constants::CURRENT_TIMESTAMP) == 'CURRENT_TIMESTAMP'
+    @db.literal(Sequel::CURRENT_TIMESTAMP) == 'CURRENT_TIMESTAMP'
+  end
+end
+
+describe "Sequel timezone support" do
+  before do
+    @db = MockDatabase.new
+    @dataset = @db.dataset
+    @dataset.meta_def(:supports_timestamp_timezones?){true}
+    @dataset.meta_def(:supports_timestamp_usecs?){false}
+    @offset = sprintf("%+03i%02i", *(Time.now.utc_offset/60).divmod(60))
+  end
+  after do
+    Sequel.default_timezone = nil
+    Sequel.datetime_class = Time
+  end
+  
+  specify "should handle an database timezone of :utc when literalizing values" do
+    Sequel.database_timezone = :utc
+
+    t = Time.now
+    s = t.getutc.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}+0000'"
+
+    t = DateTime.now
+    s = t.new_offset(0).strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}+0000'"
+  end
+  
+  specify "should handle an database timezone of :local when literalizing values" do
+    Sequel.database_timezone = :local
+
+    t = Time.now.utc
+    s = t.getlocal.strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}#{@offset}'"
+
+    t = DateTime.now.new_offset(0)
+    s = t.new_offset(Sequel::LOCAL_DATETIME_OFFSET).strftime("'%Y-%m-%d %H:%M:%S")
+    @dataset.literal(t).should == "#{s}#{@offset}'"
+  end
+  
+  specify "should handle converting database timestamps into application timestamps" do
+    Sequel.database_timezone = :utc
+    Sequel.application_timezone = :local
+    t = Time.now.utc
+    Sequel.database_to_application_timestamp(t).to_s.should == t.getlocal.to_s
+    Sequel.database_to_application_timestamp(t.to_s).to_s.should == t.getlocal.to_s
+    Sequel.database_to_application_timestamp(t.strftime('%Y-%m-%d %H:%M:%S')).to_s.should == t.getlocal.to_s
+    
+    Sequel.datetime_class = DateTime
+    dt = DateTime.now
+    dt2 = dt.new_offset(0)
+    Sequel.database_to_application_timestamp(dt2).to_s.should == dt.to_s
+    Sequel.database_to_application_timestamp(dt2.to_s).to_s.should == dt.to_s
+    Sequel.database_to_application_timestamp(dt2.strftime('%Y-%m-%d %H:%M:%S')).to_s.should == dt.to_s
+    
+    Sequel.datetime_class = Time
+    Sequel.database_timezone = :local
+    Sequel.application_timezone = :utc
+    Sequel.database_to_application_timestamp(t.getlocal).to_s.should == t.to_s
+    Sequel.database_to_application_timestamp(t.getlocal.to_s).to_s.should == t.to_s
+    Sequel.database_to_application_timestamp(t.getlocal.strftime('%Y-%m-%d %H:%M:%S')).to_s.should == t.to_s
+    
+    Sequel.datetime_class = DateTime
+    Sequel.database_to_application_timestamp(dt).to_s.should == dt2.to_s
+    Sequel.database_to_application_timestamp(dt.to_s).to_s.should == dt2.to_s
+    Sequel.database_to_application_timestamp(dt.strftime('%Y-%m-%d %H:%M:%S')).to_s.should == dt2.to_s
+  end
+  
+  specify "should handle typecasting timestamp columns" do
+    Sequel.typecast_timezone = :utc
+    Sequel.application_timezone = :local
+    t = Time.now.utc
+    @db.typecast_value(:datetime, t).to_s.should == t.getlocal.to_s
+    @db.typecast_value(:datetime, t.to_s).to_s.should == t.getlocal.to_s
+    @db.typecast_value(:datetime, t.strftime('%Y-%m-%d %H:%M:%S')).to_s.should == t.getlocal.to_s
+    
+    Sequel.datetime_class = DateTime
+    dt = DateTime.now
+    dt2 = dt.new_offset(0)
+    @db.typecast_value(:datetime, dt2).to_s.should == dt.to_s
+    @db.typecast_value(:datetime, dt2.to_s).to_s.should == dt.to_s
+    @db.typecast_value(:datetime, dt2.strftime('%Y-%m-%d %H:%M:%S')).to_s.should == dt.to_s
+    
+    Sequel.datetime_class = Time
+    Sequel.typecast_timezone = :local
+    Sequel.application_timezone = :utc
+    @db.typecast_value(:datetime, t.getlocal).to_s.should == t.to_s
+    @db.typecast_value(:datetime, t.getlocal.to_s).to_s.should == t.to_s
+    @db.typecast_value(:datetime, t.getlocal.strftime('%Y-%m-%d %H:%M:%S')).to_s.should == t.to_s
+    
+    Sequel.datetime_class = DateTime
+    @db.typecast_value(:datetime, dt).to_s.should == dt2.to_s
+    @db.typecast_value(:datetime, dt.to_s).to_s.should == dt2.to_s
+    @db.typecast_value(:datetime, dt.strftime('%Y-%m-%d %H:%M:%S')).to_s.should == dt2.to_s
+  end
+  
+  specify "should handle converting database timestamp columns from an array of values" do
+    Sequel.database_timezone = :utc
+    Sequel.application_timezone = :local
+    t = Time.now.utc
+    Sequel.database_to_application_timestamp([t.year, t.mon, t.day, t.hour, t.min, t.sec]).to_s.should == t.getlocal.to_s
+    
+    Sequel.datetime_class = DateTime
+    dt = DateTime.now
+    dt2 = dt.new_offset(0)
+    Sequel.database_to_application_timestamp([dt2.year, dt2.mon, dt2.day, dt2.hour, dt2.min, dt2.sec]).to_s.should == dt.to_s
+    
+    Sequel.datetime_class = Time
+    Sequel.database_timezone = :local
+    Sequel.application_timezone = :utc
+    t = t.getlocal
+    Sequel.database_to_application_timestamp([t.year, t.mon, t.day, t.hour, t.min, t.sec]).to_s.should == t.getutc.to_s
+    
+    Sequel.datetime_class = DateTime
+    Sequel.database_to_application_timestamp([dt.year, dt.mon, dt.day, dt.hour, dt.min, dt.sec]).to_s.should == dt2.to_s
+  end
+  
+  specify "should raise an InvalidValue error when an error occurs while converting a timestamp" do
+    proc{Sequel.database_to_application_timestamp([0, 0, 0, 0, 0, 0])}.should raise_error(Sequel::InvalidValue)
+  end
+  
+  specify "should raise an error when attempting to typecast to a timestamp from an unsupported type" do
+    proc{Sequel.database_to_application_timestamp(Object.new)}.should raise_error(Sequel::InvalidValue)
+  end
+  
+  specify "should have Sequel.default_timezone= should set all other timezones" do
+    Sequel.database_timezone.should == nil
+    Sequel.application_timezone.should == nil
+    Sequel.typecast_timezone.should == nil
+    Sequel.default_timezone = :utc
+    Sequel.database_timezone.should == :utc
+    Sequel.application_timezone.should == :utc
+    Sequel.typecast_timezone.should == :utc
+  end
+end