sequel 4.45.0 → 4.46.0

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

@@ -8,7 +8,9 @@ module Sequel
 
     module DatabaseMethods
       AUTO_INCREMENT = ''.freeze
+      Sequel::Deprecation.deprecate_constant(self, :AUTO_INCREMENT)
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :TEMPORARY)
 
       def clear_primary_key(*tables)
         tables.each{|t| @primary_keys.delete(dataset.send(:input_identifier, t))}
@@ -54,6 +56,10 @@ module Sequel
 
       private
 
+      def temporary_table_sql
+        'GLOBAL TEMPORARY '
+      end
+
       # Use Firebird specific syntax for add column
       def alter_table_sql(table, op)
         case op[:op]
@@ -70,8 +76,8 @@ module Sequel
         end
       end
 
-      def auto_increment_sql()
-        AUTO_INCREMENT
+      def auto_increment_sql
+        ''
       end
       
       def create_sequence_sql(name, opts=OPTS)
@@ -158,12 +164,18 @@ module Sequel
     end
 
     module DatasetMethods
+      NULL = LiteralString.new('NULL').freeze
+
       BOOL_TRUE = '1'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
       BOOL_FALSE = '0'.freeze
-      NULL = LiteralString.new('NULL').freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
       FIRST = " FIRST ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :FIRST)
       SKIP = " SKIP ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SKIP)
       DEFAULT_FROM = " FROM RDB$DATABASE"
+      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_FROM)
       
       Dataset.def_sql_method(self, :select, %w'with select distinct limit columns from join where group having compounds order')
       Dataset.def_sql_method(self, :insert, %w'insert into columns values returning')
@@ -213,7 +225,7 @@ module Sequel
       private
 
       def empty_from_sql
-        DEFAULT_FROM
+        " FROM RDB$DATABASE"
       end
 
       def insert_pk(*values)
@@ -222,11 +234,11 @@ module Sequel
       end
 
       def literal_false
-        BOOL_FALSE
+        '0'
       end
 
       def literal_true
-        BOOL_TRUE
+        '1'
       end
 
       # Firebird can insert multiple rows using a UNION
@@ -236,11 +248,11 @@ module Sequel
 
       def select_limit_sql(sql)
         if l = @opts[:limit]
-          sql << FIRST
+          sql << " FIRST "
           literal_append(sql, l)
         end
         if o = @opts[:offset]
-          sql << SKIP
+          sql << " SKIP "
           literal_append(sql, o)
         end
       end

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

@@ -8,6 +8,7 @@ module Sequel
 
     module DatabaseMethods
       TEMPORARY = 'TEMP '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :TEMPORARY)
 
       # Informix uses the :informix database type
       def database_type
@@ -24,13 +25,15 @@ module Sequel
 
       # SQL fragment for showing a table is temporary
       def temporary_table_sql
-        TEMPORARY
+        'TEMP '
       end
     end
     
     module DatasetMethods
       FIRST = " FIRST ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :FIRST)
       SKIP = " SKIP ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SKIP)
 
       Dataset.def_sql_method(self, :select, %w'select limit distinct columns from join where having group compounds order')
 
@@ -47,11 +50,11 @@ module Sequel
 
       def select_limit_sql(sql)
         if o = @opts[:offset]
-          sql << SKIP
+          sql << " SKIP "
           literal_append(sql, o)
         end
         if l = @opts[:limit]
-          sql << FIRST
+          sql << " FIRST "
           literal_append(sql, l)
         end
       end

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

@@ -14,14 +14,26 @@ module Sequel
 
     module DatabaseMethods
       AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :AUTO_INCREMENT)
       SERVER_VERSION_RE = /^(\d+)\.(\d+)\.(\d+)/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :SERVER_VERSION_RE)
       SERVER_VERSION_SQL = "SELECT CAST(SERVERPROPERTY('ProductVersion') AS varchar)".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SERVER_VERSION_SQL)
       SQL_BEGIN = "BEGIN TRANSACTION".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SQL_BEGIN)
       SQL_COMMIT = "COMMIT TRANSACTION".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SQL_COMMIT)
       SQL_ROLLBACK = "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SQL_ROLLBACK)
       SQL_ROLLBACK_TO_SAVEPOINT = 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION autopoint_%d'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :SQL_ROLLBACK_TO_SAVEPOINT)
       SQL_SAVEPOINT = 'SAVE TRANSACTION autopoint_%d'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :SQL_SAVEPOINT)
       MSSQL_DEFAULT_RE = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/
