dict0load.c 30.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/******************************************************
Loads to the memory cache database object definitions
from dictionary tables

(c) 1996 Innobase Oy

Created 4/24/1996 Heikki Tuuri
*******************************************************/

#include "dict0load.h"

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

#include "btr0pcur.h"
#include "btr0btr.h"
#include "page0page.h"
#include "mach0data.h"
#include "dict0dict.h"
#include "dict0boot.h"
unknown's avatar
unknown committed
22
#include "srv0start.h"
23

24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
/************************************************************************
Finds the first table name in the given database. */

char*
dict_get_first_table_name_in_db(
/*============================*/
			/* out, own: table name, NULL if does not exist;
			the caller must free the memory in the string! */
	char*	name)	/* in: database name which ends to '/' */
{
	dict_table_t*	sys_tables;
	btr_pcur_t	pcur;
	dict_index_t*	sys_index;
	dtuple_t*	tuple;
	mem_heap_t*	heap;
	dfield_t*	dfield;
	rec_t*		rec;
	byte*		field;
	ulint		len;
	char*		table_name;
	mtr_t		mtr;
	
	ut_ad(mutex_own(&(dict_sys->mutex)));

	heap = mem_heap_create(1000);
	
	mtr_start(&mtr);

unknown's avatar
unknown committed
52
	sys_tables = dict_table_get_low((char *) "SYS_TABLES");
53 54 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
	sys_index = UT_LIST_GET_FIRST(sys_tables->indexes);

	tuple = dtuple_create(heap, 1);
	dfield = dtuple_get_nth_field(tuple, 0);

	dfield_set_data(dfield, name, ut_strlen(name));
	dict_index_copy_types(tuple, sys_index, 1);

	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
					BTR_SEARCH_LEAF, &pcur, &mtr);
loop:
	rec = btr_pcur_get_rec(&pcur);

	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)) {
		/* Not found */

		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		mem_heap_free(heap);
		
		return(NULL);
	}	

	field = rec_get_nth_field(rec, 0, &len);

	if (len < strlen(name)
	    || ut_memcmp(name, field, strlen(name)) != 0) {
		/* Not found */

		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		mem_heap_free(heap);
		
		return(NULL);
	}

	if (!rec_get_deleted_flag(rec)) {

		/* We found one */

		table_name = mem_alloc(len + 1);
		ut_memcpy(table_name, field, len);
		table_name[len] = '\0';
		
		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		mem_heap_free(heap);
		
		return(table_name);
	}
	
	btr_pcur_move_to_next_user_rec(&pcur, &mtr);

	goto loop;
}

/************************************************************************
Prints to the standard output information on all tables found in the data
dictionary system table. */

void
dict_print(void)
/*============*/
{
	dict_table_t*	sys_tables;
	dict_index_t*	sys_index;
	dict_table_t*	table;
	btr_pcur_t	pcur;
	rec_t*		rec;
	byte*		field;
	ulint		len;
	mtr_t		mtr;
unknown's avatar
unknown committed
125
	char		table_name[10000];
126 127 128 129 130
	
	mutex_enter(&(dict_sys->mutex));

	mtr_start(&mtr);

unknown's avatar
unknown committed
131
	sys_tables = dict_table_get_low((char *) "SYS_TABLES");
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
	sys_index = UT_LIST_GET_FIRST(sys_tables->indexes);

	btr_pcur_open_at_index_side(TRUE, sys_index, BTR_SEARCH_LEAF, &pcur,
								TRUE, &mtr);
loop:
	btr_pcur_move_to_next_user_rec(&pcur, &mtr);

	rec = btr_pcur_get_rec(&pcur);

	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)) {
		/* end of index */

		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		
		mutex_exit(&(dict_sys->mutex));

		return;
	}	

	field = rec_get_nth_field(rec, 0, &len);

	if (!rec_get_deleted_flag(rec)) {

		/* We found one */

		ut_memcpy(table_name, field, len);
		table_name[len] = '\0';
			
		btr_pcur_store_position(&pcur, &mtr);

		mtr_commit(&mtr);
		
		table = dict_table_get_low(table_name);

		if (table == NULL) {
			fprintf(stderr, "InnoDB: Failed to load table %s\n",
								table_name);
		} else {
unknown's avatar
unknown committed
171 172 173 174 175 176
			/* The table definition was corrupt if there
			is no index */

			if (dict_table_get_first_index(table)) {
				dict_update_statistics_low(table, TRUE);
			}
177 178 179 180 181 182 183 184 185 186 187 188

			dict_table_print_low(table);
		}

		mtr_start(&mtr);

		btr_pcur_restore_position(BTR_SEARCH_LEAF, &pcur, &mtr);
	}

	goto loop;
}

unknown's avatar
unknown committed
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 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
/************************************************************************
In a crash recovery we already have all the tablespace objects created.
This function compares the space id information in the InnoDB data dictionary
to what we already read with fil_load_single_table_tablespaces().
In a normal startup we just scan the biggest space id, and store it to
fil_system. */

