Merge lp:~maria-captains/maria/maria-xtradb into lp:~maria-captains/maria/5.1-converting

[Percona]

[Percona (percona-team)]

Proposal to merge replacement InnoDB->XtraDB

[Sergei Golubchik (sergii)]

proposal for the old lp:~maria-captains/maria/5.1-converting tree.
it the proposal is still relevant, please resubmit for the current tree

Unmerged revisions

2689. By Vadim Tkachenko on 2009-03-31

replace InnoDB by XtraDB release 4

2688. By Michael Widenius on 2009-03-22

Merge with trunk

2687. By Michael Widenius on 2009-03-22

Apply patch by Antony Dovgal:
- Move SAFE_MUTEX to be stored in config.h by configure.in (not as a flag used with compiler command line)
- Generate my_config.h in configure

2686. By Michael Widenius on 2009-03-20

Merge with trunk

2685. By Michael Widenius on 2009-03-20

Avoid compiler warnings on windows

2684. By Michael Widenius on 2009-03-18

Ignore generated file event-config.h

2683. By Michael Widenius on 2009-03-18

Added mariadb and mariadb-version as my.conf option tags
Fixed compiler error when configuring without --lib-event

2682. By Kristian Nielsen on 2009-03-13

Fix build error in some configs.

Remove non-source file from bzr.

2681. By Michael Widenius on 2009-03-12

Added missing fix from last commit

2680. By Michael Widenius on 2009-03-12

Added "pool-of-threads" handling (with libevent)
This is a backport of code from MySQL 6.0 with cleanups and extensions

The following new options are supported
configure options:
  --with-libevent ; Enable use of libevent, which is needed for pool of threads

mysqld options:
--thread-handling=pool-of-threads ; Use a pool of threads to handle queries
--thread-pool-size=# ; Define how many threads should be created to handle all queries
--extra-port=# ; Extra tcp port that uses the old one-thread-per-connection method
--extra-max-connections=# ; Number of connections to accept to 'extra-port'
--test-ignore-wrong-options ; Ignore setting an enum value to a wrong option (for mysql-test-run)

=== modified file 'storage/innobase/CMakeLists.txt' (properties changed: +x to -x)
--- storage/innobase/CMakeLists.txt	2008-05-22 22:25:21 +0000
+++ storage/innobase/CMakeLists.txt	2009-03-31 04:19:17 +0000
@@ -15,7 +15,7 @@
 
 SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DSAFEMALLOC -DSAFE_MUTEX")
 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DSAFEMALLOC -DSAFE_MUTEX")
-ADD_DEFINITIONS(-DMYSQL_SERVER -D_WIN32 -D_LIB)
+ADD_DEFINITIONS(-D_WIN32 -D_LIB)
 
 # Bug 19424 - InnoDB: Possibly a memory overrun of the buffer being freed (64-bit Visual C)
 # Removing Win64 compiler optimizations for all innodb/mem/* files.
@@ -33,7 +33,7 @@
                     ${CMAKE_SOURCE_DIR}/extra/yassl/include)
 
 SET(INNOBASE_SOURCES  btr/btr0btr.c btr/btr0cur.c btr/btr0pcur.c btr/btr0sea.c 
-					 buf/buf0buf.c buf/buf0flu.c buf/buf0lru.c buf/buf0rea.c 
+					 buf/buf0buddy.c buf/buf0buf.c buf/buf0flu.c buf/buf0lru.c buf/buf0rea.c 
 					 data/data0data.c data/data0type.c 
 					 dict/dict0boot.c dict/dict0crea.c dict/dict0dict.c dict/dict0load.c dict/dict0mem.c 
 					 dyn/dyn0dyn.c 
@@ -41,30 +41,57 @@
 					 fil/fil0fil.c 
 					 fsp/fsp0fsp.c
 					 fut/fut0fut.c fut/fut0lst.c 
-					 ha/ha0ha.c ha/hash0hash.c 
+					 ha/ha0ha.c ha/hash0hash.c ha/ha0storage.c 
 					 ibuf/ibuf0ibuf.c 
 					 pars/lexyy.c pars/pars0grm.c pars/pars0opt.c pars/pars0pars.c pars/pars0sym.c 
-					 lock/lock0lock.c
+					 lock/lock0lock.c lock/lock0iter.c 
 					 log/log0log.c log/log0recv.c 
 					 mach/mach0data.c 
 					 mem/mem0mem.c mem/mem0pool.c 
 					 mtr/mtr0log.c mtr/mtr0mtr.c 
 					 os/os0file.c os/os0proc.c os/os0sync.c os/os0thread.c 
-					 page/page0cur.c page/page0page.c 
+					 page/page0cur.c page/page0page.c page/page0zip.c 
 					 que/que0que.c 
-					 handler/ha_innodb.cc
+					 handler/ha_innodb.cc handler/handler0alter.cc handler/i_s.cc handler/mysql_addons.cc 
 					 read/read0read.c 
 					 rem/rem0cmp.c rem/rem0rec.c
-					 row/row0ins.c row/row0mysql.c row/row0purge.c row/row0row.c row/row0sel.c row/row0uins.c 
+					 row/row0ext.c row/row0ins.c row/row0merge.c row/row0mysql.c 
+					 row/row0purge.c row/row0row.c row/row0sel.c row/row0uins.c 
 					 row/row0umod.c row/row0undo.c row/row0upd.c row/row0vers.c 
 					 srv/srv0que.c srv/srv0srv.c srv/srv0start.c 
 					 sync/sync0arr.c sync/sync0rw.c sync/sync0sync.c 
 					 thr/thr0loc.c 
-					 trx/trx0purge.c trx/trx0rec.c trx/trx0roll.c trx/trx0rseg.c trx/trx0sys.c trx/trx0trx.c trx/trx0undo.c 
+					 trx/trx0i_s.c trx/trx0purge.c trx/trx0rec.c trx/trx0roll.c trx/trx0rseg.c 
+					 trx/trx0sys.c trx/trx0trx.c trx/trx0undo.c 
 					 usr/usr0sess.c 
 					 ut/ut0byte.c ut/ut0dbg.c ut/ut0mem.c ut/ut0rnd.c ut/ut0ut.c ut/ut0vec.c ut/ut0list.c ut/ut0wqueue.c)
 
 IF(NOT SOURCE_SUBLIBS)
   ADD_LIBRARY(innobase ${INNOBASE_SOURCES})
   ADD_DEPENDENCIES(innobase GenError)
+  SET_TARGET_PROPERTIES(innobase PROPERTIES COMPILE_FLAGS "-DMYSQL_SERVER")
+
+  IF(INNODB_DYNAMIC_PLUGIN)
+    # The dynamic plugin requires CMake 2.6.0 or later. Otherwise, the /DELAYLOAD property
+    # will not be set
+    CMAKE_MINIMUM_REQUIRED(VERSION 2.6.0 FATAL_ERROR)
+    ADD_LIBRARY(ha_innodb SHARED ${INNOBASE_SOURCES} ha_innodb.def handler/win_delay_loader.cc)
+    ADD_DEPENDENCIES(ha_innodb GenError mysqld)
+    # If build type is not specified as Release, default to Debug
+    # This is a workaround to a problem in CMake 2.6, which does not
+    # set the path of mysqld.lib correctly
+    IF(CMAKE_BUILD_TYPE MATCHES Release)
+       SET(CMAKE_BUILD_TYPE "Release")
+    ELSE(CMAKE_BUILD_TYPE MATCHES Release)
+       SET(CMAKE_BUILD_TYPE "Debug") 
+    ENDIF(CMAKE_BUILD_TYPE MATCHES Release)
+    TARGET_LINK_LIBRARIES(ha_innodb strings zlib)
+    TARGET_LINK_LIBRARIES(ha_innodb ${CMAKE_SOURCE_DIR}/sql/${CMAKE_BUILD_TYPE}/mysqld.lib)
+    SET_TARGET_PROPERTIES(ha_innodb PROPERTIES OUTPUT_NAME ha_innodb)
+    SET_TARGET_PROPERTIES(ha_innodb PROPERTIES LINK_FLAGS "/MAP /MAPINFO:EXPORTS")
+    SET_TARGET_PROPERTIES(ha_innodb PROPERTIES LINK_FLAGS "/ENTRY:\"_DllMainCRTStartup@12\"")
+    SET_TARGET_PROPERTIES(ha_innodb PROPERTIES COMPILE_FLAGS "-DMYSQL_DYNAMIC_PLUGIN")
+    SET_TARGET_PROPERTIES(ha_innodb PROPERTIES LINK_FLAGS "/DELAYLOAD:mysqld.exe")
+  ENDIF(INNODB_DYNAMIC_PLUGIN)
+
 ENDIF(NOT SOURCE_SUBLIBS)

