sequel 3.29.0 → 3.30.0

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

@@ -333,34 +333,69 @@ module Sequel
       COMMA_SEPARATOR = ', '.freeze
       FOR_SHARE = ' LOCK IN SHARE MODE'.freeze
       SQL_CALC_FOUND_ROWS = ' SQL_CALC_FOUND_ROWS'.freeze
-      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from where order limit')
-      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'ignore into columns values on_duplicate_key_update')
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct calc_found_rows columns from join where group having compounds order limit lock')
-      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set where order limit')
+      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'delete from where order limit')
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert ignore into columns values on_duplicate_key_update')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct calc_found_rows columns from join where group having compounds order limit lock')
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'update table set where order limit')
+      SPACE = Dataset::SPACE
+      PAREN_OPEN = Dataset::PAREN_OPEN
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      NOT_SPACE = Dataset::NOT_SPACE
+      FROM = Dataset::FROM
+      INSERT = Dataset::INSERT
+      COMMA = Dataset::COMMA
+      LIMIT = Dataset::LIMIT
+      REGEXP = 'REGEXP'.freeze
+      LIKE = 'LIKE'.freeze
+      BINARY = 'BINARY '.freeze
+      CONCAT = "CONCAT".freeze
+      CAST_BITCOMP_OPEN = "CAST(~".freeze
+      CAST_BITCOMP_CLOSE = " AS SIGNED INTEGER)".freeze
+      STRAIGHT_JOIN = 'STRAIGHT_JOIN'.freeze
+      NATURAL_LEFT_JOIN = 'NATURAL LEFT JOIN'.freeze
+      BACKTICK = '`'.freeze
+      EMPTY_COLUMNS = " ()".freeze
+      EMPTY_VALUES = " VALUES ()".freeze
+      IGNORE = " IGNORE".freeze
+      REPLACE = 'REPLACE'.freeze
+      ON_DUPLICATE_KEY_UPDATE = " ON DUPLICATE KEY UPDATE ".freeze
+      EQ_VALUES = '=VALUES('.freeze
+      EQ = '='.freeze
       
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
-      def complex_expression_sql(op, args)
+      def complex_expression_sql_append(sql, op, args)
         case op
         when :IN, :"NOT IN"
           ds = args.at(1)
           if ds.is_a?(Sequel::Dataset) && ds.opts[:limit]
-            super(op, [args.at(0), ds.from_self])
+            super(sql, op, [args.at(0), ds.from_self])
           else
             super
           end
         when :~, :'!~', :'~*', :'!~*', :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
-          "(#{literal(args.at(0))} #{'NOT ' if [:'NOT LIKE', :'NOT ILIKE', :'!~', :'!~*'].include?(op)}#{[:~, :'!~', :'~*', :'!~*'].include?(op) ? 'REGEXP' : 'LIKE'} #{'BINARY ' if [:~, :'!~', :LIKE, :'NOT LIKE'].include?(op)}#{literal(args.at(1))})"
+          sql << PAREN_OPEN
+          literal_append(sql, args.at(0))
+          sql << SPACE
+          sql << 'NOT ' if [:'NOT LIKE', :'NOT ILIKE', :'!~', :'!~*'].include?(op)
+          sql << ([:~, :'!~', :'~*', :'!~*'].include?(op) ? REGEXP : LIKE)
+          sql << SPACE
+          sql << BINARY if [:~, :'!~', :LIKE, :'NOT LIKE'].include?(op)
+          literal_append(sql, args.at(1))
+          sql << PAREN_CLOSE
         when :'||'
           if args.length > 1
-            "CONCAT(#{args.collect{|a| literal(a)}.join(', ')})"
+            sql << CONCAT
+            array_sql_append(sql, args)
           else
-            literal(args.at(0))
+            literal_append(sql, args.at(0))
           end
         when :'B~'
