was actually fetched.  ext->len[i] == 0 is reserved to mean an uninitialized
BLOB pointer.

* Change terminology:
  wait lock -> requested lock
  waited lock -> blocking lock
  new: requesting transaction (the trx what owns the requested lock)
  new: blocking transaction (the trx that owns the blocking lock)

* Add transaction ids to INFORMATION_SCHEMA.INNODB_LOCK_WAITS. This is
  somewhat redundant because transaction ids can be found in INNODB_LOCKS
  (which can be joined with INNODB_LOCK_WAITS) but would help users to
  write shorter joins (one table less) in some cases where they want to
  find which transaction is blocking which.

Suggested by:	Ken
Approved by:	Heikki

in r2131.

have been removed in r2131.

Only add indexed BLOBs to row_ext.

trx_undo_rec_get_partial_row(): Move the BLOB fetching to row_ext_create().

row_build(): Pass only those BLOBs to row_ext_create() that are referenced by
ordering columns of some indexes, similar to trx_undo_rec_get_partial_row().

row_ext_create(): Add the parameter "tuple".  Move the implementation
from row0ext.ic to row0ext.c.

row_ext_lookup_ith(), row_ext_lookup(): Return a const pointer.  Remove
the parameters "field" and "f_len".  Make the row_ext_t* parameter const.

row_ext_t: Remove the field zip_size.

field_ref_zero[]: Declare in btr0types.h instead of btr0cur.h.

row_ext_lookup_low(): Rename to row_ext_cache_fill() and change the
signature.

univ.i: Do not define UNIV_DEBUG, UNIV_ZIP_DEBUG.

btr_cur_del_unmark_for_ibuf(): Use the same comment in both btr0cur.c and
btr0cur.h.  Wrap long lines.

contents end up with conflicting versions of a record's state. The zipped
page record was not being marked as "(un)deleted" because we were not
passing the zipped page contents to the (un)delete function, which first
(un)delete marks the uncompressed version and then based on whether
page_zip is NULL or not (un)delete marks the record in the compressed page.

for dropping the index trees, and set the dictionary operation flag, similar
to what ha_innobase::add_index() does.  This should ensure correct crash
recovery.

only for those externally stored columns that occur in the ordering columns
of indexes.  Prefetch the prefixes of those columns, because the clustered
index record and the BLOBs may have been deleted by the time when the
purge thread needs to read the BLOB prefixes.

row_ext_create(): Add the debug assertion ut_ad(ut_is_2pow(zip_size)).

in signedness that were introduced in r2114.

row_upd_index_replace_new_col_vals_index_pos(),
row_upd_index_replace_new_col_vals(): Declare "data" as const byte*
instead of const char*, and add casts to the dtype_get_at_most_n_mbchars()
calls.

buf_block_is_uncompressed(): Check that the pointer is aligned.  Use the
C modulus operator % instead of ut_align_offset(), because sizeof(buf_block_t)
is not guaranteed to be a power of 2.

assert ut_a(entry) instead of playing it safe.

point to a buffer pool chunk that has been released when resizing the
buffer pool.

buf_block_is_uncompressed(): Check that the pointer is aligned.  Thanks
to this check, it is safe to pass an arbitrary pointer as a guess
to buf_page_get_gen().

buf_page_get_release_on_io(): Removed this unused function.

ibuf_build_entry_from_ibuf_rec(): Justify why it is not necessary to
add system columns to the dummy table pointed to by the dummy secondary index.

page_zip_rec_set_deleted(): Add a page_zip_validate() assertion.

Add the transaction's weight to information_schema.innodb_trx table.

Suggested by:	Ken
Approved by:	Heikki

static.  It is only called from lock0lock.c.

inserted, uncommitted clustered index records when determining if a
secondary index record that contains a column prefix of an externally
stored column is referencing the clustered index record.

field_ref_zero[]: A BLOB pointer full of zero, for use in comparisons.

btr_copy_externally_stored_field_prefix(): Assert that the BLOB pointer is set.

row_ext_lookup_ith(), row_ext_lookup(), row_ext_lookup_low(): Document
that field_ref_zero is returned when the BLOB cannot be fetched.

row_ext_lookup_low(): Return field_ref_zero and *len = 0 when the
BLOB pointer is unset.

row_build_index_entry(): Return NULL when a needed BLOB pointer cannot
be dereferenced (row_ext_lookup returns field_ref_zero).  Check the
return value for NULL in callers.

row_vers_impl_x_locked_off_kernel(): Avoid comparisons when
row_build_index_entry() returns NULL.

row_vers_old_has_index_entry(): Ignore records for which
row_build_index_entry() returns NULL.  The entry should never be NULL
in rollback, but it may be NULL in purge.

row_merge_buf_add(): Assert that row_ext_lookup() does not return
field_ref_zero.  The table will be locked during index creation.

btr_cur_optimistic_insert(), pass big_rec to it, so that
the field references of externally stored columns (BLOB pointers)
will not be left uninitialized after a successful optimistic insert.
This bug was spotted by Sunny.

