← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/trx/trx0i_s.cc
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 2007, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (C) 2007, 2010, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
41
41
# include <mysql/plugin.h>
42
42
#endif
43
43
 
44
 
#include "mysql_addons.h"
45
 
 
46
44
#include "buf0buf.h"
47
45
#include "dict0dict.h"
48
46
#include "ha0storage.h"
64
62
#include "ut0mem.h"
65
63
#include "ut0ut.h"
66
64
 
 
65
#include <drizzled/session.h>
 
66
 
67
67
/** Initial number of rows in the table cache */
68
68
#define TABLE_CACHE_INITIAL_ROWSNUM     1024
69
69
 
196
196
code in handler/i_s.cc. */
197
197
UNIV_INTERN trx_i_s_cache_t*    trx_i_s_cache = &trx_i_s_cache_static;
198
198
 
 
199
/* Key to register the lock/mutex with performance schema */
 
200
#ifdef UNIV_PFS_RWLOCK
 
201
UNIV_INTERN mysql_pfs_key_t     trx_i_s_cache_lock_key;
 
202
#endif /* UNIV_PFS_RWLOCK */
 
203
 
 
204
#ifdef UNIV_PFS_MUTEX
 
205
UNIV_INTERN mysql_pfs_key_t     cache_last_read_mutex_key;
 
206
#endif /* UNIV_PFS_MUTEX */
 
207
 
199
208
/*******************************************************************//**
200
209
For a record lock that is in waiting state retrieves the only bit that
201
210
is set, for a table lock returns ULINT_UNDEFINED.
411
420
        return(row);
412
421
}
413
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
 
414
459
/*******************************************************************//**
415
460
Fills i_s_trx_row_t object.
416
461
If memory can not be allocated then FALSE is returned.
434
479
{
435
480
        const char*     stmt;
436
481
        size_t          stmt_len;
437
 
 
438
 
        row->trx_id = trx_get_id(trx);
 
482
        const char*     s;
 
483
 
 
484
        ut_ad(mutex_own(&kernel_mutex));
 
485
 
 
486
        row->trx_id = trx->id;
439
487
        row->trx_started = (ib_time_t) trx->start_time;
440
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));
441
492
 
442
493
        if (trx->wait_lock != NULL) {
443
 
 
444
494
                ut_a(requested_lock_row != NULL);
445
 
 
446
 
                row->requested_lock_row = requested_lock_row;
447
495
                row->trx_wait_started = (ib_time_t) trx->wait_started;
448
496
        } else {
449
 
 
450
497
                ut_a(requested_lock_row == NULL);
451
 
 
452
 
                row->requested_lock_row = NULL;
453
498
                row->trx_wait_started = 0;
454
499
        }
455
500
 
456
 
        row->trx_weight = (ullint) ut_conv_dulint_to_longlong(TRX_WEIGHT(trx));
 
501
        row->trx_weight = (ullint) TRX_WEIGHT(trx);
457
502
 
458
503
        if (trx->mysql_thd == NULL) {
459
504
                /* For internal transactions e.g., purge and transactions
460
505
                being recovered at startup there is no associated MySQL
461
506
                thread data structure. */
462
507
                row->trx_mysql_thread_id = 0;
463
 
                row->trx_query = NULL;
464
 
                return(TRUE);
 
508
                row->trx_query = NULL;
 
509
                goto thd_done;
465
510
        }
466
511
 
467
 
        row->trx_mysql_thread_id = session_get_thread_id(trx->mysql_thd);
468
 
        stmt = innobase_get_stmt(trx->mysql_thd, &stmt_len);
 
512
        row->trx_mysql_thread_id = trx->session()->getSessionId();
 
513
        stmt= trx->mysql_thd->getQueryStringCopy(stmt_len);
469
514
 