=== added file 'storage/innobase/COPYING.Google'
--- storage/innobase/COPYING.Google	1970-01-01 00:00:00 +0000
+++ storage/innobase/COPYING.Google	2009-03-31 04:19:17 +0000
@@ -0,0 +1,30 @@
+Portions of this software contain modifications contributed by Google, Inc.
+These contributions are used with the following license:
+
+Copyright (c) 2008, Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above
+        copyright notice, this list of conditions and the following
+        disclaimer in the documentation and/or other materials
+        provided with the distribution.
+      * Neither the name of the Google Inc. nor the names of its
+        contributors may be used to endorse or promote products
+        derived from this software without specific prior written
+        permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=== added file 'storage/innobase/ChangeLog'
--- storage/innobase/ChangeLog	1970-01-01 00:00:00 +0000
+++ storage/innobase/ChangeLog	2009-03-31 04:19:17 +0000
@@ -0,0 +1,775 @@
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, mysql-test/innodb-autoinc.result,
+	mysql-test/innodb-autoinc.test:
+	Fix Bug#43203 Overflow from auto incrementing causes server segv
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, mysql-test/innodb-autoinc.result,
+	mysql-test/innodb-autoinc.test:
+	Fix Bug#42714 AUTO_INCREMENT errors in 5.1.31
+
[phone]	The InnoDB Team
+
+	* btr/btr0cur.c:
+	Fix Bug#43043 Crash on BLOB delete operation
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc:
+	Make innodb_use_sys_malloc=ON the default.
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, mysql-test/innodb-autoinc.result,
+	mysql-test/innodb-autoinc.test:
+	Fix Bug#42400 InnoDB autoinc code can't handle floating-point columns
+
[phone]	The InnoDB Team
+
+	* include/ut0mem.h, os/os0proc.c, ut/ut0mem.c:
+	Protect ut_total_allocated_memory with ut_list_mutex in
+	os_mem_alloc_large() and os_mem_free_large(). The lack of this mutex
+	protection could cause an assertion failure during fast index
+	creation. Also, add UNIV_MEM_ALLOC and UNIV_MEM_FREE instrumentation
+	to os_mem_alloc_large() and os_mem_free_large(), so that Valgrind can
+	detect more errors.
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc:
+	Make innodb_thread_concurrency=0 the default. The old default value
+	was 8. A non-zero setting may be useful when InnoDB is showing severe
+	scalability problems under multiple concurrent connections.
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, handler/ha_innodb.h:
+	Fix Bug#41676 Table names are case insensitive in locking
+
[phone]	The InnoDB Team
+
+	* mem/mem0dbg.c, mem/mem0mem.c, mem/mem0pool.c:
+	When innodb_use_sys_malloc is set, ignore
+	innodb_additional_mem_pool_size, because nothing will be allocated
+	from mem_comm_pool.
+
[phone]	The InnoDB Team
+
+	* ut/ut0mem.c:
+	Map ut_malloc_low(), ut_realloc(), and ut_free() directly to malloc(),
+	realloc(), and free() when innodb_use_sys_malloc is set. As a side
+	effect, ut_total_allocated_memory ("Total memory allocated" in the
+	"BUFFER POOL AND MEMORY" section of SHOW ENGINE INNODB STATUS) will
+	exclude any memory allocated by these functions when
+	innodb_use_sys_malloc is set.
+
[phone]	The InnoDB Team
+
+	* btr/btr0cur.c, btr/btr0sea.c, buf/buf0buf.c, handler/ha_innodb.cc,
+	include/buf0buf.ic, include/os0sync.h, include/srv0srv.h,
+	include/sync0rw.h, include/sync0rw.ic, include/sync0sync.h,
+	include/sync0sync.ic, include/univ.i, row/row0sel.c, srv/srv0srv.c,
+	srv/srv0start.c, sync/sync0arr.c, sync/sync0rw.c, sync/sync0sync.c:
+	On those platforms that support it, implement the synchronization
+	primitives of InnoDB mutexes and read/write locks with GCC atomic
+	builtins instead of Pthreads mutexes and InnoDB mutexes. These changes
+	are based on a patch supplied by Mark Callaghan of Google under a BSD
+	license.
+
[phone]	The InnoDB Team
+
+	* btr/btr0cur.c, btr/btr0sea.c, buf/buf0buf.c, handler/ha_innodb.cc,
+	include/btr0sea.h, include/buf0buf.h, include/sync0sync.h,
+	sync/sync0sync.c:
+	Make the configuration parameter innodb_adaptive_hash_index dynamic,
+	so that it can be changed at runtime.
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, ibuf/ibuf0ibuf.c, include/ibuf0ibuf.h,
+	include/ibuf0ibuf.ic:
+	Implement the settable global variable innodb_change_buffering,
+	with the allowed values 'none' and 'inserts'. The default value
+	'inserts' enables the buffering of inserts to non-unique secondary
+	index trees when the B-tree leaf page is not in the buffer pool.
+
[phone]	The InnoDB Team
+
+	* buf/buf0lru.c:
+	Fix a race condition in buf_LRU_invalidate_tablespace(): The
+	compressed page size (zip_size) was read while the block descriptor
+	was no longer protected by a mutex. This could lead to corruption
+	when a table is dropped on a busy system that contains compressed
+	tables.
+
[phone]	The InnoDB Team
+
+	* btr/btr0sea.c, buf/buf0buf.c, include/buf0buf.h, include/buf0buf.ic,
+	include/mtr0log.ic, include/row0upd.ic, mtr/mtr0mtr.c:
+	Implement buf_block_align() with pointer arithmetics, as it is in the
+	built-in InnoDB distributed with MySQL. Do not acquire the buffer pool
+	mutex before buf_block_align(). This removes a scalability bottleneck
+	in the adaptive hash index lookup. In CHECK TABLE, check that
+	buf_pool->page_hash is consistent with buf_block_align().
+
[phone]	The InnoDB Team
+
+	* btr/btr0sea.c:
+	Fix Bug#42279 Race condition in btr_search_drop_page_hash_when_freed()
+
[phone]	The InnoDB Team
+
+	* buf/buf0buf.c, include/buf0buf.h:
+	Remove the unused mode BUF_GET_NOWAIT of buf_page_get_gen()
+
[phone]	The InnoDB Team
+
+	* include/rem0rec.h, include/rem0rec.ic:
+	Fix Bug#41571 MySQL segfaults after innodb recovery
+
[phone]	The InnoDB Team
+
+	* lock/lock0lock.c:
+	Fix Bug#42152 Race condition in lock_is_table_exclusive()
+
[phone]	The InnoDB Team
+
+	* include/trx0roll.h, trx/trx0roll.c, trx/trx0trx.c:
+	Fix Bug#38187 Error 153 when creating savepoints
+
[phone]	The InnoDB Team
+
+	* dict/dict0load.c:
+	Fix Bug#42075 dict_load_indexes failure in dict_load_table will
+	corrupt the dictionary cache
+
[phone]	The InnoDB Team
+
+	* buf/buf0buddy.c, dict/dict0dict.c, dict/dict0mem.c, fil/fil0fil.c,
+	ha/ha0storage.c, handler/ha_innodb.cc, handler/win_delay_loader.cc,
+	include/buf0buf.ic, include/dict0dict.ic, include/hash0hash.h,
+	thr/thr0loc.c, trx/trx0i_s.c:
+	Add the parameter ASSERTION to HASH_SEARCH() macro, and use it for
+	light validation of the traversed items in hash table lookups when
+	UNIV_DEBUG is enabled.
+
[phone]	The InnoDB Team
+
+	* buf/buf0flu.c, include/buf0flu.h, include/buf0flu.ic:
+	Remove unused code from the functions
+	buf_flush_insert_into_flush_list() and
+	buf_flush_insert_sorted_into_flush_list().
+
[phone]	The InnoDB Team
+
+	* buf/buf0flu.c:
+	Simplify the functions buf_flush_try_page() and buf_flush_batch(). Add
+	debug assertions and an explanation to buf_flush_write_block_low().
+
[phone]	The InnoDB Team
+
+	* row/row0merge.c:
+	Fix a bug in recovery when dropping temporary indexes.
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, handler/ha_innodb.h, handler/handler0alter.cc:
+	Fix Bug#41680 calls to trx_allocate_for_mysql are not consistent
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb_bug41904.result, mysql-test/innodb_bug41904.test,
+	row/row0merge.c:
+	Fix Bug#41904 create unique index problem
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, include/srv0srv.h, mem/mem0pool.c,
+	mysql-test/innodb-use-sys-malloc-master.opt,
+	mysql-test/innodb-use-sys-malloc.result,
+	mysql-test/innodb-use-sys-malloc.test, srv/srv0srv.c, srv/srv0start.c:
+	Implement the configuration parameter innodb_use_sys_malloc (false by
+	default), for disabling InnoDB's internal memory allocator and using
+	system malloc/free instead. The "BUFFER POOL AND MEMORY" section of
+	SHOW ENGINE INNODB STATUS will report "in additional pool allocated
+	allocated 0" when innodb_use_sys_malloc is set.
+
[phone]	The InnoDB Team
+
+	* btr/btr0btr.c:
+	When setting the PAGE_LEVEL of a compressed B-tree page from or to 0,
+	compress the page at the same time. This is necessary, because the
+	column information stored on the compressed page will differ between
+	leaf and non-leaf pages. Leaf pages are identified by PAGE_LEVEL=0.
+	This bug can make InnoDB crash when all rows of a compressed table are
+	deleted.
+
[phone]	The InnoDB Team
+
+	* include/row0sel.h, include/row0upd.h, pars/pars0pars.c,
+	row/row0mysql.c, row/row0sel.c, row/row0upd.c:
+	Remove update-in-place select from the internal SQL interpreter. It
+	was only used for updating the InnoDB internal data dictionary when
+	renaming or dropping tables. It could have caused deadlocks when
+	acquiring latches on insert buffer bitmap pages.
+
[phone]	The InnoDB Team
+
+	* btr/btr0sea.c, buf/buf0buf.c, buf/buf0lru.c, ha/ha0ha.c,
+	ha/hash0hash.c, include/buf0buf.h, include/ha0ha.h, include/ha0ha.ic,
+	include/hash0hash.h, include/univ.i:
+	Introduce the preprocessor symbol UNIV_AHI_DEBUG for enabling adaptive
+	hash index debugging independently of UNIV_DEBUG.
+
[phone]	The InnoDB Team
+
+	* btr/btr0cur.c:
+	Do not update the free bits in the insert buffer bitmap when inserting
+	or deleting from the insert buffer B-tree. Assert that records in the
+	insert buffer B-tree are never updated.
+
[phone]	The InnoDB Team
+
+	* buf/buf0buf.c, fil/fil0fil.c, fsp/fsp0fsp.c, ibuf/ibuf0ibuf.c,
+	include/fil0fil.h, include/ibuf0ibuf.h, include/ibuf0ibuf.ic,
+	include/ibuf0types.h:
+	Clean up the insert buffer subsystem so that only one insert
+	buffer B-tree exists.
+	Originally, there were provisions in InnoDB for multiple insert
+	buffer B-trees, apparently one for each tablespace.
+	When Heikki Tuuri implemented multiple InnoDB tablespaces in
+	MySQL/InnoDB 4.1, he made the insert buffer live only in the
+	system tablespace (space 0) but left the provisions in the code.
+
[phone]	The InnoDB Team
+
+	* include/srv0srv.h, os/os0proc.c, srv/srv0srv.c:
+	Fix the issue that the InnoDB plugin fails if innodb_buffer_pool_size
+	is defined bigger than 4096M on 64-bit Windows. This bug should not
+	have affected other 64-bit systems.
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc:
+	Fix Bug#40386 Not flushing query cache after truncate.
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, srv/srv0srv.c, trx/trx0trx.c:
+	Fix Bug#40760 "set global innodb_thread_concurrency = 0;" is not safe
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, handler/mysql_addons.cc,
+	include/mysql_addons.h, trx/trx0i_s.c, win-plugin/win-plugin.diff:
+	Remove dependencies to MySQL internals (defining MYSQL_SERVER).
+
[phone]	The InnoDB Team
+
+	* page/page0cur.c:
+	When allocating space for a record from the free list of previously
+	purged records, zero out the DB_TRX_ID and DB_ROLL_PTR of the purged
+	record if the new record would not overwrite these fields. This fixes
+	a harmless content mismatch reported by page_zip_validate().
+
[phone]	The InnoDB Team
+
+	* row/row0merge.c:
+	Replace the WHILE 1 with WHILE 1=1 in the SQL procedure, so that the
+	loop will actually be entered and temporary indexes be dropped during
+	crash recovery.
+
[phone]	The InnoDB Team
+
+	InnoDB Plugin 1.0.2 released
+
[phone]	The InnoDB Team
+
+	* dict/dict0mem.c, include/dict0mem.h, include/lock0lock.h,
+	include/row0mysql.h, include/trx0trx.h, include/univ.i,
+	include/ut0vec.h, include/ut0vec.ic, lock/lock0lock.c,
+	row/row0mysql.c, trx/trx0trx.c:
+	Fix Bug#26316 Triggers create duplicate entries on auto-increment
+	columns
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, handler/handler0vars.h,
+	handler/win_delay_loader.cc, mysql-test/innodb_bug40360.result,
+	mysql-test/innodb_bug40360.test:
+	Fix Bug#40360 Binlog related errors with binlog off
+
[phone]	The InnoDB Team
+
+	* include/data0type.ic:
+	Fix Bug#40369 dtype_get_sql_null_size() returns 0 or 1, not the size
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, include/srv0srv.h, srv/srv0srv.c:
+	Fix Bug#38189 innodb_stats_on_metadata missing
+
[phone]	The InnoDB Team
+
+	* CMakeLists.txt, ha_innodb.def, handler/ha_innodb.cc,
+	handler/handler0alter.cc, handler/handler0vars.h, handler/i_s.cc,
+	handler/win_delay_loader.cc, win-plugin/*:
+	Implemented the delayloading of externals for the plugin on Windows.
+	This makes it possible to build a dynamic plugin (ha_innodb.dll) on
+	Windows.
+
[phone]	The InnoDB Team
+
+	* CMakeLists.txt:
+	Fix Bug#19424 InnoDB: Possibly a memory overrun of the buffer being
+	freed (64-bit Visual C)
+
[phone]	The InnoDB Team
+
+	* ibuf/ibuf0ibuf.c:
+	ibuf_delete_rec(): When the cursor to the insert buffer record
+	cannot be restored, do not complain if the tablespace does not
+	exist, because the insert buffer record may have been discarded by
+	some other thread. This bug has existed in MySQL/InnoDB since
+	version 4.1, when innodb_file_per_table was implemented.
+	This may fix Bug#27276 InnoDB Error: ibuf cursor restoration fails.
+
[phone]	The InnoDB Team
+
+	* dict/dict0dict.c, dict/dict0mem.c, handler/ha_innodb.cc,
+	handler/ha_innodb.h, include/dict0dict.h, include/dict0mem.h,
+	row/row0mysql.c:
+	Fix Bug#39830 Table autoinc value not updated on first insert
+	Fix Bug#35498 Cannot get table test/table1 auto-inccounter value in
+	::info
+	Fix Bug#36411 "Failed to read auto-increment value from storage
+	engine" in 5.1.24 auto-inc
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, include/row0mysql.h, row/row0mysql.c:
+	Fix Bug#40224 New AUTOINC changes mask reporting of deadlock/timeout
+	errors
+
[phone]	The InnoDB Team
+
+	* dict/dict0dict.c, mysql-test/innodb-index.result,
+	mysql-test/innodb-index.test:
+	Skip the undo log size check when creating REDUNDANT and COMPACT
+	tables. In ROW_FORMAT=DYNAMIC and ROW_FORMAT=COMPRESSED, column
+	prefix indexes require that prefixes of externally stored columns
+	be written to the undo log. This may make the undo log record
+	bigger than the record on the B-tree page. The maximum size of an
+	undo log record is the page size. That must be checked for, in
+	dict_index_add_to_cache(). However, this restriction must not
+	be enforced on REDUNDANT or COMPACT tables.
+
[phone]	The InnoDB Team
+
+	* btr/btr0cur.c, include/btr0cur.h, row/row0ext.c, row/row0sel.c,
+	row/row0upd.c:
+	When the server crashes while freeing an externally stored column
+	of a compressed table, the BTR_EXTERN_LEN field in the BLOB
+	pointer will be written as 0. Tolerate this in the functions that
+	deal with externally stored columns. This fixes problems after
+	crash recovery, in the rollback of incomplete transactions, and in
+	the purge of delete-marked records.
+
[phone]	The InnoDB Team
+
+	* btr/btr0btr.c, include/page0zip.h, page/page0zip.c, include/univ.i:
+	When a B-tree node of a compressed table is split or merged, the
+	compression may fail. In this case, the entire compressed page
+	will be copied and the excess records will be deleted. However,
+	page_zip_copy(), now renamed to page_zip_copy_recs(), copied too
+	many fields in the page header, overwriting PAGE_BTR_SEG_LEAF and
+	PAGE_BTR_SEG_TOP when splitting the B-tree root. This caused
+	corruption of compressed tables. Furthermore, the lock table and
+	the adaptive hash index would be corrupted, because we forgot to
+	update them when invoking page_zip_copy_recs().
+
+	Introduce the symbol UNIV_ZIP_DEBUG for triggering the copying of
+	compressed pages more often, for debugging purposes.
+
[phone]	The InnoDB Team
+
+	* handler/handler0alter.cc, include/row0merge.h, row/row0merge.c,
+	row/row0mysql.c:
+	Fix some locking issues, mainly in fast index creation. The
+	InnoDB data dictionary cache should be latched whenever a
+	transaction is holding locks on any data dictionary tables.
+	Otherwise, lock waits or deadlocks could occur. Furthermore, the
+	data dictionary transaction must be committed (and the locks
+	released) before the data dictionary latch is released.
+
+	ha_innobase::add_index(): Lock the data dictionary before renaming
+	or dropping the created indexes, because neither operation will
+	commit the data dictionary transaction.
+
+	ha_innobase::final_drop_index(): Commit the transactions before
+	unlocking the data dictionary.
+
[phone]	The InnoDB Team
+
+	* buf/buf0lru.c:
+	Fix Bug#39939 DROP TABLE/DISCARD TABLESPACE takes long time in
+	buf_LRU_invalidate_tablespace()
+
[phone]	The InnoDB Team
+
+	* dict/dict0crea.c, trx/trx0roll.c, include/row0mysql.h,
+	row/row0merge.c, row/row0mysql.c:
+	When dropping a table, hold the data dictionary latch until the
+	transaction has been committed. The data dictionary latch is
+	supposed to prevent lock waits and deadlocks in the data
+	dictionary tables. Due to this bug, DROP TABLE could cause a
+	deadlock or hang. Note that because of Bug#33650 and Bug#39833,
+	MySQL may also drop a (temporary) table when executing CREATE INDEX
+	or ALTER TABLE ... ADD INDEX.
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, mysql-test/innodb_bug39438-master.opt,
+	mysql-test/innodb_bug39438.result, mysql-test/innodb_bug39438.test:
+	Fix Bug#39438 Testcase for Bug#39436 crashes on 5.1 in
+	fil_space_get_latch
+
[phone]	The InnoDB Team
+
+	* include/lock0lock.h, lock/lock0lock.c,
+	mysql-test/innodb_bug38231.result, mysql-test/innodb_bug38231.test,
+	row/row0mysql.c:
+	Fix Bug#38231 Innodb crash in lock_reset_all_on_table() on TRUNCATE +
+	LOCK / UNLOCK
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc:
+	Fix Bug#35498 Cannot get table test/table1 auto-inccounter value in
+	::info
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, handler/ha_innodb.h:
+	Fix Bug#37788 InnoDB Plugin: AUTO_INCREMENT wrong for compressed
+	tables
+
[phone]	The InnoDB Team
+
+	* dict/dict0dict.c, handler/ha_innodb.cc, handler/ha_innodb.h,
+	include/dict0dict.h, include/dict0mem.h, row/row0mysql.c:
+	Fix Bug#39830 Table autoinc value not updated on first insert
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb-index.test, mysql-test/innodb-index.result,
+	mysql-test/innodb-timeout.test, mysql-test/innodb-timeout.result,
+	srv/srv0srv.c, include/srv0srv.h, handler/ha_innodb.cc,
+	include/ha_prototypes.h:
+	Fix Bug#36285 innodb_lock_wait_timeout is not dynamic, not per session
+
[phone]	The InnoDB Team
+
+	* os/os0proc.c:
+	Fix a memory leak on Windows. The memory leak was due to wrong
+	parameters passed into VirtualFree() call. As the result, the
+	call fails with Windows error 87.
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb.result, mysql-test/innodb-zip.result,
+	mysql-test/innodb-zip.test, mysql-test/innodb.test, ibuf/ibuf0ibuf.c,
+	dict/dict0crea.c, dict/dict0load.c, dict/dict0boot.c,
+	include/dict0dict.h, include/trx0trx.h, dict/dict0dict.c,
+	trx/trx0trx.c, include/ha_prototypes.h, handler/ha_innodb.cc:
+	When creating an index in innodb_strict_mode, check that the
+	maximum record size will never exceed the B-tree page size limit.
+	For uncompressed tables, there should always be enough space for
+	two records in an empty B-tree page. For compressed tables, there
+	should be enough space for storing two node pointer records or one
+	data record in an empty page in uncompressed format.
+	The purpose of this check is to guarantee that INSERT or UPDATE
+	will never fail due to too big record size.
+
[phone]	The InnoDB Team
+
+	* btr/btr0cur.c, data/data0data.c, include/page0zip.h,
+	include/page0zip.ic, page/page0zip.c, mysql-test/innodb_bug36172.test:
+	Prevent infinite B-tree page splits in compressed tables by
+	ensuring that there will always be enough space for two node
+	pointer records in an empty B-tree page. Also, require that at
+	least one data record will fit in an empty compressed page. This
+	will reduce the maximum size of records in compressed tables.
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb.result:
+	Fix the failing innodb test by merging changes that MySQL made to
+	that file (r2646.12.1 in MySQL BZR repository)
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, mysql-test/innodb-autoinc.result,
+	mysql-test/innodb-autoinc.test:
+	Fix Bug#38839 auto increment does not work properly with InnoDB after
+	update
+
[phone]	The InnoDB Team
+
+	* dict/dict0dict.c, handler/handler0alter.cc, include/dict0dict.h,
+	mysql-test/innodb-index.result, mysql-test/innodb-index.test:
+	Fix Bug#38786 InnoDB plugin crashes on drop table/create table with FK
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, include/ha_prototypes.h, row/row0sel.c:
+	Fix Bug#37885 row_search_for_mysql may gap lock unnecessarily with SQL
+	comments in query
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc:
+	Fix Bug#38185 ha_innobase::info can hold locks even when called with
+	HA_STATUS_NO_LOCK
+
[phone]	The InnoDB Team
+
+	* buf/buf0buf.c, buf/buf0lru.c, include/buf0buf.ic, include/univ.i:
+	Introduce UNIV_LRU_DEBUG for debugging the LRU buffer pool cache
+
[phone]	The InnoDB Team
+
+	* buf/buf0lru.c, include/buf0buf.h:
+	Fix two recovery bugs that could lead to a crash in debug builds with
+	small buffer size
+
[phone]	The InnoDB Team
+
+	* btr/btr0cur.c, handler/ha_innodb.cc, include/srv0srv.h,
+	srv/srv0srv.c:
+	Add a parameter innodb_stats_sample_pages to allow users to control
+	the number of index dives when InnoDB estimates the cardinality of
+	an index (ANALYZE TABLE, SHOW TABLE STATUS etc)
+
[phone]	The InnoDB Team
+
+	* trx/trx0i_s.c:
+	Fix a bug that would lead to a crash if a SELECT was issued from the
+	INFORMATION_SCHEMA tables and there are rolling back transactions at
+	the same time
+
[phone]	The InnoDB Team
+
+	* btr/btr0btr.c, btr/btr0cur.c, ibuf/ibuf0ibuf.c, include/btr0cur.h,
+	include/trx0roll.h, include/trx0types.h, row/row0purge.c,
+	row/row0uins.c, row/row0umod.c, trx/trx0roll.c:
+	In the rollback of incomplete transactions after crash recovery,
+	tolerate clustered index records whose externally stored columns
+	have not been written.
+
[phone]	The InnoDB Team
+
+	* trx/trx0trx.c:
+	Fixes a race in recovery where the recovery thread recovering a
+	PREPARED trx and the background rollback thread can both try
+	to free the trx after its status is set to COMMITTED_IN_MEMORY.
+
[phone]	The InnoDB Team
+
+	* include/trx0rec.h, row/row0purge.c, row/row0vers.c, trx/trx0rec.c:
+	Fix a BLOB corruption bug
+
[phone]	The InnoDB Team
+
+	* btr/btr0sea.c, dict/dict0dict.c, include/btr0sea.h:
+	Fixed a timing hole where a thread dropping an index can free the
+	in-memory index struct while another thread is still using that
+	structure to remove entries from adaptive hash index belonging
+	to one of the pages that belongs to the index being dropped.
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb-index.result:
+	Fix the failing innodb-index test by adjusting the result to a new
+	MySQL behavior (the change occured in BZR-r2667)
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb-zip.result, mysql-test/innodb-zip.test:
+	Remove the negative test cases that produce warnings
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb-replace.result, mysql-test/innodb-index.test:
+	Disable part of innodb-index test because MySQL changed its behavior
+	and is not calling ::add_index() anymore when adding primary index on
+	non-NULL column
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb-replace.result, mysql-test/innodb-replace.test:
+	Fix the failing innodb-replace test by merging changes that MySQL
+	made to that file (r2659 in MySQL BZR repository)
+
[phone]	The InnoDB Team
+
+	* lock/lock0lock.c:
+	Fix Bug#36942 Performance problem in lock_get_n_rec_locks (SHOW INNODB
+	STATUS)
+
[phone]	The InnoDB Team
+
+	* ha/ha0ha.c:
+	Fix Bug#36941 Performance problem in ha_print_info (SHOW INNODB
+	STATUS)
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, mysql-test/innodb-autoinc.result,
+	mysql-test/innodb-autoinc.test:
+	Fix Bug#37531 After truncate, auto_increment behaves incorrectly for
+	InnoDB
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc:
+	Rewrite the function innodb_plugin_init() to support parameters in
+	different order (in static and dynamic InnoDB) and to support more
+	parameters in the static InnoDB
+
[phone]	The InnoDB Team
+
+	* handler/handler0alter.cc:
+	Fix a bug in ::add_index() which set the transaction state to "active"
+	but never restored it to the original value. This bug caused warnings
+	to be printed by the rpl.rpl_ddl mysql-test.
+
[phone]	The InnoDB Team
+
+	* mysql-test/patches:
+	Add a directory which contains patches, which need to be applied to
+	MySQL source in order to get some mysql-tests to succeed. The patches
+	cannot be committed in MySQL repository because they are specific to
+	the InnoDB plugin.
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb-zip.result, mysql-test/innodb-zip.test,
+	row/row0row.c:
+	Fix an anomaly when updating a record with BLOB prefix
+
[phone]	The InnoDB Team
+
+	* include/trx0sys.h, srv/srv0start.c, trx/trx0sys.c:
+	Fix a bug in recovery which was a side effect of the file_format_check
+	changes
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb.result:
+	Fix the failing innodb test by merging changes that MySQL made to that
+	file
+
[phone]	The InnoDB Team
+
+	* buf/buf0buf.c, handler/ha_innodb.cc, include/buf0buf.h,
+	include/srv0srv.h, srv/srv0srv.c:
+	Fix Bug#36600 SHOW STATUS takes a lot of CPU in
+	buf_get_latched_pages_number
+
+	* handler/ha_innodb.cc, os/os0file.c:
+	Fix Bug#11894 innodb_file_per_table crashes w/ Windows .sym symbolic
+	link hack
+
+	* include/ut0ut.h, srv/srv0srv.c, ut/ut0ut.c:
+	Fix Bug#36819 ut_usectime does not handle errors from gettimeofday
+
+	* handler/ha_innodb.cc:
+	Fix Bug#35602 Failed to read auto-increment value from storage engine
+
+	* srv/srv0start.c:
+	Fix Bug#36149 Read buffer overflow in srv0start.c found during "make
+	test"
+
[phone]	The InnoDB Team
+
+	* btr/btr0btr.c, mysql-test/innodb_bug36172.result,
+	mysql-test/innodb_bug36172.test:
+	Fix Bug#36172 insert into compressed innodb table crashes
+
[phone]	The InnoDB Team
+
+	InnoDB Plugin 1.0.1 released
+
[phone]	The InnoDB Team
+
+	* handler/ha_innodb.cc, include/srv0srv.h, include/sync0sync.h,
+	include/trx0sys.h, mysql-test/innodb-zip.result,
+	mysql-test/innodb-zip.test, srv/srv0srv.c, srv/srv0start.c,
+	sync/sync0sync.c, trx/trx0sys.c:
+	Implement the system tablespace tagging
+
+	* handler/ha_innodb.cc, handler/i_s.cc, include/univ.i,
+	srv/srv0start.c:
+	Add InnoDB version in INFORMATION_SCHEMA.PLUGINS.PLUGIN_VERSION,
+	in the startup message and in a server variable innodb_version.
+
+	* sync/sync0sync.c:
+	Fix a bug in the sync debug code where a lock with level
+	SYNC_LEVEL_VARYING would cause an assertion failure when a thread
+	tried to release it.
+
[phone]	The InnoDB Team
+
+	* Makefile.am:
+	Fix Bug#36434 ha_innodb.so is installed in the wrong directory
+
+	* handler/ha_innodb.cc:
+	Merge change from MySQL (Fix Bug#35406 5.1-opt crashes on select from
+	I_S.REFERENTIAL_CONSTRAINTS):
+	ChangeSet@1.2563, 2008-03-18 19:42:04+04:00, [e-mail] +1 -0
+
+	* scripts/install_innodb_plugins.sql:
+	Added
+
+	* mysql-test/innodb.result:
+	Merge change from MySQL (this fixes the failing innodb test):
+	ChangeSet@1.1810.3601.4, 2008-02-07 02:33:21+04:00
+
+	* row/row0sel.c:
+	Fix Bug#35226 RBR event crashes slave
+
+	* handler/ha_innodb.cc:
+	Change the fix for Bug#32440 to show bytes instead of kilobytes in
+	INFORMATION_SCHEMA.TABLES.DATA_FREE
+
+	* handler/ha_innodb.cc, mysql-test/innodb.result,
+	mysql-test/innodb.test:
+	Fix Bug#29507 TRUNCATE shows to many rows effected
+
+	* handler/ha_innodb.cc, mysql-test/innodb.result,
+	mysql-test/innodb.test:
+	Fix Bug#35537 Innodb doesn't increment handler_update and
+	handler_delete
+
[phone]	The InnoDB Team
+
+	* handler/i_s.cc, include/srv0start.h, srv/srv0start.c:
+	Fix Bug#36310 InnoDB plugin crash
+
[phone]	The InnoDB Team
+
+	* mysql-test/innodb_bug36169.result, mysql-test/innodb_bug36169.test,
+	row/row0mysql.c:
+	Fix Bug#36169 create innodb compressed table with too large row size
+	crashed
+
+	* (outside the source tree):
+	Fix Bug#36222 New InnoDB plugin 1.0 has wrong MKDIR_P defined in
+	Makefile.in
+
[phone]	The InnoDB Team
+
+	InnoDB Plugin 1.0.0 released

=== modified file 'storage/innobase/Makefile.am'
--- storage/innobase/Makefile.am	2008-12-14 18:54:01 +0000
+++ storage/innobase/Makefile.am	2009-03-31 04:19:17 +0000
@@ -33,7 +33,8 @@
 			include/btr0cur.h include/btr0cur.ic		\
 			include/btr0pcur.h include/btr0pcur.ic		\
 			include/btr0sea.h include/btr0sea.ic		\
-			include/btr0types.h include/buf0buf.h		\
+			include/btr0types.h include/buf0buddy.h		\
+			include/buf0buddy.ic include/buf0buf.h		\
 			include/buf0buf.ic include/buf0flu.h		\
 			include/buf0flu.ic include/buf0lru.h		\
 			include/buf0lru.ic include/buf0rea.h		\
@@ -53,7 +54,10 @@
 			include/fsp0fsp.ic include/fut0fut.h		\
 			include/fut0fut.ic include/fut0lst.h		\
 			include/fut0lst.ic include/ha0ha.h		\
-			include/ha0ha.ic include/hash0hash.h		\
+			include/ha0ha.ic				\
+			include/ha0storage.h				\
+			include/ha0storage.ic				\
+			include/hash0hash.h				\
 			include/hash0hash.ic include/ibuf0ibuf.h	\
 			include/ibuf0ibuf.ic include/ibuf0types.h	\
 			include/lock0iter.h				\
@@ -68,12 +72,15 @@
 			include/mem0pool.h include/mem0pool.ic		\
 			include/mtr0log.h include/mtr0log.ic		\
 			include/mtr0mtr.h include/mtr0mtr.ic		\
-			include/mtr0types.h include/os0file.h		\
+			include/mtr0types.h				\
+			include/mysql_addons.h				\
+			include/os0file.h				\
 			include/os0proc.h include/os0proc.ic		\
 			include/os0sync.h include/os0sync.ic		\
 			include/os0thread.h include/os0thread.ic	\
 			include/page0cur.h include/page0cur.ic		\
 			include/page0page.h include/page0page.ic	\
+			include/page0zip.h include/page0zip.ic		\
 			include/page0types.h include/pars0grm.h		\
 			include/pars0opt.h include/pars0opt.ic		\
 			include/pars0pars.h include/pars0pars.ic	\
@@ -84,7 +91,9 @@
 			include/read0types.h include/rem0cmp.h		\
 			include/rem0cmp.ic include/rem0rec.h		\
 			include/rem0rec.ic include/rem0types.h		\
+			include/row0ext.h include/row0ext.ic		\
 			include/row0ins.h include/row0ins.ic		\
+			include/row0merge.h				\
 			include/row0mysql.h include/row0mysql.ic	\
 			include/row0purge.h include/row0purge.ic	\
 			include/row0row.h include/row0row.ic		\
@@ -101,6 +110,7 @@
 			include/sync0rw.ic include/sync0sync.h		\
 			include/sync0sync.ic include/sync0types.h	\
 			include/thr0loc.h include/thr0loc.ic		\
+			include/trx0i_s.h				\
 			include/trx0purge.h include/trx0purge.ic	\
 			include/trx0rec.h include/trx0rec.ic		\
 			include/trx0roll.h include/trx0roll.ic		\
@@ -119,41 +129,52 @@
 			include/ut0ut.ic include/ut0vec.h		\
 			include/ut0vec.ic include/ut0list.h		\
 			include/ut0list.ic include/ut0wqueue.h		\
-			include/ha_prototypes.h handler/ha_innodb.h
+			include/ha_prototypes.h handler/ha_innodb.h	\
+			include/handler0alter.h				\
+			handler/i_s.h handler/innodb_patch_info.h
 
 EXTRA_LIBRARIES=	libinnobase.a
 noinst_LIBRARIES=	@plugin_innobase_static_target@
 libinnobase_a_SOURCES=	btr/btr0btr.c btr/btr0cur.c btr/btr0pcur.c	\
-			btr/btr0sea.c buf/buf0buf.c buf/buf0flu.c	\
+			btr/btr0sea.c buf/buf0buddy.c			\
+			buf/buf0buf.c buf/buf0flu.c			\
 			buf/buf0lru.c buf/buf0rea.c data/data0data.c	\
 			data/data0type.c dict/dict0boot.c		\
 			dict/dict0crea.c dict/dict0dict.c		\
 			dict/dict0load.c dict/dict0mem.c dyn/dyn0dyn.c	\
 			eval/eval0eval.c eval/eval0proc.c		\
 			fil/fil0fil.c fsp/fsp0fsp.c fut/fut0fut.c	\
-			fut/fut0lst.c ha/ha0ha.c ha/hash0hash.c		\
+			fut/fut0lst.c ha/ha0ha.c			\
+			ha/ha0storage.c					\
+			ha/hash0hash.c					\
 			ibuf/ibuf0ibuf.c lock/lock0iter.c		\
 			lock/lock0lock.c				\
 			log/log0log.c log/log0recv.c mach/mach0data.c	\
 			mem/mem0mem.c mem/mem0pool.c mtr/mtr0log.c	\
 			mtr/mtr0mtr.c os/os0file.c os/os0proc.c		\
 			os/os0sync.c os/os0thread.c page/page0cur.c	\
-			page/page0page.c pars/lexyy.c pars/pars0grm.c	\
+			page/page0page.c page/page0zip.c		\
+			pars/lexyy.c pars/pars0grm.c			\
 			pars/pars0opt.c pars/pars0pars.c		\
 			pars/pars0sym.c que/que0que.c read/read0read.c	\
-			rem/rem0cmp.c rem/rem0rec.c row/row0ins.c	\
+			rem/rem0cmp.c rem/rem0rec.c row/row0ext.c	\
+			row/row0ins.c row/row0merge.c			\
 			row/row0mysql.c row/row0purge.c row/row0row.c	\
 			row/row0sel.c row/row0uins.c row/row0umod.c	\
 			row/row0undo.c row/row0upd.c row/row0vers.c	\
 			srv/srv0que.c srv/srv0srv.c srv/srv0start.c	\
 			sync/sync0arr.c sync/sync0rw.c			\
-			sync/sync0sync.c thr/thr0loc.c trx/trx0purge.c	\
+			sync/sync0sync.c thr/thr0loc.c			\
+			trx/trx0i_s.c					\
+			trx/trx0purge.c					\
 			trx/trx0rec.c trx/trx0roll.c trx/trx0rseg.c	\
 			trx/trx0sys.c trx/trx0trx.c trx/trx0undo.c	\
 			usr/usr0sess.c ut/ut0byte.c ut/ut0dbg.c		\
 			ut/ut0list.c ut/ut0mem.c ut/ut0rnd.c		\
 			ut/ut0ut.c ut/ut0vec.c ut/ut0wqueue.c		\
-			handler/ha_innodb.cc
+			handler/ha_innodb.cc handler/handler0alter.cc	\
+			handler/i_s.cc					\
+			handler/mysql_addons.cc
 
 libinnobase_a_CXXFLAGS=	$(AM_CFLAGS)
 libinnobase_a_CFLAGS=	$(AM_CFLAGS)

=== added file 'storage/innobase/README'
--- storage/innobase/README	1970-01-01 00:00:00 +0000
+++ storage/innobase/README	2009-03-31 04:19:17 +0000
@@ -0,0 +1,29 @@
+This is the source of the InnoDB Plugin 1.0.3 for MySQL 5.1
+===========================================================
+
+Instructions for compiling the plugin:
+--------------------------------------
+
+1. Get the latest MySQL 5.1 sources from
+   http://dev.mysql.com/downloads/mysql/5.1.html#source
+
+2. Replace the contents of the mysql-5.1.N/storage/innobase/ directory
+   with the contents of this directory.
+
+3. Optional (only necessary if you are going to run tests from the
+   mysql-test suite): cd into the innobase directory and run ./setup.sh
+
+4. Compile MySQL as usual.
+
+5. Enjoy!
+
+See the online documentation for more detailed instructions:
+http://www.innodb.com/doc/innodb_plugin-1.0/innodb-plugin-installation.html
+
+For more information about InnoDB visit
+http://www.innodb.com
+
+Please report any problems or issues with the plugin in the InnoDB Forums
+http://forums.innodb.com/ or in the MySQL Bugs database http://bugs.mysql.com
+
+Thank you for using the InnoDB plugin!

=== modified file 'storage/innobase/btr/btr0btr.c'
--- storage/innobase/btr/btr0btr.c	2007-07-10 14:34:21 +0000
+++ storage/innobase/btr/btr0btr.c	2009-03-31 04:19:17 +0000
@@ -1,8 +1,24 @@
+/*****************************************************************************
+
+Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+
+*****************************************************************************/
+
 /******************************************************
 The B-tree
 
-(c) 1994-1996 Innobase Oy
-
 Created 6/2/1994 Heikki Tuuri
 *******************************************************/
 
