dict0dict.c 107 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/**********************************************************************
Data dictionary system

(c) 1996 Innobase Oy

Created 1/8/1996 Heikki Tuuri
***********************************************************************/

#include "dict0dict.h"

#ifdef UNIV_NONINL
#include "dict0dict.ic"
#endif

#include "buf0buf.h"
#include "data0type.h"
#include "mach0data.h"
#include "dict0boot.h"
#include "dict0mem.h"
20
#include "dict0crea.h"
21 22
#include "trx0undo.h"
#include "btr0btr.h"
23
#include "btr0cur.h"
24 25 26 27
#include "btr0sea.h"
#include "pars0pars.h"
#include "pars0sym.h"
#include "que0que.h"
28
#include "rem0cmp.h"
29 30 31

dict_sys_t*	dict_sys	= NULL;	/* the dictionary system */

unknown's avatar
unknown committed
32
rw_lock_t	dict_operation_lock;	/* table create, drop, etc. reserve
unknown's avatar
unknown committed
33
					this in X-mode; implicit or backround
unknown's avatar
unknown committed
34 35 36 37
					operations purge, rollback, foreign
					key checks reserve this in S-mode; we
					cannot trust that MySQL protects
					implicit or background operations
unknown's avatar
unknown committed
38 39 40 41 42
					a table drop since MySQL does not
					know of them; therefore we need this;
					NOTE: a transaction which reserves
					this must keep book on the mode in
					trx->dict_operation_lock_mode */
43

44 45 46 47 48 49 50 51
#define	DICT_HEAP_SIZE		100	/* initial memory heap size when
					creating a table or index object */
#define DICT_POOL_PER_TABLE_HASH 512	/* buffer pool max size per table
					hash table fixed size in bytes */
#define DICT_POOL_PER_COL_HASH	128	/* buffer pool max size per column
					hash table fixed size in bytes */
#define DICT_POOL_PER_VARYING	4	/* buffer pool max size per data
					dictionary varying size in bytes */
52 53 54 55

/* Identifies generated InnoDB foreign key names */
static char	dict_ibfk[] = "_ibfk_";

56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
/**********************************************************************
Compares NUL-terminated UTF-8 strings case insensitively.

NOTE: the prototype of this function is copied from ha_innodb.cc! If you change
this function, you MUST change also the prototype here! */
extern
int
innobase_strcasecmp(
/*================*/
				/* out: 0 if a=b, <0 if a<b, >1 if a>b */
	const char*	a,	/* in: first string to compare */
	const char*	b);	/* in: second string to compare */

/**********************************************************************
Makes all characters in a NUL-terminated UTF-8 string lower case.

NOTE: the prototype of this function is copied from ha_innodb.cc! If you change
this function, you MUST change also the prototype here! */
extern
void
innobase_casedn_str(
/*================*/
	char*	a);	/* in/out: string to put in lower case */

80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
/**************************************************************************
Adds a column to the data dictionary hash table. */
static
void
dict_col_add_to_cache(
/*==================*/
	dict_table_t*	table,	/* in: table */
	dict_col_t*	col);	/* in: column */
/**************************************************************************
Repositions a column in the data dictionary hash table when the table name
changes. */
static
void
dict_col_reposition_in_cache(
/*=========================*/
	dict_table_t*	table,		/* in: table */
	dict_col_t*	col,		/* in: column */
97
	const char*	new_name);	/* in: new table name */
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
/**************************************************************************
Removes a column from the data dictionary hash table. */
static
void
dict_col_remove_from_cache(
/*=======================*/
	dict_table_t*	table,	/* in: table */
	dict_col_t*	col);	/* in: column */
/**************************************************************************
Removes an index from the dictionary cache. */
static
void
dict_index_remove_from_cache(
/*=========================*/
	dict_table_t*	table,	/* in: table */
	dict_index_t*	index);	/* in, own: index */
/***********************************************************************
Copies fields contained in index2 to index1. */
static
void
dict_index_copy(
/*============*/
	dict_index_t*	index1,	/* in: index to copy to */
	dict_index_t*	index2,	/* in: index to copy from */
	ulint		start,	/* in: first position to copy */
	ulint		end);	/* in: last position to copy */
/***********************************************************************
Tries to find column names for the index in the column hash table and
sets the col field of the index. */
static
ibool
dict_index_find_cols(
/*=================*/
				/* out: TRUE if success */
	dict_table_t*	table,	/* in: table */
	dict_index_t*	index);	/* in: index */	
/***********************************************************************
Builds the internal dictionary cache representation for a clustered
index, containing also system fields not defined by the user. */
static
dict_index_t*
dict_index_build_internal_clust(
/*============================*/
				/* out, own: the internal representation
				of the clustered index */
	dict_table_t*	table,	/* in: table */
	dict_index_t*	index);	/* in: user representation of a clustered
				index */	
/***********************************************************************
Builds the internal dictionary cache representation for a non-clustered
index, containing also system fields not defined by the user. */
static
dict_index_t*
dict_index_build_internal_non_clust(
/*================================*/
				/* out, own: the internal representation
				of the non-clustered index */
	dict_table_t*	table,	/* in: table */
	dict_index_t*	index);	/* in: user representation of a non-clustered
				index */	
/**************************************************************************
159
Removes a foreign constraint struct from the dictionet cache. */
160 161
static
void
162 163 164
dict_foreign_remove_from_cache(
/*===========================*/
	dict_foreign_t*	foreign);	/* in, own: foreign constraint */
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
/**************************************************************************
Prints a column data. */
static
void
dict_col_print_low(
/*===============*/
	dict_col_t*	col);	/* in: column */
/**************************************************************************
Prints an index data. */
static
void
dict_index_print_low(
/*=================*/
	dict_index_t*	index);	/* in: index */
/**************************************************************************
Prints a field data. */
static
void
dict_field_print_low(
/*=================*/
	dict_field_t*	field);	/* in: field */
186 187 188 189 190 191 192
/*************************************************************************
Frees a foreign key struct. */
static
void
dict_foreign_free(
/*==============*/
	dict_foreign_t*	foreign);	/* in, own: foreign key struct */
193

194
/* Stream for storing detailed information about the latest foreign key
195
and unique key errors */
196
FILE*	dict_foreign_err_file		= NULL;
197 198
mutex_t	dict_foreign_err_mutex; 	/* mutex protecting the foreign
					and unique error buffers */
unknown's avatar
unknown committed
199 200
	
	
unknown's avatar
unknown committed
201 202
/************************************************************************
Checks if the database name in two table names is the same. */
203

unknown's avatar
unknown committed
204 205 206
ibool
dict_tables_have_same_db(
/*=====================*/
207 208 209 210 211
				/* out: TRUE if same db name */
	const char*	name1,	/* in: table name in the form
				dbname '/' tablename */
	const char*	name2)	/* in: table name in the form
				dbname '/' tablename */
unknown's avatar
unknown committed
212
{
213 214
	for (; *name1 == *name2; name1++, name2++) {
		if (*name1 == '/') {
unknown's avatar
unknown committed
215 216
			return(TRUE);
		}
217
		ut_a(*name1); /* the names must contain '/' */
unknown's avatar
unknown committed
218 219 220 221 222 223 224
	}
	return(FALSE);
}

/************************************************************************
Return the end of table name where we have removed dbname and '/'. */
static
unknown's avatar
unknown committed
225
const char*
unknown's avatar
unknown committed
226 227
dict_remove_db_name(
/*================*/
unknown's avatar
unknown committed
228 229 230
				/* out: table name */
	const char*	name)	/* in: table name in the form
				dbname '/' tablename */
unknown's avatar
unknown committed
231
{
unknown's avatar
unknown committed
232
	const char*	s;
233 234 235 236
	s = strchr(name, '/');
	ut_a(s);
	if (s) s++;
	return(s);
unknown's avatar
unknown committed
237
}
unknown's avatar
unknown committed
238 239 240 241 242 243 244

/************************************************************************
Get the database name length in a table name. */

ulint
dict_get_db_name_len(
/*=================*/
245 246 247
				/* out: database name length */
	const char*	name)	/* in: table name in the form
				dbname '/' tablename */
unknown's avatar
unknown committed
248
{
249 250 251 252
	const char*	s;
	s = strchr(name, '/');
	ut_a(s);
	return(s - name);
unknown's avatar
unknown committed
253
}
unknown's avatar
unknown committed
254
	
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
/************************************************************************
Reserves the dictionary system mutex for MySQL. */

void
dict_mutex_enter_for_mysql(void)
/*============================*/
{
	mutex_enter(&(dict_sys->mutex));
}
	
/************************************************************************
Releases the dictionary system mutex for MySQL. */

void
dict_mutex_exit_for_mysql(void)
/*===========================*/
{
	mutex_exit(&(dict_sys->mutex));
}
	
unknown's avatar
unknown committed
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
/************************************************************************
Decrements the count of open MySQL handles to a table. */

void
dict_table_decrement_handle_count(
/*==============================*/
	dict_table_t*	table)	/* in: table */
{
	mutex_enter(&(dict_sys->mutex));

	ut_a(table->n_mysql_handles_opened > 0);

	table->n_mysql_handles_opened--;
	
	mutex_exit(&(dict_sys->mutex));
}

292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
/************************************************************************
Gets the nth column of a table. */

dict_col_t*
dict_table_get_nth_col_noninline(
/*=============================*/
				/* out: pointer to column object */
	dict_table_t*	table,	/* in: table */
	ulint		pos)	/* in: position of column */
{
	return(dict_table_get_nth_col(table, pos));
}

/************************************************************************
Gets the first index on the table (the clustered index). */

dict_index_t*
dict_table_get_first_index_noninline(
/*=================================*/
				/* out: index, NULL if none exists */
	dict_table_t*	table)	/* in: table */
{
	return(dict_table_get_first_index(table));
}

/************************************************************************
Gets the next index on the table. */

dict_index_t*
dict_table_get_next_index_noninline(
/*================================*/
				/* out: index, NULL if none left */
	dict_index_t*	index)	/* in: index */
{
	return(dict_table_get_next_index(index));
}

/**************************************************************************
Returns an index object. */

dict_index_t*
dict_table_get_index_noninline(
/*===========================*/
				/* out: index, NULL if does not exist */
	dict_table_t*	table,	/* in: table */
337
	const char*	name)	/* in: index name */
338 339 340
{
	return(dict_table_get_index(table, name));
}
unknown's avatar
unknown committed
341
	
342
/************************************************************************
unknown's avatar
Merge  
unknown committed
343
Initializes the autoinc counter. It is not an error to initialize an already
344 345 346 347 348 349
initialized counter. */

void
dict_table_autoinc_initialize(
/*==========================*/
	dict_table_t*	table,	/* in: table */
unknown's avatar
unknown committed
350
	ib_longlong	value)	/* in: next value to assign to a row */
351 352 353 354 355 356 357 358 359 360
{
	mutex_enter(&(table->autoinc_mutex));

	table->autoinc_inited = TRUE;
	table->autoinc = value;

	mutex_exit(&(table->autoinc_mutex));
}

/************************************************************************
unknown's avatar
unknown committed
361 362
Gets the next autoinc value (== autoinc counter value), 0 if not yet
initialized. If initialized, increments the counter by 1. */
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378

ib_longlong
dict_table_autoinc_get(
/*===================*/
				/* out: value for a new row, or 0 */
	dict_table_t*	table)	/* in: table */
{
	ib_longlong	value;

	mutex_enter(&(table->autoinc_mutex));

	if (!table->autoinc_inited) {

		value = 0;
	} else {
		value = table->autoinc;
unknown's avatar
unknown committed
379
		table->autoinc = table->autoinc + 1;
380 381 382 383 384 385 386
	}
	
	mutex_exit(&(table->autoinc_mutex));

	return(value);
}

unknown's avatar
unknown committed
387
/************************************************************************
388
Decrements the autoinc counter value by 1. */
unknown's avatar
unknown committed
389

390 391 392
void
dict_table_autoinc_decrement(
/*=========================*/
unknown's avatar
unknown committed
393 394 395 396
	dict_table_t*	table)	/* in: table */
{
	mutex_enter(&(table->autoinc_mutex));

397
	table->autoinc = table->autoinc - 1;
unknown's avatar
unknown committed
398 399 400 401
	
	mutex_exit(&(table->autoinc_mutex));
}

402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
/************************************************************************
Reads the next autoinc value (== autoinc counter value), 0 if not yet
initialized. */

ib_longlong
dict_table_autoinc_read(
/*====================*/
				/* out: value for a new row, or 0 */
	dict_table_t*	table)	/* in: table */
{
	ib_longlong	value;

	mutex_enter(&(table->autoinc_mutex));

	if (!table->autoinc_inited) {

		value = 0;
	} else {
		value = table->autoinc;
	}
	
	mutex_exit(&(table->autoinc_mutex));

	return(value);
}

428
/************************************************************************
unknown's avatar
unknown committed
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
Peeks the autoinc counter value, 0 if not yet initialized. Does not
increment the counter. The read not protected by any mutex! */

ib_longlong
dict_table_autoinc_peek(
/*====================*/
				/* out: value of the counter */
	dict_table_t*	table)	/* in: table */
{
	ib_longlong	value;

	if (!table->autoinc_inited) {

		value = 0;
	} else {
		value = table->autoinc;
	}

	return(value);
}

/************************************************************************
Updates the autoinc counter if the value supplied is equal or bigger than the
452 453 454 455 456
current value. If not inited, does nothing. */

void
dict_table_autoinc_update(
/*======================*/
unknown's avatar
unknown committed
457

458 459 460 461 462 463
	dict_table_t*	table,	/* in: table */
	ib_longlong	value)	/* in: value which was assigned to a row */
{
	mutex_enter(&(table->autoinc_mutex));

	if (table->autoinc_inited) {
unknown's avatar
unknown committed
464 465
		if (value >= table->autoinc) {
			table->autoinc = value + 1;
466 467 468 469 470 471
		}
	}	

	mutex_exit(&(table->autoinc_mutex));
}

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
/************************************************************************
Looks for column n in an index. */

ulint
dict_index_get_nth_col_pos(
/*=======================*/
				/* out: position in internal representation
				of the index; if not contained, returns
				ULINT_UNDEFINED */
	dict_index_t*	index,	/* in: index */
	ulint		n)	/* in: column number */
{
	dict_field_t*	field;
	dict_col_t*	col;
	ulint		pos;
	ulint		n_fields;
	
	ut_ad(index);
	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);

unknown's avatar
unknown committed
492 493
	col = dict_table_get_nth_col(index->table, n);

494 495 496 497 498 499 500 501 502 503
	if (index->type & DICT_CLUSTERED) {

		return(col->clust_pos);
	}

	n_fields = dict_index_get_n_fields(index);
	
	for (pos = 0; pos < n_fields; pos++) {
		field = dict_index_get_nth_field(index, pos);

unknown's avatar
unknown committed
504
		if (col == field->col && field->prefix_len == 0) {
505 506 507 508 509 510 511

			return(pos);
		}
	}

	return(ULINT_UNDEFINED);
}
unknown's avatar
unknown committed
512

513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
/************************************************************************
Returns TRUE if the index contains a column or a prefix of that column. */

ibool
dict_index_contains_col_or_prefix(
/*==============================*/
				/* out: TRUE if contains the column or its
				prefix */
	dict_index_t*	index,	/* in: index */
	ulint		n)	/* in: column number */
{
	dict_field_t*	field;
	dict_col_t*	col;
	ulint		pos;
	ulint		n_fields;
	
	ut_ad(index);
	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);

	if (index->type & DICT_CLUSTERED) {

		return(TRUE);
	}

	col = dict_table_get_nth_col(index->table, n);

	n_fields = dict_index_get_n_fields(index);
	
	for (pos = 0; pos < n_fields; pos++) {
		field = dict_index_get_nth_field(index, pos);

		if (col == field->col) {

			return(TRUE);
		}
	}

	return(FALSE);
}

unknown's avatar
unknown committed
553
/************************************************************************
554 555 556 557
Looks for a matching field in an index. The column has to be the same. The
column in index must be complete, or must contain a prefix longer than the
column in index2. That is, we must be able to construct the prefix in index2
from the prefix in index. */
unknown's avatar
unknown committed
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572

ulint
dict_index_get_nth_field_pos(
/*=========================*/
				/* out: position in internal representation
				of the index; if not contained, returns
				ULINT_UNDEFINED */
	dict_index_t*	index,	/* in: index from which to search */
	dict_index_t*	index2,	/* in: index */
	ulint		n)	/* in: field number in index2 */
{
	dict_field_t*	field;
	dict_field_t*	field2;
	ulint		n_fields;
	ulint		pos;
573
	
unknown's avatar
unknown committed
574 575 576 577 578 579 580 581 582 583 584
	ut_ad(index);
	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);

	field2 = dict_index_get_nth_field(index2, n);

	n_fields = dict_index_get_n_fields(index);
	
	for (pos = 0; pos < n_fields; pos++) {
		field = dict_index_get_nth_field(index, pos);

		if (field->col == field2->col
585 586 587
		    && (field->prefix_len == 0
			|| (field->prefix_len >= field2->prefix_len
			    && field2->prefix_len != 0))) {
unknown's avatar
unknown committed
588 589 590 591 592 593 594 595

			return(pos);
		}
	}

	return(ULINT_UNDEFINED);
}

596 597 598 599 600 601 602 603 604 605 606 607
/**************************************************************************
Returns a table object, based on table id, and memoryfixes it. */

dict_table_t*
dict_table_get_on_id(
/*=================*/
				/* out: table, NULL if does not exist */
	dulint	table_id,	/* in: table id */
	trx_t*	trx)		/* in: transaction handle */
{
	dict_table_t*	table;
	
608 609
	if (ut_dulint_cmp(table_id, DICT_FIELDS_ID) <= 0
	   || trx->dict_operation) {
610 611 612 613 614
		/* It is a system table which will always exist in the table
		cache: we avoid acquiring the dictionary mutex, because
		if we are doing a rollback to handle an error in TABLE
		CREATE, for example, we already have the mutex! */

615
#ifdef UNIV_SYNC_DEBUG
616
		ut_ad(mutex_own(&(dict_sys->mutex)));
617
#endif /* UNIV_SYNC_DEBUG */
618 619 620 621 622 623 624 625 626 627 628 629 630 631

		return(dict_table_get_on_id_low(table_id, trx));
	}

	mutex_enter(&(dict_sys->mutex));

	table = dict_table_get_on_id_low(table_id, trx);
	
	mutex_exit(&(dict_sys->mutex));

	return(table);
}

