sequel 3.21.0 → 3.36.0

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

@@ -1,5 +1,6 @@
 module Sequel
   Dataset::NON_SQL_OPTIONS << :insert_ignore
+  Dataset::NON_SQL_OPTIONS << :update_ignore
   Dataset::NON_SQL_OPTIONS << :on_duplicate_key_update
 
   module MySQL
@@ -30,7 +31,7 @@ module Sequel
     module DatabaseMethods
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
       CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}
-      COLUMN_DEFINITION_ORDER = [:null, :default, :unique, :primary_key, :auto_increment, :references]
+      COLUMN_DEFINITION_ORDER = [:collate, :null, :default, :unique, :primary_key, :auto_increment, :references]
       PRIMARY = 'PRIMARY'.freeze
       
       # MySQL's cast rules are restrictive in that you can't just cast to any possible
@@ -50,6 +51,36 @@ module Sequel
         :mysql
       end
 
+      # Use the Information Schema's KEY_COLUMN_USAGE table to get
+      # basic information on foreign key columns, but include the
+      # constraint name.
+      def foreign_key_list(table, opts={})
+        m = output_identifier_meth
+        im = input_identifier_meth
+        ds = metadata_dataset.
+          from(:INFORMATION_SCHEMA__KEY_COLUMN_USAGE).
+          where(:TABLE_NAME=>im.call(table)).
+          exclude(:CONSTRAINT_NAME=>'PRIMARY').
+          exclude(:REFERENCED_TABLE_NAME=>nil).
+          select(:CONSTRAINT_NAME___name, :COLUMN_NAME___column, :REFERENCED_TABLE_NAME___table, :REFERENCED_COLUMN_NAME___key)
+        
+        h = {}
+        ds.each do |row|
+          if r = h[row[:name]]
+            r[:columns] << m.call(row[:column])
+            r[:key] << m.call(row[:key])
+          else
+            h[row[:name]] = {:name=>m.call(row[:name]), :columns=>[m.call(row[:column])], :table=>m.call(row[:table]), :key=>[m.call(row[:key])]}
+          end
+        end
+        h.values
+      end
+
+      # MySQL namespaces indexes per table.
+      def global_index_namespace?
+        false
+      end
+
       # Use SHOW INDEX FROM to get the index information for the
       # table.
       #
