dict0dict.c 108 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 */

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
32
rw_lock_t	dict_operation_lock;	/* table create, drop, etc. reserve
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
33
					this in X-mode; implicit or backround
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi 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
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi 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 52 53 54
#define	DICT_HEAP_SIZE		100	/* initial memory heap size when
					creating a table or index object */
#define DICT_POOL_PER_PROCEDURE_HASH 512 /* buffer pool max size per stored
					procedure hash table fixed size in
					bytes */
#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 */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
55
 
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 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
/**************************************************************************
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 */
	char*		new_name);	/* in: new table name */
/**************************************************************************
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 */	
/**************************************************************************
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 */
	rec_t*		rec);	/* in: record for which to find correct index */
/**************************************************************************
144
Removes a foreign constraint struct from the dictionet cache. */
145 146
static
void
147 148 149
dict_foreign_remove_from_cache(
/*===========================*/
	dict_foreign_t*	foreign);	/* in, own: foreign constraint */
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
/**************************************************************************
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 */
171 172 173 174 175 176 177
/*************************************************************************
Frees a foreign key struct. */
static
void
dict_foreign_free(
/*==============*/
	dict_foreign_t*	foreign);	/* in, own: foreign key struct */
178

179 180
/* Buffers for storing detailed information about the latest foreign key
and unique key errors */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
181
char*	dict_foreign_err_buf		= NULL;
182 183 184
char*	dict_unique_err_buf		= NULL;
mutex_t	dict_foreign_err_mutex; 	/* mutex protecting the foreign
					and unique error buffers */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
185 186
	
	
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
/************************************************************************
Checks if the database name in two table names is the same. */
static
ibool
dict_tables_have_same_db(
/*=====================*/
			/* out: TRUE if same db name */
	char*	name1,	/* in: table name in the form dbname '/' tablename */
	char*	name2)	/* in: table name in the form dbname '/' tablename */
{
	ulint	i;

	for (i = 0; i < 100000; i++) {
		if (name1[i] == '/' && name2[i] == '/') {

			return(TRUE);
		}

		if (name1[i] != name2[i]) {

			return(FALSE);
		}
	}

	ut_a(0);

	return(FALSE);
}

/************************************************************************
Return the end of table name where we have removed dbname and '/'. */
static
char*
dict_remove_db_name(
/*================*/
			/* out: table name */
	char*	name)	/* in: table name in the form dbname '/' tablename */
{
	ulint	i;

	for (i = 0; i < 100000 ; i++) {
		if (name[i] == '/') {

			return(name + i + 1);
		}
	}

	ut_a(0);

	return(NULL);
}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260

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

ulint
dict_get_db_name_len(
/*=================*/
			/* out: database name length */
	char*	name)	/* in: table name in the form dbname '/' tablename */
{
	ulint	i;

	for (i = 0; i < 100000 ; i++) {
		if (name[i] == '/') {

			return(i);
		}
	}

	ut_a(0);

	return(0);
}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
261
	
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
/************************************************************************
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));
}
	
heikki@donna.mysql.fi's avatar
heikki@donna.mysql.fi committed
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
/************************************************************************
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));
}

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 337 338 339 340 341 342 343 344 345 346 347
/************************************************************************
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 */
	char*		name)	/* in: index name */
{
	return(dict_table_get_index(table, name));
}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
348
	
349
/************************************************************************
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
350
Initializes the autoinc counter. It is not an error to initialize an already
351 352 353 354 355 356
initialized counter. */

void
dict_table_autoinc_initialize(
/*==========================*/
	dict_table_t*	table,	/* in: table */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
357
	ib_longlong	value)	/* in: next value to assign to a row */
358 359 360 361 362 363 364 365 366 367
{
	mutex_enter(&(table->autoinc_mutex));

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

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

/************************************************************************
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
368 369
Gets the next autoinc value (== autoinc counter value), 0 if not yet
initialized. If initialized, increments the counter by 1. */
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385

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;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
386
		table->autoinc = table->autoinc + 1;
387 388 389 390 391 392 393
	}
	
	mutex_exit(&(table->autoinc_mutex));

	return(value);
}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
394
/************************************************************************
395
Decrements the autoinc counter value by 1. */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
396

397 398 399
void
dict_table_autoinc_decrement(
/*=========================*/
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
400 401 402 403
	dict_table_t*	table)	/* in: table */
{
	mutex_enter(&(table->autoinc_mutex));

404
	table->autoinc = table->autoinc - 1;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
405 406 407 408
	
	mutex_exit(&(table->autoinc_mutex));
}

409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
/************************************************************************
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);
}

435
/************************************************************************
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
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
459 460 461 462 463
current value. If not inited, does nothing. */

void
dict_table_autoinc_update(
/*======================*/
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
464

465 466 467 468 469 470
	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) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
471 472
		if (value >= table->autoinc) {
			table->autoinc = value + 1;
473 474 475 476 477 478
		}
	}	

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

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
/************************************************************************
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);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
499 500
	col = dict_table_get_nth_col(index->table, n);

501 502 503 504 505 506 507 508 509 510
	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);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
511
		if (col == field->col && field->prefix_len == 0) {
512 513 514 515 516 517 518

			return(pos);
		}
	}

	return(ULINT_UNDEFINED);
}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
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 553 554 555 556 557 558 559
/************************************************************************
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);
}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
/************************************************************************
Looks for a matching field in an index. The column and the prefix len have
to be the same. */

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;
578
	
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
	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
		    && field->prefix_len == field2->prefix_len) {

			return(pos);
		}
	}

	return(ULINT_UNDEFINED);
}

599 600 601 602 603 604 605 606 607 608 609 610
/**************************************************************************
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;
	
611 612
	if (ut_dulint_cmp(table_id, DICT_FIELDS_ID) <= 0
	   || trx->dict_operation) {
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 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
		/* 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! */

		ut_ad(mutex_own(&(dict_sys->mutex)));

		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);
}

/************************************************************************
Looks for column n postion in the clustered index. */

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));
}

/**************************************************************************
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->procedure_hash = hash_create(buf_pool_get_max_size() /
					(DICT_POOL_PER_PROCEDURE_HASH *
					UNIV_WORD_SIZE));
	dict_sys->size = 0;

	UT_LIST_INIT(dict_sys->table_LRU);
674

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
675 676
	rw_lock_create(&dict_operation_lock);
	rw_lock_set_level(&dict_operation_lock, SYNC_DICT_OPERATION);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
677 678 679

	dict_foreign_err_buf = mem_alloc(DICT_FOREIGN_ERR_BUF_LEN);
	dict_foreign_err_buf[0] = '\0';
680 681
	dict_unique_err_buf = mem_alloc(DICT_FOREIGN_ERR_BUF_LEN);
	dict_unique_err_buf[0] = '\0';
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
682 683
	mutex_create(&dict_foreign_err_mutex);
	mutex_set_level(&dict_foreign_err_mutex, SYNC_ANY_LATCH);
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
}

/**************************************************************************
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(
/*===========*/
				/* out: table, NULL if does not exist */
	char*	table_name,	/* in: table name */
	trx_t*	trx)		/* in: transaction handle or NULL */
{
	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) {
709
	        if (!table->stat_initialized) {
710 711 712 713 714 715 716 717
			dict_update_statistics(table);
		}
	}
	
	return(table);
}

/**************************************************************************
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
718
Returns a table object and increments MySQL open handle count on the table. */
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750

dict_table_t*
dict_table_get_and_increment_handle_count(
/*======================================*/
				/* out: table, NULL if does not exist */
	char*	table_name,	/* in: table name */
	trx_t*	trx)		/* in: transaction handle or NULL */
{
	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) {
	        if (!table->stat_initialized) {
			dict_update_statistics(table);
		}
	}
	
	return(table);
}

751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
/**************************************************************************
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);
	ut_ad(mutex_own(&(dict_sys->mutex)));
	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. */

780 781
	dict_mem_table_add_col(table, (char *) "DB_ROW_ID", DATA_SYS,
			       DATA_ROW_ID, 0, 0);
782
	ut_ad(DATA_ROW_ID == 0);
783 784
	dict_mem_table_add_col(table, (char *) "DB_TRX_ID", DATA_SYS,
			       DATA_TRX_ID, 0, 0);
785
	ut_ad(DATA_TRX_ID == 1);
786 787
	dict_mem_table_add_col(table, (char *) "DB_ROLL_PTR", DATA_SYS,
			       DATA_ROLL_PTR,
788 789 790
									0, 0);
	ut_ad(DATA_ROLL_PTR == 2);

791 792
	dict_mem_table_add_col(table, (char *) "DB_MIX_ID", DATA_SYS,
			       DATA_MIX_ID, 0, 0);
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
	ut_ad(DATA_MIX_ID == 3);
	ut_ad(DATA_N_SYS_COLS == 4); /* This assert reminds that if a new
					system column is added to the program,
					it should be dealt with here */ 

	/* 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 */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
