sequel 3.29.0 → 3.30.0

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

@@ -8,27 +8,57 @@ module Sequel
       # Database instance methods for SQLServer databases accessed via JDBC.
       module DatabaseMethods
         include Sequel::JDBC::MSSQL::DatabaseMethods
-        
-        def metadata_dataset
-          ds = super
-          # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
-          # for the getColumns result set specifies an incorrect type for the
-          # IS_AUTOINCREMENT column. The column is a string, but the type is
-          # specified as a short. This causes getObject() to throw a
-          # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
-          # from char to SMALLINT is unsupported." Using getString() rather
-          # than getObject() for this column avoids the problem.
-          # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
-          def ds.result_set_object_getter
-            lambda do |result, n, i|
-              if n == :is_autoincrement
-                @convert_types ? convert_type(result.getString(i)) : result.getString(i)
-              else
-                @convert_types ? convert_type(result.getObject(i)) : result.getObject(i)
+
+        # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
+        # for the getColumns result set specifies an incorrect type for the
+        # IS_AUTOINCREMENT column. The column is a string, but the type is
+        # specified as a short. This causes getObject() to throw a
+        # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
+        # from char to SMALLINT is unsupported." Using getString() rather
+        # than getObject() for this column avoids the problem.
+        # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
+        module MetadataDatasetMethods
+          def process_result_set_convert(cols, result, rn)
+            while result.next
+              row = {}
+              cols.each do |n, i, p|
+                v = (n == :is_autoincrement ? result.getString(i) : result.getObject(i))
+                row[n] = if v
+                  if p
+                    p.call(v)
+                  elsif p.nil?
+                    cols[i-1][2] = p = convert_type_proc(v)
+                    if p
+                      p.call(v)
+                    else
+                      v
+                    end
+                  else
+                    v
+                  end
+                else
+                  v
+                end
+              end
+              row.delete(rn) if rn
+              yield row
+            end
+          end
+
+          def process_result_set_no_convert(cols, result, rn)
+            while result.next
+              row = {}
+              cols.each do |n, i|
+                row[n] = (n == :is_autoincrement ? result.getString(i) : result.getObject(i))
               end
+              row.delete(rn) if rn
+              yield row
             end
           end
-          ds
+        end
+        
+        def metadata_dataset
+          super.extend(MetadataDatasetMethods)
         end
       end
       

data/lib/sequel/adapters/mock.rb

@@ -92,8 +92,9 @@ module Sequel
       # :numrows :: Call #numrows= with the value
       # :extend :: A module the object is extended with.
       # :sqls :: The array to store the SQL queries in.
-      def initialize(opts=nil)
+      def initialize(opts={})
         super
+        opts = @opts
         self.autoid = opts[:autoid]
         self.columns = opts[:columns]
         self.fetch = opts[:fetch]

data/lib/sequel/adapters/mysql.rb

@@ -347,8 +347,10 @@ module Sequel
       end
       
       # Handle correct quoting of strings using ::MySQL.quote.
-      def literal_string(v)
-        "'#{::Mysql.quote(v)}'"
+      def literal_string_append(sql, v)
+        sql << "'"
+        sql << ::Mysql.quote(v)
+        sql << "'"
       end
       
       # Yield each row of the given result set r with columns cols

data/lib/sequel/adapters/mysql2.rb

@@ -172,8 +172,8 @@ module Sequel
       end
 
       # Handle correct quoting of strings using ::Mysql2::Client#escape.
-      def literal_string(v)
-        db.synchronize{|c| "'#{c.escape(v)}'"}
+      def literal_string_append(sql, v)
+        sql << "'" << db.synchronize{|c| c.escape(v)} << "'"
       end
     end
   end

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

@@ -7,7 +7,7 @@ module Sequel
     module MSSQL
       module DatabaseMethods
         include Sequel::MSSQL::DatabaseMethods
-        LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'
+        LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'.freeze
         
         # Return the last inserted identity value.
         def execute_insert(sql, opts={})

data/lib/sequel/adapters/openbase.rb

@@ -32,7 +32,7 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
+      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
 
       Database::DatasetClass = self
       

data/lib/sequel/adapters/oracle.rb

@@ -317,17 +317,17 @@ module Sequel
         # Run execute_select on the database with the given SQL and the stored
         # bind arguments.
         def execute(sql, opts={}, &block)
-          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
         def execute_dui(sql, opts={}, &block)
-          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
         def execute_insert(sql, opts={}, &block)
-          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
       end
 
@@ -414,13 +414,13 @@ module Sequel
 
       private
 
-      def literal_other(v)
+      def literal_other_append(sql, v)
         case v
         when OraDate
-          literal(db.to_application_timestamp(v))
+          literal_append(sql, db.to_application_timestamp(v))
         when OCI8::CLOB
           v.rewind
-          literal(v.read)
+          literal_append(sql, v.read)
         else
           super
         end

data/lib/sequel/adapters/postgres.rb

