sequel 3.21.0 → 3.32.0

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

@@ -1,3 +1,5 @@
+Sequel.require 'adapters/utils/emulate_offset_with_row_number'
+
 module Sequel
   Dataset::NON_SQL_OPTIONS << :disable_insert_output
   module MSSQL
@@ -11,15 +13,41 @@ module Sequel
       SQL_ROLLBACK_TO_SAVEPOINT = 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION autopoint_%d'.freeze
       SQL_SAVEPOINT = 'SAVE TRANSACTION autopoint_%d'.freeze
       
+      # Whether to use N'' to quote strings, which allows unicode characters inside the
+      # strings.  True by default for compatibility, can be set to false for a possible
+      # performance increase.  This sets the default for all datasets created from this
+      # Database object.
+      attr_accessor :mssql_unicode_strings
+
       # The types to check for 0 scale to transform :decimal types
       # to :integer.
       DECIMAL_TYPE_RE = /number|numeric|decimal/io
-      
+
       # Microsoft SQL Server uses the :mssql type.
       def database_type
         :mssql
       end
       
+      # Use the system tables to get index information
+      def indexes(table, opts={})
+        m = output_identifier_meth
+        im = input_identifier_meth
+        indexes = {}
+        metadata_dataset.from(:sys__tables___t).
+         join(:sys__indexes___i, :object_id=>:object_id).
+         join(:sys__index_columns___ic, :object_id=>:object_id, :index_id=>:index_id).
+         join(:sys__columns___c, :object_id=>:object_id, :column_id=>:column_id).
+         select(:i__name, :i__is_unique, :c__name___column).
+         where{{t__name=>im.call(table)}}.
+         where(:i__is_primary_key=>0, :i__is_disabled=>0).
+         order(:i__name, :ic__index_column_id).
+         each do |r|
+          index = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>(r[:is_unique] && r[:is_unique]!=0)}
+          index[:columns] << m.call(r[:column])
+        end
+        indexes
+      end
+
       # The version of the MSSQL server, as an integer (e.g. 10001600 for
       # SQL Server 2008 Express).
       def server_version(server=nil)
@@ -47,11 +75,13 @@ module Sequel
       # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
       # information on tables.
       def tables(opts={})
-        m = output_identifier_meth
-        metadata_dataset.from(:information_schema__tables___t).
-          select(:table_name).
-          filter(:table_type=>'BASE TABLE', :table_schema=>(opts[:schema]||default_schema||'dbo').to_s).
-          map{|x| m.call(x[:table_name])}
+        information_schema_tables('BASE TABLE', opts)
+      end
+
+      # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
+      # information on views.
+      def views(opts={})
+        information_schema_tables('VIEW', opts)
       end
 
       private
@@ -69,7 +99,21 @@ module Sequel
         when :rename_column
           "sp_rename #{literal("#{quote_schema_table(table)}.#{quote_identifier(op[:name])}")}, #{literal(op[:new_name].to_s)}, 'COLUMN'"
         when :set_column_type
-          "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+          sqls = []
+          if sch = schema(table)
+            if cs = sch.each{|k, v| break v if k == op[:name]; nil}
+              cs = cs.dup
+              if constraint = default_constraint_name(table, op[:name])
+                sqls << "ALTER TABLE #{quote_schema_table(table)} DROP CONSTRAINT #{constraint}"
+              end
+              cs[:default] = cs[:ruby_default]
+              op = cs.merge!(op)
+              default = op.delete(:default)
+            end
+          end
+          sqls << "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{column_definition_sql(op)}"
+          sqls << alter_table_sql(table, op.merge(:op=>:set_column_default, :default=>default)) if default
+          sqls
         when :set_column_null
           sch = schema(table).find{|k,v| k.to_s == op[:name].to_s}.last
           type = sch[:db_type]
@@ -97,7 +141,7 @@ module Sequel
       # Commit the active transaction on the connection, does not commit/release
       # savepoints.
       def commit_transaction(conn, opts={})