827 828
	HASH_INSERT(dict_table_t, name_hash, dict_sys->table_hash, fold,
								   table);
829 830 831

	/* 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,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
832
								   table);
833 834 835 836 837 838 839 840 841
	/* 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(); */
}

842 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 873 874 875 876
/**************************************************************************
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);
}

877 878 879 880 881 882 883 884
/**************************************************************************
Renames a table object. */

ibool
dict_table_rename_in_cache(
/*=======================*/
					/* out: TRUE if success */
	dict_table_t*	table,		/* in: table */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
885 886 887 888
	char*		new_name,	/* in: new name */
	ibool		rename_also_foreigns)/* in: in ALTER TABLE we want
					to preserve the original table name
					in constraints which reference it */
889
{
890 891 892 893 894
	dict_foreign_t*	foreign;
	dict_index_t*	index;
	ulint		fold;
	ulint		old_size;
	char*		name_buf;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
895
	char*		old_name;
896
	ulint		i;
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 923 924
	
	ut_ad(table);
	ut_ad(mutex_own(&(dict_sys->mutex)));
	
	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) {
			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,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
925
					ut_fold_string(table->name), table);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
926 927 928
	old_name = mem_heap_alloc(table->heap, ut_strlen(table->name) + 1);
	
	ut_strcpy(old_name, table->name);
929 930 931 932 933 934 935 936

	name_buf = mem_heap_alloc(table->heap, ut_strlen(new_name) + 1);
					
	ut_memcpy(name_buf, new_name, ut_strlen(new_name) + 1);

	table->name = name_buf;
					
	/* Add table to hash table of tables */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
937 938
	HASH_INSERT(dict_table_t, name_hash, dict_sys->table_hash, fold,
								   table);
939 940 941
	
	dict_sys->size += (mem_heap_get_size(table->heap) - old_size);

942 943 944 945 946 947 948 949 950
	/* 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);
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
	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);
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
986 987 988
	/* 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. */
989 990 991 992 993 994 995 996

	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 */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
997

998 999 1000 1001 1002
			foreign->foreign_table_name = mem_heap_alloc(
					foreign->heap,
					ut_strlen(table->name) + 1);
		}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 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 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
		sprintf(foreign->foreign_table_name, "%s", table->name);

		if (ut_str_contains(foreign->id, '/')) {
			ulint	db_len;
			char	old_id[2000];

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

			ut_a(ut_strlen(foreign->id) < 1999);

			ut_strcpy(old_id, foreign->id);

			if (ut_strlen(foreign->id) > ut_strlen(old_name)
						+ ut_strlen("_ibfk_")
			    && 0 == ut_memcmp(foreign->id, old_name,
						ut_strlen(old_name))
			    && 0 == ut_memcmp(
					foreign->id + ut_strlen(old_name),
				    (char*)"_ibfk_", ut_strlen("_ibfk_"))) {

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

				if (ut_strlen(table->name) 
				    > ut_strlen(old_name)) {
					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 */
				sprintf(foreign->id, "%s%s", table->name,
						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);

				sprintf(foreign->id + db_len, "%s",
						dict_remove_db_name(old_id));
			}
		}
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069

		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 */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1070

1071 1072 1073 1074 1075
			foreign->referenced_table_name = mem_heap_alloc(
					foreign->heap,
					ut_strlen(table->name) + 1);
		}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1076
		sprintf(foreign->referenced_table_name, "%s", table->name);
1077 1078 1079 1080

		foreign = UT_LIST_GET_NEXT(referenced_list, foreign);
	}

1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
	return(TRUE);
}

/**************************************************************************
Removes a table object from the dictionary cache. */

void
dict_table_remove_from_cache(
/*=========================*/
	dict_table_t*	table)	/* in, own: table */
{
1092
	dict_foreign_t*	foreign;
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
	dict_index_t*	index;
	ulint		size;
	ulint		i;
	
	ut_ad(table);
	ut_ad(mutex_own(&(dict_sys->mutex)));
	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);

	/* printf("Removing table %s from dictionary cache\n", table->name); */

1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
	/* 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);
	}

1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
	/* 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);

1145 1146
	mutex_free(&(table->autoinc_mutex));

1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
	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! */
1159

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 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 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
void
dict_table_LRU_trim(void)
/*=====================*/
{
	dict_table_t*	table;
	dict_table_t*	prev_table;

	ut_a(0);

	ut_ad(mutex_own(&(dict_sys->mutex)));

	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);
	ut_ad(mutex_own(&(dict_sys->mutex)));
	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);
	ut_ad(mutex_own(&(dict_sys->mutex)));
	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 */
	char*		new_name)	/* in: new table name */
{
	ulint		fold;

	ut_ad(table && col);
	ut_ad(mutex_own(&(dict_sys->mutex)));
	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);
	ut_ad(mutex_own(&(dict_sys->mutex)));
	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);
	}
1313
	
1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
	/* 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);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1356 1357
		tree = dict_index_get_tree(
					UT_LIST_GET_FIRST(cluster->indexes));
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
		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;
	}

1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
	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;
		}
	}
	
1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 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 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 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
	/* 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);
	ut_ad(mutex_own(&(dict_sys->mutex)));

	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);
	ut_ad(mutex_own(&(dict_sys->mutex)));

	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(
/*===============*/
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1485 1486 1487 1488
	dict_index_t*	index,		/* in: index */
	dict_col_t*	col,		/* in: column */
	ulint		order,		/* in: order criterion */
	ulint		prefix_len)	/* in: column prefix length */
1489 1490 1491
{
	dict_field_t*	field;

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1492
	dict_mem_index_add_field(index, col->name, order, prefix_len);
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

	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);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1518 1519
		dict_index_add_col(index1, field->col, field->order,
						      field->prefix_len);
1520 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 1564 1565 1566 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 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621
	}
}

/***********************************************************************
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);
	ut_ad(mutex_own(&(dict_sys->mutex)));
	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,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1622
			  dict_table_get_sys_col(table, DATA_MIX_ID), 0, 0);
1623 1624 1625 1626 1627 1628 1629 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

		/* 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,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1660
			   dict_table_get_sys_col(table, DATA_ROW_ID), 0, 0);
1661 1662 1663 1664
			trx_id_pos++;
		}

		dict_index_add_col(new_index,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1665 1666
			   dict_table_get_sys_col(table, DATA_TRX_ID), 0, 0);
	
1667
		dict_index_add_col(new_index,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1668
			   dict_table_get_sys_col(table, DATA_ROLL_PTR), 0, 0);
1669 1670 1671 1672 1673 1674 1675

		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) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1676 1677 1678 1679 1680 1681 1682
				new_index->trx_id_offset = 0;

				break;
			}

			if (dict_index_get_nth_field(new_index, i)->prefix_len
			    > 0) {
1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
				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);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1704 1705 1706 1707 1708 1709 1710 1711

		/* 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;
		}
1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
	}
	
	/* 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) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1722
			dict_index_add_col(new_index, col, 0, 0);
1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
		}
	}

	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);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1734 1735 1736 1737 1738

		if (field->prefix_len == 0) {

		        field->col->clust_pos = i;
		}
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 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
	}
	
	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));
	ut_ad(mutex_own(&(dict_sys->mutex)));
	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);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1800
		field->col->aux = ULINT_UNDEFINED;
1801 1802 1803 1804 1805 1806
	}

	/* 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);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1807 1808 1809 1810 1811 1812 1813 1814

		/* 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;
		}
1815 1816
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1817
	/* Add to new_index the columns necessary to determine the clustered
1818 1819 1820 1821 1822 1823
	index entry uniquely */

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

		field = dict_index_get_nth_field(clust_index, i);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1824 1825 1826
		if (field->col->aux == ULINT_UNDEFINED) {
			dict_index_add_col(new_index, field->col, 0,
						      field->prefix_len);
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
		}
	}

	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);
}	

1846 1847 1848 1849 1850 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 1878 1879 1880 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 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948
/*====================== FOREIGN KEY PROCESSING ========================*/

/*************************************************************************
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 */
{
	ut_ad(mutex_own(&(dict_sys->mutex)));
	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 */
	char*		id)	/* in: foreign constraint id */
{
	dict_foreign_t*	foreign;

	ut_ad(mutex_own(&(dict_sys->mutex)));

	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 */
	char**		columns,/* in: array of column names */
	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;
	char*		col_name;
	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;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1949 1950 1951 1952 1953 1954 1955 1956
				if (dict_index_get_nth_field(index, i)
						->prefix_len != 0) {
					/* We do not accept column prefix
					indexes here */
					
					break;
				}

1957 1958
				if (ut_strlen(columns[i]) !=
						ut_strlen(col_name)
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1959
				    || 0 != ut_cmp_in_lower_case(columns[i],
1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999
				    			col_name,
				  			ut_strlen(col_name))) {
				  	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);
}

