row0undo.h

Go to the documentation of this file.

/*****************************************************************************

Copyright (c) 1997, 2009, Oracle and/or its affiliates. All Rights Reserved.

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA

*****************************************************************************/

/**************************************************/
#ifndef row0undo_h
#define row0undo_h

#include "univ.i"
#include "mtr0mtr.h"
#include "trx0sys.h"
#include "btr0types.h"
#include "btr0pcur.h"
#include "dict0types.h"
#include "trx0types.h"
#include "que0types.h"
#include "row0types.h"

/********************************************************************/
UNIV_INTERN
undo_node_t*
row_undo_node_create(
/*=================*/
        trx_t*          trx,    
        que_thr_t*      parent, 
        mem_heap_t*     heap);  
/***********************************************************/
UNIV_INTERN
ibool
row_undo_search_clust_to_pcur(
/*==========================*/
        undo_node_t*    node);  
/***********************************************************/
UNIV_INTERN
que_thr_t*
row_undo_step(
/*==========*/
        que_thr_t*      thr);   
/* A single query thread will try to perform the undo for all successive
versions of a clustered index record, if the transaction has modified it
several times during the execution which is rolled back. It may happen
that the task is transferred to another query thread, if the other thread
is assigned to handle an undo log record in the chain of different versions
of the record, and the other thread happens to get the x-latch to the
clustered index record at the right time.
        If a query thread notices that the clustered index record it is looking
for is missing, or the roll ptr field in the record doed not point to the
undo log record the thread was assigned to handle, then it gives up the undo
task for that undo log record, and fetches the next. This situation can occur
just in the case where the transaction modified the same record several times
and another thread is currently doing the undo for successive versions of
that index record. */

enum undo_exec {
        UNDO_NODE_FETCH_NEXT = 1,       
        UNDO_NODE_INSERT,               
        UNDO_NODE_MODIFY                
};

struct undo_node_t{
        que_common_t    common; 
        enum undo_exec  state;  
        trx_t*          trx;    
        roll_ptr_t      roll_ptr;
        trx_undo_rec_t* undo_rec;
        undo_no_t       undo_no;
        ulint           rec_type;
        trx_id_t        new_trx_id; 
        btr_pcur_t      pcur;   
        dict_table_t*   table;  
        ulint           cmpl_info;
        upd_t*          update; 
        dtuple_t*       ref;    
        dtuple_t*       row;    
        row_ext_t*      ext;    
        dtuple_t*       undo_row;
        row_ext_t*      undo_ext;
        dict_index_t*   index;  
        mem_heap_t*     heap;   
};


#ifndef UNIV_NONINL
#include "row0undo.ic"
#endif

#endif