@@ -14,6 +30,7 @@
 
 #include "fsp0fsp.h"
 #include "page0page.h"
+#include "page0zip.h"
 #include "btr0cur.h"
 #include "btr0sea.h"
 #include "btr0pcur.h"
@@ -77,47 +94,65 @@
 we allocate pages for the non-leaf levels of the tree.
 */
 
-/****************************************************************
-Returns the upper level node pointer to a page. It is assumed that
-mtr holds an x-latch on the tree. */
-static
-rec_t*
-btr_page_get_father_node_ptr(
-/*=========================*/
-				/* out: pointer to node pointer record */
+#ifdef UNIV_BTR_DEBUG
+/******************************************************************
+Checks a file segment header within a B-tree root page. */
+static
+ibool
+btr_root_fseg_validate(
+/*===================*/
+						/* out: TRUE if valid */
+	const fseg_header_t*	seg_header,	/* in: segment header */
+	ulint			space)		/* in: tablespace identifier */
+{
+	ulint	offset = mach_read_from_2(seg_header + FSEG_HDR_OFFSET);
+
+	ut_a(mach_read_from_4(seg_header + FSEG_HDR_SPACE) == space);
+	ut_a(offset >= FIL_PAGE_DATA);
+	ut_a(offset <= UNIV_PAGE_SIZE - FIL_PAGE_DATA_END);
+	return(TRUE);
+}
+#endif /* UNIV_BTR_DEBUG */
+
+/******************************************************************
+Gets the root node of a tree and x-latches it. */
+static
+buf_block_t*
+btr_root_block_get(
+/*===============*/
+				/* out: root page, x-latched */
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page: must contain at least one
-				user record */
-	mtr_t*		mtr);	/* in: mtr */
-/*****************************************************************
-Empties an index page. */
-static
-void
-btr_page_empty(
-/*===========*/
-	page_t*	page,	/* in: page to be emptied */
-	mtr_t*	mtr);	/* in: mtr */
-/*****************************************************************
-Returns TRUE if the insert fits on the appropriate half-page
-with the chosen split_rec. */
-static
-ibool
-btr_page_insert_fits(
-/*=================*/
-					/* out: TRUE if fits */
-	btr_cur_t*	cursor,		/* in: cursor at which insert
-					should be made */
-	rec_t*		split_rec,	/* in: suggestion for first record
-					on upper half-page, or NULL if
-					tuple should be first */
-	const ulint*	offsets,	/* in: rec_get_offsets(
-					split_rec, cursor->index) */
-	dtuple_t*	tuple,		/* in: tuple to insert */
-	mem_heap_t*	heap);		/* in: temporary memory heap */
+	mtr_t*		mtr)	/* in: mtr */
+{
+	ulint		space;
+	ulint		zip_size;
+	ulint		root_page_no;
+	buf_block_t*	block;
+
+	space = dict_index_get_space(index);
+	zip_size = dict_table_zip_size(index->table);
+	root_page_no = dict_index_get_page(index);
+
+	block = btr_block_get(space, zip_size, root_page_no, RW_X_LATCH, mtr);
+	ut_a((ibool)!!page_is_comp(buf_block_get_frame(block))
+	     == dict_table_is_comp(index->table));
+#ifdef UNIV_BTR_DEBUG
+	if (!dict_index_is_ibuf(index)) {
+		const page_t*	root = buf_block_get_frame(block);
+
+		ut_a(btr_root_fseg_validate(FIL_PAGE_DATA + PAGE_BTR_SEG_LEAF
+					    + root, space));
+		ut_a(btr_root_fseg_validate(FIL_PAGE_DATA + PAGE_BTR_SEG_TOP
+					    + root, space));
+	}
+#endif /* UNIV_BTR_DEBUG */
+
+	return(block);
+}
 
 /******************************************************************
 Gets the root node of a tree and x-latches it. */
-
+UNIV_INTERN
 page_t*
 btr_root_get(
 /*=========*/
@@ -125,23 +160,13 @@
 	dict_index_t*	index,	/* in: index tree */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	ulint	space;
-	ulint	root_page_no;
-	page_t*	root;
-
-	space = dict_index_get_space(index);
-	root_page_no = dict_index_get_page(index);
-
-	root = btr_page_get(space, root_page_no, RW_X_LATCH, mtr);
-	ut_a((ibool)!!page_is_comp(root) == dict_table_is_comp(index->table));
-
-	return(root);
+	return(buf_block_get_frame(btr_root_block_get(index, mtr)));
 }
 
 /*****************************************************************
 Gets pointer to the previous user record in the tree. It is assumed that
 the caller has appropriate latches on the page and its neighbor. */
-
+UNIV_INTERN
 rec_t*
 btr_get_prev_user_rec(
 /*==================*/
@@ -153,7 +178,6 @@
 	page_t*	page;
 	page_t*	prev_page;
 	ulint	prev_page_no;
-	ulint	space;
 
 	if (!page_rec_is_infimum(rec)) {
 
@@ -165,23 +189,30 @@
 		}
 	}
 
-	page = buf_frame_align(rec);
+	page = page_align(rec);
 	prev_page_no = btr_page_get_prev(page, mtr);
-	space = buf_frame_get_space_id(page);
 
 	if (prev_page_no != FIL_NULL) {
 
-		prev_page = buf_page_get_with_no_latch(space, prev_page_no,
-						       mtr);
+		ulint		space;
+		ulint		zip_size;
+		buf_block_t*	prev_block;
+
+		space = page_get_space_id(page);
+		zip_size = fil_space_get_zip_size(space);
+
+		prev_block = buf_page_get_with_no_latch(space, zip_size,
+							prev_page_no, mtr);
+		prev_page = buf_block_get_frame(prev_block);
 		/* The caller must already have a latch to the brother */
-		ut_ad((mtr_memo_contains(mtr, buf_block_align(prev_page),
-					 MTR_MEMO_PAGE_S_FIX))
-		      || (mtr_memo_contains(mtr, buf_block_align(prev_page),
-					    MTR_MEMO_PAGE_X_FIX)));
+		ut_ad(mtr_memo_contains(mtr, prev_block,
+					MTR_MEMO_PAGE_S_FIX)
+		      || mtr_memo_contains(mtr, prev_block,
+					   MTR_MEMO_PAGE_X_FIX));
+#ifdef UNIV_BTR_DEBUG
 		ut_a(page_is_comp(prev_page) == page_is_comp(page));
-#ifdef UNIV_BTR_DEBUG
 		ut_a(btr_page_get_next(prev_page, mtr)
-		     == buf_frame_get_page_no(page));
+		     == page_get_page_no(page));
 #endif /* UNIV_BTR_DEBUG */
 
 		return(page_rec_get_prev(page_get_supremum_rec(prev_page)));
@@ -193,7 +224,7 @@
 /*****************************************************************
 Gets pointer to the next user record in the tree. It is assumed that the
 caller has appropriate latches on the page and its neighbor. */
-
+UNIV_INTERN
 rec_t*
 btr_get_next_user_rec(
 /*==================*/
@@ -205,7 +236,6 @@
 	page_t*	page;
 	page_t*	next_page;
 	ulint	next_page_no;
-	ulint	space;
 
 	if (!page_rec_is_supremum(rec)) {
 
@@ -217,25 +247,30 @@
 		}
 	}
 
-	page = buf_frame_align(rec);
+	page = page_align(rec);
 	next_page_no = btr_page_get_next(page, mtr);
-	space = buf_frame_get_space_id(page);
 
 	if (next_page_no != FIL_NULL) {
-
-		next_page = buf_page_get_with_no_latch(space, next_page_no,
-						       mtr);
+		ulint		space;
+		ulint		zip_size;
+		buf_block_t*	next_block;
+
+		space = page_get_space_id(page);
+		zip_size = fil_space_get_zip_size(space);
+
+		next_block = buf_page_get_with_no_latch(space, zip_size,
+							next_page_no, mtr);
+		next_page = buf_block_get_frame(next_block);
 		/* The caller must already have a latch to the brother */
-		ut_ad((mtr_memo_contains(mtr, buf_block_align(next_page),
-					 MTR_MEMO_PAGE_S_FIX))
-		      || (mtr_memo_contains(mtr, buf_block_align(next_page),
-					    MTR_MEMO_PAGE_X_FIX)));
+		ut_ad(mtr_memo_contains(mtr, next_block, MTR_MEMO_PAGE_S_FIX)
+		      || mtr_memo_contains(mtr, next_block,
+					   MTR_MEMO_PAGE_X_FIX));
 #ifdef UNIV_BTR_DEBUG
+		ut_a(page_is_comp(next_page) == page_is_comp(page));
 		ut_a(btr_page_get_prev(next_page, mtr)
-		     == buf_frame_get_page_no(page));
+		     == page_get_page_no(page));
 #endif /* UNIV_BTR_DEBUG */
 
-		ut_a(page_is_comp(next_page) == page_is_comp(page));
 		return(page_rec_get_next(page_get_infimum_rec(next_page)));
 	}
 
@@ -244,37 +279,49 @@
 
 /******************************************************************
 Creates a new index page (not the root, and also not
-used in page reorganization). */
+used in page reorganization).  @see btr_page_empty(). */
 static
 void
 btr_page_create(
 /*============*/
-	page_t*		page,	/* in: page to be created */
+	buf_block_t*	block,	/* in/out: page to be created */
+	page_zip_des_t*	page_zip,/* in/out: compressed page, or NULL */
 	dict_index_t*	index,	/* in: index */
+	ulint		level,	/* in: the B-tree level of the page */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
-	page_create(page, mtr, dict_table_is_comp(index->table));
-	buf_block_align(page)->check_index_page_at_flush = TRUE;
-
-	btr_page_set_index_id(page, index->id, mtr);
+	page_t*		page = buf_block_get_frame(block);
+
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+
+	if (UNIV_LIKELY_NULL(page_zip)) {
+		page_create_zip(block, index, level, mtr);
+	} else {
+		page_create(block, mtr, dict_table_is_comp(index->table));
+		/* Set the level of the new index page */
+		btr_page_set_level(page, NULL, level, mtr);
+	}
+
+	block->check_index_page_at_flush = TRUE;
+
+	btr_page_set_index_id(page, page_zip, index->id, mtr);
 }
 
 /******************************************************************
 Allocates a new file page to be used in an ibuf tree. Takes the page from
 the free list of the tree, which must contain pages! */
 static
-page_t*
+buf_block_t*
 btr_page_alloc_for_ibuf(
 /*====================*/
-				/* out: new allocated page, x-latched */
+				/* out: new allocated block, x-latched */
 	dict_index_t*	index,	/* in: index tree */
 	mtr_t*		mtr)	/* in: mtr */
 {
 	fil_addr_t	node_addr;
 	page_t*		root;
 	page_t*		new_page;
+	buf_block_t*	new_block;
 
 	root = btr_root_get(index, mtr);
 
@@ -282,11 +329,11 @@
 				   + PAGE_BTR_IBUF_FREE_LIST, mtr);
 	ut_a(node_addr.page != FIL_NULL);
 
-	new_page = buf_page_get(dict_index_get_space(index), node_addr.page,
-				RW_X_LATCH, mtr);
-#ifdef UNIV_SYNC_DEBUG
-	buf_page_dbg_add_level(new_page, SYNC_TREE_NODE_NEW);
-#endif /* UNIV_SYNC_DEBUG */
+	new_block = buf_page_get(dict_index_get_space(index),
+				 dict_table_zip_size(index->table),
+				 node_addr.page, RW_X_LATCH, mtr);
+	new_page = buf_block_get_frame(new_block);
+	buf_block_dbg_add_level(new_block, SYNC_TREE_NODE_NEW);
 
 	flst_remove(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
 		    new_page + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST_NODE,
@@ -294,17 +341,17 @@
 	ut_ad(flst_validate(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
 			    mtr));
 
-	return(new_page);
+	return(new_block);
 }
 
 /******************************************************************
 Allocates a new file page to be used in an index tree. NOTE: we assume
 that the caller has made the reservation for free extents! */
-
-page_t*
+UNIV_INTERN
+buf_block_t*
 btr_page_alloc(
 /*===========*/
-					/* out: new allocated page, x-latched;
+					/* out: new allocated block, x-latched;
 					NULL if out of space */
 	dict_index_t*	index,		/* in: index */
 	ulint		hint_page_no,	/* in: hint of a good page */
@@ -316,10 +363,10 @@
 {
 	fseg_header_t*	seg_header;
 	page_t*		root;
-	page_t*		new_page;
+	buf_block_t*	new_block;
 	ulint		new_page_no;
 
-	if (index->type & DICT_IBUF) {
+	if (dict_index_is_ibuf(index)) {
 
 		return(btr_page_alloc_for_ibuf(index, mtr));
 	}
@@ -343,18 +390,17 @@
 		return(NULL);
 	}
 
-	new_page = buf_page_get(dict_index_get_space(index), new_page_no,
-				RW_X_LATCH, mtr);
-#ifdef UNIV_SYNC_DEBUG
-	buf_page_dbg_add_level(new_page, SYNC_TREE_NODE_NEW);
-#endif /* UNIV_SYNC_DEBUG */
+	new_block = buf_page_get(dict_index_get_space(index),
+				 dict_table_zip_size(index->table),
+				 new_page_no, RW_X_LATCH, mtr);
+	buf_block_dbg_add_level(new_block, SYNC_TREE_NODE_NEW);
 
-	return(new_page);
+	return(new_block);
 }
 
 /******************************************************************
 Gets the number of pages in a B-tree. */
-
+UNIV_INTERN
 ulint
 btr_get_size(
 /*=========*/
@@ -404,17 +450,17 @@
 btr_page_free_for_ibuf(
 /*===================*/
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page to be freed, x-latched */
+	buf_block_t*	block,	/* in: block to be freed, x-latched */
 	mtr_t*		mtr)	/* in: mtr */
 {
 	page_t*		root;
 
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 	root = btr_root_get(index, mtr);
 
 	flst_add_first(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
-		       page + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST_NODE, mtr);
+		       buf_block_get_frame(block)
+		       + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST_NODE, mtr);
 
 	ut_ad(flst_validate(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
 			    mtr));
@@ -424,30 +470,27 @@
 Frees a file page used in an index tree. Can be used also to (BLOB)
 external storage pages, because the page level 0 can be given as an
 argument. */
-
+UNIV_INTERN
 void
 btr_page_free_low(
 /*==============*/
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page to be freed, x-latched */
+	buf_block_t*	block,	/* in: block to be freed, x-latched */
 	ulint		level,	/* in: page level */
 	mtr_t*		mtr)	/* in: mtr */
 {
 	fseg_header_t*	seg_header;
 	page_t*		root;
-	ulint		space;
-	ulint		page_no;
 
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 	/* The page gets invalid for optimistic searches: increment the frame
 	modify clock */
 
-	buf_frame_modify_clock_inc(page);
-
-	if (index->type & DICT_IBUF) {
-
-		btr_page_free_for_ibuf(index, page, mtr);
+	buf_block_modify_clock_inc(block);
+
+	if (dict_index_is_ibuf(index)) {
+
+		btr_page_free_for_ibuf(index, block, mtr);
 
 		return;
 	}
@@ -460,30 +503,27 @@
 		seg_header = root + PAGE_HEADER + PAGE_BTR_SEG_TOP;
 	}
 
-	space = buf_frame_get_space_id(page);
-	page_no = buf_frame_get_page_no(page);
-
-	fseg_free_page(seg_header, space, page_no, mtr);
+	fseg_free_page(seg_header,
+		       buf_block_get_space(block),
+		       buf_block_get_page_no(block), mtr);
 }
 
 /******************************************************************
 Frees a file page used in an index tree. NOTE: cannot free field external
 storage pages because the page must contain info on its level. */
-
+UNIV_INTERN
 void
 btr_page_free(
 /*==========*/
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page to be freed, x-latched */
+	buf_block_t*	block,	/* in: block to be freed, x-latched */
 	mtr_t*		mtr)	/* in: mtr */
 {
 	ulint		level;
 
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
-	level = btr_page_get_level(page, mtr);
+	level = btr_page_get_level(buf_block_get_frame(block), mtr);
 
-	btr_page_free_low(index, page, level, mtr);
+	btr_page_free_low(index, block, level, mtr);
 }
 
 /******************************************************************
@@ -493,6 +533,8 @@
 btr_node_ptr_set_child_page_no(
 /*===========================*/
 	rec_t*		rec,	/* in: node pointer record */
+	page_zip_des_t*	page_zip,/* in/out: compressed page whose uncompressed
+				part will be updated, or NULL */
 	const ulint*	offsets,/* in: array returned by rec_get_offsets() */
 	ulint		page_no,/* in: child node address */
 	mtr_t*		mtr)	/* in: mtr */
@@ -501,92 +543,99 @@
 	ulint	len;
 
 	ut_ad(rec_offs_validate(rec, NULL, offsets));
-	ut_ad(0 < btr_page_get_level(buf_frame_align(rec), mtr));
+	ut_ad(!page_is_leaf(page_align(rec)));
 	ut_ad(!rec_offs_comp(offsets) || rec_get_node_ptr_flag(rec));
 
 	/* The child address is in the last field */
 	field = rec_get_nth_field(rec, offsets,
 				  rec_offs_n_fields(offsets) - 1, &len);
 
-	ut_ad(len == 4);
+	ut_ad(len == REC_NODE_PTR_SIZE);
 
-	mlog_write_ulint(field, page_no, MLOG_4BYTES, mtr);
+	if (UNIV_LIKELY_NULL(page_zip)) {
+		page_zip_write_node_ptr(page_zip, rec,
+					rec_offs_data_size(offsets),
+					page_no, mtr);
+	} else {
+		mlog_write_ulint(field, page_no, MLOG_4BYTES, mtr);
+	}
 }
 
 /****************************************************************
 Returns the child page of a node pointer and x-latches it. */
 static
-page_t*
+buf_block_t*
 btr_node_ptr_get_child(
 /*===================*/
 				/* out: child page, x-latched */
-	rec_t*		node_ptr,/* in: node pointer */
+	const rec_t*	node_ptr,/* in: node pointer */
+	dict_index_t*	index,	/* in: index */
 	const ulint*	offsets,/* in: array returned by rec_get_offsets() */
 	mtr_t*		mtr)	/* in: mtr */
 {
 	ulint	page_no;
 	ulint	space;
-	page_t*	page;
 
-	ut_ad(rec_offs_validate(node_ptr, NULL, offsets));
-	space = buf_frame_get_space_id(node_ptr);
+	ut_ad(rec_offs_validate(node_ptr, index, offsets));
+	space = page_get_space_id(page_align(node_ptr));
 	page_no = btr_node_ptr_get_child_page_no(node_ptr, offsets);
 
-	page = btr_page_get(space, page_no, RW_X_LATCH, mtr);
-
-	return(page);
+	return(btr_block_get(space, dict_table_zip_size(index->table),
+			     page_no, RW_X_LATCH, mtr));
 }
 
 /****************************************************************
 Returns the upper level node pointer to a page. It is assumed that mtr holds
 an x-latch on the tree. */
 static
-rec_t*
-btr_page_get_father_for_rec(
-/*========================*/
-				/* out: pointer to node pointer record,
+ulint*
+btr_page_get_father_node_ptr(
+/*=========================*/
+				/* out: rec_get_offsets() of the
+				node pointer record */
+	ulint*		offsets,/* in: work area for the return value */
+	mem_heap_t*	heap,	/* in: memory heap to use */
+	btr_cur_t*	cursor,	/* in: cursor pointing to user record,
+				out: cursor on node pointer record,
 				its page x-latched */
-	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page: must contain at least one
-				user record */
-	rec_t*		user_rec,/* in: user_record on page */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	mem_heap_t*	heap;
 	dtuple_t*	tuple;
-	btr_cur_t	cursor;
+	rec_t*		user_rec;
 	rec_t*		node_ptr;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets	= offsets_;
-	*offsets_ = (sizeof offsets_) / sizeof *offsets_;
+	ulint		level;
+	ulint		page_no;
+	dict_index_t*	index;
+
+	page_no = buf_block_get_page_no(btr_cur_get_block(cursor));
+	index = btr_cur_get_index(cursor);
 
 	ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index),
 				MTR_MEMO_X_LOCK));
+
+	ut_ad(dict_index_get_page(index) != page_no);
+
+	level = btr_page_get_level(btr_cur_get_page(cursor), mtr);
+	user_rec = btr_cur_get_rec(cursor);
 	ut_a(page_rec_is_user_rec(user_rec));
-
-	ut_ad(dict_index_get_page(index) != buf_frame_get_page_no(page));
-
-	heap = mem_heap_create(100);
-
-	tuple = dict_index_build_node_ptr(index, user_rec, 0, heap,
-					  btr_page_get_level(page, mtr));
-
-	btr_cur_search_to_nth_level(index,
-				    btr_page_get_level(page, mtr) + 1,
-				    tuple, PAGE_CUR_LE,
-				    BTR_CONT_MODIFY_TREE, &cursor, 0, mtr);
-
-	node_ptr = btr_cur_get_rec(&cursor);
+	tuple = dict_index_build_node_ptr(index, user_rec, 0, heap, level);
+
+	btr_cur_search_to_nth_level(index, level + 1, tuple, PAGE_CUR_LE,
+				    BTR_CONT_MODIFY_TREE, cursor, 0, mtr);
+
+	node_ptr = btr_cur_get_rec(cursor);
+	ut_ad(!page_rec_is_comp(node_ptr)
+	      || rec_get_status(node_ptr) == REC_STATUS_NODE_PTR);
 	offsets = rec_get_offsets(node_ptr, index, offsets,
 				  ULINT_UNDEFINED, &heap);
 
 	if (UNIV_UNLIKELY(btr_node_ptr_get_child_page_no(node_ptr, offsets)
-			  != buf_frame_get_page_no(page))) {
+			  != page_no)) {
 		rec_t*	print_rec;
 		fputs("InnoDB: Dump of the child page:\n", stderr);
-		buf_page_print(buf_frame_align(page));
+		buf_page_print(page_align(user_rec), 0);
 		fputs("InnoDB: Dump of the parent page:\n", stderr);
-		buf_page_print(buf_frame_align(node_ptr));
+		buf_page_print(page_align(node_ptr), 0);
 
 		fputs("InnoDB: Corruption of an index tree: table ", stderr);
 		ut_print_name(stderr, NULL, TRUE, index->table_name);
@@ -596,8 +645,9 @@
 			"InnoDB: father ptr page no %lu, child page no %lu\n",
 			(ulong)
 			btr_node_ptr_get_child_page_no(node_ptr, offsets),
-			(ulong) buf_frame_get_page_no(page));
-		print_rec = page_rec_get_next(page_get_infimum_rec(page));
+			(ulong) page_no);
+		print_rec = page_rec_get_next(
+			page_get_infimum_rec(page_align(user_rec)));
 		offsets = rec_get_offsets(print_rec, index,
 					  offsets, ULINT_UNDEFINED, &heap);
 		page_rec_print(print_rec, offsets);