/**************************************************************************
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;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2000
	dict_foreign_t*	for_in_cache			= NULL;
2001
	dict_index_t*	index;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2002
	ibool		added_to_referenced_list	= FALSE;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2003
	char*		buf 				= dict_foreign_err_buf;
2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035

	ut_ad(mutex_own(&(dict_sys->mutex)));

	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,
		    		   for_in_cache->referenced_col_names,
		    		   for_in_cache->n_fields,
		    		   for_in_cache->foreign_index);

		if (index == NULL) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054
			mutex_enter(&dict_foreign_err_mutex);
			ut_sprintf_timestamp(buf);
			sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s:\n"
"there is no index in referenced table which would contain\n"
"the columns as the first columns, or the data types in the\n"
"referenced table do not match to the ones in table. Constraint:\n",
				for_in_cache->foreign_table_name);
			dict_print_info_on_foreign_key_in_create_format(
				for_in_cache, buf + strlen(buf));
			if (for_in_cache->foreign_index) {
				sprintf(buf + strlen(buf),
"\nThe index in the foreign key in table is %.500s\n"
"See http://www.innodb.com/ibman.html about correct foreign key definition.\n",
				for_in_cache->foreign_index->name);
			}
			ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
			mutex_exit(&dict_foreign_err_mutex);
			
2055 2056 2057
			if (for_in_cache == foreign) {
				mem_heap_free(foreign->heap);
			}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2058

2059 2060 2061 2062 2063 2064 2065 2066
		    	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);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2067
		added_to_referenced_list = TRUE;
2068 2069 2070 2071 2072 2073 2074 2075 2076
	}

	if (for_in_cache->foreign_table == NULL && for_table) {
		index = dict_foreign_find_index(for_table,
		    		   for_in_cache->foreign_col_names,
		    		   for_in_cache->n_fields,
		    		   for_in_cache->referenced_index);

		if (index == NULL) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095
			mutex_enter(&dict_foreign_err_mutex);
			ut_sprintf_timestamp(buf);
			sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s:\n"
"there is no index in the table which would contain\n"
"the columns as the first columns, or the data types in the\n"
"table do not match to the ones in the referenced table. Constraint:\n",
				for_in_cache->foreign_table_name);
			dict_print_info_on_foreign_key_in_create_format(
				for_in_cache, buf + strlen(buf));
			if (for_in_cache->foreign_index) {
				sprintf(buf + strlen(buf),
"\nIndex of the foreign key in the referenced table is %.500s\n"
"See http://www.innodb.com/ibman.html about correct foreign key definition.\n",
				for_in_cache->referenced_index->name);
			}
			ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
			mutex_exit(&dict_foreign_err_mutex);

2096
			if (for_in_cache == foreign) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2097 2098 2099 2100 2101 2102
				if (added_to_referenced_list) {
					UT_LIST_REMOVE(referenced_list,
						ref_table->referenced_list,
						for_in_cache);
				}
			
2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
				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'. */
static
char*
dict_scan_to(
/*=========*/
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2127
				/* out: scanned up to this */
2128 2129
	char*	ptr,		/* in: scan from */
	const char *string)	/* in: look for this */
2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159
{
	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. */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2160

2161 2162 2163 2164 2165 2166
char*
dict_accept(
/*========*/
			/* out: if string was accepted, the pointer
			is moved after that, else ptr is returned */
	char*	ptr,	/* in: scan from this */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2167
	const char* string,/* in: accept only this string as the next
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193
			non-whitespace string */
	ibool*	success)/* out: TRUE if accepted */
{
	char*	old_ptr = ptr;
	char*	old_ptr2;

	*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));
}

/*************************************************************************
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2194 2195
Scans an id. For the lexical definition of an 'id', see the code below.
Strips backquotes or double quotes from around the id. */
2196 2197
static
char*
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2198 2199
dict_scan_id(
/*=========*/
2200
				/* out: scanned to */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2201 2202 2203 2204 2205 2206 2207
	char*	ptr,		/* in: scanned to */
	char**	start,		/* out: start of the id; NULL if no id was
				scannable */
	ulint*	len,		/* out: length of the id */
	ibool	accept_also_dot)/* in: TRUE if also a dot can appear in a
				non-quoted id; in a quoted id it can appear
				always */
2208
{
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2209 2210 2211
	char quote	= '\0';

	*start = NULL;
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221

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

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

		return(ptr);
	}

2222
	if (*ptr == '`' || *ptr == '"') {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2223 2224 2225 2226
		quote = *ptr++;
	}
	
	*start = ptr;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2227

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2228 2229 2230
	if (quote) {
		while (*ptr != quote && *ptr != '\0') {
			ptr++;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2231
		}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2232 2233 2234 2235
	} else {
		while (!isspace(*ptr) && *ptr != '(' && *ptr != ')'
		       && (accept_also_dot || *ptr != '.')
		       && *ptr != ',' && *ptr != '\0') {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2236

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2237
			ptr++;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2238
		}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2239 2240 2241
	}

	*len = (ulint) (ptr - *start);
2242
	
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2243 2244
	if (quote) {
		if (*ptr == quote) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2245
			ptr++;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2246 2247 2248 2249
		} else {
			/* Syntax error */
			*start = NULL;
		}
2250
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271

	return(ptr);
}

/*************************************************************************
Tries to scan a column name. */
static
char*
dict_scan_col(
/*==========*/
				/* out: scanned to */
	char*		ptr,	/* in: scanned to */
	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 */
	char**		column_name,/* out: pointer to column->name if
				success */
	ulint*		column_name_len)/* out: column name length */
{
	dict_col_t*	col;
	ulint		i;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2272
	
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2273 2274 2275 2276 2277 2278 2279 2280 2281
	*success = FALSE;

	ptr = dict_scan_id(ptr, column_name, column_name_len, TRUE);

	if (column_name == NULL) {

		return(ptr);	/* Syntax error */
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2282 2283 2284 2285 2286
	if (table == NULL) {
		*success = TRUE;
		*column = NULL;
	} else {
	    	for (i = 0; i < dict_table_get_n_cols(table); i++) {
2287

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2288
			col = dict_table_get_nth_col(table, i);
2289

2290
			if (ut_strlen(col->name) == *column_name_len
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2291 2292
			    && 0 == ut_cmp_in_lower_case(col->name,
							*column_name,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2293
							*column_name_len)) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2294
		    		/* Found */
2295

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2296 2297 2298
		    		*success = TRUE;
		    		*column = col;
		    		*column_name = col->name;
2299

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2300 2301
		    		break;
			}
2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315
		}
	}
	
	return(ptr);
}

/*************************************************************************
Scans the referenced table name from an SQL string. */
static
char*
dict_scan_table_name(
/*=================*/
				/* out: scanned to */
	char*		ptr,	/* in: scanned to */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2316 2317 2318 2319 2320 2321
	dict_table_t**	table,	/* out: table object or NULL */
	char*		name,	/* in: foreign key table name */
	ibool*		success,/* out: TRUE if ok name found */
	char*		second_table_name)/* in/out: buffer where to store
				the referenced table name; must be at least
				2500 bytes */
