sequel 3.29.0 → 3.30.0

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

@@ -31,7 +31,10 @@ module Sequel
       # The Progress adapter targets Progress 9, so it silently ignores the option.
       def select_limit_sql(sql)
         raise(Error, "OFFSET not supported") if @opts[:offset]
-        #sql << " TOP #{@opts[:limit]}" if @opts[:limit]
+        # if l = @opts[:limit]
+        #   sql << " TOP "
+        #   literal_append(sql, l)
+        # end
       end
     end
   end

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

@@ -396,24 +396,36 @@ module Sequel
     
     # Instance methods for datasets that connect to an SQLite database
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
-      COMMA_SEPARATOR = ', '.freeze
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
       CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}
       EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}
+      NOT_SPACE = Dataset::NOT_SPACE
+      COMMA = Dataset::COMMA
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      AS = Dataset::AS
+      APOS = Dataset::APOS
+      EXTRACT_OPEN = "CAST(strftime(".freeze
+      EXRACT_CLOSE = ') AS '.freeze
+      NUMERIC = 'NUMERIC'.freeze
+      INTEGER = 'INTEGER'.freeze
+      BACKTICK = '`'.freeze
+      BLOB_START = "X'".freeze
+      HSTAR = "H*".freeze
 
       # SQLite does not support pattern matching via regular expressions.
       # SQLite is case insensitive (depending on pragma), so use LIKE for
       # ILIKE.
-      def complex_expression_sql(op, args)
+      def complex_expression_sql_append(sql, op, args)
         case op
         when :~, :'!~', :'~*', :'!~*'
           raise Error, "SQLite does not support pattern matching via regular expressions"
         when :ILIKE
-          super(:LIKE, args.map{|a| SQL::Function.new(:upper, a)})
+          super(sql, :LIKE, args.map{|a| SQL::Function.new(:upper, a)})
         when :"NOT LIKE", :"NOT ILIKE"
-          "NOT #{complex_expression_sql((op == :"NOT ILIKE" ? :ILIKE : :LIKE), args)}"
+          sql << NOT_SPACE
+          complex_expression_sql_append(sql, (op == :"NOT ILIKE" ? :ILIKE : :LIKE), args)
         when :^
-          complex_expression_arg_pairs(args) do |a, b|
+          sql << complex_expression_arg_pairs(args) do |a, b|
             a = literal(a)
             b = literal(b)
             "((~(#{a} & #{b})) & (#{a} | #{b}))"
@@ -421,16 +433,21 @@ module Sequel
         when :extract
           part = args.at(0)
           raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
-          expr = args.at(1)
-          "CAST(strftime(#{format}, #{literal(expr)}) AS #{part == :second ? 'NUMERIC' : 'INTEGER'})"
+          sql << EXTRACT_OPEN << format << COMMA
+          literal_append(sql, args.at(1))
+          sql << EXRACT_CLOSE << (part == :second ? NUMERIC : INTEGER) << PAREN_CLOSE
         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
       
       # SQLite performs a TRUNCATE style DELETE if no filter is specified.
@@ -454,8 +471,8 @@ module Sequel
       end
       
       # SQLite 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
       
       # When a qualified column is selected on SQLite and the qualifier
@@ -500,9 +517,10 @@ module Sequel
       private
       
       # SQLite uses string literals instead of identifiers in AS clauses.
-      def as_sql(expression, aliaz)
+      def as_sql_append(sql, aliaz)
         aliaz = aliaz.value if aliaz.is_a?(SQL::Identifier)
-        "#{expression} AS #{literal(aliaz.to_s)}"
+        sql << AS
+        literal_append(sql, aliaz.to_s)
       end
 
       # If col is a qualified column, alias it to the same as the column name
@@ -524,14 +542,12 @@ module Sequel
       
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
-        columns.map{|i| quote_identifier(i)}.join(COMMA_SEPARATOR)
+        columns.map{|i| quote_identifier(i)}.join(COMMA)
       end
     
       # SQLite uses a preceding X for hex escaping strings
-      def literal_blob(v)
-        blob = ''
-        v.each_byte{|x| blob << sprintf('%02x', x)}
-        "X'#{blob}'"
+      def literal_blob_append(sql, v)
+        sql << BLOB_START << v.unpack(HSTAR).first << APOS
       end
 
       # SQLite does not support the SQL WITH clause

data/lib/sequel/adapters/sqlite.rb

@@ -323,7 +323,6 @@ module Sequel
           ps.prepared_statement_name = name
           db.prepared_statements[name] = ps
         end
-        ps.prepared_sql
         ps
       end
       
@@ -335,8 +334,8 @@ module Sequel
       end
 
       # Quote the string using the adapter class method.
-      def literal_string(v)
-        "'#{::SQLite3::Database.quote(v)}'"
+      def literal_string_append(sql, v)
+        sql << "'" << ::SQLite3::Database.quote(v) << "'"
       end
 
       # SQLite uses a : before the name of the argument as a placeholder.

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

@@ -34,6 +34,7 @@ module Sequel
       # Dataset class for MySQL datasets accessed via Swift.
       class Dataset < Swift::Dataset
         include Sequel::MySQL::DatasetMethods
+        APOS = Dataset::APOS
         
         # Use execute_insert to execute the replace_sql.
         def replace(*args)
@@ -43,8 +44,8 @@ module Sequel
         private
         
         # Use Swift's escape method for quoting.
-        def literal_string(s)
-          db.synchronize{|c| "'#{c.escape(s)}'"}
+        def literal_string_append(sql, s)
+          sql << APOS << db.synchronize{|c| c.escape(s)} << APOS
         end
       end
     end

data/lib/sequel/adapters/swift/sqlite.rb

@@ -24,8 +24,8 @@ module Sequel
         private
         
         # Use Swift's escape method for quoting.
-        def literal_string(s)
-          db.synchronize{|c| "#{c.escape(s)}"}
+        def literal_string_append(sql, s)
+          sql << db.synchronize{|c| c.escape(s)}
         end
       end
     end

data/lib/sequel/adapters/tinytds.rb

@@ -186,17 +186,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
       
@@ -206,15 +206,15 @@ module Sequel
         execute(sql) do |result|
           each_opts = {:cache_rows=>false}
           each_opts[:timezone] = :utc if db.timezone == :utc
-          rn = row_number_column if @opts[:offset]
+          rn = row_number_column if offset = @opts[:offset]
           columns = cols = result.fields.map{|c| output_identifier(c)}
-          if opts[:offset]
+          if offset
             rn = row_number_column
             columns = columns.dup
             columns.delete(rn)
           end
           @columns = columns
-          if identifier_output_method
+          #if identifier_output_method
             each_opts[:as] = :array
             result.each(each_opts) do |r|
               h = {}
@@ -222,6 +222,10 @@ module Sequel
               h.delete(rn) if rn
               yield h
             end
+=begin
+        # Temporarily disable this optimization, as tiny_tds uses string keys
+        # if result.fields is called before result.each(:symbolize_keys=>true).
+        # See https://github.com/rails-sqlserver/tiny_tds/issues/57
           else
             each_opts[:symbolize_keys] = true
             if offset
@@ -233,6 +237,7 @@ module Sequel
               result.each(each_opts, &Proc.new)
             end
           end
+=end
         end
         self
       end
@@ -252,8 +257,9 @@ module Sequel
       private
       
       # Properly escape the given string +v+.
-      def literal_string(v)
-        s = db.synchronize{|c| "#{'N' if mssql_unicode_strings}'#{c.escape(v)}'"}
+      def literal_string_append(sql, v)
+        sql << 'N' if mssql_unicode_strings
+        sql << "'" << db.synchronize{|c| c.escape(v)} << "'"
       end
     end
   end

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -3,7 +3,7 @@ module Sequel
     # When a subselect that uses :offset is used in IN or NOT IN,
     # use a nested subselect that only includes the first column
     # instead of the ROW_NUMBER column added by the emulated offset support.