-        log_connection_execute(conn, commit_transaction_sql) unless Thread.current[:sequel_transaction_depth] > 1
+        log_connection_execute(conn, commit_transaction_sql) unless @transactions[conn][:savepoint_level] > 1
       end
 
       # SQL to COMMIT a transaction.
@@ -112,11 +156,32 @@ module Sequel
         "CREATE TABLE #{quote_schema_table(options[:temp] ? "##{name}" : name)} (#{column_list_sql(generator)})"
       end
       
+      # The name of the constraint for setting the default value on the table and column.
+      def default_constraint_name(table, column)
+        from(:sysobjects___c_obj).
+          join(:syscomments___com, :id=>:id).
+          join(:sysobjects___t_obj, :id=>:c_obj__parent_obj).
+          join(:sysconstraints___con, :constid=>:c_obj__id).
+          join(:syscolumns___col, :id=>:t_obj__id, :colid=>:colid).
+          where{{c_obj__uid=>user_id{}}}.
+          where(:c_obj__xtype=>'D', :t_obj__name=>table.to_s, :col__name=>column.to_s).
+          get(:c_obj__name)
+      end
+
       # The SQL to drop an index for the table.
       def drop_index_sql(table, op)
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end
       
+      # Backbone of the tables and views support.
+      def information_schema_tables(type, opts)
+        m = output_identifier_meth
+        metadata_dataset.from(:information_schema__tables___t).
+          select(:table_name).
+          filter(:table_type=>type, :table_schema=>(opts[:schema]||default_schema||'dbo').to_s).
+          map{|x| m.call(x[:table_name])}
+      end
+
       # Always quote identifiers in the metadata_dataset, so schema parsing works.
       def metadata_dataset
         ds = super
@@ -139,20 +204,41 @@ module Sequel
         SQL_ROLLBACK
       end
       
-      # MSSQL uses the INFORMATION_SCHEMA to hold column information.  This method does
-      # not support the parsing of primary key information.
+      # The closest MSSQL equivalent of a boolean datatype is the bit type.
+      def schema_column_type(db_type)
+        case db_type
+        when /\A(bit)\z/io
+          :boolean
+        else
+          super
+        end
+      end
+
+      # MSSQL uses the INFORMATION_SCHEMA to hold column information, and
+      # parses primary key information from the sysindexes, sysindexkeys,
+      # and syscolumns system tables.
       def schema_parse_table(table_name, opts)
-        m = output_identifier_meth
-        m2 = input_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
+        m2 = input_identifier_meth(opts[:dataset])
+        tn = m2.call(table_name.to_s)
+        table_id = get{object_id(tn)}
+        pk_index_id = metadata_dataset.from(:sysindexes).
+          where(:id=>table_id, :indid=>1..254){{(status & 2048)=>2048}}.
+          get(:indid)
+        pk_cols = metadata_dataset.from(:sysindexkeys___sik).
+          join(:syscolumns___sc, :id=>:id, :colid=>:colid).
+          where(:sik__id=>table_id, :sik__indid=>pk_index_id).
+          select_order_map(:sc__name)
         ds = metadata_dataset.from(:information_schema__tables___t).
          join(:information_schema__columns___c, :table_catalog=>:table_catalog,
               :table_schema => :table_schema, :table_name => :table_name).
          select(:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, :column_default___default, :is_nullable___allow_null, :numeric_precision___column_size, :numeric_scale___scale).
-         filter(:c__table_name=>m2.call(table_name.to_s))
+         filter(:c__table_name=>tn)
         if schema = opts[:schema] || default_schema
           ds.filter!(:c__table_schema=>schema)
         end
         ds.map do |row|
+          row[:primary_key] = pk_cols.include?(row[:column])
           row[:allow_null] = row[:allow_null] == 'YES' ? true : false
           row[:default] = nil if blank_object?(row[:default])
           row[:type] = if row[:db_type] =~ DECIMAL_TYPE_RE && row[:scale] == 0