@@ -218,14 +218,27 @@ module Sequel
       # client encoding for the connection.
       def connect(server)
         opts = server_opts(server)
-        conn = Adapter.connect(
-          (opts[:host] unless blank_object?(opts[:host])),
-          opts[:port] || 5432,
-          nil, '',
-          opts[:database],
-          opts[:user],
-          opts[:password]
-        )
+        conn = if SEQUEL_POSTGRES_USES_PG
+          connection_params = {
+            :host => opts[:host],
+            :port => opts[:port] || 5432,
+            :tty => '',
+            :dbname => opts[:database],
+            :user => opts[:user],
+            :password => opts[:password],
+            :connect_timeout => opts[:connect_timeout] || 20
+          }.delete_if { |key, value| blank_object?(value) }
+          Adapter.connect(connection_params)
+        else
+          Adapter.connect(
+            (opts[:host] unless blank_object?(opts[:host])),
+            opts[:port] || 5432,
+            nil, '',
+            opts[:database],
+            opts[:user],
+            opts[:password]
+          )
+        end
         if encoding = opts[:encoding] || opts[:charset]
           if conn.respond_to?(:set_client_encoding)
             conn.set_client_encoding(encoding)
@@ -639,13 +652,13 @@ module Sequel
       end
       
       # Use the driver's escape_bytea
-      def literal_blob(v)
-        db.synchronize{|c| "'#{c.escape_bytea(v)}'"}
+      def literal_blob_append(sql, v)
+        sql << "'" << db.synchronize{|c| c.escape_bytea(v)} << "'"
       end
       
       # Use the driver's escape_string
-      def literal_string(v)
-        db.synchronize{|c| "'#{c.escape_string(v)}'"}
+      def literal_string_append(sql, v)
+        sql << "'" << db.synchronize{|c| c.escape_string(v)} << "'"
       end
       
       # For each row in the result set, yield a hash with column name symbol

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

@@ -28,7 +28,12 @@ module Sequel
     end
   
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select limit distinct columns from join where group order having compounds')
+      DATE_FORMAT = '#%Y-%m-%d#'.freeze
+      TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze
+      TOP = " TOP ".freeze
+      BRACKET_CLOSE = Dataset::BRACKET_CLOSE
+      BRACKET_OPEN = Dataset::BRACKET_OPEN
 
       # Access doesn't support INTERSECT or EXCEPT
       def supports_intersect_except?
@@ -39,23 +44,26 @@ module Sequel
 
       # Access uses # to quote dates
       def literal_date(d)
-        d.strftime('#%Y-%m-%d#')
+        d.strftime(DATE_FORMAT)
       end
 
       # Access uses # to quote datetimes
       def literal_datetime(t)
-        t.strftime('#%Y-%m-%d %H:%M:%S#')
+        t.strftime(TIMESTAMP_FORMAT)
       end
       alias literal_time literal_datetime
 
       # Access uses TOP for limits
       def select_limit_sql(sql)
-        sql << " TOP #{@opts[:limit]}" if @opts[:limit]
+        if l = @opts[:limit]
+          sql << TOP
+          literal_append(sql, l)
+        end
       end
 
       # Access uses [] for quoting identifiers
-      def quoted_identifier(v)
-        "[#{v}]"
+      def quoted_identifier_append(sql, v)
+        sql << BRACKET_OPEN << v.to_s << BRACKET_CLOSE
       end
 
       # Access requires the limit clause come before other clauses

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

@@ -175,35 +175,52 @@ module Sequel
     module DatasetMethods
       include EmulateOffsetWithRowNumber
 
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      PAREN_OPEN = Dataset::PAREN_OPEN
       BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
-      
+      CAST_STRING_OPEN = "RTRIM(CHAR(".freeze
+      CAST_STRING_CLOSE = "))".freeze
+      FETCH_FIRST_ROW_ONLY = " FETCH FIRST ROW ONLY".freeze
+      FETCH_FIRST = " FETCH FIRST ".freeze
+      ROWS_ONLY = " ROWS ONLY".freeze
+      EMPTY_FROM_TABLE = ' FROM "SYSIBM"."SYSDUMMY1"'.freeze
+
       # DB2 casts strings using RTRIM and CHAR instead of VARCHAR.
-      def cast_sql(expr, type)
-        type == String ?  "RTRIM(CHAR(#{literal(expr)}))" : super
+      def cast_sql_append(sql, expr, type)
+        if(type == String)
+          sql << CAST_STRING_OPEN
+          literal_append(sql, expr)
+          sql << CAST_STRING_CLOSE
+        else
+          super
+        end
       end
 
       # Handle DB2 specific LIKE and bitwise operator support, and
       # emulate the extract method, which DB2 doesn't natively support.
-      def complex_expression_sql(op, args)
+      def complex_expression_sql_append(sql, op, args)
         case op
         when :ILIKE