/************************************************************************
unknown's avatar
unknown committed
632
Looks for column n position in the clustered index. */
633 634 635 636 637 638 639 640 641 642 643 644 645

ulint
dict_table_get_nth_col_pos(
/*=======================*/
				/* out: position in internal representation
				of the clustered index */
	dict_table_t*	table,	/* in: table */
	ulint		n)	/* in: column number */
{
	return(dict_index_get_nth_col_pos(dict_table_get_first_index(table),
								n));
}

unknown's avatar
unknown committed
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
/************************************************************************
Checks if a column is in the ordering columns of the clustered index of a
table. Column prefixes are treated like whole columns. */

ibool
dict_table_col_in_clustered_key(
/*============================*/
				/* out: TRUE if the column, or its prefix, is
				in the clustered key */
	dict_table_t*	table,	/* in: table */
	ulint		n)	/* in: column number */
{
	dict_index_t*	index;
	dict_field_t*	field;
	dict_col_t*	col;
	ulint		pos;
	ulint		n_fields;
	
	ut_ad(table);

	col = dict_table_get_nth_col(table, n);

	index = dict_table_get_first_index(table);

	n_fields = dict_index_get_n_unique(index);
	
	for (pos = 0; pos < n_fields; pos++) {
		field = dict_index_get_nth_field(index, pos);

		if (col == field->col) {

			return(TRUE);
		}
	}

	return(FALSE);
}

684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
/**************************************************************************
Inits the data dictionary module. */

void
dict_init(void)
/*===========*/
{
	dict_sys = mem_alloc(sizeof(dict_sys_t));

	mutex_create(&(dict_sys->mutex));
	mutex_set_level(&(dict_sys->mutex), SYNC_DICT);

	dict_sys->table_hash = hash_create(buf_pool_get_max_size() /
					(DICT_POOL_PER_TABLE_HASH *
					UNIV_WORD_SIZE));
	dict_sys->table_id_hash = hash_create(buf_pool_get_max_size() /
					(DICT_POOL_PER_TABLE_HASH *
					UNIV_WORD_SIZE));
	dict_sys->col_hash = hash_create(buf_pool_get_max_size() /
					(DICT_POOL_PER_COL_HASH *
					UNIV_WORD_SIZE));
	dict_sys->size = 0;

	UT_LIST_INIT(dict_sys->table_LRU);
708

unknown's avatar
unknown committed
709 710
	rw_lock_create(&dict_operation_lock);
	rw_lock_set_level(&dict_operation_lock, SYNC_DICT_OPERATION);
unknown's avatar
unknown committed
711

712
	dict_foreign_err_file = os_file_create_tmpfile();
713
	ut_a(dict_foreign_err_file);
unknown's avatar
unknown committed
714 715
	mutex_create(&dict_foreign_err_mutex);
	mutex_set_level(&dict_foreign_err_mutex, SYNC_ANY_LATCH);
716 717 718 719 720 721 722 723 724 725
}

/**************************************************************************
Returns a table object and memoryfixes it. NOTE! This is a high-level
function to be used mainly from outside the 'dict' directory. Inside this
directory dict_table_get_low is usually the appropriate function. */

dict_table_t*
dict_table_get(
/*===========*/
726 727 728 729
					/* out: table, NULL if
					does not exist */
	const char*	table_name,	/* in: table name */
	trx_t*		trx)		/* in: transaction handle or NULL */
730 731 732 733 734 735 736 737 738 739 740 741
{
	dict_table_t*	table;

	UT_NOT_USED(trx);

	mutex_enter(&(dict_sys->mutex));
	
	table = dict_table_get_low(table_name);

	mutex_exit(&(dict_sys->mutex));

	if (table != NULL) {
742
	        if (!table->stat_initialized) {
743 744 745 746 747 748 749 750
			dict_update_statistics(table);
		}
	}
	
	return(table);
}

/**************************************************************************
unknown's avatar
unknown committed
751
Returns a table object and increments MySQL open handle count on the table. */
752 753 754 755

dict_table_t*
dict_table_get_and_increment_handle_count(
/*======================================*/
756 757 758 759
					/* out: table, NULL if
					does not exist */
	const char*	table_name,	/* in: table name */
	trx_t*		trx)		/* in: transaction handle or NULL */
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
{
	dict_table_t*	table;

	UT_NOT_USED(trx);

	mutex_enter(&(dict_sys->mutex));
	
	table = dict_table_get_low(table_name);

	if (table != NULL) {

	        table->n_mysql_handles_opened++;
	}

	mutex_exit(&(dict_sys->mutex));

	if (table != NULL) {
unknown's avatar
unknown committed
777
	        if (!table->stat_initialized && !table->ibd_file_missing) {
778 779 780 781 782 783 784
			dict_update_statistics(table);
		}
	}
	
	return(table);
}

785 786 787 788 789 790 791 792 793 794 795 796 797
/**************************************************************************
Adds a table object to the dictionary cache. */

void
dict_table_add_to_cache(
/*====================*/
	dict_table_t*	table)	/* in: table */
{
	ulint	fold;
	ulint	id_fold;
	ulint	i;
	
	ut_ad(table);
798
#ifdef UNIV_SYNC_DEBUG
799
	ut_ad(mutex_own(&(dict_sys->mutex)));
800
#endif /* UNIV_SYNC_DEBUG */
801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
	ut_ad(table->n_def == table->n_cols - DATA_N_SYS_COLS);
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
	ut_ad(table->cached == FALSE);
	
	fold = ut_fold_string(table->name);
	id_fold = ut_fold_dulint(table->id);
	
	table->cached = TRUE;
	
	/* NOTE: the system columns MUST be added in the following order
	(so that they can be indexed by the numerical value of DATA_ROW_ID,
	etc.) and as the last columns of the table memory object.
	The clustered index will not always physically contain all
	system columns. */

unknown's avatar
unknown committed
816
	dict_mem_table_add_col(table, "DB_ROW_ID", DATA_SYS,
unknown's avatar
unknown committed
817
			       DATA_ROW_ID, 0, 0);
unknown's avatar
unknown committed
818 819 820 821
#if DATA_ROW_ID != 0
#error "DATA_ROW_ID != 0"
#endif
	dict_mem_table_add_col(table, "DB_TRX_ID", DATA_SYS,
unknown's avatar
unknown committed
822
			       DATA_TRX_ID, 0, 0);
unknown's avatar
unknown committed
823 824 825 826 827 828 829 830
#if DATA_TRX_ID != 1
#error "DATA_TRX_ID != 1"
#endif
	dict_mem_table_add_col(table, "DB_ROLL_PTR", DATA_SYS,
			       DATA_ROLL_PTR, 0, 0);
#if DATA_ROLL_PTR != 2
#error "DATA_ROLL_PTR != 2"
#endif
831

unknown's avatar
unknown committed
832
	dict_mem_table_add_col(table, "DB_MIX_ID", DATA_SYS,
unknown's avatar
unknown committed
833
			       DATA_MIX_ID, 0, 0);
unknown's avatar
unknown committed
834 835 836 837 838 839 840 841 842
#if DATA_MIX_ID != 3
#error "DATA_MIX_ID != 3"
#endif

	/* This check reminds that if a new system column is added to
	the program, it should be dealt with here */ 
#if DATA_N_SYS_COLS != 4
#error "DATA_N_SYS_COLS != 4"
#endif
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872

	/* Look for a table with the same name: error if such exists */
	{
		dict_table_t*	table2;
		HASH_SEARCH(name_hash, dict_sys->table_hash, fold, table2,
				(ut_strcmp(table2->name, table->name) == 0));
		ut_a(table2 == NULL);
	}

	/* Look for a table with the same id: error if such exists */
	{
		dict_table_t*	table2;
		HASH_SEARCH(id_hash, dict_sys->table_id_hash, id_fold, table2,
				(ut_dulint_cmp(table2->id, table->id) == 0));
		ut_a(table2 == NULL);
	}

	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {

		table->mix_id_len = mach_dulint_get_compressed_size(
								table->mix_id);
		mach_dulint_write_compressed(table->mix_id_buf, table->mix_id);
	}

	/* Add the columns to the column hash table */
	for (i = 0; i < table->n_cols; i++) {
		dict_col_add_to_cache(table, dict_table_get_nth_col(table, i));
	}

	/* Add table to hash table of tables */
unknown's avatar
unknown committed
873 874
	HASH_INSERT(dict_table_t, name_hash, dict_sys->table_hash, fold,
								   table);
875 876 877

	/* Add table to hash table of tables based on table id */
	HASH_INSERT(dict_table_t, id_hash, dict_sys->table_id_hash, id_fold,
unknown's avatar
unknown committed
878
								   table);
879 880 881 882 883 884 885 886 887
	/* Add table to LRU list of tables */
	UT_LIST_ADD_FIRST(table_LRU, dict_sys->table_LRU, table);

	/* If the dictionary cache grows too big, trim the table LRU list */

	dict_sys->size += mem_heap_get_size(table->heap);
	/* dict_table_LRU_trim(); */
}

888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
/**************************************************************************
Looks for an index with the given id. NOTE that we do not reserve
the dictionary mutex: this function is for emergency purposes like
printing info of a corrupt database page! */

dict_index_t*
dict_index_find_on_id_low(
/*======================*/
			/* out: index or NULL if not found from cache */
	dulint	id)	/* in: index id */
{
	dict_table_t*	table;
	dict_index_t*	index;
	
	table = UT_LIST_GET_FIRST(dict_sys->table_LRU);

	while (table) {
		index = dict_table_get_first_index(table);

		while (index) {
			if (0 == ut_dulint_cmp(id, index->tree->id)) {
				/* Found */

				return(index);
			}

			index = dict_table_get_next_index(index);
		}

		table = UT_LIST_GET_NEXT(table_LRU, table);
	}

	return(NULL);
}

923 924 925 926 927 928 929 930
/**************************************************************************
Renames a table object. */

ibool
dict_table_rename_in_cache(
/*=======================*/
					/* out: TRUE if success */
	dict_table_t*	table,		/* in: table */
931
	const char*	new_name,	/* in: new name */
unknown's avatar
unknown committed
932 933 934
	ibool		rename_also_foreigns)/* in: in ALTER TABLE we want
					to preserve the original table name
					in constraints which reference it */
935
{
936 937 938 939
	dict_foreign_t*	foreign;
	dict_index_t*	index;
	ulint		fold;
	ulint		old_size;
unknown's avatar
unknown committed
940
	char*		old_name;
unknown's avatar
unknown committed
941
	ibool		success;
942
	ulint		i;
943 944
	
	ut_ad(table);
945
#ifdef UNIV_SYNC_DEBUG
946
	ut_ad(mutex_own(&(dict_sys->mutex)));
947 948
#endif /* UNIV_SYNC_DEBUG */

949 950 951 952 953 954 955 956 957 958
	old_size = mem_heap_get_size(table->heap);
	
	fold = ut_fold_string(new_name);
	
	/* Look for a table with the same name: error if such exists */
	{
		dict_table_t*	table2;
		HASH_SEARCH(name_hash, dict_sys->table_hash, fold, table2,
				(ut_strcmp(table2->name, new_name) == 0));
		if (table2) {
unknown's avatar
unknown committed
959 960 961 962 963 964 965 966 967 968 969
			fprintf(stderr,
"InnoDB: Error: dictionary cache already contains a table of name %s\n",
	 							     new_name);
			return(FALSE);
		}
	}

	/* If the table is stored in a single-table tablespace, rename the
	.ibd file */

	if (table->space != 0) {
unknown's avatar
unknown committed
970 971 972 973 974 975 976 977 978 979
		if (table->dir_path_of_temp_table != NULL) {
			fprintf(stderr,
"InnoDB: Error: trying to rename a table %s (%s) created with CREATE\n"
"InnoDB: TEMPORARY TABLE\n", table->name, table->dir_path_of_temp_table);
			success = FALSE;
		} else {
			success = fil_rename_tablespace(table->name,
						table->space, new_name);
		}

unknown's avatar
unknown committed
980 981
		if (!success) {

982 983 984 985 986 987 988 989 990 991 992 993 994 995
			return(FALSE);
		}
	}

	/* Reposition the columns in the column hash table; they are hashed
	according to the pair (table name, column name) */

	for (i = 0; i < table->n_cols; i++) {
		dict_col_reposition_in_cache(table,
				dict_table_get_nth_col(table, i), new_name);
	}

	/* Remove table from the hash tables of tables */
	HASH_DELETE(dict_table_t, name_hash, dict_sys->table_hash,
unknown's avatar
unknown committed
996
					ut_fold_string(table->name), table);
997 998
	old_name = mem_heap_strdup(table->heap, table->name);
	table->name = mem_heap_strdup(table->heap, new_name);
999 1000

	/* Add table to hash table of tables */
unknown's avatar
unknown committed
1001 1002
	HASH_INSERT(dict_table_t, name_hash, dict_sys->table_hash, fold,
								   table);
1003 1004
	dict_sys->size += (mem_heap_get_size(table->heap) - old_size);

1005 1006 1007 1008 1009 1010 1011 1012 1013
	/* Update the table_name field in indexes */
	index = dict_table_get_first_index(table);

	while (index != NULL) {
		index->table_name = table->name;
		
		index = dict_table_get_next_index(index);
	}

unknown's avatar
unknown committed
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
	if (!rename_also_foreigns) {
		/* In ALTER TABLE we think of the rename table operation
		in the direction table -> temporary table (#sql...)
		as dropping the table with the old name and creating
		a new with the new name. Thus we kind of drop the
		constraints from the dictionary cache here. The foreign key
		constraints will be inherited to the new table from the
		system tables through a call of dict_load_foreigns. */
	
		/* Remove the foreign constraints from the cache */
		foreign = UT_LIST_GET_LAST(table->foreign_list);

		while (foreign != NULL) {
			dict_foreign_remove_from_cache(foreign);
			foreign = UT_LIST_GET_LAST(table->foreign_list);
		}

		/* Reset table field in referencing constraints */

		foreign = UT_LIST_GET_FIRST(table->referenced_list);

		while (foreign != NULL) {
			foreign->referenced_table = NULL;
			foreign->referenced_index = NULL;
		
			foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
		}

		/* Make the list of referencing constraints empty */

		UT_LIST_INIT(table->referenced_list);
		
		return(TRUE);
	}

unknown's avatar
unknown committed
1049 1050 1051
	/* Update the table name fields in foreign constraints, and update also
	the constraint id of new format >= 4.0.18 constraints. Note that at
	this point we have already changed table->name to the new name. */
1052 1053 1054 1055 1056 1057 1058 1059

	foreign = UT_LIST_GET_FIRST(table->foreign_list);

	while (foreign != NULL) {
		if (ut_strlen(foreign->foreign_table_name) <
						ut_strlen(table->name)) {
			/* Allocate a longer name buffer;
			TODO: store buf len to save memory */
unknown's avatar
unknown committed
1060

1061 1062 1063 1064 1065
			foreign->foreign_table_name = mem_heap_alloc(
					foreign->heap,
					ut_strlen(table->name) + 1);
		}

1066
		strcpy(foreign->foreign_table_name, table->name);
unknown's avatar
unknown committed
1067

1068
		if (strchr(foreign->id, '/')) {
unknown's avatar
unknown committed
1069
			ulint	db_len;
1070
			char*	old_id;
unknown's avatar
unknown committed
1071 1072 1073

			/* This is a >= 4.0.18 format id */

1074
			old_id = mem_strdup(foreign->id);
unknown's avatar
unknown committed
1075 1076

			if (ut_strlen(foreign->id) > ut_strlen(old_name)
1077
						+ ((sizeof dict_ibfk) - 1)
unknown's avatar
unknown committed
1078 1079 1080 1081
			    && 0 == ut_memcmp(foreign->id, old_name,
						ut_strlen(old_name))
			    && 0 == ut_memcmp(
					foreign->id + ut_strlen(old_name),
1082
					dict_ibfk, (sizeof dict_ibfk) - 1)) {
unknown's avatar
unknown committed
1083 1084 1085

				/* This is a generated >= 4.0.18 format id */

1086
				if (ut_strlen(table->name) > ut_strlen(old_name)) {
unknown's avatar
unknown committed
1087 1088 1089 1090 1091 1092 1093 1094
					foreign->id = mem_heap_alloc(
					     foreign->heap,
						ut_strlen(table->name)
						+ ut_strlen(old_id) + 1);
				}
				
				/* Replace the prefix 'databasename/tablename'
				with the new names */
1095 1096
				strcpy(foreign->id, table->name);
				strcat(foreign->id,
unknown's avatar
unknown committed
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
						old_id + ut_strlen(old_name));
			} else {
				/* This is a >= 4.0.18 format id where the user
				gave the id name */
				db_len = dict_get_db_name_len(table->name) + 1;

				if (dict_get_db_name_len(table->name)
			    	    > dict_get_db_name_len(foreign->id)) {

					foreign->id = mem_heap_alloc(
					     foreign->heap,
				 	     db_len + ut_strlen(old_id) + 1);
				}

				/* Replace the database prefix in id with the
				one from table->name */
			
				ut_memcpy(foreign->id, table->name, db_len);

1116
				strcpy(foreign->id + db_len,
unknown's avatar
unknown committed
1117 1118
						dict_remove_db_name(old_id));
			}
1119 1120

			mem_free(old_id);
unknown's avatar
unknown committed
1121
		}
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132

		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}

	foreign = UT_LIST_GET_FIRST(table->referenced_list);

	while (foreign != NULL) {
		if (ut_strlen(foreign->referenced_table_name) <
						ut_strlen(table->name)) {
			/* Allocate a longer name buffer;
			TODO: store buf len to save memory */
unknown's avatar
unknown committed
1133

1134 1135 1136 1137 1138
			foreign->referenced_table_name = mem_heap_alloc(
					foreign->heap,
					ut_strlen(table->name) + 1);
		}

1139
		strcpy(foreign->referenced_table_name, table->name);
1140 1141 1142 1143

		foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
	}

1144 1145 1146
	return(TRUE);
}

unknown's avatar
unknown committed
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
/**************************************************************************
Change the id of a table object in the dictionary cache. This is used in
DISCARD TABLESPACE. */

