sequel 3.21.0 → 3.41.0

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

@@ -1,3 +1,5 @@
+Sequel.require %w'emulate_offset_with_row_number split_alter_table', 'adapters/utils/'
+
 module Sequel
   Dataset::NON_SQL_OPTIONS << :disable_insert_output
   module MSSQL
@@ -10,16 +12,92 @@ module Sequel
       SQL_ROLLBACK = "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION".freeze
       SQL_ROLLBACK_TO_SAVEPOINT = 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION autopoint_%d'.freeze
       SQL_SAVEPOINT = 'SAVE TRANSACTION autopoint_%d'.freeze
+      MSSQL_DEFAULT_RE = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/
+      FOREIGN_KEY_ACTION_MAP = {0 => :no_action, 1 => :cascade, 2 => :set_null, 3 => :set_default}.freeze
+
+      include Sequel::Database::SplitAlterTable
       
+      # 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
       
+      # Microsoft SQL Server namespaces indexes per table.
+      def global_index_namespace?
+        false
+      end
+
+      # Return foreign key information using the system views, including
+      # :name, :on_delete, and :on_update entries in the hashes.
+      def foreign_key_list(table, opts={})
+        m = output_identifier_meth
+        im = input_identifier_meth
+        schema, table = schema_and_table(table)
+        current_schema = m.call(get(Sequel.function('schema_name')))
+        fk_action_map = FOREIGN_KEY_ACTION_MAP
+        ds = metadata_dataset.from(:sys__foreign_keys___fk).
+          join(:sys__foreign_key_columns___fkc, :constraint_object_id => :object_id).
+          join(:sys__all_columns___pc, :object_id => :fkc__parent_object_id,     :column_id => :fkc__parent_column_id).
+          join(:sys__all_columns___rc, :object_id => :fkc__referenced_object_id, :column_id => :fkc__referenced_column_id).
+          where{{object_schema_name(:fk__parent_object_id) => im.call(schema || current_schema)}}.
+          where{{object_name(:fk__parent_object_id) => im.call(table)}}.
+          select{[:fk__name, 
+                  :fk__delete_referential_action, 
+                  :fk__update_referential_action, 
+                  :pc__name___column, 
+                  :rc__name___referenced_column, 
+                  object_schema_name(:fk__referenced_object_id).as(:schema), 
+                  object_name(:fk__referenced_object_id).as(:table)]}.
+          order(:name, :fkc__constraint_column_id)
+        h = {}
+        ds.each do |row|
+          if r = h[row[:name]]
+            r[:columns] << m.call(row[:column])
+            r[:key] << m.call(row[:referenced_column])
+          else
+            referenced_schema = m.call(row[:schema])
+            referenced_table = m.call(row[:table])
+            h[row[:name]] = { :name      => m.call(row[:name]), 
+                              :table     => (referenced_schema == current_schema) ? referenced_table : :"#{referenced_schema}__#{referenced_table}",
+                              :columns   => [m.call(row[:column])], 
+                              :key       => [m.call(row[:referenced_column])], 
+                              :on_update => fk_action_map[row[:update_referential_action]], 
+                              :on_delete => fk_action_map[row[:delete_referential_action]] }
+          end
+        end
+        h.values
+      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)
@@ -44,18 +122,33 @@ module Sequel
         true
       end
 
+      # MSSQL supports transaction DDL statements.
+      def supports_transactional_ddl?
+        true
+      end
+
       # 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
       
+      # Add dropping of the default constraint to the list of SQL queries.
+      # This is necessary before dropping the column or changing its type.
+      def add_drop_default_constraint_sql(sqls, table, column)
+        if constraint = default_constraint_name(table, column)
+          sqls << "ALTER TABLE #{quote_schema_table(table)} DROP CONSTRAINT #{constraint}"
+        end
+      end
+
       # MSSQL uses the IDENTITY(1,1) column for autoincrementing columns.
       def auto_increment_sql
         AUTO_INCREMENT
@@ -66,10 +159,26 @@ module Sequel
         case op[:op]
         when :add_column
           "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
+        when :drop_column
+          sqls = []
+          add_drop_default_constraint_sql(sqls, table, op[:name])
+          sqls << super
         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
+              add_drop_default_constraint_sql(sqls, table, op[:name])
+              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]
@@ -94,10 +203,18 @@ module Sequel
         SQL_BEGIN
       end
       
+      # Handle MSSQL specific default format.
+      def column_schema_normalize_default(default, type)
+        if m = MSSQL_DEFAULT_RE.match(default)
+          default = m[1] || m[2]
+        end
+        super(default, type)
+      end
+
       # 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 _trans(conn)[:savepoint_level] > 1
       end
 
       # SQL to COMMIT a transaction.
@@ -108,15 +225,55 @@ module Sequel
       # MSSQL uses the name of the table to decide the difference between
       # a regular and temporary table, with temporary table names starting with
       # a #.