@@ -163,6 +249,11 @@ module Sequel
           [m.call(row.delete(:column)), row]
         end
       end
+
+      # Set the mssql_unicode_strings settings from the given options.
+      def set_mssql_unicode_strings
+        @mssql_unicode_strings = typecast_value_boolean(@opts.fetch(:mssql_unicode_strings, true))
+      end
       
       # MSSQL has both datetime and timestamp classes, most people are going
       # to want datetime
@@ -189,49 +280,103 @@ module Sequel
       # support for clustered index type
       def index_definition_sql(table_name, index)
         index_name = index[:name] || default_index_name(table_name, index[:columns])
-        clustered = index[:type] == :clustered
-        if index[:where]
-          raise Error, "Partial indexes are not supported for this database"
+        raise Error, "Partial indexes are not supported for this database" if index[:where]
+        if index[:type] == :full_text
+          "CREATE FULLTEXT INDEX ON #{quote_schema_table(table_name)} #{literal(index[:columns])} KEY INDEX #{literal(index[:key_index])}"
         else
-          "CREATE #{'UNIQUE ' if index[:unique]}#{'CLUSTERED ' if clustered}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}"
+          "CREATE #{'UNIQUE ' if index[:unique]}#{'CLUSTERED ' if index[:type] == :clustered}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}#{" INCLUDE #{literal(index[:include])}" if index[:include]}"
         end
       end
     end
   
     module DatasetMethods
+      include EmulateOffsetWithRowNumber
+
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.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 distinct limit columns into from lock join where group having order compounds')
-      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with table set output from where')
+      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'with delete from output from2 where')
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'with insert into columns output values')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct limit columns into from lock join where group having order compounds')
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with update table set output from where')
       NOLOCK = ' WITH (NOLOCK)'.freeze
       UPDLOCK = ' WITH (UPDLOCK)'.freeze
       WILDCARD = LiteralString.new('*').freeze
       CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}
+      EXTRACT_MAP = {:year=>"yy", :month=>"m", :day=>"d", :hour=>"hh", :minute=>"n", :second=>"s"}
+      BRACKET_CLOSE = Dataset::BRACKET_CLOSE
+      BRACKET_OPEN = Dataset::BRACKET_OPEN
+      COMMA = Dataset::COMMA
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      PAREN_SPACE_OPEN = Dataset::PAREN_SPACE_OPEN
+      SPACE = Dataset::SPACE
+      FROM = Dataset::FROM
+      APOS = Dataset::APOS
+      APOS_RE = Dataset::APOS_RE
+      DOUBLE_APOS = Dataset::DOUBLE_APOS
+      INTO = Dataset::INTO
+      DATEPART_SECOND_OPEN = "CAST((datepart(".freeze
+      DATEPART_SECOND_MIDDLE = ') + datepart(ns, '.freeze
+      DATEPART_SECOND_CLOSE = ")/1000000000.0) AS double precision)".freeze
+      DATEPART_OPEN = "datepart(".freeze
+      UNION_ALL = ' UNION ALL '.freeze
+      SELECT_SPACE = 'SELECT '.freeze
+      TIMESTAMP_USEC_FORMAT = ".%03d".freeze
+      OUTPUT_INSERTED = " OUTPUT INSERTED.*".freeze
+      HEX_START = '0x'.freeze
+      UNICODE_STRING_START = "N'".freeze
+      TOP_PAREN = " TOP (".freeze
+      TOP = " TOP ".freeze
+      OUTPUT = " OUTPUT ".freeze
+      HSTAR = "H*".freeze
+      CASE_SENSITIVE_COLLATION = 'Latin1_General_CS_AS'.freeze
+      CASE_INSENSITIVE_COLLATION = 'Latin1_General_CI_AS'.freeze
+
+      # Allow overriding of the mssql_unicode_strings option at the dataset level.
+      attr_accessor :mssql_unicode_strings
+
+      # Copy the mssql_unicode_strings option from the +db+ object.
+      def initialize(db, opts={})
+        super
+        @mssql_unicode_strings = db.mssql_unicode_strings
+      end
 
       # MSSQL uses + for string concatenation, and LIKE is case insensitive by default.