@@ -613,51 +663,82 @@
 		      "forcing-recovery.html about\n"
 		      "InnoDB: forcing recovery. "
 		      "Then dump + drop + reimport.\n", stderr);
+
+		ut_error;
 	}
 
-	ut_a(btr_node_ptr_get_child_page_no(node_ptr, offsets)
-	     == buf_frame_get_page_no(page));
+	return(offsets);
+}
+
+/****************************************************************
+Returns the upper level node pointer to a page. It is assumed that mtr holds
+an x-latch on the tree. */
+static
+ulint*
+btr_page_get_father_block(
+/*======================*/
+				/* out: rec_get_offsets() of the
+				node pointer record */
+	ulint*		offsets,/* in: work area for the return value */
+	mem_heap_t*	heap,	/* in: memory heap to use */
+	dict_index_t*	index,	/* in: b-tree index */
+	buf_block_t*	block,	/* in: child page in the index */
+	mtr_t*		mtr,	/* in: mtr */
+	btr_cur_t*	cursor)	/* out: cursor on node pointer record,
+				its page x-latched */
+{
+	rec_t*	rec
+		= page_rec_get_next(page_get_infimum_rec(buf_block_get_frame(
+								 block)));
+	btr_cur_position(index, rec, block, cursor);
+	return(btr_page_get_father_node_ptr(offsets, heap, cursor, mtr));
+}
+
+/****************************************************************
+Seeks to the upper level node pointer to a page.
+It is assumed that mtr holds an x-latch on the tree. */
+static
+void
+btr_page_get_father(
+/*================*/
+	dict_index_t*	index,	/* in: b-tree index */
+	buf_block_t*	block,	/* in: child page in the index */
+	mtr_t*		mtr,	/* in: mtr */
+	btr_cur_t*	cursor)	/* out: cursor on node pointer record,
+				its page x-latched */
+{
+	mem_heap_t*	heap;
+	rec_t*		rec
+		= page_rec_get_next(page_get_infimum_rec(buf_block_get_frame(
+								 block)));
+	btr_cur_position(index, rec, block, cursor);
+
+	heap = mem_heap_create(100);
+	btr_page_get_father_node_ptr(NULL, heap, cursor, mtr);
 	mem_heap_free(heap);
-
-	return(node_ptr);
-}
-
-/****************************************************************
-Returns the upper level node pointer to a page. It is assumed that
-mtr holds an x-latch on the tree. */
-static
-rec_t*
-btr_page_get_father_node_ptr(
-/*=========================*/
-				/* out: pointer to node pointer record */
-	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page: must contain at least one
-				user record */
-	mtr_t*		mtr)	/* in: mtr */
-{
-	return(btr_page_get_father_for_rec(
-		       index, page,
-		       page_rec_get_next(page_get_infimum_rec(page)), mtr));
 }
 
 /****************************************************************
 Creates the root node for a new index tree. */
-
+UNIV_INTERN
 ulint
 btr_create(
 /*=======*/
-			/* out: page number of the created root, FIL_NULL if
-			did not succeed */
-	ulint	type,	/* in: type of the index */
-	ulint	space,	/* in: space where created */
-	dulint	index_id,/* in: index id */
-	ulint	comp,	/* in: nonzero=compact page format */
-	mtr_t*	mtr)	/* in: mini-transaction handle */
+				/* out: page number of the created root,
+				FIL_NULL if did not succeed */
+	ulint		type,	/* in: type of the index */
+	ulint		space,	/* in: space where created */
+	ulint		zip_size,/* in: compressed page size in bytes
+				or 0 for uncompressed pages */
+	dulint		index_id,/* in: index id */
+	dict_index_t*	index,	/* in: index */
+	mtr_t*		mtr)	/* in: mini-transaction handle */
 {
 	ulint		page_no;
-	buf_frame_t*	ibuf_hdr_frame;
+	buf_block_t*	block;
 	buf_frame_t*	frame;
 	page_t*		page;
+	page_zip_des_t*	page_zip;
 
 	/* Create the two new segments (one, in the case of an ibuf tree) for
 	the index tree; the segment headers are put on the allocated root page
@@ -666,39 +747,41 @@
 
 	if (type & DICT_IBUF) {
 		/* Allocate first the ibuf header page */
-		ibuf_hdr_frame = fseg_create(
-			space, 0, IBUF_HEADER + IBUF_TREE_SEG_HEADER, mtr);
-
-#ifdef UNIV_SYNC_DEBUG
-		buf_page_dbg_add_level(ibuf_hdr_frame, SYNC_TREE_NODE_NEW);
-#endif /* UNIV_SYNC_DEBUG */
-		ut_ad(buf_frame_get_page_no(ibuf_hdr_frame)
+		buf_block_t*	ibuf_hdr_block = fseg_create(
+			space, 0,
+			IBUF_HEADER + IBUF_TREE_SEG_HEADER, mtr);
+
+		buf_block_dbg_add_level(ibuf_hdr_block, SYNC_TREE_NODE_NEW);
+
+		ut_ad(buf_block_get_page_no(ibuf_hdr_block)
 		      == IBUF_HEADER_PAGE_NO);
 		/* Allocate then the next page to the segment: it will be the
 		tree root page */
 
-		page_no = fseg_alloc_free_page(ibuf_hdr_frame + IBUF_HEADER
+		page_no = fseg_alloc_free_page(buf_block_get_frame(
+						       ibuf_hdr_block)
+					       + IBUF_HEADER
 					       + IBUF_TREE_SEG_HEADER,
 					       IBUF_TREE_ROOT_PAGE_NO,
 					       FSP_UP, mtr);
 		ut_ad(page_no == IBUF_TREE_ROOT_PAGE_NO);
 
-		frame = buf_page_get(space, page_no, RW_X_LATCH, mtr);
+		block = buf_page_get(space, zip_size, page_no,
+				     RW_X_LATCH, mtr);
 	} else {
-		frame = fseg_create(space, 0, PAGE_HEADER + PAGE_BTR_SEG_TOP,
-				    mtr);
+		block = fseg_create(space, 0,
+				    PAGE_HEADER + PAGE_BTR_SEG_TOP, mtr);
 	}
 
-	if (frame == NULL) {
+	if (block == NULL) {
 
 		return(FIL_NULL);
 	}
 
-	page_no = buf_frame_get_page_no(frame);
+	page_no = buf_block_get_page_no(block);
+	frame = buf_block_get_frame(block);
 
-#ifdef UNIV_SYNC_DEBUG
-	buf_page_dbg_add_level(frame, SYNC_TREE_NODE_NEW);
-#endif /* UNIV_SYNC_DEBUG */
+	buf_block_dbg_add_level(block, SYNC_TREE_NODE_NEW);
 
 	if (type & DICT_IBUF) {
 		/* It is an insert buffer tree: initialize the free list */
@@ -709,34 +792,41 @@
 	} else {
 		/* It is a non-ibuf tree: create a file segment for leaf
 		pages */
-		fseg_create(space, page_no, PAGE_HEADER + PAGE_BTR_SEG_LEAF,
-			    mtr);
+		fseg_create(space, page_no,
+			    PAGE_HEADER + PAGE_BTR_SEG_LEAF, mtr);
 		/* The fseg create acquires a second latch on the page,
 		therefore we must declare it: */
-#ifdef UNIV_SYNC_DEBUG
-		buf_page_dbg_add_level(frame, SYNC_TREE_NODE_NEW);
-#endif /* UNIV_SYNC_DEBUG */
+		buf_block_dbg_add_level(block, SYNC_TREE_NODE_NEW);
 	}
 
 	/* Create a new index page on the the allocated segment page */
-	page = page_create(frame, mtr, comp);
-	buf_block_align(page)->check_index_page_at_flush = TRUE;
+	page_zip = buf_block_get_page_zip(block);
+
+	if (UNIV_LIKELY_NULL(page_zip)) {
+		page = page_create_zip(block, index, 0, mtr);
+	} else {
+		page = page_create(block, mtr,
+				   dict_table_is_comp(index->table));
+		/* Set the level of the new index page */
+		btr_page_set_level(page, NULL, 0, mtr);
+	}
+
+	block->check_index_page_at_flush = TRUE;
 
 	/* Set the index id of the page */
-	btr_page_set_index_id(page, index_id, mtr);
-
-	/* Set the level of the new index page */
-	btr_page_set_level(page, 0, mtr);
+	btr_page_set_index_id(page, page_zip, index_id, mtr);
 
 	/* Set the next node and previous node fields */
-	btr_page_set_next(page, FIL_NULL, mtr);
-	btr_page_set_prev(page, FIL_NULL, mtr);
+	btr_page_set_next(page, page_zip, FIL_NULL, mtr);
+	btr_page_set_prev(page, page_zip, FIL_NULL, mtr);
 
 	/* We reset the free bits for the page to allow creation of several
 	trees in the same mtr, otherwise the latch on a bitmap page would
 	prevent it because of the latching order */
 
-	ibuf_reset_free_bits_with_type(type, page);
+	if (!(type & DICT_CLUSTERED)) {
+		ibuf_reset_free_bits(block);
+	}
 
 	/* In the following assertion we test that two records of maximum
 	allowed size fit on the root page: this fact is needed to ensure
@@ -750,11 +840,13 @@
 /****************************************************************
 Frees a B-tree except the root page, which MUST be freed after this
 by calling btr_free_root. */
-
+UNIV_INTERN
 void
 btr_free_but_not_root(
 /*==================*/
 	ulint	space,		/* in: space where created */
+	ulint	zip_size,	/* in: compressed page size in bytes
+				or 0 for uncompressed pages */
 	ulint	root_page_no)	/* in: root page number */
 {
 	ibool	finished;
@@ -764,7 +856,13 @@
 leaf_loop:
 	mtr_start(&mtr);
 
-	root = btr_page_get(space, root_page_no, RW_X_LATCH, &mtr);
+	root = btr_page_get(space, zip_size, root_page_no, RW_X_LATCH, &mtr);
+#ifdef UNIV_BTR_DEBUG
+	ut_a(btr_root_fseg_validate(FIL_PAGE_DATA + PAGE_BTR_SEG_LEAF
+				    + root, space));
+	ut_a(btr_root_fseg_validate(FIL_PAGE_DATA + PAGE_BTR_SEG_TOP
+				    + root, space));
+#endif /* UNIV_BTR_DEBUG */
 
 	/* NOTE: page hash indexes are dropped when a page is freed inside
 	fsp0fsp. */
@@ -780,7 +878,11 @@
 top_loop:
 	mtr_start(&mtr);
 
-	root = btr_page_get(space, root_page_no, RW_X_LATCH, &mtr);
+	root = btr_page_get(space, zip_size, root_page_no, RW_X_LATCH, &mtr);
+#ifdef UNIV_BTR_DEBUG
+	ut_a(btr_root_fseg_validate(FIL_PAGE_DATA + PAGE_BTR_SEG_TOP
+				    + root, space));
+#endif /* UNIV_BTR_DEBUG */
 
 	finished = fseg_free_step_not_header(
 		root + PAGE_HEADER + PAGE_BTR_SEG_TOP, &mtr);
@@ -794,33 +896,36 @@
 
 /****************************************************************
 Frees the B-tree root page. Other tree MUST already have been freed. */
-
+UNIV_INTERN
 void
 btr_free_root(
 /*==========*/
 	ulint	space,		/* in: space where created */
+	ulint	zip_size,	/* in: compressed page size in bytes
+				or 0 for uncompressed pages */
 	ulint	root_page_no,	/* in: root page number */
 	mtr_t*	mtr)		/* in: a mini-transaction which has already
 				been started */
 {
-	ibool	finished;
-	page_t*	root;
-
-	root = btr_page_get(space, root_page_no, RW_X_LATCH, mtr);
-
-	btr_search_drop_page_hash_index(root);
-top_loop:
-	finished = fseg_free_step(root + PAGE_HEADER + PAGE_BTR_SEG_TOP, mtr);
-	if (!finished) {
-
-		goto top_loop;
-	}
+	buf_block_t*	block;
+	fseg_header_t*	header;
+
+	block = btr_block_get(space, zip_size, root_page_no, RW_X_LATCH, mtr);
+
+	btr_search_drop_page_hash_index(block);
+
+	header = buf_block_get_frame(block) + PAGE_HEADER + PAGE_BTR_SEG_TOP;
+#ifdef UNIV_BTR_DEBUG
+	ut_a(btr_root_fseg_validate(header, space));
+#endif /* UNIV_BTR_DEBUG */
+
+	while (!fseg_free_step(header, mtr));
 }
 
 /*****************************************************************
 Reorganizes an index page. */
 static
-void
+ibool
 btr_page_reorganize_low(
 /*====================*/
 	ibool		recovery,/* in: TRUE if called in recovery:
@@ -828,20 +933,26 @@
 				there cannot exist locks on the
 				page, and a hash index should not be
 				dropped: it cannot exist */
-	page_t*		page,	/* in: page to be reorganized */
+	buf_block_t*	block,	/* in: page to be reorganized */
 	dict_index_t*	index,	/* in: record descriptor */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	page_t*	new_page;
-	ulint	log_mode;
-	ulint	data_size1;
-	ulint	data_size2;
-	ulint	max_ins_size1;
-	ulint	max_ins_size2;
+	page_t*		page		= buf_block_get_frame(block);
+	page_zip_des_t*	page_zip	= buf_block_get_page_zip(block);
+	buf_block_t*	temp_block;
+	page_t*		temp_page;
+	ulint		log_mode;
+	ulint		data_size1;
+	ulint		data_size2;
+	ulint		max_ins_size1;
+	ulint		max_ins_size2;
+	ibool		success		= FALSE;
 
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 	ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table));
+#ifdef UNIV_ZIP_DEBUG
+	ut_a(!page_zip || page_zip_validate(page_zip, page));
+#endif /* UNIV_ZIP_DEBUG */
 	data_size1 = page_get_data_size(page);
 	max_ins_size1 = page_get_max_insert_size_after_reorganize(page, 1);
 
@@ -853,41 +964,53 @@
 	/* Turn logging off */
 	log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
 
-	new_page = buf_frame_alloc();
+	temp_block = buf_block_alloc(0);
+	temp_page = temp_block->frame;
 
 	/* Copy the old page to temporary space */
-	buf_frame_copy(new_page, page);
+	buf_frame_copy(temp_page, page);
 
-	if (!recovery) {
-		btr_search_drop_page_hash_index(page);
+	if (UNIV_LIKELY(!recovery)) {
+		btr_search_drop_page_hash_index(block);
 	}
 
 	/* Recreate the page: note that global data on page (possible
 	segment headers, next page-field, etc.) is preserved intact */
 
-	page_create(page, mtr, page_is_comp(page));
-	buf_block_align(page)->check_index_page_at_flush = TRUE;
+	page_create(block, mtr, dict_table_is_comp(index->table));
+	block->check_index_page_at_flush = TRUE;
 
 	/* Copy the records from the temporary space to the recreated page;
 	do not copy the lock bits yet */
 
-	page_copy_rec_list_end_no_locks(page, new_page,
-					page_get_infimum_rec(new_page),
+	page_copy_rec_list_end_no_locks(block, temp_block,
+					page_get_infimum_rec(temp_page),
 					index, mtr);
 	/* Copy max trx id to recreated page */
-	page_set_max_trx_id(page, page_get_max_trx_id(new_page));
-
-	if (!recovery) {
+	page_set_max_trx_id(block, NULL, page_get_max_trx_id(temp_page));
+
+	if (UNIV_LIKELY_NULL(page_zip)
+	    && UNIV_UNLIKELY
+	    (!page_zip_compress(page_zip, page, index, NULL))) {
+
+		/* Restore the old page and exit. */
+		buf_frame_copy(page, temp_page);
+
+		goto func_exit;
+	}
+
+	if (UNIV_LIKELY(!recovery)) {
 		/* Update the record lock bitmaps */
-		lock_move_reorganize_page(page, new_page);
+		lock_move_reorganize_page(block, temp_block);
 	}
 
 	data_size2 = page_get_data_size(page);
 	max_ins_size2 = page_get_max_insert_size_after_reorganize(page, 1);
 
-	if (data_size1 != data_size2 || max_ins_size1 != max_ins_size2) {
-		buf_page_print(page);
-		buf_page_print(new_page);
+	if (UNIV_UNLIKELY(data_size1 != data_size2)
+	    || UNIV_UNLIKELY(max_ins_size1 != max_ins_size2)) {
+		buf_page_print(page, 0);
+		buf_page_print(temp_page, 0);
 		fprintf(stderr,
 			"InnoDB: Error: page old data size %lu"
 			" new data size %lu\n"
@@ -898,30 +1021,43 @@
 			(unsigned long) data_size1, (unsigned long) data_size2,
 			(unsigned long) max_ins_size1,
 			(unsigned long) max_ins_size2);
+	} else {
+		success = TRUE;
 	}
 
-	buf_frame_free(new_page);
+func_exit:
+#ifdef UNIV_ZIP_DEBUG
+	ut_a(!page_zip || page_zip_validate(page_zip, page));
+#endif /* UNIV_ZIP_DEBUG */
+	buf_block_free(temp_block);
 
 	/* Restore logging mode */
 	mtr_set_log_mode(mtr, log_mode);
+
+	return(success);
 }
 
 /*****************************************************************
-Reorganizes an index page. */
-
-void
+Reorganizes an index page.
+IMPORTANT: if btr_page_reorganize() is invoked on a compressed leaf
+page of a non-clustered index, the caller must update the insert
+buffer free bits in the same mini-transaction in such a way that the
+modification will be redo-logged. */
+UNIV_INTERN
+ibool
 btr_page_reorganize(
 /*================*/
-	page_t*		page,	/* in: page to be reorganized */
+				/* out: TRUE on success, FALSE on failure */
+	buf_block_t*	block,	/* in: page to be reorganized */
 	dict_index_t*	index,	/* in: record descriptor */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	btr_page_reorganize_low(FALSE, page, index, mtr);
+	return(btr_page_reorganize_low(FALSE, block, index, mtr));
 }
 
 /***************************************************************
 Parses a redo log record of reorganizing a page. */
-
+UNIV_INTERN
 byte*
 btr_parse_page_reorganize(
 /*======================*/
@@ -930,38 +1066,53 @@
 	byte*		end_ptr __attribute__((unused)),
 				/* in: buffer end */
 	dict_index_t*	index,	/* in: record descriptor */
-	page_t*		page,	/* in: page or NULL */
+	buf_block_t*	block,	/* in: page to be reorganized, or NULL */
 	mtr_t*		mtr)	/* in: mtr or NULL */
 {
 	ut_ad(ptr && end_ptr);
 
 	/* The record is empty, except for the record initial part */
 
-	if (page) {
-		btr_page_reorganize_low(TRUE, page, index, mtr);
+	if (UNIV_LIKELY(block != NULL)) {
+		btr_page_reorganize_low(TRUE, block, index, mtr);
 	}
 
 	return(ptr);
 }
 
 /*****************************************************************
-Empties an index page. */
+Empties an index page.  @see btr_page_create().*/
 static
 void
 btr_page_empty(
 /*===========*/
-	page_t*	page,	/* in: page to be emptied */
-	mtr_t*	mtr)	/* in: mtr */
+	buf_block_t*	block,	/* in: page to be emptied */
+	page_zip_des_t*	page_zip,/* out: compressed page, or NULL */
+	dict_index_t*	index,	/* in: index of the page */
+	ulint		level,	/* in: the B-tree level of the page */
+	mtr_t*		mtr)	/* in: mtr */
 {
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
-	btr_search_drop_page_hash_index(page);
+	page_t*	page = buf_block_get_frame(block);
+
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+	ut_ad(page_zip == buf_block_get_page_zip(block));
+#ifdef UNIV_ZIP_DEBUG
+	ut_a(!page_zip || page_zip_validate(page_zip, page));
+#endif /* UNIV_ZIP_DEBUG */
+
+	btr_search_drop_page_hash_index(block);
 
 	/* Recreate the page: note that global data on page (possible
 	segment headers, next page-field, etc.) is preserved intact */
 
-	page_create(page, mtr, page_is_comp(page));
-	buf_block_align(page)->check_index_page_at_flush = TRUE;
+	if (UNIV_LIKELY_NULL(page_zip)) {
+		page_create_zip(block, index, level, mtr);
+	} else {
+		page_create(block, mtr, dict_table_is_comp(index->table));
+		btr_page_set_level(page, NULL, level, mtr);
+	}
+
+	block->check_index_page_at_flush = TRUE;
 }
 
 /*****************************************************************
@@ -970,7 +1121,7 @@
 NOTE that the operation of this function must always succeed,
 we cannot reverse it: therefore enough free disk space must be
 guaranteed to be available before this function is called. */
-
+UNIV_INTERN
 rec_t*
 btr_root_raise_and_insert(
 /*======================*/
@@ -979,7 +1130,8 @@
 				on the root page; when the function returns,
 				the cursor is positioned on the predecessor
 				of the inserted record */
-	dtuple_t*	tuple,	/* in: tuple to insert */
+	const dtuple_t*	tuple,	/* in: tuple to insert */
+	ulint		n_ext,	/* in: number of externally stored columns */
 	mtr_t*		mtr)	/* in: mtr */
 {
 	dict_index_t*	index;
@@ -992,77 +1144,127 @@
 	ulint		level;
 	rec_t*		node_ptr_rec;
 	page_cur_t*	page_cursor;
+	page_zip_des_t*	root_page_zip;
+	page_zip_des_t*	new_page_zip;
+	buf_block_t*	root_block;
+	buf_block_t*	new_block;
 
 	root = btr_cur_get_page(cursor);
+	root_block = btr_cur_get_block(cursor);
+	root_page_zip = buf_block_get_page_zip(root_block);
+#ifdef UNIV_ZIP_DEBUG
+	ut_a(!root_page_zip || page_zip_validate(root_page_zip, root));
+#endif /* UNIV_ZIP_DEBUG */
 	index = btr_cur_get_index(cursor);
-
-	ut_ad(dict_index_get_page(index) == buf_frame_get_page_no(root));
+#ifdef UNIV_BTR_DEBUG
+	if (!dict_index_is_ibuf(index)) {
+		ulint	space = dict_index_get_space(index);
+
+		ut_a(btr_root_fseg_validate(FIL_PAGE_DATA + PAGE_BTR_SEG_LEAF
+					    + root, space));
+		ut_a(btr_root_fseg_validate(FIL_PAGE_DATA + PAGE_BTR_SEG_TOP
+					    + root, space));
+	}
+
+	ut_a(dict_index_get_page(index) == page_get_page_no(root));
+#endif /* UNIV_BTR_DEBUG */
 	ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index),
 				MTR_MEMO_X_LOCK));
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(root),
-				MTR_MEMO_PAGE_X_FIX));
-	btr_search_drop_page_hash_index(root);
+	ut_ad(mtr_memo_contains(mtr, root_block, MTR_MEMO_PAGE_X_FIX));
 
 	/* Allocate a new page to the tree. Root splitting is done by first
 	moving the root records to the new page, emptying the root, putting
 	a node pointer to the new page, and then splitting the new page. */
 
-	new_page = btr_page_alloc(index, 0, FSP_NO_DIR,
-				  btr_page_get_level(root, mtr), mtr);
-
-	btr_page_create(new_page, index, mtr);
-
 	level = btr_page_get_level(root, mtr);
 
-	/* Set the levels of the new index page and root page */
-	btr_page_set_level(new_page, level, mtr);
-	btr_page_set_level(root, level + 1, mtr);
+	new_block = btr_page_alloc(index, 0, FSP_NO_DIR, level, mtr);
+	new_page = buf_block_get_frame(new_block);
+	new_page_zip = buf_block_get_page_zip(new_block);
+	ut_a(!new_page_zip == !root_page_zip);
+	ut_a(!new_page_zip
+	     || page_zip_get_size(new_page_zip)
+	     == page_zip_get_size(root_page_zip));
+
+	btr_page_create(new_block, new_page_zip, index, level, mtr);
 
 	/* Set the next node and previous node fields of new page */
-	btr_page_set_next(new_page, FIL_NULL, mtr);
-	btr_page_set_prev(new_page, FIL_NULL, mtr);
-
-	/* Move the records from root to the new page */
-
-	page_move_rec_list_end(new_page, root, page_get_infimum_rec(root),
-			       index, mtr);
+	btr_page_set_next(new_page, new_page_zip, FIL_NULL, mtr);
+	btr_page_set_prev(new_page, new_page_zip, FIL_NULL, mtr);
+
+	/* Copy the records from root to the new page one by one. */
+
+	if (0
+#ifdef UNIV_ZIP_COPY
+	    || new_page_zip
+#endif /* UNIV_ZIP_COPY */
+	    || UNIV_UNLIKELY
+	    (!page_copy_rec_list_end(new_block, root_block,
+				     page_get_infimum_rec(root),
+				     index, mtr))) {
+		ut_a(new_page_zip);
+
+		/* Copy the page byte for byte. */
+		page_zip_copy_recs(new_page_zip, new_page,
+				   root_page_zip, root, index, mtr);
+
+		/* Update the lock table and possible hash index. */
+
+		lock_move_rec_list_end(new_block, root_block,
+				       page_get_infimum_rec(root));
+
+		btr_search_move_or_delete_hash_entries(new_block, root_block,
+						       index);
+	}
+
 	/* If this is a pessimistic insert which is actually done to
 	perform a pessimistic update then we have stored the lock
 	information of the record to be inserted on the infimum of the
 	root page: we cannot discard the lock structs on the root page */
 
-	lock_update_root_raise(new_page, root);
+	lock_update_root_raise(new_block, root_block);
 
 	/* Create a memory heap where the node pointer is stored */
 	heap = mem_heap_create(100);
 
 	rec = page_rec_get_next(page_get_infimum_rec(new_page));
-	new_page_no = buf_frame_get_page_no(new_page);
+	new_page_no = buf_block_get_page_no(new_block);
 
 	/* Build the node pointer (= node key and page address) for the
 	child */
 
 	node_ptr = dict_index_build_node_ptr(index, rec, new_page_no, heap,
 					     level);
-	/* Reorganize the root to get free space */
-	btr_page_reorganize(root, index, mtr);
-
-	page_cursor = btr_cur_get_page_cur(cursor);
-
-	/* Insert node pointer to the root */
-
-	page_cur_set_before_first(root, page_cursor);
-
-	node_ptr_rec = page_cur_tuple_insert(page_cursor, node_ptr,
-					     index, mtr);
-
-	ut_ad(node_ptr_rec);
-
 	/* The node pointer must be marked as the predefined minimum record,
 	as there is no lower alphabetical limit to records in the leftmost
 	node of a level: */
-
-	btr_set_min_rec_mark(node_ptr_rec, page_is_comp(root), mtr);
+	dtuple_set_info_bits(node_ptr,
+			     dtuple_get_info_bits(node_ptr)
+			     | REC_INFO_MIN_REC_FLAG);
+
+	/* Rebuild the root page to get free space */
+	btr_page_empty(root_block, root_page_zip, index, level + 1, mtr);
+
+	/* Set the next node and previous node fields, although
+	they should already have been set.  The previous node field
+	must be FIL_NULL if root_page_zip != NULL, because the
+	REC_INFO_MIN_REC_FLAG (of the first user record) will be
+	set if and only if btr_page_get_prev() == FIL_NULL. */
+	btr_page_set_next(root, root_page_zip, FIL_NULL, mtr);
+	btr_page_set_prev(root, root_page_zip, FIL_NULL, mtr);
+
+	page_cursor = btr_cur_get_page_cur(cursor);
+
+	/* Insert node pointer to the root */
+
+	page_cur_set_before_first(root_block, page_cursor);
+
+	node_ptr_rec = page_cur_tuple_insert(page_cursor, node_ptr,
+					     index, 0, mtr);
+
+	/* The root page should only contain the node pointer
+	to new_page at this point.  Thus, the data should fit. */
+	ut_a(node_ptr_rec);
 
 	/* Free the memory heap */
 	mem_heap_free(heap);
@@ -1070,23 +1272,25 @@
 	/* We play safe and reset the free bits for the new page */
 
 #if 0
-	fprintf(stderr, "Root raise new page no %lu\n",
-		buf_frame_get_page_no(new_page));
+	fprintf(stderr, "Root raise new page no %lu\n", new_page_no);
 #endif
 
-	ibuf_reset_free_bits(index, new_page);
+	if (!dict_index_is_clust(index)) {
+		ibuf_reset_free_bits(new_block);
+	}
+
 	/* Reposition the cursor to the child node */
-	page_cur_search(new_page, index, tuple,
+	page_cur_search(new_block, index, tuple,
 			PAGE_CUR_LE, page_cursor);
 
 	/* Split the child and insert tuple */
-	return(btr_page_split_and_insert(cursor, tuple, mtr));
+	return(btr_page_split_and_insert(cursor, tuple, n_ext, mtr));
 }
 
 /*****************************************************************
 Decides if the page should be split at the convergence point of inserts
 converging to the left. */
-
+UNIV_INTERN
 ibool
 btr_page_get_split_rec_to_left(
 /*===========================*/
@@ -1131,7 +1335,7 @@
 /*****************************************************************
 Decides if the page should be split at the convergence point of inserts
 converging to the right. */
-
+UNIV_INTERN
 ibool
 btr_page_get_split_rec_to_right(
 /*============================*/
@@ -1194,32 +1398,44 @@
 rec_t*
 btr_page_get_sure_split_rec(
 /*========================*/
-					/* out: split record, or NULL if
-					tuple will be the first record on
-					upper half-page */
-	btr_cur_t*	cursor,		/* in: cursor at which insert
-					should be made */
-	dtuple_t*	tuple)		/* in: tuple to insert */
+				/* out: split record, or NULL if tuple
+				will be the first record on upper half-page */
+	btr_cur_t*	cursor,	/* in: cursor at which insert should be made */
+	const dtuple_t*	tuple,	/* in: tuple to insert */
+	ulint		n_ext)	/* in: number of externally stored columns */
 {
-	page_t*	page;
-	ulint	insert_size;
-	ulint	free_space;
-	ulint	total_data;
-	ulint	total_n_recs;
-	ulint	total_space;
-	ulint	incl_data;
-	rec_t*	ins_rec;
-	rec_t*	rec;
-	rec_t*	next_rec;
-	ulint	n;
-	mem_heap_t* heap;
-	ulint*	offsets;
+	page_t*		page;
+	page_zip_des_t*	page_zip;
+	ulint		insert_size;
+	ulint		free_space;
+	ulint		total_data;
+	ulint		total_n_recs;
+	ulint		total_space;
+	ulint		incl_data;
+	rec_t*		ins_rec;
+	rec_t*		rec;
+	rec_t*		next_rec;
+	ulint		n;
+	mem_heap_t*	heap;
+	ulint*		offsets;
 
 	page = btr_cur_get_page(cursor);
 
-	insert_size = rec_get_converted_size(cursor->index, tuple);
+	insert_size = rec_get_converted_size(cursor->index, tuple, n_ext);
 	free_space  = page_get_free_space_of_empty(page_is_comp(page));
 
+	page_zip = btr_cur_get_page_zip(cursor);
+	if (UNIV_LIKELY_NULL(page_zip)) {
+		/* Estimate the free space of an empty compressed page. */
+		ulint	free_space_zip = page_zip_empty_size(
+			cursor->index->n_fields,
+			page_zip_get_size(page_zip));
+
+		if (UNIV_LIKELY(free_space > (ulint) free_space_zip)) {
+			free_space = (ulint) free_space_zip;
+		}
+	}
+
 	/* free_space is now the free space of a created new page */
 
 	total_data   = page_get_data_size(page) + insert_size;
@@ -1242,7 +1458,7 @@
 	otherwise the last included record will be the first on the right
 	half page */
 
-	for (;;) {
+	do {
 		/* Decide the next record to include */
 		if (rec == ins_rec) {
 			rec = NULL;	/* NULL denotes that tuple is
@@ -1264,38 +1480,34 @@
 		}
 
 		n++;
-
-		if (incl_data + page_dir_calc_reserved_space(n)
-		    >= total_space / 2) {
-
-			if (incl_data + page_dir_calc_reserved_space(n)
-			    <= free_space) {
-				/* The next record will be the first on
-				the right half page if it is not the
-				supremum record of page */
-
-				if (rec == ins_rec) {
-					rec = NULL;
-
-					goto func_exit;
-				} else if (rec == NULL) {
-					next_rec = page_rec_get_next(ins_rec);
-				} else {
-					next_rec = page_rec_get_next(rec);
-				}
-				ut_ad(next_rec);
-				if (!page_rec_is_supremum(next_rec)) {
-					rec = next_rec;
-				}
-			}
+	} while (incl_data + page_dir_calc_reserved_space(n)
+		 < total_space / 2);
+
+	if (incl_data + page_dir_calc_reserved_space(n) <= free_space) {
+		/* The next record will be the first on
+		the right half page if it is not the
+		supremum record of page */
+
+		if (rec == ins_rec) {
+			rec = NULL;
+
+			goto func_exit;
+		} else if (rec == NULL) {
+			next_rec = page_rec_get_next(ins_rec);
+		} else {
+			next_rec = page_rec_get_next(rec);
+		}
+		ut_ad(next_rec);
+		if (!page_rec_is_supremum(next_rec)) {
+			rec = next_rec;
+		}
+	}
 
 func_exit:
-			if (UNIV_LIKELY_NULL(heap)) {
-				mem_heap_free(heap);
-			}
-			return(rec);
-		}
+	if (UNIV_LIKELY_NULL(heap)) {
+		mem_heap_free(heap);
 	}
+	return(rec);
 }
 
 /*****************************************************************
@@ -1305,25 +1517,26 @@
 ibool
 btr_page_insert_fits(
 /*=================*/
-					/* out: TRUE if fits */
-	btr_cur_t*	cursor,		/* in: cursor at which insert
-					should be made */
-	rec_t*		split_rec,	/* in: suggestion for first record
-					on upper half-page, or NULL if
-					tuple to be inserted should be first */
-	const ulint*	offsets,	/* in: rec_get_offsets(
-					split_rec, cursor->index) */
-	dtuple_t*	tuple,		/* in: tuple to insert */
-	mem_heap_t*	heap)		/* in: temporary memory heap */
+				/* out: TRUE if fits */
+	btr_cur_t*	cursor,	/* in: cursor at which insert
+				should be made */
+	const rec_t*	split_rec,/* in: suggestion for first record
+				on upper half-page, or NULL if
+				tuple to be inserted should be first */
+	const ulint*	offsets,/* in: rec_get_offsets(
+				split_rec, cursor->index) */
+	const dtuple_t*	tuple,	/* in: tuple to insert */
+	ulint		n_ext,	/* in: number of externally stored columns */
+	mem_heap_t*	heap)	/* in: temporary memory heap */
 {
-	page_t*	page;
-	ulint	insert_size;
-	ulint	free_space;
-	ulint	total_data;
-	ulint	total_n_recs;
-	rec_t*	rec;
-	rec_t*	end_rec;
-	ulint*	offs;
+	page_t*		page;
+	ulint		insert_size;
+	ulint		free_space;
+	ulint		total_data;
+	ulint		total_n_recs;
+	const rec_t*	rec;
+	const rec_t*	end_rec;
+	ulint*		offs;
 
 	page = btr_cur_get_page(cursor);
 
@@ -1333,7 +1546,7 @@
 	ut_ad(!offsets
 	      || rec_offs_validate(split_rec, cursor->index, offsets));
 
-	insert_size = rec_get_converted_size(cursor->index, tuple);
+	insert_size = rec_get_converted_size(cursor->index, tuple, n_ext);
 	free_space  = page_get_free_space_of_empty(page_is_comp(page));
 
 	/* free_space is now the free space of a created new page */
@@ -1388,7 +1601,7 @@
 			return(TRUE);
 		}
 
-		rec = page_rec_get_next(rec);
+		rec = page_rec_get_next_const(rec);
 	}
 
 	return(FALSE);