-    def complex_expression_sql(op, args)
+    def complex_expression_sql_append(sql, op, args)
       case op
       when :IN, :"NOT IN"
         ds = args.at(1)
@@ -22,7 +22,7 @@ module Sequel
           when SQL::QualifiedIdentifier
             c = SQL::Identifier.new(c.column)
           end
-          super(op, [args.at(0), ds.from_self.select(c)])
+          super(sql, op, [args.at(0), ds.from_self.select(c)])
         else
           super
         end
@@ -44,12 +44,15 @@ module Sequel
       raise(Error, "#{db.database_type} requires an order be provided if using an offset") unless order = @opts[:order]
       dsa1 = dataset_alias(1)
       rn = row_number_column
-      subselect_sql(unlimited.
+      sql = @opts[:append_sql] || ''
+      subselect_sql_append(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))
+        where(SQL::Identifier.new(rn) > o).
+        order(rn))
+      sql
     end
 
     private

data/lib/sequel/database/misc.rb

@@ -69,9 +69,11 @@ module Sequel
     # If a transaction is not currently in process, yield to the block immediately.
     # Otherwise, add the block to the list of blocks to call after the currently
     # in progress transaction commits (and only if it commits).
+    # Options:
+    # :server :: The server/shard to use.
     def after_commit(opts={}, &block)
       raise Error, "must provide block to after_commit" unless block
-      synchronize(opts) do |conn|
+      synchronize(opts[:server]) do |conn|
         if h = @transactions[conn]
           raise Error, "cannot call after_commit in a prepared transaction" if h[:prepare]
           (h[:after_commit] ||= []) << block
@@ -84,9 +86,11 @@ module Sequel
     # If a transaction is not currently in progress, ignore the block.
     # Otherwise, add the block to the list of the blocks to call after the currently
     # in progress transaction rolls back (and only if it rolls back).
+    # Options:
+    # :server :: The server/shard to use.
     def after_rollback(opts={}, &block)
       raise Error, "must provide block to after_rollback" unless block
-      synchronize(opts) do |conn|
+      synchronize(opts[:server]) do |conn|
         if h = @transactions[conn]
           raise Error, "cannot call after_rollback in a prepared transaction" if h[:prepare]
           (h[:after_rollback] ||= []) << block

data/lib/sequel/dataset/graph.rb

@@ -113,11 +113,13 @@ module Sequel
       add_table = options[:select] == false ? false : true
       # Whether to add the columns to the list of column aliases
       add_columns = !ds.opts.include?(:graph_aliases)
-      # columns to select
-      select = (opts[:select] || []).dup
 
       # Setup the initial graph data structure if it doesn't exist
-      unless graph = opts[:graph]
+      if graph = opts[:graph]
+        opts[:graph] = graph = graph.dup
+        select = opts[:select].dup
+        [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k] = graph[k].dup}
+      else
         master = alias_symbol(ds.first_source_alias)
         raise_alias_error.call if master == table_alias
         # Master hash storing all .graph related information
@@ -132,9 +134,33 @@ module Sequel
         # aliased, but are not included if set_graph_aliases
         # has been used.
         if add_columns
-          columns.each do |column|
-            column_aliases[column] = [master, column]
-            select.push(SQL::QualifiedIdentifier.new(master, column))
+          if (select = @opts[:select]) && !select.empty? && !(select.length == 1 && (select.first.is_a?(SQL::ColumnAll)))
+            select = select.each do |sel|
+              column = case sel
+              when Symbol
+                _, c, a = split_symbol(sel)
+                (a || c).to_sym
+              when SQL::Identifier
+                sel.value.to_sym
+              when SQL::QualifiedIdentifier
+                column = sel.column
+                column = column.value if column.is_a?(SQL::Identifier)
+                column.to_sym
+              when SQL::AliasedExpression
+                column = sel.aliaz
+                column = column.value if column.is_a?(SQL::Identifier)
+                column.to_sym
+              else
+                raise Error, "can't figure out alias to use for graphing for #{sel.inspect}"
+              end
+              column_aliases[column] = [master, column]
+            end
+            select = qualified_expression(select, master)
+          else
+            select = columns.map do |column|
+              column_aliases[column] = [master, column]
+              SQL::QualifiedIdentifier.new(master, column)
+            end
           end
         end
       end
@@ -174,7 +200,7 @@ module Sequel
           select.push(identifier)
         end
       end
-      ds.select(*select)
+      add_columns ? ds.select(*select) : ds
     end
 
     # This allows you to manually specify the graph aliases to use

data/lib/sequel/dataset/prepared_statements.rb

@@ -63,6 +63,9 @@ module Sequel
       # The array/hash of bound variable placeholder names.
       attr_accessor :prepared_args
       
+      # The dataset that created this prepared statement.
+      attr_accessor :orig_dataset
+      
       # The argument to supply to insert and update, which may use
       # placeholders specified by prepared_args
       attr_accessor :prepared_modify_values
@@ -72,6 +75,12 @@ module Sequel
       def call(bind_vars={}, &block)
         bind(bind_vars).run(&block)
       end
+
+      # Send the columns to the original dataset, as calling it
+      # on the prepared statement can cause problems.
+      def columns
+        orig_dataset.columns
+      end
       
       # Returns the SQL for the prepared statement, depending on
       # the type of the statement and the prepared_modify_values.
@@ -80,7 +89,7 @@ module Sequel
         when :select, :all
           select_sql
         when :first
-          limit(1).select_sql
+          clone(:limit=>1).select_sql
         when :insert_select
           returning.insert_sql(*@prepared_modify_values)
         when :insert
@@ -95,10 +104,14 @@ module Sequel
       # Changes the values of symbols if they start with $ and
       # prepared_args is present.  If so, they are considered placeholders,
       # and they are substituted using prepared_arg.
-      def literal_symbol(v)
+      def literal_symbol_append(sql, v)
         if @opts[:bind_vars] and match = PLACEHOLDER_RE.match(v.to_s)
           s = match[1].to_sym
-          prepared_arg?(s) ? literal(prepared_arg(s)) : v
+          if prepared_arg?(s)
+            literal_append(sql, prepared_arg(s))
+          else
+            sql << v.to_s
+          end
         else
           super
         end
@@ -148,8 +161,8 @@ module Sequel
       # Use a clone of the dataset extended with prepared statement
       # support and using the same argument hash so that you can use
       # bind variables/prepared arguments in subselects.
-      def subselect_sql(ds)
-        ps = ds.prepare(:select)
+      def subselect_sql_append(sql, ds)
+        ps = ds.clone(:append_sql=>sql).prepare(:select)
         ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
         ps.prepared_args = prepared_args
         ps.prepared_sql
@@ -240,6 +253,7 @@ module Sequel
     def to_prepared_statement(type, values=nil)
       ps = bind
       ps.extend(PreparedStatementMethods)
+      ps.orig_dataset = self
       ps.prepared_type = type
       ps.prepared_modify_values = values
       ps

data/lib/sequel/dataset/sql.rb

@@ -61,9 +61,8 @@ module Sequel
         end
       end
 
-      columns = columns.map{|k| literal(String === k ? k.to_sym : k)}
       if values.is_a?(Array) && values.empty? && !insert_supports_empty_values? 
-        columns = [literal(columns().last)]
+        columns = [columns().last]
         values = ['DEFAULT'.lit]
       end
       clone(:columns=>columns, :values=>values)._insert_sql
@@ -79,41 +78,47 @@ module Sequel
     #   DB[:items].literal(:x + 1 > :y) => "((x + 1) > y)"
     #
     # If an unsupported object is given, an +Error+ is raised.
-    def literal(v)
+    def literal_append(sql, v)
       case v