-      def complex_expression_sql(op, args)
+      def complex_expression_sql_append(sql, op, args)
         case op
         when :'||'
-          super(:+, args)
-        when :ILIKE
-          super(:LIKE, args)
-        when :"NOT ILIKE"
-          super(:"NOT LIKE", args)
+          super(sql, :+, args)
+        when :LIKE, :"NOT LIKE"
+          super(sql, op, args.map{|a| LiteralString.new("(#{literal(a)} COLLATE #{CASE_SENSITIVE_COLLATION})")})
+        when :ILIKE, :"NOT ILIKE"
+          super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args.map{|a| LiteralString.new("(#{literal(a)} COLLATE #{CASE_INSENSITIVE_COLLATION})")})
         when :<<
-          "(#{literal(args[0])} * POWER(2, #{literal(args[1])}))"
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
         when :>>
-          "(#{literal(args[0])} / POWER(2, #{literal(args[1])}))"
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+        when :extract
+          part = args.at(0)
+          raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
+          if part == :second
+            expr = literal(args.at(1))
+            sql << DATEPART_SECOND_OPEN << format.to_s << COMMA << expr << DATEPART_SECOND_MIDDLE << expr << DATEPART_SECOND_CLOSE
+          else
+            sql << DATEPART_OPEN << format.to_s << COMMA
+            literal_append(sql, args.at(1))
+            sql << PAREN_CLOSE
+          end
         else
-          super(op, args)
+          super
         end
       end
       
       # MSSQL doesn't support the SQL standard CURRENT_DATE or CURRENT_TIME
-      def constant_sql(constant)
-        CONSTANT_MAP[constant] || super
+      def constant_sql_append(sql, constant)
+        if c = CONSTANT_MAP[constant]
+          sql << c
+        else
+          super
+        end
       end
       
       # Disable the use of INSERT OUTPUT
@@ -244,21 +389,16 @@ module Sequel
         mutation_method(:disable_insert_output)
       end
 
-      # When returning all rows, if an offset is used, delete the row_number column
-      # before yielding the row.
-      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
       def full_text_search(cols, terms, opts = {})
-        filter("CONTAINS (#{literal(cols)}, #{literal(terms)})")
+        terms = "\"#{terms.join('" OR "')}\"" if terms.is_a?(Array)
+        filter("CONTAINS (?, ?)", cols, terms)
       end
 
       # Use the OUTPUT clause to get the value of all columns for the newly inserted record.
       def insert_select(*values)
-        return unless supports_output_clause?
-        naked.clone(default_server_opts(:sql=>output(nil, [:inserted.*]).insert_sql(*values))).single_record unless opts[:disable_insert_output]
+        return unless supports_insert_select?
+        naked.clone(default_server_opts(:sql=>output(nil, [SQL::ColumnAll.new(:inserted)]).insert_sql(*values))).single_record
       end
 
       # Specify a table for a SELECT ... INTO query.
@@ -266,17 +406,18 @@ module Sequel
         clone(:into => table)
       end
 
-      # SQL Server does not support CTEs on subqueries, so move any CTEs
-      # on joined datasets to the top level. The user is responsible for
-      # resolving any name clashes this may cause.
-      def join_table(type, table, expr=nil, table_alias={}, &block)
-        return super unless Dataset === table && table.opts[:with]
-        clone(:with => (opts[:with] || []) + table.opts[:with]).join_table(type, table.clone(:with => nil), expr, table_alias, &block)
-      end
-
       # MSSQL uses a UNION ALL statement to insert multiple values at once.
       def multi_insert_sql(columns, values)