@@ -83,23 +114,25 @@ module Sequel
         @server_version ||= (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
       end
       
-      # Return an array of symbols specifying table names in the current database.
-      #
-      # Options:
-      # * :server - Set the server to use
-      def tables(opts={})
-        m = output_identifier_meth
-        metadata_dataset.with_sql('SHOW TABLES').server(opts[:server]).map{|r| m.call(r.values.first)}
+      # MySQL supports CREATE TABLE IF NOT EXISTS syntax.
+      def supports_create_table_if_not_exists?
+        true
       end
       
       # MySQL supports prepared transactions (two-phase commit) using XA
       def supports_prepared_transactions?
-        true
+        server_version >= 50000
       end
 
       # MySQL supports savepoints
       def supports_savepoints?
-        true
+        server_version >= 50000
+      end
+
+      # MySQL doesn't support savepoints inside prepared transactions in from
+      # 5.5.12 to 5.5.23, see http://bugs.mysql.com/bug.php?id=64374
+      def supports_savepoints_in_prepared_transactions?
+        super && (server_version <= 50512 || server_version >= 50523)
       end
 
       # MySQL supports transaction isolation levels
@@ -107,6 +140,14 @@ module Sequel
         true
       end
 
+      # Return an array of symbols specifying table names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use
+      def tables(opts={})
+        full_tables('BASE TABLE', opts)
+      end
+      
       # Changes the database in use by issuing a USE statement.  I would be
       # very careful if I used this.
       def use(db_name)
@@ -116,6 +157,14 @@ module Sequel
         self
       end
       
+      # Return an array of symbols specifying view names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use
+      def views(opts={})
+        full_tables('VIEW', opts)
+      end
+      
       private
       
       # Use MySQL specific syntax for rename column, set column type, and
@@ -126,6 +175,7 @@ module Sequel
           if related = op.delete(:table)
             sql = super(table, op)
             op[:table] = related
+            op[:key] ||= primary_key_from_schema(related)
             [sql, "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])})#{column_references_sql(op)}"]
           else
             super(table, op)
@@ -142,10 +192,47 @@ module Sequel
           "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
         when :drop_index
           "#{drop_index_sql(table, op)} ON #{quote_schema_table(table)}"
+        when :drop_constraint
+          type = case op[:type]
+          when :primary_key
+            return "ALTER TABLE #{quote_schema_table(table)} DROP PRIMARY KEY"
+          when :foreign_key
+            'FOREIGN KEY'
+          when :unique
+            'INDEX'
+          else
+            raise(Error, "must specify constraint type via :type=>(:foreign_key|:primary_key|:unique) when dropping constraints on MySQL")
+          end
+          "ALTER TABLE #{quote_schema_table(table)} DROP #{type} #{quote_identifier(op[:name])}"
+        when :add_constraint
+          if op[:type] == :foreign_key
+            op[:key] ||= primary_key_from_schema(op[:table])
+          end
+          super(table, op)
         else
           super(table, op)
         end
       end
+
+      # The SQL queries to execute on initial connection
+      def mysql_connection_setting_sqls
+        sqls = []
+        
+        # Increase timeout so mysql server doesn't disconnect us
+        # Value used by default is maximum allowed value on Windows.
+        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
+
+        # By default, MySQL 'where id is null' selects the last inserted id
+        sqls <<  "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]
+
+        # If the user has specified one or more sql modes, enable them
+        if sql_mode = opts[:sql_mode]
+          sql_mode = Array(sql_mode).join(',').upcase
+          sqls <<  "SET sql_mode = '#{sql_mode}'"
+        end
+
+        sqls
+      end
       
       # Use MySQL specific AUTO_INCREMENT text.
       def auto_increment_sql
@@ -161,9 +248,9 @@ module Sequel
       # Use XA START to start a new prepared transaction if the :prepare
       # option is given.
       def begin_transaction(conn, opts={})
-        if s = opts[:prepare]
+        if (s = opts[:prepare]) && (th = _trans(conn))[:savepoint_level] == 0
           log_connection_execute(conn, "XA START #{literal(s)}")
-          conn
+          th[:savepoint_level] += 1
         else
           super
         end
@@ -184,7 +271,7 @@ module Sequel
       # Prepare the XA transaction for a two-phase commit if the
       # :prepare option is given.
       def commit_transaction(conn, opts={})
-        if s = opts[:prepare]
+        if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
         else
@@ -197,14 +284,50 @@ module Sequel
         engine = options.fetch(:engine, Sequel::MySQL.default_engine)
         charset = options.fetch(:charset, Sequel::MySQL.default_charset)
         collate = options.fetch(:collate, Sequel::MySQL.default_collate)
+        generator.constraints.sort_by{|c| (c[:type] == :primary_key) ? -1 : 1}
+
+        key_proc = lambda do |t|
+          if t == name 
+            if pk = generator.primary_key_name
+              [pk]
+            elsif !(pkc = generator.constraints.select{|con| con[:type] == :primary_key}).empty?
+              pkc.first[:columns]
+            end
+          else
+            primary_key_from_schema(t)
+          end
+        end
+
+        generator.constraints.each do |c|
+          if c[:type] == :foreign_key
+            c[:key] ||= key_proc.call(c[:table])
+          end
+        end
+
         generator.columns.each do |c|
           if t = c.delete(:table)
-            generator.foreign_key([c[:name]], t, c.merge(:name=>nil, :type=>:foreign_key))
+            same_table = t == name
+            k = c[:key]
+
+            key ||= key_proc.call(t)
+
+            if same_table && !k.nil?
+              generator.constraints.unshift(:type=>:unique, :columns=>Array(k))
+            end
+
+            generator.foreign_key([c[:name]], t, c.merge(:name=>nil, :type=>:foreign_key, :key=>key))
           end
         end
+
         "#{super}#{" ENGINE=#{engine}" if engine}#{" DEFAULT CHARSET=#{charset}" if charset}#{" DEFAULT COLLATE=#{collate}" if collate}"
       end
 
+      # Backbone of the tables and views support using SHOW FULL TABLES.
+      def full_tables(type, opts)
+        m = output_identifier_meth
+        metadata_dataset.with_sql('SHOW FULL TABLES').server(opts[:server]).map{|r| m.call(r.values.first) if r.delete(:Table_type) == type}.compact
+      end
+
       # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
       def identifier_input_method_default
         nil
@@ -230,9 +353,14 @@ module Sequel
         "CREATE #{index_type}INDEX #{index_name}#{using} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}"
       end
       
+      # Parse the schema for the given table to get an array of primary key columns
+      def primary_key_from_schema(table)
+        schema(table).select{|a| a[1][:primary_key]}.map{|a| a[0]}
+      end
+
       # Rollback the currently open XA transaction
       def rollback_transaction(conn, opts={})
-        if s = opts[:prepare]
+        if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
           log_connection_execute(conn, "XA ROLLBACK #{literal(s)}")
@@ -248,9 +376,11 @@ module Sequel
 
       # Use the MySQL specific DESCRIBE syntax to get a table description.
       def schema_parse_table(table_name, opts)
-        m = output_identifier_meth
-        im = input_identifier_meth
-        metadata_dataset.with_sql("DESCRIBE ?", SQL::Identifier.new(im.call(table_name))).map do |row|
+        m = output_identifier_meth(opts[:dataset])
+        im = input_identifier_meth(opts[:dataset])
+        table = SQL::Identifier.new(im.call(table_name))
+        table = SQL::QualifiedIdentifier.new(im.call(opts[:schema]), table) if opts[:schema]
+        metadata_dataset.with_sql("DESCRIBE ?", table).map do |row|
           row[:auto_increment] = true if row.delete(:Extra).to_s =~ /auto_increment/io
           row[:allow_null] = row.delete(:Null) == 'YES'
           row[:default] = row.delete(:Default)
@@ -281,13 +411,17 @@ module Sequel
       # MySQL has both datetime and timestamp classes, most people are going
       # to want datetime
       def type_literal_generic_datetime(column)
-        :datetime
+        if column[:default] == Sequel::CURRENT_TIMESTAMP
+          :timestamp
+        else
+          :datetime
+        end
       end
 
       # MySQL has both datetime and timestamp classes, most people are going
       # to want datetime
       def type_literal_generic_time(column)
-        column[:only_time] ? :time : :datetime
+        column[:only_time] ? :time : type_literal_generic_datetime(column)
       end
 
       # MySQL doesn't have a true boolean class, so it uses tinyint(1)
@@ -303,27 +437,82 @@ 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 ignore table set where order limit')
+      APOS = Dataset::APOS
+      APOS_RE = Dataset::APOS_RE
+      DOUBLE_APOS = Dataset::DOUBLE_APOS
+      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
+      GROUP_BY = Dataset::GROUP_BY
+      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
+      BACKTICK_RE = /`/.freeze
+      DOUBLE_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
+      WITH_ROLLUP = ' WITH ROLLUP'.freeze
+      MATCH_AGAINST = ["(MATCH ".freeze, " AGAINST (".freeze, "))".freeze].freeze
+      MATCH_AGAINST_BOOLEAN = ["(MATCH ".freeze, " AGAINST (".freeze, " IN BOOLEAN MODE))".freeze].freeze
+      EXPLAIN = 'EXPLAIN '.freeze
+      EXPLAIN_EXTENDED = 'EXPLAIN EXTENDED '.freeze
+      BACKSLASH_RE = /\\/.freeze
+      QUAD_BACKSLASH = "\\\\\\\\".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(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
       
@@ -340,6 +529,17 @@ module Sequel
         clone(:calc_found_rows => true)
       end
       
+      # Return the results of an EXPLAIN query as a string. Options:
+      # :extended :: Use EXPLAIN EXPTENDED instead of EXPLAIN if true.
+      def explain(opts={})
+        # Load the PrettyTable class, needed for explain output
+        Sequel.extension(:_pretty_table) unless defined?(Sequel::PrettyTable)
+
+        ds = db.send(:metadata_dataset).with_sql((opts[:extended] ? EXPLAIN_EXTENDED : EXPLAIN) + select_sql).naked
+        rows = ds.all
+        Sequel::PrettyTable.string(rows, ds.columns)
+      end
+
       # Return a cloned dataset which will use LOCK IN SHARE MODE to lock returned rows.
       def for_share
         lock_style(:share)
@@ -351,8 +551,9 @@ module Sequel
       end
       
       # MySQL specific full text search syntax.
-      def full_text_sql(cols, term, opts = {})
-        "MATCH #{literal(Array(cols))} AGAINST (#{literal(Array(term).join(' '))}#{" IN BOOLEAN MODE" if opts[:boolean]})"
+      def full_text_sql(cols, terms, opts = {})
+        terms = terms.join(' ') if terms.is_a?(Array)
+        SQL::PlaceholderLiteralString.new((opts[:boolean] ? MATCH_AGAINST_BOOLEAN : MATCH_AGAINST), [Array(cols), terms])
       end
 
       # MySQL allows HAVING clause on ungrouped datasets.
@@ -372,9 +573,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
       
@@ -389,7 +593,7 @@ module Sequel
       def insert_ignore
         clone(:insert_ignore=>true)
       end
-      
+
       # Sets up the insert methods to use ON DUPLICATE KEY UPDATE
       # If you pass no arguments, ALL fields will be
       # updated with the new values.  If you pass the fields you
@@ -415,25 +619,31 @@ 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)))]
-      end
-      
-      # MySQL uses the number of rows actually modified in the update,
-      # instead of the number of matched by the filter.
-      def provides_accurate_rows_matched?
-        false
+        sql = LiteralString.new('VALUES ')
+        expression_list_append(sql, values.map{|r| Array(r)})
+        [insert_sql(columns, sql)]
       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.gsub(BACKTICK_RE, DOUBLE_BACKTICK) << BACKTICK
       end
       
+      # Execute a REPLACE statement on the database.
+      def replace(*values)
+        execute_insert(replace_sql(*values))
+      end
+
       # MySQL specific syntax for REPLACE (aka UPSERT, or update if exists,
       # insert if it doesn't).
       def replace_sql(*values)
         clone(:replace=>true).insert_sql(*values)
       end
+
+      # Replace multiple rows in a single query.
+      def multi_replace(*values)
+        clone(:replace=>true).multi_insert(*values)
+      end
       
       # MySQL can emulate DISTINCT ON with its non-standard GROUP BY implementation,
       # though the rows returned cannot be made deterministic through ordering.
@@ -441,6 +651,11 @@ module Sequel
         true
       end
 
+      # MySQL supports GROUP BY WITH ROLLUP (but not CUBE)
+      def supports_group_rollup?
+        true
+      end
+
       # MySQL does not support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
@@ -451,6 +666,12 @@ module Sequel
         true
       end
 
+      # MySQL's DISTINCT ON emulation using GROUP BY does not respect the
+      # queries ORDER BY clause.
+      def supports_ordered_distinct_on?
+        false
+      end
+    
       # MySQL does support fractional timestamps in literal timestamps, but it
       # ignores them.  Also, using them seems to cause problems on 1.9.  Since
       # they are ignored anyway, not using them is probably best.
@@ -458,13 +679,16 @@ 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
+      # Sets up the update methods to use UPDATE IGNORE.
+      # Useful if you have a unique key and want to just skip
+      # updating rows that violate the unique key restriction.
+      #
+      #   dataset.update_ignore.update({:name => 'a', :value => 1})
+      #   # UPDATE IGNORE tablename SET name = 'a', value = 1
+      def update_ignore
+        clone(:update_ignore=>true)
       end
-
+      
       private
 
       # MySQL supports the ORDER BY and LIMIT clauses for DELETE statements
@@ -476,7 +700,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
@@ -493,7 +720,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
@@ -501,19 +728,62 @@ 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
+
+      # MySQL supports UPDATE IGNORE
+      def update_ignore_sql(sql)
+        sql << IGNORE if opts[:update_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
@@ -521,7 +791,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
@@ -531,30 +804,16 @@ module Sequel
         BOOL_FALSE
       end
 
+      # SQL fragment for String.  Doubles \ and ' by default.
+      def literal_string_append(sql, v)
+        sql << APOS << v.gsub(BACKSLASH_RE, QUAD_BACKSLASH).gsub(APOS_RE, DOUBLE_APOS) << APOS
+      end
+
       # Use 1 for true on MySQL
       def literal_true
         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
@@ -574,6 +833,11 @@ module Sequel
       def update_clause_methods
         UPDATE_CLAUSE_METHODS
       end
+
+      # MySQL uses WITH ROLLUP syntax.
+      def uses_with_rollup?
+        true
+      end
     end
   end
 end