-      when String
-        return v if v.is_a?(LiteralString)
-        v.is_a?(SQL::Blob) ? literal_blob(v) : literal_string(v)
       when Symbol
-        literal_symbol(v)
+        literal_symbol_append(sql, v)
+      when String
+        case v
+        when LiteralString
+          sql << v
+        when SQL::Blob
+          literal_blob_append(sql, v)
+        else
+          literal_string_append(sql, v)
+        end
       when Integer
-        literal_integer(v)
+        sql << literal_integer(v)
       when Hash
-        literal_hash(v)
+        literal_hash_append(sql, v)
       when SQL::Expression
-        literal_expression(v)
+        literal_expression_append(sql, v)
       when Float
-        literal_float(v)
+        sql << literal_float(v)
       when BigDecimal
-        literal_big_decimal(v)
+        sql << literal_big_decimal(v)
       when NilClass
-        literal_nil
+        sql << literal_nil
       when TrueClass
-        literal_true
+        sql << literal_true
       when FalseClass
-        literal_false
+        sql << literal_false
       when Array
-        literal_array(v)
+        literal_array_append(sql, v)
       when Time
-        v.is_a?(SQLTime) ? literal_sqltime(v) : literal_time(v)
+        sql << (v.is_a?(SQLTime) ? literal_sqltime(v) : literal_time(v))
       when DateTime
-        literal_datetime(v)
+        sql << literal_datetime(v)
       when Date
-        literal_date(v)
+        sql << literal_date(v)
       when Dataset
-        literal_dataset(v)
+        literal_dataset_append(sql, v)
       else
-        literal_other(v)
+        literal_other_append(sql, v)
       end
     end
     
@@ -177,84 +182,234 @@ module Sequel
       clauses.map{|clause| :"#{type}_#{clause}_sql"}.freeze
     end
 
+    ALL = ' ALL'.freeze
     AND_SEPARATOR = " AND ".freeze
+    APOS = "'".freeze
+    APOS_RE = /'/.freeze
+    ARRAY_EMPTY = '(NULL)'.freeze
+    AS = ' AS '.freeze
+    ASC = ' ASC'.freeze
+    BACKSLASH_RE = /\\/.freeze
     BOOL_FALSE = "'f'".freeze
     BOOL_TRUE = "'t'".freeze
-    COMMA_SEPARATOR = ', '.freeze
-    COLUMN_REF_RE1 = /\A(((?!__).)+)__(((?!___).)+)___(.+)\z/.freeze
-    COLUMN_REF_RE2 = /\A(((?!___).)+)___(.+)\z/.freeze
-    COLUMN_REF_RE3 = /\A(((?!__).)+)__(.+)\z/.freeze
+    BRACKET_CLOSE =  ']'.freeze
+    BRACKET_OPEN = '['.freeze
+    CASE_ELSE = " ELSE ".freeze
+    CASE_END = " END)".freeze
+    CASE_OPEN = '(CASE'.freeze
+    CASE_THEN = " THEN ".freeze
+    CASE_WHEN = " WHEN ".freeze
+    CAST_OPEN = 'CAST('.freeze
+    COLUMN_ALL = '.*'.freeze
+    COLUMN_REF_RE1 = /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/.freeze
+    COLUMN_REF_RE2 = /\A((?:(?!___).)+)___(.+)\z/.freeze
+    COLUMN_REF_RE3 = /\A((?:(?!__).)+)__(.+)\z/.freeze
+    COMMA = ', '.freeze
+    COMMA_SEPARATOR = COMMA
+    CONDITION_FALSE = '(1 = 0)'.freeze
+    CONDITION_TRUE = '(1 = 1)'.freeze
     COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
     COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, LiteralString.new('*'.freeze)).as(:count)
     DATASET_ALIAS_BASE_NAME = 't'.freeze
+    DEFAULT_VALUES = " DEFAULT VALUES".freeze
+    DELETE = 'DELETE'.freeze
+    DELETE_CLAUSE_METHODS = clause_methods(:delete, %w'delete from where')
+    DESC = ' DESC'.freeze
+    DISTINCT = " DISTINCT".freeze
+    DOT = '.'.freeze
+    DOUBLE_APOS = "''".freeze
+    DOUBLE_QUOTE = '""'.freeze
+    EQUAL = ' = '.freeze
+    EXTRACT = 'extract('.freeze
     FOR_UPDATE = ' FOR UPDATE'.freeze
+    FORMAT_DATE = "'%Y-%m-%d'".freeze
+    FORMAT_DATE_STANDARD = "DATE '%Y-%m-%d'".freeze
+    FORMAT_OFFSET = "%+03i%02i".freeze
+    FORMAT_TIMESTAMP_RE = /%[Nz]/.freeze
+    FORMAT_TIMESTAMP_USEC = ".%06d".freeze
+    FORMAT_USEC = '%N'.freeze
+    FRAME_ALL = "ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING".freeze
+    FRAME_ROWS = "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW".freeze
+    FROM = ' FROM '.freeze
+    FUNCTION_EMPTY = '()'.freeze
+    GROUP_BY = " GROUP BY ".freeze
+    HAVING = " HAVING ".freeze
+    INSERT = "INSERT".freeze
+    INSERT_CLAUSE_METHODS = clause_methods(:insert, %w'insert into columns values')
+    INTO = " INTO ".freeze
     IS_LITERALS = {nil=>'NULL'.freeze, true=>'TRUE'.freeze, false=>'FALSE'.freeze}.freeze
     IS_OPERATORS = ::Sequel::SQL::ComplexExpression::IS_OPERATORS
+    LIMIT = " LIMIT ".freeze
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
+    NOT_SPACE = 'NOT '.freeze
     NULL = "NULL".freeze
+    NULLS_FIRST = " NULLS FIRST".freeze
+    NULLS_LAST = " NULLS LAST".freeze
+    OFFSET = " OFFSET ".freeze
+    ON = ' ON '.freeze
+    ON_PAREN = " ON (".freeze
+    ORDER_BY = " ORDER BY ".freeze
+    ORDER_BY_NS = "ORDER BY ".freeze
+    OVER = ' OVER '.freeze
+    PAREN_CLOSE = ')'.freeze
+    PAREN_OPEN = '('.freeze
+    PAREN_SPACE_OPEN = ' ('.freeze
+    PARTITION_BY = "PARTITION BY ".freeze
+    QUAD_BACKSLASH = "\\\\\\\\".freeze
     QUALIFY_KEYS = [:select, :where, :having, :order, :group]
     QUESTION_MARK = '?'.freeze
-    DELETE_CLAUSE_METHODS = clause_methods(:delete, %w'from where')
-    INSERT_CLAUSE_METHODS = clause_methods(:insert, %w'into columns values')
-    SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with distinct columns from join where group having compounds order limit lock')
-    UPDATE_CLAUSE_METHODS = clause_methods(:update, %w'table set where')
+    QUESTION_MARK_RE = /\?/.freeze
+    QUOTE = '"'.freeze
+    QUOTE_RE = /"/.freeze
+    RETURNING = " RETURNING ".freeze
+    SELECT = 'SELECT'.freeze
+    SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with select distinct columns from join where group having compounds order limit lock')
+    SET = ' SET '.freeze
+    SPACE = ' '.freeze
+    SQL_WITH = "WITH ".freeze
+    TILDE = '~'.freeze
     TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S%N%z'".freeze
     STANDARD_TIMESTAMP_FORMAT = "TIMESTAMP #{TIMESTAMP_FORMAT}".freeze
     TWO_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::TWO_ARITY_OPERATORS
+    UNDERSCORE = '_'.freeze
+    UPDATE = 'UPDATE'.freeze
+    UPDATE_CLAUSE_METHODS = clause_methods(:update, %w'update table set where')
+    USING = ' USING ('.freeze
+    VALUES = " VALUES ".freeze
+    WHERE = " WHERE ".freeze
     WILDCARD = LiteralString.new('*').freeze
