sequel 3.4.0 → 3.5.0

data/lib/sequel/adapters/ado.rb

@@ -23,10 +23,12 @@ module Sequel
       #   to execute a command before cancelling the attempt and generating
       #   an error. Specifically, it sets the ADO CommandTimeout property.
       #   If this property is not set, the default of 30 seconds is used.
+      # * :conn_string - The full ADO connection string.  If this is provided,
+      #   the usual options are ignored.
       # * :provider - Sets the Provider of this ADO connection (for example, "SQLOLEDB")
       def connect(server)
         opts = server_opts(server)
-        s = "driver=#{opts[:driver]};server=#{opts[:host]};database=#{opts[:database]}#{";uid=#{opts[:user]};pwd=#{opts[:password]}" if opts[:user]}"
+        s = opts[:conn_string] || "driver=#{opts[:driver]};server=#{opts[:host]};database=#{opts[:database]}#{";uid=#{opts[:user]};pwd=#{opts[:password]}" if opts[:user]}"
         handle = WIN32OLE.new('ADODB.Connection')
         handle.CommandTimeout = opts[:command_timeout] if opts[:command_timeout]
         handle.Provider = opts[:provider] if opts[:provider]

data/lib/sequel/adapters/ado/mssql.rb

@@ -20,9 +20,9 @@ module Sequel
         # Use a nasty hack of multiple SQL statements in the same call and
         # having the last one return the most recently inserted id.  This
         # is necessary as ADO doesn't provide a consistent native connection.
-        def insert(values={})
+        def insert(*values)
           return super if @opts[:sql]
-          with_sql("SET NOCOUNT ON; #{insert_sql(values)}; SELECT CAST(SCOPE_IDENTITY() AS INTEGER)").single_value
+          with_sql("SET NOCOUNT ON; #{insert_sql(*values)}; SELECT CAST(SCOPE_IDENTITY() AS INTEGER)").single_value
         end
       end
     end

data/lib/sequel/adapters/do.rb

@@ -16,19 +16,16 @@ module Sequel
     DATABASE_SETUP = {:postgres=>proc do |db|
         require 'do_postgres'
         Sequel.require 'adapters/do/postgres'
-        db.converted_exceptions << PostgresError
         db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
       end,
       :mysql=>proc do |db|
         require 'do_mysql'
         Sequel.require 'adapters/do/mysql'
-        db.converted_exceptions << MysqlError
         db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
       end,
       :sqlite3=>proc do |db|
         require 'do_sqlite3'
         Sequel.require 'adapters/do/sqlite'
-        db.converted_exceptions << Sqlite3Error
         db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
       end
     }
@@ -41,18 +38,12 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :do
       
-      # Convert the given exceptions to Sequel:Errors, necessary
-      # because DO raises errors specific to database types in
-      # certain cases.
-      attr_accessor :converted_exceptions
-      
       # Call the DATABASE_SETUP proc directly after initialization,
       # so the object always uses sub adapter specific code.  Also,
       # raise an error immediately if the connection doesn't have a
       # uri, since DataObjects requires one.
       def initialize(opts)
         @opts = opts
-        @converted_exceptions = []
         raise(Error, "No connection string specified") unless uri
         if prok = DATABASE_SETUP[subadapter.to_sym]
           prok.call(self)
@@ -81,8 +72,8 @@ module Sequel
           begin
             command = conn.create_command(sql)
             res = block_given? ? command.execute_reader : command.execute_non_query
-          rescue Exception => e
-            raise_error(e, :classes=>@converted_exceptions)
+          rescue ::DataObjects::Error => e
+            raise_error(e)
           end
           if block_given?
             begin

data/lib/sequel/adapters/do/mysql.rb

@@ -32,6 +32,13 @@ module Sequel
         def replace(*args)
           execute_insert(replace_sql(*args))
         end
+        
+        private
+        
+        # do_mysql sets NO_BACKSLASH_ESCAPES, so use standard SQL string escaping
+        def literal_string(s)
+          "'#{s.gsub("'", "''")}'"
+        end
       end
     end
   end

data/lib/sequel/adapters/do/postgres.rb

@@ -1,7 +1,7 @@
 Sequel.require 'adapters/shared/postgres'
 
 module Sequel
-  Postgres::CONVERTED_EXCEPTIONS << PostgresError
+  Postgres::CONVERTED_EXCEPTIONS << ::DataObjects::Error
   
   module DataObjects
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
@@ -27,7 +27,7 @@ module Sequel
             else
               command.execute_non_query
             end
-          rescue PostgresError => e
+          rescue ::DataObjects::Error => e
             raise_error(e)
           end
         end