2322
{
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2323 2324 2325 2326 2327 2328 2329
	char*	database_name	= NULL;
	ulint	database_name_len = 999999999;	/* init to a dummy value to
						suppress a compiler warning */
	char*	table_name	= NULL;
	ulint	table_name_len;
	char*	scanned_id;
	ulint	scanned_id_len;
2330 2331
	ulint	i;
	
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2332
	*success = FALSE;
2333
	*table = NULL;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2334 2335
	
	ptr = dict_scan_id(ptr, &scanned_id, &scanned_id_len, FALSE);	
2336

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2337 2338 2339
	if (scanned_id == NULL) {
		
		return(ptr);	/* Syntax error */
2340 2341
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2342 2343
	if (*ptr == '.') {
		/* We scanned the database name; scan also the table name */
2344

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2345
		ptr++;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2346

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2347 2348
		database_name = scanned_id;
		database_name_len = scanned_id_len;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2349

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2350
		ptr = dict_scan_id(ptr, &table_name, &table_name_len, FALSE);
2351

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2352
		if (table_name == NULL) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2353

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2354
			return(ptr);	/* Syntax error */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2355 2356
		}
	} else {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374
		/* 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` ... */

		for (i = 0; i < scanned_id_len; i++) {
			if (scanned_id[i] == '.') {
				database_name = scanned_id;
				database_name_len = i;
				
				scanned_id = scanned_id + i + 1;
				scanned_id_len -= i + 1;
			}
		}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2375 2376 2377
		table_name = scanned_id;
		table_name_len = scanned_id_len;
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2378

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2379 2380 2381 2382 2383
	if (database_name == NULL) {
		/* Use the database name of the foreign key table */

		database_name = name;
			
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2384
		database_name_len = dict_get_db_name_len(name);
2385 2386
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2387
	if (table_name_len + database_name_len > 2000) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2388

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2389
		return(ptr);	/* Too long name */
2390 2391
	}
	
2392
#ifdef __WIN__
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2393 2394
	ut_cpy_in_lower_case(second_table_name, database_name,
							database_name_len);
2395
#else
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2396 2397 2398
	if (srv_lower_case_table_names) {
		ut_cpy_in_lower_case(second_table_name, database_name,
							database_name_len);
2399
	} else {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2400 2401 2402 2403 2404 2405
		ut_memcpy(second_table_name, database_name,
							database_name_len);
	}
#endif
	second_table_name[database_name_len] = '/';

2406
#ifdef __WIN__
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2407 2408
	ut_cpy_in_lower_case(second_table_name + database_name_len + 1,
						table_name, table_name_len);
2409
#else
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2410 2411 2412 2413 2414 2415
	if (srv_lower_case_table_names) {
		ut_cpy_in_lower_case(second_table_name + database_name_len + 1,
						table_name, table_name_len);
	} else {
		ut_memcpy(second_table_name + database_name_len + 1,
						table_name, table_name_len);
2416
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2417 2418
#endif
	second_table_name[database_name_len + 1 + table_name_len] = '\0';
2419

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2420 2421
	*success = TRUE;

2422 2423
	*table = dict_table_get_low(second_table_name);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2424 2425 2426
	return(ptr);
}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2427
/*************************************************************************
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2428
Skips one id. The id is allowed to contain also '.'. */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
static
char*
dict_skip_word(
/*===========*/
			/* out: scanned to */
	char*	ptr,	/* in: scanned to */
	ibool*	success)/* out: TRUE if success, FALSE if just spaces left in
			string or a syntax error */
{
	char*	start;
	ulint	len;
	
	*success = FALSE;

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2443
	ptr = dict_scan_id(ptr, &start, &len, TRUE);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2444 2445 2446 2447 2448 2449 2450 2451 2452

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

#ifdef currentlynotused
2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478
/*************************************************************************
Returns the number of opening brackets '(' subtracted by the number
of closing brackets ')' between string and ptr. */
static
int
dict_bracket_count(
/*===============*/
			/* out: bracket count */
	char*	string,	/* in: start of string */
	char*	ptr)	/* in: end of string */
{
	int	count	= 0;

	while (string != ptr) {
		if (*string == '(') {
			count++;
		}
		if (*string == ')') {
			count--;
		}

		string++;
	}

	return(count);
}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505
#endif

/*************************************************************************
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(
/*================*/
				/* out, own: SQL string stripped from
				comments; the caller must free this
				with mem_free()! */
	char*	sql_string)	/* in: SQL string */
{
	char*	str;
	char*	sptr;
	char*	ptr;
	
	str = mem_alloc(strlen(sql_string) + 1);

	sptr = sql_string;
	ptr = str;

	for (;;) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2506
scan_more:
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2507 2508 2509
		if (*sptr == '\0') {
			*ptr = '\0';

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2510 2511
			ut_a(ptr <= str + strlen(sql_string));

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524
			return(str);
		}
		
		if (*sptr == '#'
		    || (strlen(sptr) >= 3 && 0 == memcmp("-- ", sptr, 3))) {
			for (;;) {
				/* In Unix a newline is 0x0D while in Windows
				it is 0x0A followed by 0x0D */

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

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2525
					goto scan_more;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
				}

				sptr++;
			}
		}

		if (strlen(sptr) >= 2 && *sptr == '/' && *(sptr + 1) == '*') {
			for (;;) {
				if (strlen(sptr) >= 2
				     && *sptr == '*' && *(sptr + 1) == '/') {

				     	sptr += 2;

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2539
					goto scan_more;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2540 2541 2542 2543
				}

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

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2544
					goto scan_more;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557
				}

				sptr++;
			}
		}

		*ptr = *sptr;

		ptr++;
		sptr++;
	}
}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603
/*************************************************************************
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;

	ut_a(table);

	foreign = UT_LIST_GET_FIRST(table->foreign_list);

	while (foreign) {
		if (ut_strlen(foreign->id) > ut_strlen("_ibfk_")
						+ ut_strlen(table->name)
		    && 0 == ut_memcmp(foreign->id, table->name,
							ut_strlen(table->name))
		    && 0 == ut_memcmp(foreign->id + ut_strlen(table->name),
				      (char*)"_ibfk_", ut_strlen("_ibfk_"))) {
			/* It is of the >= 4.0.18 format */

			id = strtoul(foreign->id + ut_strlen(table->name)
						 + ut_strlen("_ibfk_"),
					&endp, 10);
			ut_a(id != biggest_id);

			if (id > biggest_id) {
				biggest_id = id;
			}
		}

		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}

	return(biggest_id);
}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
/*************************************************************************
Reports a simple foreign key create clause syntax error. */
static
void
dict_foreign_report_syntax_err(
/*===========================*/
	char*	name,			/* in: table name */
	char*	start_of_latest_foreign,/* in: start of the foreign key clause
					in the SQL string */
	char*	ptr)			/* in: place of the syntax error */
{
        char*   buf = dict_foreign_err_buf;

	mutex_enter(&dict_foreign_err_mutex);

	ut_sprintf_timestamp(buf);

	sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s,\n%.500s.\n"
"Syntax error close to:\n%.500s\n", name, start_of_latest_foreign, ptr);

	ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
	mutex_exit(&dict_foreign_err_mutex);
}
2628 2629 2630 2631 2632 2633 2634

/*************************************************************************
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. */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2635
static
2636
ulint
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2637 2638
dict_create_foreign_constraints_low(
/*================================*/
2639 2640
				/* out: error code or DB_SUCCESS */
	trx_t*	trx,		/* in: transaction */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2641 2642
	char*	sql_string,	/* in: table create or ALTER TABLE
				statement where foreign keys are declared like:
2643 2644 2645
				FOREIGN KEY (a, b) REFERENCES table2(c, d),
				table2 can be written also with the database
				name before it: test.table2; the default
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2646
				database is the database of parameter name */
2647 2648 2649 2650 2651
	char*	name)		/* in: table full name in the normalized form
				database_name/table_name */
{
	dict_table_t*	table;
	dict_table_t*	referenced_table;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2652 2653
	dict_table_t*	table_to_alter;
	ulint		highest_id_so_far	= 0;
2654 2655
	dict_index_t*	index;
	dict_foreign_t*	foreign;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2656 2657 2658
 	char*		ptr			= sql_string;
	char*		start_of_latest_foreign	= sql_string;
 	char*		buf			= dict_foreign_err_buf;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2659 2660 2661
	char*		constraint_name;	/* this is NOT a null-
						terminated string */
	ulint		constraint_name_len;
2662 2663
	ibool		success;
	ulint		error;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2664 2665
	char*		ptr1;
	char*		ptr2;
2666
	ulint		i;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2667
	ulint		j;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2668 2669 2670
	ibool		is_on_delete;
	ulint		n_on_deletes;
	ulint		n_on_updates;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2671 2672 2673 2674 2675
	dict_col_t*	columns[500];
	char*		column_names[500];
	ulint		column_name_lens[500];
	char		referenced_table_name[2500];
	
2676 2677 2678 2679 2680
	ut_ad(mutex_own(&(dict_sys->mutex)));

	table = dict_table_get_low(name);

	if (table == NULL) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2681 2682 2683 2684 2685 2686 2687 2688 2689
		mutex_enter(&dict_foreign_err_mutex);
		ut_sprintf_timestamp(buf);
		sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s.\n"
"Cannot find the table from the internal data dictionary of InnoDB.\n"
"Create table statement:\n%.2000\n", name, sql_string);
		ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
		mutex_exit(&dict_foreign_err_mutex);

2690 2691
		return(DB_ERROR);
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739

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

	ptr = dict_accept(ptr, (char*) "ALTER", &success);

	if (!success) {

		goto loop;
	}

	ptr = dict_accept(ptr, (char*) "TABLE", &success);

	if (!success) {

		goto loop;
	}

	/* We are doing an ALTER TABLE: scan the table name we are altering;
	in the call below we use the buffer 'referenced_table_name' as a dummy
	buffer */

	ptr = dict_scan_table_name(ptr, &table_to_alter, name,
					&success, referenced_table_name);
	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 */
2740
loop:
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2741
	/* Scan either to "CONSTRAINT" or "FOREIGN", whichever is closer */
2742

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754
	ptr1 = dict_scan_to(ptr, (char *) "CONSTRAINT");
	ptr2 = dict_scan_to(ptr, (char *) "FOREIGN");

	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;

		ptr = dict_accept(ptr, (char *) "CONSTRAINT", &success);
