sequel 3.21.0 → 3.39.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,8 +31,9 @@ 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_TIMESTAMP_RE = /\ACURRENT_(?:DATE|TIMESTAMP)?\z/
       
       # MySQL's cast rules are restrictive in that you can't just cast to any possible
       # database type.
@@ -50,6 +52,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.
       #
@@ -79,27 +111,31 @@ module Sequel
 
       # Get version of MySQL server, used for determined capabilities.
       def server_version
-        m = /(\d+)\.(\d+)\.(\d+)/.match(get(SQL::Function.new(:version)))
-        @server_version ||= (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
+        @server_version ||= begin
+          m = /(\d+)\.(\d+)\.(\d+)/.match(get(SQL::Function.new(:version)))
+          (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
+        end
       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 +143,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,19 +160,60 @@ 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
-      # drop index cases.
-      def alter_table_sql(table, op)
+      # Preprocess the array of operations.  If it looks like some operations depend
+      # on results of earlier operations and may require reloading the schema to
+      # work correctly, split those operations into separate lists, and between each
+      # list, remove the cached schema so that the later operations deal with the
+      # then current table schema.
+      def apply_alter_table(name, ops)
+        modified_columns = []
+        op_groups = [[]]
+        ops.each do |op|
+          case op[:op]
+          when :add_column, :set_column_type, :set_column_null, :set_column_default
+            if modified_columns.include?(op[:name])
+              op_groups << []
+            else
+              modified_columns << op[:name]
+            end
+          when :rename_column
+            if modified_columns.include?(op[:name]) || modified_columns.include?(op[:new_name])
+              op_groups << []
+            end
+            modified_columns << op[:name] unless modified_columns.include?(op[:name])
+            modified_columns << op[:new_name] unless modified_columns.include?(op[:new_name])
+          end
+          op_groups.last << op
+        end
+
+        op_groups.each do |ops|
+          next if ops.empty?
+          alter_table_sql_list(name, ops).each{|sql| execute_ddl(sql)}
+          remove_cached_schema(name)
+        end
+      end
+    
+      # Use MySQL specific syntax for some alter table operations.
+      def alter_table_op_sql(table, op)
         case op[:op]
         when :add_column
           if related = op.delete(:table)
-            sql = super(table, op)
+            sql = super
             op[:table] = related
-            [sql, "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])})#{column_references_sql(op)}"]
+            op[:key] ||= primary_key_from_schema(related)
+            sql << ", ADD FOREIGN KEY (#{quote_identifier(op[:name])})#{column_references_sql(op)}"
           else
-            super(table, op)
+            super
           end
         when :rename_column, :set_column_type, :set_column_null, :set_column_default
           o = op[:op]
@@ -139,13 +224,71 @@ module Sequel
           opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
           opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
           opts.delete(:default) if opts[:default] == nil
-          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
+          "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
+        when :drop_constraint
+          type = case op[:type]
+          when :primary_key
+            "DROP PRIMARY KEY"
+          when :foreign_key
+            "DROP FOREIGN KEY #{quote_identifier(op[:name])}"
+          when :unique
+            "DROP INDEX #{quote_identifier(op[:name])}"
+          end
+        when :add_constraint
+          if op[:type] == :foreign_key
+            op[:key] ||= primary_key_from_schema(op[:table])
+          end
+          super
+        else
+          super
+        end
+      end
+
+      # MySQL server requires table names when dropping indexes.
+      def alter_table_sql(table, op)
+        case op[:op]
         when :drop_index
           "#{drop_index_sql(table, op)} ON #{quote_schema_table(table)}"
         else
-          super(table, op)
+          super
         end
       end
+
+      # Handle MySQL specific default format.
+      def column_schema_normalize_default(default, type)
+        if column_schema_default_string_type?(type)
+          return if [:date, :datetime, :time].include?(type) && MYSQL_TIMESTAMP_RE.match(default)
+          default = "'#{default.gsub("'", "''").gsub('\\', '\\\\')}'"
+        end
+        super(default, type)
+      end
+
+      # Don't allow combining adding foreign key operations with other
+      # operations, since in some cases adding a foreign key constraint in
+      # the same query as other operations results in MySQL error 150.
+      def combinable_alter_table_op?(op)
+        super && !(op[:op] == :add_constraint && op[:type] == :foreign_key)
+      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 +304,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 +327,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 +340,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 +409,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)}")
@@ -241,16 +425,23 @@ module Sequel
         end
       end
 
-      # MySQL treats integer primary keys as autoincrementing.
-      def schema_autoincrementing_primary_key?(schema)
-        super and schema[:db_type] =~ /int/io
+      # Recognize MySQL set type.
+      def schema_column_type(db_type)
+        case db_type
+        when /\Aset/io
+          :set
+        else
+          super
+        end
       end
 
       # 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)
@@ -262,6 +453,11 @@ module Sequel
         end
       end
 
+      # MySQL can combine multiple alter table ops into a single query.
+      def supports_combining_alter_table_ops?
+        true
+      end
+
       # Respect the :size option if given to produce
       # tinyblob, mediumblob, and longblob if :tiny,
       # :medium, or :long is given.
@@ -281,13 +477,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 +503,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 +595,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 +617,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 +639,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 +659,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 +685,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 +717,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 +732,17 @@ 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 supports pattern matching via regular expressions
+      def supports_regexp?
+        true
+      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 +750,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 +771,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 +791,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 +799,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 +862,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 +875,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 +904,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