sequel 3.4.0 → 3.5.0

data/lib/sequel/database.rb

@@ -31,6 +31,7 @@ module Sequel
     TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
     
     POSTGRES_DEFAULT_RE = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/
+    MSSQL_DEFAULT_RE = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/
     MYSQL_TIMESTAMP_RE = /\ACURRENT_(?:DATE|TIMESTAMP)?\z/
     STRING_DEFAULT_RE = /\A'(.*)'\z/
 
@@ -109,7 +110,7 @@ module Sequel
         begin
           Sequel.require "adapters/#{scheme}"
         rescue LoadError => e
-          raise AdapterNotFound, "Could not load #{scheme} adapter:\n  #{e.message}"
+          raise Sequel.convert_exception_class(e, AdapterNotFound)
         end
         
         # make sure we actually loaded the adapter
@@ -533,10 +534,8 @@ module Sequel
       meth = "typecast_value_#{column_type}"
       begin
         respond_to?(meth, true) ? send(meth, value) : value
-      rescue ArgumentError, TypeError => exp
-        e = Sequel::InvalidValue.new("#{exp.class} #{exp.message}")
-        e.set_backtrace(exp.backtrace)
-        raise e
+      rescue ArgumentError, TypeError => e
+        raise Sequel.convert_exception_class(e, InvalidValue)
       end
     end
     
@@ -658,10 +657,13 @@ module Sequel
       if database_type == :postgres and m = POSTGRES_DEFAULT_RE.match(default)
         default = m[1] || m[2]
       end
-      if [:string, :blob, :date, :datetime, :time].include?(type)
+      if database_type == :mssql and m = MSSQL_DEFAULT_RE.match(default)
+        default = m[1] || m[2]
+      end
+      if [:string, :blob, :date, :datetime, :time, :enum].include?(type)
         if database_type == :mysql
           return if [:date, :datetime, :time].include?(type) && MYSQL_TIMESTAMP_RE.match(default)
-          orig_default = default = "'#{default.gsub("'", "''").gsub('\\', '\\\\')}'" 
+          orig_default = default = "'#{default.gsub("'", "''").gsub('\\', '\\\\')}'"
         end
         return unless m = STRING_DEFAULT_RE.match(default)
         default = m[1].gsub("''", "'")
@@ -675,7 +677,7 @@ module Sequel
           when /[t1]/i
             true
           end
-        when :string
+        when :string, :enum
           default
         when :blob
           Sequel::SQL::Blob.new(default)
@@ -801,9 +803,7 @@ module Sequel
     # and traceback.
     def raise_error(exception, opts={})
       if !opts[:classes] || Array(opts[:classes]).any?{|c| exception.is_a?(c)}
-        e = (opts[:disconnect] ? DatabaseDisconnectError : DatabaseError).new("#{exception.class}: #{exception.message}")
-        e.set_backtrace(exception.backtrace)
-        raise e
+        raise Sequel.convert_exception_class(exception, opts[:disconnect] ? DatabaseDisconnectError : DatabaseError)
       else
         raise exception
       end
@@ -876,6 +876,8 @@ module Sequel
         :decimal
       when /bytea|blob|image|(var)?binary/io
         :blob
+      when /\Aenum/
+        :enum
       end
     end
 
@@ -906,7 +908,7 @@ module Sequel
 
     # Raise a database error unless the exception is an Rollback.
     def transaction_error(e)
-      raise_error(e, :classes=>database_error_classes) unless Rollback === e
+      raise_error(e, :classes=>database_error_classes) unless e.is_a?(Rollback)
     end
 
     # Typecast the value to an SQL::Blob

data/lib/sequel/dataset.rb

@@ -51,7 +51,7 @@ module Sequel
     unlimited unordered where with with_recursive with_sql'.collect{|x| x.to_sym}
 
     NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
-    WITH_SUPPORTED='with'.freeze
+    WITH_SUPPORTED=:select_with_sql
 
     # The database that corresponds to this dataset
     attr_accessor :db
@@ -97,7 +97,7 @@ module Sequel
     # options of the resulting dataset.
     def self.def_mutation_method(*meths)
       meths.each do |meth|
-        class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
+        class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
       end
     end
 
@@ -163,12 +163,12 @@ module Sequel
     # Add a mutation method to this dataset instance.
     def def_mutation_method(*meths)
       meths.each do |meth|