2755

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769
		ut_a(success);

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

		ptr = dict_scan_id(ptr, &constraint_name, &constraint_name_len,
									FALSE);
	} else {
		ptr = ptr2;
	}

	if (*ptr == '\0') {
		/**********************************************************/
2770 2771 2772
		/* The following call adds the foreign key constraints
		to the data dictionary system tables on disk */
		
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2773 2774
		error = dict_create_add_foreigns_to_dictionary(
						highest_id_so_far, table, trx);
2775 2776 2777
		return(error);
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2778 2779
	start_of_latest_foreign = ptr;

2780
	ptr = dict_accept(ptr, (char *) "FOREIGN", &success);		
2781 2782
	
	if (!isspace(*ptr)) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2783
	        goto loop;
2784 2785
	}

2786
	ptr = dict_accept(ptr, (char *) "KEY", &success);
2787 2788 2789 2790 2791

	if (!success) {
		goto loop;
	}

2792
	ptr = dict_accept(ptr, (char *) "(", &success);
2793 2794

	if (!success) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2795 2796 2797 2798 2799
		/* MySQL allows also an index id before the '('; we
		skip it */
		ptr = dict_skip_word(ptr, &success);

		if (!success) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2800 2801 2802
			dict_foreign_report_syntax_err(name,
					start_of_latest_foreign, ptr);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2803 2804 2805 2806 2807 2808
			return(DB_CANNOT_ADD_CONSTRAINT);
		}

		ptr = dict_accept(ptr, (char *) "(", &success);

		if (!success) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2809 2810 2811 2812
			/* We do not flag a syntax error here because in an
			ALTER TABLE we may also have DROP FOREIGN KEY abc */

		        goto loop;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2813
		}
2814 2815 2816 2817 2818 2819 2820
	}

	i = 0;

	/* Scan the columns in the first list */
col_loop1:
	ptr = dict_scan_col(ptr, &success, table, columns + i,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2821
				column_names + i, column_name_lens + i);
2822
	if (!success) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2823 2824 2825 2826 2827 2828 2829 2830 2831
		mutex_enter(&dict_foreign_err_mutex);
		ut_sprintf_timestamp(buf);
		sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s,\n%.500s.\n"
"Cannot resolve column name close to:\n%.500s\n", name,
					start_of_latest_foreign, ptr);
		ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
		mutex_exit(&dict_foreign_err_mutex);

2832 2833 2834 2835 2836
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

	i++;
	
2837
	ptr = dict_accept(ptr, (char *) ",", &success);
2838 2839 2840 2841 2842

	if (success) {
		goto col_loop1;
	}
	
2843
	ptr = dict_accept(ptr, (char *) ")", &success);
2844 2845

	if (!success) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2846 2847
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
2848 2849 2850 2851 2852 2853 2854 2855 2856
		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) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867
		mutex_enter(&dict_foreign_err_mutex);
		ut_sprintf_timestamp(buf);
		sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s:\n"
"There is no index in the table %.500s where the columns appear\n"
"as the first columns. Constraint:\n%.500s\n"
"See http://www.innodb.com/ibman.html for correct foreign key definition.\n",
			name, name, start_of_latest_foreign);
		ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
		mutex_exit(&dict_foreign_err_mutex);

2868 2869
		return(DB_CANNOT_ADD_CONSTRAINT);
	}
2870
	ptr = dict_accept(ptr, (char *) "REFERENCES", &success);
2871 2872

	if (!success || !isspace(*ptr)) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2873 2874
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
2875 2876 2877 2878 2879 2880 2881
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

	/* Let us create a constraint struct */

	foreign = dict_mem_foreign_create();

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903
	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,
				db_len + 1 + constraint_name_len + 1);
		
		ut_memcpy(foreign->id, table->name, db_len);

		foreign->id[db_len] = '/';

		ut_memcpy(foreign->id + db_len + 1, constraint_name,
							constraint_name_len);
		foreign->id[db_len + 1 + constraint_name_len] = '\0';
	}

2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916
	foreign->foreign_table = table;
	foreign->foreign_table_name = table->name;
	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++) {
		foreign->foreign_col_names[i] = mem_heap_alloc(foreign->heap,
					1 + ut_strlen(columns[i]->name));
		ut_memcpy(foreign->foreign_col_names[i], columns[i]->name,
					1 + ut_strlen(columns[i]->name));
	}
	
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2917 2918
	ptr = dict_scan_table_name(ptr, &referenced_table, name,
					&success, referenced_table_name);
2919

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2920 2921 2922 2923
	/* Note that referenced_table can be NULL if the user has suppressed
	checking of foreign key constraints! */

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

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2926 2927 2928 2929 2930 2931 2932 2933 2934
		mutex_enter(&dict_foreign_err_mutex);
		ut_sprintf_timestamp(buf);
		sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s,\n%.500s.\n"
"Cannot resolve table name close to:\n"
"%.500s\n", name, start_of_latest_foreign, ptr);
		ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
		mutex_exit(&dict_foreign_err_mutex);

2935 2936 2937
		return(DB_CANNOT_ADD_CONSTRAINT);
	}
	
2938
	ptr = dict_accept(ptr, (char *) "(", &success);
2939 2940 2941

	if (!success) {
		dict_foreign_free(foreign);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2942 2943
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
2944 2945 2946 2947 2948 2949 2950 2951
		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,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2952
				column_names + i, column_name_lens + i);
2953 2954 2955 2956
	i++;
	
	if (!success) {
		dict_foreign_free(foreign);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2957

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2958 2959 2960 2961 2962 2963 2964 2965 2966
		mutex_enter(&dict_foreign_err_mutex);
		ut_sprintf_timestamp(buf);
		sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s,\n%.500s\n"
"Cannot resolve column name close to:\n"
"%.500s\n", name, start_of_latest_foreign, ptr);
		ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
		mutex_exit(&dict_foreign_err_mutex);

2967 2968 2969
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

2970
	ptr = dict_accept(ptr, (char *) ",", &success);
2971 2972 2973 2974 2975

	if (success) {
		goto col_loop2;
	}
	
2976
	ptr = dict_accept(ptr, (char *) ")", &success);