@@ -1397,7 +1610,7 @@
 /***********************************************************
 Inserts a data tuple to a tree on a non-leaf level. It is assumed
 that mtr holds an x-latch on the tree. */
-
+UNIV_INTERN
 void
 btr_insert_on_non_leaf_level(
 /*=========================*/
@@ -1421,7 +1634,7 @@
 					 | BTR_KEEP_SYS_FLAG
 					 | BTR_NO_UNDO_LOG_FLAG,
 					 &cursor, tuple, &rec,
-					 &dummy_big_rec, NULL, mtr);
+					 &dummy_big_rec, 0, NULL, mtr);
 	ut_a(err == DB_SUCCESS);
 }
 
@@ -1433,32 +1646,30 @@
 btr_attach_half_pages(
 /*==================*/
 	dict_index_t*	index,		/* in: the index tree */
-	page_t*		page,		/* in: page to be split */
+	buf_block_t*	block,		/* in/out: page to be split */
 	rec_t*		split_rec,	/* in: first record on upper
 					half page */
-	page_t*		new_page,	/* in: the new half page */
+	buf_block_t*	new_block,	/* in/out: the new half page */
 	ulint		direction,	/* in: FSP_UP or FSP_DOWN */
 	mtr_t*		mtr)		/* in: mtr */
 {
 	ulint		space;
-	rec_t*		node_ptr;
-	page_t*		prev_page;
-	page_t*		next_page;
+	ulint		zip_size;
 	ulint		prev_page_no;
 	ulint		next_page_no;
 	ulint		level;
+	page_t*		page		= buf_block_get_frame(block);
 	page_t*		lower_page;
 	page_t*		upper_page;
 	ulint		lower_page_no;
 	ulint		upper_page_no;
+	page_zip_des_t*	lower_page_zip;
+	page_zip_des_t*	upper_page_zip;
 	dtuple_t*	node_ptr_upper;
 	mem_heap_t*	heap;
 
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(new_page),
-				MTR_MEMO_PAGE_X_FIX));
-	ut_a(page_is_comp(page) == page_is_comp(new_page));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains(mtr, new_block, MTR_MEMO_PAGE_X_FIX));
 
 	/* Create a memory heap where the data tuple is stored */
 	heap = mem_heap_create(1024);
@@ -1466,33 +1677,41 @@
 	/* Based on split direction, decide upper and lower pages */
 	if (direction == FSP_DOWN) {
 
-		lower_page_no = buf_frame_get_page_no(new_page);
-		upper_page_no = buf_frame_get_page_no(page);
-		lower_page = new_page;
-		upper_page = page;
+		btr_cur_t	cursor;
+		ulint*		offsets;
+
+		lower_page = buf_block_get_frame(new_block);
+		lower_page_no = buf_block_get_page_no(new_block);
+		lower_page_zip = buf_block_get_page_zip(new_block);
+		upper_page = buf_block_get_frame(block);
+		upper_page_no = buf_block_get_page_no(block);
+		upper_page_zip = buf_block_get_page_zip(block);
 
 		/* Look up the index for the node pointer to page */
-		node_ptr = btr_page_get_father_node_ptr(index, page, mtr);
+		offsets = btr_page_get_father_block(NULL, heap, index,
+						    block, mtr, &cursor);
 
 		/* Replace the address of the old child node (= page) with the
 		address of the new lower half */
 
-		btr_node_ptr_set_child_page_no(node_ptr,
-					       rec_get_offsets(
-						       node_ptr, index,
-						       NULL, ULINT_UNDEFINED,
-						       &heap),
-					       lower_page_no, mtr);
+		btr_node_ptr_set_child_page_no(
+			btr_cur_get_rec(&cursor),
+			btr_cur_get_page_zip(&cursor),
+			offsets, lower_page_no, mtr);
 		mem_heap_empty(heap);
 	} else {
-		lower_page_no = buf_frame_get_page_no(page);
-		upper_page_no = buf_frame_get_page_no(new_page);
-		lower_page = page;
-		upper_page = new_page;
+		lower_page = buf_block_get_frame(block);
+		lower_page_no = buf_block_get_page_no(block);
+		lower_page_zip = buf_block_get_page_zip(block);
+		upper_page = buf_block_get_frame(new_block);
+		upper_page_no = buf_block_get_page_no(new_block);
+		upper_page_zip = buf_block_get_page_zip(new_block);
 	}
 
 	/* Get the level of the split pages */
-	level = btr_page_get_level(page, mtr);
+	level = btr_page_get_level(buf_block_get_frame(block), mtr);
+	ut_ad(level
+	      == btr_page_get_level(buf_block_get_frame(new_block), mtr));
 
 	/* Build the node pointer (= node key and page address) for the upper
 	half */
@@ -1512,37 +1731,46 @@
 
 	prev_page_no = btr_page_get_prev(page, mtr);
 	next_page_no = btr_page_get_next(page, mtr);
-	space = buf_frame_get_space_id(page);
+	space = buf_block_get_space(block);
+	zip_size = buf_block_get_zip_size(block);
 
 	/* Update page links of the level */
 
 	if (prev_page_no != FIL_NULL) {
-
-		prev_page = btr_page_get(space, prev_page_no, RW_X_LATCH, mtr);
-		ut_a(page_is_comp(prev_page) == page_is_comp(page));
+		buf_block_t*	prev_block = btr_block_get(space, zip_size,
+							   prev_page_no,
+							   RW_X_LATCH, mtr);
 #ifdef UNIV_BTR_DEBUG
-		ut_a(btr_page_get_next(prev_page, mtr)
-		     == buf_frame_get_page_no(page));
+		ut_a(page_is_comp(prev_block->frame) == page_is_comp(page));
+		ut_a(btr_page_get_next(prev_block->frame, mtr)
+		     == buf_block_get_page_no(block));
 #endif /* UNIV_BTR_DEBUG */
 
-		btr_page_set_next(prev_page, lower_page_no, mtr);
+		btr_page_set_next(buf_block_get_frame(prev_block),
+				  buf_block_get_page_zip(prev_block),
+				  lower_page_no, mtr);
 	}
 
 	if (next_page_no != FIL_NULL) {
-
-		next_page = btr_page_get(space, next_page_no, RW_X_LATCH, mtr);
-		ut_a(page_is_comp(next_page) == page_is_comp(page));
-
-		btr_page_set_prev(next_page, upper_page_no, mtr);
+		buf_block_t*	next_block = btr_block_get(space, zip_size,
+							   next_page_no,
+							   RW_X_LATCH, mtr);
+#ifdef UNIV_BTR_DEBUG
+		ut_a(page_is_comp(next_block->frame) == page_is_comp(page));
+		ut_a(btr_page_get_prev(next_block->frame, mtr)
+		     == page_get_page_no(page));
+#endif /* UNIV_BTR_DEBUG */
+
+		btr_page_set_prev(buf_block_get_frame(next_block),
+				  buf_block_get_page_zip(next_block),
+				  upper_page_no, mtr);
 	}
 
-	btr_page_set_prev(lower_page, prev_page_no, mtr);
-	btr_page_set_next(lower_page, upper_page_no, mtr);
-	btr_page_set_level(lower_page, level, mtr);
+	btr_page_set_prev(lower_page, lower_page_zip, prev_page_no, mtr);
+	btr_page_set_next(lower_page, lower_page_zip, upper_page_no, mtr);
 
-	btr_page_set_prev(upper_page, lower_page_no, mtr);
-	btr_page_set_next(upper_page, next_page_no, mtr);
-	btr_page_set_level(upper_page, level, mtr);
+	btr_page_set_prev(upper_page, upper_page_zip, lower_page_no, mtr);
+	btr_page_set_next(upper_page, upper_page_zip, next_page_no, mtr);
 }
 
 /*****************************************************************
@@ -1552,7 +1780,7 @@
 function must always succeed, we cannot reverse it: therefore
 enough free disk space must be guaranteed to be available before
 this function is called. */