void
dict_check_tablespaces_or_store_max_id(
/*===================================*/
	ibool	in_crash_recovery)	/* in: are we doing a crash recovery */
{
	dict_table_t*	sys_tables;
	dict_index_t*	sys_index;
	btr_pcur_t	pcur;
	rec_t*		rec;
	byte*		field;
	ulint		len;
	ulint		space_id;
	ulint		max_space_id	= 0;
	mtr_t		mtr;
	char		name[OS_FILE_MAX_PATH];
	
	mutex_enter(&(dict_sys->mutex));

	mtr_start(&mtr);

	sys_tables = dict_table_get_low((char *) "SYS_TABLES");
	sys_index = UT_LIST_GET_FIRST(sys_tables->indexes);

	btr_pcur_open_at_index_side(TRUE, sys_index, BTR_SEARCH_LEAF, &pcur,
								TRUE, &mtr);
loop:
	btr_pcur_move_to_next_user_rec(&pcur, &mtr);

	rec = btr_pcur_get_rec(&pcur);

	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)) {
		/* end of index */

		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		
		/* We must make the tablespace cache aware of the biggest
		known space id */

		/* printf("Biggest space id in data dictionary %lu\n",
							    max_space_id); */
		fil_set_max_space_id_if_bigger(max_space_id);

		mutex_exit(&(dict_sys->mutex));

		return;
	}	

	field = rec_get_nth_field(rec, 0, &len);

	if (!rec_get_deleted_flag(rec)) {

		/* We found one */

		ut_a(len < OS_FILE_MAX_PATH - 10);
		ut_memcpy(name, field, len);
		name[len] = '\0';

		field = rec_get_nth_field(rec, 9, &len);
		ut_a(len == 4);
			
		space_id = mach_read_from_4(field);

		btr_pcur_store_position(&pcur, &mtr);

		mtr_commit(&mtr);
		
		if (space_id != 0 && in_crash_recovery) {
			/* Check that the tablespace (the .ibd file) really
			exists; print a warning to the .err log if not */
			
			fil_space_for_table_exists_in_mem(space_id, name,
								TRUE, TRUE);
		}
		
		if (space_id > max_space_id) {
			max_space_id = space_id;
		}

		mtr_start(&mtr);

		btr_pcur_restore_position(BTR_SEARCH_LEAF, &pcur, &mtr);
	}

	goto loop;
}

283
/************************************************************************
unknown's avatar
unknown committed
284 285 286 287 288 289 290
Loads definitions for table columns. */
static
void
dict_load_columns(
/*==============*/
	dict_table_t*	table,	/* in: table */
	mem_heap_t*	heap)	/* in: memory heap for temporary storage */
291
{
unknown's avatar
unknown committed
292
	dict_table_t*	sys_columns;
293
	dict_index_t*	sys_index;
unknown's avatar
unknown committed
294
	btr_pcur_t	pcur;
295 296 297 298 299
	dtuple_t*	tuple;
	dfield_t*	dfield;
	rec_t*		rec;
	byte*		field;
	ulint		len;
unknown's avatar
unknown committed
300 301 302 303 304 305 306 307
	byte*		buf;
	char*		name_buf;
	char*		name;
	ulint		mtype;
	ulint		prtype;
	ulint		col_len;
	ulint		prec;
	ulint		i;
308
	mtr_t		mtr;
309 310 311 312 313
	
	ut_ad(mutex_own(&(dict_sys->mutex)));

	mtr_start(&mtr);

unknown's avatar
unknown committed
314
	sys_columns = dict_table_get_low((char*) "SYS_COLUMNS");
unknown's avatar
unknown committed
315
	sys_index = UT_LIST_GET_FIRST(sys_columns->indexes);
316 317 318 319

	tuple = dtuple_create(heap, 1);
	dfield = dtuple_get_nth_field(tuple, 0);

unknown's avatar
unknown committed
320 321 322 323
	buf = mem_heap_alloc(heap, 8);
	mach_write_to_8(buf, table->id);

	dfield_set_data(dfield, buf, 8);
324 325 326
	dict_index_copy_types(tuple, sys_index, 1);

	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
unknown's avatar
unknown committed
327 328
						BTR_SEARCH_LEAF, &pcur, &mtr);
   	for (i = 0; i < table->n_cols - DATA_N_SYS_COLS; i++) {
329

unknown's avatar
unknown committed
330
		rec = btr_pcur_get_rec(&pcur);
331

unknown's avatar
unknown committed
332
		ut_a(btr_pcur_is_on_user_rec(&pcur, &mtr));
333

unknown's avatar
unknown committed
334
		ut_a(!rec_get_deleted_flag(rec));
335
		
unknown's avatar
unknown committed
336 337 338
		field = rec_get_nth_field(rec, 0, &len);
		ut_ad(len == 8);
		ut_a(ut_dulint_cmp(table->id, mach_read_from_8(field)) == 0);
339

unknown's avatar
unknown committed
340 341 342
		field = rec_get_nth_field(rec, 1, &len);
		ut_ad(len == 4);
		ut_a(i == mach_read_from_4(field));
343

unknown's avatar
unknown committed
344
		ut_a(0 == ut_strcmp((char*) "NAME",
unknown's avatar
unknown committed
345 346 347
			dict_field_get_col(
			dict_index_get_nth_field(
			dict_table_get_first_index(sys_columns), 4))->name));
348

unknown's avatar
unknown committed
349
		field = rec_get_nth_field(rec, 4, &len);
350

unknown's avatar
unknown committed
351 352 353
		name_buf = mem_heap_alloc(heap, len + 1);
		ut_memcpy(name_buf, field, len);
		name_buf[len] = '\0';
354

unknown's avatar
unknown committed
355
		name = name_buf;
356

unknown's avatar
unknown committed
357 358
		field = rec_get_nth_field(rec, 5, &len);
		mtype = mach_read_from_4(field);
359 360

		field = rec_get_nth_field(rec, 6, &len);
unknown's avatar
unknown committed
361
		prtype = mach_read_from_4(field);
362 363

		field = rec_get_nth_field(rec, 7, &len);
unknown's avatar
unknown committed
364
		col_len = mach_read_from_4(field);
365

unknown's avatar
unknown committed
366
		ut_a(0 == ut_strcmp((char*) "PREC",
unknown's avatar
unknown committed
367 368 369
			dict_field_get_col(
			dict_index_get_nth_field(
			dict_table_get_first_index(sys_columns), 8))->name));
370

unknown's avatar
unknown committed
371 372
		field = rec_get_nth_field(rec, 8, &len);
		prec = mach_read_from_4(field);
373

unknown's avatar
unknown committed
374 375 376 377
		dict_mem_table_add_col(table, name, mtype, prtype, col_len,
									prec);
		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
	} 