-    SQL_WITH = "WITH ".freeze
+
+    PUBLIC_APPEND_METHODS = (<<-END).split.map{|x| x.to_sym}
+      literal
+      aliased_expression_sql
+      array_sql
+      boolean_constant_sql
+      case_expression_sql
+      cast_sql
+      column_all_sql
+      complex_expression_sql
+      constant_sql
+      function_sql
+      join_clause_sql
+      join_on_clause_sql
+      join_using_clause_sql
+      negative_boolean_constant_sql
+      ordered_expression_sql
+      placeholder_literal_string_sql
+      qualified_identifier_sql
+      quote_identifier
+      quote_schema_table
+      quoted_identifier
+      subscript_sql
+      window_sql
+      window_function_sql
+    END
+    PRIVATE_APPEND_METHODS = (<<-END).split.map{|x| x.to_sym}
+      argument_list
+      as_sql
+      column_list
+      compound_dataset_sql
+      expression_list
+      literal_array
+      literal_blob
+      literal_dataset
+      literal_expression
+      literal_hash
+      literal_other
+      literal_string
+      literal_symbol
+      source_list
+      subselect_sql
+      table_ref
+    END
+    def self.def_append_methods(meths)
+      meths.each do |meth|
+        class_eval(<<-END, __FILE__, __LINE__ + 1)
+          def #{meth}(*args, &block)
+            s = ''
+            #{meth}_append(s, *args, &block)
+            s
+          end
+        END
+      end
+    end
+    def_append_methods(PUBLIC_APPEND_METHODS + PRIVATE_APPEND_METHODS)
+    private *PRIVATE_APPEND_METHODS
 
     # SQL fragment for AliasedExpression
-    def aliased_expression_sql(ae)
-      as_sql(literal(ae.expression), ae.aliaz)
+    def aliased_expression_sql_append(sql, ae)
+      literal_append(sql, ae.expression)
+      as_sql_append(sql, ae.aliaz)
     end
 
     # SQL fragment for Array
-    def array_sql(a)
-      a.empty? ? '(NULL)' : "(#{expression_list(a)})"     
+    def array_sql_append(sql, a)
+      if a.empty?
+        sql << ARRAY_EMPTY
+      else
+        sql << PAREN_OPEN
+        expression_list_append(sql, a)
+        sql << PAREN_CLOSE
+      end
     end
 
     # SQL fragment for BooleanConstants
-    def boolean_constant_sql(constant)
+    def boolean_constant_sql_append(sql, constant)
       if (constant == true || constant == false) && !supports_where_true?
-        constant == true ? '(1 = 1)' : '(1 = 0)'
+        sql << (constant == true ? CONDITION_TRUE : CONDITION_FALSE)
       else
-        literal(constant)
+        literal_append(sql, constant)
       end
     end
 
     # SQL fragment for CaseExpression
-    def case_expression_sql(ce)
-      sql = '(CASE '
-      sql << "#{literal(ce.expression)} " if ce.expression?
-      ce.conditions.collect{ |c,r|
-        sql << "WHEN #{literal(c)} THEN #{literal(r)} "
-      }
-      sql << "ELSE #{literal(ce.default)} END)"
+    def case_expression_sql_append(sql, ce)
+      sql << CASE_OPEN
+      if ce.expression?
+        sql << SPACE
+        literal_append(sql, ce.expression)
+      end
+      w = CASE_WHEN
+      t = CASE_THEN
+      ce.conditions.each do |c,r|
+        sql << w
+        literal_append(sql, c)
+        sql << t
+        literal_append(sql, r)
+      end
+      sql << CASE_ELSE
+      literal_append(sql, ce.default)
+      sql << CASE_END
     end
 
     # SQL fragment for the SQL CAST expression
-    def cast_sql(expr, type)
-      "CAST(#{literal(expr)} AS #{db.cast_type_literal(type)})"
+    def cast_sql_append(sql, expr, type)
+      sql << CAST_OPEN
+      literal_append(sql, expr)
+      sql << AS << db.cast_type_literal(type).to_s
+      sql << PAREN_CLOSE
     end
 
     # SQL fragment for specifying all columns in a given table
-    def column_all_sql(ca)
-      "#{quote_schema_table(ca.table)}.*"
+    def column_all_sql_append(sql, ca)
+      quote_schema_table_append(sql, ca.table)
+      sql << COLUMN_ALL
     end
 
-    # SQL fragment for complex expressions
-    def complex_expression_sql(op, args)
+    def complex_expression_sql_append(sql, op, args)
       case op
       when *IS_OPERATORS
         r = args.at(1)
         if r.nil? || supports_is_true?
           raise(InvalidOperation, 'Invalid argument used for IS operator') unless v = IS_LITERALS[r]
-          "(#{literal(args.at(0))} #{op} #{v})"
+          sql << PAREN_OPEN
+          literal_append(sql, args.at(0))
+          sql << SPACE << op.to_s << SPACE
+          sql << v << PAREN_CLOSE
         elsif op == :IS
-          complex_expression_sql(:"=", args)
+          complex_expression_sql_append(sql, :"=", args)
         else
-          complex_expression_sql(:OR, [SQL::BooleanExpression.new(:"!=", *args), SQL::BooleanExpression.new(:IS, args.at(0), nil)])
+          complex_expression_sql_append(sql, :OR, [SQL::BooleanExpression.new(:"!=", *args), SQL::BooleanExpression.new(:IS, args.at(0), nil)])
         end
       when :IN, :"NOT IN"
         cols = args.at(0)
@@ -267,147 +422,228 @@ module Sequel
         if col_array
           if empty_val_array
             if op == :IN
-              literal(SQL::BooleanExpression.from_value_pairs(cols.to_a.map{|x| [x, x]}, :AND, true))
+              literal_append(sql, SQL::BooleanExpression.from_value_pairs(cols.to_a.map{|x| [x, x]}, :AND, true))
             else
-              literal(1=>1)
+              literal_append(sql, 1=>1)
             end
           elsif !supports_multiple_column_in?
             if val_array
               expr = SQL::BooleanExpression.new(:OR, *vals.to_a.map{|vs| SQL::BooleanExpression.from_value_pairs(cols.to_a.zip(vs).map{|c, v| [c, v]})})
-              literal(op == :IN ? expr : ~expr)
+              literal_append(sql, op == :IN ? expr : ~expr)
             else
               old_vals = vals
               vals = vals.naked if vals.is_a?(Sequel::Dataset)
               vals = vals.to_a
               val_cols = old_vals.columns
-              complex_expression_sql(op, [cols, vals.map!{|x| x.values_at(*val_cols)}])
+              complex_expression_sql_append(sql, op, [cols, vals.map!{|x| x.values_at(*val_cols)}])
             end
           else
             # If the columns and values are both arrays, use array_sql instead of
             # literal so that if values is an array of two element arrays, it
             # will be treated as a value list instead of a condition specifier.
-            "(#{literal(cols)} #{op} #{val_array ? array_sql(vals) : literal(vals)})"
+            sql << PAREN_OPEN
+            literal_append(sql, cols)
+            sql << SPACE << op.to_s << SPACE
+            if val_array
+              array_sql_append(sql, vals)
+            else
+              literal_append(sql, vals)
+            end
+            sql << PAREN_CLOSE
           end
         else
           if empty_val_array
             if op == :IN
-              literal(SQL::BooleanExpression.from_value_pairs([[cols, cols]], :AND, true))
+              literal_append(sql, SQL::BooleanExpression.from_value_pairs([[cols, cols]], :AND, true))
             else
-              literal(1=>1)
+              literal_append(sql, 1=>1)
             end
           else
