← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/trx/trx0i_s.c

Merge Stewart - Update innobase plugin to be based on innodb 1.1.4 from MySQL 5.5.8 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/trx/trx0i_s.c
420
420
        return(row);
421
421
}
422
422
 
 
423
#ifdef UNIV_DEBUG
 
424
/*******************************************************************//**
 
425
Validates a row in the locks cache.
 
426
@return TRUE if valid */
 
427
static
 
428
ibool
 
429
i_s_locks_row_validate(
 
430
/*===================*/
 
431
        const i_s_locks_row_t*  row)    /*!< in: row to validate */
 
432
{
 
433
        ut_ad(row->lock_trx_id != 0);
 
434
        ut_ad(row->lock_mode != NULL);
 
435
        ut_ad(row->lock_type != NULL);
 
436
        ut_ad(row->lock_table != NULL);
 
437
        ut_ad(row->lock_table_id != 0);
 
438
 
 
439
        if (row->lock_space == ULINT_UNDEFINED) {
 
440
                /* table lock */
 
441
                ut_ad(!strcmp("TABLE", row->lock_type));
 
442
                ut_ad(row->lock_index == NULL);
 
443
                ut_ad(row->lock_data == NULL);
 
444
                ut_ad(row->lock_page == ULINT_UNDEFINED);
 
445
                ut_ad(row->lock_rec == ULINT_UNDEFINED);
 
446
        } else {
 
447
                /* record lock */
 
448
                ut_ad(!strcmp("RECORD", row->lock_type));
 
449
                ut_ad(row->lock_index != NULL);
 
450
                ut_ad(row->lock_data != NULL);
 
451
                ut_ad(row->lock_page != ULINT_UNDEFINED);
 
452
                ut_ad(row->lock_rec != ULINT_UNDEFINED);
 
453
        }
 
454
 
 
455
        return(TRUE);
 
456
}
 
457
#endif /* UNIV_DEBUG */
 
458
 
423
459
/*******************************************************************//**
424
460
Fills i_s_trx_row_t object.
425
461
If memory can not be allocated then FALSE is returned.
450
486
        row->trx_id = trx->id;
451
487
        row->trx_started = (ib_time_t) trx->start_time;
452
488
        row->trx_state = trx_get_que_state_str(trx);
 
489
        row->requested_lock_row = requested_lock_row;
 
490
        ut_ad(requested_lock_row == NULL
 
491
              || i_s_locks_row_validate(requested_lock_row));
453
492
 
454
493
        if (trx->wait_lock != NULL) {
455
 
 
456
494
                ut_a(requested_lock_row != NULL);
457
 
 
458
 
                row->requested_lock_row = requested_lock_row;
459
495
                row->trx_wait_started = (ib_time_t) trx->wait_started;
460
496
        } else {
461
 
 
462
497
                ut_a(requested_lock_row == NULL);
463
 
 
464
 
                row->requested_lock_row = NULL;
465
498
                row->trx_wait_started = 0;
466
499
        }
467
500
 
817
850
        row->lock_table_id = lock_get_table_id(lock);
818
851
 
819
852
        row->hash_chain.value = row;
 
853
        ut_ad(i_s_locks_row_validate(row));
820
854
 
821
855
        return(TRUE);
822
856
}
837
871
                                                relevant blocking lock
838
872
                                                row in innodb_locks */
839
873
{
 
874
        ut_ad(i_s_locks_row_validate(requested_lock_row));
 
875
        ut_ad(i_s_locks_row_validate(blocking_lock_row));
 
876
 
840
877
        row->requested_lock_row = requested_lock_row;
841
878
        row->blocking_lock_row = blocking_lock_row;
842
879
 
908
945
                                        or ULINT_UNDEFINED if the lock
909
946
                                        is a table lock */
910
947
{
 
948
        ut_ad(i_s_locks_row_validate(row));
911
949
#ifdef TEST_NO_LOCKS_ROW_IS_EVER_EQUAL_TO_LOCK_T
912
950
        return(0);
913
951
#else
965
1003
                /* auxiliary variable */
966
1004
                hash_chain,
967
1005
                /* assertion on every traversed item */
968
 
                ,
 
1006
                ut_ad(i_s_locks_row_validate(hash_chain->value)),
969
1007
                /* this determines if we have found the lock */
970
1008
                locks_row_eq_lock(hash_chain->value, lock, heap_no));
971
1009
 
1005
1043
        dst_row = search_innodb_locks(cache, lock, heap_no);
1006
1044
        if (dst_row != NULL) {
1007
1045
 
 
1046
                ut_ad(i_s_locks_row_validate(dst_row));
1008
1047
                return(dst_row);
1009
1048
        }
1010
1049
#endif
1042
1081
        } /* for()-loop */
1043
1082
#endif
1044
1083
 
 
1084
        ut_ad(i_s_locks_row_validate(dst_row));
1045
1085
        return(dst_row);
1046
1086
}
1047
1087