row_upd_index_replace_new_col_vals(): Declare fetch_ext.

row_upd_index_replace_new_col_vals_index_pos(): Add a type conversion
to the initialization expression of fetch_ext, to avoid a warning about
comparison between signed and unsigned.

column prefix of an externally stored column.

row_upd_ext_fetch(): New function.

row_upd_index_replace_new_col_vals(),
row_upd_index_replace_new_col_vals_index_pos(): Fetch prefixes of
externally stored columns when they are needed for column prefix
indexes.  For memory allocation, add the parameter ext_heap.  Avoid
repeating the inner loop after finding a  matching upd_field->field_no.

column numbers are relative to the InnoDB table object, or numbers
returned by dict_col_get_no().  This will have to be ensured in
all calling code.

make use of dict_index_is_clust().

numbers are relative to the clustered index record.

btr_free_externally_stored_field(): Add some page type assertions
that were suggested by Sunny.

Fix the size of the static buffer for lock_table and lock_index.
I was not realizing that NAME_LEN contains the mbmaxlen multiplier and thus
a quote, when converted to 2 quotes, will take 2 bytes while there are 3
bytes reserved.

Spotted by:	Marko
Pointyhat to:	Vasil

Add C test for innobase_convert_name() in addition to the mysql-test one.

set the "external storage" flag.  When parsing the undo log, do not
misinterpret a SQL NULL column for externally stored.

These bugs were spotted by Heikki and Sunny.

trx_undo_page_report_modify(): Set the UNIV_EXTERN_STORAGE_FIELD flag
when needed.

trx_undo_rec_get_partial_row(): Check for len == UNIV_SQL_NULL.

Fix a bug where the static buffer for innodb_locks.lock_table may not
have enough space.

Pointyhat to:	Marko

Bugfix1: Set innodb_locks.lock_index to NOT NULL.
If a column in INFORMATION_SCHEMA table has the flag
MY_I_S_MAYBE_NULL and it is not explicitly marked as NOT NULL
with the method ::set_notnull() then it is always rendered as
NULL by MySQL.

Bugfix2: Avoid crashes if lock_index is NULL. It is NULL for table
level locks.

Pointyhat to:	Marko

Non-functional change:
Fix consistency of the sizeof() operator with the rest of i_s.cc

Pointyhat to:	Marko

Move test that depends on ucs2 to a separate file that is disabled if
ucs2 is not compiled in.

Move common SQL commands to an .inc file.

Synchronize the utf8 and ucs2 tests.

innodb_information_schema.test. Add tests that display most columns from
INFORMATION_SCHEMA.INNODB_LOCKS.  Test that quoting of table names works
and respects SQL_MODE='ANSI_QUOTES'.

innobase_print_identifier(): Remove.

innobase_convert_identifier(): New function,
based on innobase_print_identifier().

innobase_convert_name(): New function, similar to ut_print_namel(), but
using a memory buffer.

ut_print_namel(): Use innobase_convert_name().

fill_innodb_locks_from_cache(): Convert lock_table and lock_index by
calling innobase_convert_name().

Convert INFORMATION_SCHEMA tables' names to upper case so that they are
consistent with other INFORMATION_SCHEMA tables.

 mysql> show tables;
 +---------------------------------------+
 | Tables_in_information_schema          |
 +---------------------------------------+
 | CHARACTER_SETS                        | 
 | COLLATIONS                            | 
 | COLLATION_CHARACTER_SET_APPLICABILITY | 
 | COLUMNS                               | 
 | COLUMN_PRIVILEGES                     | 
 | ENGINES                               | 
 | EVENTS                                | 
 | FILES                                 | 
 | GLOBAL_STATUS                         | 
 | GLOBAL_VARIABLES                      | 
 | KEY_COLUMN_USAGE                      | 
 | PARTITIONS                            | 
 | PLUGINS                               | 
 | PROCESSLIST                           | 
 | REFERENTIAL_CONSTRAINTS               | 
 | ROUTINES                              | 
 | SCHEMATA                              | 
 | SCHEMA_PRIVILEGES                     | 
 | SESSION_STATUS                        | 
 | SESSION_VARIABLES                     | 
 | STATISTICS                            | 
 | TABLES                                | 
 | TABLE_CONSTRAINTS                     | 
 | TABLE_PRIVILEGES                      | 
 | TRIGGERS                              | 
 | USER_PRIVILEGES                       | 
 | VIEWS                                 | 
 | innodb_zip_reset                      | 
 | innodb_trx                            | 
 | innodb_locks                          | 
 | innodb_lock_waits                     | 
 | innodb_zip                            | 
 +---------------------------------------+

stored column, subtract UNIV_EXTERN_STORAGE_FIELD from the length of
the field.

Implement a limit on the memory used by the INNODB_TRX, INNODB_LOCKS and
INNODB_LOCK_WAITS tables. The maximum allowed memory is defined with the
macro TRX_I_S_MEM_LIMIT.

Approved by:	Marko (via IM)