-        instance_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
+        instance_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
       end
     end
 
     # Deletes the records in the dataset.  The returned value is generally the
-    # number of records deleted, but that is adapter dependent.
+    # number of records deleted, but that is adapter dependent.  See delete_sql.
     def delete
       execute_dui(delete_sql)
     end
@@ -200,6 +200,7 @@ module Sequel
   
     # Inserts values into the associated table.  The returned value is generally
     # the value of the primary key for the inserted row, but that is adapter dependent.
+    # See insert_sql.
     def insert(*values)
       execute_insert(insert_sql(*values))
     end
@@ -242,7 +243,7 @@ module Sequel
       update(*args)
     end
 
-    # Set the default values for insert and update statements.  The values passed
+    # Set the default values for insert and update statements.  The values hash passed
     # to insert or update are merged into this hash.
     def set_defaults(hash)
       clone(:defaults=>(@opts[:defaults]||{}).merge(hash))
@@ -256,7 +257,7 @@ module Sequel
     
     # Whether the dataset supports common table expressions (the WITH clause).
     def supports_cte?
-      select_clause_order.include?(WITH_SUPPORTED)
+      select_clause_methods.include?(WITH_SUPPORTED)
     end
 
     # Whether the dataset supports the DISTINCT ON clause, true by default.
@@ -300,7 +301,7 @@ module Sequel
     end
 
     # Updates values for the dataset.  The returned value is generally the
-    # number of rows updated, but that is adapter dependent.
+    # number of rows updated, but that is adapter dependent.  See update_sql.
     def update(values={})
       execute_dui(update_sql(values))
     end
@@ -377,19 +378,5 @@ module Sequel
     # default, added to make the model eager loading code simpler.
     def post_load(all_records)
     end
-
-    # If a block argument is passed to a method that uses a VirtualRow,
-    # yield a new VirtualRow instance to the block if it accepts a single
-    # argument.  Otherwise, evaluate the block in the context of a new
-    # VirtualRow instance.
-    def virtual_row_block_call(block)
-      return unless block
-      case block.arity
-      when -1, 0
-        SQL::VirtualRow.new.instance_eval(&block)
-      else
-        block.call(SQL::VirtualRow.new)
-      end
-    end
   end
 end

data/lib/sequel/dataset/convenience.rb

@@ -109,7 +109,7 @@ module Sequel
     #   # this will commit every 50 records
     #   dataset.import([:x, :y], [[1, 2], [3, 4], ...], :slice => 50)
     def import(columns, values, opts={})
-      return @db.transaction{execute_dui("#{insert_sql_base}#{quote_schema_table(@opts[:from].first)} (#{identifier_list(columns)}) #{subselect_sql(values)}")} if values.is_a?(Dataset)
+      return @db.transaction{insert(columns, values)} if values.is_a?(Dataset)
 
       return if values.empty?
       raise(Error, IMPORT_ERROR_MSG) if columns.empty?

data/lib/sequel/dataset/graph.rb

@@ -41,6 +41,10 @@ module Sequel
     #   or an object that responds to .dataset and return a symbol or a dataset
     # * join_conditions - Any condition(s) allowed by join_table.
     # * options -  A hash of graph options.  The following options are currently used:
+    #   * :from_self_alias - The alias to use when the receiver is not a graphed
+    #     dataset but it contains multiple FROM tables or a JOIN.  In this case,
+    #     the receiver is wrapped in a from_self before graphing, and this option
+    #     determines the alias to use.
     #   * :implicit_qualifier - The qualifier of implicit conditions, see #join_table.
     #   * :join_type - The type of join to use (passed to join_table).  Defaults to
     #     :left_outer.
@@ -83,9 +87,12 @@ module Sequel
 
       # Only allow table aliases that haven't been used
       raise_alias_error.call if @opts[:graph] && @opts[:graph][:table_aliases] && @opts[:graph][:table_aliases].include?(table_alias)
-
+      
+      # Use a from_self if this is already a joined table
+      ds = (!@opts[:graph] && (@opts[:from].length > 1 || @opts[:join])) ? from_self(:alias=>options[:from_self_alias] || first_source) : self
+      
       # Join the table early in order to avoid cloning the dataset twice
-      ds = join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], &block)
+      ds = ds.join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], &block)
       opts = ds.opts
 
       # Whether to include the table in the result set

data/lib/sequel/dataset/sql.rb