data/lib/sequel/adapters/firebird.rb

@@ -202,7 +202,7 @@ module Sequel
       BOOL_FALSE = '0'.freeze
       NULL = LiteralString.new('NULL').freeze
       COMMA_SEPARATOR = ', '.freeze
-      SELECT_CLAUSE_ORDER = %w'with distinct limit columns from join where group having compounds order'.freeze
+      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with distinct limit columns from join where group having compounds order')
 
       # Yield all rows returned by executing the given SQL and converting
       # the types.
@@ -253,8 +253,8 @@ module Sequel
       end
 
       # The order of clauses in the SELECT SQL statement
-      def select_clause_order
-        SELECT_CLAUSE_ORDER
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
       end
       
       def select_limit_sql(sql)

data/lib/sequel/adapters/informix.rb

@@ -37,7 +37,7 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where having group compounds order'.freeze
+      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'limit distinct columns from join where having group compounds order')
 
       def fetch_rows(sql, &block)
         execute(sql) do |cursor|
@@ -66,8 +66,8 @@ module Sequel
         false
       end
 
-      def select_clause_order
-        SELECT_CLAUSE_ORDER
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
       end
 
       def select_limit_sql(sql)

data/lib/sequel/adapters/jdbc/h2.rb

@@ -74,7 +74,7 @@ module Sequel
       
       # Dataset class for H2 datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
-        SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
+        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
         
         # H2 requires SQL standard datetimes
         def requires_sql_standard_datetimes?
@@ -88,8 +88,8 @@ module Sequel
         
         private
       
-        def select_clause_order
-          SELECT_CLAUSE_ORDER
+        def select_clause_methods
+          SELECT_CLAUSE_METHODS
         end
       end
     end

data/lib/sequel/adapters/jdbc/mssql.rb

@@ -12,6 +12,8 @@ module Sequel
     module MSSQL
       # Database instance methods for MSSQL databases accessed via JDBC.
       module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Apk__/i.freeze
+        
         include Sequel::MSSQL::DatabaseMethods
         
         # Return instance of Sequel::JDBC::MSSQL::Dataset with the given opts.
@@ -40,6 +42,11 @@ module Sequel
         def schema_parse_table(table, opts={})
           jdbc_schema_parse_table(table, opts)
         end
+        
+        # Primary key indexes appear to start with pk__ on MSSQL
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
+        end
       end
       
       # Dataset class for MSSQL datasets accessed via JDBC.

data/lib/sequel/adapters/mysql.rb

@@ -67,7 +67,7 @@ module Sequel
       include Sequel::MySQL::DatabaseMethods
       
       # Mysql::Error messages that indicate the current connection should be disconnected
-      MYSQL_DATABASE_DISCONNECT_ERRORS = /\ACommands out of sync; you can't run this command now\z/
+      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now\z|Can't connect to local MySQL server through socket)/
       
       set_adapter_scheme :mysql
       
@@ -132,12 +132,12 @@ module Sequel
       # Executes the given SQL using an available connection, yielding the
       # connection if the block is given.
       def execute(sql, opts={}, &block)
-        return call_sproc(sql, opts, &block) if opts[:sproc]
-        return execute_prepared_statement(sql, opts, &block) if Symbol === sql
-        begin
+        if opts[:sproc]
+          call_sproc(sql, opts, &block)
+        elsif sql.is_a?(Symbol)
+          execute_prepared_statement(sql, opts, &block)
+        else
           synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-        rescue Mysql::Error => e
-          raise_error(e)
         end
       end
       