-          super(:LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
+          super(sql, :LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
         when :"NOT ILIKE"
-          super(:"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
+          super(sql, :"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1)) ])
         when :&, :|, :^
           # works with db2 v9.5 and after
           op = BITWISE_METHOD_MAP[op]
-          complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(op, a, b))}
+          sql << complex_expression_arg_pairs(args){|a, b| literal(SQL::Function.new(op, a, b))}
         when :<<
-          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
         when :>>
-          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
         when :'B~'
-          literal(SQL::Function.new(:BITNOT, *args))
+          literal_append(sql, SQL::Function.new(:BITNOT, *args))
         when :extract
-          "#{args.at(0)}(#{literal(args.at(1))})"
+          sql << args.at(0).to_s
+          sql << PAREN_OPEN
+          literal_append(sql, args.at(1))
+          sql << PAREN_CLOSE
         else
           super
         end
@@ -259,7 +276,7 @@ module Sequel
 
       # Add a fallback table for empty from situation
       def select_from_sql(sql)
-        @opts[:from] ? super : (sql << ' FROM "SYSIBM"."SYSDUMMY1"')
+        @opts[:from] ? super : (sql << EMPTY_FROM_TABLE)
       end
 
       # Modify the sql to limit the number of rows returned
@@ -274,7 +291,13 @@ module Sequel
       #     Support for this feature is not used in this adapter however.
       def select_limit_sql(sql)
         if l = @opts[:limit]
-          sql << " FETCH FIRST #{l == 1 ? 'ROW' : "#{literal(l)} ROWS"} ONLY"
+          if l == 1
+            sql << FETCH_FIRST_ROW_ONLY
+          elsif l > 1
+            sql << FETCH_FIRST
+            literal_append(sql, l)
+            sql << ROWS_ONLY
+          end
         end
       end
       

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

@@ -150,9 +150,10 @@ module Sequel
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       NULL = LiteralString.new('NULL').freeze
-      COMMA_SEPARATOR = ', '.freeze
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct limit columns from join where group having compounds order')
-      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'into columns values returning')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct limit columns from join where group having compounds order')
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert into columns values returning')
+      FIRST = " FIRST ".freeze
+      SKIP = " SKIP ".freeze
       
       # Insert given values into the database.
       def insert(*values)
@@ -206,8 +207,14 @@ module Sequel
       end
       
       def select_limit_sql(sql)
-        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
-        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
+        if l = @opts[:limit]
+          sql << FIRST
+          literal_append(sql, l)
+        end
+        if o = @opts[:offset]
+          sql << SKIP
+          literal_append(sql, o)
+        end
       end
     end
   end

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

@@ -23,7 +23,9 @@ module Sequel
     end
     
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where having group compounds order')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select limit distinct columns from join where having group compounds order')
+      FIRST = " FIRST ".freeze
+      SKIP = " SKIP ".freeze
 
       private
 
@@ -37,8 +39,14 @@ module Sequel
       end
 
       def select_limit_sql(sql)
-        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
-        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
+        if o = @opts[:offset]
+          sql << SKIP
+          literal_append(sql, o)
+        end
+        if l = @opts[:limit]
+          sql << FIRST
+          literal_append(sql, l)
+        end
       end
     end
   end

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

@@ -249,15 +249,42 @@ module Sequel
       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
@@ -269,33 +296,41 @@ module Sequel
       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)
+          super(sql, :+, args)
         when :LIKE, :"NOT LIKE"
-          super(op, args.map{|a| LiteralString.new("(#{literal(a)} COLLATE Latin1_General_CS_AS)")})
+          super(sql, op, args.map{|a| LiteralString.new("(#{literal(a)} COLLATE #{CASE_SENSITIVE_COLLATION})")})
         when :ILIKE, :"NOT ILIKE"
-          super((op == :ILIKE ? :LIKE : :"NOT LIKE"), args)
+          super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args.map{|a| LiteralString.new("(#{literal(a)} COLLATE #{CASE_INSENSITIVE_COLLATION})")})
         when :<<
-          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
         when :>>
-          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+          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]
-          expr = literal(args.at(1))
-          s = "datepart(#{format}, #{expr})"
-          s = "CAST((#{s} + datepart(ns, #{expr})/1000000000.0) AS double precision)" if part == :second
-          s
+          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
@@ -326,7 +361,16 @@ module Sequel
 
       # 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).
@@ -365,8 +409,8 @@ 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
       
       # The version of the database server.
@@ -439,7 +483,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.
@@ -451,19 +496,11 @@ 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)
-      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.
@@ -476,23 +513,22 @@ module Sequel
       # for use with the prepared statement code.
       def insert_output_sql(sql)
         if @opts.has_key?(:returning)
-          sql << " OUTPUT INSERTED.*"
+          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
       
       # Optionally use unicode string syntax for all strings. Don't double
       # backslashes.
-      def literal_string(v)
-        "#{'N' if mssql_unicode_strings}'#{v.gsub(/'/, "''")}'"
+      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
@@ -511,16 +547,24 @@ module Sequel
       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
 
@@ -540,13 +584,15 @@ 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
@@ -561,7 +607,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