@@ -1,5 +1,12 @@
 module Sequel
   class Dataset
+
+    # Given a type (e.g. select) and an array of clauses,
+    # return an array of methods to call to build the SQL string.
+    def self.clause_methods(type, clauses)
+      clauses.map{|clause| :"#{type}_#{clause}_sql"}.freeze
+    end
+
     AND_SEPARATOR = " AND ".freeze
     BOOL_FALSE = "'f'".freeze
     BOOL_TRUE = "'t'".freeze
@@ -8,7 +15,7 @@ module Sequel
     COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
     COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
     DATASET_ALIAS_BASE_NAME = 't'.freeze
-    INSERT_SQL_BASE="INSERT INTO ".freeze
+    FROM_SELF_KEEP_OPTS = [:graph, :eager_graph, :graph_aliases]
     IS_LITERALS = {nil=>'NULL'.freeze, true=>'TRUE'.freeze, false=>'FALSE'.freeze}.freeze
     IS_OPERATORS = ::Sequel::SQL::ComplexExpression::IS_OPERATORS
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
@@ -16,7 +23,10 @@ module Sequel
     QUALIFY_KEYS = [:select, :where, :having, :order, :group]
     QUESTION_MARK = '?'.freeze
     STOCK_COUNT_OPTS = {:select => [SQL::AliasedExpression.new(LiteralString.new("COUNT(*)").freeze, :count)], :order => nil}.freeze
-    SELECT_CLAUSE_ORDER = %w'with distinct columns from join where group having compounds order limit'.freeze
+    DELETE_CLAUSE_METHODS = clause_methods(:delete, %w'from where')
+    INSERT_CLAUSE_METHODS = clause_methods(:insert, %w'into columns values')
+    SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with distinct columns from join where group having compounds order limit')
+    UPDATE_CLAUSE_METHODS = clause_methods(:update, %w'table set where')
     TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S%N%z'".freeze
     STANDARD_TIMESTAMP_FORMAT = "TIMESTAMP #{TIMESTAMP_FORMAT}".freeze
     TWO_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::TWO_ARITY_OPERATORS
@@ -106,19 +116,9 @@ module Sequel
     #   dataset.filter{|o| o.price >= 100}.delete_sql #=>
     #     "DELETE FROM items WHERE (price >= 100)"
     def delete_sql
-      opts = @opts
-
       return static_sql(opts[:sql]) if opts[:sql]
-
       check_modification_allowed!
-
-      sql = "DELETE FROM #{source_list(opts[:from])}"
-
-      if where = opts[:where]
-        sql << " WHERE #{literal(where)}"
-      end
-
-      sql
+      clause_sql(:delete)
     end
 
     # Returns a copy of the dataset with the SQL DISTINCT clause.
@@ -168,7 +168,7 @@ module Sequel
     # Returns an EXISTS clause for the dataset as a LiteralString.
     #
     #   DB.select(1).where(DB[:items].exists).sql
-    #   #=> "SELECT 1 WHERE EXISTS (SELECT * FROM items)"
+    #   #=> "SELECT 1 WHERE (EXISTS (SELECT * FROM items))"
     def exists
       LiteralString.new("EXISTS (#{select_sql})")
     end
@@ -283,7 +283,7 @@ module Sequel
     #   ds.from_self(:alias=>:foo).sql #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS 'foo'"
     def from_self(opts={})
       fs = {}
-      @opts.keys.each{|k| fs[k] = nil} 
+      @opts.keys.each{|k| fs[k] = nil unless FROM_SELF_KEEP_OPTS.include?(k)}
       clone(fs).from(opts[:alias] ? as(opts[:alias]) : self)
     end
 
@@ -336,57 +336,60 @@ module Sequel
       end
     end
 
-    # Formats an INSERT statement using the given values. If a hash is given,
-    # the resulting statement includes column names. If no values are given, 
-    # the resulting statement includes a DEFAULT VALUES clause.
+    # Formats an INSERT statement using the given values. The API is a little
+    # complex, and best explained by example:
     #