-        [insert_sql(columns, LiteralString.new(values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")))]
+        c = false
+        sql = LiteralString.new('')
+        u = UNION_ALL
+        values.each do |v|
+          sql << u if c
+          sql << SELECT_SPACE
+          expression_list_append(sql, v)
+          c ||= true
+        end
+        [insert_sql(columns, sql)]
       end
 
       # Allows you to do a dirty read of uncommitted data using WITH (NOLOCK).
@@ -315,38 +456,30 @@ module Sequel
       end
 
       # MSSQL uses [] to quote identifiers
-      def quoted_identifier(name)
-        "[#{name}]"
+      def quoted_identifier_append(sql, name)
+        sql << BRACKET_OPEN << name.to_s << BRACKET_CLOSE
       end
       
-      # MSSQL Requires the use of the ROW_NUMBER window function to emulate
-      # an offset.  This implementation requires MSSQL 2005 or greater (offset
-      # can't be emulated well in MSSQL 2000).
-      # 
-      # The implementation is ugly, cloning the current dataset and modifying
-      # the clone to add a ROW_NUMBER window function (and some other things),
-      # then using the modified clone in a subselect which is selected from.
-      #
-      # If offset is used, an order must be provided, because the use of ROW_NUMBER
-      # requires an order.
-      def select_sql
-        return super unless o = @opts[:offset]
-        raise(Error, 'MSSQL requires an order be provided if using an offset') unless order = @opts[:order]
-        dsa1 = dataset_alias(1)
-        rn = row_number_column
-        subselect_sql(unlimited.
-          unordered.
-          select_append{ROW_NUMBER(:over, :order=>order){}.as(rn)}.
-          from_self(:alias=>dsa1).
-          limit(@opts[:limit]).
-          where(SQL::Identifier.new(rn) > o))
-      end
-
       # The version of the database server.
       def server_version
         db.server_version(@opts[:server])
       end
 
+      # MSSQL 2005+ supports GROUP BY CUBE.
+      def supports_group_cube?
+        is_2005_or_later?
+      end
+
+      # MSSQL 2005+ supports GROUP BY ROLLUP
+      def supports_group_rollup?
+        is_2005_or_later?
+      end
+
+      # MSSQL supports insert_select via the OUTPUT clause.
+      def supports_insert_select?
+        supports_output_clause? && !opts[:disable_insert_output]
+      end
+
       # MSSQL 2005+ supports INTERSECT and EXCEPT
       def supports_intersect_except?
         is_2005_or_later?
@@ -381,14 +514,38 @@ module Sequel
       def supports_window_functions?
         true
       end
+
+      # MSSQL cannot use WHERE 1.
+      def supports_where_true?
+        false
+      end
       
       protected
+      
+      # If returned primary keys are requested, use OUTPUT unless already set on the
+      # dataset.  If OUTPUT is already set, use existing returning values.  If OUTPUT
+      # is only set to return a single columns, return an array of just that column.
+      # Otherwise, return an array of hashes.
+      def _import(columns, values, opts={})
+        if opts[:return] == :primary_key && !@opts[:output]
+          output(nil, [SQL::QualifiedIdentifier.new(:inserted, first_primary_key)])._import(columns, values, opts)
+        elsif @opts[:output]
+          statements = multi_insert_sql(columns, values)
+          @db.transaction(opts.merge(:server=>@opts[:server])) do
+            statements.map{|st| with_sql(st)}
+          end.first.map{|v| v.length == 1 ? v.values.first : v}
+        else
+          super
+        end
+      end
+
       # MSSQL does not allow ordering in sub-clauses unless 'top' (limit) is specified
       def aggregate_dataset
         (options_overlap(Sequel::Dataset::COUNT_FROM_SELF_OPTS) && !options_overlap([:limit])) ? unordered.from_self : super
       end
 
       private
+
       def is_2005_or_later?
         server_version >= 9000000
       end
@@ -401,7 +558,8 @@ module Sequel
 
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
-        sql << " FROM #{source_list(@opts[:from][0..0])}"
+        sql << FROM
+        source_list_append(sql, @opts[:from][0..0])
       end
 
       # MSSQL supports FROM clauses in DELETE and UPDATE statements.
@@ -413,19 +571,17 @@ module Sequel
       end
       alias update_from_sql delete_from2_sql
       
-      # 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)
+      # Return the first primary key for the current table.  If this table has
+      # multiple primary keys, this will only return one of them.  Used by #_import.
+      def first_primary_key
+        @db.schema(self).map{|k, v| k if v[:primary_key] == true}.compact.first
       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)
+        sprintf(TIMESTAMP_USEC_FORMAT, usec/1000)
       end
 
       # MSSQL supports the OUTPUT clause for INSERT statements.
@@ -434,16 +590,26 @@ module Sequel
         INSERT_CLAUSE_METHODS
       end
 
+      # Use OUTPUT INSERTED.* to return all columns of the inserted row,
+      # for use with the prepared statement code.
+      def insert_output_sql(sql)
+        if @opts.has_key?(:returning)
+          sql << OUTPUT_INSERTED
+        else
+          output_sql(sql)
+        end
+      end
+
       # MSSQL uses a literal hexidecimal number for blob strings
-      def literal_blob(v)
-        blob = '0x'
-        v.each_byte{|x| blob << sprintf('%02x', x)}
-        blob
+      def literal_blob_append(sql, v)
+        sql << HEX_START << v.unpack(HSTAR).first
       end
       
-      # Use unicode string syntax for all strings. Don't double backslashes.
-      def literal_string(v)
-        "N'#{v.gsub(/'/, "''")}'"
+      # Optionally use unicode string syntax for all strings. Don't double
+      # backslashes.
+      def literal_string_append(sql, v)
+        sql << (mssql_unicode_strings ? UNICODE_STRING_START : APOS)
+        sql << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
       end
       
       # Use 0 for false on MSSQL
@@ -456,27 +622,30 @@ module Sequel
         BOOL_TRUE
       end
       
-      # The alias to use for the row_number column when emulating OFFSET
-      def row_number_column
-        :x_sequel_row_number_x
-      end
-
       # MSSQL adds the limit before the columns
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end
 
       def select_into_sql(sql)
-        sql << " INTO #{table_ref(@opts[:into])}" if @opts[:into]
+        if i = @opts[:into]
+          sql << INTO
+          table_ref_append(sql, i)
+        end
       end
 
       # MSSQL uses TOP N for limit.  For MSSQL 2005+ TOP (N) is used
       # to allow the limit to be a bound variable.
       def select_limit_sql(sql)
         if l = @opts[:limit]
-          l = literal(l)
-          l = "(#{l})" if server_version >= 9000000
-          sql << " TOP #{l}"
+          if is_2005_or_later?
+            sql << TOP_PAREN
+            literal_append(sql, l)
+            sql << PAREN_CLOSE
+          else
+            sql << TOP
+            literal_append(sql, l)
+          end
         end
       end
 
@@ -496,19 +665,20 @@ module Sequel
       def output_sql(sql)
         return unless supports_output_clause?
         return unless output = @opts[:output]
-        sql << " OUTPUT #{column_list(output[:select_list])}"
+        sql << OUTPUT
+        column_list_append(sql, output[:select_list])
         if into = output[:into]
-          sql << " INTO #{table_ref(into)}"
+          sql << INTO
+          table_ref_append(sql, 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)})"
+            sql << PAREN_SPACE_OPEN
+            source_list_append(sql, column_list)
+            sql << PAREN_CLOSE
           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.
@@ -518,7 +688,8 @@ module Sequel
 
       # Only include the primary table in the main update clause
       def update_table_sql(sql)
-        sql << " #{source_list(@opts[:from][0..0])}"
+        sql << SPACE
+        source_list_append(sql, @opts[:from][0..0])
       end
     end
   end