-            "(#{literal(cols)} #{op} #{literal(vals)})"
+            sql << PAREN_OPEN
+            literal_append(sql, cols)
+            sql << SPACE << op.to_s << SPACE
+            literal_append(sql, vals)
+            sql << PAREN_CLOSE
           end
         end
       when *TWO_ARITY_OPERATORS
-        "(#{literal(args.at(0))} #{op} #{literal(args.at(1))})"
+        sql << PAREN_OPEN
+        literal_append(sql, args.at(0))
+        sql << SPACE << op.to_s << SPACE
+        literal_append(sql, args.at(1))
+        sql << PAREN_CLOSE
       when *N_ARITY_OPERATORS
-        "(#{args.collect{|a| literal(a)}.join(" #{op} ")})"
+        sql << PAREN_OPEN
+        c = false
+        op_str = " #{op} "
+        args.each do |a|
+          sql << op_str if c
+          literal_append(sql, a)
+          c ||= true
+        end
+        sql << PAREN_CLOSE
       when :NOT
-        "NOT #{literal(args.at(0))}"
+        sql << NOT_SPACE
+        literal_append(sql, args.at(0))
       when :NOOP
-        literal(args.at(0))
+        literal_append(sql, args.at(0))
       when :'B~'
-        "~#{literal(args.at(0))}"
+        sql << TILDE
+        literal_append(sql, args.at(0))
       when :extract
-        "extract(#{args.at(0)} FROM #{literal(args.at(1))})"
+        sql << EXTRACT << args.at(0).to_s << FROM
+        literal_append(sql, args.at(1))
+        sql << PAREN_CLOSE
       else
         raise(InvalidOperation, "invalid operator #{op}")
       end
     end
     
     # SQL fragment for constants
-    def constant_sql(constant)
-      constant.to_s
+    def constant_sql_append(sql, constant)
+      sql << constant.to_s
     end
 
     # SQL fragment specifying an SQL function call
-    def function_sql(f)
+    def function_sql_append(sql, f)
+      sql << f.f.to_s
       args = f.args
-      "#{f.f}#{args.empty? ? '()' : literal(args)}"
+      if args.empty?
+        sql << FUNCTION_EMPTY
+      else
+        literal_append(sql, args)
+      end
     end
 
     # SQL fragment specifying a JOIN clause without ON or USING.
-    def join_clause_sql(jc)
+    def join_clause_sql_append(sql, jc)
       table = jc.table
       table_alias = jc.table_alias
       table_alias = nil if table == table_alias
-      tref = table_ref(table)
-      " #{join_type_sql(jc.join_type)} #{table_alias ? as_sql(tref, table_alias) : tref}"
+      sql << SPACE << join_type_sql(jc.join_type) << SPACE
+      table_ref_append(sql, table)
+      as_sql_append(sql, table_alias) if table_alias
     end
 
     # SQL fragment specifying a JOIN clause with ON.
-    def join_on_clause_sql(jc)
-      "#{join_clause_sql(jc)} ON #{literal(filter_expr(jc.on))}"
+    def join_on_clause_sql_append(sql, jc)
+      join_clause_sql_append(sql, jc)
+      sql << ON
+      literal_append(sql, filter_expr(jc.on))
     end
 
     # SQL fragment specifying a JOIN clause with USING.
-    def join_using_clause_sql(jc)
-      "#{join_clause_sql(jc)} USING (#{column_list(jc.using)})"
+    def join_using_clause_sql_append(sql, jc)
+      join_clause_sql_append(sql, jc)
+      sql << USING
+      column_list_append(sql, jc.using)
+      sql << PAREN_CLOSE
     end
     
     # SQL fragment for NegativeBooleanConstants
-    def negative_boolean_constant_sql(constant)
-      "NOT #{boolean_constant_sql(constant)}"
+    def negative_boolean_constant_sql_append(sql, constant)
+      sql << NOT_SPACE
+      boolean_constant_sql_append(sql, constant)
     end
 
     # SQL fragment for the ordered expression, used in the ORDER BY
     # clause.
-    def ordered_expression_sql(oe)
-      s = "#{literal(oe.expression)} #{oe.descending ? 'DESC' : 'ASC'}"
+    def ordered_expression_sql_append(sql, oe)
+      literal_append(sql, oe.expression)
+      sql << (oe.descending ? DESC : ASC)
       case oe.nulls
       when :first
-        "#{s} NULLS FIRST"
+        sql << NULLS_FIRST
       when :last
-        "#{s} NULLS LAST"
-      else
-        s
+        sql << NULLS_LAST
       end
     end
 
     # SQL fragment for a literal string with placeholders
-    def placeholder_literal_string_sql(pls)
+    def placeholder_literal_string_sql_append(sql, pls)
       args = pls.args