-    #   dataset.insert_sql #=> 'INSERT INTO items DEFAULT VALUES'
-    #   dataset.insert_sql(1,2,3) #=> 'INSERT INTO items VALUES (1, 2, 3)'
-    #   dataset.insert_sql(:a => 1, :b => 2) #=>
-    #     'INSERT INTO items (a, b) VALUES (1, 2)'
+    #   # Default values
+    #   DB[:items].insert_sql #=> 'INSERT INTO items DEFAULT VALUES'
+    #   DB[:items].insert_sql({}) #=> 'INSERT INTO items DEFAULT VALUES'
+    #   # Values without columns
+    #   DB[:items].insert_sql(1,2,3) #=> 'INSERT INTO items VALUES (1, 2, 3)'
+    #   DB[:items].insert_sql([1,2,3]) #=> 'INSERT INTO items VALUES (1, 2, 3)'
+    #   # Values with columns
+    #   DB[:items].insert_sql([:a, :b], [1,2]) #=> 'INSERT INTO items (a, b) VALUES (1, 2)'
+    #   DB[:items].insert_sql(:a => 1, :b => 2) #=> 'INSERT INTO items (a, b) VALUES (1, 2)'
+    #   # Using a subselect
+    #   DB[:items].insert_sql(DB[:old_items]) #=> 'INSERT INTO items SELECT * FROM old_items
+    #   # Using a subselect with columns
+    #   DB[:items].insert_sql([:a, :b], DB[:old_items]) #=> 'INSERT INTO items (a, b) SELECT * FROM old_items
     def insert_sql(*values)
       return static_sql(@opts[:sql]) if @opts[:sql]
 
       check_modification_allowed!
 
-      from = source_list(@opts[:from])
+      columns = []
+
       case values.size
       when 0
-        values = {}
+        return insert_sql({})
       when 1
-        vals = values.at(0)
-        if [Hash, Dataset, Array].any?{|c| vals.is_a?(c)}
+        case vals = values.at(0)
+        when Hash
+          vals = @opts[:defaults].merge(vals) if @opts[:defaults]
+          vals = vals.merge(@opts[:overrides]) if @opts[:overrides]
+          values = []
+          vals.each do |k,v| 
+            columns << k
+            values << v
+          end
+        when Dataset, Array, LiteralString
           values = vals
-        elsif vals.respond_to?(:values)
-          values = vals.values
-        end
-      end
-
-      case values
-      when Array
-        if values.empty?
-          insert_default_values_sql
         else
-          "#{insert_sql_base}#{from} VALUES #{literal(values)}#{insert_sql_suffix}"
-        end
-      when Hash
-        values = @opts[:defaults].merge(values) if @opts[:defaults]
-        values = values.merge(@opts[:overrides]) if @opts[:overrides]
-        if values.empty?
-          insert_default_values_sql
-        else
-          fl, vl = [], []
-          values.each do |k, v|
-            fl << literal(String === k ? k.to_sym : k)
-            vl << literal(v)
+          if vals.respond_to?(:values) && (v = vals.values).is_a?(Hash)
+            return insert_sql(v) 
           end
-          "#{insert_sql_base}#{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})#{insert_sql_suffix}"
         end
-      when Dataset
-        "#{insert_sql_base}#{from} #{literal(values)}#{insert_sql_suffix}"
+      when 2
+        if (v0 = values.at(0)).is_a?(Array) && ((v1 = values.at(1)).is_a?(Array) || v1.is_a?(Dataset) || v1.is_a?(LiteralString))
+          columns, values = v0, v1
+          raise(Error, "Different number of values and columns given to insert_sql") if values.is_a?(Array) and columns.length != values.length
+        end
       end
+
+      columns = columns.map{|k| literal(String === k ? k.to_sym : k)}
+      clone(:columns=>columns, :values=>values)._insert_sql
     end
-    
+
     # Adds an INTERSECT clause using a second dataset object.
     # An INTERSECT compound dataset returns all rows in both the current dataset
     # and the given dataset.
@@ -590,8 +593,7 @@ module Sequel
     # This method should be overridden by descendants if the support
     # inserting multiple records in a single SQL statement.
     def multi_insert_sql(columns, values)
-      s = "#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES "
-      values.map{|r| s + literal(r)}
+      values.map{|r| insert_sql(columns, r)}
     end
     
     # Adds an alternate filter to an existing filter using OR. If no filter 
@@ -619,7 +621,7 @@ module Sequel
     #   ds.order{|o| o.sum(:name)}.sql #=> 'SELECT * FROM items ORDER BY sum(name)'
     #   ds.order(nil).sql #=> 'SELECT * FROM items'
     def order(*columns, &block)
