← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/trx0trx.h

Merge Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/trx0trx.h
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 1996, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1996, 2009, 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
11
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
12
 
13
13
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
16
16
 
17
17
*****************************************************************************/
18
18
 
179
179
/****************************************************************//**
180
180
Cleans up a transaction at database startup. The cleanup is needed if
181
181
the transaction already got to the middle of a commit when the database
182
 
crashed, and we cannot roll it back. */
 
182
crashed, andf we cannot roll it back. */
183
183
UNIV_INTERN
184
184
void
185
185
trx_cleanup_at_db_startup(
338
338
 
339
339
/**********************************************************************//**
340
340
Prints info about a transaction to the given file. The caller must own the
341
 
kernel mutex. */
 
341
kernel mutex and must have called
 
342
innobase_mysql_prepare_print_arbitrary_thd(), unless he knows that MySQL
 
343
or InnoDB cannot meanwhile change the info printed here. */
342
344
UNIV_INTERN
343
345
void
344
346
trx_print(
349
351
                                   use the default max length */
350
352
 
351
353
/** Type of data dictionary operation */
352
 
typedef enum trx_dict_op {
 
354
enum trx_dict_op {
353
355
        /** The transaction is not modifying the data dictionary. */
354
356
        TRX_DICT_OP_NONE = 0,
355
357
        /** The transaction is creating a table or an index, or
361
363
        existing table.  In crash recovery, the the data dictionary
362
364
        must be locked, but the table must not be dropped. */
363
365
        TRX_DICT_OP_INDEX = 2
364
 
} trx_dict_op_t;
 
366
};
365
367
 
366
368
/**********************************************************************//**
367
369
Determine if a transaction is a dictionary operation.
391
393
trx_is_interrupted(
392
394
/*===============*/
393
395
        trx_t*  trx);   /*!< in: transaction */
394
 
/**********************************************************************//**
395
 
Determines if the currently running transaction is in strict mode.
396
 
@return TRUE if strict */
397
 
UNIV_INTERN
398
 
ibool
399
 
trx_is_strict(
400
 
/*==========*/
401
 
        trx_t*  trx);   /*!< in: transaction */
402
396
#else /* !UNIV_HOTBACKUP */
403
397
#define trx_is_interrupted(trx) FALSE
404
398
#endif /* !UNIV_HOTBACKUP */
408
402
is estimated as the number of altered rows + the number of locked rows.
409
403
@param t        transaction
410
404
@return         transaction weight */
411
 
#define TRX_WEIGHT(t)   ((t)->undo_no + UT_LIST_GET_LEN((t)->trx_locks))
 
405
#define TRX_WEIGHT(t)   \
 
406
        ut_dulint_add((t)->undo_no, UT_LIST_GET_LEN((t)->trx_locks))
412
407
 
413
408
/*******************************************************************//**
414
409
Compares the "weight" (or size) of two transactions. Transactions that
415
410
have edited non-transactional tables are considered heavier than ones
416
411
that have not.
417
 
@return TRUE if weight(a) >= weight(b) */
 
412
@return <0, 0 or >0; similar to strcmp(3) */
418
413
UNIV_INTERN
419
 
ibool
420
 
trx_weight_ge(
421
 
/*==========*/
 
414
int
 
415
trx_weight_cmp(
 
416
/*===========*/
422
417
        const trx_t*    a,      /*!< in: the first transaction to be compared */
423
418
        const trx_t*    b);     /*!< in: the second transaction to be compared */
424
419
 
 
420
/*******************************************************************//**
 
421
Retrieves transacion's id, represented as unsigned long long.
 
422
@return transaction's id */
 
423
UNIV_INLINE
 
424
ullint
 
425
trx_get_id(
 
426
/*=======*/
 
427
        const trx_t*    trx);   /*!< in: transaction */
 
428
 
425
429
/* Maximum length of a string that can be returned by
426
430
trx_get_que_state_str(). */
427
431
#define TRX_QUE_STATE_STR_MAX_LEN       12 /* "ROLLING BACK" */
461
465
 
462
466
struct trx_struct{
463
467
        ulint           magic_n;
464
 
 
465
 
        /* These fields are not protected by any mutex. */
 
468
        /* All the next fields are protected by the kernel mutex, except the
 
469
        undo logs which are protected by undo_mutex */
466
470
        const char*     op_info;        /*!< English text describing the
467
471
                                        current operation, or an empty
468
472
                                        string */
469
 
        ulint           conc_state;     /*!< state of the trx from the point
 
473
        unsigned        is_purge:1;     /*!< 0=user transaction, 1=purge */
 
474
        unsigned        is_recovered:1; /*!< 0=normal transaction,
 
475
                                        1=recovered, must be rolled back */
 
476
        unsigned        conc_state:2;   /*!< state of the trx from the point
470
477
                                        of view of concurrency control:
471
478
                                        TRX_ACTIVE, TRX_COMMITTED_IN_MEMORY,
472
479
                                        ... */
473
 
        ulint           isolation_level;/* TRX_ISO_REPEATABLE_READ, ... */
474
 
        ulint           check_foreigns; /* normally TRUE, but if the user
 
480
        unsigned        que_state:2;    /*!< valid when conc_state == TRX_ACTIVE:
 
481
                                        TRX_QUE_RUNNING, TRX_QUE_LOCK_WAIT,
 
482
                                        ... */
 
483
        unsigned        isolation_level:2;/* TRX_ISO_REPEATABLE_READ, ... */
 
484
        unsigned        check_foreigns:1;/* normally TRUE, but if the user
475
485
                                        wants to suppress foreign key checks,
476
486
                                        (in table imports, for example) we
477
487
                                        set this FALSE */
478
 
        unsigned        check_unique_secondary;
 
488
        unsigned        check_unique_secondary:1;
479
489
                                        /* normally TRUE, but if the user
480
490
                                        wants to speed up inserts by
481
491
                                        suppressing unique key checks
482
492
                                        for secondary indexes when we decide
483
493
                                        if we can use the insert buffer for
484
494
                                        them, we set this FALSE */
485
 
        unsigned        support_xa;     /*!< normally we do the XA two-phase
 
495
        unsigned        support_xa:1;   /*!< normally we do the XA two-phase
486
496
                                        commit steps, but by setting this to
487
497
                                        FALSE, one can save CPU time and about
488
498
                                        150 bytes in the undo log size as then
489
499
                                        we skip XA steps */
490
 
        unsigned        flush_log_later;/* In 2PC, we hold the
 
500
        unsigned        flush_log_later:1;/* In 2PC, we hold the
491
501
                                        prepare_commit mutex across
492
502
                                        both phases. In that case, we
493
503
                                        defer flush of the logs to disk
494
504
                                        until after we release the
495
505
                                        mutex. */
496
 
        unsigned        must_flush_log_later;/* this flag is set to TRUE in
 
506
        unsigned        must_flush_log_later:1;/* this flag is set to TRUE in
497
507
                                        trx_commit_off_kernel() if
498
508
                                        flush_log_later was TRUE, and there
499
509
                                        were modifications by the transaction;
500
510
                                        in that case we must flush the log
501
511
                                        in trx_commit_complete_for_mysql() */
502
 
        ulint           duplicates;     /*!< TRX_DUP_IGNORE | TRX_DUP_REPLACE */
503
 
        ulint           active_trans;   /*!< 1 - if a transaction in MySQL
504
 
                                        is active. 2 - if prepare_commit_mutex
505
 
                                        was taken */
506
 
        unsigned        has_search_latch;
 
512
        unsigned        dict_operation:2;/**< @see enum trx_dict_op */
 
513
        unsigned        duplicates:2;   /*!< TRX_DUP_IGNORE | TRX_DUP_REPLACE */
 
514
        unsigned        has_search_latch:1;
507
515
                                        /* TRUE if this trx has latched the
508
516
                                        search system latch in S-mode */
509
 
        ulint           deadlock_mark;  /*!< a mark field used in deadlock
510
 
                                        checking algorithm.  */
511
 
        trx_dict_op_t   dict_operation; /**< @see enum trx_dict_op */
512
 
 
513
 
        /* Fields protected by the srv_conc_mutex. */
514
 
        ulint           declared_to_be_inside_innodb;
 
517
        unsigned        declared_to_be_inside_innodb:1;
515
518
                                        /* this is TRUE if we have declared
516
519
                                        this transaction in
517
520
                                        srv_conc_enter_innodb to be inside the
518
521
                                        InnoDB engine */
519
 
 
520
 
        /* Fields protected by dict_operation_lock. The very latch
521
 
        it is used to track. */
522
 
        ulint           dict_operation_lock_mode;
523
 
                                        /*!< 0, RW_S_LATCH, or RW_X_LATCH:
 
522
        unsigned        handling_signals:1;/* this is TRUE as long as the trx
 
523
                                        is handling signals */
 
524
        unsigned        dict_operation_lock_mode:2;
 
525
                                        /* 0, RW_S_LATCH, or RW_X_LATCH:
524
526
                                        the latch mode trx currently holds
525
527
                                        on dict_operation_lock */
526
 
 
527
 
        /* All the next fields are protected by the kernel mutex, except the
528
 
        undo logs which are protected by undo_mutex */
529
 
        ulint           is_purge;       /*!< 0=user transaction, 1=purge */
530
 
        ulint           is_recovered;   /*!< 0=normal transaction,
531
 
                                        1=recovered, must be rolled back */
532
 
        ulint           que_state;      /*!< valid when conc_state
533
 
                                        == TRX_ACTIVE: TRX_QUE_RUNNING,
534
 
                                        TRX_QUE_LOCK_WAIT, ... */
535
 
        ulint           handling_signals;/* this is TRUE as long as the trx
536
 
                                        is handling signals */
537
528
        time_t          start_time;     /*!< time the trx object was created
538
529
                                        or the state last time became
539
530
                                        TRX_ACTIVE */
545
536
                                        max trx id when the transaction is
546
537
                                        moved to COMMITTED_IN_MEMORY state */
547
538
        ib_uint64_t     commit_lsn;     /*!< lsn at the time of the commit */
548
 
        table_id_t      table_id;       /*!< Table to drop iff dict_operation
549
 
                                        is TRUE, or 0. */
 
539
        trx_id_t        table_id;       /*!< Table to drop iff dict_operation
 
540
                                        is TRUE, or ut_dulint_zero. */
550
541
        /*------------------------------*/
551
542
        void*           mysql_thd;      /*!< MySQL thread handle corresponding
552
543
                                        to this trx, or NULL */
 
544
        const char*     mysql_query_str;/* pointer to the field in mysqld_thd
 
545
                                        which contains the pointer to the
 
546
                                        current SQL query string */
553
547
        const char*     mysql_log_file_name;
554
548
                                        /* if MySQL binlog is used, this field
555
549
                                        contains a pointer to the latest file
641
635
                        wait_thrs;      /*!< query threads belonging to this
642
636
                                        trx that are in the QUE_THR_LOCK_WAIT
643
637
                                        state */
 
638
        ulint           deadlock_mark;  /*!< a mark field used in deadlock
 
639
                                        checking algorithm.  This must be
 
640
                                        in its own machine word, because
 
641
                                        it can be changed by other
 
642
                                        threads while holding kernel_mutex. */
644
643
        /*------------------------------*/
645
644
        mem_heap_t*     lock_heap;      /*!< memory heap for the locks of the
646
645
                                        transaction */