378

unknown's avatar
unknown committed
379 380
	btr_pcur_close(&pcur);
	mtr_commit(&mtr);
381 382
}

unknown's avatar
unknown committed
383 384 385 386 387 388 389 390 391
/************************************************************************
Loads definitions for index fields. */
static
void
dict_load_fields(
/*=============*/
	dict_table_t*	table,	/* in: table */
	dict_index_t*	index,	/* in: index whose fields to load */
	mem_heap_t*	heap)	/* in: memory heap for temporary storage */
392
{
unknown's avatar
unknown committed
393 394
	dict_table_t*	sys_fields;
	dict_index_t*	sys_index;
395 396 397
	btr_pcur_t	pcur;
	dtuple_t*	tuple;
	dfield_t*	dfield;
unknown's avatar
unknown committed
398
	char*		col_name;
unknown's avatar
unknown committed
399 400
	ulint		pos_and_prefix_len;
	ulint		prefix_len;
401 402
	rec_t*		rec;
	byte*		field;
unknown's avatar
unknown committed
403 404 405
	ulint		len;
	byte*		buf;
	ulint		i;
406 407 408 409
	mtr_t		mtr;
	
	ut_ad(mutex_own(&(dict_sys->mutex)));

unknown's avatar
unknown committed
410
	UT_NOT_USED(table);
411

unknown's avatar
unknown committed
412
	mtr_start(&mtr);
413

unknown's avatar
unknown committed
414
	sys_fields = dict_table_get_low((char*) "SYS_FIELDS");
unknown's avatar
unknown committed
415 416 417
	sys_index = UT_LIST_GET_FIRST(sys_fields->indexes);

	tuple = dtuple_create(heap, 1);
418 419
	dfield = dtuple_get_nth_field(tuple, 0);

unknown's avatar
unknown committed
420 421
	buf = mem_heap_alloc(heap, 8);
	mach_write_to_8(buf, index->id);
422

unknown's avatar
unknown committed
423 424
	dfield_set_data(dfield, buf, 8);
	dict_index_copy_types(tuple, sys_index, 1);
425

unknown's avatar
unknown committed
426
	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
427
						BTR_SEARCH_LEAF, &pcur, &mtr);
unknown's avatar
unknown committed
428
   	for (i = 0; i < index->n_fields; i++) {
429

unknown's avatar
unknown committed
430
		rec = btr_pcur_get_rec(&pcur);
431 432

		ut_a(btr_pcur_is_on_user_rec(&pcur, &mtr));
unknown's avatar
unknown committed
433 434
		if (rec_get_deleted_flag(rec)) {
			fprintf(stderr,
unknown's avatar
unknown committed
435
"InnoDB: Error: data dictionary entry for table %s is corrupt!\n"
unknown's avatar
unknown committed
436 437 438
"InnoDB: An index field is delete marked.\n",
			table->name);
		}
439 440 441
		
		field = rec_get_nth_field(rec, 0, &len);
		ut_ad(len == 8);
unknown's avatar
unknown committed
442
		ut_a(ut_memcmp(buf, field, len) == 0);
443 444

		field = rec_get_nth_field(rec, 1, &len);
unknown's avatar
unknown committed
445 446 447 448 449 450 451 452 453 454 455 456
		ut_a(len == 4);

		/* The next field stores the field position in the index
		and a possible column prefix length if the index field
		does not contain the whole column. The storage format is
		like this: if there is at least one prefix field in the index,
		then the HIGH 2 bytes contain the field number (== i) and the
		low 2 bytes the prefix length for the field. Otherwise the
		field number (== i) is contained in the 2 LOW bytes. */

		pos_and_prefix_len = mach_read_from_4(field);

unknown's avatar
unknown committed
457 458
		ut_a((pos_and_prefix_len & 0xFFFFUL) == i
		     || (pos_and_prefix_len & 0xFFFF0000UL) == (i << 16));
unknown's avatar
unknown committed
459 460

		if ((i == 0 && pos_and_prefix_len > 0)
unknown's avatar
unknown committed
461
		    || (pos_and_prefix_len & 0xFFFF0000UL) > 0) {
unknown's avatar
unknown committed
462

unknown's avatar
unknown committed
463
		        prefix_len = pos_and_prefix_len & 0xFFFFUL;
unknown's avatar
unknown committed
464 465 466
		} else {
		        prefix_len = 0;
		}
467

unknown's avatar
unknown committed
468
		ut_a(0 == ut_strcmp((char*) "COL_NAME",
469 470
			dict_field_get_col(
			dict_index_get_nth_field(
unknown's avatar
unknown committed
471
			dict_table_get_first_index(sys_fields), 4))->name));
472 473 474

		field = rec_get_nth_field(rec, 4, &len);

unknown's avatar
unknown committed
475 476 477 478
		col_name = mem_heap_alloc(heap, len + 1);
		ut_memcpy(col_name, field, len);
		col_name[len] = '\0';
		
unknown's avatar
unknown committed
479
		dict_mem_index_add_field(index, col_name, 0, prefix_len);
480 481 482 483 484 485 486 487 488

		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
	} 

	btr_pcur_close(&pcur);
	mtr_commit(&mtr);
}