-      columns += Array(virtual_row_block_call(block)) if block
+      columns += Array(Sequel.virtual_row(&block)) if block
       clone(:order => (columns.compact.empty?) ? nil : columns)
     end
     alias_method :order_by, :order
@@ -630,7 +632,8 @@ module Sequel
     #   ds.order(:a).order(:b).sql #=> 'SELECT * FROM items ORDER BY b'
     #   ds.order(:a).order_more(:b).sql #=> 'SELECT * FROM items ORDER BY a, b'
     def order_more(*columns, &block)
-      order(*Array(@opts[:order]).concat(columns), &block)
+      columns = @opts[:order] + columns if @opts[:order]
+      order(*columns, &block)
     end
     
     # SQL fragment for the ordered expression, used in the ORDER BY
@@ -740,7 +743,7 @@ module Sequel
     #   dataset.select(:a, :b) # SELECT a, b FROM items
     #   dataset.select{|o| o.a, o.sum(:b)} # SELECT a, sum(b) FROM items
     def select(*columns, &block)
-      columns += Array(virtual_row_block_call(block)) if block
+      columns += Array(Sequel.virtual_row(&block)) if block
       m = []
       columns.map do |i|
         i.is_a?(Hash) ? m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)}) : m << i
@@ -761,7 +764,8 @@ module Sequel
     #   dataset.select(:a).select(:b) # SELECT b FROM items
     #   dataset.select(:a).select_more(:b) # SELECT a, b FROM items
     def select_more(*columns, &block)
-      select(*Array(@opts[:select]).concat(columns), &block)
+      columns = @opts[:select] + columns if @opts[:select]
+      select(*columns, &block)
     end
     
     # Formats a SELECT statement
@@ -769,9 +773,7 @@ module Sequel
     #   dataset.select_sql # => "SELECT * FROM items"
     def select_sql
       return static_sql(@opts[:sql]) if @opts[:sql]
-      sql = 'SELECT'
-      select_clause_order.each{|x| send(:"select_#{x}_sql", sql)}
-      sql
+      clause_sql(:select)
     end
 
     # Same as select_sql, not aliased directly to make subclassing simpler.
@@ -845,32 +847,11 @@ module Sequel
     # Raises an error if the dataset is grouped or includes more
     # than one table.
     def update_sql(values = {})
-      opts = @opts
-
       return static_sql(opts[:sql]) if opts[:sql]
-
       check_modification_allowed!
-      
-      sql = "UPDATE #{source_list(@opts[:from])} SET "
-      set = if values.is_a?(Hash)
-        values = opts[:defaults].merge(values) if opts[:defaults]
-        values = values.merge(opts[:overrides]) if opts[:overrides]
-        # get values from hash
-        values.map do |k, v|
-          "#{[String, Symbol].any?{|c| k.is_a?(c)} ? quote_identifier(k) : literal(k)} = #{literal(v)}"
-        end.join(COMMA_SEPARATOR)
-      else
-        # copy values verbatim
-        values
-      end
-      sql << set
-      if where = opts[:where]
-        sql << " WHERE #{literal(where)}"
-      end
-
-      sql
+      clone(:values=>values)._update_sql
     end
-    
+
     # Add a condition to the WHERE clause.  See #filter for argument types.
     #
     #   dataset.group(:a).having(:a).filter(:b) # SELECT * FROM items GROUP BY a HAVING a AND b
@@ -933,12 +914,22 @@ module Sequel
     end
 
     [:inner, :full_outer, :right_outer, :left_outer].each do |jtype|
-      class_eval("def #{jtype}_join(*args, &block); join_table(:#{jtype}, *args, &block) end")
+      class_eval("def #{jtype}_join(*args, &block); join_table(:#{jtype}, *args, &block) end", __FILE__, __LINE__)
     end
     alias join inner_join
 
     protected
 
+    # Formats in INSERT statement using the stored columns and values.
+    def _insert_sql
+      clause_sql(:insert)
+    end
+
+    # Formats an UPDATE statement using the stored values.
+    def _update_sql
+      clause_sql(:update)
+    end
+
     # Return a from_self dataset if an order or limit is specified, so it works as expected
     # with UNION, EXCEPT, and INTERSECT clauses.
     def compound_from_self
@@ -955,6 +946,12 @@ module Sequel
       clone(clause => cond)
     end
     
