Merge lp:~laurynas-biveinis/percona-server/bug54330 into lp:percona-server/5.5

[Laurynas Biveinis]

Fix bug 939485 (MySQL bugs 64432, 54330): fast index creation is
broken - the index contains only part of data.

This has been fixed upstream in 5.1 for bug 54330. The fix is
straightforwardly backported from there, revisions 3351.14.149 and
3351.54.1, but adds a testcase.

[Laurynas Biveinis (laurynas-biveinis)]

Issue 21240.

Jenkins results: http://jenkins.percona.com/job/percona-server-5.5-param/287/

[Alexey Kopytov (akopytov)]

review: Approve

=== added file 'patches/bug54330.patch'
--- patches/bug54330.patch	1970-01-01 00:00:00 +0000
+++ patches/bug54330.patch	2012-02-24 09:44:20 +0000
@@ -0,0 +1,236 @@
+--- a/storage/innobase/row/row0merge.c
++++ b/storage/innobase/row/row0merge.c
+@@ -1607,22 +1607,28 @@
+ 	const dict_index_t*	index,	/*!< in: index being created */
+ 	merge_file_t*		file,	/*!< in/out: file containing
+ 					index entries */
+-	ulint*			half,	/*!< in/out: half the file */
+ 	row_merge_block_t*	block,	/*!< in/out: 3 buffers */
+ 	int*			tmpfd,	/*!< in/out: temporary file handle */
+-	struct TABLE*		table)	/*!< in/out: MySQL table, for
++	struct TABLE*		table,	/*!< in/out: MySQL table, for
+ 					reporting erroneous key value
+ 					if applicable */
++	ulint*			num_run,/*!< in/out: Number of runs remain
++					to be merged */
++	ulint*			run_offset) /*!< in/out: Array contains the
++					first offset number for each merge
++					run */
+ {
+ 	ulint		foffs0;	/*!< first input offset */
+ 	ulint		foffs1;	/*!< second input offset */
+ 	ulint		error;	/*!< error code */
+ 	merge_file_t	of;	/*!< output file */
+-	const ulint	ihalf	= *half;
++	const ulint	ihalf	= run_offset[*num_run / 2];
+ 				/*!< half the input file */
+-	ulint		ohalf;	/*!< half the output file */
++	ulint		n_run	= 0;
++				/*!< num of runs generated from this merge */
+ 
+ 	UNIV_MEM_ASSERT_W(block[0], 3 * sizeof block[0]);
++
+ 	ut_ad(ihalf < file->offset);
+ 
+ 	of.fd = *tmpfd;
+@@ -1638,17 +1644,20 @@
+ #endif /* POSIX_FADV_SEQUENTIAL */
+ 
+ 	/* Merge blocks to the output file. */
+-	ohalf = 0;
+ 	foffs0 = 0;
+ 	foffs1 = ihalf;
+ 
++	UNIV_MEM_INVALID(run_offset, *num_run * sizeof *run_offset);
++
+ 	for (; foffs0 < ihalf && foffs1 < file->offset; foffs0++, foffs1++) {
+-		ulint	ahalf;	/*!< arithmetic half the input file */
+ 
+ 		if (UNIV_UNLIKELY(trx_is_interrupted(trx))) {
+ 			return(DB_INTERRUPTED);
+ 		}
+ 
++		/* Remember the offset number for this run */
++		run_offset[n_run++] = of.offset;
++
+ 		error = row_merge_blocks(index, file, block,
+ 					 &foffs0, &foffs1, &of, table);
+ 
+@@ -1656,21 +1665,6 @@
+ 			return(error);
+ 		}
+ 
+-		/* Record the offset of the output file when
+-		approximately half the output has been generated.  In
+-		this way, the next invocation of row_merge() will
+-		spend most of the time in this loop.  The initial
+-		estimate is ohalf==0. */
+-		ahalf = file->offset / 2;
+-		ut_ad(ohalf <= of.offset);
+-
+-		/* Improve the estimate until reaching half the input
+-		file size, or we can not get any closer to it.  All
+-		comparands should be non-negative when !(ohalf < ahalf)
+-		because ohalf <= of.offset. */
+-		if (ohalf < ahalf || of.offset - ahalf < ohalf - ahalf) {
+-			ohalf = of.offset;
+-		}
+ 	}
+ 
+ 	/* Copy the last blocks, if there are any. */
+@@ -1680,6 +1674,9 @@
+ 			return(DB_INTERRUPTED);
+ 		}
+ 
++		/* Remember the offset number for this run */
++		run_offset[n_run++] = of.offset;
++
+ 		if (!row_merge_blocks_copy(index, file, block, &foffs0, &of)) {
+ 			return(DB_CORRUPTION);
+ 		}
+@@ -1692,6 +1689,9 @@
+ 			return(DB_INTERRUPTED);
+ 		}
+ 
++		/* Remember the offset number for this run */
++		run_offset[n_run++] = of.offset;
++
+ 		if (!row_merge_blocks_copy(index, file, block, &foffs1, &of)) {
+ 			return(DB_CORRUPTION);
+ 		}
+@@ -1703,10 +1703,23 @@
+ 		return(DB_CORRUPTION);
+ 	}
+ 
++	ut_ad(n_run <= *num_run);
++
++	*num_run = n_run;
++
++	/* Each run can contain one or more offsets. As merge goes on,
++	the number of runs (to merge) will reduce until we have one
++	single run. So the number of runs will always be smaller than
++	the number of offsets in file */
++	ut_ad((*num_run) <= file->offset);
++
++	/* The number of offsets in output file is always equal or
++	smaller than input file */
++	ut_ad(of.offset <= file->offset);
++
+ 	/* Swap file descriptors for the next pass. */
+ 	*tmpfd = file->fd;
+ 	*file = of;
+-	*half = ohalf;
+ 
+ 	UNIV_MEM_INVALID(block[0], 3 * sizeof block[0]);
+ 
+@@ -1731,27 +1744,44 @@
+ 					if applicable */
+ {
+ 	ulint	half = file->offset / 2;
++	ulint	num_runs;
++	ulint*	run_offset;
++	ulint	error = DB_SUCCESS;
++
++	/* Record the number of merge runs we need to perform */
++	num_runs = file->offset;
++
++	/* If num_runs are less than 1, nothing to merge */
++	if (num_runs <= 1) {
++		return(error);
++	}
++
++	/* "run_offset" records each run's first offset number */
++	run_offset = (ulint*) mem_alloc(file->offset * sizeof(ulint));
++
++	/* This tells row_merge() where to start for the first round
++	of merge. */
++	run_offset[half] = half;
+ 
+ 	/* The file should always contain at least one byte (the end
+ 	of file marker).  Thus, it must be at least one block. */
+ 	ut_ad(file->offset > 0);
+ 
++	/* Merge the runs until we have one big run */
+ 	do {
+-		ulint	error;
++		error = row_merge(trx, index, file, block, tmpfd,
++				  table, &num_runs, run_offset);
+ 
+-		error = row_merge(trx, index, file, &half,
+-				  block, tmpfd, table);
++		UNIV_MEM_ASSERT_RW(run_offset, num_runs * sizeof *run_offset);
+ 
+ 		if (error != DB_SUCCESS) {
+-			return(error);
++			break;
+ 		}
++	} while (num_runs > 1);
+ 
+-		/* half > 0 should hold except when the file consists
+-		of one block.  No need to merge further then. */
+-		ut_ad(half > 0 || file->offset == 1);
+-	} while (half < file->offset && half > 0);
++	mem_free(run_offset);
+ 
+-	return(DB_SUCCESS);
++	return(error);
+ }
+ 
+ /*************************************************************//**
+--- /dev/null
++++ b/mysql-test/suite/innodb/r/bug54330.result
+@@ -0,0 +1,13 @@
++DROP TABLE IF EXISTS t1;
++CREATE TABLE t1 (
++id BIGINT(20) AUTO_INCREMENT PRIMARY KEY,
++bar BIGINT(20)
++) ENGINE=InnoDB;
++SELECT COUNT(*) FROM t1;
++COUNT(*)
++517672
++ALTER TABLE t1 ADD INDEX baz (bar);
++SELECT COUNT(*) FROM t1 FORCE INDEX (baz);
++COUNT(*)
++517672
++DROP TABLE t1;
+--- /dev/null
++++ b/mysql-test/suite/innodb/t/bug54330.test
+@@ -0,0 +1,38 @@
++# Testcase for MySQL bug #54330 - broken fast index creation
++
++--disable_warnings
++DROP TABLE IF EXISTS t1;
++--enable_warnings
++
++CREATE TABLE t1 (
++       id BIGINT(20) AUTO_INCREMENT PRIMARY KEY,
++       bar BIGINT(20)
++) ENGINE=InnoDB;
++
++--disable_query_log
++SET @old_autocommit=@@AUTOCOMMIT;
++SET AUTOCOMMIT=0;
++let $1= 515641;
++while ($1)
++{
++  eval INSERT INTO t1 (bar) VALUES (NULL);
++  dec $1;
++}
++let $1= 2031;
++while ($1)
++{
++  eval INSERT INTO t1 (bar) VALUES ($1);
++  dec $1;
++}
++COMMIT;
++SET AUTOCOMMIT=@old_autocommit;
++--enable_query_log
++
++SELECT COUNT(*) FROM t1;
++
++ALTER TABLE t1 ADD INDEX baz (bar);
++
++# With the bug present this will differ from the SELECT above!
++SELECT COUNT(*) FROM t1 FORCE INDEX (baz);
++
++DROP TABLE t1;

=== modified file 'patches/series'
--- patches/series	2012-01-19 08:42:23 +0000
+++ patches/series	2012-02-24 09:44:20 +0000
@@ -63,3 +63,4 @@
 group_commit.patch
 warning_fixes.patch
 bug917246.patch
+bug54330.patch