-      s = if args.is_a?(Hash)
+      sql << PAREN_OPEN if pls.parens
+      if args.is_a?(Hash)
         re = /:(#{args.keys.map{|k| Regexp.escape(k.to_s)}.join('|')})\b/
-        pls.str.gsub(re){literal(args[$1.to_sym])}
+        if RUBY_VERSION >= '1.8.7'
+          str = pls.str
+          loop do
+            previous, q, str = str.partition(re)
+            sql << previous
+            literal_append(sql, args[($1||q[1..-1].to_s).to_sym]) unless q.empty?
+            break if str.empty?
+          end
+        else
+          sql << pls.str.gsub(re){literal(args[$1.to_sym])}
+        end
       else
         i = -1
-        pls.str.gsub(QUESTION_MARK){literal(args.at(i+=1))}
+        if RUBY_VERSION >= '1.8.7'
+          str = pls.str
+          loop do
+            previous, q, str = str.partition(QUESTION_MARK)
+            sql << previous
+            literal_append(sql, args.at(i+=1)) unless q.empty?
+            break if str.empty?
+          end
+        else
+          sql << pls.str.gsub(QUESTION_MARK_RE){literal(args.at(i+=1))}
+        end
       end
-      s = "(#{s})" if pls.parens
-      s
+      sql << PAREN_CLOSE if pls.parens
     end
 
     # SQL fragment for the qualifed identifier, specifying
     # a table and a column (or schema and table).
-    def qualified_identifier_sql(qcr)
-      [qcr.table, qcr.column].map{|x| [SQL::QualifiedIdentifier, SQL::Identifier, Symbol].any?{|c| x.is_a?(c)} ? literal(x) : quote_identifier(x)}.join('.')
+    def qualified_identifier_sql_append(sql, qcr)
+      case t = qcr.table
+      when Symbol, SQL::QualifiedIdentifier, SQL::Identifier
+        literal_append(sql, t) 
+      else
+        quote_identifier_append(sql, t)
+      end
+      sql << DOT
+      case c = qcr.column
+      when Symbol, SQL::QualifiedIdentifier, SQL::Identifier
+        literal_append(sql, c) 
+      else
+        quote_identifier_append(sql, c)
+      end
     end
 
     # Adds quoting to identifiers (columns and tables). If identifiers are not
     # being quoted, returns name as a string.  If identifiers are being quoted
     # quote the name with quoted_identifier.
-    def quote_identifier(name)
-      return name if name.is_a?(LiteralString)
-      name = name.value if name.is_a?(SQL::Identifier)
-      name = input_identifier(name)
-      name = quoted_identifier(name) if quote_identifiers?
-      name
+    def quote_identifier_append(sql, name)
+      if name.is_a?(LiteralString)
+        sql << name
+      else
+        name = name.value if name.is_a?(SQL::Identifier)
+        name = input_identifier(name)
+        if quote_identifiers?
+          quoted_identifier_append(sql, name)
+        else
+          sql << name
+        end
+      end
     end
 
     # Separates the schema from the table and returns a string with them
     # quoted (if quoting identifiers)
-    def quote_schema_table(table)
+    def quote_schema_table_append(sql, table)
       schema, table = schema_and_table(table)
-      "#{"#{quote_identifier(schema)}." if schema}#{quote_identifier(table)}"
+      if schema
+        quote_identifier_append(sql, schema)
+        sql << DOT
+      end
+      quote_identifier_append(sql, table)
     end
 
     # This method quotes the given name with the SQL standard double quote. 
     # should be overridden by subclasses to provide quoting not matching the
     # SQL standard, such as backtick (used by MySQL and SQLite).
-    def quoted_identifier(name)
-      "\"#{name.to_s.gsub('"', '""')}\""
+    def quoted_identifier_append(sql, name)
+      sql << QUOTE << name.to_s.gsub(QUOTE_RE, DOUBLE_QUOTE) << QUOTE
     end
 
     # Split the schema information from the table
@@ -429,34 +665,59 @@ module Sequel
     end
 
     # SQL fragment for specifying subscripts (SQL array accesses)
-    def subscript_sql(s)
-      "#{literal(s.f)}[#{expression_list(s.sub)}]"
+    def subscript_sql_append(sql, s)
+      literal_append(sql, s.f)
+      sql << BRACKET_OPEN
+      expression_list_append(sql, s.sub)
+      sql << BRACKET_CLOSE
     end
 
     # The SQL fragment for the given window's options.
-    def window_sql(opts)
+    def window_sql_append(sql, opts)
       raise(Error, 'This dataset does not support window functions') unless supports_window_functions?
-      window = literal(opts[:window]) if opts[:window]
-      partition = "PARTITION BY #{expression_list(Array(opts[:partition]))}" if opts[:partition]
-      order = "ORDER BY #{expression_list(Array(opts[:order]))}" if opts[:order]
-      frame = case opts[:frame]
+      sql << PAREN_OPEN
+      window, part, order, frame = opts.values_at(:window, :partition, :order, :frame)
+      space = false
+      space_s = SPACE
+      if window
+        literal_append(sql, window)
+        space = true
+      end
+      if part
+        sql << space_s if space
+        sql << PARTITION_BY
+        expression_list_append(sql, Array(part))
+        space = true
+      end
+      if order
+        sql << space_s if space
+        sql << ORDER_BY_NS
+        expression_list_append(sql, Array(order))
+        space = true
+      end
+      case frame
         when nil
-          nil
+          # nothing
         when :all
-          "ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING"
+          sql << space_s if space
+          sql << FRAME_ALL
         when :rows
-          "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW"
+          sql << space_s if space
+          sql << FRAME_ROWS
         when String
-          opts[:frame]
+          sql << space_s if space
+          sql << frame
         else
           raise Error, "invalid window frame clause, should be :all, :rows, a string, or nil"
       end
-      "(#{[window, partition, order, frame].compact.join(' ')})"
+      sql << PAREN_CLOSE
     end
 
     # The SQL fragment for the given window function's function and window.
-    def window_function_sql(function, window)
-      "#{literal(function)} OVER #{literal(window)}"
+    def window_function_sql_append(sql, function, window)
+      literal_append(sql, function)
+      sql << OVER
+      literal_append(sql, window)
     end
 
     protected
@@ -528,14 +789,20 @@ module Sequel
       options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered
     end
 
-    # Do a simple join of the arguments (which should be strings or symbols) separated by commas
-    def argument_list(args)
-      args.join(COMMA_SEPARATOR)
+    def argument_list_append(sql, args)
+      c = false
+      comma = COMMA
+      args.each do |a|
+        sql << comma if c
+        sql << a.to_s
+        c ||= true
+      end
     end
 
     # SQL fragment for specifying an alias.  expression should already be literalized.
-    def as_sql(expression, aliaz)
-      "#{expression} AS #{quote_identifier(aliaz)}"
+    def as_sql_append(sql, aliaz)
+      sql << AS
+      quote_identifier_append(sql, aliaz)
     end
     
     # Raise an InvalidOperation exception if deletion is not allowed
@@ -547,17 +814,21 @@ module Sequel
 
     # Prepare an SQL statement by calling all clause methods for the given statement type.
     def clause_sql(type)
-      sql = type.to_s.upcase
+      sql = @opts[:append_sql] || ''
       send("#{type}_clause_methods").each{|x| send(x, sql)}
       sql
     end
 
     # Converts an array of column names into a comma seperated string of 
     # column names. If the array is empty, a wildcard (*) is returned.
-    def column_list(columns)
-      (columns.nil? || columns.empty?) ? WILDCARD : expression_list(columns)
+    def column_list_append(sql, columns)
+      if (columns.nil? || columns.empty?)
+        sql << WILDCARD
+      else
+        expression_list_append(sql, columns)
+      end
     end
-    
+
     # Yield each two pair of arguments to the block, which should
     # return a string representing the SQL code for those
     # two arguments.  If more than 2 arguments are provided, all
@@ -576,8 +847,8 @@ module Sequel
     end
 
     # The SQL to use for the dataset used in a UNION/INTERSECT/EXCEPT clause. 
-    def compound_dataset_sql(ds)
-      subselect_sql(ds)
+    def compound_dataset_sql_append(sql, ds)
+      subselect_sql_append(sql, ds)
     end
 
     # The alias to use for datasets, takes a number to make sure the name is unique.
@@ -590,10 +861,20 @@ module Sequel
       DELETE_CLAUSE_METHODS
     end
 
+    def delete_delete_sql(sql)
+      sql << DELETE
+    end
+
     # Converts an array of expressions into a comma separated string of
     # expressions.
-    def expression_list(columns)
-      columns.map{|i| literal(i)}.join(COMMA_SEPARATOR)
+    def expression_list_append(sql, columns)
+      c = false
+      co = COMMA
+      columns.each do |col|
+        sql << co if c
+        literal_append(sql, col)
+        c ||= true
+      end
     end
     
     # The strftime format to use when literalizing the time.
@@ -607,8 +888,8 @@ module Sequel
     # of hours and minutes.
     def format_timestamp(v)
       v2 = db.from_application_timestamp(v)
-      fmt = default_timestamp_format.gsub(/%[Nz]/) do |m|
-        if m == '%N'
+      fmt = default_timestamp_format.gsub(FORMAT_TIMESTAMP_RE) do |m|
+        if m == FORMAT_USEC
           format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000) : v.usec) if supports_timestamp_usecs?
         else
           if supports_timestamp_timezones?
@@ -624,13 +905,13 @@ module Sequel
     
     # Return the SQL timestamp fragment to use for the timezone offset.
     def format_timestamp_offset(hour, minute)
-      sprintf("%+03i%02i", hour, minute)
+      sprintf(FORMAT_OFFSET, hour, minute)
     end
 
     # Return the SQL timestamp fragment to use for the fractional time part.
     # Should start with the decimal point.  Uses 6 decimal places by default.
     def format_timestamp_usec(usec)
-      sprintf(".%06d", usec)
+      sprintf(FORMAT_TIMESTAMP_USEC, usec)
     end
 
     # Modify the identifier returned from the database based on the
@@ -641,7 +922,8 @@ module Sequel
 
     # SQL fragment specifying the table to insert INTO
     def insert_into_sql(sql)
-      sql << " INTO #{source_list(@opts[:from])}"
+      sql << INTO
+      source_list_append(sql, @opts[:from])
     end
 
     # The order of methods to call to build the INSERT SQL statement
@@ -652,18 +934,42 @@ module Sequel
     # SQL fragment specifying the columns to insert into
     def insert_columns_sql(sql)
       columns = opts[:columns]