+    # Formats the truncate statement.  Assumes the table given has already been
+    # literalized.
+    def _truncate_sql(table)
+      "TRUNCATE TABLE #{table}"
+    end
+
     # Do a simple join of the arguments (which should be strings or symbols) separated by commas
     def argument_list(args)
       args.join(COMMA_SEPARATOR)
@@ -972,6 +969,13 @@ module Sequel
       raise(InvalidOperation, "Joined datasets cannot be modified") if (opts[:from].is_a?(Array) && opts[:from].size > 1) || opts[:join]
     end
 
+    # Prepare an SQL statement by calling all clause methods for the given statement type.
+    def clause_sql(type)
+      sql = type.to_s.upcase
+      send("#{type}_clause_methods").each{|x| send(x, sql)}
+      sql
+    end
+
     # Converts an array of column names into a comma seperated string of 
     # column names. If the array is empty, a wildcard (*) is returned.
     def column_list(columns)
@@ -989,6 +993,11 @@ module Sequel
       :"#{DATASET_ALIAS_BASE_NAME}#{number}"
     end
     
+    # The order of methods to call to build the DELETE SQL statement
+    def delete_clause_methods
+      DELETE_CLAUSE_METHODS
+    end
+
     # Converts an array of expressions into a comma separated string of
     # expressions.
     def expression_list(columns)
@@ -1020,7 +1029,7 @@ module Sequel
           SQL::BooleanExpression.new(:AND, *expr.map{|x| filter_expr(x)})
         end
       when Proc
-        filter_expr(virtual_row_block_call(expr))
+        filter_expr(Sequel.virtual_row(&expr))
       when SQL::NumericExpression, SQL::StringExpression
         raise(Error, "Invalid SQL Expression type: #{expr.inspect}") 
       when Symbol, SQL::Expression
@@ -1042,37 +1051,64 @@ module Sequel
       v2 = Sequel.application_to_database_timestamp(v)
       fmt = default_timestamp_format.gsub(/%[Nz]/) do |m|
         if m == '%N'
-          sprintf(".%06d", v.is_a?(DateTime) ? v.sec_fraction*86400000000 : v.usec) if supports_timestamp_usecs?
+          format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*86400000000 : v.usec) if supports_timestamp_usecs?
         else
           if supports_timestamp_timezones?
             # Would like to just use %z format, but it doesn't appear to work on Windows
             # Instead, the offset fragment is constructed manually
             minutes = (v2.is_a?(DateTime) ? v2.offset * 1440 : v2.utc_offset/60).to_i
-            sprintf("%+03i%02i", *minutes.divmod(60))
+            format_timestamp_offset(*minutes.divmod(60))
           end
         end
       end
       v2.strftime(fmt)
     end
+    
+    # Return the SQL timestamp fragment to use for the timezone offset.
+    def format_timestamp_offset(hour, minute)
+      sprintf("%+03i%02i", hour, minute)
+    end
 
+    # Return the SQL timestamp fragment to use for the fractional time part.
+    # Should start with the decimal point.  Uses 6 decimal places by default.
+    def format_timestamp_usec(usec)
+      sprintf(".%06d", usec)
+    end
+
+    # SQL fragment specifying a list of identifiers
     # SQL fragment specifying a list of identifiers
     def identifier_list(columns)
       columns.map{|i| quote_identifier(i)}.join(COMMA_SEPARATOR)
     end
 
-    # SQL statement for the beginning of an INSERT statement
-    def insert_sql_base
-      INSERT_SQL_BASE
+    # SQL fragment specifying the table to insert INTO
+    def insert_into_sql(sql)
+      sql << " INTO #{source_list(@opts[:from])}"
     end
 
-    # SQL statement for formatting an insert statement with default values
-    def insert_default_values_sql
-      "#{insert_sql_base}#{source_list(@opts[:from])} DEFAULT VALUES"
+    # The order of methods to call to build the INSERT SQL statement
+    def insert_clause_methods
+      INSERT_CLAUSE_METHODS
     end
 