void
dict_table_change_id_in_cache(
/*==========================*/
	dict_table_t*	table,	/* in: table object already in cache */
	dulint		new_id)	/* in: new id to set */
{
	ut_ad(table);
unknown's avatar
unknown committed
1158
#ifdef UNIV_SYNC_DEBUG
unknown's avatar
unknown committed
1159
	ut_ad(mutex_own(&(dict_sys->mutex)));
unknown's avatar
unknown committed
1160
#endif /* UNIV_SYNC_DEBUG */
unknown's avatar
unknown committed
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);

	/* Remove the table from the hash table of id's */

	HASH_DELETE(dict_table_t, id_hash, dict_sys->table_id_hash,
					ut_fold_dulint(table->id), table);
	table->id = new_id;

	/* Add the table back to the hash table */
	HASH_INSERT(dict_table_t, id_hash, dict_sys->table_id_hash,
					ut_fold_dulint(table->id), table);
}

1174 1175 1176 1177 1178 1179 1180 1181
/**************************************************************************
Removes a table object from the dictionary cache. */

void
dict_table_remove_from_cache(
/*=========================*/
	dict_table_t*	table)	/* in, own: table */
{
1182
	dict_foreign_t*	foreign;
1183 1184 1185 1186 1187
	dict_index_t*	index;
	ulint		size;
	ulint		i;
	
	ut_ad(table);
1188
#ifdef UNIV_SYNC_DEBUG
1189
	ut_ad(mutex_own(&(dict_sys->mutex)));
1190
#endif /* UNIV_SYNC_DEBUG */
1191 1192
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);

1193 1194 1195 1196 1197
#if 0
	fputs("Removing table ", stderr);
	ut_print_name(stderr, table->name, ULINT_UNDEFINED);
	fputs(" from dictionary cache\n", stderr);
#endif
1198

1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
	/* Remove the foreign constraints from the cache */
	foreign = UT_LIST_GET_LAST(table->foreign_list);

	while (foreign != NULL) {
		dict_foreign_remove_from_cache(foreign);
		foreign = UT_LIST_GET_LAST(table->foreign_list);
	}

	/* Reset table field in referencing constraints */

	foreign = UT_LIST_GET_FIRST(table->referenced_list);

	while (foreign != NULL) {
		foreign->referenced_table = NULL;
		foreign->referenced_index = NULL;
		
		foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
	}

1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
	/* Remove the indexes from the cache */
	index = UT_LIST_GET_LAST(table->indexes);

	while (index != NULL) {
		dict_index_remove_from_cache(table, index);
		index = UT_LIST_GET_LAST(table->indexes);
	}

	/* Remove the columns of the table from the cache */
	for (i = 0; i < table->n_cols; i++) {
		dict_col_remove_from_cache(table,
					   dict_table_get_nth_col(table, i));
	}

	/* Remove table from the hash tables of tables */
	HASH_DELETE(dict_table_t, name_hash, dict_sys->table_hash,
					ut_fold_string(table->name), table);
	HASH_DELETE(dict_table_t, id_hash, dict_sys->table_id_hash,
					ut_fold_dulint(table->id), table);

	/* Remove table from LRU list of tables */
	UT_LIST_REMOVE(table_LRU, dict_sys->table_LRU, table);

1241 1242
	mutex_free(&(table->autoinc_mutex));

1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
	size = mem_heap_get_size(table->heap);

	ut_ad(dict_sys->size >= size);

	dict_sys->size -= size;

	mem_heap_free(table->heap);
}

/**************************************************************************
Frees tables from the end of table_LRU if the dictionary cache occupies
too much space. Currently not used! */
1255

1256 1257 1258 1259 1260 1261 1262
void
dict_table_LRU_trim(void)
/*=====================*/
{
	dict_table_t*	table;
	dict_table_t*	prev_table;

1263
	ut_error;
1264

1265
#ifdef UNIV_SYNC_DEBUG
1266
	ut_ad(mutex_own(&(dict_sys->mutex)));
1267
#endif /* UNIV_SYNC_DEBUG */
1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295

	table = UT_LIST_GET_LAST(dict_sys->table_LRU);

	while (table && (dict_sys->size >
			 buf_pool_get_max_size() / DICT_POOL_PER_VARYING)) {

		prev_table = UT_LIST_GET_PREV(table_LRU, table);

		if (table->mem_fix == 0) {
			dict_table_remove_from_cache(table);
		}

		table = prev_table;
	}
}

/**************************************************************************
Adds a column to the data dictionary hash table. */
static
void
dict_col_add_to_cache(
/*==================*/
	dict_table_t*	table,	/* in: table */
	dict_col_t*	col)	/* in: column */
{
	ulint	fold;

	ut_ad(table && col);
1296
#ifdef UNIV_SYNC_DEBUG
1297
	ut_ad(mutex_own(&(dict_sys->mutex)));
1298
#endif /* UNIV_SYNC_DEBUG */
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
	
	fold = ut_fold_ulint_pair(ut_fold_string(table->name),
				  ut_fold_string(col->name));

	/* Look for a column with same table name and column name: error */
	{
		dict_col_t*	col2;
		HASH_SEARCH(hash, dict_sys->col_hash, fold, col2,
			(ut_strcmp(col->name, col2->name) == 0)
			&& (ut_strcmp((col2->table)->name, table->name)
							== 0));  
		ut_a(col2 == NULL);
	}

	HASH_INSERT(dict_col_t, hash, dict_sys->col_hash, fold, col);
}

/**************************************************************************
Removes a column from the data dictionary hash table. */
static
void
dict_col_remove_from_cache(
/*=======================*/
	dict_table_t*	table,	/* in: table */
	dict_col_t*	col)	/* in: column */
{
	ulint		fold;

	ut_ad(table && col);
1329
#ifdef UNIV_SYNC_DEBUG
1330
	ut_ad(mutex_own(&(dict_sys->mutex)));
1331
#endif /* UNIV_SYNC_DEBUG */
1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
	
	fold = ut_fold_ulint_pair(ut_fold_string(table->name),
				  ut_fold_string(col->name));

	HASH_DELETE(dict_col_t, hash, dict_sys->col_hash, fold, col);
}

/**************************************************************************
Repositions a column in the data dictionary hash table when the table name
changes. */
static
void
dict_col_reposition_in_cache(
/*=========================*/
	dict_table_t*	table,		/* in: table */
	dict_col_t*	col,		/* in: column */
1349
	const char*	new_name)	/* in: new table name */
1350 1351 1352 1353
{
	ulint		fold;

	ut_ad(table && col);
1354
#ifdef UNIV_SYNC_DEBUG
1355
	ut_ad(mutex_own(&(dict_sys->mutex)));
1356
#endif /* UNIV_SYNC_DEBUG */
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
	
	fold = ut_fold_ulint_pair(ut_fold_string(table->name),
				  ut_fold_string(col->name));

	HASH_DELETE(dict_col_t, hash, dict_sys->col_hash, fold, col);

	fold = ut_fold_ulint_pair(ut_fold_string(new_name),
				  ut_fold_string(col->name));
				  
	HASH_INSERT(dict_col_t, hash, dict_sys->col_hash, fold, col);
}

/**************************************************************************
Adds an index to the dictionary cache. */

ibool
dict_index_add_to_cache(
/*====================*/
				/* out: TRUE if success */
	dict_table_t*	table,	/* in: table on which the index is */
	dict_index_t*	index)	/* in, own: index; NOTE! The index memory
				object is freed in this function! */
{
	dict_index_t*	new_index;
	dict_tree_t*	tree;
	dict_table_t*	cluster;
	dict_field_t*	field;
	ulint		n_ord;
	ibool		success;
	ulint		i;
	
	ut_ad(index);
1390
#ifdef UNIV_SYNC_DEBUG
1391
	ut_ad(mutex_own(&(dict_sys->mutex)));
1392
#endif /* UNIV_SYNC_DEBUG */
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
	ut_ad(index->n_def == index->n_fields);
	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
	
	ut_ad(mem_heap_validate(index->heap));

	{
		dict_index_t*	index2;
		index2 = UT_LIST_GET_FIRST(table->indexes);

		while (index2 != NULL) {
			ut_ad(ut_strcmp(index->name, index2->name) != 0);

			index2 = UT_LIST_GET_NEXT(indexes, index2);
		}

		ut_a(UT_LIST_GET_LEN(table->indexes) == 0
	      			|| (index->type & DICT_CLUSTERED) == 0);
	}

	success = dict_index_find_cols(table, index);

	if (!success) {
		dict_mem_index_free(index);

		return(FALSE);
	}
1419
	
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461
	/* Build the cache internal representation of the index,
	containing also the added system fields */

	if (index->type & DICT_CLUSTERED) {
		new_index = dict_index_build_internal_clust(table, index);
	} else {
		new_index = dict_index_build_internal_non_clust(table, index);
	}

	new_index->search_info = btr_search_info_create(new_index->heap);
	
	/* Set the n_fields value in new_index to the actual defined
	number of fields in the cache internal representation */

	new_index->n_fields = new_index->n_def;
	
	/* Add the new index as the last index for the table */

	UT_LIST_ADD_LAST(indexes, table->indexes, new_index);	
	new_index->table = table;
	new_index->table_name = table->name;

	/* Increment the ord_part counts in columns which are ordering */

	if (index->type & DICT_UNIVERSAL) {
		n_ord = new_index->n_fields;
	} else {
		n_ord = dict_index_get_n_unique(new_index);
	}

	for (i = 0; i < n_ord; i++) {

		field = dict_index_get_nth_field(new_index, i);

		dict_field_get_col(field)->ord_part++;
	}

	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
		/* The index tree is found from the cluster object */
	    
		cluster = dict_table_get_low(table->cluster_name);

unknown's avatar
unknown committed
1462 1463
		tree = dict_index_get_tree(
					UT_LIST_GET_FIRST(cluster->indexes));
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
		new_index->tree = tree;
		new_index->page_no = tree->page;
	} else {
		/* Create an index tree memory object for the index */
		tree = dict_tree_create(new_index);
		ut_ad(tree);

		new_index->tree = tree;
	}

1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
	if (!(new_index->type & DICT_UNIVERSAL)) {

		new_index->stat_n_diff_key_vals =
			mem_heap_alloc(new_index->heap,
				(1 + dict_index_get_n_unique(new_index))
				* sizeof(ib_longlong));
		/* Give some sensible values to stat_n_... in case we do
		not calculate statistics quickly enough */

		for (i = 0; i <= dict_index_get_n_unique(new_index); i++) {

			new_index->stat_n_diff_key_vals[i] = 100;
		}
	}
	
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
	/* Add the index to the list of indexes stored in the tree */
	UT_LIST_ADD_LAST(tree_indexes, tree->tree_indexes, new_index); 
	
	/* If the dictionary cache grows too big, trim the table LRU list */

	dict_sys->size += mem_heap_get_size(new_index->heap);
	/* dict_table_LRU_trim(); */

	dict_mem_index_free(index);

	return(TRUE);
}

/**************************************************************************
Removes an index from the dictionary cache. */
static
void
dict_index_remove_from_cache(
/*=========================*/
	dict_table_t*	table,	/* in: table */
	dict_index_t*	index)	/* in, own: index */
{
	dict_field_t*	field;
	ulint		size;
	ulint		i;

	ut_ad(table && index);
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
	ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
1518
#ifdef UNIV_SYNC_DEBUG
1519
	ut_ad(mutex_own(&(dict_sys->mutex)));
1520
#endif /* UNIV_SYNC_DEBUG */
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563

	ut_ad(UT_LIST_GET_LEN((index->tree)->tree_indexes) == 1);
	dict_tree_free(index->tree);

	/* Decrement the ord_part counts in columns which are ordering */
	for (i = 0; i < dict_index_get_n_unique(index); i++) {

		field = dict_index_get_nth_field(index, i);

		ut_ad(dict_field_get_col(field)->ord_part > 0);
		(dict_field_get_col(field)->ord_part)--;
	}

	/* Remove the index from the list of indexes of the table */
	UT_LIST_REMOVE(indexes, table->indexes, index);

	size = mem_heap_get_size(index->heap);

	ut_ad(dict_sys->size >= size);

	dict_sys->size -= size;

	mem_heap_free(index->heap);
}

/***********************************************************************
Tries to find column names for the index in the column hash table and
sets the col field of the index. */
static
ibool
dict_index_find_cols(
/*=================*/
				/* out: TRUE if success */
	dict_table_t*	table,	/* in: table */
	dict_index_t*	index)	/* in: index */	
{
	dict_col_t*	col;
	dict_field_t*	field;
	ulint		fold;
	ulint		i;
	
	ut_ad(table && index);
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
1564
#ifdef UNIV_SYNC_DEBUG
1565
	ut_ad(mutex_own(&(dict_sys->mutex)));
1566
#endif /* UNIV_SYNC_DEBUG */
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594

	for (i = 0; i < index->n_fields; i++) {
		field = dict_index_get_nth_field(index, i);

		fold = ut_fold_ulint_pair(ut_fold_string(table->name),
				  	       ut_fold_string(field->name));
			
		HASH_SEARCH(hash, dict_sys->col_hash, fold, col,
				(ut_strcmp(col->name, field->name) == 0)
				&& (ut_strcmp((col->table)->name, table->name)
								== 0));  
		if (col == NULL) {

 			return(FALSE);
		} else {
			field->col = col;
		}
	}

	return(TRUE);
}
	
/***********************************************************************
Adds a column to index. */
UNIV_INLINE
void
dict_index_add_col(
/*===============*/
unknown's avatar
unknown committed
1595 1596 1597 1598
	dict_index_t*	index,		/* in: index */
	dict_col_t*	col,		/* in: column */
	ulint		order,		/* in: order criterion */
	ulint		prefix_len)	/* in: column prefix length */
1599 1600 1601
{
	dict_field_t*	field;

unknown's avatar
unknown committed
1602
	dict_mem_index_add_field(index, col->name, order, prefix_len);
1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627

	field = dict_index_get_nth_field(index, index->n_def - 1);

	field->col = col;
}

/***********************************************************************
Copies fields contained in index2 to index1. */
static
void
dict_index_copy(
/*============*/
	dict_index_t*	index1,	/* in: index to copy to */
	dict_index_t*	index2,	/* in: index to copy from */
	ulint		start,	/* in: first position to copy */
	ulint		end)	/* in: last position to copy */
{
	dict_field_t*	field;
	ulint		i;
	
	/* Copy fields contained in index2 */

	for (i = start; i < end; i++) {

		field = dict_index_get_nth_field(index2, i);
unknown's avatar
unknown committed
1628 1629
		dict_index_add_col(index1, field->col, field->order,
						      field->prefix_len);
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
	}
}

/***********************************************************************
Copies types of fields contained in index to tuple. */

void
dict_index_copy_types(
/*==================*/
	dtuple_t*	tuple,		/* in: data tuple */
	dict_index_t*	index,		/* in: index */
	ulint		n_fields)	/* in: number of field types to copy */
{
	dtype_t*	dfield_type;
	dtype_t*	type;
	ulint		i;

	if (index->type & DICT_UNIVERSAL) {
		dtuple_set_types_binary(tuple, n_fields);

		return;
	}

	for (i = 0; i < n_fields; i++) {
		dfield_type = dfield_get_type(dtuple_get_nth_field(tuple, i));
		type = dict_col_get_type(dict_field_get_col(
				dict_index_get_nth_field(index, i)));
		*dfield_type = *type;
	}
}

/***********************************************************************
Copies types of columns contained in table to tuple. */

void
dict_table_copy_types(
/*==================*/
	dtuple_t*	tuple,	/* in: data tuple */
	dict_table_t*	table)	/* in: index */
{
	dtype_t*	dfield_type;
	dtype_t*	type;
	ulint		i;

	ut_ad(!(table->type & DICT_UNIVERSAL));

	for (i = 0; i < dtuple_get_n_fields(tuple); i++) {

		dfield_type = dfield_get_type(dtuple_get_nth_field(tuple, i));
		type = dict_col_get_type(dict_table_get_nth_col(table, i));

		*dfield_type = *type;
	}
}