-      sql << " (#{columns.join(COMMA_SEPARATOR)})" if columns && !columns.empty?
+      if columns && !columns.empty?
+        sql << PAREN_SPACE_OPEN
+        c = false
+        co = COMMA
+        columns.each do |col|
+          sql << co if c
+          if col.is_a?(String) && !col.is_a?(LiteralString)
+            quote_identifier_append(sql, col)
+          else
+            literal_append(sql, col)
+          end
+          c ||= true
+        end
+        sql << PAREN_CLOSE
+      end 
+    end
+
+    def insert_insert_sql(sql)
+      sql << INSERT
     end
 
     # SQL fragment specifying the values to insert.
     def insert_values_sql(sql)
       case values = opts[:values]
       when Array
-        sql << (values.empty? ? " DEFAULT VALUES" : " VALUES #{literal(values)}")
+        if values.empty?
+          sql << DEFAULT_VALUES
+        else
+          sql << VALUES
+          literal_append(sql, values)
+        end
       when Dataset
-        sql << " #{subselect_sql(values)}"
+        sql << SPACE
+        subselect_sql_append(sql, values)
       when LiteralString
-        sql << " #{values}"
+        sql << SPACE << values
       else
         raise Error, "Unsupported INSERT values type, should be an Array or Dataset: #{values.inspect}"
       end
@@ -672,7 +978,8 @@ module Sequel
     # SQL fragment specifying the values to return.
     def insert_returning_sql(sql)
       if opts.has_key?(:returning)
-        sql << " RETURNING #{column_list(Array(opts[:returning]))}"
+        sql << RETURNING
+        column_list_append(sql, Array(opts[:returning]))
       end
     end
     alias delete_returning_sql insert_returning_sql
@@ -681,7 +988,7 @@ module Sequel
     # SQL fragment specifying a JOIN type, converts underscores to
     # spaces and upcases.
     def join_type_sql(join_type)
-      "#{join_type.to_s.gsub('_', ' ').upcase} JOIN"
+      "#{join_type.to_s.gsub(UNDERSCORE, SPACE).upcase} JOIN"
     end
 
     # Whether this dataset is a joined dataset
@@ -690,8 +997,12 @@ module Sequel
     end
 
     # SQL fragment for Array.  Treats as an expression if an array of all two pairs, or as a SQL array otherwise.
-    def literal_array(v)
-      Sequel.condition_specifier?(v) ? literal_expression(SQL::BooleanExpression.from_value_pairs(v)) : array_sql(v)
+    def literal_array_append(sql, v)
+      if Sequel.condition_specifier?(v)
+        literal_expression_append(sql, SQL::BooleanExpression.from_value_pairs(v))
+      else
+        array_sql_append(sql, v)
+      end
     end
 
     # SQL fragment for BigDecimal
@@ -701,18 +1012,24 @@ module Sequel
     end
 
     # SQL fragment for SQL::Blob
-    def literal_blob(v)
-      literal_string(v)
+    def literal_blob_append(sql, v)
+      literal_string_append(sql, v)
     end
 
     # SQL fragment for Dataset.  Does a subselect inside parantheses.
-    def literal_dataset(v)
-      "(#{subselect_sql(v)})"
+    def literal_dataset_append(sql, v)
+      sql << PAREN_OPEN
+      subselect_sql_append(sql, v)
+      sql << PAREN_CLOSE
     end
 
     # SQL fragment for Date, using the ISO8601 format.
     def literal_date(v)
-      v.strftime("#{'DATE ' if requires_sql_standard_datetimes?}'%Y-%m-%d'")
+      if requires_sql_standard_datetimes?
+        v.strftime(FORMAT_DATE_STANDARD)
+      else
+        v.strftime(FORMAT_DATE)
+      end
     end
 
     # SQL fragment for DateTime
@@ -721,8 +1038,8 @@ module Sequel
     end
 
     # SQL fragment for SQL::Expression, result depends on the specific type of expression.
-    def literal_expression(v)
-      v.to_s(self)
+    def literal_expression_append(sql, v)
+      v.to_s_append(self, sql)
     end
 
     # SQL fragment for false
@@ -736,8 +1053,8 @@ module Sequel
     end
 
     # SQL fragment for Hash, treated as an expression
-    def literal_hash(v)
-      literal_expression(SQL::BooleanExpression.from_value_pairs(v))
+    def literal_hash_append(sql, v)
+      literal_expression_append(sql, SQL::BooleanExpression.from_value_pairs(v))
     end
 
     # SQL fragment for Integer
@@ -756,9 +1073,11 @@ module Sequel
     # provided and should add that method to Sequel::Dataset, allowing for adapters
     # to provide customized literalizations.
     # If a database specific type is allowed, this should be overriden in a subclass.
-    def literal_other(v)
-      if v.respond_to?(:sql_literal)
-        v.sql_literal(self)
+    def literal_other_append(sql, v)
+      if v.respond_to?(:sql_literal_append)
+        v.sql_literal_append(self, sql)
+      elsif v.respond_to?(:sql_literal)
+        sql << v.sql_literal(self)
       else
         raise Error, "can't express #{v.inspect} as a SQL literal"
       end
@@ -770,8 +1089,8 @@ module Sequel
     end
 
     # SQL fragment for String.  Doubles \ and ' by default.
-    def literal_string(v)
-      "'#{v.gsub(/\\/, "\\\\\\\\").gsub(/'/, "''")}'"
+    def literal_string_append(sql, v)
+      sql << APOS << v.gsub(BACKSLASH_RE, QUAD_BACKSLASH).gsub(APOS_RE, DOUBLE_APOS) << APOS
     end
 
     # Converts a symbol into a column name. This method supports underscore
@@ -782,10 +1101,14 @@ module Sequel
     #   dataset.literal(:abc___a) #=> "abc AS a"
     #   dataset.literal(:items__abc) #=> "items.abc"
     #   dataset.literal(:items__abc___a) #=> "items.abc AS a"
-    def literal_symbol(v)
+    def literal_symbol_append(sql, v)
       c_table, column, c_alias = split_symbol(v)
-      qc = "#{"#{quote_identifier(c_table)}." if c_table}#{quote_identifier(column)}"
-      c_alias ? as_sql(qc, c_alias) : qc
+      if c_table
+        quote_identifier_append(sql, c_table)
+        sql << DOT
+      end
+      quote_identifier_append(sql, column)
+      as_sql_append(sql, c_alias) if c_alias
     end
 
     # SQL fragment for Time
@@ -831,13 +1154,19 @@ module Sequel
 
     # Modify the sql to add the columns selected
     def select_columns_sql(sql)
-      sql << " #{column_list(@opts[:select])}"
+      sql << SPACE
+      column_list_append(sql, @opts[:select])
     end
 
     # Modify the sql to add the DISTINCT modifier
     def select_distinct_sql(sql)
       if distinct = @opts[:distinct]