-          "CAST(~#{literal(args.at(0))} AS SIGNED INTEGER)"
+          sql << CAST_BITCOMP_OPEN
+          literal_append(sql, args.at(0))
+          sql << CAST_BITCOMP_CLOSE
         else
-          super(op, args)
+          super
         end
       end
       
@@ -409,9 +444,12 @@ module Sequel
       # STRAIGHT_JOIN.
       def join_type_sql(join_type)
         case join_type
-        when :straight then 'STRAIGHT_JOIN'
-        when :natural_inner then 'NATURAL LEFT JOIN'
-        else super
+        when :straight
+          STRAIGHT_JOIN
+        when :natural_inner
+          NATURAL_LEFT_JOIN
+        else
+          super
         end
       end
       
@@ -452,7 +490,9 @@ module Sequel
 
       # MySQL specific syntax for inserting multiple values at once.
       def multi_insert_sql(columns, values)
-        [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
+        sql = LiteralString.new('VALUES ')
+        expression_list_append(sql, values.map{|r| Array(r)})
+        [insert_sql(columns, sql)]
       end
       
       # MySQL uses the number of rows actually modified in the update,
@@ -462,8 +502,8 @@ module Sequel
       end
       
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
-      def quoted_identifier(c)
-        "`#{c}`"
+      def quoted_identifier_append(sql, c)
+        sql << BACKTICK << c.to_s << BACKTICK
       end
       
       # MySQL specific syntax for REPLACE (aka UPSERT, or update if exists,
@@ -501,13 +541,6 @@ module Sequel
         false
       end
       
-      protected
-      
-      # If this is an replace instead of an insert, use replace instead
-      def _insert_sql
-        @opts[:replace] ? clause_sql(:replace) : super
-      end
-
       private
 
       # MySQL supports the ORDER BY and LIMIT clauses for DELETE statements
@@ -519,7 +552,10 @@ module Sequel
       # from, but include the others for the purposes of selecting rows.
       def delete_from_sql(sql)
         if joined_dataset?
-          sql << " #{source_list(@opts[:from][0..0])} FROM #{source_list(@opts[:from])}"
+          sql << SPACE
+          source_list_append(sql, @opts[:from][0..0])
+          sql << FROM
+          source_list_append(sql, @opts[:from])
           select_join_sql(sql)
         else
           super
@@ -536,7 +572,7 @@ module Sequel
       def insert_columns_sql(sql)
         values = opts[:values]
         if values.is_a?(Array) && values.empty?
-          sql << " ()"
+          sql << EMPTY_COLUMNS
         else
           super
         end
@@ -544,19 +580,57 @@ module Sequel
 
       # MySQL supports INSERT IGNORE INTO
       def insert_ignore_sql(sql)
-        sql << " IGNORE" if opts[:insert_ignore]
+        sql << IGNORE if opts[:insert_ignore]
+      end
+
+      # If this is an replace instead of an insert, use replace instead
+      def insert_insert_sql(sql)
+        sql << (@opts[:replace] ? REPLACE : INSERT)
       end
 
       # MySQL supports INSERT ... ON DUPLICATE KEY UPDATE
       def insert_on_duplicate_key_update_sql(sql)
-        sql << on_duplicate_key_update_sql if opts[:on_duplicate_key_update]
+        if update_cols = opts[:on_duplicate_key_update]
+          update_vals = nil
+
+          if update_cols.empty?
+            update_cols = columns
+          elsif update_cols.last.is_a?(Hash)
+            update_vals = update_cols.last
+            update_cols = update_cols[0..-2]
+          end
+
+          sql << ON_DUPLICATE_KEY_UPDATE
+          c = false
+          co = COMMA
+          values = EQ_VALUES
+          endp = PAREN_CLOSE
+          update_cols.each do |col|
+            sql << co if c
+            quote_identifier_append(sql, col)
+            sql << values
+            quote_identifier_append(sql, col)
+            sql << endp
+            c ||= true
+          end
+          if update_vals
+            eq = EQ
+            update_vals.map do |col,v| 
+              sql << co if c
+              quote_identifier_append(sql, col)
+              sql << eq
+              literal_append(sql, v)
+              c ||= true
+            end
+          end
+        end
       end
 
       # MySQL doesn't use the standard DEFAULT VALUES for empty values.
       def insert_values_sql(sql)
         values = opts[:values]
         if values.is_a?(Array) && values.empty?
-          sql << " VALUES ()"
+          sql << EMPTY_VALUES
         else
           super
         end
@@ -564,7 +638,10 @@ module Sequel
 
       # MySQL allows a LIMIT in DELETE and UPDATE statements.
       def limit_sql(sql)
-        sql << " LIMIT #{@opts[:limit]}" if @opts[:limit]
+        if l = @opts[:limit]
+          sql << LIMIT
+          literal_append(sql, @opts[:limit])
+        end
       end
       alias delete_limit_sql limit_sql
       alias update_limit_sql limit_sql
@@ -579,25 +656,6 @@ module Sequel
         BOOL_TRUE
       end
       
-      # MySQL specific syntax for ON DUPLICATE KEY UPDATE
-      def on_duplicate_key_update_sql
-        if update_cols = opts[:on_duplicate_key_update]
-          update_vals = nil
-
-          if update_cols.empty?
-            update_cols = columns
-          elsif update_cols.last.is_a?(Hash)
-            update_vals = update_cols.last
-            update_cols = update_cols[0..-2]
-          end
-
-          updating = update_cols.map{|c| "#{quote_identifier(c)}=VALUES(#{quote_identifier(c)})" }
-          updating += update_vals.map{|c,v| "#{quote_identifier(c)}=#{literal(v)}" } if update_vals
-
-          " ON DUPLICATE KEY UPDATE #{updating.join(COMMA_SEPARATOR)}"
-        end
-      end
-
       # MySQL does not support the SQL WITH clause for SELECT statements
       def select_clause_methods
         SELECT_CLAUSE_METHODS

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

@@ -63,8 +63,8 @@ module Sequel
         module CallableStatementMethods
           # Extend given dataset with this module so subselects inside subselects in
           # prepared statements work.
-          def subselect_sql(ds)
-            ps = ds.to_prepared_statement(:select)
+          def subselect_sql_append(sql, ds)
+            ps = ds.to_prepared_statement(:select).clone(:append_sql => sql)
             ps.extend(CallableStatementMethods)
             ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
             ps.prepared_args = prepared_args

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

@@ -177,27 +177,53 @@ module Sequel
     module DatasetMethods
       include EmulateOffsetWithRowNumber
 
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct columns from join where group having compounds order lock')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct columns from join where group having compounds order lock')
       ROW_NUMBER_EXPRESSION = 'ROWNUM'.lit.freeze