/************************************************************************
unknown's avatar
unknown committed
489 490
Loads definitions for table indexes. Adds them to the data dictionary
cache. */
491
static
unknown's avatar
unknown committed
492
ibool
493 494
dict_load_indexes(
/*==============*/
unknown's avatar
unknown committed
495 496
				/* out: TRUE if ok, FALSE if corruption
				of dictionary table */
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
	dict_table_t*	table,	/* in: table */
	mem_heap_t*	heap)	/* in: memory heap for temporary storage */
{
	dict_table_t*	sys_indexes;
	dict_index_t*	sys_index;
	dict_index_t*	index;
	btr_pcur_t	pcur;
	dtuple_t*	tuple;
	dfield_t*	dfield;
	rec_t*		rec;
	byte*		field;
	ulint		len;
	ulint		name_len;
	char*		name_buf;
	ulint		type;
	ulint		space;
	ulint		page_no;
	ulint		n_fields;
	byte*		buf;
	ibool		is_sys_table;
	dulint		id;
	mtr_t		mtr;
	
	ut_ad(mutex_own(&(dict_sys->mutex)));

	if ((ut_dulint_get_high(table->id) == 0)
	    && (ut_dulint_get_low(table->id) < DICT_HDR_FIRST_ID)) {
		is_sys_table = TRUE;
	} else {
		is_sys_table = FALSE;
	}
	
	mtr_start(&mtr);

unknown's avatar
unknown committed
531
	sys_indexes = dict_table_get_low((char*) "SYS_INDEXES");
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
	sys_index = UT_LIST_GET_FIRST(sys_indexes->indexes);

	tuple = dtuple_create(heap, 1);
	dfield = dtuple_get_nth_field(tuple, 0);

	buf = mem_heap_alloc(heap, 8);
	mach_write_to_8(buf, table->id);

	dfield_set_data(dfield, buf, 8);
	dict_index_copy_types(tuple, sys_index, 1);

	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
						BTR_SEARCH_LEAF, &pcur, &mtr);
   	for (;;) {
		if (!btr_pcur_is_on_user_rec(&pcur, &mtr)) {

			break;
		}

		rec = btr_pcur_get_rec(&pcur);
		
		field = rec_get_nth_field(rec, 0, &len);
		ut_ad(len == 8);

		if (ut_memcmp(buf, field, len) != 0) {
			break;
		}

unknown's avatar
unknown committed
560 561 562 563 564 565 566 567 568 569 570
		if (rec_get_deleted_flag(rec)) {
			fprintf(stderr,
"InnoDB: Error: data dictionary entry for table %s is corrupt!\n"
"InnoDB: An index is delete marked.\n",
			table->name);

			btr_pcur_close(&pcur);
			mtr_commit(&mtr);

			return(FALSE);
		}
571 572 573 574 575

		field = rec_get_nth_field(rec, 1, &len);
		ut_ad(len == 8);
		id = mach_read_from_8(field);

unknown's avatar
unknown committed
576
		ut_a(0 == ut_strcmp((char*) "NAME",
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
			dict_field_get_col(
			dict_index_get_nth_field(
			dict_table_get_first_index(sys_indexes), 4))->name));
		
		field = rec_get_nth_field(rec, 4, &name_len);

		name_buf = mem_heap_alloc(heap, name_len + 1);
		ut_memcpy(name_buf, field, name_len);
		name_buf[name_len] = '\0';

		field = rec_get_nth_field(rec, 5, &len);
		n_fields = mach_read_from_4(field);

		field = rec_get_nth_field(rec, 6, &len);
		type = mach_read_from_4(field);

		field = rec_get_nth_field(rec, 7, &len);
		space = mach_read_from_4(field);

unknown's avatar
unknown committed
596
		ut_a(0 == ut_strcmp((char*) "PAGE_NO",
597 598 599 600 601 602 603
			dict_field_get_col(
			dict_index_get_nth_field(
			dict_table_get_first_index(sys_indexes), 8))->name));

		field = rec_get_nth_field(rec, 8, &len);
		page_no = mach_read_from_4(field);

unknown's avatar
unknown committed
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
		if (page_no == FIL_NULL) {

			fprintf(stderr,
	"InnoDB: Error: trying to load index %s for table %s\n"
	"InnoDB: but the index tree has been freed!\n",
				name_buf, table->name);
 
			btr_pcur_close(&pcur);
			mtr_commit(&mtr);

			return(FALSE);
		}

		if ((type & DICT_CLUSTERED) == 0
			    && NULL == dict_table_get_first_index(table)) {

			fprintf(stderr,
	"InnoDB: Error: trying to load index %s for table %s\n"
	"InnoDB: but the first index was not clustered!\n",
				name_buf, table->name);

			btr_pcur_close(&pcur);
			mtr_commit(&mtr);

			return(FALSE);
		}
		
631 632 633 634
		if (is_sys_table
		    && ((type & DICT_CLUSTERED)
		        || ((table == dict_sys->sys_tables)
		            && (name_len == ut_strlen("ID_IND"))
unknown's avatar
unknown committed
635
			    && (0 == ut_memcmp(name_buf, (char*) "ID_IND",
636 637
							name_len))))) {

unknown's avatar
unknown committed
638 639
			/* The index was created in memory already at booting
			of the database server */
640 641 642 643 644 645 646 647
		} else {
 			index = dict_mem_index_create(table->name, name_buf,
						space, type, n_fields);
			index->page_no = page_no;
			index->id = id;
		
			dict_load_fields(table, index, heap);

unknown's avatar
unknown committed
648
			dict_index_add_to_cache(table, index);
649 650 651 652 653 654 655
		}

		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
	} 

	btr_pcur_close(&pcur);
	mtr_commit(&mtr);