2977 2978 2979 2980

	if (!success || foreign->n_fields != i) {
		dict_foreign_free(foreign);
		
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2981 2982
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
2983 2984 2985
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2986 2987 2988 2989 2990 2991
	n_on_deletes = 0;
	n_on_updates = 0;
	
scan_on_conditions:
	/* Loop here as long as we can find ON ... conditions */

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
2992 2993 2994 2995 2996 2997 2998 2999 3000 3001
	ptr = dict_accept(ptr, "ON", &success);

	if (!success) {

		goto try_find_index;
	}

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

	if (!success) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3002 3003 3004 3005
		ptr = dict_accept(ptr, "UPDATE", &success);

		if (!success) {
			dict_foreign_free(foreign);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3006
		
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3007 3008
			dict_foreign_report_syntax_err(name,
						start_of_latest_foreign, ptr);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3009 3010 3011 3012 3013 3014 3015 3016
			return(DB_CANNOT_ADD_CONSTRAINT);
		}

		is_on_delete = FALSE;
		n_on_updates++;
	} else {
		is_on_delete = TRUE;
		n_on_deletes++;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3017 3018 3019
	}

	ptr = dict_accept(ptr, "RESTRICT", &success);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3020

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3021
	if (success) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3022
		goto scan_on_conditions;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3023 3024 3025 3026 3027
	}

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

	if (success) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3028 3029 3030 3031 3032
		if (is_on_delete) {
			foreign->type |= DICT_FOREIGN_ON_DELETE_CASCADE;
		} else {
			foreign->type |= DICT_FOREIGN_ON_UPDATE_CASCADE;
		}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3033

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3034 3035 3036 3037 3038 3039 3040 3041 3042 3043
		goto scan_on_conditions;
	}

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

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

		if (!success) {
			dict_foreign_free(foreign);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3044 3045
			dict_foreign_report_syntax_err(name,
					start_of_latest_foreign, ptr);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056
		
			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;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3057 3058 3059 3060 3061
	}

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

	if (!success) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3062
		dict_foreign_free(foreign);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3063 3064
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3065
		return(DB_CANNOT_ADD_CONSTRAINT);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3066 3067 3068 3069
	}

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

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3070 3071
	if (!success) {
		dict_foreign_free(foreign);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3072 3073
		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
									ptr);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3074 3075 3076 3077 3078
		return(DB_CANNOT_ADD_CONSTRAINT);
	}

	for (j = 0; j < foreign->n_fields; j++) {
		if ((dict_index_get_nth_type(
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3079 3080 3081
				foreign->foreign_index, j)->prtype)
				& DATA_NOT_NULL) {

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3082 3083
			/* It is not sensible to define SET NULL
			if the column is not allowed to be NULL! */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3084

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3085 3086
			dict_foreign_free(foreign);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3087 3088 3089 3090 3091 3092 3093 3094 3095
			mutex_enter(&dict_foreign_err_mutex);
			ut_sprintf_timestamp(buf);
			sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s,\n%.500s.\n"
"You have defined a SET NULL condition though some of the\n"
"columns is defined as NOT NULL.\n", name, start_of_latest_foreign);
			ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
			mutex_exit(&dict_foreign_err_mutex);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3096
			return(DB_CANNOT_ADD_CONSTRAINT);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3097
		}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3098
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3099

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3100 3101 3102 3103 3104
	if (is_on_delete) {
		foreign->type |= DICT_FOREIGN_ON_DELETE_SET_NULL;
	} else {
		foreign->type |= DICT_FOREIGN_ON_UPDATE_SET_NULL;
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3105
	
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3106
	goto scan_on_conditions;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3107

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3108 3109 3110 3111
try_find_index:
	if (n_on_deletes > 1 || n_on_updates > 1) {
		/* It is an error to define more than 1 action */
		
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3112 3113
		dict_foreign_free(foreign);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3114 3115 3116 3117 3118 3119 3120 3121 3122
		mutex_enter(&dict_foreign_err_mutex);
		ut_sprintf_timestamp(buf);
		sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s,\n%.500s.\n"
"You have twice an ON DELETE clause or twice an ON UPDATE clause.\n",
		name, start_of_latest_foreign);
		ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
		mutex_exit(&dict_foreign_err_mutex);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3123
		return(DB_CANNOT_ADD_CONSTRAINT);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3124
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3125

3126 3127 3128 3129
	/* 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 */

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3130 3131 3132
	if (referenced_table) {
		index = dict_foreign_find_index(referenced_table,
						column_names, i,
3133
						foreign->foreign_index);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3134 3135
		if (!index) {
			dict_foreign_free(foreign);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147
			mutex_enter(&dict_foreign_err_mutex);
			ut_sprintf_timestamp(buf);
			sprintf(buf + strlen(buf),
" Error in foreign key constraint of table %.500s:\n"
"Cannot find an index in the referenced table where the\n"
"referenced columns appear as the first columns, or column types\n"
"in the table and the referenced table do not match for constraint:\n%.500s\n"
"See http://www.innodb.com/ibman.html for correct foreign key definition.\n",
				name, start_of_latest_foreign);
			ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
			mutex_exit(&dict_foreign_err_mutex);

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3148 3149 3150 3151 3152
			return(DB_CANNOT_ADD_CONSTRAINT);
		}
	} else {
		ut_a(trx->check_foreigns == FALSE);
		index = NULL;
3153 3154 3155 3156 3157 3158
	}

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

	foreign->referenced_table_name = mem_heap_alloc(foreign->heap,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3159
					1 + ut_strlen(referenced_table_name));
3160

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3161 3162
	ut_memcpy(foreign->referenced_table_name, referenced_table_name,
					1 + ut_strlen(referenced_table_name));
3163 3164 3165 3166 3167 3168
					
	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]
				= mem_heap_alloc(foreign->heap,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3169 3170 3171 3172
					1 + column_name_lens[i]);
		ut_memcpy(foreign->referenced_col_names[i], column_names[i],
					column_name_lens[i]);
		(foreign->referenced_col_names[i])[column_name_lens[i]] = '\0';
3173 3174 3175 3176 3177
	}

	/* We found an ok constraint definition: add to the lists */
	
	UT_LIST_ADD_LAST(foreign_list, table->foreign_list, foreign);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3178 3179 3180 3181

	if (referenced_table) {
		UT_LIST_ADD_LAST(referenced_list,
					referenced_table->referenced_list,
3182
								foreign);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3183
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3184

3185 3186 3187
	goto loop;
}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204
/*************************************************************************
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(
/*============================*/
				/* out: error code or DB_SUCCESS */
	trx_t*	trx,		/* in: transaction */
	char*	sql_string,	/* in: table create or ALTER TABLE
				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
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3205
				database is the database of parameter name */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288
	char*	name)		/* in: table full name in the normalized form
				database_name/table_name */
{
	char*	str;
	ulint	err;

	str = dict_strip_comments(sql_string);

	err = dict_create_foreign_constraints_low(trx, str, name);

	mem_free(str);	
	
	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 */
	char***		constraints_to_drop)	/* out: id's of the
						constraints to drop */
{
        dict_foreign_t* foreign;
	ibool	success;
	char*	str;
 	char*	ptr;
 	char*	buf	= dict_foreign_err_buf;
	char*	start;
	char*	id;
	ulint	len;
	
	*n = 0;

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

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

	ut_ad(mutex_own(&(dict_sys->mutex)));
loop:
	ptr = dict_scan_to(ptr, (char *) "DROP");

	if (*ptr == '\0') {
		ut_a(*n < 1000);

		mem_free(str);
		
		return(DB_SUCCESS);
	}

	ptr = dict_accept(ptr, (char *) "DROP", &success);

	if (!isspace(*ptr)) {

	        goto loop;
	}

	ptr = dict_accept(ptr, (char *) "FOREIGN", &success);
	
	if (!success) {

	        goto loop;
	}

	ptr = dict_accept(ptr, (char *) "KEY", &success);

	if (!success) {

		goto syntax_error;
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3289
	ptr = dict_scan_id(ptr, &start, &len, TRUE);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306

	if (start == NULL) {

		goto syntax_error;
	}

	id = mem_heap_alloc(heap, len + 1);
	ut_memcpy(id, start, len);
	id[len] = '\0';
	(*constraints_to_drop)[*n] = id;
	(*n)++;
	
	/* Look for the given constraint id */

	foreign = UT_LIST_GET_FIRST(table->foreign_list);

	while (foreign != NULL) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3307 3308 3309 3310
		if (0 == ut_strcmp(foreign->id, id)
		    || (ut_str_contains(foreign->id, '/')
			&& 0 == ut_strcmp(id,
					dict_remove_db_name(foreign->id)))) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322
			/* Found */
			break;
		}
		
		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}

	if (foreign == NULL) {
		mutex_enter(&dict_foreign_err_mutex);
		ut_sprintf_timestamp(buf);
		sprintf(buf + strlen(buf),
" Error in dropping of a foreign key constraint of table %.500s,\n"
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3323 3324
"in SQL command\n%s\nCannot find a constraint with the\n"
"given id %s.\n", table->name, str, id);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348
		ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
		mutex_exit(&dict_foreign_err_mutex);

		mem_free(str);

		return(DB_CANNOT_DROP_CONSTRAINT);
	}

	goto loop;	

syntax_error:
	mutex_enter(&dict_foreign_err_mutex);
	ut_sprintf_timestamp(buf);
	sprintf(buf + strlen(buf),
" Syntax error in dropping of a foreign key constraint of table %.500s,\n"
"close to:\n%s\n in SQL command\n%s\n", table->name, ptr, str);
	ut_a(strlen(buf) < DICT_FOREIGN_ERR_BUF_LEN);
	mutex_exit(&dict_foreign_err_mutex);

	mem_free(str);

	return(DB_CANNOT_DROP_CONSTRAINT);
}

3349 3350
/*==================== END OF FOREIGN KEY PROCESSING ====================*/

3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 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 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 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 3603 3604 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
/**************************************************************************
Adds a stored procedure object to the dictionary cache. */

void
dict_procedure_add_to_cache(
/*========================*/
	dict_proc_t*	proc)	/* in: procedure */
{
	ulint	fold;
	
	mutex_enter(&(dict_sys->mutex));
	
	fold = ut_fold_string(proc->name);

	/* Look for a procedure with the same name: error if such exists */
	{
		dict_proc_t*	proc2;
		
		HASH_SEARCH(name_hash, dict_sys->procedure_hash, fold, proc2,
				(ut_strcmp(proc2->name, proc->name) == 0));
		ut_a(proc2 == NULL);
	}

	/* Add the procedure to the hash table */

	HASH_INSERT(dict_proc_t, name_hash, dict_sys->procedure_hash, fold,
									proc);
	mutex_exit(&(dict_sys->mutex));
}

/**************************************************************************
Reserves a parsed copy of a stored procedure to execute. If there are no
free parsed copies left at the moment, parses a new copy. Takes the copy off
the list of copies: the copy must be returned there with
dict_procedure_release_parsed_copy. */