+      SPACE = Dataset::SPACE
+      APOS = Dataset::APOS
+      APOS_RE = Dataset::APOS_RE
+      DOUBLE_APOS = Dataset::DOUBLE_APOS
+      FROM = Dataset::FROM
+      BITCOMP_OPEN = "((0 - ".freeze
+      BITCOMP_CLOSE = ") - 1)".freeze
+      ILIKE_0 = "(UPPER(".freeze
+      ILIKE_1 = ") ".freeze
+      ILIKE_2 = ' UPPER('.freeze
+      ILIKE_3 = "))".freeze
+      LIKE = 'LIKE'.freeze
+      NOT_LIKE = 'NOT LIKE'.freeze
+      TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'".freeze
+      TIMESTAMP_OFFSET_FORMAT = "%+03i:%02i".freeze
+      BOOL_FALSE = "'N'".freeze
+      BOOL_TRUE = "'Y'".freeze
+      HSTAR = "H*".freeze
+      DUAL = ['DUAL'.freeze].freeze
 
       # Oracle needs to emulate bitwise operators and ILIKE/NOT ILIKE operators.
-      def complex_expression_sql(op, args)
+      def complex_expression_sql_append(sql, op, args)
         case op
         when :&
-          complex_expression_arg_pairs(args){|a, b| "CAST(BITAND(#{literal(a)}, #{literal(b)}) AS INTEGER)"}
+          sql << complex_expression_arg_pairs(args){|a, b| "CAST(BITAND(#{literal(a)}, #{literal(b)}) AS INTEGER)"}
         when :|