unknown's avatar
unknown committed
656 657

	return(TRUE);
658 659 660
}

/************************************************************************
unknown's avatar
unknown committed
661 662 663 664 665 666 667 668 669
Loads a table definition and also all its index definitions, and also
the cluster definition if the table is a member in a cluster. Also loads
all foreign key constraints where the foreign key is in the table or where
a foreign key references columns in this table. Adds all these to the data
dictionary cache. */

dict_table_t*
dict_load_table(
/*============*/
unknown's avatar
unknown committed
670 671 672 673 674 675
			/* out: table, NULL if does not exist; if the table is
			stored in an .ibd file, but the file does not exist,
			then we set the ibd_file_missing flag TRUE in the table
			object we return */
	char*	name)	/* in: table name in the databasename/tablename
			format */
676
{
unknown's avatar
unknown committed
677
	ibool		ibd_file_missing	= FALSE;
unknown's avatar
unknown committed
678 679
	dict_table_t*	table;
	dict_table_t*	sys_tables;
680
	btr_pcur_t	pcur;
unknown's avatar
unknown committed
681
	dict_index_t*	sys_index;
682
	dtuple_t*	tuple;
unknown's avatar
unknown committed
683
	mem_heap_t*	heap;
684 685 686 687
	dfield_t*	dfield;
	rec_t*		rec;
	byte*		field;
	ulint		len;
unknown's avatar
unknown committed
688 689 690
	char*		buf;
	ulint		space;
	ulint		n_cols;
unknown's avatar
unknown committed
691
	ulint		err;
692
	mtr_t		mtr;
693 694 695
	
	ut_ad(mutex_own(&(dict_sys->mutex)));

unknown's avatar
unknown committed
696 697
	heap = mem_heap_create(1000);
	
698 699
	mtr_start(&mtr);

unknown's avatar
unknown committed
700
	sys_tables = dict_table_get_low((char *) "SYS_TABLES");
unknown's avatar
unknown committed
701
	sys_index = UT_LIST_GET_FIRST(sys_tables->indexes);
702 703 704 705

	tuple = dtuple_create(heap, 1);
	dfield = dtuple_get_nth_field(tuple, 0);

unknown's avatar
unknown committed
706
	dfield_set_data(dfield, name, ut_strlen(name));
707 708 709
	dict_index_copy_types(tuple, sys_index, 1);

	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
unknown's avatar
unknown committed
710 711
					BTR_SEARCH_LEAF, &pcur, &mtr);
	rec = btr_pcur_get_rec(&pcur);
712

unknown's avatar
unknown committed
713 714 715
	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)
					|| rec_get_deleted_flag(rec)) {
		/* Not found */
716

unknown's avatar
unknown committed
717 718 719
		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		mem_heap_free(heap);
720
		
unknown's avatar
unknown committed
721 722
		return(NULL);
	}	
723

unknown's avatar
unknown committed
724
	field = rec_get_nth_field(rec, 0, &len);
725

unknown's avatar
unknown committed
726 727
	/* Check if the table name in record is the searched one */
	if (len != ut_strlen(name) || ut_memcmp(name, field, len) != 0) {
728

unknown's avatar
unknown committed
729 730 731 732 733 734
		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		mem_heap_free(heap);
		
		return(NULL);
	}
735

unknown's avatar
unknown committed
736
	ut_a(0 == ut_strcmp((char *) "SPACE",
unknown's avatar
unknown committed
737 738 739 740 741 742 743
		dict_field_get_col(
		dict_index_get_nth_field(
			dict_table_get_first_index(sys_tables), 9))->name));
	
	field = rec_get_nth_field(rec, 9, &len);
	space = mach_read_from_4(field);

unknown's avatar
unknown committed
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
	/* Check if the tablespace exists and has the right name */
	if (space != 0) {
		if (fil_space_for_table_exists_in_mem(space, name, FALSE,
								   FALSE)) {
			/* Ok; (if we did a crash recovery then the tablespace
			can already be in the memory cache) */
		} else {
			/* Try to open the tablespace */
			if (!fil_open_single_table_tablespace(space, name)) {
				/* We failed to find a sensible tablespace
				file */

				ibd_file_missing = TRUE;
			}
		}
	}

unknown's avatar
unknown committed
761
	ut_a(0 == ut_strcmp((char *) "N_COLS",
unknown's avatar
unknown committed
762 763 764 765 766 767 768 769 770
		dict_field_get_col(
		dict_index_get_nth_field(
			dict_table_get_first_index(sys_tables), 4))->name));

	field = rec_get_nth_field(rec, 4, &len);
	n_cols = mach_read_from_4(field);

	table = dict_mem_table_create(name, space, n_cols);

unknown's avatar
unknown committed
771 772
	table->ibd_file_missing = ibd_file_missing;

unknown's avatar
unknown committed
773
	ut_a(0 == ut_strcmp((char *) "ID",
unknown's avatar
unknown committed
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
		dict_field_get_col(
		dict_index_get_nth_field(
			dict_table_get_first_index(sys_tables), 3))->name));

	field = rec_get_nth_field(rec, 3, &len);
	table->id = mach_read_from_8(field);

	field = rec_get_nth_field(rec, 5, &len);
	table->type = mach_read_from_4(field);

	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
		ut_a(0);
	
		field = rec_get_nth_field(rec, 6, &len);
		table->mix_id = mach_read_from_8(field);

		field = rec_get_nth_field(rec, 8, &len);
		buf = mem_heap_alloc(heap, len);
		ut_memcpy(buf, field, len);

		table->cluster_name = buf;
	}

	if ((table->type == DICT_TABLE_CLUSTER)
	    || (table->type == DICT_TABLE_CLUSTER_MEMBER)) {
799
		
unknown's avatar
unknown committed
800 801 802
		field = rec_get_nth_field(rec, 7, &len);
		table->mix_len = mach_read_from_4(field);
	}