/***********************************************************************
Builds the internal dictionary cache representation for a clustered
index, containing also system fields not defined by the user. */
static
dict_index_t*
dict_index_build_internal_clust(
/*============================*/
				/* out, own: the internal representation
				of the clustered index */
	dict_table_t*	table,	/* in: table */
	dict_index_t*	index)	/* in: user representation of a clustered
				index */	
{
	dict_index_t*	new_index;
	dict_field_t*	field;
	dict_col_t*	col;
	ulint		fixed_size;
	ulint		trx_id_pos;
	ulint		i;

	ut_ad(table && index);
	ut_ad(index->type & DICT_CLUSTERED);
1707
#ifdef UNIV_SYNC_DEBUG
1708
	ut_ad(mutex_own(&(dict_sys->mutex)));
1709
#endif /* UNIV_SYNC_DEBUG */
1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);

	/* Create a new index object with certainly enough fields */
	new_index = dict_mem_index_create(table->name,
				     index->name,
				     table->space,
				     index->type,
				     index->n_fields + table->n_cols);

	/* Copy other relevant data from the old index struct to the new
	struct: it inherits the values */

	new_index->n_user_defined_cols = index->n_fields;
	
	new_index->id = index->id;
	new_index->page_no = index->page_no;

	if (table->type != DICT_TABLE_ORDINARY) {
		/* The index is mixed: copy common key prefix fields */
		
		dict_index_copy(new_index, index, 0, table->mix_len);

		/* Add the mix id column */
		dict_index_add_col(new_index,
unknown's avatar
unknown committed
1734
			  dict_table_get_sys_col(table, DATA_MIX_ID), 0, 0);
1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771

		/* Copy the rest of fields */
		dict_index_copy(new_index, index, table->mix_len,
							index->n_fields);
	} else {
		/* Copy the fields of index */
		dict_index_copy(new_index, index, 0, index->n_fields);
	}

	if (index->type & DICT_UNIVERSAL) {
		/* No fixed number of fields determines an entry uniquely */

		new_index->n_uniq = ULINT_MAX;
		
	} else if (index->type & DICT_UNIQUE) {
		/* Only the fields defined so far are needed to identify
		the index entry uniquely */

		new_index->n_uniq = new_index->n_def;
	} else {
		/* Also the row id is needed to identify the entry */
		new_index->n_uniq = 1 + new_index->n_def;
	}

	new_index->trx_id_offset = 0;

	if (!(index->type & DICT_IBUF)) {
		/* Add system columns, trx id first */

		trx_id_pos = new_index->n_def;

		ut_ad(DATA_ROW_ID == 0);
		ut_ad(DATA_TRX_ID == 1);
		ut_ad(DATA_ROLL_PTR == 2);

		if (!(index->type & DICT_UNIQUE)) {
			dict_index_add_col(new_index,
unknown's avatar
unknown committed
1772
			   dict_table_get_sys_col(table, DATA_ROW_ID), 0, 0);
1773 1774 1775 1776
			trx_id_pos++;
		}

		dict_index_add_col(new_index,
unknown's avatar
unknown committed
1777 1778
			   dict_table_get_sys_col(table, DATA_TRX_ID), 0, 0);
	
1779
		dict_index_add_col(new_index,
unknown's avatar
unknown committed
1780
			   dict_table_get_sys_col(table, DATA_ROLL_PTR), 0, 0);
1781 1782 1783 1784 1785 1786 1787

		for (i = 0; i < trx_id_pos; i++) {

			fixed_size = dtype_get_fixed_size(
				dict_index_get_nth_type(new_index, i));

			if (fixed_size == 0) {
unknown's avatar
unknown committed
1788 1789 1790 1791 1792 1793 1794
				new_index->trx_id_offset = 0;

				break;
			}

			if (dict_index_get_nth_field(new_index, i)->prefix_len
			    > 0) {
1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
				new_index->trx_id_offset = 0;

				break;
			}

			new_index->trx_id_offset += fixed_size;
		}

	}

	/* Set auxiliary variables in table columns as undefined */
	for (i = 0; i < table->n_cols; i++) {

		col = dict_table_get_nth_col(table, i);
		col->aux = ULINT_UNDEFINED;
	}

	/* Mark with 0 the table columns already contained in new_index */
	for (i = 0; i < new_index->n_def; i++) {

		field = dict_index_get_nth_field(new_index, i);
unknown's avatar
unknown committed
1816 1817 1818 1819 1820 1821 1822 1823

		/* If there is only a prefix of the column in the index
		field, do not mark the column as contained in the index */

		if (field->prefix_len == 0) {

		        field->col->aux = 0;
		}
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833
	}
	
	/* Add to new_index non-system columns of table not yet included
	there */
	for (i = 0; i < table->n_cols - DATA_N_SYS_COLS; i++) {

		col = dict_table_get_nth_col(table, i);
		ut_ad(col->type.mtype != DATA_SYS);

		if (col->aux == ULINT_UNDEFINED) {
unknown's avatar
unknown committed
1834
			dict_index_add_col(new_index, col, 0, 0);
1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
		}
	}

	ut_ad((index->type & DICT_IBUF)
				|| (UT_LIST_GET_LEN(table->indexes) == 0));

	/* Store to the column structs the position of the table columns
	in the clustered index */

	for (i = 0; i < new_index->n_def; i++) {
		field = dict_index_get_nth_field(new_index, i);
unknown's avatar
unknown committed
1846 1847 1848 1849 1850

		if (field->prefix_len == 0) {

		        field->col->clust_pos = i;
		}
1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
	}
	
	new_index->cached = TRUE;

	return(new_index);
}	

/***********************************************************************
Builds the internal dictionary cache representation for a non-clustered
index, containing also system fields not defined by the user. */
static
dict_index_t*
dict_index_build_internal_non_clust(
/*================================*/
				/* out, own: the internal representation
				of the non-clustered index */
	dict_table_t*	table,	/* in: table */
	dict_index_t*	index)	/* in: user representation of a non-clustered
				index */	
{
	dict_field_t*	field;
	dict_index_t*	new_index;
	dict_index_t*	clust_index;
	ulint		i;

	ut_ad(table && index);
	ut_ad(0 == (index->type & DICT_CLUSTERED));
1878
#ifdef UNIV_SYNC_DEBUG
1879
	ut_ad(mutex_own(&(dict_sys->mutex)));
1880
#endif /* UNIV_SYNC_DEBUG */
1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);

	/* The clustered index should be the first in the list of indexes */
	clust_index = UT_LIST_GET_FIRST(table->indexes);
	
	ut_ad(clust_index);
	ut_ad(clust_index->type & DICT_CLUSTERED);
	ut_ad(!(clust_index->type & DICT_UNIVERSAL));

	/* Create a new index */
	new_index = dict_mem_index_create(table->name,
				     index->name,
				     index->space,
				     index->type,
				     index->n_fields
				     + 1 + clust_index->n_uniq);

	/* Copy other relevant data from the old index
	struct to the new struct: it inherits the values */

	new_index->n_user_defined_cols = index->n_fields;
	
	new_index->id = index->id;
	new_index->page_no = index->page_no;

	/* Copy fields from index to new_index */
	dict_index_copy(new_index, index, 0, index->n_fields);

	/* Set the auxiliary variables in the clust_index unique columns
	as undefined */
	for (i = 0; i < clust_index->n_uniq; i++) {

		field = dict_index_get_nth_field(clust_index, i);
unknown's avatar
unknown committed
1914
		field->col->aux = ULINT_UNDEFINED;
1915 1916 1917 1918 1919 1920
	}

	/* Mark with 0 table columns already contained in new_index */
	for (i = 0; i < new_index->n_def; i++) {

		field = dict_index_get_nth_field(new_index, i);
unknown's avatar
unknown committed
1921 1922 1923 1924 1925 1926 1927 1928

		/* If there is only a prefix of the column in the index
		field, do not mark the column as contained in the index */

		if (field->prefix_len == 0) {

		        field->col->aux = 0;
		}
1929 1930
	}

unknown's avatar
unknown committed
1931
	/* Add to new_index the columns necessary to determine the clustered
1932 1933 1934 1935 1936 1937
	index entry uniquely */

	for (i = 0; i < clust_index->n_uniq; i++) {

		field = dict_index_get_nth_field(clust_index, i);

unknown's avatar
unknown committed
1938 1939 1940
		if (field->col->aux == ULINT_UNDEFINED) {
			dict_index_add_col(new_index, field->col, 0,
						      field->prefix_len);
1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959
		}
	}

	if ((index->type) & DICT_UNIQUE) {
		new_index->n_uniq = index->n_fields;
	} else {
		new_index->n_uniq = new_index->n_def;
	}

	/* Set the n_fields value in new_index to the actual defined
	number of fields */

	new_index->n_fields = new_index->n_def;

	new_index->cached = TRUE;

	return(new_index);
}	

1960 1961
/*====================== FOREIGN KEY PROCESSING ========================*/

unknown's avatar
unknown committed
1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979
/*************************************************************************
Checks if a table is referenced by foreign keys. */

ibool
dict_table_referenced_by_foreign_key(
/*=================================*/
				/* out: TRUE if table is referenced by a
				foreign key */
	dict_table_t*	table)	/* in: InnoDB table */
{
	if (UT_LIST_GET_LEN(table->referenced_list) > 0) {
		
		return(TRUE);
	}

	return(FALSE);
}

1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
/*************************************************************************
Frees a foreign key struct. */
static
void
dict_foreign_free(
/*==============*/
	dict_foreign_t*	foreign)	/* in, own: foreign key struct */
{
	mem_heap_free(foreign->heap);
}

/**************************************************************************
Removes a foreign constraint struct from the dictionary cache. */
static
void
dict_foreign_remove_from_cache(
/*===========================*/
	dict_foreign_t*	foreign)	/* in, own: foreign constraint */
{
1999
#ifdef UNIV_SYNC_DEBUG
2000
	ut_ad(mutex_own(&(dict_sys->mutex)));
2001
#endif /* UNIV_SYNC_DEBUG */
2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
	ut_a(foreign);
	
	if (foreign->referenced_table) {
		UT_LIST_REMOVE(referenced_list,
			foreign->referenced_table->referenced_list, foreign);
	}

	if (foreign->foreign_table) {
		UT_LIST_REMOVE(foreign_list,
			foreign->foreign_table->foreign_list, foreign);
	}

	dict_foreign_free(foreign);
}

/**************************************************************************
Looks for the foreign constraint from the foreign and referenced lists
of a table. */
static
dict_foreign_t*
dict_foreign_find(
/*==============*/
				/* out: foreign constraint */
	dict_table_t*	table,	/* in: table object */
unknown's avatar
unknown committed
2026
	const char*	id)	/* in: foreign constraint id */
2027 2028 2029
{
	dict_foreign_t*	foreign;

2030
#ifdef UNIV_SYNC_DEBUG
2031
	ut_ad(mutex_own(&(dict_sys->mutex)));
2032
#endif /* UNIV_SYNC_DEBUG */
2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067

	foreign = UT_LIST_GET_FIRST(table->foreign_list);

	while (foreign) {
		if (ut_strcmp(id, foreign->id) == 0) {

			return(foreign);
		}

		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}
	
	foreign = UT_LIST_GET_FIRST(table->referenced_list);

	while (foreign) {
		if (ut_strcmp(id, foreign->id) == 0) {

			return(foreign);
		}

		foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
	}

	return(NULL);
}	

/*************************************************************************
Tries to find an index whose first fields are the columns in the array,
in the same order. */
static
dict_index_t*
dict_foreign_find_index(
/*====================*/
				/* out: matching index, NULL if not found */
	dict_table_t*	table,	/* in: table */
2068
	const char**	columns,/* in: array of column names */
2069 2070 2071 2072 2073
	ulint		n_cols,	/* in: number of columns */
	dict_index_t*	types_idx)/* in: NULL or an index to whose types the
				column types must match */
{
	dict_index_t*	index;
2074
	const char*	col_name;
2075 2076 2077 2078 2079 2080 2081 2082 2083 2084
	ulint		i;
	
	index = dict_table_get_first_index(table);

	while (index != NULL) {
		if (dict_index_get_n_fields(index) >= n_cols) {

			for (i = 0; i < n_cols; i++) {
				col_name = dict_index_get_nth_field(index, i)
							->col->name;
unknown's avatar
unknown committed
2085 2086 2087 2088 2089 2090 2091 2092
				if (dict_index_get_nth_field(index, i)
						->prefix_len != 0) {
					/* We do not accept column prefix
					indexes here */
					
					break;
				}

2093
				if (0 != innobase_strcasecmp(columns[i],
2094
								col_name)) {
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118
				  	break;
				}

				if (types_idx && !cmp_types_are_equal(
				     dict_index_get_nth_type(index, i),
				     dict_index_get_nth_type(types_idx, i))) {

				  	break;
				}		
			}

			if (i == n_cols) {
				/* We found a matching index */

				return(index);
			}
		}

		index = dict_table_get_next_index(index);
	}

	return(NULL);
}

2119 2120 2121 2122 2123
/**************************************************************************
Report an error in a foreign key definition. */
static
void
dict_foreign_error_report_low(
2124
/*==========================*/
2125 2126 2127 2128 2129
	FILE*		file,	/* in: output stream */
	const char*	name)	/* in: table name */
{
	rewind(file);
	ut_print_timestamp(file);
2130 2131
	fprintf(file, " Error in foreign key constraint of table %s:\n",
		name);
2132 2133 2134 2135 2136 2137 2138
}

/**************************************************************************
Report an error in a foreign key definition. */
static
void
dict_foreign_error_report(
2139
/*======================*/
2140 2141 2142 2143 2144 2145 2146 2147
	FILE*		file,	/* in: output stream */
	dict_foreign_t*	fk,	/* in: foreign key constraint */
	const char*	msg)	/* in: the error message */
{
	mutex_enter(&dict_foreign_err_mutex);
	dict_foreign_error_report_low(file, fk->foreign_table_name);
	fputs(msg, file);
	fputs(" Constraint:\n", file);
2148
	dict_print_info_on_foreign_key_in_create_format(file, NULL, fk);
2149 2150
	if (fk->foreign_index) {
		fputs("\nThe index in the foreign key in table is ", file);
2151
		ut_print_name(file, NULL, fk->foreign_index->name);
2152
		fputs(
2153 2154
"\nSee http://dev.mysql.com/doc/mysql/en/InnoDB_foreign_key_constraints.html\n"
"for correct foreign key definition.\n",
2155 2156 2157 2158 2159
		file);
	}
	mutex_exit(&dict_foreign_err_mutex);
}

2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173
/**************************************************************************
Adds a foreign key constraint object to the dictionary cache. May free
the object if there already is an object with the same identifier in.
At least one of the foreign table and the referenced table must already
be in the dictionary cache! */

ulint
dict_foreign_add_to_cache(
/*======================*/
					/* out: DB_SUCCESS or error code */
	dict_foreign_t*	foreign)	/* in, own: foreign key constraint */
{
	dict_table_t*	for_table;
	dict_table_t*	ref_table;
2174
	dict_foreign_t*	for_in_cache		= NULL;
2175
	dict_index_t*	index;
2176 2177
	ibool		added_to_referenced_list= FALSE;
	FILE*		ef 			= dict_foreign_err_file;
2178

2179
#ifdef UNIV_SYNC_DEBUG
2180
	ut_ad(mutex_own(&(dict_sys->mutex)));
2181
#endif /* UNIV_SYNC_DEBUG */
2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206

	for_table = dict_table_check_if_in_cache_low(
					foreign->foreign_table_name);
	
	ref_table = dict_table_check_if_in_cache_low(
					foreign->referenced_table_name);
	ut_a(for_table || ref_table);

	if (for_table) {
		for_in_cache = dict_foreign_find(for_table, foreign->id);
	}

	if (!for_in_cache && ref_table) {
		for_in_cache = dict_foreign_find(ref_table, foreign->id);
	}

	if (for_in_cache) {
		/* Free the foreign object */
		mem_heap_free(foreign->heap);
	} else {
		for_in_cache = foreign;
	}

	if (for_in_cache->referenced_table == NULL && ref_table) {
		index = dict_foreign_find_index(ref_table,
2207 2208 2209
			(const char**) for_in_cache->referenced_col_names,
			for_in_cache->n_fields,
			for_in_cache->foreign_index);
2210 2211

		if (index == NULL) {
2212
			dict_foreign_error_report(ef, for_in_cache,
unknown's avatar
unknown committed
2213 2214
"there is no index in referenced table which would contain\n"
"the columns as the first columns, or the data types in the\n"
2215 2216
"referenced table do not match to the ones in table.");

2217 2218 2219
			if (for_in_cache == foreign) {
				mem_heap_free(foreign->heap);
			}
unknown's avatar
unknown committed
2220

2221 2222 2223 2224 2225 2226 2227 2228
		    	return(DB_CANNOT_ADD_CONSTRAINT);
		}

		for_in_cache->referenced_table = ref_table;
		for_in_cache->referenced_index = index;
		UT_LIST_ADD_LAST(referenced_list,
					ref_table->referenced_list,
					for_in_cache);
unknown's avatar
unknown committed
2229
		added_to_referenced_list = TRUE;
2230 2231 2232 2233
	}

	if (for_in_cache->foreign_table == NULL && for_table) {
		index = dict_foreign_find_index(for_table,
2234 2235 2236
			(const char**) for_in_cache->foreign_col_names,
			for_in_cache->n_fields,
			for_in_cache->referenced_index);
2237 2238

		if (index == NULL) {
2239
			dict_foreign_error_report(ef, for_in_cache,
unknown's avatar
unknown committed
2240 2241
"there is no index in the table which would contain\n"
"the columns as the first columns, or the data types in the\n"
2242
"table do not match to the ones in the referenced table.");
unknown's avatar
unknown committed
2243

2244
			if (for_in_cache == foreign) {
unknown's avatar
unknown committed
2245 2246 2247 2248 2249 2250
				if (added_to_referenced_list) {
					UT_LIST_REMOVE(referenced_list,
						ref_table->referenced_list,
						for_in_cache);
				}
			
2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270
				mem_heap_free(foreign->heap);
			}

		    	return(DB_CANNOT_ADD_CONSTRAINT);
		}

		for_in_cache->foreign_table = for_table;
		for_in_cache->foreign_index = index;
		UT_LIST_ADD_LAST(foreign_list,
					for_table->foreign_list,
					for_in_cache);
	}

	return(DB_SUCCESS);
}

/*************************************************************************
Scans from pointer onwards. Stops if is at the start of a copy of
'string' where characters are compared without case sensitivity. Stops
also at '\0'. */
2271

2272
const char*
2273 2274
dict_scan_to(
/*=========*/
unknown's avatar
unknown committed
2275
				/* out: scanned up to this */
2276 2277
	const char*	ptr,	/* in: scan from */
	const char*	string)	/* in: look for this */
2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
{
	ibool	success;
	ulint	i;
loop:
	if (*ptr == '\0') {
		return(ptr);
	}

	success = TRUE;
	
	for (i = 0; i < ut_strlen(string); i++) {
		if (toupper((ulint)(ptr[i])) != toupper((ulint)(string[i]))) {
			success = FALSE;

			break;
		}
	}

	if (success) {

		return(ptr);
	}

	ptr++;

	goto loop;
}

/*************************************************************************
Accepts a specified string. Comparisons are case-insensitive. */
unknown's avatar
unknown committed
2308

2309
const char*
2310 2311
dict_accept(
/*========*/
2312 2313 2314 2315 2316 2317
				/* out: if string was accepted, the pointer
				is moved after that, else ptr is returned */
	const char*	ptr,	/* in: scan from this */
	const char*	string,	/* in: accept only this string as the next
				non-whitespace string */
	ibool*		success)/* out: TRUE if accepted */
2318
{
2319 2320
	const char*	old_ptr = ptr;
	const char*	old_ptr2;
2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341

	*success = FALSE;
	
	while (isspace(*ptr)) {
		ptr++;
	}

	old_ptr2 = ptr;
	
	ptr = dict_scan_to(ptr, string);
	
	if (*ptr == '\0' || old_ptr2 != ptr) {
		return(old_ptr);
	}

	*success = TRUE;

	return(ptr + ut_strlen(string));
}

/*************************************************************************
unknown's avatar
unknown committed
2342 2343
Scans an id. For the lexical definition of an 'id', see the code below.
Strips backquotes or double quotes from around the id. */
2344
static
2345
const char*
unknown's avatar
unknown committed
2346 2347
dict_scan_id(
/*=========*/
2348
				/* out: scanned to */
2349 2350 2351 2352 2353
	const char*	ptr,	/* in: scanned to */
	mem_heap_t*	heap,	/* in: heap where to allocate the id
				(NULL=id will not be allocated, but it
				will point to string near ptr) */
	const char**	id,	/* out,own: the id; NULL if no id was
unknown's avatar
unknown committed
2354
				scannable */
2355 2356
	ibool		accept_also_dot)
				/* in: TRUE if also a dot can appear in a
unknown's avatar
unknown committed
2357 2358
				non-quoted id; in a quoted id it can appear
				always */