-          complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} - #{complex_expression_sql(:&, [a, b])} + #{literal(b)})"}
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} - #{complex_expression_sql(:&, [a, b])} + #{literal(b)})"}
         when :^
-          complex_expression_arg_pairs(args){|*x| "(#{complex_expression_sql(:|, x)} - #{complex_expression_sql(:&, x)})"}
+          sql << complex_expression_arg_pairs(args){|*x| "(#{complex_expression_sql(:|, x)} - #{complex_expression_sql(:&, x)})"}
         when :'B~'
-          "((0 - #{literal(args.at(0))}) - 1)"
+          sql << BITCOMP_OPEN
+          literal_append(sql, args.at(0))
+          sql << BITCOMP_CLOSE
         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 :ILIKE, :'NOT ILIKE'
-          a, b = args
-          "(UPPER(#{literal(a)}) #{op == :ILIKE ? :LIKE : :'NOT LIKE'} UPPER(#{literal(b)}))"
+          sql << ILIKE_0
+          literal_append(sql, args.at(0))
+          sql << ILIKE_1
+          sql << (op == :ILIKE ? LIKE : NOT_LIKE)
+          sql<< ILIKE_2
+          literal_append(sql, args.at(1))
+          sql << ILIKE_3
         else
           super
         end
@@ -206,9 +232,9 @@ module Sequel
       # Oracle doesn't support CURRENT_TIME, as it doesn't have
       # a type for storing just time values without a date, so
       # use CURRENT_TIMESTAMP in its place.
-      def constant_sql(c)
+      def constant_sql_append(sql, c)
         if c == :CURRENT_TIME
-          super(:CURRENT_TIMESTAMP)
+          super(sql, :CURRENT_TIMESTAMP)
         else
           super
         end
@@ -244,7 +270,9 @@ module Sequel
           # Lock doesn't work in subselects, so don't use a subselect when locking.
           # Don't use a subselect if custom SQL is used, as it breaks somethings.
           ds = ds.from_self unless @opts[:lock]
-          subselect_sql(ds.where(SQL::ComplexExpression.new(:<=, ROW_NUMBER_EXPRESSION, limit)))
+          sql = @opts[:append_sql] || ''
+          subselect_sql_append(sql, ds.where(SQL::ComplexExpression.new(:<=, ROW_NUMBER_EXPRESSION, limit)))
+          sql
         else
           super
         end
@@ -289,13 +317,14 @@ module Sequel
 
       # Oracle doesn't support the use of AS when aliasing a dataset.  It doesn't require
       # the use of AS anywhere, so this disables it in all cases.
-      def as_sql(expression, aliaz)
-        "#{expression} #{quote_identifier(aliaz)}"
+      def as_sql_append(sql, aliaz)
+        sql << SPACE
+        quote_identifier_append(sql, aliaz)
       end
 
       # The strftime format to use when literalizing the time.
       def default_timestamp_format
-        "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'".freeze
+        TIMESTAMP_FORMAT
       end
 
       # If this dataset is associated with a sequence, return the most recently
@@ -307,7 +336,7 @@ module Sequel
 
       # Use a colon for the timestamp offset, since Oracle appears to require it.
       def format_timestamp_offset(hour, minute)
-        sprintf("%+03i:%02i", hour, minute)
+        sprintf(TIMESTAMP_OFFSET_FORMAT, hour, minute)
       end
 
       # Oracle doesn't support empty values when inserting.
@@ -316,26 +345,23 @@ module Sequel
       end
 
       # Use string in hex format for blob data.