803

unknown's avatar
unknown committed
804 805
	btr_pcur_close(&pcur);
	mtr_commit(&mtr);
806

unknown's avatar
unknown committed
807 808 809 810 811 812 813 814 815 816 817 818
	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
		/* Load the cluster table definition if not yet in
		memory cache */
		dict_table_get_low(table->cluster_name);
	}

	dict_load_columns(table, heap);

	dict_table_add_to_cache(table);
	
	dict_load_indexes(table, heap);
	
unknown's avatar
unknown committed
819 820 821 822 823
	err = dict_load_foreigns(table->name);
/*
	if (err != DB_SUCCESS) {
	
 		mutex_enter(&dict_foreign_err_mutex);
unknown's avatar
unknown committed
824

unknown's avatar
unknown committed
825 826 827 828 829 830 831 832 833 834 835 836 837
 		ut_print_timestamp(stderr);
 		
		fprintf(stderr,
"  InnoDB: Error: could not make a foreign key definition to match\n"
"InnoDB: the foreign key table or the referenced table!\n"
"InnoDB: The data dictionary of InnoDB is corrupt. You may need to drop\n"
"InnoDB: and recreate the foreign key table or the referenced table.\n"
"InnoDB: Send a detailed bug report to mysql@lists.mysql.com\n"
"InnoDB: Latest foreign key error printout:\n%s\n", dict_foreign_err_buf);
				
		mutex_exit(&dict_foreign_err_mutex);
	}
*/
unknown's avatar
unknown committed
838 839 840 841 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 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910
	mem_heap_free(heap);

	return(table);
}

/***************************************************************************
Loads a table object based on the table id. */

dict_table_t*
dict_load_table_on_id(
/*==================*/
				/* out: table; NULL if table does not exist */
	dulint	table_id)	/* in: table id */	
{
	byte		id_buf[8];
	btr_pcur_t	pcur;
	mem_heap_t* 	heap;
	dtuple_t*	tuple;
	dfield_t*	dfield;
	dict_index_t*	sys_table_ids;
	dict_table_t*	sys_tables;
	rec_t*		rec;
	byte*		field;
	ulint		len;	
	dict_table_t*	table;
	char*		name;
	mtr_t		mtr;
	
	ut_ad(mutex_own(&(dict_sys->mutex)));

	/* NOTE that the operation of this function is protected by
	the dictionary mutex, and therefore no deadlocks can occur
	with other dictionary operations. */

	mtr_start(&mtr);	
	/*---------------------------------------------------*/
	/* Get the secondary index based on ID for table SYS_TABLES */	
	sys_tables = dict_sys->sys_tables;
	sys_table_ids = dict_table_get_next_index(
				dict_table_get_first_index(sys_tables));
	heap = mem_heap_create(256);

	tuple  = dtuple_create(heap, 1);
	dfield = dtuple_get_nth_field(tuple, 0);

	/* Write the table id in byte format to id_buf */
	mach_write_to_8(id_buf, table_id);
	
	dfield_set_data(dfield, id_buf, 8);
	dict_index_copy_types(tuple, sys_table_ids, 1);

	btr_pcur_open_on_user_rec(sys_table_ids, tuple, PAGE_CUR_GE,
						BTR_SEARCH_LEAF, &pcur, &mtr);
	rec = btr_pcur_get_rec(&pcur);
	
	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)
					|| rec_get_deleted_flag(rec)) {
		/* Not found */

		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		mem_heap_free(heap);
		
		return(NULL);
	}

	/*---------------------------------------------------*/
	/* Now we have the record in the secondary index containing the
	table ID and NAME */

	rec = btr_pcur_get_rec(&pcur);
	field = rec_get_nth_field(rec, 0, &len);
	ut_ad(len == 8);
911

unknown's avatar
unknown committed
912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931
	/* Check if the table id in record is the one searched for */
	if (ut_dulint_cmp(table_id, mach_read_from_8(field)) != 0) {

		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		mem_heap_free(heap);
		
		return(NULL);
	}
		
	/* Now we get the table name from the record */
	field = rec_get_nth_field(rec, 1, &len);

	name = mem_heap_alloc(heap, len + 1);
	ut_memcpy(name, field, len);
	name[len] = '\0';
	
	/* Load the table definition to memory */
	table = dict_load_table(name);
	
932 933
	btr_pcur_close(&pcur);
	mtr_commit(&mtr);
unknown's avatar
unknown committed
934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957
	mem_heap_free(heap);

	return(table);
}

/************************************************************************
This function is called when the database is booted. Loads system table
index definitions except for the clustered index which is added to the
dictionary cache at booting before calling this function. */

