← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-09-22 22:25:29 UTC
  • mto: (1791.1.1 drizzle)
  • mto: This revision was merged to the branch mainline in revision 1792.
  • Revision ID: brian@tangent.org-20100922222529-geo4wggmu5ntqa5k
Current boost work (more conversion).

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
 
38
38
#include "trx0xa.h"
39
39
#include "ut0vec.h"
40
40
 
41
 
namespace drizzled { class Session; }
42
 
 
43
41
/** Dummy session used currently in MySQL interface */
44
42
extern sess_t*  trx_dummy_sess;
45
43
 
72
70
        trx_t*  trx,    /*!< in: transaction struct */
73
71
        FILE*   file);  /*!< in: file to read message from */
74
72
/****************************************************************//**
75
 
Checks if the commit id should be logged to the sys header file
76
 
@return TRUE if the commit id should be logged */ 
77
 
UNIV_INLINE
78
 
ibool
79
 
trx_log_commit_id(
80
 
/*==============*/
81
 
        const trx_t*    trx);   /*!< in: trx object */
82
 
/****************************************************************//**
83
73
Retrieves the error_info field from a trx.
84
74
@return the error info */
85
75
UNIV_INLINE
189
179
/****************************************************************//**
190
180
Cleans up a transaction at database startup. The cleanup is needed if
191
181
the transaction already got to the middle of a commit when the database
192
 
crashed, and we cannot roll it back. */
 