@@ -178,7 +178,16 @@ module Sequel
         rescue Mysql::Error => e
           raise_error(e, :disconnect=>MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
         ensure
-          r.free if r
+          if r
+            r.free 
+            # Use up all results to avoid a commands out of sync message.
+            if conn.respond_to?(:next_result)
+              while conn.next_result
+                r = conn.use_result
+                r.free if r
+              end
+            end
+          end
         end
       end
       
@@ -221,16 +230,10 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           unless conn.prepared_statements[ps_name] == sql
             conn.prepared_statements[ps_name] = sql
-            s = "PREPARE #{ps_name} FROM '#{::Mysql.quote(sql)}'"
-            log_info(s)
-            conn.query(s)
+            _execute(conn, "PREPARE #{ps_name} FROM '#{::Mysql.quote(sql)}'", opts)
           end
           i = 0
-          args.each do |arg|
-            s = "SET @sequel_arg_#{i+=1} = #{literal(arg)}"
-            log_info(s)
-            conn.query(s)
-          end
+          _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
           _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
         end
       end
@@ -310,21 +313,31 @@ module Sequel
         execute_dui(delete_sql){|c| c.affected_rows}
       end
       
-      # Yield all rows matching this dataset
-      def fetch_rows(sql)
+      # Yield all rows matching this dataset.  If the dataset is set to
+      # split multiple statements, yield arrays of hashes one per statement
+      # instead of yielding results for all statements as hashes.
+      def fetch_rows(sql, &block)
         execute(sql) do |r|
           i = -1
           cols = r.fetch_fields.map{|f| [output_identifier(f.name), MYSQL_TYPES[f.type], i+=1]}
           @columns = cols.map{|c| c.first}
-          while row = r.fetch_row
-            h = {}
-            cols.each{|n, p, i| v = row[i]; h[n] = (v && p) ? p.call(v) : v}
-            yield h
+          if opts[:split_multiple_result_sets]
+            s = []
+            yield_rows(r, cols){|h| s << h}
+            yield s
+          else
+            yield_rows(r, cols, &block)
           end
         end
         self
       end
       
+      # Don't allow graphing a dataset that splits multiple statements
+      def graph(*)
+        raise(Error, "Can't graph a dataset that splits multiple result sets") if opts[:split_multiple_result_sets]
+        super
+      end
+      
       # Insert a new value into this dataset
       def insert(*values)
         execute_dui(insert_sql(*values)){|c| c.insert_id}
@@ -347,6 +360,22 @@ module Sequel
         execute_dui(replace_sql(*args)){|c| c.insert_id}
       end
       
+      # Makes each yield arrays of rows, with each array containing the rows
+      # for a given result set.  Does not work with graphing.  So you can submit
+      # SQL with multiple statements and easily determine which statement
+      # returned which results.
+      #
+      # Modifies the row_proc of the returned dataset so that it still works
+      # as expected (running on the hashes instead of on the arrays of hashes).
+      # If you modify the row_proc afterward, note that it will receive an array
+      # of hashes instead of a hash.
+      def split_multiple_result_sets
+        raise(Error, "Can't split multiple statements on a graphed dataset") if opts[:graph]
+        ds = clone(:split_multiple_result_sets=>true)
+        ds.row_proc = proc{|x| x.map{|h| row_proc.call(h)}} if row_proc
+        ds
+      end
+      
       # Update the matching rows.
       def update(values={})
         execute_dui(update_sql(values)){|c| c.affected_rows}
@@ -373,6 +402,16 @@ module Sequel
       def prepare_extend_sproc(ds)
         ds.extend(StoredProcedureMethods)
       end
+      
+      # Yield each row of the given result set r with columns cols
+      # as a hash with symbol keys
+      def yield_rows(r, cols)
+        while row = r.fetch_row
+          h = {}
+          cols.each{|n, p, i| v = row[i]; h[n] = (v && p) ? p.call(v) : v}
+          yield h
+        end
+      end
     end
   end
 end

data/lib/sequel/adapters/odbc.rb

@@ -90,7 +90,7 @@ module Sequel
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
-      TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S%N'}".freeze
+      TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S'}".freeze
 
       def fetch_rows(sql, &block)
         execute(sql) do |s|

data/lib/sequel/adapters/openbase.rb

@@ -37,7 +37,7 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
+      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
       
       def fetch_rows(sql)
         execute(sql) do |result|
@@ -57,8 +57,8 @@ module Sequel
       
       private
       
-      def select_clause_order
-        SELECT_CLAUSE_ORDER
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
       end
     end
   end

data/lib/sequel/adapters/oracle.rb

@@ -67,11 +67,7 @@ module Sequel
             yield(r) if block_given?
             r
           rescue OCIException => e
-            if CONNECTION_ERROR_CODES.include?(e.code)  
-              raise(Sequel::DatabaseDisconnectError)              
-            else
-              raise
-            end
+            raise_error(e, :disconnect=>CONNECTION_ERROR_CODES.include?(e.code))
           end
         end
       end

data/lib/sequel/adapters/postgres.rb

@@ -144,14 +144,14 @@ module Sequel
         q = nil
         begin
           q = args ? async_exec(sql, args) : async_exec(sql)
-        rescue PGError
+        rescue PGError => e
           begin
             s = status
           rescue PGError
-            raise(Sequel::DatabaseDisconnectError)
+            raise Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)
           end
           status_ok = (s == Adapter::CONNECTION_OK)
-          status_ok ? raise : raise(Sequel::DatabaseDisconnectError)
+          status_ok ? raise : Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)
         ensure
           block if status_ok
         end

