Merge dl145h.mysql.com:/data0/mkindahl/mysql-5.1-rpl-merge

into  dl145h.mysql.com:/data0/mkindahl/mysql-5.1-new-rpl

mysql-test/Makefile.am

@@ -44,7 +44,8 @@ dist-hook:
 		$(distdir)/std_data/ndb_backup51 \
 		$(distdir)/std_data/ndb_backup51_data_be \
 		$(distdir)/std_data/ndb_backup51_data_le \
-		$(distdir)/lib
+		$(distdir)/lib \
+		$(distdir)/lib/My
 	-$(INSTALL_DATA) $(srcdir)/t/*.def $(distdir)/t
 	$(INSTALL_DATA) $(srcdir)/t/*.test $(distdir)/t
 	-$(INSTALL_DATA) $(srcdir)/t/*.imtest $(distdir)/t
@@ -57,6 +58,7 @@ dist-hook:
 	-$(INSTALL_DATA) $(srcdir)/extra/binlog_tests/*.opt $(distdir)/extra/binlog_tests
 	-$(INSTALL_DATA) $(srcdir)/extra/rpl_tests/*.opt $(distdir)/extra/rpl_tests
 	$(INSTALL_DATA) $(srcdir)/include/*.inc $(distdir)/include
+	$(INSTALL_DATA) $(srcdir)/include/*.sql $(distdir)/include
 	$(INSTALL_DATA) $(srcdir)/include/*.test $(distdir)/include
 	$(INSTALL_DATA) $(srcdir)/r/*.result $(srcdir)/r/*.require $(distdir)/r
 	$(INSTALL_DATA) $(srcdir)/std_data/Moscow_leap $(distdir)/std_data
@@ -72,6 +74,7 @@ dist-hook:
 	$(INSTALL_DATA) $(srcdir)/std_data/ndb_backup51_data_be/BACKUP* $(distdir)/std_data/ndb_backup51_data_be
 	$(INSTALL_DATA) $(srcdir)/std_data/ndb_backup51_data_le/BACKUP* $(distdir)/std_data/ndb_backup51_data_le
 	$(INSTALL_DATA) $(srcdir)/lib/*.pl $(distdir)/lib
+	$(INSTALL_DATA) $(srcdir)/lib/My/*.pm $(distdir)/lib/My
 	-rm -rf `find $(distdir)/suite -type d -name SCCS` $(distdir)/suite/row_lock
 
 install-data-local:
@@ -86,7 +89,8 @@ install-data-local:
 		$(DESTDIR)$(testdir)/std_data/ndb_backup51 \
 		$(DESTDIR)$(testdir)/std_data/ndb_backup51_data_be \
 		$(DESTDIR)$(testdir)/std_data/ndb_backup51_data_le \
-		$(DESTDIR)$(testdir)/lib
+		$(DESTDIR)$(testdir)/lib \
+		$(DESTDIR)$(testdir)/lib/My
 	$(INSTALL_DATA) $(srcdir)/README $(DESTDIR)$(testdir)
 	-$(INSTALL_DATA) $(srcdir)/t/*.def $(DESTDIR)$(testdir)/t
 	$(INSTALL_DATA) $(srcdir)/t/*.test $(DESTDIR)$(testdir)/t
@@ -103,6 +107,7 @@ install-data-local:
 	-$(INSTALL_DATA) $(srcdir)/extra/binlog_tests/*.opt $(DESTDIR)$(testdir)/extra/binlog_tests
 	-$(INSTALL_DATA) $(srcdir)/extra/rpl_tests/*.opt $(DESTDIR)$(testdir)/extra/rpl_tests
 	$(INSTALL_DATA) $(srcdir)/include/*.inc $(DESTDIR)$(testdir)/include
+	$(INSTALL_DATA) $(srcdir)/include/*.sql $(DESTDIR)$(testdir)/include
 	$(INSTALL_DATA) $(srcdir)/include/*.test $(DESTDIR)$(testdir)/include
 	$(INSTALL_DATA) $(srcdir)/std_data/*.dat $(DESTDIR)$(testdir)/std_data
 	$(INSTALL_DATA) $(srcdir)/std_data/*.*001 $(DESTDIR)$(testdir)/std_data
@@ -119,6 +124,7 @@ install-data-local:
 	$(INSTALL_DATA) $(srcdir)/std_data/ndb_backup51_data_be/BACKUP* $(DESTDIR)$(testdir)/std_data/ndb_backup51_data_be
 	$(INSTALL_DATA) $(srcdir)/std_data/ndb_backup51_data_le/BACKUP* $(DESTDIR)$(testdir)/std_data/ndb_backup51_data_le
 	$(INSTALL_DATA) $(srcdir)/lib/*.pl $(DESTDIR)$(testdir)/lib
+	$(INSTALL_DATA) $(srcdir)/lib/My/*.pm $(DESTDIR)$(testdir)/lib/My
 	for f in `(cd $(srcdir); find suite -type f | egrep -v 'SCCS|row_lock')`; \
 	do \
 	  d=$(DESTDIR)$(testdir)/`dirname $$f`; \

mysql-test/include/have_binlog_format_row_or_statement.inc

@@ -0,0 +1,7 @@
+--source include/have_log_bin.inc
+
+-- require r/have_binlog_format_statement.require
+--disable_query_log
+--replace_result ROW STATEMENT
+show variables like "binlog_format";
+--enable_query_log

mysql-test/include/set_binlog_format_mixed.sql

@@ -0,0 +1,2 @@
+SET GLOBAL BINLOG_FORMAT=MIXED;
+SET SESSION BINLOG_FORMAT=MIXED;

mysql-test/include/set_binlog_format_row.sql

@@ -0,0 +1,2 @@
+SET GLOBAL BINLOG_FORMAT=ROW;
+SET SESSION BINLOG_FORMAT=ROW;

mysql-test/include/set_binlog_format_statement.sql

@@ -0,0 +1,2 @@
+SET GLOBAL BINLOG_FORMAT=STATEMENT;
+SET SESSION BINLOG_FORMAT=STATEMENT;

mysql-test/lib/My/Config.pm

@@ -0,0 +1,422 @@
+# -*- cperl -*-
+
+package My::Config::Option;
+
+use strict;
+use warnings;
+
+
+sub new {
+  my ($class, $option_name, $option_value)= @_;
+  my $self= bless { name => $option_name,
+		    value => $option_value
+		  }, $class;
+  return $self;
+}
+
+
+sub name {
+  my ($self)= @_;
+  return $self->{name};
+}
+
+
+sub value {
+  my ($self)= @_;
+  return $self->{value};
+}
+
+
+package My::Config::Group;
+
+use strict;
+use warnings;
+
+
+sub new {
+  my ($class, $group_name)= @_;
+  my $self= bless { name => $group_name,
+		    options => [],
+		    options_by_name => {},
+		  }, $class;
+  return $self;
+}
+
+
+sub insert {
+  my ($self, $option_name, $value, $if_not_exist)= @_;
+  my $option= $self->option($option_name);
+  if (defined($option) and !$if_not_exist) {
+    $option->{value}= $value;
+  }
+  else {
+    my $option= My::Config::Option->new($option_name, $value);
+    # Insert option in list
+    push(@{$self->{options}}, $option);
+    # Insert option in hash
+    $self->{options_by_name}->{$option_name}= $option;
+  }
+  return $option;
+}
+
+sub remove {
+  my ($self, $option_name)= @_;
+
+  # Check that option exists
+  my $option= $self->option($option_name);
+
+  return undef unless defined $option;
+
+  # Remove from the hash
+  delete($self->{options_by_name}->{$option_name}) or die;
+
+  # Remove from the array
+  @{$self->{options}}= grep { $_->name ne $option_name } @{$self->{options}};
+
+  return $option;
+}
+
+
+sub options {
+  my ($self)= @_;
+  return @{$self->{options}};
+}
+
+
+sub name {
+  my ($self)= @_;
+  return $self->{name};
+}
+
+
+#
+# Return a specific option in the group
+#
+sub option {
+  my ($self, $option_name)= @_;
+
+  return $self->{options_by_name}->{$option_name};
+}
+
+
+#
+# Return a specific value for an option in the group
+#
+sub value {
+  my ($self, $option_name)= @_;
+  my $option= $self->option($option_name);
+
+  die "No option named '$option_name' in this group"
+    if ! defined($option);
+
+  return $option->value();
+}
+
+
+package My::Config;
+
+use strict;
+use warnings;
+use IO::File;
+use File::Basename;
+
+#
+# Constructor for My::Config
+# - represents a my.cnf config file
+#
+# Array of arrays
+#
+sub new {
+  my ($class, $path)= @_;
+  my $group_name= undef;
+
+  my $self= bless { groups => [] }, $class;
+  my $F= IO::File->new($path, "<")
+    or die "Could not open '$path': $!";
+
+  while (  my $line= <$F> ) {
+    chomp($line);
+
+    # [group]
+    if ( $line =~ /\[(.*)\]/ ) {
+      # New group found
+      $group_name= $1;
+      #print "group: $group_name\n";
+
+      $self->insert($group_name, undef, undef);
+    }
+
+    # Magic #! comments
+    elsif ( $line =~ /^#\!/) {
+      my $magic= $line;
+      die "Found magic comment '$magic' outside of group"
+	unless $group_name;
+
+      #print "$magic\n";
+      $self->insert($group_name, $magic, undef);
+    }
+
+    # Comments
+    elsif ( $line =~ /^#/ || $line =~ /^;/) {
+      # Skip comment
+      next;
+    }
+
+    # Empty lines
+    elsif ( $line =~ /^$/ ) {
+      # Skip empty lines
+      next;
+    }
+
+    # !include <filename>
+    elsif ( $line =~ /^\!include\s*(.*?)\s*$/ ) {
+      my $include_file_name= dirname($path)."/".$1;
+      # Check that the file exists
+      die "The include file '$include_file_name' does not exist"
+	unless -f $include_file_name;
+
+      $self->append(My::Config->new($include_file_name));
+    }
+
+    # <option>
+    elsif ( $line =~ /^([\@\w-]+)\s*$/ ) {
+      my $option= $1;
+
+      die "Found option '$option' outside of group"
+	unless $group_name;
+
+      #print "$option\n";
+      $self->insert($group_name, $option, undef);
+    }
+
+    # <option>=<value>
+    elsif ( $line =~ /^([\@\w-]+)\s*=\s*(.*?)\s*$/ ) {
+      my $option= $1;
+      my $value= $2;
+
+      die "Found option '$option=$value' outside of group"
+	unless $group_name;
+
+      #print "$option=$value\n";
+      $self->insert($group_name, $option, $value);
+    } else {
+      die "Unexpected line '$line' found in '$path'";
+    }
+
+  }
+  undef $F;			# Close the file
+
+  return $self;
+}
+
+#
+# Insert a new group if it does not already exist
+# and add option if defined
+#
+sub insert {
+  my ($self, $group_name, $option, $value, $if_not_exist)= @_;
+  my $group;
+
+  # Create empty array for the group if it doesn't exist
+  if ( !$self->group_exists($group_name) ) {
+    $group= $self->_group_insert($group_name);
+  }
+  else {
+    $group= $self->group($group_name);
+  }
+
+  if ( defined $option ) {
+    #print "option: $option, value: $value\n";
+
+    # Add the option to the group
+    $group->insert($option, $value, $if_not_exist);
+  }
+}
+
+#
+# Remove a option, given group and option name
+#
+sub remove {
+  my ($self, $group_name, $option_name)= @_;
+  my $group= $self->group($group_name);
+
+  die "group '$group_name' does not exist"
+    unless defined($group);
+
+  $group->remove($option_name) or
+    die "option '$option_name' does not exist";
+}
+
+
+
+#
+# Check if group with given name exists in config
+#
+sub group_exists {
+  my ($self, $group_name)= @_;
+
+  foreach my $group ($self->groups()) {
+    return 1 if $group->{name} eq $group_name;
+  }
+  return 0;
+}
+
+
+#
+# Insert a new group into config
+#
+sub _group_insert {
+  my ($self, $group_name)= @_;
+  caller eq __PACKAGE__ or die;
+
+  # Check that group does not already exist
+  die "Group already exists" if $self->group_exists($group_name);
+
+  my $group= My::Config::Group->new($group_name);
+  push(@{$self->{groups}}, $group);
+  return $group;
+}
+
+
+#
+# Append a configuration to current config
+#
+sub append {
+  my ($self, $from)= @_;
+
+  foreach my $group ($from->groups()) {
+    foreach my $option ($group->options()) {
+      $self->insert($group->name(), $option->name(), $option->value());
+    }
+
+  }
+}
+
+
+#
+# Return a list with all the groups in config
+#
+sub groups {
+  my ($self)= @_;
+  return ( @{$self->{groups}} );
+}
+
+
+#
+# Return a list of all the groups in config
+# starting with the given string
+#
+sub like {
+  my ($self, $prefix)= @_;
+  return ( grep ( $_->{name} =~ /^$prefix/, $self->groups()) );
+}
+
+
+#
+# Return the first group in config
+# starting with the given string
+#
+sub first_like {
+  my ($self, $prefix)= @_;
+  return ($self->like($prefix))[0];
+}
+
+
+#
+# Return a specific group in the config
+#
+sub group {
+  my ($self, $group_name)= @_;
+
+  foreach my $group ( $self->groups() ) {
+    return $group if $group->{name} eq $group_name;
+  }
+  return undef;
+}
+
+
+#
+# Return a list of all options in a specific group in the config
+#
+sub options_in_group {
+  my ($self, $group_name)= @_;
+
+  my $group= $self->group($group_name);
+  return () unless defined $group;
+  return $group->options();
+}
+
+
+#
+# Return a value given group and option name
+#
+sub value {
+  my ($self, $group_name, $option_name)= @_;
+  my $group= $self->group($group_name);
+
+  die "group '$group_name' does not exist"
+    unless defined($group);
+
+  my $option= $group->option($option_name);
+  die "option '$option_name' does not exist"
+    unless defined($option);
+
+  return $option->value();
+}
+
+
+#
+# Check if an option exists
+#
+sub exists {
+  my ($self, $group_name, $option_name)= @_;
+  my $group= $self->group($group_name);
+
+  die "group '$group_name' does not exist"
+    unless defined($group);
+
+  my $option= $group->option($option_name);
+  return defined($option);
+}
+
+
+# Overload "to string"-operator with 'stringify'
+use overload
+    '""' => \&stringify;
+
+#
+# Return the config as a string in my.cnf file format
+#
+sub stringify {
+  my ($self)= @_;
+  my $res;
+
+  foreach my $group ($self->groups()) {
+    $res .= "[$group->{name}]\n";
+
+    foreach my $option ($group->options()) {
+      $res .= $option->name();
+      my $value= $option->value();
+      if (defined $value) {
+	$res .= "=$value";
+      }
+      $res .= "\n";
+    }
+    $res .= "\n";
+  }
+  return $res;
+}
+
+
+#
+# Save the config to named file
+#
+sub save {
+    my ($self, $path)= @_;
+    my $F= IO::File->new($path, ">")
+	or die "Could not open '$path': $!";
+    print $F $self;
+    undef $F; # Close the file
+}
+
+1;

mysql-test/lib/mtr_cases.pl

@@ -22,8 +22,10 @@ use File::Basename;
 use IO::File();
 use strict;
 
+use My::Config;
+
 sub collect_test_cases ($);
-sub collect_one_suite ($$);
+sub collect_one_suite ($);
 sub collect_one_test_case ($$$$$$$$$);
 
 sub mtr_options_from_test_file($$);
@@ -63,7 +65,7 @@ sub collect_test_cases ($) {
 
   foreach my $suite (split(",", $suites))
   {
-    collect_one_suite($suite, $cases);
+    push(@$cases, collect_one_suite($suite));
   }
 
 
@@ -207,51 +209,24 @@ sub split_testname {
 }
 
 
-sub collect_one_suite($$)
+sub collect_one_suite($)
 {
   my $suite= shift;  # Test suite name
-  my $cases= shift;  # List of test cases
+  my @cases;  # Array of hash
 
   mtr_verbose("Collecting: $suite");
 
-  my $combination_file=  "combinations";
-  my $combinations = [];
-
   my $suitedir= "$::glob_mysql_test_dir"; # Default
-  my $combination_file= "$::glob_mysql_test_dir/$combination_file";
   if ( $suite ne "main" )
   {
     $suitedir= mtr_path_exists("$suitedir/suite/$suite",
 			       "$suitedir/$suite");
     mtr_verbose("suitedir: $suitedir");
-    $combination_file= "$suitedir/$combination_file";
   }
 
   my $testdir= "$suitedir/t";
   my $resdir=  "$suitedir/r";
 
-  if (!@::opt_combination) 
-  {
-    # Read combinations file
-    if ( open(COMB,$combination_file) )
-    {
-      while (<COMB>)
-      {
-        chomp;
-        s/\ +/ /g;
-        push (@$combinations, $_) unless ($_ eq '');
-      }
-      close COMB;
-    }
-  }
-  else
-  {
-    # take the combination from command-line
-    @$combinations = @::opt_combination;
-  }
-  # Remember last element position
-  my $begin_index = $#{@$cases} + 1;
-
   # ----------------------------------------------------------------------
   # Build a hash of disabled testcases for this suite
   # ----------------------------------------------------------------------
@@ -326,7 +301,7 @@ sub collect_one_suite($$)
       }
 
       collect_one_test_case($testdir,$resdir,$suite,$tname,
-                            "$tname.$extension",$cases,\%disabled,
+                            "$tname.$extension",\@cases,\%disabled,
 			    $component_id,$suite_opts);
     }
   }
@@ -356,14 +331,19 @@ sub collect_one_suite($$)
       next if ($do_test and not $tname =~ /$do_test/o);
 
       collect_one_test_case($testdir,$resdir,$suite,$tname,
-                            $elem,$cases,\%disabled,$component_id,
+                            $elem,\@cases,\%disabled,$component_id,
 			    $suite_opts);
     }
     closedir TESTDIR;
   }
 
+
+  #  Return empty list if no testcases found
+  return if (@cases == 0);
+
   # ----------------------------------------------------------------------
-  # Proccess combinations only if new tests were added
+  # Read combinations for this suite and build testcases x combinations
+  # if any combinations exists
   # ----------------------------------------------------------------------
   if (0 and $combinations && $begin_index <= $#{@$cases}) 
   { 
@@ -434,7 +414,84 @@ sub collect_one_suite($$)
     }    
   }
 
-  return $cases;
+  optimize_cases(\@cases);
+  #print_testcases(@cases);
+
+  return @cases;
+}
+
+
+#
+# Loop through all test cases
+# - optimize which test to run by skipping unnecessary ones
+# - update settings if necessary
+#
+sub optimize_cases {
+  my ($cases)= @_;
+
+  foreach my $tinfo ( @$cases )
+  {
+    # Skip processing if already marked as skipped
+    next if $tinfo->{skip};
+
+    # Replication test needs an adjustment of binlog format
+    if (mtr_match_prefix($tinfo->{'name'}, "rpl"))
+    {
+
+      # =======================================================
+      # Get binlog-format used by this test from master_opt
+      # =======================================================
+      my $test_binlog_format;
+      foreach my $opt ( @{$tinfo->{master_opt}} ) {
+	$test_binlog_format= $test_binlog_format ||
+	  mtr_match_prefix($opt, "--binlog-format=");
+      }
+      # print $tinfo->{name}." uses ".$test_binlog_format."\n";
+
+      # =======================================================
+      # If a special binlog format was selected with
+      # --mysqld=--binlog-format=x, skip all test with different
+      # binlog-format
+      # =======================================================
+      if (defined $::used_binlog_format and
+	  $test_binlog_format and
+	  $::used_binlog_format ne $test_binlog_format)
+      {
+	$tinfo->{'skip'}= 1;
+	$tinfo->{'comment'}= "Requires --binlog-format='$test_binlog_format'";
+	next;
+      }
+
+      # =======================================================
+      # Check that testcase supports the designated binlog-format
+      # =======================================================
+      if ($test_binlog_format and defined $tinfo->{'sup_binlog_formats'} )
+      {
+	my $supported=
+	  grep { $_ eq $test_binlog_format } @{$tinfo->{'sup_binlog_formats'}};
+	if ( !$supported )
+	{
+	  $tinfo->{'skip'}= 1;
+	  $tinfo->{'comment'}=
+	    "Doesn't support --binlog-format='$test_binlog_format'";
+	  next;
+	}
+      }
+
+      # =======================================================
+      # Use dynamic switching of binlog-format if mtr started
+      # w/o --mysqld=--binlog-format=xxx and combinations.
+      # =======================================================
+      if (!defined $tinfo->{'combination'} and
+          !defined $::used_binlog_format)
+      {
+        $test_binlog_format= $tinfo->{'sup_binlog_formats'}->[0];
+      }
+
+      # Save binlog format for dynamic switching
+      $tinfo->{binlog_format}= $test_binlog_format;
+    }
+  }
 }
 
 
@@ -524,6 +581,7 @@ sub collect_one_test_case($$$$$$$$$) {
   $tinfo->{'slave_opt'}=  [];
   $tinfo->{'slave_mi'}=   [];
 
+
   # Add suite opts
   foreach my $opt ( @$suite_opts )
   {
@@ -737,14 +795,6 @@ sub collect_one_test_case($$$$$$$$$) {
       return;
     }
 
-    if ( defined $tinfo->{'binlog_format'} and
-	 ! ( $tinfo->{'binlog_format'} eq $::used_binlog_format ) )
-    {
-      $tinfo->{'skip'}= 1;
-      $tinfo->{'comment'}= "Requiring binlog format '$tinfo->{'binlog_format'}'";
-      return;
-    }
-
     if ( $tinfo->{'need_debug'} && ! $::debug_compiled_binaries )
     {
       $tinfo->{'skip'}= 1;
@@ -824,10 +874,17 @@ sub collect_one_test_case($$$$$$$$$) {
 our @tags=
 (
  ["include/have_innodb.inc", "innodb_test", 1],
- ["include/have_binlog_format_row.inc", "binlog_format", "row"],
+ ["include/have_binlog_format_row.inc", "sup_binlog_formats", ["row"]],
  ["include/have_log_bin.inc", "need_binlog", 1],
- ["include/have_binlog_format_statement.inc", "binlog_format", "statement"],
+ ["include/have_binlog_format_statement.inc",
- ["include/have_binlog_format_mixed.inc", "binlog_format", "mixed"],
+  "sup_binlog_formats", ["statement"]],
+ ["include/have_binlog_format_mixed.inc", "sup_binlog_formats", ["mixed"]],
+ ["include/have_binlog_format_mixed_or_row.inc",
+  "sup_binlog_formats", ["mixed","row"]],
+ ["include/have_binlog_format_mixed_or_statement.inc",
+  "sup_binlog_formats", ["mixed","statement"]],
+ ["include/have_binlog_format_row_or_statement.inc",
+  "sup_binlog_formats", ["row","statement"]],
  ["include/big_test.inc", "big_test", 1],
  ["include/have_debug.inc", "need_debug", 1],
  ["include/have_ndb.inc", "ndb_test", 1],
@@ -853,8 +910,8 @@ sub mtr_options_from_test_file($$) {
     {
       if ( index($line, $tag->[0]) >= 0 )
       {
-	# Tag matched, assign value to "tinfo"
+    	  # Tag matched, assign value to "tinfo"
-	$tinfo->{"$tag->[1]"}= $tag->[2];
+        $tinfo->{"$tag->[1]"}= $tag->[2];
       }
     }
 
@@ -875,8 +932,29 @@ sub mtr_options_from_test_file($$) {
 	mtr_options_from_test_file($tinfo, $sourced_file);
       }
     }
-
   }
 }
 
+
+sub print_testcases {
+  my (@cases)= @_;
+
+  print "=" x 60, "\n";
+  foreach my $test (@cases){
+    print "[", $test->{name}, "]", "\n";
+    while ((my ($key, $value)) = each(%$test)) {
+      print " ", $key, "=";
+      if (ref $value eq "ARRAY") {
+	print join(", ", @$value);
+      } else {
+	print $value;
+      }
+      print "\n";
+    }
+    print "\n";
+  }
+  print "=" x 60, "\n";
+}
+
+
 1;

mysql-test/lib/mtr_misc.pl

@@ -280,4 +280,33 @@ sub mtr_cmp_opts ($$) {
   return 0;                             # They are the same
 }
 
+#
+# Compare two arrays and put all unequal elements into a new one
+#
+sub mtr_diff_opts ($$) {
+  my $l1= shift;
+  my $l2= shift;
+  my $f;
+  my $l= [];
+  foreach my $e1 (@$l1) 
+  {    
+    $f= undef;
+    foreach my $e2 (@$l2) 
+    {
+      $f= 1 unless ($e1 ne $e2);
+    }
+    push(@$l, $e1) unless (defined $f);
+  }
+  foreach my $e2 (@$l2) 
+  {
+    $f= undef;
+    foreach my $e1 (@$l1) 
+    {
+      $f= 1 unless ($e1 ne $e2);
+    }
+    push(@$l, $e2) unless (defined $f);
+  }
+  return $l;
+}
+
 1;

mysql-test/lib/mtr_report.pl

@@ -50,9 +50,13 @@ my $tot_real_time= 0;
 
 sub mtr_report_test_name ($) {
   my $tinfo= shift;
+  my $tname= $tinfo->{name};
 
-  _mtr_log("$tinfo->{name}");
+  $tname.= " '$tinfo->{combination}'"
-  printf "%-30s ", $tinfo->{'name'};
+    if defined $tinfo->{combination};
+
+  _mtr_log($tname);
+  printf "%-30s ", $tname;
 }
 
 sub mtr_report_test_skipped ($) {

mysql-test/mysql-test-run.pl

@@ -52,6 +52,9 @@
 # "perl -d:Trace mysql-test-run.pl"
 #
 
+
+use lib "lib/";
+
 $Devel::Trace::TRACE= 0;       # Don't trace boring init stuff
 
 #require 5.6.1;
@@ -164,7 +167,8 @@ our $opt_bench= 0;
 our $opt_small_bench= 0;
 our $opt_big_test= 0;
 
-our @opt_combination;
+our @opt_combinations;
+our $opt_skip_combination;
 
 our @opt_extra_mysqld_opt;
 
@@ -531,7 +535,8 @@ sub command_line_setup () {
              'skip-im'                  => \$opt_skip_im,
              'skip-test=s'              => \$opt_skip_test,
              'big-test'                 => \$opt_big_test,
-             'combination=s'            => \@opt_combination,
+             'combination=s'            => \@opt_combinations,
+             'skip-combination'         => \$opt_skip_combination,
 
              # Specify ports
              'master_port=i'            => \$opt_master_myport,
@@ -792,20 +797,23 @@ sub command_line_setup () {
   # --------------------------------------------------------------------------
   # Find out type of logging that are being used
   # --------------------------------------------------------------------------
-  # NOTE if the default binlog format is changed, this has to be changed
-  $used_binlog_format= "statement";
   if (!$opt_extern && $mysql_version_id >= 50100 )
   {
-    $used_binlog_format= "mixed"; # Default value for binlog format
-
     foreach my $arg ( @opt_extra_mysqld_opt )
     {
       if ( $arg =~ /binlog[-_]format=(\S+)/ )
       {
-	$used_binlog_format= $1;
+      	$used_binlog_format= $1;
       }
     }
-    mtr_report("Using binlog format '$used_binlog_format'");
+    if (defined $used_binlog_format) 
+    {
+      mtr_report("Using binlog format '$used_binlog_format'");
+    }
+    else
+    {
+      mtr_report("Using dynamic switching of binlog format");
+    }
   }
 
 
@@ -923,6 +931,10 @@ sub command_line_setup () {
     mtr_error("Will not run in record mode without a specific test case");
   }
 
+  if ( $opt_record )
+  {
+    $opt_skip_combination = 1;
+  }
 
   # --------------------------------------------------------------------------
   # ps protcol flag
@@ -3304,6 +3316,7 @@ sub run_testcase_check_skip_test($)
 sub do_before_run_mysqltest($)
 {
   my $tinfo= shift;
+  my $args;
 
   # Remove old files produced by mysqltest
   my $base_file= mtr_match_extension($tinfo->{'result_file'},
@@ -3324,6 +3337,28 @@ sub do_before_run_mysqltest($)
       # if script decided to run mysqltest cluster _is_ installed ok
       $ENV{'NDB_STATUS_OK'} = "YES";
     }
+    if (defined $tinfo->{binlog_format} and  $mysql_version_id > 50100 )
+    {
+      # Dynamically switch binlog format of
+      # master, slave is always restarted
+      foreach my $server ( @$master )
+      {
+        next unless ($server->{'pid'});
+
+	mtr_init_args(\$args);
+	mtr_add_arg($args, "--no-defaults");
+	mtr_add_arg($args, "--user=root");
+	mtr_add_arg($args, "--port=$server->{'port'}");
+	mtr_add_arg($args, "--socket=$server->{'path_sock'}");
+
+	my $sql= "include/set_binlog_format_".$tinfo->{binlog_format}.".sql";
+	mtr_verbose("Setting binlog format:", $tinfo->{binlog_format});
+	if (mtr_run($exe_mysql, $args, $sql, "", "", "") != 0)
+	{
+	  mtr_error("Failed to switch binlog format");
+	}
+      }
+    }
   }
 }
 
@@ -3755,12 +3790,11 @@ sub mysqld_arguments ($$$$) {
   mtr_add_arg($args, "%s--connect-timeout=60", $prefix);
 
   # When mysqld is run by a root user(euid is 0), it will fail
-  # to start unless we specify what user to run as. If not running
+  # to start unless we specify what user to run as, see BUG#30630
-  # as root it will be ignored, see BUG#30630
   my $euid= $>;
   if (!$glob_win32 and $euid == 0 and
-      grep(/^--user/, @$extra_opt, @opt_extra_mysqld_opt) == 0) {
+      (grep(/^--user/, @$extra_opt, @opt_extra_mysqld_opt)) == 0) {
-    mtr_add_arg($args, "%s--user=root");
+    mtr_add_arg($args, "%s--user=root", $prefix);
   }
 
   if ( $opt_valgrind_mysqld )
@@ -3867,7 +3901,7 @@ sub mysqld_arguments ($$$$) {
     my $slave_load_path= "../tmp";
     mtr_add_arg($args, "%s--slave-load-tmpdir=%s", $prefix,
                 $slave_load_path);
-    mtr_add_arg($args, "%s--set-variable=slave_net_timeout=10", $prefix);
+    mtr_add_arg($args, "%s--set-variable=slave_net_timeout=120", $prefix);
 
     if ( @$slave_master_info )
     {
@@ -4220,10 +4254,19 @@ sub run_testcase_need_master_restart($)
   elsif (! mtr_same_opts($master->[0]->{'start_opts'},
                          $tinfo->{'master_opt'}) )
   {
-    $do_restart= 1;
+    # Chech that diff is binlog format only
-    mtr_verbose("Restart master: running with different options '" .
+    my $diff_opts= mtr_diff_opts($master->[0]->{'start_opts'},$tinfo->{'master_opt'});
-	       join(" ", @{$tinfo->{'master_opt'}}) . "' != '" .
+    if (scalar(@$diff_opts) eq 2) 
-		join(" ", @{$master->[0]->{'start_opts'}}) . "'" );
+    {
+      $do_restart= 1 unless ($diff_opts->[0] =~/^--binlog-format=/ and $diff_opts->[1] =~/^--binlog-format=/);
+    }
+    else
+    {
+      $do_restart= 1;
+      mtr_verbose("Restart master: running with different options '" .
+	         join(" ", @{$tinfo->{'master_opt'}}) . "' != '" .
+	  	join(" ", @{$master->[0]->{'start_opts'}}) . "'" );
+    }
   }
   elsif( ! $master->[0]->{'pid'} )
   {
@@ -5148,6 +5191,7 @@ Options to control what test suites or cases to run
                         checked from test cases.
   combination="ARG1 .. ARG2" Specify a set of "mysqld" arguments for one
                         combination.
+  skip-combination      Skip any combination options and combinations files
 
 Options that specify ports
 

mysql-test/r/bdb_notembedded.result

@@ -0,0 +1,35 @@
+set autocommit=1;
+reset master;
+create table bug16206 (a int);
+insert into bug16206 values(1);
+start transaction;
+insert into bug16206 values(2);
+commit;
+show binlog events;
+Log_name	Pos	Event_type	Server_id	End_log_pos	Info
+f	n	Format_desc	1	n	Server ver: VERSION, Binlog ver: 4
+f	n	Query	1	n	use `test`; create table bug16206 (a int)
+f	n	Query	1	n	use `test`; insert into bug16206 values(1)
+f	n	Query	1	n	use `test`; insert into bug16206 values(2)
+drop table bug16206;
+reset master;
+create table bug16206 (a int) engine=         bdb;
+insert into bug16206 values(0);
+insert into bug16206 values(1);
+start transaction;
+insert into bug16206 values(2);
+commit;
+insert into bug16206 values(3);
+show binlog events;
+Log_name	Pos	Event_type	Server_id	End_log_pos	Info
+f	n	Format_desc	1	n	Server ver: VERSION, Binlog ver: 4
+f	n	Query	1	n	use `test`; create table bug16206 (a int) engine=         bdb
+f	n	Query	1	n	use `test`; insert into bug16206 values(0)
+f	n	Query	1	n	use `test`; insert into bug16206 values(1)
+f	n	Query	1	n	use `test`; BEGIN
+f	n	Query	1	n	use `test`; insert into bug16206 values(2)
+f	n	Query	1	n	use `test`; COMMIT
+f	n	Query	1	n	use `test`; insert into bug16206 values(3)
+drop table bug16206;
+set autocommit=0;
+End of 5.0 tests

mysql-test/r/mysqlbinlog.result

@@ -352,4 +352,29 @@ a	b
 1	root@localhost
 DROP DATABASE mysqltest1;
 DROP USER untrusted@localhost;
+BUG#32580: mysqlbinlog cannot read binlog event with user variables
+USE test;
+SET BINLOG_FORMAT = STATEMENT;
+FLUSH LOGS;
+CREATE TABLE t1 (a_real FLOAT, an_int INT, a_decimal DECIMAL(5,2), a_string CHAR(32));
+SET @a_real = rand(20) * 1000;
+SET @an_int = 1000;
+SET @a_decimal = CAST(rand(19) * 999 AS DECIMAL(5,2));
+SET @a_string = 'Just a test';
+INSERT INTO t1 VALUES (@a_real, @an_int, @a_decimal, @a_string);
+FLUSH LOGS;
+SELECT * FROM t1;
+a_real	158.883
+an_int	1000
+a_decimal	907.79
+a_string	Just a test
+DROP TABLE t1;
+>> mysqlbinlog var/log/master-bin.000019 > var/tmp/bug32580.sql
+>> mysql test < var/tmp/bug32580.sql
+SELECT * FROM t1;
+a_real	158.883
+an_int	1000
+a_decimal	907.79
+a_string	Just a test
+DROP TABLE t1;
 End of 5.1 tests

mysql-test/suite/rpl/combinations

@@ -0,0 +1,8 @@
+[row]
+--binlog-format=row
+
+[stmt]
+--binlog-format=statement
+
+[mix]
+--binlog-format=mixed

mysql-test/suite/rpl/r/rpl_invoked_features.result

@@ -116,23 +116,23 @@ t12
 t13
 t2
 t3
-SELECT table_name FROM information_schema.views WHERE table_schema='test';
+SELECT table_name FROM information_schema.views WHERE table_schema='test' ORDER BY table_name;
 table_name
 v1
 v11
-SELECT trigger_name, event_manipulation, event_object_table FROM information_schema.triggers WHERE trigger_schema='test';
+SELECT trigger_name, event_manipulation, event_object_table FROM information_schema.triggers WHERE trigger_schema='test' ORDER BY trigger_name;
 trigger_name	event_manipulation	event_object_table
-t1_tr1	INSERT	t1
-t1_tr2	UPDATE	t1
 t11_tr1	INSERT	t11
 t11_tr2	UPDATE	t11
-SELECT routine_type, routine_name FROM information_schema.routines WHERE routine_schema='test';
+t1_tr1	INSERT	t1
+t1_tr2	UPDATE	t1
+SELECT routine_type, routine_name FROM information_schema.routines WHERE routine_schema='test' ORDER BY routine_name;
 routine_type	routine_name
 FUNCTION	f1
 FUNCTION	f2
 PROCEDURE	p1
 PROCEDURE	p11
-SELECT event_name, status FROM information_schema.events WHERE event_schema='test';
+SELECT event_name, status FROM information_schema.events WHERE event_schema='test' ORDER BY event_name;
 event_name	status
 e1	DISABLED
 e11	DISABLED
@@ -276,23 +276,23 @@ t12
 t13
 t2
 t3
-SELECT table_name FROM information_schema.views WHERE table_schema='test';
+SELECT table_name FROM information_schema.views WHERE table_schema='test' ORDER BY table_name;
 table_name
 v1
 v11
-SELECT trigger_name, event_manipulation, event_object_table FROM information_schema.triggers WHERE trigger_schema='test';
+SELECT trigger_name, event_manipulation, event_object_table FROM information_schema.triggers WHERE trigger_schema='test' ORDER BY trigger_name;
 trigger_name	event_manipulation	event_object_table
-t1_tr1	INSERT	t1
-t1_tr2	UPDATE	t1
 t11_tr1	INSERT	t11
 t11_tr2	UPDATE	t11
-SELECT routine_type, routine_name FROM information_schema.routines WHERE routine_schema='test';
+t1_tr1	INSERT	t1
+t1_tr2	UPDATE	t1
+SELECT routine_type, routine_name FROM information_schema.routines WHERE routine_schema='test' ORDER BY routine_name;
 routine_type	routine_name
 FUNCTION	f1
 FUNCTION	f2
 PROCEDURE	p1
 PROCEDURE	p11
-SELECT event_name, status FROM information_schema.events WHERE event_schema='test';
+SELECT event_name, status FROM information_schema.events WHERE event_schema='test' ORDER BY event_name;
 event_name	status
 e1	SLAVESIDE_DISABLED
 e11	SLAVESIDE_DISABLED

mysql-test/suite/rpl/t/rpl_invoked_features.test

@@ -202,10 +202,10 @@ SET GLOBAL EVENT_SCHEDULER = off;
 # Check original objects
 --echo
 SHOW TABLES LIKE 't%';
-SELECT table_name FROM information_schema.views WHERE table_schema='test';
+SELECT table_name FROM information_schema.views WHERE table_schema='test' ORDER BY table_name;
-SELECT trigger_name, event_manipulation, event_object_table FROM information_schema.triggers WHERE trigger_schema='test';
+SELECT trigger_name, event_manipulation, event_object_table FROM information_schema.triggers WHERE trigger_schema='test' ORDER BY trigger_name;
-SELECT routine_type, routine_name FROM information_schema.routines WHERE routine_schema='test';
+SELECT routine_type, routine_name FROM information_schema.routines WHERE routine_schema='test' ORDER BY routine_name;
-SELECT event_name, status FROM information_schema.events WHERE event_schema='test';
+SELECT event_name, status FROM information_schema.events WHERE event_schema='test' ORDER BY event_name;
 
 # Check original data
 --echo
@@ -229,10 +229,10 @@ SELECT a,b FROM v11 ORDER BY a;
 # Check replicated objects
 --echo
 SHOW TABLES LIKE 't%';
-SELECT table_name FROM information_schema.views WHERE table_schema='test';
+SELECT table_name FROM information_schema.views WHERE table_schema='test' ORDER BY table_name;
-SELECT trigger_name, event_manipulation, event_object_table FROM information_schema.triggers WHERE trigger_schema='test';
+SELECT trigger_name, event_manipulation, event_object_table FROM information_schema.triggers WHERE trigger_schema='test' ORDER BY trigger_name;
-SELECT routine_type, routine_name FROM information_schema.routines WHERE routine_schema='test';
+SELECT routine_type, routine_name FROM information_schema.routines WHERE routine_schema='test' ORDER BY routine_name;
-SELECT event_name, status FROM information_schema.events WHERE event_schema='test';
+SELECT event_name, status FROM information_schema.events WHERE event_schema='test' ORDER BY event_name;
 
 # Check replicated data
 --echo

mysql-test/suite/rpl/t/rpl_misc_functions.test

@@ -109,6 +109,7 @@ DROP TABLE t1, t1_slave;
 DROP PROCEDURE test_replication_sp1;
 DROP PROCEDURE test_replication_sp2;
 DROP FUNCTION test_replication_sf;
+--remove_file $MYSQLTEST_VARDIR/master-data/test/rpl_misc_functions.outfile
 --sync_slave_with_master
 
 

mysql-test/suite/rpl/t/rpl_session_var.test

@@ -51,8 +51,9 @@ CREATE TABLE t1 (
   `data` varchar(100),
   PRIMARY KEY  (`id`)
  ) ENGINE=MyISAM;
-
+--disable_warnings
 INSERT INTO t1(data) VALUES(SESSION_USER());
+--enable_warnings
 save_master_pos;
 connection slave;
 sync_with_master;

mysql-test/t/bdb_notembedded.test

@@ -0,0 +1,38 @@
+-- source include/not_embedded.inc
+-- source include/have_bdb.inc
+
+#
+# Bug #16206: Superfluous COMMIT event in binlog when updating BDB in autocommit mode
+#
+set autocommit=1;
+
+let $VERSION=`select version()`;
+
+reset master;
+create table bug16206 (a int);
+insert into bug16206 values(1);
+start transaction;
+insert into bug16206 values(2);
+commit;
+--replace_result $VERSION VERSION
+--replace_column 1 f 2 n 5 n
+show binlog events;
+drop table bug16206;
+
+reset master;
+create table bug16206 (a int) engine=         bdb;
+insert into bug16206 values(0);
+insert into bug16206 values(1);
+start transaction;
+insert into bug16206 values(2);
+commit;
+insert into bug16206 values(3);
+--replace_result $VERSION VERSION
+--replace_column 1 f 2 n 5 n
+show binlog events;
+drop table bug16206;
+
+set autocommit=0;
+
+
+--echo End of 5.0 tests

mysql-test/t/mysqlbinlog.test

@@ -282,4 +282,31 @@ connection default;
 DROP DATABASE mysqltest1;
 DROP USER untrusted@localhost;
 
+--echo BUG#32580: mysqlbinlog cannot read binlog event with user variables
+
+# Testing that various kinds of events can be read and restored properly.
+
+connection default;
+USE test;
+SET BINLOG_FORMAT = STATEMENT;
+FLUSH LOGS;
+CREATE TABLE t1 (a_real FLOAT, an_int INT, a_decimal DECIMAL(5,2), a_string CHAR(32));
+SET @a_real = rand(20) * 1000;
+SET @an_int = 1000;
+SET @a_decimal = CAST(rand(19) * 999 AS DECIMAL(5,2));
+SET @a_string = 'Just a test';
+INSERT INTO t1 VALUES (@a_real, @an_int, @a_decimal, @a_string);
+FLUSH LOGS;
+query_vertical SELECT * FROM t1;
+DROP TABLE t1;
+
+echo >> mysqlbinlog var/log/master-bin.000019 > var/tmp/bug32580.sql;
+exec $MYSQL_BINLOG $MYSQLTEST_VARDIR/log/master-bin.000019 > $MYSQLTEST_VARDIR/tmp/bug32580.sql;
+echo >> mysql test < var/tmp/bug32580.sql;
+exec $MYSQL test < $MYSQLTEST_VARDIR/tmp/bug32580.sql;
+remove_file $MYSQLTEST_VARDIR/tmp/bug32580.sql;
+
+query_vertical SELECT * FROM t1;
+DROP TABLE t1;
+
 --echo End of 5.1 tests

scripts/make_binary_distribution.sh

@@ -396,6 +396,7 @@ copyfileto $BASE/mysql-test \
 $CP mysql-test/lib/*.pl  $BASE/mysql-test/lib
 $CP mysql-test/t/*.def $BASE/mysql-test/t
 $CP mysql-test/include/*.inc $BASE/mysql-test/include
+$CP mysql-test/include/*.sql $BASE/mysql-test/include
 $CP mysql-test/include/*.test $BASE/mysql-test/include
 $CP mysql-test/t/*.def $BASE/mysql-test/t
 $CP mysql-test/std_data/*.dat mysql-test/std_data/*.frm \

sql/log_event.cc

@@ -36,6 +36,16 @@
 
 #define FLAGSTR(V,F) ((V)&(F)?#F" ":"")
 
+
+/*
+  Size of buffer for printing a double in format %.<PREC>g
+
+  optional '-' + optional zero + '.'  + PREC digits + 'e' + sign +
+  exponent digits + '\0'
+*/
+#define FMT_G_BUFSIZE(PREC) (3 + (PREC) + 5 + 1)
+
+
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) && !defined(DBUG_OFF) && !defined(_lint)
 static const char *HA_ERR(int i)
 {
@@ -4508,8 +4518,10 @@ void User_var_log_event::print(FILE* file, PRINT_EVENT_INFO* print_event_info)
     switch (type) {
     case REAL_RESULT:
       double real_val;
+      char real_buf[FMT_G_BUFSIZE(14)];
       float8get(real_val, val);
-      my_b_printf(&cache, ":=%.14g%s\n", real_val, print_event_info->delimiter);
+      my_sprintf(real_buf, (real_buf, "%.14g", real_val));
+      my_b_printf(&cache, ":=%s%s\n", real_buf, print_event_info->delimiter);
       break;
     case INT_RESULT:
       char int_buf[22];

sql/log_event_old.h

@@ -21,17 +21,268 @@
  */
 
 
-class Old_rows_log_event
+/**
+  @file
+
+  @brief This file contains classes handling old formats of row-based
+  binlog events.
+*/
+/*
+  Around 2007-10-31, I made these classes completely separated from
+  the new classes (before, there was a complex class hierarchy
+  involving multiple inheritance; see BUG#31581), by simply copying
+  and pasting the entire contents of Rows_log_event into
+  Old_rows_log_event and the entire contents of
+  {Write|Update|Delete}_rows_log_event into
+  {Write|Update|Delete}_rows_log_event_old.  For clarity, I will keep
+  the comments marking which code was cut-and-pasted for some time.
+  With the classes collapsed into one, there is probably some
+  redundancy (maybe some methods can be simplified and/or removed),
+  but we keep them this way for now.  /Sven
+*/
+
+
+/**
+  @class Old_rows_log_event
+  
+  Base class for the three types of row-based events
+  {Write|Update|Delete}_row_log_event_old, with event type codes
+  PRE_GA_{WRITE|UPDATE|DELETE}_ROWS_EVENT.  These events are never
+  created any more, except when reading a relay log created by an old
+  server.
+*/
+class Old_rows_log_event : public Log_event
 {
- public:
+  /********** BEGIN CUT & PASTE FROM Rows_log_event **********/
+public:
+  /**
+     Enumeration of the errors that can be returned.
+   */
+  enum enum_error
+  {
+    ERR_OPEN_FAILURE = -1,               /**< Failure to open table */
+    ERR_OK = 0,                                 /**< No error */
+    ERR_TABLE_LIMIT_EXCEEDED = 1,      /**< No more room for tables */
+    ERR_OUT_OF_MEM = 2,                         /**< Out of memory */
+    ERR_BAD_TABLE_DEF = 3,     /**< Table definition does not match */
+    ERR_RBR_TO_SBR = 4  /**< daisy-chanining RBR to SBR not allowed */
+  };
 
-  virtual ~Old_rows_log_event() {}
+  /*
+    These definitions allow you to combine the flags into an
+    appropriate flag set using the normal bitwise operators.  The
+    implicit conversion from an enum-constant to an integer is
+    accepted by the compiler, which is then used to set the real set
+    of flags.
+  */
+  enum enum_flag
+  {
+    /* Last event of a statement */
+    STMT_END_F = (1U << 0),
 
+    /* Value of the OPTION_NO_FOREIGN_KEY_CHECKS flag in thd->options */
+    NO_FOREIGN_KEY_CHECKS_F = (1U << 1),
+
+    /* Value of the OPTION_RELAXED_UNIQUE_CHECKS flag in thd->options */
+    RELAXED_UNIQUE_CHECKS_F = (1U << 2),
+
+    /** 
+      Indicates that rows in this event are complete, that is contain
+      values for all columns of the table.
+     */
+    COMPLETE_ROWS_F = (1U << 3)
+  };
+
+  typedef uint16 flag_set;
+
+  /* Special constants representing sets of flags */
+  enum 
+  {
+      RLE_NO_FLAGS = 0U
+  };
+
+  virtual ~Old_rows_log_event();
+
+  void set_flags(flag_set flags_arg) { m_flags |= flags_arg; }
+  void clear_flags(flag_set flags_arg) { m_flags &= ~flags_arg; }
+  flag_set get_flags(flag_set flags_arg) const { return m_flags & flags_arg; }
+
+#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
+  virtual void pack_info(Protocol *protocol);
+#endif
+
+#ifdef MYSQL_CLIENT
+  /* not for direct call, each derived has its own ::print() */
+  virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info)= 0;
+#endif
+
+#ifndef MYSQL_CLIENT
+  int add_row_data(uchar *data, size_t length)
+  {
+    return do_add_row_data(data,length); 
+  }
+#endif
+
+  /* Member functions to implement superclass interface */
+  virtual int get_data_size();
+
+  MY_BITMAP const *get_cols() const { return &m_cols; }
+  size_t get_width() const          { return m_width; }
+  ulong get_table_id() const        { return m_table_id; }
+
+#ifndef MYSQL_CLIENT
+  virtual bool write_data_header(IO_CACHE *file);
+  virtual bool write_data_body(IO_CACHE *file);
+  virtual const char *get_db() { return m_table->s->db.str; }
+#endif
+  /*
+    Check that malloc() succeeded in allocating memory for the rows
+    buffer and the COLS vector. Checking that an Update_rows_log_event_old
+    is valid is done in the Update_rows_log_event_old::is_valid()
+    function.
+  */
+  virtual bool is_valid() const
+  {
+    return m_rows_buf && m_cols.bitmap;
+  }
+
+  uint     m_row_count;         /* The number of rows added to the event */
+
+protected:
+  /* 
+     The constructors are protected since you're supposed to inherit
+     this class, not create instances of this class.
+  */
+#ifndef MYSQL_CLIENT
+  Old_rows_log_event(THD*, TABLE*, ulong table_id,
+                     MY_BITMAP const *cols, bool is_transactional);
+#endif
+  Old_rows_log_event(const char *row_data, uint event_len,
+                     Log_event_type event_type,
+                     const Format_description_log_event *description_event);
+
+#ifdef MYSQL_CLIENT
+  void print_helper(FILE *, PRINT_EVENT_INFO *, char const *const name);
+#endif
+
+#ifndef MYSQL_CLIENT
+  virtual int do_add_row_data(uchar *data, size_t length);
+#endif
+
+#ifndef MYSQL_CLIENT
+  TABLE *m_table;		/* The table the rows belong to */
+#endif
+  ulong       m_table_id;	/* Table ID */
+  MY_BITMAP   m_cols;		/* Bitmap denoting columns available */
+  ulong       m_width;          /* The width of the columns bitmap */
+  /*
+    Bitmap for columns available in the after image, if present. These
+    fields are only available for Update_rows events. Observe that the
+    width of both the before image COLS vector and the after image
+    COLS vector is the same: the number of columns of the table on the
+    master.
+  */
+  MY_BITMAP   m_cols_ai;
+
+  ulong       m_master_reclength; /* Length of record on master side */
+
+  /* Bit buffers in the same memory as the class */
+  uint32    m_bitbuf[128/(sizeof(uint32)*8)];
+  uint32    m_bitbuf_ai[128/(sizeof(uint32)*8)];
+
+  uchar    *m_rows_buf;		/* The rows in packed format */
+  uchar    *m_rows_cur;		/* One-after the end of the data */
+  uchar    *m_rows_end;		/* One-after the end of the allocated space */
+
+  flag_set m_flags;		/* Flags for row-level events */
+
+  /* helper functions */
+
+#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
+  const uchar *m_curr_row;     /* Start of the row being processed */
+  const uchar *m_curr_row_end; /* One-after the end of the current row */
+  uchar    *m_key;      /* Buffer to keep key value during searches */
+
+  int find_row(const Relay_log_info *const);
+  int write_row(const Relay_log_info *const, const bool);
+
+  // Unpack the current row into m_table->record[0]
+  int unpack_current_row(const Relay_log_info *const rli)
+  { 
+    DBUG_ASSERT(m_table);
+    ASSERT_OR_RETURN_ERROR(m_curr_row < m_rows_end, HA_ERR_CORRUPT_EVENT);
+    int const result= ::unpack_row(rli, m_table, m_width, m_curr_row, &m_cols,
+                                   &m_curr_row_end, &m_master_reclength);
+    ASSERT_OR_RETURN_ERROR(m_curr_row_end <= m_rows_end, HA_ERR_CORRUPT_EVENT);
+    return result;
+  }
+#endif
+
+private:
+
+#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
+  virtual int do_apply_event(Relay_log_info const *rli);
+  virtual int do_update_pos(Relay_log_info *rli);
+  virtual enum_skip_reason do_shall_skip(Relay_log_info *rli);
+
+  /*
+    Primitive to prepare for a sequence of row executions.
+
+    DESCRIPTION
+
+      Before doing a sequence of do_prepare_row() and do_exec_row()
+      calls, this member function should be called to prepare for the
+      entire sequence. Typically, this member function will allocate
+      space for any buffers that are needed for the two member
+      functions mentioned above.
+
+    RETURN VALUE
+
+      The member function will return 0 if all went OK, or a non-zero
+      error code otherwise.
+  */
+  virtual 
+  int do_before_row_operations(const Slave_reporting_capability *const log) = 0;
+
+  /*
+    Primitive to clean up after a sequence of row executions.
+
+    DESCRIPTION
+    
+      After doing a sequence of do_prepare_row() and do_exec_row(),
+      this member function should be called to clean up and release
+      any allocated buffers.
+      
+      The error argument, if non-zero, indicates an error which happened during
+      row processing before this function was called. In this case, even if 
+      function is successful, it should return the error code given in the argument.
+  */
+  virtual 
+  int do_after_row_operations(const Slave_reporting_capability *const log,
+                              int error) = 0;
+
+  /*
+    Primitive to do the actual execution necessary for a row.
+
+    DESCRIPTION
+      The member function will do the actual execution needed to handle a row.
+      The row is located at m_curr_row. When the function returns, 
+      m_curr_row_end should point at the next row (one byte after the end
+      of the current row).    
+
+    RETURN VALUE
+      0 if execution succeeded, 1 if execution failed.
+      
+  */
+  virtual int do_exec_row(const Relay_log_info *const rli) = 0;
+#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
+
+  /********** END OF CUT & PASTE FROM Rows_log_event **********/
  protected:
   
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 
-  int do_apply_event(Rows_log_event*,const Relay_log_info*);
+  int do_apply_event(Old_rows_log_event*,const Relay_log_info*);
 
   /*
     Primitive to prepare for a sequence of row executions.
@@ -100,9 +351,52 @@ class Old_rows_log_event
 };
 
 
-class Write_rows_log_event_old 
+/**
- : public Write_rows_log_event, public Old_rows_log_event
+  @class Write_rows_log_event_old
+
+  Old class for binlog events that write new rows to a table (event
+  type code PRE_GA_WRITE_ROWS_EVENT).  Such events are never produced
+  by this version of the server, but they may be read from a relay log
+  created by an old server.  New servers create events of class
+  Write_rows_log_event (event type code WRITE_ROWS_EVENT) instead.
+*/
+class Write_rows_log_event_old : public Old_rows_log_event
 {
+  /********** BEGIN CUT & PASTE FROM Write_rows_log_event **********/
+public:
+#if !defined(MYSQL_CLIENT)
+  Write_rows_log_event_old(THD*, TABLE*, ulong table_id,
+                           MY_BITMAP const *cols, bool is_transactional);
+#endif
+#ifdef HAVE_REPLICATION
+  Write_rows_log_event_old(const char *buf, uint event_len,
+                           const Format_description_log_event *description_event);
+#endif
+#if !defined(MYSQL_CLIENT) 
+  static bool binlog_row_logging_function(THD *thd, TABLE *table,
+                                          bool is_transactional,
+                                          MY_BITMAP *cols,
+                                          uint fields,
+                                          const uchar *before_record
+                                          __attribute__((unused)),
+                                          const uchar *after_record)
+  {
+    return thd->binlog_write_row(table, is_transactional,
+                                 cols, fields, after_record);
+  }
+#endif
+
+private:
+#ifdef MYSQL_CLIENT
+  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+#endif
+
+#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
+  virtual int do_before_row_operations(const Slave_reporting_capability *const);
+  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
+  virtual int do_exec_row(const Relay_log_info *const);
+#endif
+  /********** END OF CUT & PASTE FROM Write_rows_log_event **********/
 
 public:
   enum
@@ -111,21 +405,6 @@ public:
     TYPE_CODE = PRE_GA_WRITE_ROWS_EVENT
   };
 
-#if !defined(MYSQL_CLIENT)
-  Write_rows_log_event_old(THD *thd, TABLE *table, ulong table_id,
-                           MY_BITMAP const *cols, bool is_transactional)
-    : Write_rows_log_event(thd, table, table_id, cols, is_transactional)
-  {
-  }
-#endif
-#if defined(HAVE_REPLICATION)
-  Write_rows_log_event_old(const char *buf, uint event_len,
-                           const Format_description_log_event *descr)
-    : Write_rows_log_event(buf, event_len, descr)
-  {
-  }
-#endif
-
 private:
   virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
 
@@ -145,9 +424,65 @@ private:
 };
 
 
-class Update_rows_log_event_old 
+/**
-  : public Update_rows_log_event, public Old_rows_log_event
+  @class Update_rows_log_event_old
+
+  Old class for binlog events that modify existing rows to a table
+  (event type code PRE_GA_UPDATE_ROWS_EVENT).  Such events are never
+  produced by this version of the server, but they may be read from a
+  relay log created by an old server.  New servers create events of
+  class Update_rows_log_event (event type code UPDATE_ROWS_EVENT)
+  instead.
+*/
+class Update_rows_log_event_old : public Old_rows_log_event
 {
+  /********** BEGIN CUT & PASTE FROM Update_rows_log_event **********/
+public:
+#ifndef MYSQL_CLIENT
+  Update_rows_log_event_old(THD*, TABLE*, ulong table_id,
+                            MY_BITMAP const *cols,
+                            bool is_transactional);
+
+  void init(MY_BITMAP const *cols);
+#endif
+
+  virtual ~Update_rows_log_event_old();
+
+#ifdef HAVE_REPLICATION
+  Update_rows_log_event_old(const char *buf, uint event_len,
+                            const Format_description_log_event *description_event);
+#endif
+
+#if !defined(MYSQL_CLIENT) 
+  static bool binlog_row_logging_function(THD *thd, TABLE *table,
+                                          bool is_transactional,
+                                          MY_BITMAP *cols,
+                                          uint fields,
+                                          const uchar *before_record,
+                                          const uchar *after_record)
+  {
+    return thd->binlog_update_row(table, is_transactional,
+                                  cols, fields, before_record, after_record);
+  }
+#endif
+
+  virtual bool is_valid() const
+  {
+    return Old_rows_log_event::is_valid() && m_cols_ai.bitmap;
+  }
+
+protected:
+#ifdef MYSQL_CLIENT
+  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+#endif
+
+#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
+  virtual int do_before_row_operations(const Slave_reporting_capability *const);
+  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
+  virtual int do_exec_row(const Relay_log_info *const);
+#endif /* !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION) */
+  /********** END OF CUT & PASTE FROM Update_rows_log_event **********/
+
   uchar *m_after_image, *m_memory;
   
 public:
@@ -157,23 +492,6 @@ public:
     TYPE_CODE = PRE_GA_UPDATE_ROWS_EVENT
   };
 
-#if !defined(MYSQL_CLIENT)
-  Update_rows_log_event_old(THD *thd, TABLE *table, ulong table_id,
-                           MY_BITMAP const *cols, bool is_transactional)
-    : Update_rows_log_event(thd, table, table_id, cols, is_transactional),
-      m_after_image(NULL), m_memory(NULL)
-  {
-  }
-#endif
-#if defined(HAVE_REPLICATION)
-  Update_rows_log_event_old(const char *buf, uint event_len, 
-                            const Format_description_log_event *descr)
-    : Update_rows_log_event(buf, event_len, descr),
-      m_after_image(NULL), m_memory(NULL)
-  {
-  }
-#endif
-
 private:
   virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
 
@@ -192,9 +510,54 @@ private:
 };
 
 