-    # SQL statement for end of an INSERT statement
-    def insert_sql_suffix
-      nil
+    # SQL fragment specifying the columns to insert into
+    def insert_columns_sql(sql)
+      columns = opts[:columns]
+      sql << " (#{columns.join(COMMA_SEPARATOR)})" if columns && !columns.empty?
+    end
+
+    # SQL fragment specifying the values to insert.
+    def insert_values_sql(sql)
+      case values = opts[:values]
+      when Array
+        sql << (values.empty? ? " DEFAULT VALUES" : " VALUES #{literal(values)}")
+      when Dataset
+        sql << " #{subselect_sql(values)}"
+      when LiteralString
+        sql << " #{values}"
+      else
+        raise Error, "Unsupported INSERT values type, should be an Array or Dataset: #{values.inspect}"
+      end
     end
 
     # Inverts the given order by breaking it into a list of column references
@@ -1156,7 +1192,9 @@ module Sequel
       v.to_s
     end
 
-    # SQL fragmento for a type of object not handled by Dataset#literal.  Raises an error.  If a database specific type is allowed, this should be overriden in a subclass.
+    # SQL fragmento for a type of object not handled by Dataset#literal.
+    # Raises an error.  If a database specific type is allowed,
+    # this should be overriden in a subclass.
     def literal_other(v)
       raise Error, "can't express #{v.inspect} as a SQL literal"
     end
@@ -1262,8 +1300,8 @@ module Sequel
     end
 
     # The order of methods to call to build the SELECT SQL statement
-    def select_clause_order
-      SELECT_CLAUSE_ORDER
+    def select_clause_methods
+      SELECT_CLAUSE_METHODS
     end
 
     # Modify the sql to add the columns selected
@@ -1293,6 +1331,7 @@ module Sequel
     def select_from_sql(sql)
       sql << " FROM #{source_list(@opts[:from])}" if @opts[:from]
     end
+    alias delete_from_sql select_from_sql
 
     # Modify the sql to add the expressions to GROUP BY
     def select_group_sql(sql)
@@ -1319,18 +1358,24 @@ module Sequel
     def select_order_sql(sql)
       sql << " ORDER BY #{expression_list(@opts[:order])}" if @opts[:order]
     end
+    alias delete_order_sql select_order_sql
+    alias update_order_sql select_order_sql
 
     # Modify the sql to add the filter criteria in the WHERE clause
     def select_where_sql(sql)
       sql << " WHERE #{literal(@opts[:where])}" if @opts[:where]
     end
+    alias delete_where_sql select_where_sql
+    alias update_where_sql select_where_sql
     
+    # SQL Fragment specifying the WITH clause
     def select_with_sql(sql)
       ws = opts[:with]
       return if !ws || ws.empty?
-      sql.replace("#{select_with_sql_base}#{ws.map{|w| "#{w[:name]}#{"(#{argument_list(w[:args])})" if w[:args]} AS (#{subselect_sql(w[:dataset])})"}.join(COMMA_SEPARATOR)} #{sql}")
+      sql.replace("#{select_with_sql_base}#{ws.map{|w| "#{quote_identifier(w[:name])}#{"(#{argument_list(w[:args])})" if w[:args]} AS #{literal_dataset(w[:dataset])}"}.join(COMMA_SEPARATOR)} #{sql}")
     end
     
+    # The base keyword to use for the SQL WITH clause
     def select_with_sql_base
       SQL_WITH
     end
@@ -1376,10 +1421,31 @@ module Sequel
       t.is_a?(String) ? quote_identifier(t) : literal(t)
     end
     
-    # Formats the truncate statement.  Assumes the table given has already been
-    # literalized.
-    def _truncate_sql(table)
-      "TRUNCATE TABLE #{table}"
+    # The order of methods to call to build the UPDATE SQL statement
+    def update_clause_methods
+      UPDATE_CLAUSE_METHODS
+    end
+
+    # SQL fragment specifying the tables from with to delete
+    def update_table_sql(sql)
+      sql << " #{source_list(@opts[:from])}"
+    end
+
+    # The SQL fragment specifying the columns and values to SET.
+    def update_set_sql(sql)
+      values = opts[:values]
+      set = if values.is_a?(Hash)
+        values = opts[:defaults].merge(values) if opts[:defaults]
+        values = values.merge(opts[:overrides]) if opts[:overrides]
+        # get values from hash
+        values.map do |k, v|
+          "#{[String, Symbol].any?{|c| k.is_a?(c)} ? quote_identifier(k) : literal(k)} = #{literal(v)}"
+        end.join(COMMA_SEPARATOR)
+      else
+        # copy values verbatim
+        values
+      end
+      sql << " SET #{set}"
     end
   end
 end