+      Sequel::Deprecation.deprecate_constant(self, :MSSQL_DEFAULT_RE)
+      DECIMAL_TYPE_RE = /number|numeric|decimal/io
+      Sequel::Deprecation.deprecate_constant(self, :DECIMAL_TYPE_RE)
+
       FOREIGN_KEY_ACTION_MAP = {0 => :no_action, 1 => :cascade, 2 => :set_null, 3 => :set_default}.freeze
 
       include Sequel::Database::SplitAlterTable
@@ -37,10 +49,6 @@ module Sequel
         reset_default_dataset
       end
 
-      # The types to check for 0 scale to transform :decimal types
-      # to :integer.
-      DECIMAL_TYPE_RE = /number|numeric|decimal/io
-
       # Execute the given stored procedure with the given name.
       #
       # Options:
@@ -215,7 +223,7 @@ module Sequel
           (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)
+          m = /^(\d+)\.(\d+)\.(\d+)/.match(fetch("SELECT CAST(SERVERPROPERTY('ProductVersion') AS varchar)").single_value.to_s)
           @server_version = (m[1].to_i * 1000000) + (m[2].to_i * 10000) + m[3].to_i
         end
         @server_version
@@ -265,7 +273,7 @@ module Sequel
 
       # MSSQL uses the IDENTITY(1,1) column for autoincrementing columns.
       def auto_increment_sql
-        AUTO_INCREMENT
+        'IDENTITY(1,1)'
       end
       
       # MSSQL specific syntax for altering tables.
@@ -310,12 +318,12 @@ module Sequel
       
       # SQL to start a new savepoint
       def begin_savepoint_sql(depth)
-        SQL_SAVEPOINT % depth
+        "SAVE TRANSACTION autopoint_#{depth}"
       end
 
       # SQL to BEGIN a transaction.
       def begin_transaction_sql
-        SQL_BEGIN
+        "BEGIN TRANSACTION"
       end
 
       # MSSQL does not allow adding primary key constraints to NULLable columns.
@@ -325,7 +333,7 @@ module Sequel
 
       # Handle MSSQL specific default format.
       def column_schema_normalize_default(default, type)
-        if m = MSSQL_DEFAULT_RE.match(default)
+        if m = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/.match(default)
           default = m[1] || m[2]
         end
         super(default, type)
@@ -339,7 +347,7 @@ module Sequel
 
       # SQL to COMMIT a transaction.
       def commit_transaction_sql
-        SQL_COMMIT
+        "COMMIT TRANSACTION"
       end
         
       # MSSQL uses the name of the table to decide the difference between
@@ -418,12 +426,12 @@ module Sequel
       
       # SQL to rollback to a savepoint
       def rollback_savepoint_sql(depth)
-        SQL_ROLLBACK_TO_SAVEPOINT % depth
+        "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION autopoint_#{depth}"
       end
       
       # SQL to ROLLBACK a transaction.
       def rollback_transaction_sql
-        SQL_ROLLBACK
+        "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
       end
       
       # The closest MSSQL equivalent of a boolean datatype is the bit type.
@@ -480,7 +488,7 @@ module Sequel
           end
           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
+          row[:type] = if row[:db_type] =~ /number|numeric|decimal/i && row[:scale] == 0
             :integer
           else
             schema_column_type(row[:db_type])
@@ -529,54 +537,98 @@ module Sequel
       end)
       include EmulateOffsetWithRowNumber
 
+      CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}#.freeze # SEQUEL5
+      EXTRACT_MAP = {:year=>"yy", :month=>"m", :day=>"d", :hour=>"hh", :minute=>"n", :second=>"s"}#.freeze # SEQUEL5
+      #EXTRACT_MAP.each_value(&:freeze) # SEQUEL5
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:disable_insert_output, :mssql_unicode_strings]).freeze
+      LIMIT_ALL = Object.new.freeze
+
       BOOL_TRUE = '1'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
       BOOL_FALSE = '0'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
       COMMA_SEPARATOR = ', '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :COMMA_SEPARATOR)
       TABLE_HINT = " WITH (".freeze