-      def create_table_sql(name, generator, options)
-        "CREATE TABLE #{quote_schema_table(options[:temp] ? "##{name}" : name)} (#{column_list_sql(generator)})"
+      def create_table_prefix_sql(name, options)
+        "CREATE TABLE #{quote_schema_table(options[:temp] ? "##{name}" : name)}"
       end
       
+      # MSSQL doesn't support CREATE TABLE AS, it only supports SELECT INTO.
+      # Emulating CREATE TABLE AS using SELECT INTO is only possible if a dataset
+      # is given as the argument, it can't work with a string, so raise an
+      # Error if a string is given.
+      def create_table_as(name, ds, options)
+        raise(Error, "must provide dataset instance as value of create_table :as option on MSSQL") unless ds.is_a?(Sequel::Dataset)
+        run(ds.into(name).sql)
+      end
+    
+      # The name of the constraint for setting the default value on the table and column.
+      # The SQL used to select default constraints utilizes MSSQL catalog views which were introduced in 2005.
+      # This method intentionally does not support MSSQL 2000.
+      def default_constraint_name(table, column_name)
+        if server_version >= 9000000
+          table_name = schema_and_table(table).compact.join('.')
+          self[:sys__default_constraints].
+            where{{:parent_object_id => Sequel::SQL::Function.new(:object_id, table_name), col_name(:parent_object_id, :parent_column_id) => column_name.to_s}}.
+            get(:name)
+        end
+      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
       
+      # support for clustered index type
+      def index_definition_sql(table_name, index)
+        index_name = index[:name] || default_index_name(table_name, index[:columns])
+        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 index[:type] == :clustered}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}#{" INCLUDE #{literal(index[:include])}" if index[:include]}#{" WHERE #{filter_expr(index[:where])}" if index[:where]}"
+        end
+      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 +296,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 +341,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
@@ -185,53 +368,100 @@ module Sequel
       def type_literal_generic_file(column)
         :'varbinary(max)'
       end
-
-      # 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"
-        else
-          "CREATE #{'UNIQUE ' if index[:unique]}#{'CLUSTERED ' if clustered}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}"
-        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 limit 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
+      BACKSLASH_CRLF_RE = /\\((?:\r\n)|\n)/.freeze
+      BACKSLASH_CRLF_REPLACE = '\\\\\\\\\\1\\1'.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
+      DEFAULT_TIMESTAMP_FORMAT = "'%Y-%m-%dT%H:%M:%S%N%z'".freeze
+      FORMAT_DATE = "'%Y%m%d'".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 +474,31 @@ 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)
+      # There is no function on Microsoft SQL Server that does character length
+      # and respects trailing spaces (datalength respects trailing spaces, but
+      # counts bytes instead of characters).  Use a hack to work around the
+      # trailing spaces issue.
+      def emulated_function_sql_append(sql, f)
+        case f.f
+        when :char_length
+          literal_append(sql, SQL::Function.new(:len, Sequel.join([f.args.first, 'x'])) - 1)
+        when :trim
+          literal_append(sql, SQL::Function.new(:ltrim, SQL::Function.new(:rtrim, f.args.first)))
+        else
+          super
+        end
       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 +506,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).
@@ -314,39 +555,32 @@ module Sequel
         mutation_method(:output, into, values)
       end
 
-      # MSSQL uses [] to quote identifiers
-      def quoted_identifier(name)
-        "[#{name}]"
+      # MSSQL uses [] to quote identifiers.  MSSQL does not support
+      # escaping of ], so you cannot use that character in an identifier.
+      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,18 +615,55 @@ 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
+
+      # Whether we are using SQL Server 2005 or later.
       def is_2005_or_later?
         server_version >= 9000000
       end
 
+      # Whether we are using SQL Server 2008 or later.
+      def is_2008_or_later?
+        server_version >= 10000000
+      end
+
+      # Use strict ISO-8601 format with T between date and time,
+      # since that is the format that is multilanguage and not
+      # DATEFORMAT dependent.
+      def default_timestamp_format
+        DEFAULT_TIMESTAMP_FORMAT
+      end
+
       # MSSQL supports the OUTPUT clause for DELETE statements.
       # It also allows prepending a WITH clause.
       def delete_clause_methods
@@ -401,7 +672,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 +685,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,51 +704,71 @@ 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(/'/, "''")}'"
+      # Use YYYYmmdd format, since that's the only want that is
+      # multilanguage and not DATEFORMAT dependent.
+      def literal_date(v)
+        v.strftime(FORMAT_DATE)
       end
-      
+
       # Use 0 for false on MSSQL
       def literal_false
         BOOL_FALSE
       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
+      end
+      
       # Use 1 for true on MSSQL
       def literal_true
         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
+          identifier_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
+      alias update_limit_sql select_limit_sql
 
       # Support different types of locking styles
       def select_lock_sql(sql)
@@ -496,19 +786,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
+          identifier_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 +809,12 @@ 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
+
+      def uses_with_rollup?
+        !is_2008_or_later?
       end
     end
   end