void
dict_load_sys_table(
/*================*/
	dict_table_t*	table)	/* in: system table */
{
	mem_heap_t*	heap;

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

	heap = mem_heap_create(1000);

	dict_load_indexes(table, heap);
	
	mem_heap_free(heap);
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 986 987 988 989 990
/************************************************************************
Loads foreign key constraint col names (also for the referenced table). */
static
void
dict_load_foreign_cols(
/*===================*/
	char*		id,	/* in: foreign constraint id as a null-
				terminated string */
	dict_foreign_t*	foreign)/* in: foreign constraint object */
{
	dict_table_t*	sys_foreign_cols;
	dict_index_t*	sys_index;
	btr_pcur_t	pcur;
	dtuple_t*	tuple;
	dfield_t*	dfield;
	char*		col_name;
	rec_t*		rec;
	byte*		field;
	ulint		len;
	ulint		i;
	mtr_t		mtr;
	
	ut_ad(mutex_own(&(dict_sys->mutex)));

	foreign->foreign_col_names = mem_heap_alloc(foreign->heap,
					foreign->n_fields * sizeof(void*));

	foreign->referenced_col_names = mem_heap_alloc(foreign->heap,
					foreign->n_fields * sizeof(void*));
	mtr_start(&mtr);

unknown's avatar
unknown committed
991
	sys_foreign_cols = dict_table_get_low((char *) "SYS_FOREIGN_COLS");
992 993 994 995 996 997 998 999 1000 1001 1002 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
	sys_index = UT_LIST_GET_FIRST(sys_foreign_cols->indexes);

	tuple = dtuple_create(foreign->heap, 1);
	dfield = dtuple_get_nth_field(tuple, 0);

	dfield_set_data(dfield, id, ut_strlen(id));
	dict_index_copy_types(tuple, sys_index, 1);

	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
						BTR_SEARCH_LEAF, &pcur, &mtr);
   	for (i = 0; i < foreign->n_fields; i++) {

		rec = btr_pcur_get_rec(&pcur);

		ut_a(btr_pcur_is_on_user_rec(&pcur, &mtr));
		ut_a(!rec_get_deleted_flag(rec));
		
		field = rec_get_nth_field(rec, 0, &len);
		ut_a(len == ut_strlen(id));
		ut_a(ut_memcmp(id, field, len) == 0);

		field = rec_get_nth_field(rec, 1, &len);
		ut_a(len == 4);
		ut_a(i == mach_read_from_4(field));

		field = rec_get_nth_field(rec, 4, &len);

		col_name = mem_heap_alloc(foreign->heap, len + 1);
		ut_memcpy(col_name, field, len);
		col_name[len] = '\0';

		foreign->foreign_col_names[i] = col_name;

		field = rec_get_nth_field(rec, 5, &len);

		col_name = mem_heap_alloc(foreign->heap, len + 1);
		ut_memcpy(col_name, field, len);
		col_name[len] = '\0';

		foreign->referenced_col_names[i] = col_name;
		
		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
	} 

	btr_pcur_close(&pcur);
	mtr_commit(&mtr);
}

1040
/***************************************************************************
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
Loads a foreign key constraint to the dictionary cache. */
static
ulint
dict_load_foreign(
/*==============*/
			/* out: DB_SUCCESS or error code */
	char*	id)	/* in: foreign constraint id as a null-terminated
			string */
{	
	dict_foreign_t*	foreign;
	dict_table_t*	sys_foreign;
	btr_pcur_t	pcur;
	dict_index_t*	sys_index;
	dtuple_t*	tuple;
	mem_heap_t*	heap2;
	dfield_t*	dfield;
	rec_t*		rec;
	byte*		field;
	ulint		len;
	ulint		err;
	mtr_t		mtr;
	
	ut_ad(mutex_own(&(dict_sys->mutex)));
1064

1065 1066 1067 1068
	heap2 = mem_heap_create(1000);
	
	mtr_start(&mtr);

unknown's avatar
unknown committed
1069
	sys_foreign = dict_table_get_low((char *) "SYS_FOREIGN");
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
	sys_index = UT_LIST_GET_FIRST(sys_foreign->indexes);

	tuple = dtuple_create(heap2, 1);
	dfield = dtuple_get_nth_field(tuple, 0);

	dfield_set_data(dfield, id, ut_strlen(id));
	dict_index_copy_types(tuple, sys_index, 1);

	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
					BTR_SEARCH_LEAF, &pcur, &mtr);
	rec = btr_pcur_get_rec(&pcur);

	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)
					|| rec_get_deleted_flag(rec)) {
		/* Not found */

		fprintf(stderr,
		"InnoDB: Error A: cannot load foreign constraint %s\n", id);

		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		mem_heap_free(heap2);
		
		return(DB_ERROR);
	}	

	field = rec_get_nth_field(rec, 0, &len);

	/* Check if the id in record is the searched one */
	if (len != ut_strlen(id) || ut_memcmp(id, field, len) != 0) {

		fprintf(stderr,
		"InnoDB: Error B: cannot load foreign constraint %s\n", id);

		btr_pcur_close(&pcur);
		mtr_commit(&mtr);
		mem_heap_free(heap2);
		
		return(DB_ERROR);
	}

	/* Read the table names and the number of columns associated
	with the constraint */

	mem_heap_free(heap2);
	
	foreign = dict_mem_foreign_create();

	foreign->n_fields = mach_read_from_4(rec_get_nth_field(rec, 5, &len));

	ut_a(len == 4);
unknown's avatar
unknown committed
1121 1122 1123 1124

	/* We store the type to the bits 24-31 of n_fields */
	
	foreign->type = foreign->n_fields >> 24;
unknown's avatar
unknown committed
1125
	foreign->n_fields = foreign->n_fields & 0xFFFFFFUL;
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
	
	foreign->id = mem_heap_alloc(foreign->heap, ut_strlen(id) + 1);
				
	ut_memcpy(foreign->id, id, ut_strlen(id) + 1);

	field = rec_get_nth_field(rec, 3, &len);
							
	foreign->foreign_table_name = mem_heap_alloc(foreign->heap, 1 + len);
				
	ut_memcpy(foreign->foreign_table_name, field, len);
	foreign->foreign_table_name[len] = '\0';	
	
	field = rec_get_nth_field(rec, 4, &len);
							