que_t*
dict_procedure_reserve_parsed_copy(
/*===============================*/
				/* out: the query graph */
	dict_proc_t*	proc)	/* in: dictionary procedure node */
{
	que_t*		graph;
	proc_node_t*	proc_node;
	
	ut_ad(!mutex_own(&kernel_mutex));

	mutex_enter(&(dict_sys->mutex));

#ifdef UNIV_DEBUG
	UT_LIST_VALIDATE(graphs, que_t, proc->graphs);
#endif
	graph = UT_LIST_GET_FIRST(proc->graphs);

	if (graph) {
		UT_LIST_REMOVE(graphs, proc->graphs, graph);

/* 		printf("Graph removed, list length %lu\n",
					UT_LIST_GET_LEN(proc->graphs)); */
#ifdef UNIV_DEBUG
		UT_LIST_VALIDATE(graphs, que_t, proc->graphs);
#endif
	}

	mutex_exit(&(dict_sys->mutex));

	if (graph == NULL) {	
		graph = pars_sql(proc->sql_string);

		proc_node = que_fork_get_child(graph);

		proc_node->dict_proc = proc;

		printf("Parsed a new copy of graph %s\n",
						proc_node->proc_id->name);
	}

/*	printf("Returning graph %lu\n", (ulint)graph); */

	return(graph);
}

/**************************************************************************
Releases a parsed copy of an executed stored procedure. Puts the copy to the
list of copies. */

void
dict_procedure_release_parsed_copy(
/*===============================*/
	que_t*	graph)	/* in: query graph of a stored procedure */
{
	proc_node_t*	proc_node;

	ut_ad(!mutex_own(&kernel_mutex));

	mutex_enter(&(dict_sys->mutex));

	proc_node = que_fork_get_child(graph);

	UT_LIST_ADD_FIRST(graphs, (proc_node->dict_proc)->graphs, graph);

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

/**************************************************************************
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);

	tree->magic_n = DICT_TREE_MAGIC_N;

	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 */
{
	ut_ad(tree);
	ut_ad(tree->magic_n == DICT_TREE_MAGIC_N);

	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 */
	rec_t*		rec)	/* in: record for which to find correct index */
{
	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 */
	rec_t*		rec)	/* in: record for which to find correct index */
{
	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 */
	rec_t*		rec,	/* in: record for which to build node pointer */
	ulint		page_no,/* in: page number to put in node pointer */
3684
	mem_heap_t*	heap,	/* in: memory heap where pointer created */
3685
	ulint           level)  /* in: level of rec in tree: 0 means leaf
3686
				level */
3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697
{
	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
3698 3699 3700
		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 */
3701 3702

		n_unique = rec_get_n_fields(rec);
3703 3704 3705 3706 3707

		if (level > 0) {
		        ut_a(n_unique > 1);
		        n_unique--;
		}
3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 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
	} 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);
}	
	
/*************************************************************************
3803
Calculates the minimum record length in an index. */
3804

3805 3806 3807 3808
ulint
dict_index_calc_min_rec_len(
/*========================*/
	dict_index_t*	index)	/* in: index */
3809
{
3810 3811
	ulint	sum	= 0;
	ulint	i;
3812

3813 3814 3815
	for (i = 0; i < dict_index_get_n_fields(index); i++) {
		sum += dtype_get_fixed_size(dict_index_get_nth_type(index, i));
	}
3816

3817 3818 3819 3820
	if (sum > 127) {
		sum += 2 * dict_index_get_n_fields(index);
	} else {
		sum += dict_index_get_n_fields(index);
3821 3822
	}

3823
	sum += REC_N_EXTRA_BYTES;
3824

3825 3826
	return(sum);
}
3827

3828 3829 3830 3831 3832 3833 3834 3835
/*************************************************************************
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 */
3836 3837
	ibool		has_dict_mutex __attribute__((unused)))
                                        /* in: TRUE if the caller has the
3838 3839 3840 3841 3842
					dictionary mutex */	
{
	dict_index_t*	index;
	ulint		size;
	ulint		sum_of_index_sizes	= 0;
3843

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3844 3845 3846 3847 3848 3849 3850 3851
	/* 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;
	}

3852 3853
	/* Find out the sizes of the indexes and how many different values
	for the key they approximately have */
3854 3855 3856

	index = dict_table_get_first_index(table);	

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
3857 3858 3859 3860 3861 3862
	if (index == NULL) {
		/* Table definition is corrupt */
	
		return;
	}

3863 3864 3865
	while (index) {
		size = btr_get_size(index, BTR_TOTAL_SIZE);

3866 3867
		index->stat_index_size = size;

3868 3869
		sum_of_index_sizes += size;

3870
		size = btr_get_size(index, BTR_N_LEAF_PAGES);
3871

3872 3873 3874 3875
		if (size == 0) {
			/* The root node of the tree is a leaf */
			size = 1;
		}
3876

3877 3878 3879
		index->stat_n_leaf_pages = size;
		
		btr_estimate_number_of_different_key_vals(index);
3880 3881 3882 3883 3884 3885

		index = dict_table_get_next_index(index);
	}

	index = dict_table_get_first_index(table);

3886 3887 3888
	table->stat_n_rows = index->stat_n_diff_key_vals[
					dict_index_get_n_unique(index)];

3889 3890 3891
	table->stat_clustered_index_size = index->stat_index_size;

	table->stat_sum_of_other_index_sizes = sum_of_index_sizes
3892
						- index->stat_index_size;
3893

3894
	table->stat_initialized = TRUE;
3895

3896
        table->stat_modified_counter = 0;
3897 3898
}

3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940
/*************************************************************************
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;

	ut_ad(mutex_own(&(dict_sys->mutex)));

	printf("  FOREIGN KEY CONSTRAINT %s: %s (", foreign->id,
					foreign->foreign_table_name);
	
	for (i = 0; i < foreign->n_fields; i++) {
		printf(" %s", foreign->foreign_col_names[i]);
	}

	printf(" )\n");

	printf("             REFERENCES %s (", foreign->referenced_table_name);
	
	for (i = 0; i < foreign->n_fields; i++) {
		printf(" %s", foreign->referenced_col_names[i]);
	}

	printf(" )\n");
}

3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975
/**************************************************************************
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(
/*=====================*/
	char*	name)
{
	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. */
3976

3977 3978 3979 3980 3981 3982
void
dict_table_print_low(
/*=================*/
	dict_table_t*	table)	/* in: table */
{
	dict_index_t*	index;
3983 3984
	dict_foreign_t*	foreign;
	ulint		i;
3985 3986 3987

	ut_ad(mutex_own(&(dict_sys->mutex)));

3988 3989
	dict_update_statistics_low(table, TRUE);
	
3990
	printf("--------------------------------------\n");
3991 3992 3993 3994 3995 3996 3997 3998 3999 4000
	printf(
   "TABLE: name %s, id %lu %lu, columns %lu, indexes %lu, appr.rows %lu\n",
			table->name,
			ut_dulint_get_high(table->id),
			ut_dulint_get_low(table->id),
			table->n_cols, UT_LIST_GET_LEN(table->indexes),
			(ulint)table->stat_n_rows);
	printf("  COLUMNS: ");

	for (i = 0; i < table->n_cols - 1; i++) {
4001
		dict_col_print_low(dict_table_get_nth_col(table, i));
4002
		printf("; ");
4003 4004
	}

4005 4006
	printf("\n");

4007 4008 4009 4010 4011 4012
	index = UT_LIST_GET_FIRST(table->indexes);

	while (index != NULL) {
		dict_index_print_low(index);
		index = UT_LIST_GET_NEXT(indexes, index);
	}
4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026

	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);
	}
4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041
}

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

	ut_ad(mutex_own(&(dict_sys->mutex)));

	type = dict_col_get_type(col);
4042
	printf("%s: ", col->name);
4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055

	dtype_print(type);
}

/**************************************************************************
Prints an index data. */
static
void
dict_index_print_low(
/*=================*/
	dict_index_t*	index)	/* in: index */
{
	dict_tree_t*	tree;
4056 4057
	ib_longlong	n_vals;
	ulint		i;
4058 4059 4060 4061

	ut_ad(mutex_own(&(dict_sys->mutex)));

	tree = index->tree;
4062 4063 4064 4065 4066 4067 4068 4069

	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];
	}

4070
	printf(
4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082
	"  INDEX: name %s, table name %s, id %lu %lu, fields %lu/%lu, type %lu\n",
			index->name, index->table_name,
			ut_dulint_get_high(tree->id),
			ut_dulint_get_low(tree->id),
			index->n_user_defined_cols,
			index->n_fields, index->type);
	printf(
      "   root page %lu, appr.key vals %lu, leaf pages %lu, size pages %lu\n",
		tree->page,
		(ulint)n_vals,
		index->stat_n_leaf_pages,
		index->stat_index_size);
4083
			
4084 4085
	printf("   FIELDS: ");

4086 4087 4088 4089
	for (i = 0; i < index->n_fields; i++) {
		dict_field_print_low(dict_index_get_nth_field(index, i));
	}

4090 4091 4092
	printf("\n");

/*	btr_print_size(tree); */
4093

4094
/*	btr_print_tree(tree, 7); */
4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106
}