-class Delete_rows_log_event_old 
+/**
-  : public Delete_rows_log_event, public Old_rows_log_event
+  @class Delete_rows_log_event_old
+
+  Old class for binlog events that delete existing rows from a table
+  (event type code PRE_GA_DELETE_ROWS_EVENT).  Such events are never
+  produced by this version of the server, but they may be read from a
+  relay log created by an old server.  New servers create events of
+  class Delete_rows_log_event (event type code DELETE_ROWS_EVENT)
+  instead.
+*/
+class Delete_rows_log_event_old : public Old_rows_log_event
 {
+  /********** BEGIN CUT & PASTE FROM Update_rows_log_event **********/
+public:
+#ifndef MYSQL_CLIENT
+  Delete_rows_log_event_old(THD*, TABLE*, ulong,
+                            MY_BITMAP const *cols, bool is_transactional);
+#endif
+#ifdef HAVE_REPLICATION
+  Delete_rows_log_event_old(const char *buf, uint event_len,
+                            const Format_description_log_event *description_event);
+#endif
+#if !defined(MYSQL_CLIENT) 
+  static bool binlog_row_logging_function(THD *thd, TABLE *table,
+                                          bool is_transactional,
+                                          MY_BITMAP *cols,
+                                          uint fields,
+                                          const uchar *before_record,
+                                          const uchar *after_record
+                                          __attribute__((unused)))
+  {
+    return thd->binlog_delete_row(table, is_transactional,
+                                  cols, fields, before_record);
+  }
+#endif
+  
+protected:
+#ifdef MYSQL_CLIENT
+  void print(FILE *file, PRINT_EVENT_INFO *print_event_info);
+#endif
+
+#if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
+  virtual int do_before_row_operations(const Slave_reporting_capability *const);
+  virtual int do_after_row_operations(const Slave_reporting_capability *const,int);
+  virtual int do_exec_row(const Relay_log_info *const);
+#endif
+  /********** END CUT & PASTE FROM Delete_rows_log_event **********/
+
   uchar *m_after_image, *m_memory;
  
 public:
@@ -204,23 +567,6 @@ public:
     TYPE_CODE = PRE_GA_DELETE_ROWS_EVENT
   };
 
-#if !defined(MYSQL_CLIENT)
-  Delete_rows_log_event_old(THD *thd, TABLE *table, ulong table_id,
-                           MY_BITMAP const *cols, bool is_transactional)
-    : Delete_rows_log_event(thd, table, table_id, cols, is_transactional),
-      m_after_image(NULL), m_memory(NULL)
-  {
-  }
-#endif
-#if defined(HAVE_REPLICATION)
-  Delete_rows_log_event_old(const char *buf, uint event_len,
-                            const Format_description_log_event *descr)
-    : Delete_rows_log_event(buf, event_len, descr),
-      m_after_image(NULL), m_memory(NULL)
-  {
-  }
-#endif
-
 private:
   virtual Log_event_type get_type_code() { return (Log_event_type)TYPE_CODE; }
 
@@ -240,4 +586,3 @@ private:
 
 
 #endif
-