-      def literal_blob(v)
-        blob = "'"
-        v.each_byte{|x| blob << sprintf('%02x', x)}
-        blob << "'"
-        blob
+      def literal_blob_append(sql, v)
+        sql << APOS << v.unpack(HSTAR).first << APOS
       end
 
       # Oracle uses 'N' for false values.
       def literal_false
-        "'N'"
+        BOOL_FALSE
       end
 
       # Oracle uses the SQL standard of only doubling ' inside strings.
-      def literal_string(v)
-        "'#{v.gsub("'", "''")}'"
+      def literal_string_append(sql, v)
+        sql << APOS << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
       end
 
       # Oracle uses 'Y' for true values.
       def literal_true
-        "'Y'"
+        BOOL_TRUE
       end
 
       # Use the Oracle-specific SQL clauses (no limit, since it is emulated).
@@ -348,7 +374,8 @@ module Sequel
       # so add the dummy DUAL table if the dataset doesn't select
       # from a table.
       def select_from_sql(sql)
-        sql << " FROM #{source_list(@opts[:from] || ['DUAL'])}"
+        sql << FROM
+        source_list_append(sql, @opts[:from] || DUAL)
       end
     end
   end

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

@@ -638,29 +638,43 @@ module Sequel
       BOOL_FALSE = 'false'.freeze
       BOOL_TRUE = 'true'.freeze
       COMMA_SEPARATOR = ', '.freeze
-      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from using where')
-      DELETE_CLAUSE_METHODS_91 = Dataset.clause_methods(:delete, %w'with from using where returning')
+      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'delete from using where')
+      DELETE_CLAUSE_METHODS_91 = Dataset.clause_methods(:delete, %w'with delete from using where returning')
       EXCLUSIVE = 'EXCLUSIVE'.freeze
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
-      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'into columns values')
-      INSERT_CLAUSE_METHODS_82 = Dataset.clause_methods(:insert, %w'into columns values returning')
-      INSERT_CLAUSE_METHODS_91 = Dataset.clause_methods(:insert, %w'with into columns values returning')
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert into columns values')
+      INSERT_CLAUSE_METHODS_82 = Dataset.clause_methods(:insert, %w'insert into columns values returning')
+      INSERT_CLAUSE_METHODS_91 = Dataset.clause_methods(:insert, %w'with insert into columns values returning')
       LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
       NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
       QUERY_PLAN = 'QUERY PLAN'.to_sym
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
       ROW_SHARE = 'ROW SHARE'.freeze
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit lock')
-      SELECT_CLAUSE_METHODS_84 = Dataset.clause_methods(:select, %w'with distinct columns from join where group having window compounds order limit lock')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit lock')
+      SELECT_CLAUSE_METHODS_84 = Dataset.clause_methods(:select, %w'with select distinct columns from join where group having window compounds order limit lock')
       SHARE = 'SHARE'.freeze
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
-      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set from where')
-      UPDATE_CLAUSE_METHODS_91 = Dataset.clause_methods(:update, %w'with table set from where returning')
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'update table set from where')
+      UPDATE_CLAUSE_METHODS_91 = Dataset.clause_methods(:update, %w'with update table set from where returning')
+      SPACE = Dataset::SPACE
+      FROM = Dataset::FROM
+      APOS = Dataset::APOS
+      APOS_RE = Dataset::APOS_RE
+      DOUBLE_APOS = Dataset::DOUBLE_APOS
+      PAREN_OPEN = Dataset::PAREN_OPEN
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      COMMA = Dataset::COMMA
+      AS = Dataset::AS
+      XOR_OP = ' # '.freeze
+      CRLF = "\r\n".freeze
+      BLOB_RE = /[\000-\037\047\134\177-\377]/n.freeze
+      WINDOW = " WINDOW ".freeze
+      EMPTY_STRING = ''.freeze
       
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
@@ -698,10 +712,16 @@ module Sequel
       
       # Handle converting the ruby xor operator (^) into the
       # PostgreSQL xor operator (#).