-
+UNIV_INTERN
 rec_t*
 btr_page_split_and_insert(
 /*======================*/
@@ -1562,23 +1790,30 @@
 	btr_cur_t*	cursor,	/* in: cursor at which to insert; when the
 				function returns, the cursor is positioned
 				on the predecessor of the inserted record */
-	dtuple_t*	tuple,	/* in: tuple to insert */
+	const dtuple_t*	tuple,	/* in: tuple to insert */
+	ulint		n_ext,	/* in: number of externally stored columns */
 	mtr_t*		mtr)	/* in: mtr */
 {
+	buf_block_t*	block;
 	page_t*		page;
+	page_zip_des_t*	page_zip;
 	ulint		page_no;
 	byte		direction;
 	ulint		hint_page_no;
+	buf_block_t*	new_block;
 	page_t*		new_page;
+	page_zip_des_t*	new_page_zip;
 	rec_t*		split_rec;
-	page_t*		left_page;
-	page_t*		right_page;
+	buf_block_t*	left_block;
+	buf_block_t*	right_block;
+	buf_block_t*	insert_block;
 	page_t*		insert_page;
 	page_cur_t*	page_cursor;
 	rec_t*		first_rec;
 	byte*		buf = 0; /* remove warning */
 	rec_t*		move_limit;
 	ibool		insert_will_fit;
+	ibool		insert_left;
 	ulint		n_iterations = 0;
 	rec_t*		rec;
 	mem_heap_t*	heap;
@@ -1597,13 +1832,14 @@
 	ut_ad(rw_lock_own(dict_index_get_lock(cursor->index), RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
 
-	page = btr_cur_get_page(cursor);
-
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
-	ut_ad(page_get_n_recs(page) >= 2);
-
-	page_no = buf_frame_get_page_no(page);
+	block = btr_cur_get_block(cursor);
+	page = buf_block_get_frame(block);
+	page_zip = buf_block_get_page_zip(block);
+
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+	ut_ad(page_get_n_recs(page) >= 1);
+
+	page_no = buf_block_get_page_no(block);
 
 	/* 1. Decide the split record; split_rec == NULL means that the
 	tuple to be inserted should be the first record on the upper
@@ -1612,7 +1848,7 @@
 	if (n_iterations > 0) {
 		direction = FSP_UP;
 		hint_page_no = page_no + 1;
-		split_rec = btr_page_get_sure_split_rec(cursor, tuple);
+		split_rec = btr_page_get_sure_split_rec(cursor, tuple, n_ext);
 
 	} else if (btr_page_get_split_rec_to_right(cursor, &split_rec)) {
 		direction = FSP_UP;
@@ -1624,37 +1860,80 @@
 	} else {
 		direction = FSP_UP;
 		hint_page_no = page_no + 1;
-		split_rec = page_get_middle_rec(page);
+
+		if (page_get_n_recs(page) == 1) {
+			page_cur_t	pcur;
+
+			/* There is only one record in the index page
+			therefore we can't split the node in the middle
+			by default. We need to determine whether the
+			new record will be inserted to the left or right. */
+
+			/* Read the first (and only) record in the page. */
+			page_cur_set_before_first(block, &pcur);
+			page_cur_move_to_next(&pcur);
+			first_rec = page_cur_get_rec(&pcur);
+
+			offsets = rec_get_offsets(
+				first_rec, cursor->index, offsets,
+				n_uniq, &heap);
+
+			/* If the new record is less than the existing record
+			the the split in the middle will copy the existing
+			record to the new node. */
+			if (cmp_dtuple_rec(tuple, first_rec, offsets) < 0) {
+				split_rec = page_get_middle_rec(page);
+			} else {
+				split_rec = NULL;
+			}
+		} else {
+			split_rec = page_get_middle_rec(page);
+		}
 	}
 
 	/* 2. Allocate a new page to the index */
-	new_page = btr_page_alloc(cursor->index, hint_page_no, direction,
-				  btr_page_get_level(page, mtr), mtr);
-	btr_page_create(new_page, cursor->index, mtr);
+	new_block = btr_page_alloc(cursor->index, hint_page_no, direction,
+				   btr_page_get_level(page, mtr), mtr);
+	new_page = buf_block_get_frame(new_block);
+	new_page_zip = buf_block_get_page_zip(new_block);
+	btr_page_create(new_block, new_page_zip, cursor->index,
+			btr_page_get_level(page, mtr), mtr);
 
 	/* 3. Calculate the first record on the upper half-page, and the
 	first record (move_limit) on original page which ends up on the
 	upper half */
 
-	if (split_rec != NULL) {
-		first_rec = split_rec;
-		move_limit = split_rec;
+	if (split_rec) {
+		first_rec = move_limit = split_rec;
+
+		offsets = rec_get_offsets(split_rec, cursor->index, offsets,
+					  n_uniq, &heap);
+
+		insert_left = cmp_dtuple_rec(tuple, split_rec, offsets) < 0;
+
+		if (UNIV_UNLIKELY(!insert_left && new_page_zip
+				  && n_iterations > 0)) {
+			/* If a compressed page has already been split,
+			avoid further splits by inserting the record
+			to an empty page. */
+			split_rec = NULL;
+			goto insert_right;
+		}
 	} else {
-		buf = mem_alloc(rec_get_converted_size(cursor->index, tuple));
+insert_right:
+		insert_left = FALSE;
+		buf = mem_alloc(rec_get_converted_size(cursor->index,
+						       tuple, n_ext));
 
-		first_rec = rec_convert_dtuple_to_rec(buf,
-						      cursor->index, tuple);
+		first_rec = rec_convert_dtuple_to_rec(buf, cursor->index,
+						      tuple, n_ext);
 		move_limit = page_rec_get_next(btr_cur_get_rec(cursor));
 	}
 
 	/* 4. Do first the modifications in the tree structure */
 
-	btr_attach_half_pages(cursor->index, page, first_rec,
-			      new_page, direction, mtr);
-
-	if (split_rec == NULL) {
-		mem_free(buf);
-	}
+	btr_attach_half_pages(cursor->index, block,
+			      first_rec, new_block, direction, mtr);
 
 	/* If the split is made on the leaf level and the insert will fit
 	on the appropriate half-page, we may release the tree x-latch.
@@ -1662,19 +1941,17 @@
 	thus reducing the tree latch contention. */
 
 	if (split_rec) {
-		offsets = rec_get_offsets(split_rec, cursor->index, offsets,
-					  n_uniq, &heap);
-
-		insert_will_fit = btr_page_insert_fits(cursor,
-						       split_rec, offsets,
-						       tuple, heap);
+		insert_will_fit = !new_page_zip
+			&& btr_page_insert_fits(cursor, split_rec,
+						offsets, tuple, n_ext, heap);
 	} else {
-		insert_will_fit = btr_page_insert_fits(cursor,
-						       NULL, NULL,
-						       tuple, heap);
+		mem_free(buf);
+		insert_will_fit = !new_page_zip
+			&& btr_page_insert_fits(cursor, NULL,
+						NULL, tuple, n_ext, heap);
 	}
 
-	if (insert_will_fit && (btr_page_get_level(page, mtr) == 0)) {
+	if (insert_will_fit && page_is_leaf(page)) {
 
 		mtr_memo_release(mtr, dict_index_get_lock(cursor->index),
 				 MTR_MEMO_X_LOCK);
@@ -1684,100 +1961,184 @@
 	if (direction == FSP_DOWN) {
 		/*		fputs("Split left\n", stderr); */
 
-		page_move_rec_list_start(new_page, page, move_limit,
-					 cursor->index, mtr);
-		left_page = new_page;
-		right_page = page;
-
-		lock_update_split_left(right_page, left_page);
+		if (0
+#ifdef UNIV_ZIP_COPY
+		    || page_zip
+#endif /* UNIV_ZIP_COPY */
+		    || UNIV_UNLIKELY
+		    (!page_move_rec_list_start(new_block, block, move_limit,
+					       cursor->index, mtr))) {
+			/* For some reason, compressing new_page failed,
+			even though it should contain fewer records than
+			the original page.  Copy the page byte for byte
+			and then delete the records from both pages
+			as appropriate.  Deleting will always succeed. */
+			ut_a(new_page_zip);
+
+			page_zip_copy_recs(new_page_zip, new_page,
+					   page_zip, page, cursor->index, mtr);
+			page_delete_rec_list_end(move_limit - page + new_page,
+						 new_block, cursor->index,
+						 ULINT_UNDEFINED,
+						 ULINT_UNDEFINED, mtr);
+
+			/* Update the lock table and possible hash index. */
+
+			lock_move_rec_list_start(
+				new_block, block, move_limit,
+				new_page + PAGE_NEW_INFIMUM);
+
+			btr_search_move_or_delete_hash_entries(
+				new_block, block, cursor->index);
+
+			/* Delete the records from the source page. */
+
+			page_delete_rec_list_start(move_limit, block,
+						   cursor->index, mtr);
+		}
+
+		left_block = new_block;
+		right_block = block;
+
+		lock_update_split_left(right_block, left_block);
 	} else {
 		/*		fputs("Split right\n", stderr); */
 
-		page_move_rec_list_end(new_page, page, move_limit,
-				       cursor->index, mtr);
-		left_page = page;
-		right_page = new_page;
-
-		lock_update_split_right(right_page, left_page);
-	}
+		if (0
+#ifdef UNIV_ZIP_COPY
+		    || page_zip
+#endif /* UNIV_ZIP_COPY */
+		    || UNIV_UNLIKELY
+		    (!page_move_rec_list_end(new_block, block, move_limit,
+					     cursor->index, mtr))) {
+			/* For some reason, compressing new_page failed,
+			even though it should contain fewer records than
+			the original page.  Copy the page byte for byte
+			and then delete the records from both pages
+			as appropriate.  Deleting will always succeed. */
+			ut_a(new_page_zip);
+
+			page_zip_copy_recs(new_page_zip, new_page,
+					   page_zip, page, cursor->index, mtr);
+			page_delete_rec_list_start(move_limit - page
+						   + new_page, new_block,
+						   cursor->index, mtr);
+
+			/* Update the lock table and possible hash index. */
+
+			lock_move_rec_list_end(new_block, block, move_limit);
+
+			btr_search_move_or_delete_hash_entries(
+				new_block, block, cursor->index);
+
+			/* Delete the records from the source page. */
+
+			page_delete_rec_list_end(move_limit, block,
+						 cursor->index,
+						 ULINT_UNDEFINED,
+						 ULINT_UNDEFINED, mtr);
+		}
+
+		left_block = block;
+		right_block = new_block;
+
+		lock_update_split_right(right_block, left_block);
+	}
+
+#ifdef UNIV_ZIP_DEBUG
+	if (UNIV_LIKELY_NULL(page_zip)) {
+		ut_a(page_zip_validate(page_zip, page));
+		ut_a(page_zip_validate(new_page_zip, new_page));
+	}
+#endif /* UNIV_ZIP_DEBUG */
+
+	/* At this point, split_rec, move_limit and first_rec may point
+	to garbage on the old page. */
 
 	/* 6. The split and the tree modification is now completed. Decide the
 	page where the tuple should be inserted */
 
-	if (split_rec == NULL) {
-		insert_page = right_page;
-
+	if (insert_left) {
+		insert_block = left_block;
 	} else {
-		offsets = rec_get_offsets(first_rec, cursor->index,
-					  offsets, n_uniq, &heap);
-
-		if (cmp_dtuple_rec(tuple, first_rec, offsets) >= 0) {
-
-			insert_page = right_page;
-		} else {
-			insert_page = left_page;
-		}
+		insert_block = right_block;
 	}
 
+	insert_page = buf_block_get_frame(insert_block);
+
 	/* 7. Reposition the cursor for insert and try insertion */
 	page_cursor = btr_cur_get_page_cur(cursor);
 
-	page_cur_search(insert_page, cursor->index, tuple,
+	page_cur_search(insert_block, cursor->index, tuple,
 			PAGE_CUR_LE, page_cursor);
 
-	rec = page_cur_tuple_insert(page_cursor, tuple, cursor->index, mtr);
-
-	if (rec != NULL) {
-		/* Insert fit on the page: update the free bits for the
-		left and right pages in the same mtr */
-
-		ibuf_update_free_bits_for_two_pages_low(cursor->index,
-							left_page,
-							right_page, mtr);
-		/* fprintf(stderr, "Split and insert done %lu %lu\n",
-		buf_frame_get_page_no(left_page),
-		buf_frame_get_page_no(right_page)); */
-		mem_heap_free(heap);
-		return(rec);
+	rec = page_cur_tuple_insert(page_cursor, tuple,
+				    cursor->index, n_ext, mtr);
+
+#ifdef UNIV_ZIP_DEBUG
+	{
+		page_zip_des_t*	insert_page_zip
+			= buf_block_get_page_zip(insert_block);
+		ut_a(!insert_page_zip
+		     || page_zip_validate(insert_page_zip, insert_page));
+	}
+#endif /* UNIV_ZIP_DEBUG */
+
+	if (UNIV_LIKELY(rec != NULL)) {
+
+		goto func_exit;
 	}
 
 	/* 8. If insert did not fit, try page reorganization */
 
-	btr_page_reorganize(insert_page, cursor->index, mtr);
-
-	page_cur_search(insert_page, cursor->index, tuple,
+	if (UNIV_UNLIKELY
+	    (!btr_page_reorganize(insert_block, cursor->index, mtr))) {
+
+		goto insert_failed;
+	}
+
+	page_cur_search(insert_block, cursor->index, tuple,
 			PAGE_CUR_LE, page_cursor);
-	rec = page_cur_tuple_insert(page_cursor, tuple, cursor->index, mtr);
+	rec = page_cur_tuple_insert(page_cursor, tuple, cursor->index,
+				    n_ext, mtr);
 
-	if (rec == NULL) {
+	if (UNIV_UNLIKELY(rec == NULL)) {
 		/* The insert did not fit on the page: loop back to the
 		start of the function for a new split */
-
+insert_failed:
 		/* We play safe and reset the free bits for new_page */
-		ibuf_reset_free_bits(cursor->index, new_page);
+		if (!dict_index_is_clust(cursor->index)) {
+			ibuf_reset_free_bits(new_block);
+		}
 
 		/* fprintf(stderr, "Split second round %lu\n",
-		buf_frame_get_page_no(page)); */
+		page_get_page_no(page)); */
 		n_iterations++;
-		ut_ad(n_iterations < 2);
+		ut_ad(n_iterations < 2
+		      || buf_block_get_page_zip(insert_block));
 		ut_ad(!insert_will_fit);
 
 		goto func_start;
 	}
 
+func_exit:
 	/* Insert fit on the page: update the free bits for the
 	left and right pages in the same mtr */
 
-	ibuf_update_free_bits_for_two_pages_low(cursor->index, left_page,
-						right_page, mtr);
+	if (!dict_index_is_clust(cursor->index) && page_is_leaf(page)) {
+		ibuf_update_free_bits_for_two_pages_low(
+			buf_block_get_zip_size(left_block),
+			left_block, right_block, mtr);
+	}
+
 #if 0
 	fprintf(stderr, "Split and insert done %lu %lu\n",
-		buf_frame_get_page_no(left_page),
-		buf_frame_get_page_no(right_page));
+		buf_block_get_page_no(left_block),
+		buf_block_get_page_no(right_block));
 #endif
 
-	ut_ad(page_validate(left_page, cursor->index));
-	ut_ad(page_validate(right_page, cursor->index));
+	ut_ad(page_validate(buf_block_get_frame(left_block), cursor->index));
+	ut_ad(page_validate(buf_block_get_frame(right_block), cursor->index));
 
 	mem_heap_free(heap);
 	return(rec);
@@ -1789,48 +2150,57 @@
 void
 btr_level_list_remove(
 /*==================*/
+	ulint		space,	/* in: space where removed */
+	ulint		zip_size,/* in: compressed page size in bytes
+				or 0 for uncompressed pages */
 	page_t*		page,	/* in: page to remove */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	ulint	space;
 	ulint	prev_page_no;
-	page_t*	prev_page;
 	ulint	next_page_no;
-	page_t*	next_page;
 
 	ut_ad(page && mtr);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_X_FIX));
+	ut_ad(space == page_get_space_id(page));
 	/* Get the previous and next page numbers of page */
 
 	prev_page_no = btr_page_get_prev(page, mtr);
 	next_page_no = btr_page_get_next(page, mtr);
-	space = buf_frame_get_space_id(page);
 
 	/* Update page links of the level */
 
 	if (prev_page_no != FIL_NULL) {
-
-		prev_page = btr_page_get(space, prev_page_no, RW_X_LATCH, mtr);
+		buf_block_t*	prev_block
+			= btr_block_get(space, zip_size, prev_page_no,
+					RW_X_LATCH, mtr);
+		page_t*		prev_page
+			= buf_block_get_frame(prev_block);
+#ifdef UNIV_BTR_DEBUG
 		ut_a(page_is_comp(prev_page) == page_is_comp(page));
-#ifdef UNIV_BTR_DEBUG
 		ut_a(btr_page_get_next(prev_page, mtr)
-		     == buf_frame_get_page_no(page));
+		     == page_get_page_no(page));
 #endif /* UNIV_BTR_DEBUG */
 
-		btr_page_set_next(prev_page, next_page_no, mtr);
+		btr_page_set_next(prev_page,
+				  buf_block_get_page_zip(prev_block),
+				  next_page_no, mtr);
 	}
 
 	if (next_page_no != FIL_NULL) {
-
-		next_page = btr_page_get(space, next_page_no, RW_X_LATCH, mtr);
+		buf_block_t*	next_block
+			= btr_block_get(space, zip_size, next_page_no,
+					RW_X_LATCH, mtr);
+		page_t*		next_page
+			= buf_block_get_frame(next_block);
+#ifdef UNIV_BTR_DEBUG
 		ut_a(page_is_comp(next_page) == page_is_comp(page));
-#ifdef UNIV_BTR_DEBUG
 		ut_a(btr_page_get_prev(next_page, mtr)
-		     == buf_frame_get_page_no(page));
+		     == page_get_page_no(page));
 #endif /* UNIV_BTR_DEBUG */
 
-		btr_page_set_prev(next_page, prev_page_no, mtr);
+		btr_page_set_prev(next_page,
+				  buf_block_get_page_zip(next_block),
+				  prev_page_no, mtr);
 	}
 }
 
@@ -1842,11 +2212,10 @@
 btr_set_min_rec_mark_log(
 /*=====================*/
 	rec_t*	rec,	/* in: record */
-	ulint	comp,	/* nonzero=compact record format */
+	byte	type,	/* in: MLOG_COMP_REC_MIN_MARK or MLOG_REC_MIN_MARK */
 	mtr_t*	mtr)	/* in: mtr */
 {
-	mlog_write_initial_log_record(
-		rec, comp ? MLOG_COMP_REC_MIN_MARK : MLOG_REC_MIN_MARK, mtr);
+	mlog_write_initial_log_record(rec, type, mtr);
 
 	/* Write rec offset as a 2-byte ulint */
 	mlog_catenate_ulint(mtr, page_offset(rec), MLOG_2BYTES);
@@ -1855,7 +2224,7 @@
 /********************************************************************
 Parses the redo log record for setting an index record as the predefined
 minimum record. */
-
+UNIV_INTERN
 byte*
 btr_parse_set_min_rec_mark(
 /*=======================*/
@@ -1878,7 +2247,7 @@
 
 		rec = page + mach_read_from_2(ptr);
 
-		btr_set_min_rec_mark(rec, comp, mtr);
+		btr_set_min_rec_mark(rec, mtr);
 	}
 
 	return(ptr + 2);
@@ -1886,46 +2255,50 @@
 
 /********************************************************************
 Sets a record as the predefined minimum record. */
-
+UNIV_INTERN
 void
 btr_set_min_rec_mark(
 /*=================*/
 	rec_t*	rec,	/* in: record */
-	ulint	comp,	/* in: nonzero=compact page format */
 	mtr_t*	mtr)	/* in: mtr */
 {
 	ulint	info_bits;
 
-	info_bits = rec_get_info_bits(rec, comp);
-
-	rec_set_info_bits(rec, comp, info_bits | REC_INFO_MIN_REC_FLAG);
-
-	btr_set_min_rec_mark_log(rec, comp, mtr);
+	if (UNIV_LIKELY(page_rec_is_comp(rec))) {
+		info_bits = rec_get_info_bits(rec, TRUE);
+
+		rec_set_info_bits_new(rec, info_bits | REC_INFO_MIN_REC_FLAG);
+
+		btr_set_min_rec_mark_log(rec, MLOG_COMP_REC_MIN_MARK, mtr);
+	} else {
+		info_bits = rec_get_info_bits(rec, FALSE);
+
+		rec_set_info_bits_old(rec, info_bits | REC_INFO_MIN_REC_FLAG);
+
+		btr_set_min_rec_mark_log(rec, MLOG_REC_MIN_MARK, mtr);
+	}
 }
 
 /*****************************************************************
 Deletes on the upper level the node pointer to a page. */
-
+UNIV_INTERN
 void
 btr_node_ptr_delete(
 /*================*/
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page whose node pointer is deleted */
+	buf_block_t*	block,	/* in: page whose node pointer is deleted */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	rec_t*		node_ptr;
 	btr_cur_t	cursor;
 	ibool		compressed;
 	ulint		err;
 
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+
 	/* Delete node pointer on father page */
-
-	node_ptr = btr_page_get_father_node_ptr(index, page, mtr);
-
-	btr_cur_position(index, node_ptr, &cursor);
-	compressed = btr_cur_pessimistic_delete(&err, TRUE, &cursor, FALSE,
+	btr_page_get_father(index, block, mtr, &cursor);
+
+	compressed = btr_cur_pessimistic_delete(&err, TRUE, &cursor, RB_NONE,
 						mtr);
 	ut_a(err == DB_SUCCESS);
 
@@ -1942,80 +2315,118 @@
 btr_lift_page_up(
 /*=============*/
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page which is the only on its level;
+	buf_block_t*	block,	/* in: page which is the only on its level;
 				must not be empty: use
 				btr_discard_only_page_on_level if the last
 				record from the page should be removed */
 	mtr_t*		mtr)	/* in: mtr */
 {
+	buf_block_t*	father_block;
 	page_t*		father_page;
-	page_t*		iter_page;
-	page_t*		pages[BTR_MAX_LEVELS];
 	ulint		page_level;
+	page_zip_des_t*	father_page_zip;
+	page_t*		page		= buf_block_get_frame(block);
 	ulint		root_page_no;
-	ulint		ancestors;
+	buf_block_t*	blocks[BTR_MAX_LEVELS];
+	ulint		n_blocks;	/* last used index in blocks[] */
 	ulint		i;
 
 	ut_ad(btr_page_get_prev(page, mtr) == FIL_NULL);
 	ut_ad(btr_page_get_next(page, mtr) == FIL_NULL);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
-	father_page = buf_frame_align(
-		btr_page_get_father_node_ptr(index, page, mtr));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 
 	page_level = btr_page_get_level(page, mtr);
 	root_page_no = dict_index_get_page(index);
 
-	ancestors = 1;
-	pages[0] = father_page;
-
-	/* Store all ancestor pages so we can reset their levels later on.
-	We have to do all the searches on the tree now because later on,
-	after we've replaced the first level, the tree is in an inconsistent
-	state and can not be searched. */
-	iter_page = father_page;
-	for (;;) {
-		if (buf_block_get_page_no(buf_block_align(iter_page))
-		    == root_page_no) {
-
-			break;
+	{
+		btr_cur_t	cursor;
+		mem_heap_t*	heap	= mem_heap_create(100);
+		ulint*		offsets;
+		buf_block_t*	b;
+
+		offsets = btr_page_get_father_block(NULL, heap, index,
+						    block, mtr, &cursor);
+		father_block = btr_cur_get_block(&cursor);
+		father_page_zip = buf_block_get_page_zip(father_block);
+		father_page = buf_block_get_frame(father_block);
+
+		n_blocks = 0;
+
+		/* Store all ancestor pages so we can reset their
+		levels later on.  We have to do all the searches on
+		the tree now because later on, after we've replaced
+		the first level, the tree is in an inconsistent state
+		and can not be searched. */
+		for (b = father_block;
+		     buf_block_get_page_no(b) != root_page_no; ) {
+			ut_a(n_blocks < BTR_MAX_LEVELS);
+
+			offsets = btr_page_get_father_block(offsets, heap,
+							    index, b,
+							    mtr, &cursor);
+
+			blocks[n_blocks++] = b = btr_cur_get_block(&cursor);
 		}
 
-		ut_a(ancestors < BTR_MAX_LEVELS);
-
-		iter_page = buf_frame_align(
-			btr_page_get_father_node_ptr(index, iter_page, mtr));
-
-		pages[ancestors++] = iter_page;
+		mem_heap_free(heap);
 	}
 
-	btr_search_drop_page_hash_index(page);
+	btr_search_drop_page_hash_index(block);
 
 	/* Make the father empty */
-	btr_page_empty(father_page, mtr);
-
-	/* Move records to the father */
-	page_copy_rec_list_end(father_page, page, page_get_infimum_rec(page),
-			       index, mtr);
-	lock_update_copy_and_discard(father_page, page);
-
-	/* Go upward to root page, decreasing levels by one. */
-	for (i = 0; i < ancestors; i++) {
-		iter_page = pages[i];
-
-		ut_ad(btr_page_get_level(iter_page, mtr) == (page_level + 1));
-
-		btr_page_set_level(iter_page, page_level, mtr);
-		page_level++;
+	btr_page_empty(father_block, father_page_zip, index, page_level, mtr);
+
+	/* Copy the records to the father page one by one. */
+	if (0
+#ifdef UNIV_ZIP_COPY
+	    || father_page_zip
+#endif /* UNIV_ZIP_COPY */
+	    || UNIV_UNLIKELY
+	    (!page_copy_rec_list_end(father_block, block,
+				     page_get_infimum_rec(page),
+				     index, mtr))) {
+		const page_zip_des_t*	page_zip
+			= buf_block_get_page_zip(block);
+		ut_a(father_page_zip);
+		ut_a(page_zip);
+
+		/* Copy the page byte for byte. */
+		page_zip_copy_recs(father_page_zip, father_page,
+				   page_zip, page, index, mtr);
+
+		/* Update the lock table and possible hash index. */
+
+		lock_move_rec_list_end(father_block, block,
+				       page_get_infimum_rec(page));
+
+		btr_search_move_or_delete_hash_entries(father_block, block,
+						       index);
+	}
+
+	lock_update_copy_and_discard(father_block, block);
+
+	/* Go upward to root page, decrementing levels by one. */
+	for (i = 0; i < n_blocks; i++, page_level++) {
+		page_t*		page	= buf_block_get_frame(blocks[i]);
+		page_zip_des_t*	page_zip= buf_block_get_page_zip(blocks[i]);
+
+		ut_ad(btr_page_get_level(page, mtr) == page_level + 1);
+
+		btr_page_set_level(page, page_zip, page_level, mtr);
+#ifdef UNIV_ZIP_DEBUG
+		ut_a(!page_zip || page_zip_validate(page_zip, page));
+#endif /* UNIV_ZIP_DEBUG */
 	}
 
 	/* Free the file page */
-	btr_page_free(index, page, mtr);
+	btr_page_free(index, block, mtr);
 
-	/* We play safe and reset the free bits for the father */
-	ibuf_reset_free_bits(index, father_page);
+	/* We play it safe and reset the free bits for the father */
+	if (!dict_index_is_clust(index)) {
+		ibuf_reset_free_bits(father_block);
+	}
 	ut_ad(page_validate(father_page, index));
-	ut_ad(btr_check_node_ptr(index, father_page, mtr));
+	ut_ad(btr_check_node_ptr(index, father_block, mtr));
 }
 
 /*****************************************************************
@@ -2026,12 +2437,12 @@
 level lifts the records of the page to the father page, thus reducing the
 tree height. It is assumed that mtr holds an x-latch on the tree and on the
 page. If cursor is on the leaf level, mtr must also hold x-latches to the
-brothers, if they exist. NOTE: it is assumed that the caller has reserved
-enough free extents so that the compression will always succeed if done! */
-
-void
+brothers, if they exist. */
+UNIV_INTERN
+ibool
 btr_compress(
 /*=========*/
+				/* out: TRUE on success */
 	btr_cur_t*	cursor,	/* in: cursor on the page to merge or lift;
 				the page must not be empty: in record delete
 				use btr_discard_page if the page would become
@@ -2040,33 +2451,35 @@
 {
 	dict_index_t*	index;
 	ulint		space;
+	ulint		zip_size;
 	ulint		left_page_no;
 	ulint		right_page_no;
+	buf_block_t*	merge_block;
 	page_t*		merge_page;
-	page_t*		father_page;
+	page_zip_des_t*	merge_page_zip;
 	ibool		is_left;
+	buf_block_t*	block;
 	page_t*		page;
-	rec_t*		orig_pred;
-	rec_t*		orig_succ;
-	rec_t*		node_ptr;
+	btr_cur_t	father_cursor;
+	mem_heap_t*	heap;
+	ulint*		offsets;
 	ulint		data_size;
 	ulint		n_recs;
 	ulint		max_ins_size;
 	ulint		max_ins_size_reorg;
 	ulint		level;
-	ulint		comp;
 
+	block = btr_cur_get_block(cursor);
 	page = btr_cur_get_page(cursor);
 	index = btr_cur_get_index(cursor);
-	comp = page_is_comp(page);
-	ut_a((ibool)!!comp == dict_table_is_comp(index->table));
+	ut_a((ibool) !!page_is_comp(page) == dict_table_is_comp(index->table));
 
 	ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index),
 				MTR_MEMO_X_LOCK));
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 	level = btr_page_get_level(page, mtr);
 	space = dict_index_get_space(index);
+	zip_size = dict_table_zip_size(index->table);
 
 	left_page_no = btr_page_get_prev(page, mtr);
 	right_page_no = btr_page_get_next(page, mtr);
@@ -2076,10 +2489,9 @@
 		left_page_no, right_page_no);
 #endif
 
-	node_ptr = btr_page_get_father_node_ptr(index, page, mtr);
-	ut_ad(!comp || rec_get_status(node_ptr) == REC_STATUS_NODE_PTR);
-	father_page = buf_frame_align(node_ptr);
-	ut_a(comp == page_is_comp(father_page));
+	heap = mem_heap_create(100);
+	offsets = btr_page_get_father_block(NULL, heap, index, block, mtr,
+					    &father_cursor);
 
 	/* Decide the page to which we try to merge and which will inherit
 	the locks */
@@ -2088,166 +2500,286 @@
 
 	if (is_left) {
 
-		merge_page = btr_page_get(space, left_page_no, RW_X_LATCH,
-					  mtr);
+		merge_block = btr_block_get(space, zip_size, left_page_no,
+					    RW_X_LATCH, mtr);
+		merge_page = buf_block_get_frame(merge_block);
 #ifdef UNIV_BTR_DEBUG
 		ut_a(btr_page_get_next(merge_page, mtr)
-		     == buf_frame_get_page_no(page));
+		     == buf_block_get_page_no(block));
 #endif /* UNIV_BTR_DEBUG */
 	} else if (right_page_no != FIL_NULL) {
 
-		merge_page = btr_page_get(space, right_page_no, RW_X_LATCH,
-					  mtr);
+		merge_block = btr_block_get(space, zip_size, right_page_no,
+					    RW_X_LATCH, mtr);
+		merge_page = buf_block_get_frame(merge_block);
 #ifdef UNIV_BTR_DEBUG
 		ut_a(btr_page_get_prev(merge_page, mtr)
-		     == buf_frame_get_page_no(page));
+		     == buf_block_get_page_no(block));
 #endif /* UNIV_BTR_DEBUG */
 	} else {
 		/* The page is the only one on the level, lift the records
 		to the father */
-		btr_lift_page_up(index, page, mtr);
-
-		return;
+		btr_lift_page_up(index, block, mtr);
+		mem_heap_free(heap);
+		return(TRUE);
 	}
 
 	n_recs = page_get_n_recs(page);
 	data_size = page_get_data_size(page);
-	ut_a(page_is_comp(merge_page) == comp);
+#ifdef UNIV_BTR_DEBUG
+	ut_a(page_is_comp(merge_page) == page_is_comp(page));
+#endif /* UNIV_BTR_DEBUG */
 
 	max_ins_size_reorg = page_get_max_insert_size_after_reorganize(
 		merge_page, n_recs);
 	if (data_size > max_ins_size_reorg) {
 
 		/* No space for merge */
+err_exit:
+		/* We play it safe and reset the free bits. */
+		if (zip_size
+		    && page_is_leaf(merge_page)
+		    && !dict_index_is_clust(index)) {
+			ibuf_reset_free_bits(merge_block);
+		}
 
-		return;
+		mem_heap_free(heap);
+		return(FALSE);
 	}
 
 	ut_ad(page_validate(merge_page, index));
 
 	max_ins_size = page_get_max_insert_size(merge_page, n_recs);
 
-	if (data_size > max_ins_size) {
+	if (UNIV_UNLIKELY(data_size > max_ins_size)) {
 
 		/* We have to reorganize merge_page */
 
-		btr_page_reorganize(merge_page, index, mtr);
+		if (UNIV_UNLIKELY(!btr_page_reorganize(merge_block,
+						       index, mtr))) {
+
+			goto err_exit;
+		}
 
 		max_ins_size = page_get_max_insert_size(merge_page, n_recs);
 
 		ut_ad(page_validate(merge_page, index));
-		ut_ad(page_get_max_insert_size(merge_page, n_recs)
-		      == max_ins_size_reorg);
-	}
-
-	if (data_size > max_ins_size) {
-
-		/* Add fault tolerance, though this should never happen */
-
-		return;
-	}
-
-	btr_search_drop_page_hash_index(page);
-
-	/* Remove the page from the level list */
-	btr_level_list_remove(page, mtr);
-
+		ut_ad(max_ins_size == max_ins_size_reorg);
+
+		if (UNIV_UNLIKELY(data_size > max_ins_size)) {
+
+			/* Add fault tolerance, though this should
+			never happen */
+
+			goto err_exit;
+		}
+	}
+
+	merge_page_zip = buf_block_get_page_zip(merge_block);
+#ifdef UNIV_ZIP_DEBUG
+	if (UNIV_LIKELY_NULL(merge_page_zip)) {
+		const page_zip_des_t*	page_zip
+			= buf_block_get_page_zip(block);
+		ut_a(page_zip);
+		ut_a(page_zip_validate(merge_page_zip, merge_page));
+		ut_a(page_zip_validate(page_zip, page));
+	}
+#endif /* UNIV_ZIP_DEBUG */
+
+	/* Move records to the merge page */
 	if (is_left) {
-		btr_node_ptr_delete(index, page, mtr);
+		rec_t*	orig_pred = page_copy_rec_list_start(
+			merge_block, block, page_get_supremum_rec(page),
+			index, mtr);
+
+		if (UNIV_UNLIKELY(!orig_pred)) {
+			goto err_exit;
+		}
+
+		btr_search_drop_page_hash_index(block);
+
+		/* Remove the page from the level list */
+		btr_level_list_remove(space, zip_size, page, mtr);
+
+		btr_node_ptr_delete(index, block, mtr);
+		lock_update_merge_left(merge_block, orig_pred, block);
 	} else {
-		mem_heap_t*	heap		= NULL;
-		ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-		*offsets_ = (sizeof offsets_) / sizeof *offsets_;
+		rec_t*		orig_succ;
+#ifdef UNIV_BTR_DEBUG
+		byte		fil_page_prev[4];
+#endif /* UNIV_BTR_DEBUG */
+
+		if (UNIV_LIKELY_NULL(merge_page_zip)) {
+			/* The function page_zip_compress(), which will be
+			invoked by page_copy_rec_list_end() below,
+			requires that FIL_PAGE_PREV be FIL_NULL.
+			Clear the field, but prepare to restore it. */
+#ifdef UNIV_BTR_DEBUG
+			memcpy(fil_page_prev, merge_page + FIL_PAGE_PREV, 4);
+#endif /* UNIV_BTR_DEBUG */
+#if FIL_NULL != 0xffffffff
+# error "FIL_NULL != 0xffffffff"
+#endif
+			memset(merge_page + FIL_PAGE_PREV, 0xff, 4);
+		}
+
+		orig_succ = page_copy_rec_list_end(merge_block, block,
+						   page_get_infimum_rec(page),
+						   cursor->index, mtr);
+
+		if (UNIV_UNLIKELY(!orig_succ)) {
+			ut_a(merge_page_zip);
+#ifdef UNIV_BTR_DEBUG
+			/* FIL_PAGE_PREV was restored from merge_page_zip. */
+			ut_a(!memcmp(fil_page_prev,
+				     merge_page + FIL_PAGE_PREV, 4));
+#endif /* UNIV_BTR_DEBUG */
+			goto err_exit;
+		}
+
+		btr_search_drop_page_hash_index(block);
+
+#ifdef UNIV_BTR_DEBUG
+		if (UNIV_LIKELY_NULL(merge_page_zip)) {
+			/* Restore FIL_PAGE_PREV in order to avoid an assertion
+			failure in btr_level_list_remove(), which will set
+			the field again to FIL_NULL.  Even though this makes
+			merge_page and merge_page_zip inconsistent for a
+			split second, it is harmless, because the pages
+			are X-latched. */
+			memcpy(merge_page + FIL_PAGE_PREV, fil_page_prev, 4);
+		}
+#endif /* UNIV_BTR_DEBUG */
+
+		/* Remove the page from the level list */
+		btr_level_list_remove(space, zip_size, page, mtr);
+
 		/* Replace the address of the old child node (= page) with the
 		address of the merge page to the right */
 
-		btr_node_ptr_set_child_page_no(node_ptr,
-					       rec_get_offsets(
-						       node_ptr, index,
-						       offsets_,
-						       ULINT_UNDEFINED,
-						       &heap),
-					       right_page_no, mtr);
-		if (UNIV_LIKELY_NULL(heap)) {
-			mem_heap_free(heap);
+		btr_node_ptr_set_child_page_no(
+			btr_cur_get_rec(&father_cursor),
+			btr_cur_get_page_zip(&father_cursor),
+			offsets, right_page_no, mtr);
+		btr_node_ptr_delete(index, merge_block, mtr);
+
+		lock_update_merge_right(merge_block, orig_succ, block);
+	}
+
+	mem_heap_free(heap);
+
+	if (!dict_index_is_clust(index) && page_is_leaf(merge_page)) {
+		/* Update the free bits of the B-tree page in the
+		insert buffer bitmap.  This has to be done in a
+		separate mini-transaction that is committed before the
+		main mini-transaction.  We cannot update the insert
+		buffer bitmap in this mini-transaction, because
+		btr_compress() can be invoked recursively without
+		committing the mini-transaction in between.  Since
+		insert buffer bitmap pages have a lower rank than
+		B-tree pages, we must not access other pages in the
+		same mini-transaction after accessing an insert buffer
+		bitmap page. */
+
+		/* The free bits in the insert buffer bitmap must
+		never exceed the free space on a page.  It is safe to
+		decrement or reset the bits in the bitmap in a
+		mini-transaction that is committed before the
+		mini-transaction that affects the free space. */
+
+		/* It is unsafe to increment the bits in a separately
+		committed mini-transaction, because in crash recovery,
+		the free bits could momentarily be set too high. */
+
+		if (zip_size) {
+			/* Because the free bits may be incremented
+			and we cannot update the insert buffer bitmap
+			in the same mini-transaction, the only safe
+			thing we can do here is the pessimistic
+			approach: reset the free bits. */
+			ibuf_reset_free_bits(merge_block);
+		} else {
+			/* On uncompressed pages, the free bits will
+			never increase here.  Thus, it is safe to
+			write the bits accurately in a separate
+			mini-transaction. */
+			ibuf_update_free_bits_if_full(merge_block,
+						      UNIV_PAGE_SIZE,
+						      ULINT_UNDEFINED);
 		}
-		btr_node_ptr_delete(index, merge_page, mtr);
-	}
-
-	/* Move records to the merge page */
-	if (is_left) {
-		orig_pred = page_rec_get_prev(
-			page_get_supremum_rec(merge_page));
-		page_copy_rec_list_start(merge_page, page,
-					 page_get_supremum_rec(page),
-					 index, mtr);
-
-		lock_update_merge_left(merge_page, orig_pred, page);
-	} else {
-		orig_succ = page_rec_get_next(
-			page_get_infimum_rec(merge_page));
-		page_copy_rec_list_end(merge_page, page,
-				       page_get_infimum_rec(page),
-				       index, mtr);
-
-		lock_update_merge_right(orig_succ, page);
-	}
-
-	/* We have added new records to merge_page: update its free bits */
-	ibuf_update_free_bits_if_full(index, merge_page,
-				      UNIV_PAGE_SIZE, ULINT_UNDEFINED);
+	}
 
 	ut_ad(page_validate(merge_page, index));
+#ifdef UNIV_ZIP_DEBUG
+	ut_a(!merge_page_zip || page_zip_validate(merge_page_zip, merge_page));
+#endif /* UNIV_ZIP_DEBUG */
 
 	/* Free the file page */
-	btr_page_free(index, page, mtr);
+	btr_page_free(index, block, mtr);
 
-	ut_ad(btr_check_node_ptr(index, merge_page, mtr));
+	ut_ad(btr_check_node_ptr(index, merge_block, mtr));
+	return(TRUE);
 }
 
 /*****************************************************************
-Discards a page that is the only page on its level. */
+Discards a page that is the only page on its level.  This will empty
+the whole B-tree, leaving just an empty root page.  This function
+should never be reached, because btr_compress(), which is invoked in
+delete operations, calls btr_lift_page_up() to flatten the B-tree. */
 static
 void
 btr_discard_only_page_on_level(
 /*===========================*/
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: page which is the only on its level */
+	buf_block_t*	block,	/* in: page which is the only on its level */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	rec_t*	node_ptr;
-	page_t*	father_page;
-	ulint	page_level;
-
-	ut_ad(btr_page_get_prev(page, mtr) == FIL_NULL);
-	ut_ad(btr_page_get_next(page, mtr) == FIL_NULL);
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
-	btr_search_drop_page_hash_index(page);
-
-	node_ptr = btr_page_get_father_node_ptr(index, page, mtr);
-	father_page = buf_frame_align(node_ptr);
-
-	page_level = btr_page_get_level(page, mtr);
-
-	lock_update_discard(page_get_supremum_rec(father_page), page);
-
-	btr_page_set_level(father_page, page_level, mtr);
-
-	/* Free the file page */
-	btr_page_free(index, page, mtr);
-
-	if (buf_frame_get_page_no(father_page) == dict_index_get_page(index)) {
-		/* The father is the root page */
-
-		btr_page_empty(father_page, mtr);
-
-		/* We play safe and reset the free bits for the father */
-		ibuf_reset_free_bits(index, father_page);
-	} else {
-		ut_ad(page_get_n_recs(father_page) == 1);
-
-		btr_discard_only_page_on_level(index, father_page, mtr);
+	ulint	page_level = 0;
+
+	while (buf_block_get_page_no(block) != dict_index_get_page(index)) {
+		btr_cur_t	cursor;
+		buf_block_t*	father;
+		const page_t*	page	= buf_block_get_frame(block);
+
+		ut_a(page_get_n_recs(page) == 1);
+		ut_a(page_level == btr_page_get_level(page, mtr));
+		ut_a(btr_page_get_prev(page, mtr) == FIL_NULL);
+		ut_a(btr_page_get_next(page, mtr) == FIL_NULL);
+
+		ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+		btr_search_drop_page_hash_index(block);
+
+		btr_page_get_father(index, block, mtr, &cursor);
+		father = btr_cur_get_block(&cursor);
+
+		lock_update_discard(father, PAGE_HEAP_NO_SUPREMUM, block);
+
+		/* Free the file page */
+		btr_page_free(index, block, mtr);
+
+		block = father;
+		page_level++;
+	}
+
+	/* block is the root page, which must be empty, except
+	for the node pointer to the (now discarded) block(s). */
+
+#ifdef UNIV_BTR_DEBUG
+	if (!dict_index_is_ibuf(index)) {
+		const page_t*	root	= buf_block_get_frame(block);
+		const ulint	space	= dict_index_get_space(index);
+		ut_a(btr_root_fseg_validate(FIL_PAGE_DATA + PAGE_BTR_SEG_LEAF
+					    + root, space));
+		ut_a(btr_root_fseg_validate(FIL_PAGE_DATA + PAGE_BTR_SEG_TOP
+					    + root, space));
+	}
+#endif /* UNIV_BTR_DEBUG */
+
+	btr_page_empty(block, buf_block_get_page_zip(block), index, 0, mtr);
+
+	/* We play it safe and reset the free bits for the root */
+	if (!dict_index_is_clust(index)) {
+		ibuf_reset_free_bits(block);
 	}
 }
 
@@ -2255,7 +2787,7 @@
 Discards a page from a B-tree. This is used to remove the last record from
 a B-tree page: the whole page must be removed at the same time. This cannot
 be used for the root page, which is allowed to be empty. */
-
+UNIV_INTERN
 void
 btr_discard_page(
 /*=============*/
@@ -2265,85 +2797,104 @@
 {
 	dict_index_t*	index;
 	ulint		space;
+	ulint		zip_size;
 	ulint		left_page_no;
 	ulint		right_page_no;
+	buf_block_t*	merge_block;
 	page_t*		merge_page;
+	buf_block_t*	block;
 	page_t*		page;
 	rec_t*		node_ptr;
 
-	page = btr_cur_get_page(cursor);
+	block = btr_cur_get_block(cursor);
 	index = btr_cur_get_index(cursor);
 
-	ut_ad(dict_index_get_page(index) != buf_frame_get_page_no(page));
+	ut_ad(dict_index_get_page(index) != buf_block_get_page_no(block));
 	ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index),
 				MTR_MEMO_X_LOCK));
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 	space = dict_index_get_space(index);
+	zip_size = dict_table_zip_size(index->table);
 
 	/* Decide the page which will inherit the locks */
 
-	left_page_no = btr_page_get_prev(page, mtr);
-	right_page_no = btr_page_get_next(page, mtr);
+	left_page_no = btr_page_get_prev(buf_block_get_frame(block), mtr);
+	right_page_no = btr_page_get_next(buf_block_get_frame(block), mtr);
 
 	if (left_page_no != FIL_NULL) {
-		merge_page = btr_page_get(space, left_page_no, RW_X_LATCH,
-					  mtr);
+		merge_block = btr_block_get(space, zip_size, left_page_no,
+					    RW_X_LATCH, mtr);
+		merge_page = buf_block_get_frame(merge_block);
 #ifdef UNIV_BTR_DEBUG
 		ut_a(btr_page_get_next(merge_page, mtr)
-		     == buf_frame_get_page_no(page));
+		     == buf_block_get_page_no(block));
 #endif /* UNIV_BTR_DEBUG */
 	} else if (right_page_no != FIL_NULL) {
-		merge_page = btr_page_get(space, right_page_no, RW_X_LATCH,
-					  mtr);
+		merge_block = btr_block_get(space, zip_size, right_page_no,
+					    RW_X_LATCH, mtr);
+		merge_page = buf_block_get_frame(merge_block);
 #ifdef UNIV_BTR_DEBUG
 		ut_a(btr_page_get_prev(merge_page, mtr)
-		     == buf_frame_get_page_no(page));
+		     == buf_block_get_page_no(block));
 #endif /* UNIV_BTR_DEBUG */
 	} else {
-		btr_discard_only_page_on_level(index, page, mtr);
+		btr_discard_only_page_on_level(index, block, mtr);
 
 		return;
 	}
 
+	page = buf_block_get_frame(block);
 	ut_a(page_is_comp(merge_page) == page_is_comp(page));
-	btr_search_drop_page_hash_index(page);
+	btr_search_drop_page_hash_index(block);
 
-	if (left_page_no == FIL_NULL && btr_page_get_level(page, mtr) > 0) {
+	if (left_page_no == FIL_NULL && !page_is_leaf(page)) {
 
 		/* We have to mark the leftmost node pointer on the right
 		side page as the predefined minimum record */
-
 		node_ptr = page_rec_get_next(page_get_infimum_rec(merge_page));
 
 		ut_ad(page_rec_is_user_rec(node_ptr));
 
-		btr_set_min_rec_mark(node_ptr, page_is_comp(merge_page), mtr);
+		/* This will make page_zip_validate() fail on merge_page
+		until btr_level_list_remove() completes.  This is harmless,
+		because everything will take place within a single
+		mini-transaction and because writing to the redo log
+		is an atomic operation (performed by mtr_commit()). */
+		btr_set_min_rec_mark(node_ptr, mtr);
 	}
 
-	btr_node_ptr_delete(index, page, mtr);
+	btr_node_ptr_delete(index, block, mtr);
 
 	/* Remove the page from the level list */
-	btr_level_list_remove(page, mtr);
+	btr_level_list_remove(space, zip_size, page, mtr);
+#ifdef UNIV_ZIP_DEBUG
+	{
+		page_zip_des_t*	merge_page_zip
+			= buf_block_get_page_zip(merge_block);
+		ut_a(!merge_page_zip
+		     || page_zip_validate(merge_page_zip, merge_page));
+	}
+#endif /* UNIV_ZIP_DEBUG */
 
 	if (left_page_no != FIL_NULL) {
-		lock_update_discard(page_get_supremum_rec(merge_page), page);
+		lock_update_discard(merge_block, PAGE_HEAP_NO_SUPREMUM,
+				    block);
 	} else {
-		lock_update_discard(page_rec_get_next(
-					    page_get_infimum_rec(merge_page)),
-				    page);
+		lock_update_discard(merge_block,
+				    lock_get_min_heap_no(merge_block),
+				    block);
 	}
 
 	/* Free the file page */
-	btr_page_free(index, page, mtr);
+	btr_page_free(index, block, mtr);
 
-	ut_ad(btr_check_node_ptr(index, merge_page, mtr));
+	ut_ad(btr_check_node_ptr(index, merge_block, mtr));
 }
 
 #ifdef UNIV_BTR_PRINT
 /*****************************************************************
 Prints size info of a B-tree. */
-
+UNIV_INTERN
 void
 btr_print_size(
 /*===========*/
@@ -2353,7 +2904,7 @@
 	fseg_header_t*	seg;
 	mtr_t		mtr;
 
-	if (index->type & DICT_IBUF) {
+	if (dict_index_is_ibuf(index)) {
 		fputs("Sorry, cannot print info of an ibuf tree:"
 		      " use ibuf functions\n", stderr);
 
@@ -2387,51 +2938,53 @@
 btr_print_recursive(
 /*================*/
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: index page */
+	buf_block_t*	block,	/* in: index page */
 	ulint		width,	/* in: print this many entries from start
 				and end */
 	mem_heap_t**	heap,	/* in/out: heap for rec_get_offsets() */
 	ulint**		offsets,/* in/out: buffer for rec_get_offsets() */
 	mtr_t*		mtr)	/* in: mtr */
 {
+	const page_t*	page	= buf_block_get_frame(block);
 	page_cur_t	cursor;
 	ulint		n_recs;
 	ulint		i	= 0;
 	mtr_t		mtr2;
-	rec_t*		node_ptr;
-	page_t*		child;
 
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 	fprintf(stderr, "NODE ON LEVEL %lu page number %lu\n",
 		(ulong) btr_page_get_level(page, mtr),
-		(ulong) buf_frame_get_page_no(page));
+		(ulong) buf_block_get_page_no(block));
 
-	page_print(page, index, width, width);
+	page_print(block, index, width, width);
 
 	n_recs = page_get_n_recs(page);
 
-	page_cur_set_before_first(page, &cursor);
+	page_cur_set_before_first(block, &cursor);
 	page_cur_move_to_next(&cursor);
 
 	while (!page_cur_is_after_last(&cursor)) {
 
-		if (0 == btr_page_get_level(page, mtr)) {
+		if (page_is_leaf(page)) {
 
 			/* If this is the leaf level, do nothing */
 
 		} else if ((i <= width) || (i >= n_recs - width)) {
 
+			const rec_t*	node_ptr;
+
 			mtr_start(&mtr2);
 
 			node_ptr = page_cur_get_rec(&cursor);
 
 			*offsets = rec_get_offsets(node_ptr, index, *offsets,
 						   ULINT_UNDEFINED, heap);
-			child = btr_node_ptr_get_child(node_ptr,
-						       *offsets, &mtr2);
-			btr_print_recursive(index, child, width,
-					    heap, offsets, &mtr2);
+			btr_print_recursive(index,
+					    btr_node_ptr_get_child(node_ptr,
+								   index,
+								   *offsets,
+								   &mtr2),
+					    width, heap, offsets, &mtr2);
 			mtr_commit(&mtr2);
 		}
 
@@ -2442,7 +2995,7 @@
 
 /******************************************************************
 Prints directories and other info of all nodes in the tree. */
-
+UNIV_INTERN
 void
 btr_print_index(
 /*============*/
@@ -2451,18 +3004,18 @@
 				and end */
 {
 	mtr_t		mtr;
-	page_t*		root;
+	buf_block_t*	root;
 	mem_heap_t*	heap	= NULL;
 	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
 	ulint*		offsets	= offsets_;
-	*offsets_ = (sizeof offsets_) / sizeof *offsets_;
+	rec_offs_init(offsets_);
 
 	fputs("--------------------------\n"
 	      "INDEX TREE PRINT\n", stderr);
 
 	mtr_start(&mtr);
 
-	root = btr_root_get(index, &mtr);
+	root = btr_root_block_get(index, &mtr);
 
 	btr_print_recursive(index, root, width, &heap, &offsets, &mtr);
 	if (UNIV_LIKELY_NULL(heap)) {
@@ -2478,43 +3031,42 @@
 #ifdef UNIV_DEBUG
 /****************************************************************
 Checks that the node pointer to a page is appropriate. */
-
+UNIV_INTERN
 ibool
 btr_check_node_ptr(
 /*===============*/
 				/* out: TRUE */
 	dict_index_t*	index,	/* in: index tree */
-	page_t*		page,	/* in: index page */
+	buf_block_t*	block,	/* in: index page */
 	mtr_t*		mtr)	/* in: mtr */
 {
 	mem_heap_t*	heap;
-	rec_t*		node_ptr;
-	dtuple_t*	node_ptr_tuple;
-
-	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
-				MTR_MEMO_PAGE_X_FIX));
-	if (dict_index_get_page(index) == buf_frame_get_page_no(page)) {
-
-		return(TRUE);
-	}
-
-	node_ptr = btr_page_get_father_node_ptr(index, page, mtr);
-
-	if (btr_page_get_level(page, mtr) == 0) {
+	dtuple_t*	tuple;
+	ulint*		offsets;
+	btr_cur_t	cursor;
+	page_t*		page = buf_block_get_frame(block);
+
+	ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
+	if (dict_index_get_page(index) == buf_block_get_page_no(block)) {
 
 		return(TRUE);
 	}
 
 	heap = mem_heap_create(256);
-
-	node_ptr_tuple = dict_index_build_node_ptr(
+	offsets = btr_page_get_father_block(NULL, heap, index, block, mtr,
+					    &cursor);
+
+	if (page_is_leaf(page)) {
+
+		goto func_exit;
+	}
+
+	tuple = dict_index_build_node_ptr(
 		index, page_rec_get_next(page_get_infimum_rec(page)), 0, heap,
 		btr_page_get_level(page, mtr));
 
-	ut_a(!cmp_dtuple_rec(node_ptr_tuple, node_ptr,
-			     rec_get_offsets(node_ptr, index,
-					     NULL, ULINT_UNDEFINED, &heap)));
-
+	ut_a(!cmp_dtuple_rec(tuple, btr_cur_get_rec(&cursor), offsets));
+func_exit:
 	mem_heap_free(heap);
 
 	return(TRUE);
@@ -2527,40 +3079,40 @@
 void
 btr_index_rec_validate_report(
 /*==========================*/
-	page_t*		page,	/* in: index page */
-	rec_t*		rec,	/* in: index record */
-	dict_index_t*	index)	/* in: index */
+	const page_t*		page,	/* in: index page */
+	const rec_t*		rec,	/* in: index record */
+	const dict_index_t*	index)	/* in: index */
 {
 	fputs("InnoDB: Record in ", stderr);
 	dict_index_name_print(stderr, NULL, index);
 	fprintf(stderr, ", page %lu, at offset %lu\n",
-		buf_frame_get_page_no(page), (ulint)(rec - page));
+		page_get_page_no(page), (ulint) page_offset(rec));
 }
 
 /****************************************************************
 Checks the size and number of fields in a record based on the definition of
 the index. */
-
+UNIV_INTERN
 ibool
 btr_index_rec_validate(
 /*===================*/
-					/* out: TRUE if ok */
-	rec_t*		rec,		/* in: index record */
-	dict_index_t*	index,		/* in: index */
-	ibool		dump_on_error)	/* in: TRUE if the function
-					should print hex dump of record
-					and page on error */
+						/* out: TRUE if ok */
+	const rec_t*		rec,		/* in: index record */
+	const dict_index_t*	index,		/* in: index */
+	ibool			dump_on_error)	/* in: TRUE if the function
+						should print hex dump of record
+						and page on error */
 {
 	ulint		len;
 	ulint		n;
 	ulint		i;
-	page_t*		page;
+	const page_t*	page;
 	mem_heap_t*	heap	= NULL;
 	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
 	ulint*		offsets	= offsets_;
-	*offsets_ = (sizeof offsets_) / sizeof *offsets_;
+	rec_offs_init(offsets_);
 
-	page = buf_frame_align(rec);
+	page = page_align(rec);
 
 	if (UNIV_UNLIKELY(index->type & DICT_UNIVERSAL)) {
 		/* The insert buffer index tree can contain records from any
@@ -2589,7 +3141,7 @@
 			(ulong) rec_get_n_fields_old(rec), (ulong) n);
 
 		if (dump_on_error) {
-			buf_page_print(page);
+			buf_page_print(page, 0);
 
 			fputs("InnoDB: corrupt record ", stderr);
 			rec_print_old(stderr, rec);
@@ -2604,7 +3156,7 @@
 		ulint	fixed_size = dict_col_get_fixed_size(
 			dict_index_get_nth_col(index, i));
 
-		rec_get_nth_field(rec, offsets, i, &len);
+		rec_get_nth_field_offs(offsets, i, &len);
 
 		/* Note that if fixed_size != 0, it equals the
 		length of a fixed-size column in the clustered index.
@@ -2627,7 +3179,7 @@
 				(ulong) i, (ulong) len, (ulong) fixed_size);
 
 			if (dump_on_error) {
-				buf_page_print(page);
+				buf_page_print(page, 0);
 
 				fputs("InnoDB: corrupt record ", stderr);
 				rec_print_new(stderr, rec, offsets);
@@ -2654,13 +3206,13 @@
 btr_index_page_validate(
 /*====================*/
 				/* out: TRUE if ok */
-	page_t*		page,	/* in: index page */
+	buf_block_t*	block,	/* in: index page */
 	dict_index_t*	index)	/* in: index */
 {
 	page_cur_t	cur;
 	ibool		ret	= TRUE;
 
-	page_cur_set_before_first(page, &cur);
+	page_cur_set_before_first(block, &cur);
 	page_cur_move_to_next(&cur);
 
 	for (;;) {
@@ -2686,13 +3238,13 @@
 void
 btr_validate_report1(
 /*=================*/
-				/* out: TRUE if ok */
-	dict_index_t*	index,	/* in: index */
-	ulint		level,	/* in: B-tree level */
-	page_t*		page)	/* in: index page */
+					/* out: TRUE if ok */
+	dict_index_t*		index,	/* in: index */
+	ulint			level,	/* in: B-tree level */
+	const buf_block_t*	block)	/* in: index page */
 {
 	fprintf(stderr, "InnoDB: Error in page %lu of ",
-		buf_frame_get_page_no(page));
+		buf_block_get_page_no(block));
 	dict_index_name_print(stderr, NULL, index);
 	if (level) {
 		fprintf(stderr, ", index tree level %lu", level);
@@ -2706,15 +3258,15 @@
 void
 btr_validate_report2(
 /*=================*/
-				/* out: TRUE if ok */
-	dict_index_t*	index,	/* in: index */
-	ulint		level,	/* in: B-tree level */
-	page_t*		page1,	/* in: first index page */
-	page_t*		page2)	/* in: second index page */
+					/* out: TRUE if ok */
+	const dict_index_t*	index,	/* in: index */
+	ulint			level,	/* in: B-tree level */
+	const buf_block_t*	block1,	/* in: first index page */
+	const buf_block_t*	block2)	/* in: second index page */
 {
 	fprintf(stderr, "InnoDB: Error in pages %lu and %lu of ",
-		buf_frame_get_page_no(page1),
-		buf_frame_get_page_no(page2));
+		buf_block_get_page_no(block1),
+		buf_block_get_page_no(block2));
 	dict_index_name_print(stderr, NULL, index);
 	if (level) {
 		fprintf(stderr, ", index tree level %lu", level);
@@ -2734,12 +3286,14 @@
 	ulint		level)	/* in: level number */
 {
 	ulint		space;
+	ulint		zip_size;
+	buf_block_t*	block;
 	page_t*		page;
+	buf_block_t*	right_block = 0; /* remove warning */
 	page_t*		right_page = 0; /* remove warning */
 	page_t*		father_page;
-	page_t*		right_father_page;
-	rec_t*		node_ptr;
-	rec_t*		right_node_ptr;
+	btr_cur_t	node_cur;
+	btr_cur_t	right_node_cur;
 	rec_t*		rec;
 	ulint		right_page_no;
 	ulint		left_page_no;
@@ -2750,26 +3304,39 @@
 	mem_heap_t*	heap	= mem_heap_create(256);
 	ulint*		offsets	= NULL;
 	ulint*		offsets2= NULL;
+#ifdef UNIV_ZIP_DEBUG
+	page_zip_des_t*	page_zip;
+#endif /* UNIV_ZIP_DEBUG */
 
 	mtr_start(&mtr);
 
 	mtr_x_lock(dict_index_get_lock(index), &mtr);
 
-	page = btr_root_get(index, &mtr);
+	block = btr_root_block_get(index, &mtr);
+	page = buf_block_get_frame(block);
 
-	space = buf_frame_get_space_id(page);
+	space = dict_index_get_space(index);
+	zip_size = dict_table_zip_size(index->table);
 
 	while (level != btr_page_get_level(page, &mtr)) {
-
-		ut_a(btr_page_get_level(page, &mtr) > 0);
-
-		page_cur_set_before_first(page, &cursor);
+		const rec_t*	node_ptr;
+
+		ut_a(space == buf_block_get_space(block));
+		ut_a(space == page_get_space_id(page));
+#ifdef UNIV_ZIP_DEBUG
+		page_zip = buf_block_get_page_zip(block);
+		ut_a(!page_zip || page_zip_validate(page_zip, page));
+#endif /* UNIV_ZIP_DEBUG */
+		ut_a(!page_is_leaf(page));
+
+		page_cur_set_before_first(block, &cursor);
 		page_cur_move_to_next(&cursor);
 
 		node_ptr = page_cur_get_rec(&cursor);
 		offsets = rec_get_offsets(node_ptr, index, offsets,
 					  ULINT_UNDEFINED, &heap);
-		page = btr_node_ptr_get_child(node_ptr, offsets, &mtr);
+		block = btr_node_ptr_get_child(node_ptr, index, offsets, &mtr);
+		page = buf_block_get_frame(block);
 	}
 
 	/* Now we are on the desired level. Loop through the pages on that
@@ -2784,17 +3351,22 @@
 	offsets = offsets2 = NULL;
 	mtr_x_lock(dict_index_get_lock(index), &mtr);
 
+#ifdef UNIV_ZIP_DEBUG
+	page_zip = buf_block_get_page_zip(block);
+	ut_a(!page_zip || page_zip_validate(page_zip, page));
+#endif /* UNIV_ZIP_DEBUG */
+
 	/* Check ordering etc. of records */
 
 	if (!page_validate(page, index)) {
-		btr_validate_report1(index, level, page);
+		btr_validate_report1(index, level, block);
 
 		ret = FALSE;
 	} else if (level == 0) {
 		/* We are on level 0. Check that the records have the right
 		number of fields, and field lengths are right. */
 
-		if (!btr_index_page_validate(page, index)) {
+		if (!btr_index_page_validate(block, index)) {
 
 			ret = FALSE;
 		}
@@ -2805,32 +3377,32 @@
 	right_page_no = btr_page_get_next(page, &mtr);
 	left_page_no = btr_page_get_prev(page, &mtr);
 
-	ut_a((page_get_n_recs(page) > 0)
-	     || ((level == 0)
-		 && (buf_frame_get_page_no(page)
-		     == dict_index_get_page(index))));
+	ut_a(page_get_n_recs(page) > 0 || (level == 0
+					   && page_get_page_no(page)
+					   == dict_index_get_page(index)));
 
 	if (right_page_no != FIL_NULL) {
-		rec_t*	right_rec;
-		right_page = btr_page_get(space, right_page_no, RW_X_LATCH,
-					  &mtr);
+		const rec_t*	right_rec;
+		right_block = btr_block_get(space, zip_size, right_page_no,
+					    RW_X_LATCH, &mtr);
+		right_page = buf_block_get_frame(right_block);
 		if (UNIV_UNLIKELY(btr_page_get_prev(right_page, &mtr)
-				  != buf_frame_get_page_no(page))) {
-			btr_validate_report2(index, level, page, right_page);
+				  != page_get_page_no(page))) {
+			btr_validate_report2(index, level, block, right_block);
 			fputs("InnoDB: broken FIL_PAGE_NEXT"
 			      " or FIL_PAGE_PREV links\n", stderr);
-			buf_page_print(page);
-			buf_page_print(right_page);
+			buf_page_print(page, 0);
+			buf_page_print(right_page, 0);
 
 			ret = FALSE;
 		}
 
 		if (UNIV_UNLIKELY(page_is_comp(right_page)
 				  != page_is_comp(page))) {
-			btr_validate_report2(index, level, page, right_page);
+			btr_validate_report2(index, level, block, right_block);
 			fputs("InnoDB: 'compact' flag mismatch\n", stderr);
-			buf_page_print(page);
-			buf_page_print(right_page);
+			buf_page_print(page, 0);
+			buf_page_print(right_page, 0);
 
 			ret = FALSE;
 
@@ -2848,13 +3420,13 @@
 					      offsets, offsets2,
 					      index) >= 0)) {
 
-			btr_validate_report2(index, level, page, right_page);
+			btr_validate_report2(index, level, block, right_block);
 
 			fputs("InnoDB: records in wrong order"
 			      " on adjacent pages\n", stderr);
 
-			buf_page_print(page);
-			buf_page_print(right_page);
+			buf_page_print(page, 0);
+			buf_page_print(right_page, 0);
 
 			fputs("InnoDB: record ", stderr);
 			rec = page_rec_get_prev(page_get_supremum_rec(page));
@@ -2876,54 +3448,54 @@
 			     page_is_comp(page)));
 	}
 
-	if (buf_frame_get_page_no(page) != dict_index_get_page(index)) {
+	if (buf_block_get_page_no(block) != dict_index_get_page(index)) {
 
 		/* Check father node pointers */
 
-		node_ptr = btr_page_get_father_node_ptr(index, page, &mtr);
-		father_page = buf_frame_align(node_ptr);
-		offsets	= rec_get_offsets(node_ptr, index,
-					  offsets, ULINT_UNDEFINED, &heap);
-
-		if (btr_node_ptr_get_child_page_no(node_ptr, offsets)
-		    != buf_frame_get_page_no(page)
-		    || node_ptr != btr_page_get_father_for_rec(
-			    index, page,
-			    page_rec_get_prev(page_get_supremum_rec(page)),
-			    &mtr)) {
-			btr_validate_report1(index, level, page);
+		rec_t*	node_ptr;
+
+		offsets = btr_page_get_father_block(offsets, heap, index,
+						    block, &mtr, &node_cur);
+		father_page = btr_cur_get_page(&node_cur);
+		node_ptr = btr_cur_get_rec(&node_cur);
+
+		btr_cur_position(
+			index, page_rec_get_prev(page_get_supremum_rec(page)),
+			block, &node_cur);
+		offsets = btr_page_get_father_node_ptr(offsets, heap,
+						       &node_cur, &mtr);
+
+		if (UNIV_UNLIKELY(node_ptr != btr_cur_get_rec(&node_cur))
+		    || UNIV_UNLIKELY(btr_node_ptr_get_child_page_no(node_ptr,
+								    offsets)
+				     != buf_block_get_page_no(block))) {
+
+			btr_validate_report1(index, level, block);
 
 			fputs("InnoDB: node pointer to the page is wrong\n",
 			      stderr);
 
-			buf_page_print(father_page);
-			buf_page_print(page);
+			buf_page_print(father_page, 0);
+			buf_page_print(page, 0);
 
 			fputs("InnoDB: node ptr ", stderr);
-			rec_print_new(stderr, node_ptr, offsets);
+			rec_print(stderr, node_ptr, index);
 
+			rec = btr_cur_get_rec(&node_cur);
 			fprintf(stderr, "\n"
 				"InnoDB: node ptr child page n:o %lu\n",
-				(unsigned long) btr_node_ptr_get_child_page_no
-				(node_ptr, offsets));
+				(ulong) btr_node_ptr_get_child_page_no(
+					rec, offsets));
 
 			fputs("InnoDB: record on page ", stderr);
-			rec = btr_page_get_father_for_rec(
-				index, page,
-				page_rec_get_prev(page_get_supremum_rec(page)),
-				&mtr);
-			rec_print(stderr, rec, index);
+			rec_print_new(stderr, rec, offsets);
 			putc('\n', stderr);
 			ret = FALSE;
 
 			goto node_ptr_fails;
 		}
 
-		if (btr_page_get_level(page, &mtr) > 0) {
-			offsets	= rec_get_offsets(node_ptr, index,
-						  offsets, ULINT_UNDEFINED,
-						  &heap);
-
+		if (!page_is_leaf(page)) {
 			node_ptr_tuple = dict_index_build_node_ptr(
 				index,
 				page_rec_get_next(page_get_infimum_rec(page)),
@@ -2931,13 +3503,13 @@
 
 			if (cmp_dtuple_rec(node_ptr_tuple, node_ptr,
 					   offsets)) {
-				rec_t*	first_rec	= page_rec_get_next(
+				const rec_t* first_rec = page_rec_get_next(
 					page_get_infimum_rec(page));
 
-				btr_validate_report1(index, level, page);
+				btr_validate_report1(index, level, block);
 
-				buf_page_print(father_page);
-				buf_page_print(page);
+				buf_page_print(father_page, 0);
+				buf_page_print(page, 0);
 
 				fputs("InnoDB: Error: node ptrs differ"
 				      " on levels > 0\n"
@@ -2963,30 +3535,35 @@
 				     page_get_supremum_rec(father_page)));
 			ut_a(btr_page_get_next(father_page, &mtr) == FIL_NULL);
 		} else {
-			right_node_ptr = btr_page_get_father_node_ptr(
-				index, right_page, &mtr);
-			if (page_rec_get_next(node_ptr)
+			const rec_t*	right_node_ptr
+				= page_rec_get_next(node_ptr);
+
+			offsets = btr_page_get_father_block(
+				offsets, heap, index, right_block,
+				&mtr, &right_node_cur);
+			if (right_node_ptr
 			    != page_get_supremum_rec(father_page)) {
 
-				if (right_node_ptr
-				    != page_rec_get_next(node_ptr)) {
+				if (btr_cur_get_rec(&right_node_cur)
+				    != right_node_ptr) {
 					ret = FALSE;
 					fputs("InnoDB: node pointer to"
 					      " the right page is wrong\n",
 					      stderr);
 
 					btr_validate_report1(index, level,
-							     page);
+							     block);
 
-					buf_page_print(father_page);
-					buf_page_print(page);
-					buf_page_print(right_page);
+					buf_page_print(father_page, 0);
+					buf_page_print(page, 0);
+					buf_page_print(right_page, 0);
 				}
 			} else {
-				right_father_page = buf_frame_align(
-					right_node_ptr);
+				page_t*	right_father_page
+					= btr_cur_get_page(&right_node_cur);
 
-				if (right_node_ptr != page_rec_get_next(
+				if (btr_cur_get_rec(&right_node_cur)
+				    != page_rec_get_next(
 					    page_get_infimum_rec(
 						    right_father_page))) {
 					ret = FALSE;
@@ -2995,15 +3572,15 @@
 					      stderr);
 
 					btr_validate_report1(index, level,
-							     page);
+							     block);
 
-					buf_page_print(father_page);
-					buf_page_print(right_father_page);
-					buf_page_print(page);
-					buf_page_print(right_page);
+					buf_page_print(father_page, 0);
+					buf_page_print(right_father_page, 0);
+					buf_page_print(page, 0);
+					buf_page_print(right_page, 0);
 				}
 
-				if (buf_frame_get_page_no(right_father_page)
+				if (page_get_page_no(right_father_page)
 				    != btr_page_get_next(father_page, &mtr)) {
 
 					ret = FALSE;
@@ -3012,12 +3589,12 @@
 					      stderr);
 
 					btr_validate_report1(index, level,
-							     page);
+							     block);
 
-					buf_page_print(father_page);
-					buf_page_print(right_father_page);
-					buf_page_print(page);
-					buf_page_print(right_page);
+					buf_page_print(father_page, 0);
+					buf_page_print(right_father_page, 0);
+					buf_page_print(page, 0);
+					buf_page_print(right_page, 0);
 				}
 			}
 		}
@@ -3032,7 +3609,9 @@
 	if (right_page_no != FIL_NULL) {
 		mtr_start(&mtr);
 
-		page = btr_page_get(space, right_page_no, RW_X_LATCH, &mtr);
+		block = btr_block_get(space, zip_size, right_page_no,
+				      RW_X_LATCH, &mtr);
+		page = buf_block_get_frame(block);
 
 		goto loop;
 	}
@@ -3043,7 +3622,7 @@
 
 /******************************************************************
 Checks the consistency of an index tree. */
-
+UNIV_INTERN
 ibool
 btr_validate_index(
 /*===============*/

=== modified file 'storage/innobase/btr/btr0cur.c'
--- storage/innobase/btr/btr0cur.c	2008-12-14 18:13:36 +0000
+++ storage/innobase/btr/btr0cur.c	2009-03-31 04:19:17 +0000
@@ -1,3 +1,28 @@
+/*****************************************************************************
+
+Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
+Copyright (c) 2008, Google Inc.
+
+Portions of this file contain modifications contributed and copyrighted by
+Google, Inc. Those modifications are gratefully acknowledged and are described
+briefly in the InnoDB documentation. The contributions by Google are
+incorporated with their permission, and subject to the conditions contained in
+the file COPYING.Google.
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place, Suite 330, Boston, MA 02111-1307 USA
+
+*****************************************************************************/
+
 /******************************************************
 The index tree cursor
 
@@ -12,8 +37,6 @@
 if leaf splitting has been started, it is difficult to undo, except
 by crashing the database and doing a roll-forward.
 
-(c) 1994-2001 Innobase Oy
-
 Created 10/16/1994 Heikki Tuuri
 *******************************************************/
 
@@ -24,38 +47,38 @@
 #endif
 
 #include "page0page.h"
+#include "page0zip.h"
 #include "rem0rec.h"
 #include "rem0cmp.h"
+#include "buf0lru.h"
 #include "btr0btr.h"
 #include "btr0sea.h"
 #include "row0upd.h"
 #include "trx0rec.h"
+#include "trx0roll.h" /* trx_is_recv() */
 #include "que0que.h"
 #include "row0row.h"
 #include "srv0srv.h"
 #include "ibuf0ibuf.h"