+      Sequel::Deprecation.deprecate_constant(self, :TABLE_HINT)
       READPAST = "READPAST".freeze
+      Sequel::Deprecation.deprecate_constant(self, :READPAST)
       NOLOCK = 'NOLOCK'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :NOLOCK)
       UPDLOCK = 'UPDLOCK'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :UPDLOCK)
       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
+      Sequel::Deprecation.deprecate_constant(self, :WILDCARD)
+      BRACKET_CLOSE =  ']'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BRACKET_CLOSE)
+      BRACKET_OPEN = '['.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BRACKET_OPEN)
+      COMMA = ', '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :COMMA)
+      PAREN_CLOSE = ')'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PAREN_CLOSE)
+      PAREN_SPACE_OPEN = ' ('.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PAREN_SPACE_OPEN)
+      SPACE = ' '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :SPACE)
+      FROM = ' FROM '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :FROM)
+      APOS = "'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :APOS)
+      APOS_RE = /'/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :APOS_RE)
+      DOUBLE_APOS = "''".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DOUBLE_APOS)
+      INTO = " INTO ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :INTO)
       DOUBLE_BRACKET_CLOSE = ']]'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DOUBLE_BRACKET_CLOSE)
       DATEPART_SECOND_OPEN = "CAST((datepart(".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATEPART_SECOND_OPEN)
       DATEPART_SECOND_MIDDLE = ') + datepart(ns, '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATEPART_SECOND_MIDDLE)
       DATEPART_SECOND_CLOSE = ")/1000000000.0) AS double precision)".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATEPART_SECOND_CLOSE)
       DATEPART_OPEN = "datepart(".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATEPART_OPEN)
       OUTPUT_INSERTED = " OUTPUT INSERTED.*".freeze
+      Sequel::Deprecation.deprecate_constant(self, :OUTPUT_INSERTED)
       HEX_START = '0x'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :HEX_START)
       UNICODE_STRING_START = "N'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :UNICODE_STRING_START)
       BACKSLASH_CRLF_RE = /\\((?:\r\n)|\n)/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BACKSLASH_CRLF_RE)
       BACKSLASH_CRLF_REPLACE = '\\\\\\\\\\1\\1'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BACKSLASH_CRLF_REPLACE)
       TOP_PAREN = " TOP (".freeze
+      Sequel::Deprecation.deprecate_constant(self, :TOP_PAREN)
       TOP = " TOP ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :TOP)
       OUTPUT = " OUTPUT ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :OUTPUT)
       HSTAR = "H*".freeze
+      Sequel::Deprecation.deprecate_constant(self, :HSTAR)
       CASE_SENSITIVE_COLLATION = 'Latin1_General_CS_AS'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CASE_SENSITIVE_COLLATION)
       CASE_INSENSITIVE_COLLATION = 'Latin1_General_CI_AS'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CASE_INSENSITIVE_COLLATION)
       DEFAULT_TIMESTAMP_FORMAT = "'%Y-%m-%dT%H:%M:%S%N%z'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_TIMESTAMP_FORMAT)
       FORMAT_DATE = "'%Y%m%d'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :FORMAT_DATE)
       CROSS_APPLY = 'CROSS APPLY'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CROSS_APPLY)
       OUTER_APPLY = 'OUTER APPLY'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :OUTER_APPLY)
       OFFSET = " OFFSET ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :OFFSET)
       ROWS = " ROWS".freeze
+      Sequel::Deprecation.deprecate_constant(self, :ROWS)
       ROWS_ONLY = " ROWS ONLY".freeze
+      Sequel::Deprecation.deprecate_constant(self, :ROWS_ONLY)
       FETCH_NEXT = " FETCH NEXT ".freeze