2359
{
2360 2361 2362 2363
	char		quote	= '\0';
	ulint		len	= 0;
	const char*	s;
	char*		d;
unknown's avatar
unknown committed
2364

2365
	*id = NULL;
2366 2367 2368 2369 2370 2371 2372 2373 2374 2375

	while (isspace(*ptr)) {
		ptr++;
	}

	if (*ptr == '\0') {

		return(ptr);
	}

2376
	if (*ptr == '`' || *ptr == '"') {
unknown's avatar
unknown committed
2377 2378
		quote = *ptr++;
	}
2379 2380

	s = ptr;
unknown's avatar
unknown committed
2381

unknown's avatar
unknown committed
2382
	if (quote) {
2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393
		for (;;) {
			if (!*ptr) {
				/* Syntax error */
				return(ptr);
			}
			if (*ptr == quote) {
				ptr++;
				if (*ptr != quote) {
					break;
				}
			}
unknown's avatar
unknown committed
2394
			ptr++;
2395
			len++;
unknown's avatar
unknown committed
2396
		}
unknown's avatar
unknown committed
2397 2398 2399 2400
	} else {
		while (!isspace(*ptr) && *ptr != '(' && *ptr != ')'
		       && (accept_also_dot || *ptr != '.')
		       && *ptr != ',' && *ptr != '\0') {
unknown's avatar
unknown committed
2401

unknown's avatar
unknown committed
2402
			ptr++;
unknown's avatar
unknown committed
2403
		}
2404 2405

		len = ptr - s;
unknown's avatar
unknown committed
2406 2407
	}

2408 2409 2410 2411 2412 2413
	if (quote && heap) {
		*id = d = mem_heap_alloc(heap, len + 1);
		while (len--) {
			if ((*d++ = *s++) == quote) {
				s++;
			}
unknown's avatar
unknown committed
2414
		}
2415 2416 2417 2418 2419 2420 2421
		*d++ = 0;
		ut_a(*s == quote);
		ut_a(s + 1 == ptr);
	} else if (heap) {
		*id = mem_heap_strdupl(heap, s, len);
	} else {
		/* no heap given: id will point to source string */
unknown's avatar
unknown committed
2422
		*id = s;
2423
	}
unknown's avatar
unknown committed
2424 2425 2426 2427

	return(ptr);
}

2428 2429 2430
/*************************************************************************
Tries to scan a column name. */
static
2431
const char*
2432 2433 2434
dict_scan_col(
/*==========*/
				/* out: scanned to */
2435
	const char*	ptr,	/* in: scanned to */
2436 2437 2438
	ibool*		success,/* out: TRUE if success */
	dict_table_t*	table,	/* in: table in which the column is */
	dict_col_t**	column,	/* out: pointer to column if success */
2439 2440 2441
	mem_heap_t*	heap,	/* in: heap where to allocate the name */
	const char**	name)	/* out,own: the column name; NULL if no name
				was scannable */
2442 2443 2444
{
	dict_col_t*	col;
	ulint		i;
2445

2446 2447
	*success = FALSE;

2448
	ptr = dict_scan_id(ptr, heap, name, TRUE);
unknown's avatar
unknown committed
2449

2450
	if (*name == NULL) {
unknown's avatar
unknown committed
2451

unknown's avatar
unknown committed
2452
		return(ptr);	/* Syntax error */
2453 2454
	}

unknown's avatar
unknown committed
2455 2456 2457 2458 2459
	if (table == NULL) {
		*success = TRUE;
		*column = NULL;
	} else {
	    	for (i = 0; i < dict_table_get_n_cols(table); i++) {
2460

unknown's avatar
unknown committed
2461
			col = dict_table_get_nth_col(table, i);
2462

2463
			if (0 == innobase_strcasecmp(col->name, *name)) {
unknown's avatar
unknown committed
2464
		    		/* Found */
2465

unknown's avatar
unknown committed
2466 2467
		    		*success = TRUE;
		    		*column = col;
2468
		    		strcpy((char*) *name, col->name);
2469

unknown's avatar
unknown committed
2470 2471
		    		break;
			}
2472 2473 2474 2475 2476 2477 2478 2479 2480
		}
	}
	
	return(ptr);
}

/*************************************************************************
Scans the referenced table name from an SQL string. */
static
2481
const char*
2482 2483 2484
dict_scan_table_name(
/*=================*/
				/* out: scanned to */
2485
	const char*	ptr,	/* in: scanned to */
unknown's avatar
unknown committed
2486
	dict_table_t**	table,	/* out: table object or NULL */
2487
	const char*	name,	/* in: foreign key table name */
unknown's avatar
unknown committed
2488
	ibool*		success,/* out: TRUE if ok name found */
2489 2490 2491
	mem_heap_t*	heap,	/* in: heap where to allocate the id */
	const char**	ref_name)/* out,own: the referenced table name;
				NULL if no name was scannable */
2492
{
2493 2494 2495 2496 2497 2498 2499
	const char*	database_name	= NULL;
	ulint		database_name_len = 0;
	const char*	table_name	= NULL;
	ulint		table_name_len;
	const char*	scan_name;
	char*		ref;

unknown's avatar
unknown committed
2500
	*success = FALSE;
2501
	*table = NULL;
unknown's avatar
unknown committed
2502
	
2503
	ptr = dict_scan_id(ptr, heap, &scan_name, FALSE);	
2504

2505
	if (scan_name == NULL) {
unknown's avatar
unknown committed
2506 2507
		
		return(ptr);	/* Syntax error */
2508 2509
	}

unknown's avatar
unknown committed
2510 2511
	if (*ptr == '.') {
		/* We scanned the database name; scan also the table name */
2512

unknown's avatar
unknown committed
2513 2514
		ptr++;

2515 2516
		database_name = scan_name;
		database_name_len = strlen(database_name);
2517

2518
		ptr = dict_scan_id(ptr, heap, &table_name, FALSE);
2519

unknown's avatar
unknown committed
2520
		if (table_name == NULL) {
unknown's avatar
unknown committed
2521

unknown's avatar
unknown committed
2522
			return(ptr);	/* Syntax error */
unknown's avatar
unknown committed
2523
		}
2524
	} else {
unknown's avatar
unknown committed
2525 2526 2527 2528 2529 2530 2531
		/* To be able to read table dumps made with InnoDB-4.0.17 or
		earlier, we must allow the dot separator between the database
		name and the table name also to appear within a quoted
		identifier! InnoDB used to print a constraint as:
			... REFERENCES `databasename.tablename` ...
		starting from 4.0.18 it is
			... REFERENCES `databasename`.`tablename` ... */
2532 2533 2534 2535 2536 2537 2538 2539
		const char* s;

		for (s = scan_name; *s; s++) {
			if (*s == '.') {
				database_name = scan_name;
				database_name_len = s - scan_name;
				scan_name = ++s;
				break;/* to do: multiple dots? */
unknown's avatar
unknown committed
2540
			}
unknown's avatar
unknown committed
2541
		}
2542

2543
		table_name = scan_name;
unknown's avatar
unknown committed
2544 2545
	}

unknown's avatar
unknown committed
2546 2547
	if (database_name == NULL) {
		/* Use the database name of the foreign key table */
unknown's avatar
unknown committed
2548

unknown's avatar
unknown committed
2549
		database_name = name;
unknown's avatar
unknown committed
2550
		database_name_len = dict_get_db_name_len(name);
unknown's avatar
unknown committed
2551 2552
	}

2553 2554
	table_name_len = strlen(table_name);

2555
	/* Copy database_name, '/', table_name, '\0' */
2556
	ref = mem_heap_alloc(heap, database_name_len + table_name_len + 2);
2557 2558 2559 2560
	memcpy(ref, database_name, database_name_len);
	ref[database_name_len] = '/';
	memcpy(ref + database_name_len + 1, table_name, table_name_len + 1);
#ifndef __WIN__
unknown's avatar
unknown committed
2561
	if (srv_lower_case_table_names) {
2562 2563 2564 2565
#endif /* !__WIN__ */
		/* The table name is always put to lower case on Windows. */
		innobase_casedn_str(ref);
#ifndef __WIN__
unknown's avatar
unknown committed
2566
	}
2567
#endif /* !__WIN__ */
2568

unknown's avatar
unknown committed
2569
	*success = TRUE;
2570 2571
	*ref_name = ref;
	*table = dict_table_get_low(ref);
unknown's avatar
unknown committed
2572 2573 2574 2575

	return(ptr);
}

unknown's avatar
unknown committed
2576
/*************************************************************************
unknown's avatar
unknown committed
2577
Skips one id. The id is allowed to contain also '.'. */
unknown's avatar
unknown committed
2578
static
2579
const char*
unknown's avatar
unknown committed
2580 2581
dict_skip_word(
/*===========*/
2582 2583 2584 2585
				/* out: scanned to */
	const char*	ptr,	/* in: scanned to */
	ibool*		success)/* out: TRUE if success, FALSE if just spaces
				left in string or a syntax error */
unknown's avatar
unknown committed
2586
{
2587
	const char*	start;
unknown's avatar
unknown committed
2588 2589 2590
	
	*success = FALSE;

2591
	ptr = dict_scan_id(ptr, NULL, &start, TRUE);
unknown's avatar
unknown committed
2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609

	if (start) {
		*success = TRUE;
	}
	
	return(ptr);
}

/*************************************************************************
Removes MySQL comments from an SQL string. A comment is either
(a) '#' to the end of the line,
(b) '--<space>' to the end of the line, or
(c) '<slash><asterisk>' till the next '<asterisk><slash>' (like the familiar
C comment syntax). */
static
char*
dict_strip_comments(
/*================*/
2610 2611 2612 2613
					/* out, own: SQL string stripped from
					comments; the caller must free this
					with mem_free()! */
	const char*	sql_string)	/* in: SQL string */
unknown's avatar
unknown committed
2614
{
2615 2616 2617
	char*		str;
	const char*	sptr;
	char*		ptr;
2618 2619 2620
 	/* unclosed quote character (0 if none) */
 	char		quote	= 0;

unknown's avatar
unknown committed
2621 2622 2623 2624 2625 2626
	str = mem_alloc(strlen(sql_string) + 1);

	sptr = sql_string;
	ptr = str;

	for (;;) {
unknown's avatar
unknown committed
2627
scan_more:
unknown's avatar
unknown committed
2628 2629 2630
		if (*sptr == '\0') {
			*ptr = '\0';

unknown's avatar
unknown committed
2631 2632
			ut_a(ptr <= str + strlen(sql_string));

unknown's avatar
unknown committed
2633 2634
			return(str);
		}
2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646

		if (*sptr == quote) {
			/* Closing quote character: do not look for
			starting quote or comments. */
			quote = 0;
		} else if (quote) {
			/* Within quotes: do not look for
			starting quotes or comments. */
		} else if (*sptr == '"' || *sptr == '`') {
			/* Starting quote: remember the quote character. */
			quote = *sptr;
		} else if (*sptr == '#'
2647
		    || (0 == memcmp("-- ", sptr, 3))) {
unknown's avatar
unknown committed
2648
			for (;;) {
2649 2650
				/* In Unix a newline is 0x0A while in Windows
				it is 0x0D followed by 0x0A */
unknown's avatar
unknown committed
2651 2652 2653 2654 2655

				if (*sptr == (char)0x0A
				    || *sptr == (char)0x0D
				    || *sptr == '\0') {

unknown's avatar
unknown committed
2656
					goto scan_more;
unknown's avatar
unknown committed
2657 2658 2659 2660
				}

				sptr++;
			}
2661
		} else if (!quote && *sptr == '/' && *(sptr + 1) == '*') {
unknown's avatar
unknown committed
2662
			for (;;) {
2663
				if (*sptr == '*' && *(sptr + 1) == '/') {
unknown's avatar
unknown committed
2664 2665 2666

				     	sptr += 2;

unknown's avatar
unknown committed
2667
					goto scan_more;
unknown's avatar
unknown committed
2668 2669 2670 2671
				}

				if (*sptr == '\0') {

unknown's avatar
unknown committed
2672
					goto scan_more;
unknown's avatar
unknown committed
2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685
				}

				sptr++;
			}
		}

		*ptr = *sptr;

		ptr++;
		sptr++;
	}
}

unknown's avatar
unknown committed
2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701
/*************************************************************************
Finds the highest <number> for foreign key constraints of the table. Looks
only at the >= 4.0.18-format id's, which are of the form
databasename/tablename_ibfk_<number>. */
static
ulint
dict_table_get_highest_foreign_id(
/*==============================*/
				/* out: highest number, 0 if table has no new
				format foreign key constraints */
	dict_table_t*	table)	/* in: table in the dictionary memory cache */
{
	dict_foreign_t*	foreign;
	char*		endp;
	ulint		biggest_id	= 0;
	ulint		id;
2702
	ulint		len;
unknown's avatar
unknown committed
2703 2704 2705

	ut_a(table);

2706
	len = ut_strlen(table->name);
unknown's avatar
unknown committed
2707 2708 2709
	foreign = UT_LIST_GET_FIRST(table->foreign_list);

	while (foreign) {
2710 2711 2712 2713
		if (ut_strlen(foreign->id) > ((sizeof dict_ibfk) - 1) + len
		    && 0 == ut_memcmp(foreign->id, table->name, len)
		    && 0 == ut_memcmp(foreign->id + len,
				dict_ibfk, (sizeof dict_ibfk) - 1)) {
unknown's avatar
unknown committed
2714 2715
			/* It is of the >= 4.0.18 format */

2716
			id = strtoul(foreign->id + len + ((sizeof dict_ibfk) - 1),
unknown's avatar
unknown committed
2717
					&endp, 10);
2718 2719
			if (*endp == '\0') {
				ut_a(id != biggest_id);
unknown's avatar
unknown committed
2720

2721 2722 2723
				if (id > biggest_id) {
					biggest_id = id;
				}
unknown's avatar
unknown committed
2724 2725 2726 2727 2728 2729 2730 2731 2732
			}
		}

		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}

	return(biggest_id);
}

unknown's avatar
unknown committed
2733 2734 2735 2736 2737 2738
/*************************************************************************
Reports a simple foreign key create clause syntax error. */
static
void
dict_foreign_report_syntax_err(
/*===========================*/
2739 2740 2741
	const char*	name,		/* in: table name */
	const char*	start_of_latest_foreign,
					/* in: start of the foreign key clause
unknown's avatar
unknown committed
2742
					in the SQL string */
2743
	const char*	ptr)		/* in: place of the syntax error */
unknown's avatar
unknown committed
2744
{
2745
	FILE*	 ef = dict_foreign_err_file;
unknown's avatar
unknown committed
2746 2747

	mutex_enter(&dict_foreign_err_mutex);
2748 2749 2750
	dict_foreign_error_report_low(ef, name);
	fprintf(ef, "%s:\nSyntax error close to:\n%s\n",
		start_of_latest_foreign, ptr);
unknown's avatar
unknown committed
2751 2752
	mutex_exit(&dict_foreign_err_mutex);
}
2753 2754 2755 2756 2757 2758 2759