/**************************************************************************
Prints a field data. */
static
void
dict_field_print_low(
/*=================*/
	dict_field_t*	field)	/* in: field */
{
	ut_ad(mutex_own(&(dict_sys->mutex)));

4107
	printf(" %s", field->name);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4108 4109 4110 4111

	if (field->prefix_len != 0) {
	        printf("(%lu)", field->prefix_len);
	}
4112
}
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4113

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125
/**************************************************************************
Sprintfs to a string info on a foreign key of a table in a format suitable
for CREATE TABLE. */

char*
dict_print_info_on_foreign_key_in_create_format(
/*============================================*/
				/* out: how far in buf we printed */
	dict_foreign_t*	foreign,/* in: foreign key constraint */
	char*		buf)	/* in: buffer of at least 5000 bytes */
{
	char*	buf2	= buf;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4126
	char*	stripped_id;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4127
	ulint	cpy_len;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4128 4129
	ulint	i;
	
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4130 4131 4132 4133 4134 4135 4136 4137
	if (ut_str_contains(foreign->id, '/')) {
		/* 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;
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4138
	buf2 += sprintf(buf2, ",\n  CONSTRAINT `%s` FOREIGN KEY (",
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4139
								stripped_id);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154
	for (i = 0; i < foreign->n_fields; i++) {
	        if ((ulint)(buf2 - buf) >= 4000) {

	                goto no_space;
	        }
		buf2 += sprintf(buf2, "`%.250s`",
				foreign->foreign_col_names[i]);
		
		if (i + 1 < foreign->n_fields) {
			buf2 += sprintf(buf2, ", ");
		}
	}

	if (dict_tables_have_same_db(foreign->foreign_table_name,
					foreign->referenced_table_name)) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4155
		/* Do not print the database name of the referenced table */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4156 4157 4158 4159
		buf2 += sprintf(buf2, ") REFERENCES `%.500s` (",
					dict_remove_db_name(
					foreign->referenced_table_name));
	} else {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4160 4161 4162
		buf2 += sprintf(buf2, ") REFERENCES `");
	
		/* Look for the '/' in the table name */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4163

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4164 4165 4166 4167 4168 4169
		i = 0;
		while (foreign->referenced_table_name[i] != '/') {
			i++;
		}
		
		cpy_len = i;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4170

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4171 4172
		if (cpy_len > 500) {
			cpy_len = 500;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4173
		}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4174 4175 4176 4177 4178 4179

		memcpy(buf2, foreign->referenced_table_name, cpy_len);
		buf2 += cpy_len;

		buf2 += sprintf(buf2, "`.`%.500s` (",
				foreign->referenced_table_name + i + 1);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223
	}
	
	for (i = 0; i < foreign->n_fields; i++) {
	        if ((ulint)(buf2 - buf) >= 4000) {

	                goto no_space;
	        }
		buf2 += sprintf(buf2, "`%.250s`",
					foreign->referenced_col_names[i]);
		if (i + 1 < foreign->n_fields) {
			buf2 += sprintf(buf2, ", ");
		}
	}

	buf2 += sprintf(buf2, ")");

	if (foreign->type & DICT_FOREIGN_ON_DELETE_CASCADE) {
		buf2 += sprintf(buf2, " ON DELETE CASCADE");
	}
	
	if (foreign->type & DICT_FOREIGN_ON_DELETE_SET_NULL) {
		buf2 += sprintf(buf2, " ON DELETE SET NULL");
	}

	if (foreign->type & DICT_FOREIGN_ON_DELETE_NO_ACTION) {
		buf2 += sprintf(buf2, " ON DELETE NO ACTION");
	}

	if (foreign->type & DICT_FOREIGN_ON_UPDATE_CASCADE) {
		buf2 += sprintf(buf2, " ON UPDATE CASCADE");
	}
	
	if (foreign->type & DICT_FOREIGN_ON_UPDATE_SET_NULL) {
		buf2 += sprintf(buf2, " ON UPDATE SET NULL");
	}

	if (foreign->type & DICT_FOREIGN_ON_UPDATE_NO_ACTION) {
		buf2 += sprintf(buf2, " ON UPDATE NO ACTION");
	}

no_space:
	return(buf2);
}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4224 4225 4226 4227 4228 4229 4230
/**************************************************************************
Sprintfs to a string info on foreign keys of a table in a format suitable
for CREATE TABLE. */
static
void
dict_print_info_on_foreign_keys_in_create_format(
/*=============================================*/
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4231
	char*		buf,	/* in: auxiliary buffer */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4232
	char*		str,	/* in/out: pointer to a string */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4233 4234 4235
	ulint		len,	/* in: buf has to be a buffer of at least
				len + 5000 bytes; str must have at least
				len + 1 bytes */
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253
	dict_table_t*	table)	/* in: table */
{
	dict_foreign_t*	foreign;
	char*		buf2;

	buf2 = buf;

	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) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4254 4255 4256
	        if ((ulint)(buf2 - buf) >= len) {
	                goto no_space;
	        }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4257

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4258 4259
		buf2 = dict_print_info_on_foreign_key_in_create_format(
							foreign, buf2);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4260

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4261 4262
		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4263
no_space:
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4264 4265 4266 4267 4268 4269
	mutex_exit(&(dict_sys->mutex));

	buf[len - 1] = '\0';
	ut_memcpy(str, buf, len);
}

monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4270 4271 4272 4273 4274 4275
/**************************************************************************
Sprintfs to a string info on foreign keys of a table. */

void
dict_print_info_on_foreign_keys(
/*============================*/
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4276 4277 4278 4279
	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 */
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4280 4281 4282 4283 4284 4285 4286
	char*		str,	/* in/out: pointer to a string */
	ulint		len,	/* in: space in str available for info */
	dict_table_t*	table)	/* in: table */
{
	dict_foreign_t*	foreign;
	ulint		i;
	char*		buf2;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4287 4288 4289
	char*		buf;

	buf = mem_alloc(len + 5000);
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4290

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4291 4292 4293
	if (create_table_format) {
		dict_print_info_on_foreign_keys_in_create_format(
						buf, str, len, table);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4294
		mem_free(buf);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4295 4296 4297
		return;
	}

monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4298 4299 4300 4301 4302 4303 4304
	mutex_enter(&(dict_sys->mutex));

	foreign = UT_LIST_GET_FIRST(table->foreign_list);

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

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4305
		mem_free(buf);
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4306 4307 4308
		return;
	}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4309 4310
	buf2 = buf;

monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4311
	while (foreign != NULL) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4312

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4313 4314
		buf2 += sprintf(buf2, "; (");

monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4315
		for (i = 0; i < foreign->n_fields; i++) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4316 4317 4318 4319
		        if ((ulint)(buf2 - buf) >= len) {
		                goto no_space;
		        }

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4320
			buf2 += sprintf(buf2, "%.500s",
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4321
					foreign->foreign_col_names[i]);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4322
			
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4323 4324 4325 4326 4327
			if (i + 1 < foreign->n_fields) {
				buf2 += sprintf(buf2, " ");
			}
		}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4328
		buf2 += sprintf(buf2, ") REFER %.500s(",
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4329 4330 4331
					foreign->referenced_table_name);
	
		for (i = 0; i < foreign->n_fields; i++) {
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4332 4333 4334
		        if ((ulint)(buf2 - buf) >= len) {
		                goto no_space;
		        }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4335
			buf2 += sprintf(buf2, "%.500s",
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4336 4337 4338 4339 4340 4341 4342 4343
					foreign->referenced_col_names[i]);
			if (i + 1 < foreign->n_fields) {
				buf2 += sprintf(buf2, " ");
			}
		}

		buf2 += sprintf(buf2, ")");

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4344 4345 4346 4347 4348 4349 4350 4351
		if (foreign->type == DICT_FOREIGN_ON_DELETE_CASCADE) {
			buf2 += sprintf(buf2, " ON DELETE CASCADE");
		}
	
		if (foreign->type == DICT_FOREIGN_ON_DELETE_SET_NULL) {
			buf2 += sprintf(buf2, " ON DELETE SET NULL");
		}

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367
		if (foreign->type & DICT_FOREIGN_ON_DELETE_NO_ACTION) {
			buf2 += sprintf(buf2, " ON DELETE NO ACTION");
		}

		if (foreign->type & DICT_FOREIGN_ON_UPDATE_CASCADE) {
			buf2 += sprintf(buf2, " ON UPDATE CASCADE");
		}
	
		if (foreign->type & DICT_FOREIGN_ON_UPDATE_SET_NULL) {
			buf2 += sprintf(buf2, " ON UPDATE SET NULL");
		}

		if (foreign->type & DICT_FOREIGN_ON_UPDATE_NO_ACTION) {
			buf2 += sprintf(buf2, " ON UPDATE NO ACTION");
		}

monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4368 4369
		foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
	}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4370
no_space:
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4371 4372 4373 4374
	mutex_exit(&(dict_sys->mutex));

	buf[len - 1] = '\0';
	ut_memcpy(str, buf, len);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4375 4376

	mem_free(buf);
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
4377
}