-
-      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:disable_insert_output, :mssql_unicode_strings]).freeze
-      LIMIT_ALL = Object.new.freeze
+      Sequel::Deprecation.deprecate_constant(self, :FETCH_NEXT)
 
       Dataset.def_mutation_method(:disable_insert_output, :output, :module=>self)
       Dataset.def_sql_method(self, :delete, %w'with delete limit from output from2 where')
@@ -604,25 +656,25 @@ module Sequel
         when :'||'
           super(sql, :+, args)
         when :LIKE, :"NOT LIKE"
-          super(sql, op, args.map{|a| Sequel.lit(["(", " COLLATE #{CASE_SENSITIVE_COLLATION})"], a)})
+          super(sql, op, args.map{|a| Sequel.lit(["(", " COLLATE Latin1_General_CS_AS)"], a)})
         when :ILIKE, :"NOT ILIKE"
-          super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args.map{|a| Sequel.lit(["(", " COLLATE #{CASE_INSENSITIVE_COLLATION})"], a)})
+          super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args.map{|a| Sequel.lit(["(", " COLLATE Latin1_General_CI_AS)"], a)})
         when :<<, :>>
           complex_expression_emulate_append(sql, op, args)
         when :extract
-          part = args.at(0)
+          part = args[0]
           raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
           if part == :second
-            expr = args.at(1)
-            sql << DATEPART_SECOND_OPEN << format.to_s << COMMA
+            expr = args[1]
+            sql << "CAST((datepart(" << format.to_s << ', '
             literal_append(sql, expr)
-            sql << DATEPART_SECOND_MIDDLE
+            sql << ') + datepart(ns, '
             literal_append(sql, expr)
-            sql << DATEPART_SECOND_CLOSE
+            sql << ")/1000000000.0) AS double precision)"
           else
-            sql << DATEPART_OPEN << format.to_s << COMMA
-            literal_append(sql, args.at(1))
-            sql << PAREN_CLOSE
+            sql << "datepart(" << format.to_s << ', '
+            literal_append(sql, args[1])
+            sql << ')'
           end
         else
           super
@@ -656,7 +708,7 @@ module Sequel
       # MSSQL uses the CONTAINS keyword for full text search
       def full_text_search(cols, terms, opts = OPTS)
         terms = "\"#{terms.join('" OR "')}\"" if terms.is_a?(Array)
-        where("CONTAINS (?, ?)", cols, terms)
+        where(Sequel.lit("CONTAINS (?, ?)", cols, terms))
       end
 
       # Use the OUTPUT clause to get the value of all columns for the newly inserted record.
@@ -714,7 +766,7 @@ module Sequel
 
       # MSSQL uses [] to quote identifiers.
       def quoted_identifier_append(sql, name)
-        sql << BRACKET_OPEN << name.to_s.gsub(/\]/, DOUBLE_BRACKET_CLOSE) << BRACKET_CLOSE
+        sql << '[' << name.to_s.gsub(/\]/, ']]') << ']'
       end
 
       # Emulate RETURNING using the output clause.  This only handles values that are simple column references.
@@ -895,12 +947,12 @@ module Sequel
       # since that is the format that is multilanguage and not
       # DATEFORMAT dependent.
       def default_timestamp_format
-        DEFAULT_TIMESTAMP_FORMAT
+        "'%Y-%m-%dT%H:%M:%S%N%z'"
       end
 
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
-        sql << FROM
+        sql << ' FROM '
         source_list_append(sql, @opts[:from][0..0])
       end
 
@@ -954,9 +1006,9 @@ module Sequel
       def join_type_sql(join_type)
         case join_type
         when :cross_apply
-          CROSS_APPLY
+          'CROSS APPLY'
         when :outer_apply
-          OUTER_APPLY
+          'OUTER APPLY'
         else
           super
         end
@@ -964,30 +1016,30 @@ module Sequel
 
       # MSSQL uses a literal hexidecimal number for blob strings
       def literal_blob_append(sql, v)
-        sql << HEX_START << v.unpack(HSTAR).first
+        sql << '0x' << v.unpack("H*").first
       end
       
       # Use YYYYmmdd format, since that's the only want that is
       # multilanguage and not DATEFORMAT dependent.
       def literal_date(v)