unknown's avatar
unknown committed
1140 1141
	foreign->referenced_table_name = mem_heap_alloc(foreign->heap,
								1 + len);
1142 1143 1144 1145 1146 1147 1148 1149
	ut_memcpy(foreign->referenced_table_name, field, len);
	foreign->referenced_table_name[len] = '\0';	

	btr_pcur_close(&pcur);
	mtr_commit(&mtr);

	dict_load_foreign_cols(id, foreign);

unknown's avatar
unknown committed
1150 1151 1152 1153 1154 1155
	/* If the foreign table is not yet in the dictionary cache, we
	have to load it so that we are able to make type comparisons
	in the next function call. */

	dict_table_get_low(foreign->foreign_table_name);

1156 1157 1158
	/* Note that there may already be a foreign constraint object in
	the dictionary cache for this constraint: then the following
	call only sets the pointers in it to point to the appropriate table
unknown's avatar
unknown committed
1159 1160 1161 1162
	and index objects and frees the newly created object foreign.
	Adding to the cache should always succeed since we are not creating
	a new foreign key constraint but loading one from the data
	dictionary. */
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180

	err = dict_foreign_add_to_cache(foreign);

	return(err); 
}

/***************************************************************************
Loads foreign key constraints where the table is either the foreign key
holder or where the table is referenced by a foreign key. Adds these
constraints to the data dictionary. Note that we know that the dictionary
cache already contains all constraints where the other relevant table is
already in the dictionary cache. */

ulint
dict_load_foreigns(
/*===============*/
				/* out: DB_SUCCESS or error code */
	char*	table_name)	/* in: table name */
1181 1182 1183 1184 1185
{
	btr_pcur_t	pcur;
	mem_heap_t* 	heap;
	dtuple_t*	tuple;
	dfield_t*	dfield;
1186 1187
	dict_index_t*	sec_index;
	dict_table_t*	sys_foreign;
1188 1189 1190
	rec_t*		rec;
	byte*		field;
	ulint		len;	
1191 1192 1193
	char*		id ;
	ulint		err;
	mtr_t		mtr;
1194 1195 1196
	
	ut_ad(mutex_own(&(dict_sys->mutex)));

unknown's avatar
unknown committed
1197
	sys_foreign = dict_table_get_low((char *) "SYS_FOREIGN");
1198 1199 1200 1201 1202 1203 1204 1205 1206

	if (sys_foreign == NULL) {
		/* No foreign keys defined yet in this database */

		fprintf(stderr,
	"InnoDB: Error: no foreign key system tables in the database\n");
		
		return(DB_ERROR);
	}
1207 1208

	mtr_start(&mtr);	
1209 1210 1211 1212 1213 1214 1215

	/* Get the secondary index based on FOR_NAME from table
	SYS_FOREIGN */	

	sec_index = dict_table_get_next_index(
				dict_table_get_first_index(sys_foreign));
start_load:
1216 1217 1218 1219 1220
	heap = mem_heap_create(256);

	tuple  = dtuple_create(heap, 1);
	dfield = dtuple_get_nth_field(tuple, 0);

1221 1222
	dfield_set_data(dfield, table_name, ut_strlen(table_name));
	dict_index_copy_types(tuple, sec_index, 1);
1223

1224
	btr_pcur_open_on_user_rec(sec_index, tuple, PAGE_CUR_GE,
1225
						BTR_SEARCH_LEAF, &pcur, &mtr);
1226
loop:
1227 1228
	rec = btr_pcur_get_rec(&pcur);
	
1229 1230
	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)) {
		/* End of index */
1231

1232
		goto load_next_index;
1233 1234
	}

1235 1236
	/* Now we have the record in the secondary index containing a table
	name and a foreign constraint ID */
1237 1238 1239 1240

	rec = btr_pcur_get_rec(&pcur);
	field = rec_get_nth_field(rec, 0, &len);

1241 1242 1243
	/* Check if the table name in record is the one searched for */
	if (len != ut_strlen(table_name)
	    || 0 != ut_memcmp(field, table_name, len)) {
1244

1245
		goto load_next_index;
1246 1247
	}
		
1248 1249 1250 1251 1252 1253
	if (rec_get_deleted_flag(rec)) {

		goto next_rec;
	}

	/* Now we get a foreign key constraint id */
1254 1255
	field = rec_get_nth_field(rec, 1, &len);

1256 1257 1258
	id = mem_heap_alloc(heap, len + 1);
	ut_memcpy(id, field, len);
	id[len] = '\0';
1259
	
1260
	btr_pcur_store_position(&pcur, &mtr);
1261

1262 1263 1264
	mtr_commit(&mtr);

	/* Load the foreign constraint definition to the dictionary cache */
1265
	
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
	err = dict_load_foreign(id);

	if (err != DB_SUCCESS) {
		btr_pcur_close(&pcur);
		mem_heap_free(heap);

		return(err);
	}

	mtr_start(&mtr);

	btr_pcur_restore_position(BTR_SEARCH_LEAF, &pcur, &mtr);
next_rec:
	btr_pcur_move_to_next_user_rec(&pcur, &mtr);

	goto loop;

load_next_index:
1284 1285 1286
	btr_pcur_close(&pcur);
	mtr_commit(&mtr);
	mem_heap_free(heap);
1287 1288
	
	sec_index = dict_table_get_next_index(sec_index);
1289

1290 1291 1292 1293 1294 1295 1296 1297
	if (sec_index != NULL) {

		mtr_start(&mtr);	

		goto start_load;
	}

	return(DB_SUCCESS);
1298
}