-      def complex_expression_sql(op, args)
+      def complex_expression_sql_append(sql, op, args)
         case op
         when :^
-          "(#{args.collect{|a| literal(a)}.join(" # ")})"
+          j = XOR_OP
+          c = false
+          args.each do |a|
+            sql << j if c
+            literal_append(sql, a)
+            c ||= true
+          end
         else
           super
         end
@@ -714,7 +734,7 @@ module Sequel
 
       # Return the results of an EXPLAIN query as a string
       def explain(opts={})
-        with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join("\r\n")
+        with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join(CRLF)
       end
       
       # Return a cloned dataset which will use FOR SHARE to lock returned rows.
@@ -767,7 +787,9 @@ module Sequel
         return super if server_version < 80200
         
         # postgresql 8.2 introduces support for multi-row insert
-        [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
+        sql = LiteralString.new('VALUES ')
+        expression_list_append(sql, values.map{|r| Array(r)})
+        [insert_sql(columns, sql)]
       end
       
       # PostgreSQL supports using the WITH clause in subqueries if it
@@ -818,7 +840,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
 
       # Use USING to specify additional tables in a delete query
@@ -849,14 +872,15 @@ module Sequel
         if(from = @opts[:from][1..-1]).empty?
           raise(Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs') if @opts[:join]
         else
-          sql << " #{type} #{source_list(from)}"
+          sql << SPACE << type.to_s << SPACE
+          source_list_append(sql, from)
           select_join_sql(sql)
         end
       end
 
       # Use a generic blob quoting method, hopefully overridden in one of the subadapter methods
-      def literal_blob(v)
-        "'#{v.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
+      def literal_blob_append(sql, v)
+        sql << APOS << v.gsub(BLOB_RE){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"} << APOS
       end
 
       # PostgreSQL uses FALSE for false values
@@ -865,8 +889,8 @@ module Sequel
       end
 
       # Assume that SQL standard quoting is on, per Sequel's defaults
-      def literal_string(v)
-        "'#{v.gsub("'", "''")}'"
+      def literal_string_append(sql, v)
+        sql << APOS << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
       end
 
       # PostgreSQL uses FALSE for false values
@@ -881,8 +905,10 @@ module Sequel
       
       # PostgreSQL requires parentheses around compound datasets if they use
       # CTEs, and using them in other places doesn't hurt.
-      def compound_dataset_sql(ds)
-        "(#{super})"
+      def compound_dataset_sql_append(sql, ds)
+        sql << PAREN_OPEN
+        super
+        sql << PAREN_CLOSE
       end
 
       # Support FOR SHARE locking when using the :share lock style.
@@ -892,14 +918,26 @@ module Sequel
 
       # SQL fragment for named window specifications
       def select_window_sql(sql)
-        sql << " WINDOW #{@opts[:window].map{|name, window| "#{literal(name)} AS #{literal(window)}"}.join(', ')}" if @opts[:window]
+        if ws = @opts[:window]
+          sql << WINDOW
+          c = false
+          co = COMMA
+          as = AS
+          ws.map do |name, window| 
+            sql << co if c
+            literal_append(sql, name)
+            sql << as
+            literal_append(sql, window)
+            c ||= true
+          end
+        end
       end
       
       # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
       def select_with_sql_base
         opts[:with].any?{|w| w[:recursive]} ? SQL_WITH_RECURSIVE : super
       end
-      
+
       # The version of the database server
       def server_version
         db.server_version(@opts[:server])
@@ -907,8 +945,8 @@ module Sequel
 
       # Concatenate the expressions with a space in between
       def full_text_string_join(cols)
-        cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, '')}
-        cols = cols.zip([' '] * cols.length).flatten
+        cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, EMPTY_STRING)}
+        cols = cols.zip([SPACE] * cols.length).flatten
         cols.pop
         literal(SQL::StringExpression.new(:'||', *cols))
       end
@@ -925,7 +963,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