-        v.strftime(FORMAT_DATE)
+        v.strftime("'%Y%m%d'")
       end
 
       # Use 0 for false on MSSQL
       def literal_false
-        BOOL_FALSE
+        '0'
       end
 
       # 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).gsub(BACKSLASH_CRLF_RE, BACKSLASH_CRLF_REPLACE) << APOS
+        sql << (mssql_unicode_strings ? "N'" : "'")
+        sql << v.gsub("'", "''").gsub(/\\((?:\r\n)|\n)/, '\\\\\\\\\\1\\1') << "'"
       end
       
       # Use 1 for true on MSSQL
       def literal_true
-        BOOL_TRUE
+        '1'
       end
       
       # MSSQL 2008+ supports multiple rows in the VALUES clause, older versions
@@ -1003,7 +1055,7 @@ module Sequel
 
       def select_into_sql(sql)
         if i = @opts[:into]
-          sql << INTO
+          sql << " INTO "
           identifier_append(sql, i)
         end
       end
@@ -1022,12 +1074,12 @@ module Sequel
           if l == LIMIT_ALL
             sql << " TOP (100) PERCENT"
           else
-            sql << TOP_PAREN
+            sql << " TOP ("
             literal_append(sql, l)
-            sql << PAREN_CLOSE
+            sql << ')'
           end
         else
-          sql << TOP
+          sql << " TOP "
           literal_append(sql, l)
         end
       end
@@ -1048,25 +1100,25 @@ module Sequel
         lock_hint = for_update || dirty
 
         if lock_hint || skip_locked
-          sql << TABLE_HINT
+          sql << " WITH ("
 
           if lock_hint
             sql << if for_update
-              UPDLOCK
+              'UPDLOCK'
             else
-              NOLOCK
+              'NOLOCK'
             end
           end
 
           if lock_hint && skip_locked
-            sql << COMMA_SEPARATOR
+            sql << ', '
           end
 
           if skip_locked
-            sql << READPAST
+            sql << "READPAST"
           end
 
-          sql << PAREN_CLOSE
+          sql << ')'
         else
           super
         end
@@ -1078,14 +1130,14 @@ module Sequel
         super
         if is_2012_or_later? && @opts[:order]
           if o = @opts[:offset]
-            sql << OFFSET
+            sql << " OFFSET "
             literal_append(sql, o)
-            sql << ROWS
+            sql << " ROWS"
 
             if l = @opts[:limit]
-              sql << FETCH_NEXT
+              sql << " FETCH NEXT "
               literal_append(sql, l)
-              sql << ROWS_ONLY
+              sql << " ROWS ONLY"
             end
           end
         end
@@ -1102,21 +1154,21 @@ module Sequel
       end
 
       def output_list_sql(sql, output)
-        sql << OUTPUT
+        sql << " OUTPUT "
         column_list_append(sql, output[:select_list])
         if into = output[:into]
-          sql << INTO
+          sql << " INTO "
           identifier_append(sql, into)
           if column_list = output[:column_list]
-            sql << PAREN_SPACE_OPEN
+            sql << ' ('
             source_list_append(sql, column_list)
-            sql << PAREN_CLOSE
+            sql << ')'
           end
         end
       end
 
       def output_returning_sql(sql, type, values)
-        sql << OUTPUT
+        sql << " OUTPUT "
         if values.empty?
           literal_append(sql, SQL::ColumnAll.new(type))
         else
@@ -1132,14 +1184,22 @@ module Sequel
         end
       end
 
-      # MSSQL supports millisecond timestamp precision.
+      # MSSQL supports 100-nsec precision for time columns, but ruby by
+      # default only supports usec precision.
+      def sqltime_precision
+        6
+      end
+
+      # MSSQL supports millisecond timestamp precision for datetime columns.
+      # 100-nsec precision is supported for datetime2 columns, but Sequel does
+      # not know what the column type is when formatting values.
       def timestamp_precision
         3
       end
 
       # Only include the primary table in the main update clause
       def update_table_sql(sql)
-        sql << SPACE
+        sql << ' '
         source_list_append(sql, @opts[:from][0..0])
       end