-        sql << " DISTINCT#{" ON (#{expression_list(distinct)})" unless distinct.empty?}"
+        sql << DISTINCT
+        unless distinct.empty?
+          sql << ON_PAREN
+          expression_list_append(sql, distinct)
+          sql << PAREN_CLOSE
+        end
       end
     end
 
@@ -845,59 +1174,89 @@ module Sequel
     # This uses a subselect for the compound datasets used, because using parantheses doesn't
     # work on all databases.  I consider this an ugly hack, but can't I think of a better default.
     def select_compounds_sql(sql)
-      return unless @opts[:compounds]
-      @opts[:compounds].each do |type, dataset, all|
-        sql << " #{type.to_s.upcase}#{' ALL' if all} #{compound_dataset_sql(dataset)}"
+      return unless c = @opts[:compounds]
+      c.each do |type, dataset, all|
+        sql << SPACE << type.to_s.upcase
+        sql << ALL if all
+        sql << SPACE
+        compound_dataset_sql_append(sql, dataset)
       end
     end
 
     # Modify the sql to add the list of tables to select FROM
     def select_from_sql(sql)
-      sql << " FROM #{source_list(@opts[:from])}" if @opts[:from]
+      if f = @opts[:from]
+        sql << FROM
+        source_list_append(sql, f)
+      end
     end
     alias delete_from_sql select_from_sql
 
     # Modify the sql to add the expressions to GROUP BY
     def select_group_sql(sql)
-      sql << " GROUP BY #{expression_list(@opts[:group])}" if @opts[:group]
+      if group = @opts[:group]
+        sql << GROUP_BY
+        expression_list_append(sql, group)
+      end
     end
 
     # Modify the sql to add the filter criteria in the HAVING clause
     def select_having_sql(sql)
-      sql << " HAVING #{literal(@opts[:having])}" if @opts[:having]
+      if having = @opts[:having]
+        sql << HAVING
+        literal_append(sql, having)
+      end
     end
 
     # Modify the sql to add the list of tables to JOIN to
     def select_join_sql(sql)
-      @opts[:join].each{|j| sql << literal(j)} if @opts[:join]
+      if js = @opts[:join]
+        js.each{|j| literal_append(sql, j)}
+      end
     end
 
     # Modify the sql to limit the number of rows returned and offset
     def select_limit_sql(sql)
-      sql << " LIMIT #{literal(@opts[:limit])}" if @opts[:limit]
-      sql << " OFFSET #{literal(@opts[:offset])}" if @opts[:offset]
+      if l = @opts[:limit]
+        sql << LIMIT
+        literal_append(sql, l)
+      end
+      if o = @opts[:offset]
+        sql << OFFSET
+        literal_append(sql, o)
+      end
     end
   
     # Modify the sql to support the different types of locking modes.
     def select_lock_sql(sql)
-      case @opts[:lock]
+      case l = @opts[:lock]
       when :update
         sql << FOR_UPDATE
       when String
-        sql << " #{@opts[:lock]}"
+        sql << SPACE << l
       end
     end
 
     # Modify the sql to add the expressions to ORDER BY
     def select_order_sql(sql)
-      sql << " ORDER BY #{expression_list(@opts[:order])}" if @opts[:order]
+      if o = @opts[:order]
+        sql << ORDER_BY
+        expression_list_append(sql, o)
+      end
     end
     alias delete_order_sql select_order_sql
     alias update_order_sql select_order_sql
 
+    def select_select_sql(sql)
+      sql << SELECT
+    end
+
     # Modify the sql to add the filter criteria in the WHERE clause
     def select_where_sql(sql)
-      sql << " WHERE #{literal(@opts[:where])}" if @opts[:where]
+      if w = @opts[:where]
+        sql << WHERE
+        literal_append(sql, w)
+      end
     end
     alias delete_where_sql select_where_sql
     alias update_where_sql select_where_sql
@@ -906,7 +1265,22 @@ module Sequel
     def select_with_sql(sql)
       ws = opts[:with]
       return if !ws || ws.empty?
-      sql.replace("#{select_with_sql_base}#{ws.map{|w| "#{quote_identifier(w[:name])}#{"(#{argument_list(w[:args])})" if w[:args]} AS #{literal_dataset(w[:dataset])}"}.join(COMMA_SEPARATOR)} #{sql}")
+      sql << select_with_sql_base
+      c = false
+      comma = COMMA
+      ws.each do |w|
+        sql << comma if c
+        quote_identifier_append(sql, w[:name])
+        if args = w[:args]
+         sql << PAREN_OPEN
+         argument_list_append(sql, args)
+         sql << PAREN_CLOSE
+        end
+        sql << AS
+        literal_dataset_append(sql, w[:dataset])
+        c ||= true
+      end
+      sql << SPACE
     end
     alias delete_with_sql select_with_sql
     alias insert_with_sql select_with_sql
@@ -918,9 +1292,15 @@ module Sequel
     end
 
     # Converts an array of source names into into a comma separated list.
-    def source_list(source)
-      raise(Error, 'No source specified for query') if source.nil? || source.empty?
-      source.map{|s| table_ref(s)}.join(COMMA_SEPARATOR)
+    def source_list_append(sql, sources)
+      raise(Error, 'No source specified for query') if sources.nil? || sources == []
+      c = false
+      co = COMMA
+      sources.each do |s|
+        sql << co if c
+        table_ref_append(sql, s)
+        c ||= true
+      end
     end
     
     # Splits the symbol into three parts.  Each part will
@@ -929,13 +1309,13 @@ module Sequel
     # For columns, these parts are the table, column, and alias.
     # For tables, these parts are the schema, table, and alias.
     def split_symbol(sym)
-      s = sym.to_s
-      if m = COLUMN_REF_RE1.match(s)
-        [m[1], m[3], m[5]]
-      elsif m = COLUMN_REF_RE2.match(s)
-        [nil, m[1], m[3]]
-      elsif m = COLUMN_REF_RE3.match(s)
-        [m[1], m[3], nil]
+      case s = sym.to_s
+      when COLUMN_REF_RE1
+        [$1, $2, $3]
+      when COLUMN_REF_RE2
+        [nil, $1, $2]
+      when COLUMN_REF_RE3
+        [$1, $2, nil]
       else
         [nil, s, nil]
       end
@@ -945,18 +1325,35 @@ module Sequel
     # can be a PlaceholderLiteralString in addition to a String,
     # we literalize nonstrings.
     def static_sql(sql)
-      sql.is_a?(String) ? sql : literal(sql)
+      if append_sql = @opts[:append_sql]
+        if sql.is_a?(String)
+          append_sql << sql
+        else
+          literal_append(append_sql, sql)
+        end
+      else
+        if sql.is_a?(String)
+          sql
+        else
+          literal(sql)
+        end
+      end
     end
 
     # SQL fragment for a subselect using the given database's SQL.
-    def subselect_sql(ds)
-      ds.sql
+    def subselect_sql_append(sql, ds)
+      ds.clone(:append_sql=>sql).sql
     end
 
     # SQL fragment specifying a table name.
-    def table_ref(t)
-      t.is_a?(String) ? quote_identifier(t) : literal(t)
+    def table_ref_append(sql, t)
+      if t.is_a?(String)
+        quote_identifier_append(sql, t)
+      else
+        literal_append(sql, t)
+      end
     end
+    alias identifier_append table_ref_append
     
     # The order of methods to call to build the UPDATE SQL statement
     def update_clause_methods
@@ -966,25 +1363,38 @@ module Sequel
     # SQL fragment specifying the tables from with to delete.
     # Includes join table if modifying joins is allowed.
     def update_table_sql(sql)
-      sql << " #{source_list(@opts[:from])}"
+      sql << SPACE
+      source_list_append(sql, @opts[:from])
       select_join_sql(sql) if supports_modifying_joins?
     end
 
     # The SQL fragment specifying the columns and values to SET.
     def update_set_sql(sql)
       values = opts[:values]
-      set = if values.is_a?(Hash)
+      sql << SET
+      if values.is_a?(Hash)
         values = opts[:defaults].merge(values) if opts[:defaults]
         values = values.merge(opts[:overrides]) if opts[:overrides]
-        # get values from hash
-        values.map do |k, v|
-          "#{k.is_a?(String) && !k.is_a?(LiteralString) ? quote_identifier(k) : literal(k)} = #{literal(v)}"
-        end.join(COMMA_SEPARATOR)
+        c = false
+        eq = EQUAL
+        values.each do |k, v|
+          sql << COMMA if c
+          if k.is_a?(String) && !k.is_a?(LiteralString)
+            quote_identifier_append(sql, k)
+          else
+            literal_append(sql, k)
+          end
+          sql << eq
+          literal_append(sql, v)
+          c ||= true
+        end
       else
-        # copy values verbatim
-        values
+        sql << values
       end
-      sql << " SET #{set}"
+    end
+
+    def update_update_sql(sql)
+      sql << UPDATE
     end
   end
 end