data/lib/sequel/adapters/shared/mssql.rb

@@ -2,6 +2,8 @@ module Sequel
   module MSSQL
     module DatabaseMethods
       AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      SERVER_VERSION_RE = /^(\d+)\.(\d+)\.(\d+)/.freeze
+      SERVER_VERSION_SQL = "SELECT CAST(SERVERPROPERTY('ProductVersion') AS varchar)".freeze
       SQL_BEGIN = "BEGIN TRANSACTION".freeze
       SQL_COMMIT = "COMMIT TRANSACTION".freeze
       SQL_ROLLBACK = "ROLLBACK TRANSACTION".freeze
@@ -13,7 +15,26 @@ module Sequel
       def database_type
         :mssql
       end
-
+      
+      # The version of the MSSQL server, as an integer (e.g. 10001600 for
+      # SQL Server 2008 Express).
+      def server_version(server=nil)
+        return @server_version if @server_version
+        @server_version = synchronize(server) do |conn|
+          (conn.server_version rescue nil) if conn.respond_to?(:server_version)
+        end
+        unless @server_version
+          m = SERVER_VERSION_RE.match(fetch(SERVER_VERSION_SQL).single_value.to_s)
+          @server_version = (m[1].to_i * 1000000) + (m[2].to_i * 10000) + m[3].to_i
+        end
+        @server_version
+      end
+        
+      # MSSQL supports savepoints, though it doesn't support committing/releasing them savepoint
+      def supports_savepoints?
+        true
+      end
+      
       # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
       # information on tables.
       def tables(opts={})
@@ -23,11 +44,6 @@ module Sequel
           filter(:table_type=>'BASE TABLE', :table_schema=>(opts[:schema]||default_schema||'dbo').to_s).
           map{|x| m.call(x[:table_name])}
       end
-        
-      # MSSQL supports savepoints, though it doesn't support committing/releasing them savepoint
-      def supports_savepoints?
-        true
-      end
 
       private
       
@@ -83,6 +99,13 @@ module Sequel
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end
       
+      # Always quote identifiers in the metadata_dataset, so schema parsing works.
+      def metadata_dataset
+        ds = super
+        ds.quote_identifiers = true
+        ds
+      end
+      
       # SQL to rollback to a savepoint
       def rollback_savepoint_sql(depth)
         SQL_ROLLBACK_TO_SAVEPOINT % depth
@@ -113,7 +136,7 @@ module Sequel
           [m.call(row.delete(:column)), row]
         end
       end
-
+      
       # SQL fragment for marking a table as temporary
       def temporary_table_sql
         TEMPORARY
@@ -145,11 +168,14 @@ module Sequel
     module DatasetMethods
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
-      SELECT_CLAUSE_ORDER = %w'with limit distinct columns from table_options join where group order having compounds'.freeze
-      TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S'".freeze
+      COMMA_SEPARATOR = ', '.freeze
+      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'with from output from2 where')
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'with into columns output values')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with limit distinct columns from table_options join where group order having compounds')
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with table set output from where')
       WILDCARD = LiteralString.new('*').freeze
       CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}
-      
+
       # MSSQL uses + for string concatenation
       def complex_expression_sql(op, args)
         case op
@@ -167,8 +193,8 @@ module Sequel
       
       # When returning all rows, if an offset is used, delete the row_number column
       # before yielding the row.
-      def each(&block)
-        @opts[:offset] ? super{|r| r.delete(row_number_column); yield r} : super(&block)
+      def fetch_rows(sql, &block)
+        @opts[:offset] ? super(sql){|r| r.delete(row_number_column); yield r} : super(sql, &block)
       end
       
       # MSSQL uses the CONTAINS keyword for full text search
@@ -178,15 +204,43 @@ module Sequel
       
       # MSSQL uses a UNION ALL statement to insert multiple values at once.
       def multi_insert_sql(columns, values)