470
515
        if (stmt != NULL) {
471
516
 
478
523
                memcpy(query, stmt, stmt_len);
479
524
                query[stmt_len] = '\0';
480
525
 
481
 
                row->trx_query = ha_storage_put_memlim(
 
526
                row->trx_query = static_cast<const char *>(ha_storage_put_memlim(
482
527
                        cache->storage, stmt, stmt_len + 1,
483
 
                        MAX_ALLOWED_FOR_STORAGE(cache));
 
528
                        MAX_ALLOWED_FOR_STORAGE(cache)));
484
529
 
485
530
                if (row->trx_query == NULL) {
486
531
 
491
536
                row->trx_query = NULL;
492
537
        }
493
538
 
 
539
thd_done:
 
540
        s = trx->op_info;
 
541
 
 
542
        if (s != NULL && s[0] != '\0') {
 
543
 
 
544
                TRX_I_S_STRING_COPY(s, row->trx_operation_state,
 
545
                                    TRX_I_S_TRX_OP_STATE_MAX_LEN, cache);
 
546
 
 
547
                if (row->trx_operation_state == NULL) {
 
548
 
 
549
                        return(FALSE);
 
550
                }
 
551
        } else {
 
552
 
 
553
                row->trx_operation_state = NULL;
 
554
        }
 
555
 
 
556
//      row->trx_tables_in_use = trx->n_mysql_tables_in_use;
 
557
 
 
558
        row->trx_tables_locked = trx->mysql_n_tables_locked;
 
559
 
 
560
        row->trx_lock_structs = UT_LIST_GET_LEN(trx->trx_locks);
 
561
 
 
562
        row->trx_lock_memory_bytes = mem_heap_get_size(trx->lock_heap);
 
563
 
 
564
        row->trx_rows_locked = lock_number_of_rows_locked(trx);
 
565
 
 
566
        row->trx_rows_modified = trx->undo_no;
 
567
 
 
568
        row->trx_concurrency_tickets = trx->n_tickets_to_enter_innodb;
 
569
 
 
570
        switch (trx->isolation_level) {
 
571
        case TRX_ISO_READ_UNCOMMITTED:
 
572
                row->trx_isolation_level = "READ UNCOMMITTED";
 
573
                break;
 
574
        case TRX_ISO_READ_COMMITTED:
 
575
                row->trx_isolation_level = "READ COMMITTED";
 
576
                break;
 
577
        case TRX_ISO_REPEATABLE_READ:
 
578
                row->trx_isolation_level = "REPEATABLE READ";
 
579
                break;
 
580
        case TRX_ISO_SERIALIZABLE:
 
581
                row->trx_isolation_level = "SERIALIZABLE";
 
582
                break;
 
583
        /* Should not happen as TRX_ISO_READ_COMMITTED is default */
 
584
        default:
 
585
                row->trx_isolation_level = "UNKNOWN";
 
586
        }
 
587
 
 
588
        row->trx_unique_checks = (ibool) trx->check_unique_secondary;
 
589
 
 
590
        row->trx_foreign_key_checks = (ibool) trx->check_foreigns;
 
591
 
 
592
        s = trx->detailed_error;
 
593
 
 
594
        if (s != NULL && s[0] != '\0') {
 
595
 
 
596
                TRX_I_S_STRING_COPY(s,
 
597
                                    row->trx_foreign_key_error,
 
598
                                    TRX_I_S_TRX_FK_ERROR_MAX_LEN, cache);
 
599
 
 
600
                if (row->trx_foreign_key_error == NULL) {
 
601
 
 
602
                        return(FALSE);
 
603
                }
 
604
        } else {
 
605
                row->trx_foreign_key_error = NULL;
 
606
        }
 
607
 
 
608
        row->trx_has_search_latch = (ibool) trx->has_search_latch;
 
609
 
 
610
        row->trx_search_latch_timeout = trx->search_latch_timeout;
 
611
 
494
612
        return(TRUE);
495
613
}
496
614
 
732
850
        row->lock_table_id = lock_get_table_id(lock);
733
851
 
734
852
        row->hash_chain.value = row;
 
853
        ut_ad(i_s_locks_row_validate(row));
735
854
 
736
855
        return(TRUE);
737
856
}
752
871
                                                relevant blocking lock
753
872
                                                row in innodb_locks */
754
873
{
 
874
        ut_ad(i_s_locks_row_validate(requested_lock_row));
 
875
        ut_ad(i_s_locks_row_validate(blocking_lock_row));
 
876
 
755
877
        row->requested_lock_row = requested_lock_row;
756
878
        row->blocking_lock_row = blocking_lock_row;
757
879
 
823
945
                                        or ULINT_UNDEFINED if the lock
824
946
                                        is a table lock */
825
947
{
 
948
        ut_ad(i_s_locks_row_validate(row));
826
949
#ifdef TEST_NO_LOCKS_ROW_IS_EVER_EQUAL_TO_LOCK_T
827
950
        return(0);
828
951
#else
880
1003
                /* auxiliary variable */
881
1004
                hash_chain,
882
1005
                /* assertion on every traversed item */
883
 
                ,
 
1006
                ut_ad(i_s_locks_row_validate(hash_chain->value)),
884
1007
                /* this determines if we have found the lock */
885
1008
                locks_row_eq_lock(hash_chain->value, lock, heap_no));
886
1009
 
920
1043
        dst_row = search_innodb_locks(cache, lock, heap_no);
921
1044
        if (dst_row != NULL) {
922
1045
 
 
1046
                ut_ad(i_s_locks_row_validate(dst_row));
923
1047
                return(dst_row);
924
1048
        }
925
1049
#endif
957
1081
        } /* for()-loop */
958
1082
#endif
959
1083
 
 
1084
        ut_ad(i_s_locks_row_validate(dst_row));
960
1085
        return(dst_row);
961
1086
}
962
1087
 
1254
1379
        release trx_i_s_cache_t::last_read_mutex
1255
1380
        release trx_i_s_cache_t::rw_lock */
1256
1381
 
1257
 
        rw_lock_create(&cache->rw_lock, SYNC_TRX_I_S_RWLOCK);
 
1382
        rw_lock_create(trx_i_s_cache_lock_key, &cache->rw_lock,
 
1383
                       SYNC_TRX_I_S_RWLOCK);
1258
1384
 
1259
1385
        cache->last_read = 0;
1260
1386
 
1261
 
        mutex_create(&cache->last_read_mutex, SYNC_TRX_I_S_LAST_READ);
 
1387
        mutex_create(cache_last_read_mutex_key,
 
1388
                     &cache->last_read_mutex, SYNC_TRX_I_S_LAST_READ);
1262
1389
 
1263
1390
        table_cache_init(&cache->innodb_trx, sizeof(i_s_trx_row_t));
1264
1391
        table_cache_init(&cache->innodb_locks, sizeof(i_s_locks_row_t));
1470
1597
        } else {
1471
1598
                /* table lock */
1472
1599
                res_len = ut_snprintf(lock_id, lock_id_size,
1473
 
                                      TRX_ID_FMT ":%llu",
 
1600
                                      TRX_ID_FMT ":" TRX_ID_FMT,
1474
1601
                                      row->lock_trx_id,
1475
1602
                                      row->lock_table_id);
1476
1603
        }