/*************************************************************************
Scans a table create SQL string and adds to the data dictionary the foreign
key constraints declared in the string. This function should be called after
the indexes for a table have been created. Each foreign key constraint must
be accompanied with indexes in both participating tables. The indexes are
allowed to contain more fields than mentioned in the constraint. */
unknown's avatar
unknown committed
2760
static
2761
ulint
unknown's avatar
unknown committed
2762 2763
dict_create_foreign_constraints_low(
/*================================*/
2764
				/* out: error code or DB_SUCCESS */
2765 2766 2767 2768 2769
	trx_t*		trx,	/* in: transaction */
	mem_heap_t*	heap,	/* in: memory heap */
	const char*	sql_string,
				/* in: CREATE TABLE or ALTER TABLE statement
				where foreign keys are declared like:
2770 2771 2772
				FOREIGN KEY (a, b) REFERENCES table2(c, d),
				table2 can be written also with the database
				name before it: test.table2; the default
unknown's avatar
unknown committed
2773
				database is the database of parameter name */
2774
	const char*	name)	/* in: table full name in the normalized form
2775 2776 2777 2778
				database_name/table_name */
{
	dict_table_t*	table;
	dict_table_t*	referenced_table;
unknown's avatar
unknown committed
2779 2780
	dict_table_t*	table_to_alter;
	ulint		highest_id_so_far	= 0;
2781 2782
	dict_index_t*	index;
	dict_foreign_t*	foreign;
2783
 	const char*	ptr			= sql_string;
2784
	const char*	start_of_latest_foreign	= sql_string;
2785
	FILE*		ef			= dict_foreign_err_file;
2786
	const char*	constraint_name;
2787 2788
	ibool		success;
	ulint		error;
2789 2790
	const char*	ptr1;
	const char*	ptr2;
2791
	ulint		i;
unknown's avatar
unknown committed
2792
	ulint		j;
unknown's avatar
unknown committed
2793 2794 2795
	ibool		is_on_delete;
	ulint		n_on_deletes;
	ulint		n_on_updates;
unknown's avatar
unknown committed
2796
	dict_col_t*	columns[500];
2797 2798
	const char*	column_names[500];
	const char*	referenced_table_name;
unknown's avatar
unknown committed
2799
	
2800
#ifdef UNIV_SYNC_DEBUG
2801
	ut_ad(mutex_own(&(dict_sys->mutex)));
2802
#endif /* UNIV_SYNC_DEBUG */
2803

unknown's avatar
unknown committed
2804
	table = dict_table_get_low(name);
2805 2806

	if (table == NULL) {
unknown's avatar
unknown committed
2807
		mutex_enter(&dict_foreign_err_mutex);
2808 2809 2810 2811
		dict_foreign_error_report_low(ef, name);
		fprintf(ef,
"Cannot find the table in the internal data dictionary of InnoDB.\n"
"Create table statement:\n%s\n", sql_string);
unknown's avatar
unknown committed
2812 2813
		mutex_exit(&dict_foreign_err_mutex);

2814 2815
		return(DB_ERROR);
	}
unknown's avatar
unknown committed
2816 2817 2818 2819

	/* First check if we are actually doing an ALTER TABLE, and in that
	case look for the table being altered */

2820
	ptr = dict_accept(ptr, "ALTER", &success);
unknown's avatar
unknown committed
2821 2822 2823 2824 2825 2826

	if (!success) {

		goto loop;
	}

2827
	ptr = dict_accept(ptr, "TABLE", &success);
unknown's avatar
unknown committed
2828 2829 2830 2831 2832 2833

	if (!success) {

		goto loop;
	}

2834
	/* We are doing an ALTER TABLE: scan the table name we are altering */
unknown's avatar
unknown committed
2835 2836

	ptr = dict_scan_table_name(ptr, &table_to_alter, name,
2837
				&success, heap, &referenced_table_name);
unknown's avatar
unknown committed
2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861
	if (!success) {
		fprintf(stderr,
"InnoDB: Error: could not find the table being ALTERED in:\n%s\n", sql_string);

		return(DB_ERROR);
	}

	/* Starting from 4.0.18 and 4.1.2, we generate foreign key id's in the
	format databasename/tablename_ibfk_<number>, where <number> is local
	to the table; look for the highest <number> for table_to_alter, so
	that we can assign to new constraints higher numbers. */

	/* If we are altering a temporary table, the table name after ALTER
	TABLE does not correspond to the internal table name, and
	table_to_alter is NULL. TODO: should we fix this somehow? */

	if (table_to_alter == NULL) {
		highest_id_so_far = 0;
	} else {
		highest_id_so_far = dict_table_get_highest_foreign_id(
							table_to_alter);
	}

	/* Scan for foreign key declarations in a loop */
2862
loop:
unknown's avatar
unknown committed
2863
	/* Scan either to "CONSTRAINT" or "FOREIGN", whichever is closer */
2864

2865 2866
	ptr1 = dict_scan_to(ptr, "CONSTRAINT");
	ptr2 = dict_scan_to(ptr, "FOREIGN");
2867

unknown's avatar
unknown committed
2868 2869 2870 2871 2872 2873 2874 2875
	constraint_name = NULL;

	if (ptr1 < ptr2) {
		/* The user has specified a constraint name. Pick it so
		that we can store 'databasename/constraintname' as the id of
		the id of the constraint to system tables. */
		ptr = ptr1;

2876
		ptr = dict_accept(ptr, "CONSTRAINT", &success);
2877

unknown's avatar
unknown committed
2878 2879 2880 2881 2882 2883
		ut_a(success);

		if (!isspace(*ptr)) {
	        	goto loop;
		}

2884 2885 2886 2887 2888 2889
		do {
			ptr++;
		} while (isspace(*ptr));

		/* read constraint name unless got "CONSTRAINT FOREIGN" */
		if (ptr != ptr2) {
2890
			ptr = dict_scan_id(ptr, heap, &constraint_name, FALSE);
2891
		}
unknown's avatar
unknown committed
2892 2893 2894 2895 2896 2897
	} else {
		ptr = ptr2;
	}

	if (*ptr == '\0') {
		/**********************************************************/
2898 2899 2900
		/* The following call adds the foreign key constraints
		to the data dictionary system tables on disk */
		
unknown's avatar
unknown committed
2901 2902
		error = dict_create_add_foreigns_to_dictionary(
						highest_id_so_far, table, trx);
2903 2904 2905
		return(error);
	}

unknown's avatar
unknown committed
2906 2907
	start_of_latest_foreign = ptr;

2908
	ptr = dict_accept(ptr, "FOREIGN", &success);		
2909 2910
	
	if (!isspace(*ptr)) {
unknown's avatar
unknown committed
2911
	        goto loop;
2912 2913
	}

2914
	ptr = dict_accept(ptr, "KEY", &success);
2915 2916 2917 2918 2919

	if (!success) {
		goto loop;
	}

2920
	ptr = dict_accept(ptr, "(", &success);
2921 2922

	if (!success) {
unknown's avatar
unknown committed
2923 2924 2925 2926 2927
		/* MySQL allows also an index id before the '('; we
		skip it */
		ptr = dict_skip_word(ptr, &success);

		if (!success) {
unknown's avatar
unknown committed
2928 2929 2930
			dict_foreign_report_syntax_err(name,
					start_of_latest_foreign, ptr);

unknown's avatar
unknown committed
2931 2932 2933
			return(DB_CANNOT_ADD_CONSTRAINT);
		}

2934
		ptr = dict_accept(ptr, "(", &success);
unknown's avatar
unknown committed
2935 2936

		if (!success) {
unknown's avatar
unknown committed
2937 2938 2939 2940
			/* We do not flag a syntax error here because in an
			ALTER TABLE we may also have DROP FOREIGN KEY abc */

		        goto loop;
unknown's avatar
unknown committed
2941
		}
2942 2943 2944 2945 2946 2947
	}

	i = 0;

	/* Scan the columns in the first list */
col_loop1:
2948
	ut_a(i < (sizeof column_names) / sizeof *column_names);
2949
	ptr = dict_scan_col(ptr, &success, table, columns + i,
2950
				heap, column_names + i);
2951
	if (!success) {
unknown's avatar
unknown committed
2952
		mutex_enter(&dict_foreign_err_mutex);
2953 2954
		dict_foreign_error_report_low(ef, name);
		fprintf(ef, "%s:\nCannot resolve column name close to:\n%s\n",
unknown's avatar
unknown committed
2955 2956 2957
					start_of_latest_foreign, ptr);
		mutex_exit(&dict_foreign_err_mutex);

2958 2959 2960 2961 2962
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

	i++;
	
2963
	ptr = dict_accept(ptr, ",", &success);
2964 2965 2966 2967 2968

	if (success) {
		goto col_loop1;
	}
	
2969
	ptr = dict_accept(ptr, ")", &success);
2970 2971

	if (!success) {
unknown's avatar
unknown committed
2972 2973
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
2974 2975 2976 2977 2978 2979 2980 2981 2982
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

	/* Try to find an index which contains the columns
	as the first fields and in the right order */

	index = dict_foreign_find_index(table, column_names, i, NULL);

	if (!index) {
unknown's avatar
unknown committed
2983
		mutex_enter(&dict_foreign_err_mutex);
2984 2985
		dict_foreign_error_report_low(ef, name);
		fputs("There is no index in table ", ef);
2986
		ut_print_name(ef, NULL, name);
2987 2988
		fprintf(ef, " where the columns appear\n"
"as the first columns. Constraint:\n%s\n"
unknown's avatar
unknown committed
2989
"See http://dev.mysql.com/doc/mysql/en/InnoDB_foreign_key_constraints.html\n"
2990
"for correct foreign key definition.\n",
2991
			start_of_latest_foreign);
unknown's avatar
unknown committed
2992 2993
		mutex_exit(&dict_foreign_err_mutex);

2994 2995
		return(DB_CANNOT_ADD_CONSTRAINT);
	}
2996
	ptr = dict_accept(ptr, "REFERENCES", &success);
2997 2998

	if (!success || !isspace(*ptr)) {
unknown's avatar
unknown committed
2999 3000
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
3001 3002 3003 3004 3005 3006 3007
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

	/* Let us create a constraint struct */

	foreign = dict_mem_foreign_create();

unknown's avatar
unknown committed
3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018
	if (constraint_name) {
		ulint	db_len;	

		/* Catenate 'databasename/' to the constraint name specified
		by the user: we conceive the constraint as belonging to the
		same MySQL 'database' as the table itself. We store the name
		to foreign->id. */

		db_len = dict_get_db_name_len(table->name);

		foreign->id = mem_heap_alloc(foreign->heap,
3019
				db_len + strlen(constraint_name) + 2);
unknown's avatar
unknown committed
3020

3021
		ut_memcpy(foreign->id, table->name, db_len);
unknown's avatar
unknown committed
3022
		foreign->id[db_len] = '/';
3023
		strcpy(foreign->id + db_len + 1, constraint_name);
unknown's avatar
unknown committed
3024 3025
	}

3026
	foreign->foreign_table = table;
3027 3028
	foreign->foreign_table_name = mem_heap_strdup(foreign->heap,
							table->name);
3029 3030 3031 3032 3033
	foreign->foreign_index = index;
	foreign->n_fields = i;
	foreign->foreign_col_names = mem_heap_alloc(foreign->heap,
							i * sizeof(void*));
	for (i = 0; i < foreign->n_fields; i++) {
3034 3035
		foreign->foreign_col_names[i] =
			mem_heap_strdup(foreign->heap, columns[i]->name);
3036 3037
	}
	
unknown's avatar
unknown committed
3038
	ptr = dict_scan_table_name(ptr, &referenced_table, name,
3039
				&success, heap, &referenced_table_name);
3040

unknown's avatar
unknown committed
3041 3042 3043 3044
	/* Note that referenced_table can be NULL if the user has suppressed
	checking of foreign key constraints! */

	if (!success || (!referenced_table && trx->check_foreigns)) {
3045 3046
		dict_foreign_free(foreign);

unknown's avatar
unknown committed
3047
		mutex_enter(&dict_foreign_err_mutex);
3048 3049 3050 3051
		dict_foreign_error_report_low(ef, name);
		fprintf(ef, "%s:\nCannot resolve table name close to:\n"
			"%s\n",
			start_of_latest_foreign, ptr);
unknown's avatar
unknown committed
3052 3053
		mutex_exit(&dict_foreign_err_mutex);

3054 3055 3056
		return(DB_CANNOT_ADD_CONSTRAINT);
	}
	
3057
	ptr = dict_accept(ptr, "(", &success);
3058 3059 3060

	if (!success) {
		dict_foreign_free(foreign);
unknown's avatar
unknown committed
3061 3062
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
3063 3064 3065 3066 3067 3068 3069 3070
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

	/* Scan the columns in the second list */
	i = 0;

col_loop2:
	ptr = dict_scan_col(ptr, &success, referenced_table, columns + i,
3071
				heap, column_names + i);
3072 3073 3074 3075
	i++;
	
	if (!success) {
		dict_foreign_free(foreign);
unknown's avatar
unknown committed
3076

unknown's avatar
unknown committed
3077
		mutex_enter(&dict_foreign_err_mutex);
3078 3079 3080 3081
		dict_foreign_error_report_low(ef, name);
		fprintf(ef, "%s:\nCannot resolve column name close to:\n"
			"%s\n",
			start_of_latest_foreign, ptr);
unknown's avatar
unknown committed
3082 3083
		mutex_exit(&dict_foreign_err_mutex);

3084 3085 3086
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

3087
	ptr = dict_accept(ptr, ",", &success);
3088 3089 3090 3091 3092

	if (success) {
		goto col_loop2;
	}
	
3093
	ptr = dict_accept(ptr, ")", &success);
3094 3095 3096 3097

	if (!success || foreign->n_fields != i) {
		dict_foreign_free(foreign);
		
unknown's avatar
unknown committed
3098 3099
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
3100 3101 3102
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

unknown's avatar
unknown committed
3103 3104 3105 3106 3107 3108
	n_on_deletes = 0;
	n_on_updates = 0;
	
scan_on_conditions:
	/* Loop here as long as we can find ON ... conditions */

unknown's avatar
unknown committed
3109 3110 3111 3112 3113 3114 3115 3116 3117 3118
	ptr = dict_accept(ptr, "ON", &success);

	if (!success) {

		goto try_find_index;
	}

	ptr = dict_accept(ptr, "DELETE", &success);

	if (!success) {
unknown's avatar
unknown committed
3119 3120 3121 3122
		ptr = dict_accept(ptr, "UPDATE", &success);

		if (!success) {
			dict_foreign_free(foreign);
unknown's avatar
unknown committed
3123
		
unknown's avatar
unknown committed
3124 3125
			dict_foreign_report_syntax_err(name,
						start_of_latest_foreign, ptr);
unknown's avatar
unknown committed
3126 3127 3128 3129 3130 3131 3132 3133
			return(DB_CANNOT_ADD_CONSTRAINT);
		}

		is_on_delete = FALSE;
		n_on_updates++;
	} else {
		is_on_delete = TRUE;
		n_on_deletes++;
unknown's avatar
unknown committed
3134 3135 3136
	}

	ptr = dict_accept(ptr, "RESTRICT", &success);
unknown's avatar
unknown committed
3137

unknown's avatar
unknown committed
3138
	if (success) {
unknown's avatar
unknown committed
3139
		goto scan_on_conditions;
unknown's avatar
unknown committed
3140 3141 3142 3143 3144
	}

	ptr = dict_accept(ptr, "CASCADE", &success);

	if (success) {
unknown's avatar
unknown committed
3145 3146 3147 3148 3149
		if (is_on_delete) {
			foreign->type |= DICT_FOREIGN_ON_DELETE_CASCADE;
		} else {
			foreign->type |= DICT_FOREIGN_ON_UPDATE_CASCADE;
		}
unknown's avatar
unknown committed
3150

unknown's avatar
unknown committed
3151 3152 3153 3154 3155 3156 3157 3158 3159 3160
		goto scan_on_conditions;
	}

	ptr = dict_accept(ptr, "NO", &success);

	if (success) {
		ptr = dict_accept(ptr, "ACTION", &success);

		if (!success) {
			dict_foreign_free(foreign);
unknown's avatar
unknown committed
3161 3162
			dict_foreign_report_syntax_err(name,
					start_of_latest_foreign, ptr);
unknown's avatar
unknown committed
3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173
		
			return(DB_CANNOT_ADD_CONSTRAINT);
		}

		if (is_on_delete) {
			foreign->type |= DICT_FOREIGN_ON_DELETE_NO_ACTION;
		} else {
			foreign->type |= DICT_FOREIGN_ON_UPDATE_NO_ACTION;
		}

		goto scan_on_conditions;
unknown's avatar
unknown committed
3174 3175 3176 3177 3178
	}

	ptr = dict_accept(ptr, "SET", &success);

	if (!success) {
unknown's avatar
unknown committed
3179
		dict_foreign_free(foreign);
unknown's avatar
unknown committed
3180 3181
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
unknown's avatar
unknown committed
3182
		return(DB_CANNOT_ADD_CONSTRAINT);
unknown's avatar
unknown committed
3183 3184 3185 3186
	}

	ptr = dict_accept(ptr, "NULL", &success);

unknown's avatar
unknown committed
3187 3188
	if (!success) {
		dict_foreign_free(foreign);
unknown's avatar
unknown committed
3189 3190
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
unknown's avatar
unknown committed
3191 3192 3193 3194 3195
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

	for (j = 0; j < foreign->n_fields; j++) {
		if ((dict_index_get_nth_type(
unknown's avatar
unknown committed
3196 3197 3198
				foreign->foreign_index, j)->prtype)
				& DATA_NOT_NULL) {

unknown's avatar
unknown committed
3199 3200
			/* It is not sensible to define SET NULL
			if the column is not allowed to be NULL! */
unknown's avatar
unknown committed
3201

unknown's avatar
unknown committed
3202 3203
			dict_foreign_free(foreign);

unknown's avatar
unknown committed
3204
			mutex_enter(&dict_foreign_err_mutex);
3205 3206 3207 3208
			dict_foreign_error_report_low(ef, name);
			fprintf(ef, "%s:\n"
		"You have defined a SET NULL condition though some of the\n"
		"columns are defined as NOT NULL.\n", start_of_latest_foreign);
unknown's avatar
unknown committed
3209 3210
			mutex_exit(&dict_foreign_err_mutex);

unknown's avatar
unknown committed
3211
			return(DB_CANNOT_ADD_CONSTRAINT);
unknown's avatar
unknown committed
3212
		}
unknown's avatar
unknown committed
3213
	}
unknown's avatar
unknown committed
3214

unknown's avatar
unknown committed
3215 3216 3217 3218 3219
	if (is_on_delete) {
		foreign->type |= DICT_FOREIGN_ON_DELETE_SET_NULL;
	} else {
		foreign->type |= DICT_FOREIGN_ON_UPDATE_SET_NULL;
	}
unknown's avatar
unknown committed
3220
	
unknown's avatar
unknown committed
3221
	goto scan_on_conditions;
unknown's avatar
unknown committed
3222

unknown's avatar
unknown committed
3223 3224 3225 3226
try_find_index:
	if (n_on_deletes > 1 || n_on_updates > 1) {
		/* It is an error to define more than 1 action */
		
unknown's avatar
unknown committed
3227 3228
		dict_foreign_free(foreign);

unknown's avatar
unknown committed
3229
		mutex_enter(&dict_foreign_err_mutex);
3230 3231
		dict_foreign_error_report_low(ef, name);
		fprintf(ef, "%s:\n"
unknown's avatar
unknown committed
3232
"You have twice an ON DELETE clause or twice an ON UPDATE clause.\n",
3233
			start_of_latest_foreign);
unknown's avatar
unknown committed
3234 3235
		mutex_exit(&dict_foreign_err_mutex);

unknown's avatar
unknown committed
3236
		return(DB_CANNOT_ADD_CONSTRAINT);
unknown's avatar
unknown committed
3237
	}
unknown's avatar
unknown committed
3238

3239 3240 3241 3242
	/* Try to find an index which contains the columns as the first fields
	and in the right order, and the types are the same as in
	foreign->foreign_index */

unknown's avatar
unknown committed
3243 3244 3245
	if (referenced_table) {
		index = dict_foreign_find_index(referenced_table,
						column_names, i,
3246
						foreign->foreign_index);
unknown's avatar
unknown committed
3247 3248
		if (!index) {
			dict_foreign_free(foreign);
unknown's avatar
unknown committed
3249
			mutex_enter(&dict_foreign_err_mutex);
3250 3251
			dict_foreign_error_report_low(ef, name);
			fprintf(ef, "%s:\n"
unknown's avatar
unknown committed
3252 3253
"Cannot find an index in the referenced table where the\n"
"referenced columns appear as the first columns, or column types\n"
3254
"in the table and the referenced table do not match for constraint.\n"
3255 3256
"See http://dev.mysql.com/doc/mysql/en/InnoDB_foreign_key_constraints.html\n"
"for correct foreign key definition.\n",
3257
				start_of_latest_foreign);
unknown's avatar
unknown committed
3258 3259
			mutex_exit(&dict_foreign_err_mutex);

unknown's avatar
unknown committed
3260 3261 3262 3263 3264
			return(DB_CANNOT_ADD_CONSTRAINT);
		}
	} else {
		ut_a(trx->check_foreigns == FALSE);
		index = NULL;
3265 3266 3267 3268 3269
	}

	foreign->referenced_index = index;
	foreign->referenced_table = referenced_table;

3270 3271
	foreign->referenced_table_name = mem_heap_strdup(foreign->heap,
						referenced_table_name);
3272 3273 3274 3275 3276
					
	foreign->referenced_col_names = mem_heap_alloc(foreign->heap,
							i * sizeof(void*));
	for (i = 0; i < foreign->n_fields; i++) {
		foreign->referenced_col_names[i]
3277
			= mem_heap_strdup(foreign->heap, column_names[i]);
3278 3279 3280 3281 3282
	}

	/* We found an ok constraint definition: add to the lists */
	
	UT_LIST_ADD_LAST(foreign_list, table->foreign_list, foreign);
unknown's avatar
unknown committed
3283 3284 3285 3286

	if (referenced_table) {
		UT_LIST_ADD_LAST(referenced_list,
					referenced_table->referenced_list,
3287
								foreign);
unknown's avatar
unknown committed
3288
	}
unknown's avatar
unknown committed
3289

3290 3291 3292
	goto loop;
}

unknown's avatar
unknown committed
3293 3294 3295 3296 3297 3298 3299 3300 3301 3302
/*************************************************************************
Scans a table create SQL string and adds to the data dictionary the foreign
key constraints declared in the string. This function should be called after
the indexes for a table have been created. Each foreign key constraint must
be accompanied with indexes in both participating tables. The indexes are
allowed to contain more fields than mentioned in the constraint. */

ulint
dict_create_foreign_constraints(
/*============================*/
3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315
					/* out: error code or DB_SUCCESS */
	trx_t*		trx,		/* in: transaction */
	const char*	sql_string,	/* in: table create statement where
					foreign keys are declared like:
					FOREIGN KEY (a, b) REFERENCES
					table2(c, d), table2 can be written
					also with the database
					name before it: test.table2; the
					default database id the database of
					parameter name */
	const char*	name)		/* in: table full name in the
					normalized form
					database_name/table_name */
unknown's avatar
unknown committed
3316
{
3317 3318 3319
	char*		str;
	ulint		err;
	mem_heap_t*	heap;
unknown's avatar
unknown committed
3320 3321

	str = dict_strip_comments(sql_string);
3322
	heap = mem_heap_create(10000);
unknown's avatar
unknown committed
3323

3324 3325 3326 3327
	err = dict_create_foreign_constraints_low(trx, heap, str, name);

	mem_heap_free(heap);
	mem_free(str);
unknown's avatar
unknown committed
3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347

	return(err);	
}

/**************************************************************************
Parses the CONSTRAINT id's to be dropped in an ALTER TABLE statement. */

ulint
dict_foreign_parse_drop_constraints(
/*================================*/
						/* out: DB_SUCCESS or
						DB_CANNOT_DROP_CONSTRAINT if
						syntax error or the constraint
						id does not match */
	mem_heap_t*	heap,			/* in: heap from which we can
						allocate memory */
	trx_t*		trx,			/* in: transaction */
	dict_table_t*	table,			/* in: table */
	ulint*		n,			/* out: number of constraints
						to drop */
3348
	const char***	constraints_to_drop)	/* out: id's of the
unknown's avatar
unknown committed
3349 3350
						constraints to drop */
{
3351 3352 3353 3354 3355
	dict_foreign_t*	foreign;
	ibool		success;
	char*		str;
	const char*	ptr;
	const char*	id;
3356
	FILE*		ef	= dict_foreign_err_file;
unknown's avatar
unknown committed
3357 3358 3359 3360 3361 3362 3363 3364
	
	*n = 0;

	*constraints_to_drop = mem_heap_alloc(heap, 1000 * sizeof(char*));

	str = dict_strip_comments(*(trx->mysql_query_str));
	ptr = str;

3365
#ifdef UNIV_SYNC_DEBUG
unknown's avatar
unknown committed
3366
	ut_ad(mutex_own(&(dict_sys->mutex)));
3367
#endif /* UNIV_SYNC_DEBUG */
unknown's avatar
unknown committed
3368
loop:
3369
	ptr = dict_scan_to(ptr, "DROP");
unknown's avatar
unknown committed
3370 3371 3372 3373 3374 3375 3376

	if (*ptr == '\0') {
		mem_free(str);
		
		return(DB_SUCCESS);
	}

3377
	ptr = dict_accept(ptr, "DROP", &success);
unknown's avatar
unknown committed
3378 3379 3380 3381 3382 3383

	if (!isspace(*ptr)) {

	        goto loop;
	}

3384
	ptr = dict_accept(ptr, "FOREIGN", &success);
unknown's avatar
unknown committed
3385 3386 3387 3388 3389 3390
	
	if (!success) {

	        goto loop;
	}

3391
	ptr = dict_accept(ptr, "KEY", &success);
unknown's avatar
unknown committed
3392 3393 3394 3395 3396 3397

	if (!success) {

		goto syntax_error;
	}

3398
	ptr = dict_scan_id(ptr, heap, &id, TRUE);
unknown's avatar
unknown committed
3399

3400
	if (id == NULL) {
unknown's avatar
unknown committed
3401 3402 3403 3404

		goto syntax_error;
	}

3405
	ut_a(*n < 1000);
unknown's avatar
unknown committed
3406 3407 3408 3409 3410 3411 3412 3413
	(*constraints_to_drop)[*n] = id;
	(*n)++;
	
	/* Look for the given constraint id */

	foreign = UT_LIST_GET_FIRST(table->foreign_list);

	while (foreign != NULL) {
3414
		if (0 == strcmp(foreign->id, id)
3415
		    || (strchr(foreign->id, '/')
3416
			&& 0 == strcmp(id,
unknown's avatar
unknown committed
3417
					dict_remove_db_name(foreign->id)))) {
unknown's avatar
unknown committed
3418 3419 3420 3421 3422 3423 3424 3425 3426
			/* Found */
			break;
		}
		
		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}

	if (foreign == NULL) {
		mutex_enter(&dict_foreign_err_mutex);
3427 3428 3429 3430
		rewind(ef);
		ut_print_timestamp(ef);
		fputs(
	" Error in dropping of a foreign key constraint of table ", ef);
3431
		ut_print_name(ef, NULL, table->name);
3432 3433 3434 3435
		fputs(",\n"
			"in SQL command\n", ef);
		fputs(str, ef);
		fputs("\nCannot find a constraint with the given id ", ef);
3436
		ut_print_name(ef, NULL, id);
3437
		fputs(".\n", ef);
unknown's avatar
unknown committed
3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448
		mutex_exit(&dict_foreign_err_mutex);

		mem_free(str);

		return(DB_CANNOT_DROP_CONSTRAINT);
	}

	goto loop;	

syntax_error:
	mutex_enter(&dict_foreign_err_mutex);
3449 3450 3451 3452
	rewind(ef);
	ut_print_timestamp(ef);
	fputs(
	" Syntax error in dropping of a foreign key constraint of table ", ef);
3453
	ut_print_name(ef, NULL, table->name);
3454 3455
	fprintf(ef, ",\n"
		"close to:\n%s\n in SQL command\n%s\n", ptr, str);
unknown's avatar
unknown committed
3456 3457 3458 3459 3460 3461 3462
	mutex_exit(&dict_foreign_err_mutex);

	mem_free(str);

	return(DB_CANNOT_DROP_CONSTRAINT);
}

3463 3464
/*==================== END OF FOREIGN KEY PROCESSING ====================*/

3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530
/**************************************************************************
Returns an index object if it is found in the dictionary cache. */

dict_index_t*
dict_index_get_if_in_cache(
/*=======================*/
				/* out: index, NULL if not found */
	dulint	index_id)	/* in: index id */
{
	dict_table_t*	table;
	dict_index_t*	index;

	if (dict_sys == NULL) {
		return(NULL);
	}

	mutex_enter(&(dict_sys->mutex));
	
	table = UT_LIST_GET_FIRST(dict_sys->table_LRU);

	while (table) {
		index = UT_LIST_GET_FIRST(table->indexes);

		while (index) {
			if (0 == ut_dulint_cmp(index->id, index_id)) {

				goto found;
			}

			index = UT_LIST_GET_NEXT(indexes, index);
		}

		table = UT_LIST_GET_NEXT(table_LRU, table);
	}

	index = NULL;
found:
	mutex_exit(&(dict_sys->mutex));

	return(index);
}

/**************************************************************************
Creates an index tree struct. */

dict_tree_t*
dict_tree_create(
/*=============*/
				/* out, own: created tree */
	dict_index_t*	index)	/* in: the index for which to create: in the
				case of a mixed tree, this should be the
				index of the cluster object */
{
	dict_tree_t*	tree;

	tree = mem_alloc(sizeof(dict_tree_t));

	/* Inherit info from the index */

	tree->type = index->type;
	tree->space = index->space;
	tree->page = index->page_no;

	tree->id = index->id;
	
	UT_LIST_INIT(tree->tree_indexes);
3531

3532
	tree->magic_n = DICT_TREE_MAGIC_N;
3533

3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548
	rw_lock_create(&(tree->lock));

	rw_lock_set_level(&(tree->lock), SYNC_INDEX_TREE);

	return(tree);
}

/**************************************************************************
Frees an index tree struct. */

void
dict_tree_free(
/*===========*/
	dict_tree_t*	tree)	/* in, own: index tree */
{
unknown's avatar
unknown committed
3549
	ut_a(tree);
unknown's avatar
unknown committed
3550
	ut_ad(tree->magic_n == DICT_TREE_MAGIC_N);
3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563

	rw_lock_free(&(tree->lock));
	mem_free(tree);
}

/**************************************************************************
In an index tree, finds the index corresponding to a record in the tree. */
UNIV_INLINE
dict_index_t*
dict_tree_find_index_low(
/*=====================*/
				/* out: index */
	dict_tree_t*	tree,	/* in: index tree */
unknown's avatar
unknown committed
3564 3565
	rec_t*		rec)	/* in: record for which to find correct
				index */
3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602
{
	dict_index_t*	index;
	dict_table_t*	table;
	dulint		mix_id;
	ulint		len;
	
	index = UT_LIST_GET_FIRST(tree->tree_indexes);
	ut_ad(index);
	table = index->table;
	
	if ((index->type & DICT_CLUSTERED)
				&& (table->type != DICT_TABLE_ORDINARY)) {

		/* Get the mix id of the record */

		mix_id = mach_dulint_read_compressed(
				rec_get_nth_field(rec, table->mix_len, &len));

		while (ut_dulint_cmp(table->mix_id, mix_id) != 0) {

			index = UT_LIST_GET_NEXT(tree_indexes, index);
			table = index->table;
			ut_ad(index);
		}
	}

	return(index);
}

/**************************************************************************
In an index tree, finds the index corresponding to a record in the tree. */

dict_index_t*
dict_tree_find_index(
/*=================*/
				/* out: index */
	dict_tree_t*	tree,	/* in: index tree */
unknown's avatar
unknown committed
3603 3604
	rec_t*		rec)	/* in: record for which to find correct
				index */
3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693
{
	dict_index_t*	index;
	
	index = dict_tree_find_index_low(tree, rec);
	
	return(index);
}

/**************************************************************************
In an index tree, finds the index corresponding to a dtuple which is used
in a search to a tree. */

dict_index_t*
dict_tree_find_index_for_tuple(
/*===========================*/
				/* out: index; NULL if the tuple does not
				contain the mix id field in a mixed tree */
	dict_tree_t*	tree,	/* in: index tree */
	dtuple_t*	tuple)	/* in: tuple for which to find index */
{
	dict_index_t*	index;
	dict_table_t*	table;
	dulint		mix_id;

	ut_ad(dtuple_check_typed(tuple));
	
	if (UT_LIST_GET_LEN(tree->tree_indexes) == 1) {

		return(UT_LIST_GET_FIRST(tree->tree_indexes));
	}

	index = UT_LIST_GET_FIRST(tree->tree_indexes);
	ut_ad(index);
	table = index->table;

	if (dtuple_get_n_fields(tuple) <= table->mix_len) {

		return(NULL);
	}

	/* Get the mix id of the record */

	mix_id = mach_dulint_read_compressed(
			dfield_get_data(
				dtuple_get_nth_field(tuple, table->mix_len)));

	while (ut_dulint_cmp(table->mix_id, mix_id) != 0) {

		index = UT_LIST_GET_NEXT(tree_indexes, index);
		table = index->table;
		ut_ad(index);
	}

	return(index);
}

/**************************************************************************
Checks that a tuple has n_fields_cmp value in a sensible range, so that
no comparison can occur with the page number field in a node pointer. */

ibool
dict_tree_check_search_tuple(
/*=========================*/
				/* out: TRUE if ok */
	dict_tree_t*	tree,	/* in: index tree */
	dtuple_t*	tuple)	/* in: tuple used in a search */
{
	dict_index_t*	index;

	index = dict_tree_find_index_for_tuple(tree, tuple);

	if (index == NULL) {

		return(TRUE);
	}

	ut_a(dtuple_get_n_fields_cmp(tuple)
				<= dict_index_get_n_unique_in_tree(index));
	return(TRUE);
}

/**************************************************************************
Builds a node pointer out of a physical record and a page number. */

dtuple_t*
dict_tree_build_node_ptr(
/*=====================*/
				/* out, own: node pointer */
	dict_tree_t*	tree,	/* in: index tree */
unknown's avatar
unknown committed
3694 3695
	rec_t*		rec,	/* in: record for which to build node
				pointer */
3696
	ulint		page_no,/* in: page number to put in node pointer */
3697
	mem_heap_t*	heap,	/* in: memory heap where pointer created */
unknown's avatar
unknown committed
3698
	ulint           level)  /* in: level of rec in tree: 0 means leaf
3699
				level */
3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710
{
	dtuple_t*	tuple;
	dict_index_t*	ind;
	dfield_t*	field;
	byte*		buf;
	ulint		n_unique;

	ind = dict_tree_find_index_low(tree, rec);
	
	if (tree->type & DICT_UNIVERSAL) {
		/* In a universal index tree, we take the whole record as
3711 3712 3713
		the node pointer if the reord is on the leaf level,
		on non-leaf levels we remove the last field, which
		contains the page number of the child page */
3714 3715

		n_unique = rec_get_n_fields(rec);
3716 3717 3718 3719 3720

		if (level > 0) {
		        ut_a(n_unique > 1);
		        n_unique--;
		}
3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815
	} else {	
		n_unique = dict_index_get_n_unique_in_tree(ind);
	}

	tuple = dtuple_create(heap, n_unique + 1);

	/* When searching in the tree for the node pointer, we must not do
	comparison on the last field, the page number field, as on upper
	levels in the tree there may be identical node pointers with a
	different page number; therefore, we set the n_fields_cmp to one
	less: */
	
	dtuple_set_n_fields_cmp(tuple, n_unique);

	dict_index_copy_types(tuple, ind, n_unique);
	
	buf = mem_heap_alloc(heap, 4);

	mach_write_to_4(buf, page_no);
	
	field = dtuple_get_nth_field(tuple, n_unique);
	dfield_set_data(field, buf, 4);

	dtype_set(dfield_get_type(field), DATA_SYS_CHILD, 0, 0, 0);

	rec_copy_prefix_to_dtuple(tuple, rec, n_unique, heap);

	ut_ad(dtuple_check_typed(tuple));

	return(tuple);
}	
	
/**************************************************************************
Copies an initial segment of a physical record, long enough to specify an
index entry uniquely. */

rec_t*
dict_tree_copy_rec_order_prefix(
/*============================*/
				/* out: pointer to the prefix record */
	dict_tree_t*	tree,	/* in: index tree */
	rec_t*		rec,	/* in: record for which to copy prefix */
	byte**		buf,	/* in/out: memory buffer for the copied prefix,
				or NULL */
	ulint*		buf_size)/* in/out: buffer size */
{
	dict_index_t*	ind;
	rec_t*		order_rec;
	ulint		n_fields;
	
	ind = dict_tree_find_index_low(tree, rec);

	n_fields = dict_index_get_n_unique_in_tree(ind);
	
	if (tree->type & DICT_UNIVERSAL) {

		n_fields = rec_get_n_fields(rec);
	}

	order_rec = rec_copy_prefix_to_buf(rec, n_fields, buf, buf_size);

	return(order_rec);
}	

/**************************************************************************
Builds a typed data tuple out of a physical record. */

dtuple_t*
dict_tree_build_data_tuple(
/*=======================*/
				/* out, own: data tuple */
	dict_tree_t*	tree,	/* in: index tree */
	rec_t*		rec,	/* in: record for which to build data tuple */
	mem_heap_t*	heap)	/* in: memory heap where tuple created */
{
	dtuple_t*	tuple;
	dict_index_t*	ind;
	ulint		n_fields;

	ind = dict_tree_find_index_low(tree, rec);

	n_fields = rec_get_n_fields(rec);
	
	tuple = dtuple_create(heap, n_fields); 

	dict_index_copy_types(tuple, ind, n_fields);

	rec_copy_prefix_to_dtuple(tuple, rec, n_fields, heap);

	ut_ad(dtuple_check_typed(tuple));

	return(tuple);
}	
	
/*************************************************************************
3816
Calculates the minimum record length in an index. */
3817

3818 3819 3820 3821
ulint
dict_index_calc_min_rec_len(
/*========================*/
	dict_index_t*	index)	/* in: index */
3822
{
3823 3824
	ulint	sum	= 0;
	ulint	i;
3825

3826 3827 3828
	for (i = 0; i < dict_index_get_n_fields(index); i++) {
		sum += dtype_get_fixed_size(dict_index_get_nth_type(index, i));
	}
3829

3830 3831 3832 3833
	if (sum > 127) {
		sum += 2 * dict_index_get_n_fields(index);
	} else {
		sum += dict_index_get_n_fields(index);
3834 3835
	}

3836
	sum += REC_N_EXTRA_BYTES;
3837

3838 3839
	return(sum);
}
3840

3841 3842 3843 3844 3845 3846 3847 3848
/*************************************************************************
Calculates new estimates for table and index statistics. The statistics
are used in query optimization. */

void
dict_update_statistics_low(
/*=======================*/
	dict_table_t*	table,		/* in: table */
unknown's avatar
unknown committed
3849 3850
	ibool		has_dict_mutex __attribute__((unused)))
                                        /* in: TRUE if the caller has the
3851 3852 3853 3854 3855
					dictionary mutex */	
{
	dict_index_t*	index;
	ulint		size;
	ulint		sum_of_index_sizes	= 0;
3856

unknown's avatar
unknown committed
3857 3858 3859
	if (table->ibd_file_missing) {
		ut_print_timestamp(stderr);
		fprintf(stderr,
3860 3861 3862 3863 3864
			"  InnoDB: cannot calculate statistics for table %s\n"
"InnoDB: because the .ibd file is missing.  For help, please refer to\n"
"InnoDB: "
"http://dev.mysql.com/doc/mysql/en/InnoDB_troubleshooting_datadict.html\n",
			table->name);
unknown's avatar
unknown committed
3865 3866 3867 3868

		return;
	}

unknown's avatar
unknown committed
3869 3870 3871 3872 3873 3874 3875 3876
	/* If we have set a high innodb_force_recovery level, do not calculate
	statistics, as a badly corrupted index can cause a crash in it. */

	if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {

		return;
	}

3877 3878
	/* Find out the sizes of the indexes and how many different values
	for the key they approximately have */
3879 3880 3881

	index = dict_table_get_first_index(table);	

unknown's avatar
unknown committed
3882 3883 3884 3885 3886 3887
	if (index == NULL) {
		/* Table definition is corrupt */
	
		return;
	}

3888 3889 3890
	while (index) {
		size = btr_get_size(index, BTR_TOTAL_SIZE);

3891 3892
		index->stat_index_size = size;

3893 3894
		sum_of_index_sizes += size;

3895
		size = btr_get_size(index, BTR_N_LEAF_PAGES);
3896

3897 3898 3899 3900
		if (size == 0) {
			/* The root node of the tree is a leaf */
			size = 1;
		}
3901

3902 3903 3904
		index->stat_n_leaf_pages = size;
		
		btr_estimate_number_of_different_key_vals(index);
3905 3906 3907 3908 3909 3910

		index = dict_table_get_next_index(index);
	}

	index = dict_table_get_first_index(table);

3911 3912 3913
	table->stat_n_rows = index->stat_n_diff_key_vals[
					dict_index_get_n_unique(index)];

3914 3915 3916
	table->stat_clustered_index_size = index->stat_index_size;

	table->stat_sum_of_other_index_sizes = sum_of_index_sizes
3917
						- index->stat_index_size;
3918

3919
	table->stat_initialized = TRUE;
3920

3921
        table->stat_modified_counter = 0;
3922 3923
}

3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945
/*************************************************************************
Calculates new estimates for table and index statistics. The statistics
are used in query optimization. */

void
dict_update_statistics(
/*===================*/
	dict_table_t*	table)	/* in: table */
{
	dict_update_statistics_low(table, FALSE);
}

/**************************************************************************
Prints info of a foreign key constraint. */
static
void
dict_foreign_print_low(
/*===================*/
	dict_foreign_t*	foreign)	/* in: foreign key constraint */
{
	ulint	i;

3946
#ifdef UNIV_SYNC_DEBUG
3947
	ut_ad(mutex_own(&(dict_sys->mutex)));
3948
#endif /* UNIV_SYNC_DEBUG */
3949

3950 3951
	fprintf(stderr, "  FOREIGN KEY CONSTRAINT %s: %s (",
		foreign->id, foreign->foreign_table_name);
3952

3953
	for (i = 0; i < foreign->n_fields; i++) {
3954
		fprintf(stderr, " %s", foreign->foreign_col_names[i]);
3955 3956
	}

3957 3958 3959
	fprintf(stderr, " )\n"
		"             REFERENCES %s (",
		foreign->referenced_table_name);
3960 3961
	
	for (i = 0; i < foreign->n_fields; i++) {
3962
		fprintf(stderr, " %s", foreign->referenced_col_names[i]);
3963 3964
	}

3965
	fputs(" )\n", stderr);
3966 3967
}

3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986
/**************************************************************************
Prints a table data. */

void
dict_table_print(
/*=============*/
	dict_table_t*	table)	/* in: table */
{
	mutex_enter(&(dict_sys->mutex));
	dict_table_print_low(table);
	mutex_exit(&(dict_sys->mutex));
}

/**************************************************************************
Prints a table data when we know the table name. */

void
dict_table_print_by_name(
/*=====================*/
unknown's avatar
unknown committed
3987
	const char*	name)
3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002
{
	dict_table_t*	table;

	mutex_enter(&(dict_sys->mutex));

	table = dict_table_get_low(name);

	ut_a(table);
	
	dict_table_print_low(table);
	mutex_exit(&(dict_sys->mutex));
}

/**************************************************************************
Prints a table data. */
4003

4004 4005 4006 4007 4008 4009
void
dict_table_print_low(
/*=================*/
	dict_table_t*	table)	/* in: table */
{
	dict_index_t*	index;
4010 4011
	dict_foreign_t*	foreign;
	ulint		i;
4012

4013
#ifdef UNIV_SYNC_DEBUG
4014
	ut_ad(mutex_own(&(dict_sys->mutex)));
4015
#endif /* UNIV_SYNC_DEBUG */
4016

4017 4018
	dict_update_statistics_low(table, TRUE);
	
4019
	fprintf(stderr,
4020 4021 4022 4023
"--------------------------------------\n"
"TABLE: name %s, id %lu %lu, columns %lu, indexes %lu, appr.rows %lu\n"
"  COLUMNS: ",
			table->name,
4024 4025 4026 4027 4028
			(ulong) ut_dulint_get_high(table->id),
			(ulong) ut_dulint_get_low(table->id),
			(ulong) table->n_cols,
		        (ulong) UT_LIST_GET_LEN(table->indexes),
			(ulong) table->stat_n_rows);
4029 4030

	for (i = 0; i < table->n_cols - 1; i++) {
4031
		dict_col_print_low(dict_table_get_nth_col(table, i));
4032
		fputs("; ", stderr);
4033 4034
	}

4035
	putc('\n', stderr);
4036

4037 4038 4039 4040 4041 4042
	index = UT_LIST_GET_FIRST(table->indexes);

	while (index != NULL) {
		dict_index_print_low(index);
		index = UT_LIST_GET_NEXT(indexes, index);
	}
4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056

	foreign = UT_LIST_GET_FIRST(table->foreign_list);

	while (foreign != NULL) {
		dict_foreign_print_low(foreign);
		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}

	foreign = UT_LIST_GET_FIRST(table->referenced_list);

	while (foreign != NULL) {
		dict_foreign_print_low(foreign);
		foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
	}
4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068
}

/**************************************************************************
Prints a column data. */
static
void
dict_col_print_low(
/*===============*/
	dict_col_t*	col)	/* in: column */
{
	dtype_t*	type;

4069
#ifdef UNIV_SYNC_DEBUG
4070
	ut_ad(mutex_own(&(dict_sys->mutex)));
4071
#endif /* UNIV_SYNC_DEBUG */
4072 4073

	type = dict_col_get_type(col);
4074
	fprintf(stderr, "%s: ", col->name);
4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087

	dtype_print(type);
}

/**************************************************************************
Prints an index data. */
static
void
dict_index_print_low(
/*=================*/
	dict_index_t*	index)	/* in: index */
{
	dict_tree_t*	tree;
4088 4089
	ib_longlong	n_vals;
	ulint		i;
4090

4091
#ifdef UNIV_SYNC_DEBUG
4092
	ut_ad(mutex_own(&(dict_sys->mutex)));
4093
#endif /* UNIV_SYNC_DEBUG */
4094 4095

	tree = index->tree;
4096 4097 4098 4099 4100 4101 4102 4103

	if (index->n_user_defined_cols > 0) {
		n_vals = index->stat_n_diff_key_vals[
					index->n_user_defined_cols];
	} else {
		n_vals = index->stat_n_diff_key_vals[1];
	}

4104
	fprintf(stderr,
4105
		"  INDEX: name %s, id %lu %lu, fields %lu/%lu, type %lu\n"
4106 4107 4108
		"   root page %lu, appr.key vals %lu,"
		" leaf pages %lu, size pages %lu\n"
		"   FIELDS: ",
4109
		index->name,
unknown's avatar
unknown committed
4110 4111 4112 4113
		(ulong) ut_dulint_get_high(tree->id),
		(ulong) ut_dulint_get_low(tree->id),
		(ulong) index->n_user_defined_cols,
		(ulong) index->n_fields, (ulong) index->type,
4114 4115 4116 4117
		(ulong) tree->page,
		(ulong) n_vals,
		(ulong) index->stat_n_leaf_pages,
		(ulong) index->stat_index_size);
4118 4119 4120 4121 4122
			
	for (i = 0; i < index->n_fields; i++) {
		dict_field_print_low(dict_index_get_nth_field(index, i));
	}

4123
	putc('\n', stderr);
4124 4125

/*	btr_print_size(tree); */
4126

4127
/*	btr_print_tree(tree, 7); */
4128 4129 4130 4131 4132 4133 4134 4135 4136 4137
}

/**************************************************************************
Prints a field data. */
static
void
dict_field_print_low(
/*=================*/
	dict_field_t*	field)	/* in: field */
{
4138
#ifdef UNIV_SYNC_DEBUG
4139
	ut_ad(mutex_own(&(dict_sys->mutex)));
4140
#endif /* UNIV_SYNC_DEBUG */
4141
	fprintf(stderr, " %s", field->name);
unknown's avatar
unknown committed
4142 4143

	if (field->prefix_len != 0) {
unknown's avatar
unknown committed
4144
		fprintf(stderr, "(%lu)", (ulong) field->prefix_len);
unknown's avatar
unknown committed
4145
	}
4146
}
unknown's avatar
Merge  
unknown committed
4147

unknown's avatar
unknown committed
4148
/**************************************************************************
4149 4150
Outputs info on a foreign key of a table in a format suitable for
CREATE TABLE. */
unknown's avatar
unknown committed
4151

4152
void
unknown's avatar
unknown committed
4153 4154
dict_print_info_on_foreign_key_in_create_format(
/*============================================*/
4155
	FILE*		file,	/* in: file where to print */
4156
	trx_t*		trx,	/* in: transaction */
4157
	dict_foreign_t*	foreign)/* in: foreign key constraint */
unknown's avatar
unknown committed
4158
{
4159
	const char*	stripped_id;
unknown's avatar
unknown committed
4160 4161
	ulint	i;
	
4162
	if (strchr(foreign->id, '/')) {
unknown's avatar
unknown committed
4163 4164 4165 4166 4167 4168 4169
		/* Strip the preceding database name from the constraint id */
		stripped_id = foreign->id + 1
				+ dict_get_db_name_len(foreign->id);
	} else {
		stripped_id = foreign->id;
	}

4170
	fputs(",\n  CONSTRAINT ", file);
4171
	ut_print_name(file, trx, stripped_id);
4172
	fputs(" FOREIGN KEY (", file);
unknown's avatar
unknown committed
4173

4174
	for (i = 0;;) {
4175
		ut_print_name(file, trx, foreign->foreign_col_names[i]);
4176 4177 4178 4179
		if (++i < foreign->n_fields) {
			fputs(", ", file);
	        } else {
			break;
unknown's avatar
unknown committed
4180 4181 4182
		}
	}

4183 4184
	fputs(") REFERENCES ", file);

unknown's avatar
unknown committed
4185 4186
	if (dict_tables_have_same_db(foreign->foreign_table_name,
					foreign->referenced_table_name)) {
unknown's avatar
unknown committed
4187
		/* Do not print the database name of the referenced table */
4188
		ut_print_name(file, trx, dict_remove_db_name(
unknown's avatar
unknown committed
4189 4190
					foreign->referenced_table_name));
	} else {
unknown's avatar
unknown committed
4191
		/* Look for the '/' in the table name */
unknown's avatar
unknown committed
4192

unknown's avatar
unknown committed
4193 4194 4195 4196 4197
		i = 0;
		while (foreign->referenced_table_name[i] != '/') {
			i++;
		}

4198
		ut_print_namel(file, trx, foreign->referenced_table_name, i);
4199
		putc('.', file);
4200 4201
		ut_print_name(file, trx,
				foreign->referenced_table_name + i + 1);
unknown's avatar
unknown committed
4202 4203
	}

4204 4205 4206 4207
	putc(' ', file);
	putc('(', file);

	for (i = 0;;) {
4208
		ut_print_name(file, trx, foreign->referenced_col_names[i]);
4209 4210 4211 4212
		if (++i < foreign->n_fields) {
			fputs(", ", file);
		} else {
			break;
unknown's avatar
unknown committed
4213 4214 4215
		}
	}

4216
	putc(')', file);
unknown's avatar
unknown committed
4217 4218

	if (foreign->type & DICT_FOREIGN_ON_DELETE_CASCADE) {
4219
		fputs(" ON DELETE CASCADE", file);
unknown's avatar
unknown committed
4220 4221 4222
	}
	
	if (foreign->type & DICT_FOREIGN_ON_DELETE_SET_NULL) {
4223
		fputs(" ON DELETE SET NULL", file);
unknown's avatar
unknown committed
4224 4225 4226
	}

	if (foreign->type & DICT_FOREIGN_ON_DELETE_NO_ACTION) {
4227
		fputs(" ON DELETE NO ACTION", file);
unknown's avatar
unknown committed
4228 4229 4230
	}

	if (foreign->type & DICT_FOREIGN_ON_UPDATE_CASCADE) {
4231
		fputs(" ON UPDATE CASCADE", file);
unknown's avatar
unknown committed
4232 4233 4234
	}
	
	if (foreign->type & DICT_FOREIGN_ON_UPDATE_SET_NULL) {
4235
		fputs(" ON UPDATE SET NULL", file);
unknown's avatar
unknown committed
4236 4237 4238
	}

	if (foreign->type & DICT_FOREIGN_ON_UPDATE_NO_ACTION) {
4239
		fputs(" ON UPDATE NO ACTION", file);
unknown's avatar
unknown committed
4240 4241 4242
	}
}

unknown's avatar
unknown committed
4243
/**************************************************************************
4244
Outputs info on foreign keys of a table. */
unknown's avatar
Merge  
unknown committed
4245 4246 4247 4248

void
dict_print_info_on_foreign_keys(
/*============================*/
unknown's avatar
unknown committed
4249 4250 4251 4252
	ibool		create_table_format, /* in: if TRUE then print in
				a format suitable to be inserted into
				a CREATE TABLE, otherwise in the format
				of SHOW TABLE STATUS */
4253
	FILE*		file,	/* in: file where to print */
4254
	trx_t*		trx,	/* in: transaction */
unknown's avatar
Merge  
unknown committed
4255 4256 4257
	dict_table_t*	table)	/* in: table */
{
	dict_foreign_t*	foreign;
unknown's avatar
unknown committed
4258

unknown's avatar
Merge  
unknown committed
4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269
	mutex_enter(&(dict_sys->mutex));

	foreign = UT_LIST_GET_FIRST(table->foreign_list);

	if (foreign == NULL) {
		mutex_exit(&(dict_sys->mutex));

		return;
	}

	while (foreign != NULL) {
4270 4271
		if (create_table_format) {
			dict_print_info_on_foreign_key_in_create_format(
4272
						file, trx, foreign);
4273 4274 4275
		} else {
			ulint	i;
			fputs("; (", file);
unknown's avatar
unknown committed
4276

4277 4278 4279 4280
			for (i = 0; i < foreign->n_fields; i++) {
				if (i) {
					putc(' ', file);
				}
unknown's avatar
unknown committed
4281

4282
				ut_print_name(file, trx,
unknown's avatar
Merge  
unknown committed
4283 4284 4285
					foreign->foreign_col_names[i]);
			}

4286
			fputs(") REFER ", file);
4287 4288
			ut_print_name(file, trx,
					foreign->referenced_table_name);
4289 4290 4291 4292 4293 4294
			putc('(', file);

			for (i = 0; i < foreign->n_fields; i++) {
				if (i) {
					putc(' ', file);
				}
4295
				ut_print_name(file, trx,
unknown's avatar
Merge  
unknown committed
4296 4297 4298
					foreign->referenced_col_names[i]);
			}

4299
			putc(')', file);
unknown's avatar
Merge  
unknown committed
4300

4301 4302 4303
			if (foreign->type == DICT_FOREIGN_ON_DELETE_CASCADE) {
				fputs(" ON DELETE CASCADE", file);
			}
unknown's avatar
unknown committed
4304
	
4305 4306 4307
			if (foreign->type == DICT_FOREIGN_ON_DELETE_SET_NULL) {
				fputs(" ON DELETE SET NULL", file);
			}
unknown's avatar
unknown committed
4308

4309 4310 4311
			if (foreign->type & DICT_FOREIGN_ON_DELETE_NO_ACTION) {
				fputs(" ON DELETE NO ACTION", file);
			}
unknown's avatar
unknown committed
4312

4313 4314 4315
			if (foreign->type & DICT_FOREIGN_ON_UPDATE_CASCADE) {
				fputs(" ON UPDATE CASCADE", file);
			}
unknown's avatar
unknown committed
4316
	
4317 4318 4319
			if (foreign->type & DICT_FOREIGN_ON_UPDATE_SET_NULL) {
				fputs(" ON UPDATE SET NULL", file);
			}
unknown's avatar
unknown committed
4320

4321 4322 4323
			if (foreign->type & DICT_FOREIGN_ON_UPDATE_NO_ACTION) {
				fputs(" ON UPDATE NO ACTION", file);
			}
unknown's avatar
unknown committed
4324 4325
		}

unknown's avatar
Merge  
unknown committed
4326 4327 4328
		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}

4329 4330
	mutex_exit(&(dict_sys->mutex));
}
unknown's avatar
unknown committed
4331

4332 4333 4334 4335 4336 4337
/************************************************************************
Displays the names of the index and the table. */
void
dict_index_name_print(
/*==================*/
	FILE*			file,	/* in: output stream */
4338
	trx_t*			trx,	/* in: transaction */
4339 4340 4341
	const dict_index_t*	index)	/* in: index to print */
{
	fputs("index ", file);
4342
	ut_print_name(file, trx, index->name);
4343
	fputs(" of table ", file);
4344
	ut_print_name(file, trx, index->table_name);
unknown's avatar
Merge  
unknown committed
4345
}