182
crashed, andf we cannot roll it back. */
193
183
UNIV_INTERN
194
184
void
195
185
trx_cleanup_at_db_startup(
348
338
 
349
339
/**********************************************************************//**
350
340
Prints info about a transaction to the given file. The caller must own the
351
 
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. */
352
344
UNIV_INTERN
353
345
void
354
346
trx_print(
359
351
                                   use the default max length */
360
352
 
361
353
/** Type of data dictionary operation */
362
 
typedef enum trx_dict_op {
 
354
enum trx_dict_op {
363
355
        /** The transaction is not modifying the data dictionary. */
364
356
        TRX_DICT_OP_NONE = 0,
365
357
        /** The transaction is creating a table or an index, or
371
363
        existing table.  In crash recovery, the the data dictionary
372
364
        must be locked, but the table must not be dropped. */
373
365
        TRX_DICT_OP_INDEX = 2
374
 
} trx_dict_op_t;
 
366
};
375
367
 
376
368
/**********************************************************************//**
377
369
Determine if a transaction is a dictionary operation.
401
393
trx_is_interrupted(
402
394
/*===============*/
403
395
        trx_t*  trx);   /*!< in: transaction */
404
 
/**********************************************************************//**
405
 
Determines if the currently running transaction is in strict mode.
406
 
@return TRUE if strict */
407
 
UNIV_INTERN
408
 
ibool
409
 
trx_is_strict(
410
 
/*==========*/
411
 
        trx_t*  trx);   /*!< in: transaction */
412
396
#else /* !UNIV_HOTBACKUP */
413
397
#define trx_is_interrupted(trx) FALSE
414
398
#endif /* !UNIV_HOTBACKUP */
418
402
is estimated as the number of altered rows + the number of locked rows.
419
403
@param t        transaction
420
404
@return         transaction weight */
421
 
#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))
422
407
 
423
408
/*******************************************************************//**
424
409
Compares the "weight" (or size) of two transactions. Transactions that
425
410
have edited non-transactional tables are considered heavier than ones
426
411
that have not.
427
 
@return TRUE if weight(a) >= weight(b) */
 
412
@return <0, 0 or >0; similar to strcmp(3) */
428
413
UNIV_INTERN
429
 
ibool
430
 
trx_weight_ge(
431
 
/*==========*/
 
414
int
 
415
trx_weight_cmp(
 
416
/*===========*/
432
417
        const trx_t*    a,      /*!< in: the first transaction to be compared */
433
418
        const trx_t*    b);     /*!< in: the second transaction to be compared */
434
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
 
435
429
/* Maximum length of a string that can be returned by
436
430
trx_get_que_state_str(). */
437
431
#define TRX_QUE_STATE_STR_MAX_LEN       12 /* "ROLLING BACK" */
471
465
 
472
466
struct trx_struct{
473
467
        ulint           magic_n;
474
 
 
475
 
        /* 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 */
476
470
        const char*     op_info;        /*!< English text describing the
477
471
                                        current operation, or an empty
478
472
                                        string */
479
 
        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
480
477
                                        of view of concurrency control:
481
478
                                        TRX_ACTIVE, TRX_COMMITTED_IN_MEMORY,
482
479
                                        ... */
483
 
        ulint           isolation_level;/* TRX_ISO_REPEATABLE_READ, ... */
484
 
        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
485
485
                                        wants to suppress foreign key checks,
486
486
                                        (in table imports, for example) we
487
487
                                        set this FALSE */
488
 
        unsigned        check_unique_secondary;
 
488
        unsigned        check_unique_secondary:1;
489
489
                                        /* normally TRUE, but if the user
490
490
                                        wants to speed up inserts by
491
491
                                        suppressing unique key checks
492
492
                                        for secondary indexes when we decide
493
493
                                        if we can use the insert buffer for
494
494
                                        them, we set this FALSE */
495
 
        unsigned        support_xa;     /*!< normally we do the XA two-phase
 
495
        unsigned        support_xa:1;   /*!< normally we do the XA two-phase
496
496
                                        commit steps, but by setting this to
497
497
                                        FALSE, one can save CPU time and about
498
498
                                        150 bytes in the undo log size as then
499
499
                                        we skip XA steps */
500
 
        unsigned        flush_log_later;/* In 2PC, we hold the
 
500
        unsigned        flush_log_later:1;/* In 2PC, we hold the
501
501
                                        prepare_commit mutex across
502
502
                                        both phases. In that case, we
503
503
                                        defer flush of the logs to disk
504
504
                                        until after we release the
505
505
                                        mutex. */
506
 
        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
507
507
                                        trx_commit_off_kernel() if
508
508
                                        flush_log_later was TRUE, and there
509
509
                                        were modifications by the transaction;
510
510
                                        in that case we must flush the log
511
511
                                        in trx_commit_complete_for_mysql() */
512
 
        ulint           duplicates;     /*!< TRX_DUP_IGNORE | TRX_DUP_REPLACE */
513
 
        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;
514
515
                                        /* TRUE if this trx has latched the
515
516
                                        search system latch in S-mode */
516
 
        ulint           deadlock_mark;  /*!< a mark field used in deadlock
517
 
                                        checking algorithm.  */
518
 
        trx_dict_op_t   dict_operation; /**< @see enum trx_dict_op */
519
 
 
520
 
        /* Fields protected by the srv_conc_mutex. */
521
 
        ulint           declared_to_be_inside_innodb;
 
517
        unsigned        declared_to_be_inside_innodb:1;
522
518
                                        /* this is TRUE if we have declared
523
519
                                        this transaction in
524
520
                                        srv_conc_enter_innodb to be inside the
525
521
                                        InnoDB engine */
526
 
 
527
 
        /* Fields protected by dict_operation_lock. The very latch
528
 
        it is used to track. */
529
 
        ulint           dict_operation_lock_mode;
530
 
                                        /*!< 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:
531
526
                                        the latch mode trx currently holds
532
527
                                        on dict_operation_lock */
533
 
 
534
 
        /* All the next fields are protected by the kernel mutex, except the
535
 
        undo logs which are protected by undo_mutex */
536
 
        ulint           is_purge;       /*!< 0=user transaction, 1=purge */
537
 
        ulint           is_recovered;   /*!< 0=normal transaction,
538
 
                                        1=recovered, must be rolled back */
539
 
        ulint           que_state;      /*!< valid when conc_state
540
 
                                        == TRX_ACTIVE: TRX_QUE_RUNNING,
541
 
                                        TRX_QUE_LOCK_WAIT, ... */
542
 
        ulint           handling_signals;/* this is TRUE as long as the trx
543
 
                                        is handling signals */
544
528
        time_t          start_time;     /*!< time the trx object was created
545
529
                                        or the state last time became
546
530
                                        TRX_ACTIVE */
552
536
                                        max trx id when the transaction is
553
537
                                        moved to COMMITTED_IN_MEMORY state */
554
538
        ib_uint64_t     commit_lsn;     /*!< lsn at the time of the commit */
555
 
        table_id_t      table_id;       /*!< Table to drop iff dict_operation
556
 
                                        is TRUE, or 0. */
 
539
        trx_id_t        table_id;       /*!< Table to drop iff dict_operation
 
540
                                        is TRUE, or ut_dulint_zero. */
557
541
        /*------------------------------*/
558
 
        drizzled::Session *mysql_thd;   /*!< MySQL thread handle corresponding
 
542
        void*           mysql_thd;      /*!< MySQL thread handle corresponding
559
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 */
560
547
        const char*     mysql_log_file_name;
561
548
                                        /* if MySQL binlog is used, this field
562
549
                                        contains a pointer to the latest file
648
635
                        wait_thrs;      /*!< query threads belonging to this
649
636
                                        trx that are in the QUE_THR_LOCK_WAIT
650
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. */
651
643
        /*------------------------------*/
652
644
        mem_heap_t*     lock_heap;      /*!< memory heap for the locks of the
653
645
                                        transaction */
715
707
        /*------------------------------*/
716
708
        char detailed_error[256];       /*!< detailed error message for last
717
709
                                        error, or empty. */
718
 
 
719
 
        ibool           log_commit_id;  /*!< log the commit id to the sys
720
 
                                        file */
721
 
        inline drizzled::Session *session()
722
 
        {
723
 
          return mysql_thd;
724
 
        }
725
 
        inline drizzled::Session *session() const
726
 
        {
727
 
          return mysql_thd;
728
 
        }
729
710
};
730
711
 
731
712
#define TRX_MAX_N_THREADS       32      /* maximum number of