-        values = values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")
-        ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) #{values}"]
+        [insert_sql(columns, LiteralString.new(values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")))]
       end
 
       # Allows you to do .nolock on a query
       def nolock
         clone(:table_options => "(NOLOCK)")
       end
-      
+
+      # Include an OUTPUT clause in the eventual INSERT, UPDATE, or DELETE query.
+      #
+      # The first argument is the table to output into, and the second argument
+      # is either an Array of column values to select, or a Hash which maps output
+      # column names to selected values, in the style of #insert or #update.
+      #
+      # Output into a returned result set is not currently supported.
+      #
+      # Examples:
+      #
+      #   dataset.output(:output_table, [:deleted__id, :deleted__name])
+      #   dataset.output(:output_table, :id => :inserted__id, :name => :inserted__name)
+      def output(into, values)
+        output = {}
+        case values
+          when Hash:
+            output[:column_list], output[:select_list] = values.keys, values.values
+          when Array:
+            output[:select_list] = values
+        end
+        output[:into] = into
+        clone({:output => output})
+      end
+
+      # An output method that modifies the receiver.
+      def output!(into, values)
+        mutation_method(:output, into, values)
+      end
+
       # MSSQL uses [] to quote identifiers
       def quoted_identifier(name)
         "[#{name}]"
@@ -218,6 +272,11 @@ module Sequel
           select_sql
       end
 
+      # The version of the database server.
+      def server_version
+        db.server_version(@opts[:server])
+      end
+
       # Microsoft SQL Server does not support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
@@ -227,19 +286,56 @@ module Sequel
       def supports_is_true?
         false
       end
-      
-      # MSSQL supports timezones in literal timestamps
-      def supports_timestamp_timezones?
-        true
-      end
-      
+
       # MSSQL 2005+ supports window functions
       def supports_window_functions?
         true
       end
 
       private
+
+      # MSSQL can modify joined datasets
+      def check_modification_allowed!
+        raise(InvalidOperation, "Grouped datasets cannot be modified") if opts[:group]
+      end
+
+      # MSSQL supports the OUTPUT clause for DELETE statements.
+      # It also allows prepending a WITH clause.
+      def delete_clause_methods
+        DELETE_CLAUSE_METHODS
+      end
+
+      # Handle the with clause for delete, insert, and update statements
+      # to be the same as the insert statement.
+      def delete_with_sql(sql)
+        select_with_sql(sql)
+      end
+      alias insert_with_sql delete_with_sql
+      alias update_with_sql delete_with_sql
       
+      # MSSQL raises an error if you try to provide more than 3 decimal places
+      # for a fractional timestamp.  This probably doesn't work for smalldatetime
+      # fields.
+      def format_timestamp_usec(usec)
+        sprintf(".%03d", usec/1000)
+      end
+
+      # MSSQL supports FROM clauses in DELETE and UPDATE statements.
+      def from_sql(sql)
+        if (opts[:from].is_a?(Array) && opts[:from].size > 1) || opts[:join]
+          select_from_sql(sql)
+          select_join_sql(sql)
+        end
+      end
+      alias delete_from2_sql from_sql
+      alias update_from_sql from_sql
+      
+      # MSSQL supports the OUTPUT clause for INSERT statements.
+      # It also allows prepending a WITH clause.
+      def insert_clause_methods
+        INSERT_CLAUSE_METHODS
+      end
+
       # MSSQL uses a literal hexidecimal number for blob strings
       def literal_blob(v)
         blob = '0x'
@@ -252,20 +348,10 @@ module Sequel
         "N#{super}"
       end
       
-      # Use MSSQL Timestamp format
-      def literal_datetime(v)
-        v.strftime(TIMESTAMP_FORMAT)
-      end
-      
       # Use 0 for false on MSSQL
       def literal_false
         BOOL_FALSE
       end
-      
-      # Use MSSQL Timestamp format
-      def literal_time(v)
-        v.strftime(TIMESTAMP_FORMAT)
-      end
 
       # Use 1 for true on MSSQL
       def literal_true
@@ -278,8 +364,8 @@ module Sequel
       end
 
       # MSSQL adds the limit before the columns
-      def select_clause_order
-        SELECT_CLAUSE_ORDER
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
       end
 
       # MSSQL uses TOP for limit
@@ -291,6 +377,29 @@ module Sequel
       def select_table_options_sql(sql)
         sql << " WITH #{@opts[:table_options]}" if @opts[:table_options]
       end
+
+      # SQL fragment for MSSQL's OUTPUT clause.
+      def output_sql(sql)
+        return unless output = @opts[:output]
+        sql << " OUTPUT #{column_list(output[:select_list])}"
+        if into = output[:into]
+          sql << " INTO #{table_ref(into)}"
+          if column_list = output[:column_list]
+            cl = []
+            column_list.each { |k, v| cl << literal(String === k ? k.to_sym : k) }
+            sql << " (#{cl.join(COMMA_SEPARATOR)})"
+          end
+        end
+      end
+      alias delete_output_sql output_sql
+      alias update_output_sql output_sql
+      alias insert_output_sql output_sql
+
+      # MSSQL supports the OUTPUT clause for UPDATE statements.
+      # It also allows prepending a WITH clause.
+      def update_clause_methods
+        UPDATE_CLAUSE_METHODS
+      end
     end
   end
 end